Jak iterować obiekt JavaScript?

Oto kolejne rozwiązanie iteracji dla nowoczesnych przeglądarek:

Object.keys(obj)
  .filter((k, i) => i >= 100 && i < 300)
  .forEach(k => console.log(obj[k]));

Lub bez funkcji filtra:

Object.keys(obj).forEach((k, i) => {
    if (i >= 100 && i < 300) {
        console.log(obj[k]);
    }
});

Należy jednak wziąć pod uwagę, że właściwości obiektu JavaScript nie są posortowane, tzn. nie mają kolejności.

Używając Object.entries robisz coś takiego.

 // array like object with random key ordering
 const anObj = { 100: 'a', 2: 'b', 7: 'c' };
 console.log(Object.entries(anObj)); // [ ['2', 'b'],['7', 'c'],['100', 'a'] ]

Obiekt.metoda entries () zwraca tablicę właściwości enumerable danego obiektu [key, value]

Więc możesz iterować nad obiektem i mieć key i value dla każdego obiektu i uzyskać coś takiego.

const anObj = { 100: 'a', 2: 'b', 7: 'c' };
Object.entries(anObj).map(obj => {
   const key   = obj[0];
   const value = obj[1];

   // do whatever you want with those values.
});

Lub w ten sposób

// Or, using array extras
Object.entries(obj).forEach(([key, value]) => {
  console.log(`${key} ${value}`); // "a 5", "b 7", "c 9"
});

W celach informacyjnych zajrzyj do dokumentacji MDN dla pozycji obiektów

Dzięki nowym funkcjom ES6 / ES2015, nie musisz już używać obiektu do iteracji nad skrótem. Możesz użyć Mapy . Mapy Javascript przechowują klucze w kolejności wstawiania, co oznacza, że można je iterować bez konieczności sprawdzania hasOwnProperty, co zawsze było naprawdę włamaniem.

Iteracja na mapie:

var myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");
for (var [key, value] of myMap) {
  console.log(key + " = " + value);
}
// Will show 2 logs; first with "0 = zero" and second with "1 = one"

for (var key of myMap.keys()) {
  console.log(key);
}
// Will show 2 logs; first with "0" and second with "1"

for (var value of myMap.values()) {
  console.log(value);
}
// Will show 2 logs; first with "zero" and second with "one"

for (var [key, value] of myMap.entries()) {
  console.log(key + " = " + value);
}
// Will show 2 logs; first with "0 = zero" and second with "1 = one"

Lub użyj forEach:

myMap.forEach(function(value, key) {
  console.log(key + " = " + value);
}, myMap)
// Will show 2 logs; first with "0 = zero" and second with "1 = one"

Jeśli potrzebujesz klucza i wartości podczas iteracji, możesz użyć dla...z pętli z obiektem .wpisy .

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

for (let [key, value] of Object.entries(myObj)) {
    console.log(`key=${key} value=${value}`)
}

// output: 
// key=a value=1
// key=b value=2

Jedynym niezawodnym sposobem na to jest zapisanie danych obiektu do 2 tablic, jednego z kluczy i jednego dla danych:

var keys = [];
var data = [];
for (var key in obj) {
    if (obj.hasOwnProperty(key)) {
        keys.push(key);
        data.push(obj[key]); // Not necessary, but cleaner, in my opinion. See the example below.
    }
}

Możesz następnie iterować po tablicach tak, jak zwykle:

for(var i = 0; i < 100; i++){
    console.log(keys[i], data[i]);
    //or
    console.log(keys[i], obj[keys[i]]); // harder to read, I think.
}
for(var i = 100; i < 300; i++){
    console.log(keys[i], data[i]);
}

Nie używam Object.keys(obj), bo to IE 9+.

->jeśli iterujemy nad obiektem JavaScript używając i znajdziemy klucz tablicy obiekty

Object.keys(Array).forEach(key => {

 console.log('key',key)

})

Jeśli chcesz iterować cały obiekt na raz, możesz użyć for in loop:

for (var i in obj) {
  ...
}

Ale jeśli chcesz podzielić obiekt Na części, w rzeczywistości nie możesz. Nie ma gwarancji, że właściwości w obiekcie są w określonej kolejności. Dlatego mogę wymyślić dwa rozwiązania.

Pierwszym z nich jest "usunięcie" już przeczytanych właściwości:

var i = 0;
for (var key in obj) {
    console.log(obj[key]);
    delete obj[key];
    if ( ++i > 300) break;
}

Innym rozwiązaniem, jakie przychodzi mi do głowy, jest użycie tablicy tablic zamiast obiektu:

var obj = [['key1', 'value1'], ['key2', 'value2']];

Następnie standardowa pętla {[4] } zadziała.

W końcu wymyśliłem przydatną funkcję z zunifikowanym interfejsem do iteracji obiektów, łańcuchów, tablic, TypedArrays, map, zestawów (dowolnych Iterabli).

const iterate = require('@a-z/iterate-it');
const obj = { a: 1, b: 2, c: 3 };

iterate(obj, (value, key) => console.log(key, value)); 
// a 1
// b 2
// c 3

Https://github.com/alrik/iterate-javascript

Do iteracji obiektów zwykle używamy pętli for..in. Ta struktura będzie pętla przez wszystkie wyliczalne właściwości, w tym te, które są dziedziczone przez dziedziczenie prototypowe. Na przykład:

let obj = {
  prop1: '1',
  prop2: '2'
}

for(let el in obj) {
  console.log(el);
  console.log(obj[el]);
}

Jednakże for..in zapętli wszystkie elementy, które można wyliczyć i to nie będzie w stanie podzielić iteracji na części. Aby to osiągnąć, możemy użyć wbudowanej funkcji Object.keys(), Aby pobrać wszystkie klucze obiektu w tablicy. Następnie możemy podzielić iterację do pętli multiple for i uzyskać dostęp do właściwości za pomocą tablicy klawiszy. Na przykład:

let obj = {
  prop1: '1',
  prop2: '2',
  prop3: '3',
  prop4: '4',
};

const keys = Object.keys(obj);
console.log(keys);


for (let i = 0; i < 2; i++) {
  console.log(obj[keys[i]]);
}


for (let i = 2; i < 4; i++) {
  console.log(obj[keys[i]]);
}

Jeśli masz prosty obiekt, możesz go iterować za pomocą następującego kodu:

let myObj = {
  abc: '...',
  bca: '...',
  zzz: '...',
  xxx: '...',
  ccc: '...',
  // ...
};

let objKeys = Object.keys(myObj);

//Now we can use objKeys to iterate over myObj

for (item of objKeys) {
  //this will print out the keys
  console.log('key:', item);
  
  //this will print out the values 
  console.log('value:', myObj[item]);
}

Jeśli masz zagnieżdżony obiekt, Możesz przez niego iterować używając następującego kodu:

let b = {
  one: {
    a: 1,
    b: 2,
    c: 3
  },
  two: {
    a: 4,
    b: 5,
    c: 6
  },
  three: {
    a: 7,
    b: 8,
    c: 9
  }
};

let myKeys = Object.keys(b);

for (item of myKeys) {
  //print the key
  console.log('Key', item)
  
  //print the value (which will be another object)
  console.log('Value', b[item])
  
  //print the nested value
  console.log('Nested value', b[item]['a'])
}

Jeśli masz tablicę obiektów, Możesz przez nią przechodzić używając następującego kodu:

let c = [
{
  a: 1,
  b: 2
},
{
  a: 3,
  b: 4
}
];

for(item of c){
//print the whole object individually 
console.log('object', item);

//print the value inside the object
console.log('value', item['a']);
}

var Dictionary = {
  If: {
    you: {
      can: '',
      make: ''
    },
    sense: ''
  },
  of: {
    the: {
      sentence: {
        it: '',
        worked: ''
      }
    }
  }
};

function Iterate(obj) {
  for (prop in obj) {
    if (obj.hasOwnProperty(prop) && isNaN(prop)) {
      console.log(prop + ': ' + obj[prop]);
      Iterate(obj[prop]);
    }
  }
}
Iterate(Dictionary);

Możesz spróbować użyć lodash-nowoczesnej biblioteki narzędzi JavaScript dostarczającej modułowość, wydajność i Dodatki js do szybkiego iteracji obiektów: -

var  users  =   {
    'fred':     { 
        'user':   'fred',
            'age':  40 
    },
    'pebbles':  { 
        'user':   'pebbles',
         'age':  1 
    }
}; 
_.mapValues(users,  function(o)  { 
    return  o.age; 
});
// => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
// The `_.property` iteratee shorthand.
console.log(_.mapValues(users,  'age')); // returns age property & value 
console.log(_.mapValues(users,  'user')); // returns user property & value 
console.log(_.mapValues(users)); // returns all objects 
// => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash-compat/3.10.2/lodash.js"></script>

Naprawdę PITA to nie jest część standardowego Javascript.

/**
 * Iterates the keys and values of an object.  Object.keys is used to extract the keys.
 * @param object The object to iterate
 * @param fn (value,key)=>{}
 */
function objectForEach(object, fn) {
    Object.keys(object).forEach(key => {
        fn(object[key],key, object)
    })
}

Uwaga: zmieniłem parametry wywołania zwrotnego na (wartość, klucz) i dodałem trzeci obiekt, aby API było spójne z innymi API.

Użyj go w ten sposób

const o = {a:1, b:true};
objectForEach(o, (value, key, obj)=>{
    // do something
});

Tak. Obiekt można zapętlić za pomocą pętli for. Oto przykład

var myObj = {
    abc: 'ABC',
    bca: 'BCA',
    zzz: 'ZZZ',
    xxx: 'XXX',
    ccc: 'CCC',
}

var k = Object.keys (myObj);
for (var i = 0; i < k.length; i++) {
    console.log (k[i] + ": " + myObj[k[i]]);
}

Uwaga: powyższy przykład będzie działał tylko w IE9+. Zob. Objec.keys browser support here .

const o = {
  name: "Max",
  location: "London"
};

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

Wypróbuj online

Oto własnoręcznie wykonane Rozwiązanie:

function iterationForObject() {
    let base = 0,
        Keys= Object.keys(this);
    return {
        next: () => {
            return {
                value: {
                    "key": Keys[base],
                    "value": this[Keys[base]]
                },
                done: !(base++ < Keys.length)
            };
        }
    };
}
Object.prototype[Symbol.iterator] = iterationForObject;

I Wtedy Możesz Zapętlić Dowolny Obiekt:

for ( let keyAndValuePair of (Object Here) ) {
    console.log(`${keyAndValuePair.key} => ${keyAndValuePair.value}`);
}

<script type="text/javascript">
// method 1
var images = {};
images['name'] = {};
images['family'] = {};
images[1] = {};
images['name'][5] = "Mehdi";
images['family'][8] = "Mohammadpour";
images['family']['ok'] = 123456;
images[1][22] = 2602;
images[1][22] = 2602;
images[1][22] = 2602;
images[1][22] = 2602;
images[1][23] = 2602;

for (const [key1, value1] of Object.entries(images)){
    for (const [key2, value2] of Object.entries(value1)){
        console.log(`${key1} => ${key2}: ${value2}`);
    }
}


console.log("=============================");

// method 2
var arr = [];
for(var x = 0; x < 5; x++){
     arr[x] = [];    
     for(var y = 0; y < 5; y++){ 
         arr[x][y] = x*y;    
     }    
 }

for(var i = 0; i < arr.length; i++) {
    var cube = arr[i];
    for(var j = 0; j < cube.length; j++) {
        console.log("cube[" + i + "][" + j + "] = " + cube[j]);
    }
}

</script>