Con arreglo["texto"] estás accediendo a la propiedad(variable) texto de un objeto arreglo. Es decir, cualquiera de las múltiples formas que te permitan definir o modificar las propuedades o el objeto te sirven.

var arreglo = {};
arreglo.texto = 7;

var arreglo = {};
arreglo["texto"] = 7;

var a = "texto";
var arreglo = {};
arreglo[a] = 7;

var arreglo = {
  texto: 7
};

Obviamente arreglo no es un arreglo como tal. javascript no tiene soporte nativo a arrays multidimensionales, pero si puedes crear arrays de arrays:

var arreglo = [
  ["texto", 7]
];

También tienes un montón de formas distintas de acceder a propiedades, valores, objetos, arrays... Varios for, .keys .entries... Etc.

Que yo sepa, en JS también puedes tener un array con índices no numericos:



Eso sí, en el fondo los Arrays en javascript son objetos. En el caso original creo que podría hacer

const arreglo = { texto: 7};
console.log(arreglo['texto'])

Y por favor, estamos en 2020. DEJA DE USAR VAR PARA DECLARAR VARIABLES. Lo de ahora es const o let. Usando Var puedes tener problema con los "scopes", porque declara variables con un alcance de función, mientras que let/var declaran un alcance de bloque. Algo así.

Lo más similar a un arreglo asociativo de php en JS es un mapa. Si quieres imitar el comportamiento de inicialización de PHP lo podrías hacer con una función.

let patm = arr => new Map(arr.map((el, i) => Array.isArray(el) ? el : [i, el]));

let m = patm([
    'lorem',
    'ipsum',
    ['text', 7]
]);

Para iterar:

m.forEach((el, k) => console.log(el, k));
// 0 'lorem', 1 'ipsum', 'text' 7

También conservas las propiedades que menciona #!drvy

console.log(m.size) //3
console.log([...m.values()]) // ['lorem', 'ipsum', 7]

Lo que no vas a poder hacer es acceder a las propiedades ni siquiera con notación de corchetes.

m[0] = 'test'; //escribe 'test' en la propiedad 0 del objeto del mapa, pero los elementos 
               //del objeto no son parte del objeto del mapa. 
m[1];          //La propiedad 1 del objeto del mapa no es el elemento del mapa al que corresponde la llave 1
m['text'];     //Lo mismo de arriba.

Si quieres cambiar esos elementos tienes que usar Map.prototype.get y Map.prototype.set:

m.set(0, 'nuevo valor');
console.log(m.get(0)); //'nuevo valor'

Podrías emular ese comportamiento con un Proxy, pero yo no lo haría. Perderías la posibilidad de tener llaves como forEach, size, values, entries, etc. Sin mencionar que los Proxies son mucho más lentos.

Por otro lado, puedes optar simplemente por un objeto normal:

let obj = {
    0 : 'lorem',
    1 : 'ipsum',
    'text' : 7
};

Y también puedes iterar esas propiedades con Object.values, Object.entries y Object.keys. Pero ojo, a diferencia de PHP y los mapas el orden no está exactamente "garantizado" y no es por orden de inserción. Hasta donde tengo entendido, la especificación no había aclarado un orden al cual todas las implementaciones pudieran llegar de una manera determinista hasta hace poco. Generalmente, las implementaciones se comportan de manera muy similar (al menos en sus últimas versiones).

También puede ser un arreglo:

let a = ['lorem', 'ipsum'];
a['text'] = 7;
 
console.log(Object.values(a));

Pero ya esto a mi me sabe muy mal.

En mi opinión me quedaba con los mapas de javascript.

Si por lo mismo te refieres a que el alcance sigue siendo local a la función y no al bucle entonces eso es correcto. Las variables definidas con var no tienen ningún alcance localizado a ninguna estructura de control.


let y const sirven para mucho más... No tiene sentido declarar variables dentro de una estructura de control con var, las podrías poner todas al tope de tu función y no habría ninguna diferencia. Técnicamente, una IIFE con nombre es realmente una IINFE (Immediately Invoked Named Function Expression) y el nombre es local a la función y no es visible desde el contexto en el la expresión fue creada.

(function named() {
   console.log(named); //la funcion
})();
 
console.log(window.named == undefined) //true
console.log(named); //ReferenceError