перебор - проверка наличия свойства объекта javascript




Итерация через свойства объекта (17)

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

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

 var obj = {
		name: "Simon",
		age: "20",
		clothing: {
			style: "simple",
			hipster: false
		}
	}

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

Как переменная propt представляет свойства объекта? Это не встроенный метод или свойство. Тогда почему оно возникает с каждым свойством в объекте?


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

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 будет «имя».


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

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

Вышеупомянутые ответы немного раздражают, потому что они не объясняют, что вы делаете внутри цикла 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;)


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

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

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

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

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

console.log(someVariable); // outputs planet

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

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

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

Метод Object.entries () возвращает массив собственных пар элементов enumerable property [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
}

Здесь я повторяю каждый узел и создаю значимые имена узлов. Если вы заметили, 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]);
            }
        }
    }
}

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


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

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

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

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


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

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


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

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

    // Do stuff...
}

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

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

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

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

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

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


Чтобы добавить 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



Я хочу добавить к ответам выше, потому что у вас могут быть разные намерения от 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]);

            }

     }
}

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

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

// a
// 3
// 2




object