Si hay un objeto Javascript:

var objects={...};

Supongamos que tiene más de 50 propiedades, sin conocer los nombres de las propiedades (es decir, sin conocer las 'claves'), ¿cómo obtener cada valor de propiedad en un bucle?

486
Mellon 5 sep. 2011 a las 14:20

22 respuestas

La mejor respuesta

Al usar un bucle simple for..in:

for(var key in objects) {
    var value = objects[key];
}
444
Tatu Ulmanen 5 sep. 2011 a las 10:22
const object1 = {
  a: 'somestring',
  b: 42
};

for (let [key, value] of Object.entries(object1)) {
  console.log(`${key}: ${value}`);
}

// expected output:
// "a: somestring"
// "b: 42"
// order is not guaranteed
1
priya_21 11 sep. 2019 a las 08:50

Si tiene acceso a Underscore.js, puede usar la función _.values de esta manera:

_.values({one : 1, two : 2, three : 3}); // return [1, 2, 3]
28
Emile Bergeron 28 nov. 2017 a las 16:40

Aparentemente, como aprendí recientemente, esta es la forma más rápida de hacerlo:

var objs = {...};
var objKeys = Object.keys(obj);
for (var i = 0, objLen = objKeys.length; i < objLen; i++) {
    // do whatever in here
    var obj = objs[objKeys[i]];
}
2
dylnmc 1 oct. 2015 a las 13:09

ECMA2017 en adelante:

Object.values(obj) obtendrá todos los valores de propiedad como una matriz.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_objects/Object/values

2
ishandutta2007 4 jul. 2018 a las 10:42

Aquí hay una función similar a los array_values () de PHP

function array_values(input) {
  var output = [], key = '';
  for ( key in input ) { output[output.length] = input[key]; }
  return output;
}

Aquí le mostramos cómo obtener los valores del objeto si está utilizando ES6 o superior:

Array.from(values(obj));
0
jaggedsoft 22 ago. 2015 a las 23:09

Object.entries lo hace de mejor manera.

  var dataObject = {"a":{"title":"shop"}, "b":{"title":"home"}}
 
   Object.entries(dataObject).map(itemArray => { 
     console.log("key=", itemArray[0], "value=", itemArray[1])
  })
0
Mustkeem K 19 jun. 2018 a las 06:43

Para aquellos que se adaptaron temprano en la era de CofeeScript, aquí hay otro equivalente para ello.

val for key,val of objects

Lo que puede ser mejor que esto porque objects se puede reducir para volver a escribir y disminuir la legibilidad.

objects[key] for key of objects
3
Ch.Idea 24 feb. 2015 a las 12:20

Dependiendo de los navegadores que tenga que admitir, esto se puede hacer de varias maneras. La inmensa mayoría de los navegadores en la naturaleza son compatibles con ECMAScript 5 (ES5), pero tenga en cuenta que muchos de los ejemplos siguientes utilizan Object.keys, que no está disponible en IE <9. Consulte tabla de compatibilidad.

ECMAScript 3+

Si tiene que admitir versiones anteriores de IE, esta es la opción para usted:

for (var key in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, key)) {
        var val = obj[key];
        // use val
    }
}

El if anidado se asegura de que no enumere las propiedades en la cadena de prototipos del objeto (que es el comportamiento que seguramente desea). Debes usar

Object.prototype.hasOwnProperty.call(obj, key) // ok

En lugar de

obj.hasOwnProperty(key) // bad

Porque ECMAScript 5+ le permite crear objetos sin prototipos con Object.create(null), y estos objetos no tendrán el método hasOwnProperty. El código travieso también puede producir objetos que anulan el método hasOwnProperty.

ECMAScript 5+

Puede usar estos métodos en cualquier navegador que admita ECMAScript 5 y superior. Estos obtienen valores de un objeto y evitan enumerarlos en la cadena del prototipo. Donde obj es tu objeto:

var keys = Object.keys(obj);

for (var i = 0; i < keys.length; i++) {
    var val = obj[keys[i]];
    // use val
}

Si quieres algo un poco más compacto o quieres tener cuidado con las funciones en bucles, entonces Array.prototype.forEach es tu amigo:

Object.keys(obj).forEach(function (key) {
    var val = obj[key];
    // use val
});

El siguiente método crea una matriz que contiene los valores de un objeto. Esto es conveniente para recorrer.

var vals = Object.keys(obj).map(function (key) {
    return obj[key];
});

// use vals array

Si desea hacer que los que usan Object.keys sean seguros contra null (como for-in es), puede hacerlo Object.keys(obj || {})....

Object.keys devuelve propiedades enumerables . Para iterar sobre objetos simples, esto suele ser suficiente. Si tiene algo con propiedades no enumerables con las que necesita trabajar, puede usar Object.getOwnPropertyNames en lugar de Object.keys.

ECMAScript 2015+ (A.K.A. ES6)

Las matrices son más fáciles de iterar con ECMAScript 2015. Puede usar esto para su ventaja cuando trabaje con valores uno por uno en un bucle:

for (const key of Object.keys(obj)) {
    const val = obj[key];
    // use val
}

Usando las funciones de flecha gruesa ECMAScript 2015, mapear el objeto a una matriz de valores se convierte en una línea:

const vals = Object.keys(obj).map(key => obj[key]);

// use vals array

ECMAScript 2015 presenta Symbol, cuyas instancias pueden usarse como nombres de propiedad. Para obtener los símbolos de un objeto para enumerarlos, use Object.getOwnPropertySymbols (esta función es la razón por la que Symbol no se puede usar para hacer propiedades privadas). La nueva API Reflect de ECMAScript 2015 proporciona Reflect.ownKeys, que devuelve una lista de nombres de propiedades (incluidos los no enumerables) y símbolos.

Comprensiones de matriz (no intente usar)

Las comprensiones de matriz se eliminaron de ECMAScript 6 antes de la publicación. Antes de su eliminación, una solución habría parecido:

const vals = [for (key of Object.keys(obj)) obj[key]];

// use vals array

ECMAScript 2017+

ECMAScript 2016 agrega características que no afectan este tema. La especificación ECMAScript 2017 agrega Object.values y Object.entries. Ambas matrices de retorno (lo que sorprenderá a algunos dada la analogía con Array.entries). Object.values se puede usar como está o con un bucle for-of.

const values = Object.values(obj);

// use values array or:

for (const val of Object.values(obj)) {
    // use val
}

Si desea utilizar tanto la clave como el valor, entonces Object.entries es para usted. Produce una matriz llena de [key, value] pares. Puede usar esto como está o (tenga en cuenta también la asignación de desestructuración de ECMAScript 2015) en un bucle for-of:

for (const [key, val] of Object.entries(obj)) {
    // use key and val
}

Cuña Object.values

Finalmente, como se señaló en los comentarios y por teh_senaus en otra respuesta, puede valer la pena usar uno de estos como un calce. No se preocupe, lo siguiente no cambia el prototipo, solo agrega un método a Object (que es mucho menos peligroso). Usando las funciones de flecha gruesa, esto también se puede hacer en una línea:

Object.values = obj => Object.keys(obj).map(key => obj[key]);

Que ahora puedes usar como

// ['one', 'two', 'three']
var values = Object.values({ a: 'one', b: 'two', c: 'three' });

Si desea evitar el calce cuando existe un Object.values nativo, puede hacer lo siguiente:

Object.values = Object.values || (obj => Object.keys(obj).map(key => obj[key]));

Finalmente...

Tenga en cuenta los navegadores / versiones que necesita admitir. Lo anterior es correcto donde se implementan los métodos o las características del lenguaje. Por ejemplo, el soporte para ECMAScript 2015 se desactivó de forma predeterminada en V8 hasta hace poco, lo que alimentó navegadores como Chrome. Las características de ECMAScript 2015 deben evitarse hasta que los navegadores que intente admitir implementen las características que necesita. Si utiliza babel para compilar su código en ECMAScript 5, tendrá acceso a todas las funciones de esta respuesta.

1002
qubyte 12 ago. 2017 a las 01:42

ES5 Object.keys

var a = { a: 1, b: 2, c: 3 };
Object.keys(a).map(function(key){ return a[key] });
// result: [1,2,3]
9
Emile Bergeron 28 nov. 2017 a las 16:42

Ahora uso Dojo Toolkit porque los navegadores más antiguos no son compatibles con Object.values.

require(['dojox/lang/functional/object'], function(Object) {
    var obj = { key1: '1', key2: '2', key3: '3' };
    var values = Object.values(obj);
    console.log(values);
});

Salida:

['1', '2', '3']
-8
Emile Bergeron 28 nov. 2017 a las 16:48

En ECMAScript5 uso

 keys = Object.keys(object);

De lo contrario, si su navegador no lo admite, use el conocido for..in loop

for (key in object) {
    // your code here
}
-4
user278064 5 sep. 2011 a las 10:56
var objects={...}; this.getAllvalues = function () {
        var vls = [];
        for (var key in objects) {
            vls.push(objects[key]);
        }
        return vls;
    }
-1
Sudarshan 20 may. 2013 a las 05:34

Use un polyfill como:

if(!Object.values){Object.values=obj=>Object.keys(obj).map(key=>obj[key])}

Luego usa

Object.values(my_object)

3) beneficio!

3
user40521 26 dic. 2015 a las 13:28

Aquí hay una función reutilizable para obtener los valores en una matriz. También tiene en cuenta los prototipos.

Object.values = function (obj) {
    var vals = [];
    for( var key in obj ) {
        if ( obj.hasOwnProperty(key) ) {
            vals.push(obj[key]);
        }
    }
    return vals;
}
31
teh_senaus 27 feb. 2013 a las 13:49

Me doy cuenta de que llego un poco tarde, pero aquí hay una cuña para el nuevo método firefox 47 Object.values

Object.prototype.values = Object.prototype.values || function(obj) {
  return this.keys(obj).map(function(key){
    return obj[key];
  });
};
0
Emile Bergeron 28 nov. 2017 a las 16:51

Uso

console.log(variable)

Y si usa Google Chrome, abra la consola usando Ctrl + Shift + j

Ir a >> Consola

-10
laaposto 13 may. 2014 a las 09:29

Puede recorrer las teclas:

foo = {one:1, two:2, three:3};
for (key in foo){
    console.log("foo["+ key +"]="+ foo[key]);
}

Producirá:

foo[one]=1
foo[two]=2
foo[three]=3
5
Josua Marcel Chrisano 14 feb. 2013 a las 03:34

Compatible con ES7, incluso algunos navegadores aún no lo admiten.

Dado que, Object.values(<object>) estará integrado en ES7 y

Hasta que espere que todos los navegadores lo admitan, puede incluirlo dentro de una función:

Object.vals=(o)=>(Object.values)?Object.values(o):Object.keys(o).map((k)=>o[k])

Luego :

Object.vals({lastname:'T',firstname:'A'})
 // ['T','A']

Una vez que los navegadores sean compatibles con ES7, no tendrá que cambiar nada en su código.

0
Abdennour TOUMI 27 jul. 2016 a las 21:07

Si realmente desea una matriz de valores, encuentro esto más limpio que construir una matriz con un bucle for ... in.

ECMA 5.1+

function values(o) { return Object.keys(o).map(function(k){return o[k]}) }

Vale la pena señalar que en la mayoría de los casos realmente no necesita una matriz de valores, será más rápido hacer esto:

for(var k in o) something(o[k]);

Esto itera sobre las claves del objeto o. En cada iteración, k se establece en una clave de o.

14
zzz 3 may. 2015 a las 14:07

Use: Object.values(), pasamos un objeto como argumento y recibimos una matriz de valores como valor de retorno.

Esto devuelve una matriz de valores de propiedad enumerables propios de un objeto dado. Obtendrá los mismos valores que al usar el bucle for in pero sin las propiedades del Prototipo. Este ejemplo probablemente aclarará las cosas:

function person (name) {
  this.name = name;
}

person.prototype.age = 5;

let dude = new person('dude');

for(let prop in dude) {
  console.log(dude[prop]);     // for in still shows age because this is on the prototype
}                              // we can use hasOwnProperty but this is not very elegant

// ES6 + 
console.log(Object.values(dude));
// very concise and we don't show props on prototype
1
Willem van der Veen 17 ago. 2018 a las 14:34

La pregunta no especifica si también se desean propiedades heredadas y no enumerables.

Hay una pregunta para obtener todo, propiedades heredadas y propiedades no enumerables también, que Google no puede encontrar fácilmente.

Mi solución para eso es:

function getAllPropertyNames(obj) {
    let result = new Set();
    while (obj) {
        Object.getOwnPropertyNames(obj).forEach(p => result.add(p));
        obj = Object.getPrototypeOf(obj);
    }
    return [...result];
}

Y luego iterar sobre ellos, solo use un bucle for-of:

function getAllPropertyNames(obj) {
  let result = new Set();
  while (obj) {
    Object.getOwnPropertyNames(obj).forEach(p => result.add(p));
    obj = Object.getPrototypeOf(obj);
  }
  return [...result];
}

let obj = {
  abc: 123,
  xyz: 1.234,
  foobar: "hello"
};

for (p of getAllPropertyNames(obj)) console.log(p);
1
nonopolarity 12 ene. 2020 a las 20:10