Wenn es ein Javascript-Objekt gibt:

var objects={...};

Angenommen, es hat mehr als 50 Eigenschaften, ohne die Eigenschaftsnamen zu kennen (dh ohne die 'Schlüssel' zu kennen), wie jeder Eigenschaftswert in einer Schleife abgerufen werden kann.

Mit einer einfachen for..inSchleife:

for(var key in objects) {
    var value = objects[key];
}

Je nachdem, welche Browser Sie unterstützen müssen, kann dies auf verschiedene Arten erfolgen. Die überwiegende Mehrheit der Browser in freier Wildbahn unterstützt ECMAScript 5 (ES5). Beachten Sie jedoch, dass viele der folgenden Beispiele verwendet werden Object.keys, die in IE <9 nicht verfügbar sind. Siehe Kompatibilitätstabelle .

ECMAScript 3+

Wenn Sie ältere Versionen von IE unterstützen müssen, ist dies die Option für Sie:

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

Die Verschachtelung ifstellt sicher, dass Sie nicht über Eigenschaften in der Prototypenkette des Objekts auflisten (was das Verhalten ist, das Sie mit ziemlicher Sicherheit wollen). Du musst benutzen

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

eher, als

obj.hasOwnProperty(key) // bad

Mit ECMAScript 5+ können Sie prototyplose Objekte erstellen Object.create(null), und diese Objekte verfügen nicht über die hasOwnPropertyMethode. Frecher Code kann auch Objekte erzeugen, die das überschreibenhasOwnProperty Methode .

ECMAScript 5+

Sie können diese Methoden in jedem Browser verwenden, der ECMAScript 5 und höher unterstützt. Diese erhalten Werte von einem Objekt und vermeiden eine Aufzählung über die Prototypkette. Wo objist dein Objekt:

var keys = Object.keys(obj);

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

Wenn Sie etwas kompakteres wollen oder mit Funktionen in Schleifen vorsichtig sein wollen, dann Array.prototype.forEachist Ihr Freund:

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

Die nächste Methode erstellt ein Array, das die Werte eines Objekts enthält. Dies ist praktisch zum Umschleifen.

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

// use vals array

Wenn Sie die Benutzer Object.keyssicher machen möchten null(wie sie for-insind), können Sie dies tun Object.keys(obj || {})....

Object.keysgibt aufzählbare Eigenschaften zurück. Für die Iteration über einfache Objekte ist dies normalerweise ausreichend. Wenn Sie etwas mit nicht aufzählbaren Eigenschaften haben, mit denen Sie arbeiten müssen, können Sie es Object.getOwnPropertyNamesanstelle von verwenden Object.keys.

ECMAScript 2015+ (AKA ES6)

Arrays lassen sich mit ECMAScript 2015 einfacher iterieren. Sie können dies zu Ihrem Vorteil nutzen, wenn Sie einzeln in einer Schleife mit Werten arbeiten:

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

Mit den Fettpfeilfunktionen von ECMAScript 2015 wird das Zuordnen des Objekts zu einem Array von Werten zu einem Einzeiler:

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

// use vals array

ECMAScript 2015 wird vorgestellt Symbol, von denen Instanzen als Eigenschaftsnamen verwendet werden können. Verwenden Sie Object.getOwnPropertySymbolsdiese Option, um die Symbole eines Objekts zum Aufzählen zu erhalten (diese Funktion Symbol kann daher nicht zum Erstellen privater Eigenschaften verwendet werden). Die neue ReflectAPI von ECMAScript 2015 bietetReflect.ownKeys eine Liste von Eigenschaftsnamen (einschließlich nicht aufzählbarer) und Symbolen.

Array-Verständnis (nicht verwenden)

Das Array-Verständnis wurde vor der Veröffentlichung aus ECMAScript 6 entfernt . Vor ihrer Entfernung hätte eine Lösung so ausgesehen:

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

// use vals array

ECMAScript 2017+

ECMAScript 2016 fügt Funktionen hinzu, die dieses Thema nicht beeinflussen. Die ECMAScript 2017-Spezifikation fügt hinzu Object.valuesund Object.entries. Beide geben Arrays zurück (was angesichts der Analogie zu einigen überraschend sein wird Array.entries). Object.valueskann unverändert oder mit einer for-ofSchleife verwendet werden.

const values = Object.values(obj);

// use values array or:

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

Wenn Sie sowohl den Schlüssel als auch den Wert verwenden möchten, ist dies das Richtige Object.entriesfür Sie. Es wird ein mit [key, value]Paaren gefülltes Array erzeugt . Sie können dies unverändert oder (beachten Sie auch die ECMAScript 2015-Destrukturierungszuweisung) in einer for-ofSchleife verwenden:

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

Object.values Shim

Schließlich kann es, wie in den Kommentaren und von teh_senaus in einer anderen Antwort erwähnt, sinnvoll sein, eine davon als Unterlegscheibe zu verwenden. Keine Sorge, das Folgende ändert nichts am Prototyp, sondern fügt lediglich eine Methode hinzu Object(die viel weniger gefährlich ist). Mit den Fettpfeilfunktionen kann dies auch in einer Zeile erfolgen:

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

die du jetzt gerne benutzen kannst

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

Wenn Sie das Shimmen vermeiden möchten, wenn ein Eingeborener Object.valuesvorhanden ist, können Sie Folgendes tun:

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

Schließlich...

Beachten Sie die Browser / Versionen, die Sie unterstützen müssen. Die obigen Angaben sind korrekt, wenn die Methoden oder Sprachfunktionen implementiert sind. Beispielsweise war die Unterstützung für ECMAScript 2015 in V8 bis vor kurzem standardmäßig deaktiviert, wodurch Browser wie Chrome unterstützt wurden. Funktionen aus ECMAScript 2015 sollten vermieden werden, bis die Browser, die Sie unterstützen möchten, die von Ihnen benötigten Funktionen implementieren. Wenn Sie Ihren Code mit babel in ECMAScript 5 kompilieren, haben Sie Zugriff auf alle Funktionen in dieser Antwort.

Hier ist eine wiederverwendbare Funktion zum Abrufen der Werte in ein Array. Es werden auch Prototypen berücksichtigt.

Object.values = function (obj) {
    var vals = [];
    for( var key in obj ) {
        if ( obj.hasOwnProperty(key) ) {
            vals.push(obj[key]);
        }
    }
    return vals;
}

Wenn Sie Zugriff auf Underscore.js haben, können Sie die folgende _.valuesFunktion verwenden:

_.values({one : 1, two : 2, three : 3}); // return [1, 2, 3]

Wenn Sie wirklich ein Array von Werten wollen, finde ich das sauberer als das Erstellen eines Arrays mit einer for ... in-Schleife.

ECMA 5.1+

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

Es ist erwähnenswert, dass Sie in den meisten Fällen nicht wirklich eine Reihe von Werten benötigen. Dies geht schneller:

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

Dies iteriert über die Schlüssel des Objekts o. In jeder Iteration wird k auf einen Schlüssel von o gesetzt.

ES5 Object.keys

var a = { a: 1, b: 2, c: 3 };
Object.keys(a).map(function(key){ return a[key] });
// result: [1,2,3]

Sie können die Tasten durchlaufen:

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

wird ausgegeben:

foo[one]=1
foo[two]=2
foo[three]=3

Für diejenigen, die sich frühzeitig an die CofeeScript-Ära gewöhnt haben, ist hier ein weiteres Äquivalent dafür.

val for key,val of objects

Was vielleicht besser ist, weil das objectsreduziert werden kann, um erneut getippt zu werden, und die Lesbarkeit verringert.

objects[key] for key of objects

Verwenden Sie eine Polyfüllung wie:

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

dann benutze

Object.values(my_object)

3) Gewinn!

Ab ECMA2017:

Object.values(obj) ruft Ihnen alle Eigenschaftswerte als Array ab.

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

Anscheinend ist dies - wie ich kürzlich erfahren habe - der schnellste Weg, dies zu tun:

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]];
}

Die Frage gibt nicht an, ob auch geerbte und nicht aufzählbare Eigenschaften gewünscht werden.

Es gibt eine Frage zum Abrufen von allem, geerbten Eigenschaften und nicht aufzählbaren Eigenschaften , die Google nicht leicht finden kann.

Meine Lösung dafür ist:

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

Und dann iterieren Sie über sie, verwenden Sie einfach eine for-of-Schleife:

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);

Verwenden Sie : Object.values(), wir übergeben ein Objekt als Argument und erhalten ein Array der Werte als Rückgabewert.

Dies gibt ein Array eines bestimmten Objekts mit eigenen aufzählbaren Eigenschaftswerten zurück. Sie erhalten dieselben Werte wie bei Verwendung der for inSchleife, jedoch ohne die Eigenschaften des Prototyps. Dieses Beispiel wird wahrscheinlich die Dinge klarer machen:

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

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

Hier ist eine Funktion ähnlich der Array_values ​​() von PHP

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

So ermitteln Sie die Werte des Objekts, wenn Sie ES6 oder höher verwenden:

Array.from(values(obj));

Kompatibel mit ES7, selbst einige Browser unterstützen dies noch nicht

Da Object.values(<object>)wird in ES7 eingebaut &

Bis alle Browser darauf warten, dass es unterstützt wird, können Sie es in eine Funktion einschließen:

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

Dann :

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

Sobald die Browser mit ES7 kompatibel sind, müssen Sie nichts mehr an Ihrem Code ändern.

Mir ist klar, dass ich etwas spät dran bin, aber hier ist eine Unterlegscheibe für die neue Firefox 47- Object.valuesMethode

Object.prototype.values = Object.prototype.values || function(obj) {
  return this.keys(obj).map(function(key){
    return obj[key];
  });
};

Object.entries machen es besser.

  var dataObject = {"a":{"title":"shop"}, "b":{"title":"home"}}
 
   Object.entries(dataObject).map(itemArray => { 
     console.log("key=", itemArray[0], "value=", itemArray[1])
  })

const myObj = { a:1, b:2, c:3 }

Holen Sie sich alle Werte:

• der kürzeste Weg:

  • const myValues = Object.values(myObj)

• const myValues = Object.keys(myObj).map(key => myObj[key])

var objects={...}; this.getAllvalues = function () {
        var vls = [];
        for (var key in objects) {
            vls.push(objects[key]);
        }
        return vls;
    }

in ECMAScript5 verwenden

 keys = Object.keys(object);

Andernfalls, wenn Ihr Browser dies nicht unterstützt, verwenden Sie den bekannten for..in loop

for (key in object) {
    // your code here
}

Jetzt verwende ich Dojo Toolkit, da ältere Browser dies nicht unterstützen 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);
});

Ausgabe :

['1', '2', '3']

verwenden

console.log(variable)

und wenn Sie Google Chrome verwenden, öffnen Sie die Konsole mit Strg + Umschalt + j

Gehe zu >> Konsole