qual è la struttura interna dei dati javascript?

2

Considera un oggetto js di base:

var obj={x:1,y:'2'};

È memorizzato internamente come una tabella hash o js utilizza un meccanismo diverso per coppie di valori chiave? Se sono tabelle hash qualcuno sa come gestiscono le collisioni?

    
posta gloo 20.04.2014 - 20:32
fonte

3 risposte

1

"javascript internal" in realtà non significa nulla, per quanto ne so, tale cosa non è specificata per Javascript.

Per alcuni Javascript engine o interpreter , la rappresentazione interna può essere un numero qualsiasi di cose, qualunque cosa funzioni per qualsiasi situazione specifica.

Per oggetti a vita lunga di durata indeterminata, è molto probabilmente una tabella hash, ma anche una lista (o qualsiasi altra cosa) di nomi di proprietà in ordine naturale ("alfabetico") probabilmente esiste almeno temporaneamente.

Gli array, per quanto esistano in Javascript, probabilmente dispongono anche di una struttura dati interna ottimizzata e personalizzata, che può supportare un accesso indicizzato più veloce rispetto alla creazione di un hash della tabella hash.

E quindi un motore JS che fa JIT potrebbe vedere ad esempio che l'oggetto non è mai usato per niente, nel qual caso quell'oggetto può essere nothing internamente, l'istanza è semplicemente ottimizzata e mai creata .

    
risposta data 20.04.2014 - 20:53
fonte
2

Dipende dall'implementazione.

Da v8 / src / objects.h (Chrome's V8):

// Inheritance hierarchy:
// - MaybeObject    (an object or a failure)
//   - Failure      (immediate for marking failed operation)
//   - Object
//     - Smi          (immediate small integer)
//     - HeapObject   (superclass for everything allocated in the heap)
//       - JSReceiver  (suitable for property access)
//         - JSObject
//           - JSArray
//           - JSArrayBuffer
//           - JSArrayBufferView
//             - JSTypedArray
//             - JSDataView
//           - JSSet
//           - JSMap
//           - JSSetIterator
//           - JSMapIterator
//           - JSWeakCollection
//             - JSWeakMap
//             - JSWeakSet
//           - JSRegExp
//           - JSFunction
//           - JSGeneratorObject
//           - JSModule
//           - GlobalObject
//             - JSGlobalObject
//             - JSBuiltinsObject
//           - JSGlobalProxy
//           - JSValue
//             - JSDate
//           - JSMessageObject
//         - JSProxy
//           - JSFunctionProxy
//       - FixedArrayBase
//         - ByteArray
//         - FixedArray
//           - DescriptorArray
//           - HashTable
//             - Dictionary
//             - StringTable
//             - CompilationCacheTable
//             - CodeCacheHashTable
//             - MapCache
//           - OrderedHashTable
//             - OrderedHashSet
//             - OrderedHashMap
//           - Context
//           - JSFunctionResultCache
//           - ScopeInfo
//           - TransitionArray
//         - FixedDoubleArray
//         - ExternalArray
//           - ExternalUint8ClampedArray
//           - ExternalInt8Array
//           - ExternalUint8Array
//           - ExternalInt16Array
//           - ExternalUint16Array
//           - ExternalInt32Array
//           - ExternalUint32Array
//           - ExternalFloat32Array
//       - Name
//         - String
//           - SeqString
//             - SeqOneByteString
//             - SeqTwoByteString
//           - SlicedString
//           - ConsString
//           - ExternalString
//             - ExternalAsciiString
//             - ExternalTwoByteString
//           - InternalizedString
//             - SeqInternalizedString
//               - SeqOneByteInternalizedString
//               - SeqTwoByteInternalizedString
//             - ConsInternalizedString
//             - ExternalInternalizedString
//               - ExternalAsciiInternalizedString
//               - ExternalTwoByteInternalizedString
//         - Symbol
//       - HeapNumber
//       - Cell
//         - PropertyCell
//       - Code
//       - Map
//       - Oddball
//       - Foreign
//       - SharedFunctionInfo
//       - Struct
//         - Box
//         - DeclaredAccessorDescriptor
//         - AccessorInfo
//           - DeclaredAccessorInfo
//           - ExecutableAccessorInfo
//         - AccessorPair
//         - AccessCheckInfo
//         - InterceptorInfo
//         - CallHandlerInfo
//         - TemplateInfo
//           - FunctionTemplateInfo
//           - ObjectTemplateInfo
//         - Script
//         - SignatureInfo
//         - TypeSwitchInfo
//         - DebugInfo
//         - BreakPointInfo
//         - CodeCache
//
// Formats of Object*:
//  Smi:        [31 bit signed int] 0
//  HeapObject: [32 bit direct pointer] (4 byte aligned) | 01
//  Failure:    [30 bit signed int] 11

Non posso dirlo con certezza, ma immagino che sia un JSMap considerando che JSReceiver è "adatto per l'accesso alla proprietà".

Da mozjs-24.2.0 / js / src / jsobj.h (Firefox's SpiderMonkey):

/*
 * JS object definitions.
 *
 * A JS object consists of a possibly-shared object descriptor containing
 * ordered property names, called the map; and a dense vector of property
 * values, called slots.  The map/slot pointer pair is GC'ed, while the map
 * is reference counted and the slot vector is malloc'ed.
 */

Sembra di nuovo una mappa.

Se sei davvero curioso, potresti voler controllare tu stesso la fonte.

    
risposta data 21.04.2014 - 13:01
fonte
0

Le specifiche ECMAScript non prescrivono alcuna particolare strategia di implementazione. E perché dovrebbe? Avere motori diversi competere per le prestazioni utilizzando diverse strategie di implementazione è una buona cosa ™.

    
risposta data 20.04.2014 - 22:41
fonte

Leggi altre domande sui tag