javascript - tag - title of page html

¿Hay diccionarios en javascript como python?

Question

Necesito hacer un diccionario en javascript como este

No recuerdo la notación exacta, pero fue algo así como:

states_dictionary={ CT=[alex,harry], AK=[liza,alex], TX=[fred, harry] ........ }

¿Hay algo así en javascript?

Answer 1

Esta es una publicación anterior, pero creo que debería proporcionar una respuesta ilustrada de todos modos.

Use la notación de objetos de JavaScript. Al igual que:

states_dictionary={ 
     "CT":["alex","harry"], 
     "AK":["liza","alex"], 
     "TX":["fred", "harry"]
};

Y para acceder a los valores:

states_dictionary.AK[0] //which is liza

o puede usar la notación de objetos literales de JavaScript, por lo que las claves no requieren estar entre comillas:

states_dictionary={ 
     CT:["alex","harry"], 
     AK:["liza","alex"], 
     TX:["fred", "harry"]
};

Answer 2

Firefox 13+ proporciona una implementación experimental del objeto de map similar al objeto dict en python. Especificaciones aquí .

Solo está disponible en Firefox, pero se ve mejor que usar atributos de un new Object() . Citación de la documentación:

• Un objeto tiene un prototipo, por lo que hay claves predeterminadas en el mapa. Sin embargo, esto puede map = Object.create(null) usando map = Object.create(null) .
• Las claves de un Object son Strings , donde pueden ser cualquier valor para un Map .
• Puede obtener el tamaño de un Map fácilmente mientras tiene que realizar un seguimiento manual del tamaño de un Object .

Answer 3

He creado un diccionario simple en JS aquí:

function JSdict() {
    this.Keys = [];
    this.Values = [];
}

// Check if dictionary extensions aren''t implemented yet.
// Returns value of a key
if (!JSdict.prototype.getVal) {
    JSdict.prototype.getVal = function (key) {
        if (key == null) {
            return "Key cannot be null";
        }
        for (var i = 0; i < this.Keys.length; i++) {
            if (this.Keys[i] == key) {
                return this.Values[i];
            }
        }
        return "Key not found!";
    }
}


// Check if dictionary extensions aren''t implemented yet.
// Updates value of a key
if (!JSdict.prototype.update) {
    JSdict.prototype.update = function (key, val) {
        if (key == null || val == null) {
            return "Key or Value cannot be null";
        }
        // Verify dict integrity before each operation
        if (keysLength != valsLength) {
            return "Dictionary inconsistent. Keys length don''t match values!";
        }
        var keysLength = this.Keys.length;
        var valsLength = this.Values.length;
        var flag = false;
        for (var i = 0; i < keysLength; i++) {
            if (this.Keys[i] == key) {
                this.Values[i] = val;
                flag = true;
                break;
            }
        }
        if (!flag) {
            return "Key does not exist";
        }
    }
}



// Check if dictionary extensions aren''t implemented yet.
// Adds a unique key value pair
if (!JSdict.prototype.add) {
    JSdict.prototype.add = function (key, val) {
        // Allow only strings or numbers as keys
        if (typeof (key) == "number" || typeof (key) == "string") {
            if (key == null || val == null) {
                return "Key or Value cannot be null";
            }
            if (keysLength != valsLength) {
                return "Dictionary inconsistent. Keys length don''t match values!";
            }
            var keysLength = this.Keys.length;
            var valsLength = this.Values.length;
            for (var i = 0; i < keysLength; i++) {
                if (this.Keys[i] == key) {
                    return "Duplicate keys not allowed!";
                }
            }
            this.Keys.push(key);
            this.Values.push(val);
        }
        else {
            return "Only number or string can be key!";
        }
    }
}

// Check if dictionary extensions aren''t implemented yet.
// Removes a key value pair
if (!JSdict.prototype.remove) {
    JSdict.prototype.remove = function (key) {
        if (key == null) {
            return "Key cannot be null";
        }
        if (keysLength != valsLength) {
            return "Dictionary inconsistent. Keys length don''t match values!";
        }
        var keysLength = this.Keys.length;
        var valsLength = this.Values.length;
        var flag = false;
        for (var i = 0; i < keysLength; i++) {
            if (this.Keys[i] == key) {
                this.Keys.shift(key);
                this.Values.shift(this.Values[i]);
                flag = true;
                break;
            }
        }
        if (!flag) {
            return "Key does not exist";
        }
    }
}

La implementación anterior ahora se puede usar para simular un diccionario como:

var dict = new JSdict();

dict.add(1, "one")

dict.add(1, "one more")
"Duplicate keys not allowed!"

dict.getVal(1)
"one"

dict.update(1, "onne")

dict.getVal(1)
"onne"

dict.remove(1)

dict.getVal(1)
"Key not found!"

Esto es solo una simulación básica. Se puede optimizar aún más mediante la implementación de un mejor algoritmo de tiempo de ejecución para trabajar en al menos la complejidad del tiempo O (nlogn) o incluso menos. Me gusta combinar / ordenar rápidamente en matrices y luego buscar B para búsquedas. No lo intenté ni busqué sobre mapear una función hash en JS.

Además, Key y Value para JSdict obj se pueden convertir en variables privadas para ser engañosas.

¡Espero que esto ayude!

EDIT >> Después de implementar lo anterior, utilicé personalmente los objetos JS como matrices asociativas que están disponibles de fábrica.

Sin embargo , me gustaría hacer una mención especial sobre dos métodos que en realidad resultaron útiles para que sea una experiencia de tabla hash conveniente.

Viz: dict.hasOwnProperty (clave) y eliminar dict [clave]

Lea esta publicación como un buen recurso sobre esta implementación / uso. Creación dinámica de claves en una matriz asociativa de JavaScript

¡Gracias!

Answer 4

Me doy cuenta de que esta es una pregunta antigua, pero aparece en Google cuando buscas ''diccionarios de JavaScript'', por lo que me gustaría agregar a las respuestas anteriores que en ECMAScript 6, se ha introducido el objeto oficial de Map , que es un implementación del diccionario:

var dict = new Map();
dict.set("foo", "bar");

//returns "bar"
dict.get("foo");

A diferencia de los objetos normales de JavaScript, permite que cualquier objeto como clave:

var foo = {};
var bar = {};
var dict = new Map();
dict.set(foo, "Foo");
dict.set(bar, "Bar");

//returns "Bar"
dict.get(bar);

//returns "Foo"
dict.get(foo);

//returns undefined, as {} !== foo and {} !== bar
dict.get({});

Answer 5

No hay matrices asociativas reales en Javascript. Puedes intentar usar objetos:

var x = new Object();
x["Key"] = "Value";

Sin embargo, con los objetos no es posible usar las características típicas de la matriz o métodos como array.length. Al menos es posible acceder al "objeto-array" en un for-in-loop.

Answer 6

Una vieja pregunta, pero recientemente necesité hacer un puerto AS3> JS, y por el bien de la velocidad, escribí un objeto simple de diccionario AS3 para JS:

http://jsfiddle.net/MickMalone1983/VEpFf/2/

Si no lo sabía, el diccionario AS3 le permite usar cualquier objeto como clave, en lugar de solo cadenas. Son muy útiles una vez que has encontrado un uso para ellos.

No es tan rápido como lo sería un objeto nativo, pero no he encontrado ningún problema significativo al respecto.

API:

//Constructor
var dict = new Dict(overwrite:Boolean);

//If overwrite, allows over-writing of duplicate keys,
//otherwise, will not add duplicate keys to dictionary.

dict.put(key, value);//Add a pair
dict.get(key);//Get value from key
dict.remove(key);//Remove pair by key
dict.clearAll(value);//Remove all pairs with this value
dict.iterate(function(key, value){//Send all pairs as arguments to this function:
    console.log(key+'' is key for ''+value);
});


dict.get(key);//Get value from key

Answer 7

Use objetos de JavaScript. Puede acceder a sus propiedades como las teclas en un diccionario. Esta es la base de JSON. La sintaxis es similar a los diccionarios de Python. Ver: JSON.org