Итерация по свойствам объекта

Итерация по свойствам требует дополнительной проверки hasOwnProperty:

for (var property in object) {
    if (object.hasOwnProperty(property)) {
        // do stuff
    }
}

Это необходимо, потому что прототип объекта содержит дополнительные свойства для объекта, которые являются технически частью объекта. Эти дополнительные свойства наследуются от класса базового объекта, но все еще являются свойствами object.

hasOwnProperty просто проверяет, является ли это свойством, специфичным для этого класса, а не унаследованным от базового класса.

Начиная с JavaScript 1.8.5 вы можете использовать Object.keys(obj) для получения массива свойств, определенных на самом объекте (те, которые возвращают true для obj.hasOwnProperty(key)).

Object.keys(obj).forEach(function(key,index) {
    // key: the name of the object key
    // index: the ordinal position of the key within the object 
});

Это лучше (и более читаемо), чем использование цикла for-in.

Поддерживается в этих браузерах:

• Firefox (Gecko): 4 (2.0)
• Chrome: 5
• Internet Explorer: 9

См. Ссылку на объект Mozilla Developer Network Object.keys() для дальнейшей информации.

Девочки и ребята, мы в 2017 году, и у нас нет такого количества времени для ввода... Так что давайте сделаем этот классный новый модный ECMAScript 2016:

Object.keys(obj).forEach(e => console.log('key=${e}  value=${obj[e]}'));

Это for...in statement (MDN, спецификация ECMAScript).

Вы можете прочитать это как FOR каждое свойство IN объекта obj, присваивая каждому свойству переменную PROPT по очереди ".

В будущих версиях ES вы можете использовать Object.entries:

for (const [key, value] of Object.entries(obj)) { }

или

Object.entries(obj).forEach(([key, value]) => ...)

Если вы просто хотите перебирать значения, используйте Object.values:

for (const value of Object.values(obj)) { }

или

Object.values(obj).forEach(value => ...)

Это просто цикл for...in. Проверьте документацию в Mozilla.

jquery позволяет сделать это сейчас:

$.each( obj, function( key, value ) {
  alert( key + ": " + value );
});

for (property in object) {
  ...
} 

Вышеприведенные ответы немного раздражают, потому что они не объясняют, что вы делаете внутри цикла for, после того, как вы обеспечиваете его объектом: ВЫ НЕ ДОСТУПНЫ ЭТО ПРЯМО! Вы на самом деле только доставили КЛЮЧ, который вам нужно применить к OBJ:

var obj = {
  a: "foo",
  b: "bar",
  c: "foobar"
};

// We need to iterate the string keys (not the objects)
for(var someKey in obj)
{
  // We check if this key exists in the obj
  if (obj.hasOwnProperty(someKey))
  {
    // someKey is only the KEY (string)! Use it to get the obj:
    var myActualPropFromObj = obj[someKey]; // Since dynamic, use [] since the key isn't literally named "someKey"

    // NOW you can treat it like an obj
    var shouldBeBar = myActualPropFromObj.b;
  }
}

Это все безопасно для ECMA5. Даже работает в хромых версиях JS, таких как Rhino;)

Ответ Доминика идеален, я просто предпочитаю делать это так, как чище читать:

for (var property in object) {
    if (!object.hasOwnProperty(property)) continue;

    // Do stuff...
}

Если ваша среда поддерживает ES2017, я бы рекомендовал Object.entries:

Object.entries(obj).forEach(([key, value]) => {
  console.log('${key} ${value}');
});

Как показано в документации Mozillas Object.entries():

Метод Object.entries() возвращает массив принадлежащих данному объекту собственных пар элементов enumerable [key, value] в том же порядке, что и в цикле for for... in (разница состоит в том, что число циклов for-in перечисляется свойства в прототипной цепочке).

В основном с Object.entries мы можем отказаться от следующего дополнительного шага, который требуется для более старого для... in loop:

// This step is not necessary with Object.entries
if (object.hasOwnProperty(property)) {
  // do stuff
}

Чтобы добавить ES2015 использование Reflect.ownKeys(obj) а также итерацию по свойствам через итератор.

Например:

let obj = { a: 'Carrot', b: 'Potato', Car: { doors: 4 } };

может быть повторена

// logs each key
Reflect.ownKeys(obj).forEach(key => console.log(key));

Если вы хотите итерации непосредственно над значениями ключей объекта, вы можете определить iterator, как и итераторы по умолчанию для JavaScipts для строк, массивов, типизированных массивов, Map и Set.

JS попытается выполнить итерацию с использованием свойства iterator по умолчанию, которое должно быть определено как Symbol.iterator.

Если вы хотите, чтобы иметь возможность выполнять итерацию по всем объектам, вы можете добавить его в качестве прототипа объекта:

Object.prototype[Symbol.iterator] = function*() { 
    for(p of Reflect.ownKeys(this)){ yield this[p]; }
}

Это позволит вам перебирать значения объекта с помощью цикла for for..., например:

for(val of obj) { console.log('Value is:' + val ) }

Внимание: начиная с написания этого ответа (июнь 2018 года) все другие браузеры, но IE, поддерживают генераторы и for...of итерации через Symbol.iterator

let obj = {"a": 3, "b": 2, "6": "a"}

Object.keys(obj).map((item) => {console.log("item", obj[item])})

// a
// 3
// 2

Цикл for... in представляет каждое свойство в объекте, потому что он похож на цикл for. Вы определили propt в цикле for... in, выполнив:

    for(var propt in obj){
alert(propt + ': ' + obj[propt]);
}

А для... в цикле выполняется итерация через перечислимые свойства объекта. Какую бы переменную вы не определяли или не вводили в цикл for... in, каждый раз, когда она переходит к следующему свойству, она выполняет итерацию. Переменная в цикле for... in выполняет итерацию через клавиши, но значение этого значения является ключевым значением. Например:

    for(var propt in obj) {
      console.log(propt);//logs name
      console.log(obj[propt]);//logs "Simon"
    }

Вы можете видеть, как переменная отличается от значения переменной. Напротив, a для... цикла делает обратное.

Надеюсь, это поможет.

Вы можете использовать Lodash. Документация

var obj = {a: 1, b: 2, c: 3};
_.keys(obj).forEach(function (key) {
    ...
});

Object.keys(obj).forEach(key =>
  console.log('key=${key} value=${obj[key]}')
);

В настоящее время вы можете преобразовать стандартный объект JS в итерируемый объект, просто добавив метод Symbol.iterator. Затем вы можете использовать цикл for of и использовать его значения напрямую или даже использовать оператор распространения на объекте. Круто. Давайте посмотрим, как мы можем это сделать:

var o = {a:1,b:2,c:3},
    a = [];
o[Symbol.iterator] = function*(){
                       var ok = Object.keys(this);
                            i = 0;
                       while (i < ok.length) yield this[ok[i++]];
                     };
for (var value of o) console.log(value);
// or you can even do like
a = [...o];
console.log(a);

Ваш цикл for выполняет итерацию по всем свойствам объекта obj. propt определяется в первой строке цикла for. Это строка, которая является именем свойства объекта obj. В первой итерации цикла propt будет "name".

Объекты в JavaScript являются наборами свойств и поэтому могут быть закодированы в для каждого оператора.

Вы должны думать о obj как о наборе значений ключей.

Также добавление рекурсивного способа:

function iterate(obj) {
    // watch for objects we've already iterated so we won't end in endless cycle
    // for cases like var foo = {}; foo.bar = foo; iterate(foo);
    var walked = [];
    var stack = [{obj: obj, stack: ''}];
    while(stack.length > 0)
    {
        var item = stack.pop();
        var obj = item.obj;
        for (var property in obj) {
            if (obj.hasOwnProperty(property)) {
                if (typeof obj[property] == "object") {
                  // check if we haven't iterated through the reference yet
                  var alreadyFound = false;
                  for(var i = 0; i < walked.length; i++)
                  {
                    if (walked[i] === obj[property])
                    {
                      alreadyFound = true;
                      break;
                    }
                  }
                  // new object reference
                  if (!alreadyFound)
                  {
                    walked.push(obj[property]);
                    stack.push({obj: obj[property], stack: item.stack + '.' + property});
                  }
                }
                else
                {
                    console.log(item.stack + '.' + property + "=" + obj[property]);
                }
            }
        }
    }
}

Использование:

iterate({ foo: "foo", bar: { foo: "foo"} }); 

Если вы используете Node, я бы рекомендовал:

Object.keys(obj).forEach((key, index) => {
    console.log(key);
});

Вы в основном хотите перебирать каждое свойство в объекте.

JSFiddle

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

Здесь я повторяю каждый node и создаю значимые имена node. Если вы заметили, instanceOf Array и instanceOf Object в значительной степени делают одно и то же (в моем приложении я использую другую логику)

function iterate(obj,parent_node) {
    parent_node = parent_node || '';
    for (var property in obj) {
        if (obj.hasOwnProperty(property)) {
            var node = parent_node + "/" + property;
            if(obj[property] instanceof Array) {
                //console.log('array: ' + node + ":" + obj[property]);
                iterate(obj[property],node)
            } else if(obj[property] instanceof Object){
                //console.log('Object: ' + node + ":" + obj[property]);
                iterate(obj[property],node)
            }
            else {
                console.log(node + ":" + obj[property]);
            }
        }
    }
}

Примечание. На меня вдохновляет ответ Ондрей Швейар. Но это решение имеет лучшую производительность и менее двусмысленный

Я хочу добавить к ответам выше, потому что у вас могут быть разные намерения от Javascript. Объект JSON и объект Javascript - это разные вещи, и вы можете захотеть итерации через свойства объекта JSON с помощью предложенных выше решений, а затем удивляться.

Предположим, что у вас есть объект JSON, например:

var example = {
    "prop1": "value1",
    "prop2": [ "value2_0", value2_1"],
    "prop3": {
         "prop3_1": "value3_1"
    }
}

Неправильный путь для итерации через свои свойства:

function recursivelyIterateProperties(jsonObject) {
    for (var prop in Object.keys(example)) {
        console.log(prop);
        recursivelyIterateProperties(jsonObject[prop]);
    }
}

Вы можете быть удивлены, увидев ведение журнала консоли 0, 1 и т.д. при повторении с помощью свойств prop1 и prop2 и prop3_1. Эти объекты являются последовательностями, а индексы последовательности являются свойствами этого объекта в Javascript.

Лучший способ рекурсивного итерации через свойства объекта JSON - это сначала проверить, является ли этот объект последовательностью или нет:

function recursivelyIterateProperties(jsonObject) {
    for (var prop in Object.keys(example)) {
        console.log(prop);
        if (!(typeof(jsonObject[prop]) === 'string')
            && !(jsonObject[prop] instanceof Array)) {
                recursivelyIterateProperties(jsonObject[prop]);

            }

     }
}

Что для цикла if.. в том, что он создает новую переменную (var someVariable), а затем сохраняет каждое свойство данного объекта в этой новой переменной (someVariable) один за другим. Поэтому, если вы используете block {}, вы можете выполнять итерацию. Рассмотрим следующий пример.

var obj = {
     name:'raman',
     hobby:'coding',
     planet:'earth'
     };

for(var someVariable in obj) {
  //do nothing..
}

console.log(someVariable); // outputs planet

Чтобы уточнить принятый ответ, стоит отметить, что если вы создаете экземпляр объекта с помощью var object = Object.create(null), тогда object.hasOwnProperty(property) вызовет TypeError. Чтобы быть в безопасности, вам нужно вызвать его из прототипа следующим образом:

for (var property in object) {
    if (Object.prototype.hasOwnProperty.call(object, property)) {
        // do stuff
    }
}

Вы можете использовать его для получения или установки значения объекта или массива с объектами. https://jsfiddle.net/narendra_globalsysinfo/yt97dbm5/

var reset = function(data){
                    for( var prop in data){
                        if(typeof data[prop] === 'object')
                        {
                            data[prop] = reset(data[prop]);
                        }
                        else{
                            if(typeof data[prop] !== 'function'){
                                var dataType = typeof data[prop];
                                var returnType = null;
                                switch(dataType){
                                    case 'number':
                                        returnType = 0;
                                        break;
                                    case 'string':
                                        returnType = '';
                                        break;
                                    case 'boolean':
                                        returnType = false;
                                        break;
                                    default:
                                        break;
                                }
                                data[prop] = returnType;
                            }

                        }
                    }
                    return data;

                }

var obj = { p1:{ p11:1,p12:'Hi'},p2:1,p3:function(){console.log('hi')} };
obj = reset(obj);

Он вернет тот же объект со значением, установленным по умолчанию

По умолчанию:  для int равно 0, для строки is '', а для boolean - false

Примечание: объект с функцией как свойство не будет reset, вы можете внести изменения в соответствии с требованиями и поблагодарить меня.