Tengo un modelo con posiblemente miles de objetos. Me preguntaba cuál sería la forma más eficiente de almacenarlos y recuperar un solo objeto una vez que tenga su identificación. Las identificaciones son números largos.

Estas son las 2 opciones en las que estaba pensando. en la opción uno es una matriz simple con un índice incremental. en la opción 2 es una matriz asociativa y tal vez un objeto, si hace la diferencia. Mi pregunta es cuál es más eficiente, cuando en su mayoría necesito recuperar un solo objeto, pero también a veces recorrerlo y ordenarlo.

Opción uno con matriz no asociativa:

var a = [{id: 29938, name: 'name1'},
         {id: 32994, name: 'name1'}];
function getObject(id) {
    for (var i=0; i < a.length; i++) {
        if (a[i].id == id) 
            return a[i];
    }
}

Opción dos con matriz asociativa:

var a = [];  // maybe {} makes a difference?
a[29938] = {id: 29938, name: 'name1'};
a[32994] = {id: 32994, name: 'name1'};
function getObject(id) {
    return a[id];
}

Actualizar:

OK, entiendo que usar una matriz en la segunda opción está fuera de discusión. Entonces, la línea de declaración, la segunda opción realmente debería ser: var a = {};y la única pregunta es: qué está funcionando mejor al recuperar un objeto con una identificación dada: una matriz o un objeto donde la identificación es la clave.

y también, ¿cambiará la respuesta si tendré que ordenar la lista muchas veces?

La versión corta: las matrices son en su mayoría más rápidas que los objetos. Pero no hay una solución 100% correcta.

Actualización 2017 - Prueba y resultados

var a1 = [{id: 29938, name: 'name1'}, {id: 32994, name: 'name1'}];

var a2 = [];
a2[29938] = {id: 29938, name: 'name1'};
a2[32994] = {id: 32994, name: 'name1'};

var o = {};
o['29938'] = {id: 29938, name: 'name1'};
o['32994'] = {id: 32994, name: 'name1'};

for (var f = 0; f < 2000; f++) {
    var newNo = Math.floor(Math.random()*60000+10000);
    if (!o[newNo.toString()]) o[newNo.toString()] = {id: newNo, name: 'test'};
    if (!a2[newNo]) a2[newNo] = {id: newNo, name: 'test' };
    a1.push({id: newNo, name: 'test'});
}

Publicación original - Explicación

Hay algunas ideas falsas en su pregunta.

No hay matrices asociativas en Javascript. Solo matrices y objetos.

Estas son matrices:

var a1 = [1, 2, 3];
var a2 = ["a", "b", "c"];
var a3 = [];
a3[0] = "a";
a3[1] = "b";
a3[2] = "c";

Esta también es una matriz:

var a3 = [];
a3[29938] = "a";
a3[32994] = "b";

Básicamente es una matriz con agujeros, porque cada matriz tiene una indexación continua. Es más lento que las matrices sin agujeros. Pero iterar manualmente a través de la matriz es aún más lento (principalmente).

Este es un objeto:

var a3 = {};
a3[29938] = "a";
a3[32994] = "b";

Aquí hay una prueba de rendimiento de tres posibilidades:

Lookup Array vs Holey Array vs Object Performance Test

Una excelente lectura sobre estos temas en Smashing Magazine: escribir JavaScript eficiente en memoria rápida

En realidad, no es una pregunta de rendimiento, ya que las matrices y los objetos funcionan de manera muy diferente (o se supone que lo hacen, al menos). Las matrices tienen un índice continuo 0..n, mientras que los objetos asignan claves arbitrarias a valores arbitrarios. Si se desea proporcionar claves específicas, la única opción es un objeto. Si no te importan las claves, es una matriz.

Si intenta establecer claves arbitrarias (numéricas) en una matriz, realmente tiene una pérdida de rendimiento , ya que, en términos de comportamiento, la matriz completará todos los índices intermedios:

> foo = [];
  []
> foo[100] = 'a';
  "a"
> foo
  [undefined, undefined, undefined, ..., "a"]

_{(Tenga en cuenta que la matriz en realidad no contiene 99 undefinedvalores, pero se comportará de esta manera ya que [se supone que] está iterando la matriz en algún momento).}

Los literales para ambas opciones deben dejar muy claro cómo se pueden usar:

var arr = ['foo', 'bar', 'baz'];     // no keys, not even the option for it
var obj = { foo : 'bar', baz : 42 }; // associative by its very nature

Con ES6, la forma más eficaz sería utilizar un mapa.

var myMap = new Map();

myMap.set(1, 'myVal');
myMap.set(2, { catName: 'Meow', age: 3 });

myMap.get(1);
myMap.get(2);

Puede usar las funciones de ES6 hoy usando una cuña ( https://github.com/es-shims/es6-shim ).

El rendimiento variará según el navegador y el escenario. Pero aquí hay un ejemplo donde Mapes más eficiente: https://jsperf.com/es6-map-vs-object-properties/2

REFERENCIA https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Map

En NodeJS si conoce el ID, el bucle a través de la matriz es muy lento en comparación con object[ID].

const uniqueString = require('unique-string');
const obj = {};
const arr = [];
var seeking;

//create data
for(var i=0;i<1000000;i++){
  var getUnique = `${uniqueString()}`;
  if(i===888555) seeking = getUnique;
  arr.push(getUnique);
  obj[getUnique] = true;
}

//retrieve item from array
console.time('arrTimer');
for(var x=0;x<arr.length;x++){
  if(arr[x]===seeking){
    console.log('Array result:');
    console.timeEnd('arrTimer');
    break;
  }
}

//retrieve item from object
console.time('objTimer');
var hasKey = !!obj[seeking];
console.log('Object result:');
console.timeEnd('objTimer');

Y los resultados:

Array result:
arrTimer: 12.857ms
Object result:
objTimer: 0.051ms

Incluso si la ID de búsqueda es la primera en la matriz / objeto:

Array result:
arrTimer: 2.975ms
Object result:
objTimer: 0.068ms

Traté de llevar esto a la siguiente dimensión, literalmente.

Dada una matriz bidimensional, en la que los ejes xey son siempre de la misma longitud, ¿es más rápido:

a) busque la celda creando una matriz bidimensional y buscando el primer índice, seguido del segundo índice, es decir:

var arr=[][]    
var cell=[x][y]    

o

b) cree un objeto con una representación de cadena de las coordenadas xey, y luego haga una sola búsqueda en ese obj, es decir:

var obj={}    
var cell = obj['x,y']    

Resultado:
Resulta que es mucho más rápido hacer dos búsquedas de índice numérico en las matrices, que una búsqueda de propiedad en el objeto.

Resultados aquí:

http://jsperf.com/arr-vs-obj-lookup-2

Depende del uso. Si el caso es buscar objetos es muy rápido.

Aquí hay un ejemplo de Plunker para probar el rendimiento de la búsqueda de matrices y objetos.

https://plnkr.co/edit/n2expPWVmsdR3zmXvX4C?p=preview

Verás eso; Mirando hacia arriba para 5.000 artículos en la colección de matriz de longitud 5.000 , tome el control de 3000miliseconos

Sin embargo , la búsqueda de 5.000 elementos en el objeto tiene 5.000 propiedades, take only 2o 3milisecons

También hacer que el árbol de objetos no haga una gran diferencia

Tuve un problema similar al que tengo que enfrentar cuando necesito almacenar velas en vivo de una fuente de eventos limitada a x elementos. Podría tenerlos almacenados en un objeto donde la marca de tiempo de cada vela actuaría como la clave y la vela misma actuaría como el valor. Otra posibilidad era que pudiera almacenarlo en una matriz donde cada elemento era la vela misma. Un problema con las velas en vivo es que siguen enviando actualizaciones en la misma marca de tiempo donde la última actualización contiene los datos más recientes, por lo tanto, actualiza un elemento existente o agrega uno nuevo. Así que aquí hay un buen punto de referencia que intenta combinar las 3 posibilidades. Las matrices en la solución a continuación son al menos 4 veces más rápidas en promedio. Siéntete libre de jugar

"use strict";

const EventEmitter = require("events");
let candleEmitter = new EventEmitter();

//Change this to set how fast the setInterval should run
const frequency = 1;

setInterval(() => {
    // Take the current timestamp and round it down to the nearest second
    let time = Math.floor(Date.now() / 1000) * 1000;
    let open = Math.random();
    let high = Math.random();
    let low = Math.random();
    let close = Math.random();
    let baseVolume = Math.random();
    let quoteVolume = Math.random();

    //Clear the console everytime before printing fresh values
    console.clear()

    candleEmitter.emit("candle", {
        symbol: "ABC:DEF",
        time: time,
        open: open,
        high: high,
        low: low,
        close: close,
        baseVolume: baseVolume,
        quoteVolume: quoteVolume
    });



}, frequency)

// Test 1 would involve storing the candle in an object
candleEmitter.on('candle', storeAsObject)

// Test 2 would involve storing the candle in an array
candleEmitter.on('candle', storeAsArray)

//Container for the object version of candles
let objectOhlc = {}

//Container for the array version of candles
let arrayOhlc = {}

//Store a max 30 candles and delete older ones
let limit = 30

function storeAsObject(candle) {

    //measure the start time in nanoseconds
    const hrtime1 = process.hrtime()
    const start = hrtime1[0] * 1e9 + hrtime1[1]

    const { symbol, time } = candle;

    // Create the object structure to store the current symbol
    if (typeof objectOhlc[symbol] === 'undefined') objectOhlc[symbol] = {}

    // The timestamp of the latest candle is used as key with the pair to store this symbol
    objectOhlc[symbol][time] = candle;

    // Remove entries if we exceed the limit
    const keys = Object.keys(objectOhlc[symbol]);
    if (keys.length > limit) {
        for (let i = 0; i < (keys.length - limit); i++) {
            delete objectOhlc[symbol][keys[i]];
        }
    }

    //measure the end time in nano seocnds
    const hrtime2 = process.hrtime()
    const end = hrtime2[0] * 1e9 + hrtime2[1]

    console.log("Storing as objects", end - start, Object.keys(objectOhlc[symbol]).length)
}

function storeAsArray(candle) {

    //measure the start time in nanoseconds
    const hrtime1 = process.hrtime()
    const start = hrtime1[0] * 1e9 + hrtime1[1]

    const { symbol, time } = candle;
    if (typeof arrayOhlc[symbol] === 'undefined') arrayOhlc[symbol] = []

    //Get the bunch of candles currently stored
    const candles = arrayOhlc[symbol];

    //Get the last candle if available
    const lastCandle = candles[candles.length - 1] || {};

    // Add a new entry for the newly arrived candle if it has a different timestamp from the latest one we storeds
    if (time !== lastCandle.time) {
        candles.push(candle);
    }

    //If our newly arrived candle has the same timestamp as the last stored candle, update the last stored candle
    else {
        candles[candles.length - 1] = candle
    }

    if (candles.length > limit) {
        candles.splice(0, candles.length - limit);
    }

    //measure the end time in nano seocnds
    const hrtime2 = process.hrtime()
    const end = hrtime2[0] * 1e9 + hrtime2[1]


    console.log("Storing as array", end - start, arrayOhlc[symbol].length)
}

La conclusión 10 es el límite aquí

Storing as objects 4183 nanoseconds 10
Storing as array 373 nanoseconds 10

Si tiene una matriz ordenada, puede hacer una búsqueda binaria y eso es mucho más rápido que una búsqueda de objetos, puede ver mi respuesta aquí:
Cómo buscar más rápido en una matriz ordenada usando Javascript