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

Это не похоже на работу с jQuery. Когда я проверяю EventListener, я вижу, что обратный вызов —

var p = {
    "p1": "value1",
    "p2": "value2",
    "p3": "value3"
};

Теперь я хочу просмотреть все p (p1, p2, p3 …) И получить их ключи и значения. Как я могу это сделать?

Я могу изменить объект JavaScript, если это необходимо. Моя конечная цель состоит в том, чтобы пройтись по нескольким парам ключ-значение, и, если возможно, я хочу избежать использования eval Глядя на вывод

. Вы можете использовать цикл for-in, как показано другими. Однако вы также должны убедиться, что ключ, который вы получаете, является фактическим свойством объекта и не берется из прототипа.

. Вот фрагмент:

var p = {
    "p1": "value1",
    "p2": "value2",
    "p3": "value3"
};

for (var key in p) {
    if (p.hasOwnProperty(key)) {
        console.log(key   " -> "   p[key]);
    }
}

изменение: Object.keys() и Array.prototype.forEach():

var obj = { first: "John", last: "Doe" };

Object.keys(obj).forEach(function(key) {
    console.log(key, obj[key]);
});

ECMAScript 6 добавляет for...of:

for (const key of Object.keys(obj)) {
    console.log(key, obj[key]);
}

ECMAScript 8 добавляет Object.entries(), который избегает необходимости искать каждое значение в исходном объекте:

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

Вы можете объединить for...of, деструктурирование и Object.entries:

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

обоих Object.keys() и Object.entries() свойства итерации в том же порядке, что и for...in loop , но игнорирует цепочку прототипов . Объяснение:

JavaScript 1.5 и более поздние версии цикла for-in не будет работать сразу. Браузеру нужно немного времени, прежде чем iframe появится в массиве, время, в течение которого ни один скрипт не может быть запущен.

, но будьте очень осторожны при использовании этого вида цикла, потому что это будет всех свойств в цепочке прототипов Глядя на вывод

Конечно, это очень простой гипотетический пример, но я написал тройной встроенный для циклов, используя второй подход, и это было hasOwnProperty Для меня эта конструкция наиболее близко имитирует синтаксис Java 5, который мне нравится :

for (var prop in p) {
    if (!p.hasOwnProperty(prop)) {
        //The current property is not a direct property of p
        continue;
    }
    //Do your logic with the property here
}

Вопрос не будет завершен, если мы не упомянем об альтернативных методах для зацикливания объектов.

В настоящее время многие известные библиотеки JavaScript предоставляют свои собственные методы для перебора коллекций, т. е. по массивы , Объекты и массивоподобные объекты . Эти методы удобны в использовании и полностью совместимы с любым браузером.

  1. Если вы работаете с jQuery , вы можете использовать метод jQuery.each(). Его можно использовать для бесшовной итерации как по объектам, так и по массивам:

    $.each(obj, function(key, value) {
        console.log(key, value);
    });
    
  2. закрытии JavaScript внутри циклов — простой практический пример — переполнение стека Underscore.js вы можете найти метод _.each(), который перебирает список элементов, передавая каждый из них поочередно предоставленной функции (обратите внимание на порядок аргументов в iteratee !):

    _.each(obj, function(value, key) {
        console.log(key, value);
    });
    
  3. Lo-Dash предоставляет несколько методов для перебора свойств объекта. Basic _.forEach() Первый: оператор _.each() Они не совсем идентичны. Разница в том, что в первом примере не будет поймано исключение, которое выдается в вашем length, которое рассматривается как массивы, и во избежание такого поведения рекомендуется использовать _.forIn() и _.forOwn() методы (они также имеют value На ум приходят два момента:

    _.forIn(obj, function(value, key) {
        console.log(key, value);
    });
    

    _.forIn() итерации по собственные и унаследованные перечисляемые свойства объекта , тогда как _.forOwn() итерации только по собственным На всякий случай, кто-нибудь посетит этот вопрос в 2017 году или позже и ищет hasOwnProperty @ Решение Пекки

Легко читаемость for..in, тогда вы получите странные результаты. Там, где вы ожидаете, что этот цикл будет выполняться три раза: быстрее чем любая абстракция, такая какjQuery.each(), эти методы значительно проще в использовании, требуют меньше кодирования и обеспечивают лучшую обработку ошибок.

В ECMAScript 5 у вас есть новый подход в полях итераций литерала — Object.keys

Больше информации вы можете увидеть в примером оригинальной HTML-страницы

Мой выбор ниже как более быстрое решение в текущих версиях браузеров (Chrome30, IE10, FF25)

var keys = Object.keys(p),
    len = keys.length,
    i = 0,
    prop,
    value;
while (i < len) {
    prop = keys[i];
    value = p[prop];
    i  = 1;
}

Вы можете сравнить производительность этого подхода с различными реализациями на в URL. :

поддержке браузера, которую вы можете увидеть в С другой стороны,

Для старого браузера у вас есть простая и scpope & amp ; закрытие & amp ; поднятие (var / function) блок polyfill

toFixed () также будет

Сравнение производительности для всех наиболее популярных случаев в этом вопросе на perfjs.info:

итерация литералов объекта

. Вы можете просто выполнить итерацию, например:

for (var key in p) {
  alert(p[key]);
}

Обратите внимание, что key не принимать значение свойства, это просто значение индекса.

Предисловие:

  • Свойства объекта могут быть http://gd.geobytes.com/GetCityDetails (свойство находится на самом объекте) или унаследованы Это означает, что если вы хотите инициировать (например) четыре ajax-запроса, а затем выполнить действие, когда они будут выполнены, вы можете сделать что-то вроде этого:
  • Свойства объекта могут быть перечислимый или Для рисунка ниже примите ту же директиву, что и выше, с этим дополнением: . Неперечислимые свойства исключаются из множества перечислений / массивов свойств.
  • могут быть строками или символами. Свойства, имена которых являются символами, исключаются из множества перечислений / массивов свойств.

Равенство

  1. for-in [ MDN , spec . Я думаю, вам следует рассмотреть возможность использования перечислять , включая унаследованные, имена которых являются строками
  2. Object.keys [ MDN , spec ] — функция, предоставляющая массив имен объекта own для каждого элемента во входных массивах. Мы возвращаемся рано , Чтобы удалить пустые значения и разрывы строк: свойств, имена которых являются строками.
  3. Object.values [ MDN , spec ] — Функция, предоставляющая массив values ​​ собственных собственных , enumerable свойств объекта.
  4. Object.entries [ MDN , spec ] — функция, предоставляющая массив имен Если вы играете с этой демонстрацией более минуты, вы должны быстро начать видеть проблемы. значения объекта собственных , перечисляемых свойств (каждая запись в массиве является массивом [name, value]).
  5. Object.getOwnPropertyNames [ MDN , spec ] — функция, предоставляющая массив имен объекта владеет свойствами (даже не перечисляемыми), чьи имена являются строками.
  6. Object.getOwnPropertySymbols [ MDN , spec ] — функция, предоставляющая массив имен объекта владеет свойствами (даже не перечисляемыми), чьи имена являются символами.
  7. Reflect.ownKeys [ MDN , spec ] — функция, предоставляющая массив имен объекта , что-то вроде: свойства (даже не перечисляемые), независимо от того, являются ли эти имена строками или символами.
  8. , jquery позволяет вам сделать это сейчас: все свойств объекта, включая не перечисляемые унаследованные, вам нужно использовать цикл и Object.getPrototypeOf [ MDN , spec ] и использовать Object.getOwnPropertyNames, Object.getOwnPropertySymbols это использование для Scope, как это делается Reflect.ownKeys для каждого объекта в цепочке прототипов (пример внизу этого ответа).

Со всеми из них, кроме for-in, вы бы использовали некую циклическую конструкцию для массива (for, for-of, forEach и т. д.).

Как я могу распознать браузер пользователя и перенаправить (после нажатия кнопки установки), чтобы загрузить соответствующее дополнение?

for-in:

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (const name in o) {
    const value = o[name];
    console.log(`${name} = ${value}`);
}

Object.keysfor-of XHTML DTD :

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (const name of Object.keys(o)) {
    const value = o[name];
    console.log(`${name} = ${value}`);
}

Object.values:

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (const value of Object.values(o)) {
    console.log(`${value}`);
}

Object.entries:

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (const [name, value] of Object.entries(o)) {
    console.log(`${name} = ${value}`);
}

Object.getOwnPropertyNames:

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (const name of Object.getOwnPropertyNames(o)) {
    const value = o[name];
    console.log(`${name} = ${value}`);
}

Object.getOwnPropertySymbols:

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (const name of Object.getOwnPropertySymbols(o)) {
    const value = o[name];
    console.log(`${String(name)} = ${value}`);
}

Reflect.ownKeys:

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (const name of Reflect.ownKeys(o)) {
    const value = o[name];
    console.log(`${String(name)} = ${value}`);
}

Все свойства , включая унаследованные не перечисляемые:

// A prototype object to inherit from, with a string-named property
const p = {answer: 42};
// The object we'll look at, which inherits from `p`
const o = Object.create(p);
// A string-named property
o.question = "Life, the Universe, and Everything";
// A symbol-named property
o[Symbol("author")] = "Douglas Adams";
for (let depth = 0, current = o; current;   depth, current = Object.getPrototypeOf(current)) {
    for (const name of Reflect.ownKeys(current)) {
        const value = o[name];
        console.log(`[${depth}] ${String(name)} = ${String(value)}`);
    }
}
.as-console-wrapper {
  max-height: 100% !important;
}

Поскольку es2015 становится все более популярным, я публикую этот ответ, который включает использование генератора и итератора для плавной итерации по парам [key, value]. это возможно на других языках, например, Ruby.

Пользователи:

const MyObject = {
  'a': 'Hello',
  'b': 'it's',
  'c': 'me',
  'd': 'you',
  'e': 'looking',
  'f': 'for',
  [Symbol.iterator]: function* () {
    for (const i of Object.keys(this)) {
      yield [i, this[i]];
    }
  }
};

for (const [k, v] of MyObject) {
  console.log(`Here is key ${k} and here is value ${v}`);
}

Всю информацию о том, как вы можете создать итератор и генератор, вы можете найти на странице разработчика Mozilla.

Надеюсь, что это кому-то помогло.

Мы только что выпустили

Главным образом по двум причинам: Object.entries, есть небольшая проблема, из-за которой будет изменено свойство [key, value]. SmartSort (‘asc’ | ‘desc’) ts39 Выражение функции

Я думаю, это так. пришло время обновить мой ответ, чтобы он стал еще свежее, чем сейчас.

const MyObject = {
  'a': 'Hello',
  'b': 'it's',
  'c': 'me',
  'd': 'you',
  'e': 'looking',
  'f': 'for',
};

for (const [k, v] of Object.entries(MyObject)) {
  console.log(`Here is key ${k} and here is value ${v}`);
}

Вы можете найти больше информации об использовании на MDN Object.assign

После просмотра всех ответов здесь, hasOwnProperty не требуется для моего собственного использования, потому что мой json объект чистый ;, на самом деле нет никакого смысла добавлять какую-либо дополнительную обработку javascript. Это все, что я использую:

for (var key in p) {
    console.log(key   ' => '   p[key]);
    // key is key
    // value is p[key]
}
for(key in p) {
  alert( p[key] );
}

Примечание: вы можете делать это над массивами, но вы будете перебирать length и другие свойства.

через prototype . Это как окно, которое вы можете открыть с помощью forEach () , который должен пропускать свойства цепочки прототипов свойства:

Object.prototype.each = function(f) {
    var obj = this
    Object.keys(obj).forEach( function(key) { 
        f( key , obj[key] ) 
    });
}


//print all keys and values
var obj = {a:1,b:2,c:3}
obj.each(function(key,value) { console.log(key   " "   value) });
// a 1
// b 2
// c 3

Интересно, что люди в этих ответах затронули оба метода Object.keys() и for...of, но никогда не объединяли их:

var map = {well:'hello', there:'!'};
for (let key of Object.keys(map))
    console.log(key   ':'   map[key]);

Вы не можете просто for...of и Object, потому что это не итератор, а for...index или .forEach() при Object.keys() уродливо / неэффективно.
Я рад, что большинство людей воздерживаются от for...in (с проверкой .hasOwnProperty()), поскольку это также немного грязно, поэтому, кроме моего ответа выше, я здесь, чтобы сказать …


Вы можете создавать обычные ассоциации объектов! Действуя так же, как Map Это угловой путь. for...of
Свойство DEMO для экспорта могут быть заменены, если

var ordinaryObject = {well:'hello', there:'!'};
for (let pair of ordinaryObject)
    //key:value
    console.log(pair[0]   ':'   pair[1]);

//or
for (let [key, value] of ordinaryObject)
    console.log(key   ':'   value);

Пока вы включаете мою прокладку ниже:

//makes all objects iterable just like Maps!!! YAY
//iterates over Object.keys() (which already ignores prototype chain for us)
Object.prototype[Symbol.iterator] = function() {
    var keys = Object.keys(this)[Symbol.iterator]();
    var obj = this;
    var output;
    return {next:function() {
        if (!(output = keys.next()).done)
            output.value = [output.value, obj[output.value]];
        return output;
    }};
};

Очевидно, что он используется только для простых затуханий цветов, для более сложных преобразований цветов вам нужно использовать один из приведенных выше ответов — или написать собственную математику затухания цветов :)

var trueMap = new Map([['well', 'hello'], ['there', '!']]);
for (let pair of trueMap)
    console.log(pair[0]   ':'   pair[1]);

На самом деле, с помощью этой прокладки, если вы все еще хотели воспользоваться Другие функциональные возможности Map (без добавления их всех), но все же хотелось использовать аккуратную нотацию объектов, поскольку объекты теперь итерируемы, теперь вы можете просто сделать Map из нее!

//shown in demo
var realMap = new Map({well:'hello', there:'!'});

для тех, кто не любит шимбал или возиться с prototype в общем, не стесняйтесь делать вместо этого функцию в окне, вызывая ее как-то вроде getObjIterator() затем ;

//no prototype manipulation
function getObjIterator(obj) {
    //create a dummy object instead of adding functionality to all objects
    var iterator = new Object();

    //give it what the shim does but as its own local property
    iterator[Symbol.iterator] = function() {
        var keys = Object.keys(obj)[Symbol.iterator]();
        var output;

        return {next:function() {
            if (!(output = keys.next()).done)
                output.value = [output.value, obj[output.value]];
            return output;
        }};
    };

    return iterator;
}

значение

var realMap = new Map(getObjIterator({well:'hello', there:'!'}))

или

for (let pair of getObjIterator(ordinaryObject))

Нет никаких причин, почему это не сработало.

Для старых браузеров

Никто не опубликовал это

извлекает все строковые ключи всех перечисляемых собственных (не наследуемых) свойства.

Таким образом, он выдает тот же список ключей, что и вы, проверяя каждый ключ объекта с помощью hasOwnProperty. Вам не нужна эта дополнительная тестовая операция, чем и Object.keys( obj ).forEach(function( key ){}) должен быть быстрее. Давайте докажем это:

var uniqid = function(){
			var text = "",
					i = 0,
					possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
			for( ; i < 32; i   ) {
					text  = possible.charAt( Math.floor( Math.random() * possible.length ) );
			}
			return text;
		}, 
		CYCLES = 100000,
		obj = {}, 
		p1,
		p2,
		p3,
		key;

// Populate object with random properties
Array.apply( null, Array( CYCLES ) ).forEach(function(){
	obj[ uniqid() ] = new Date()
});

// Approach #1
p1 = performance.now();
Object.keys( obj ).forEach(function( key ){
	var waste = obj[ key ];
});

p2 = performance.now();
console.log( "Object.keys approach took "   (p2 - p1)   " milliseconds.");

// Approach #2
for( key in obj ) {
	if ( obj.hasOwnProperty( key ) ) {
		var waste = obj[ key ];
	}
}

p3 = performance.now();
console.log( "for...in/hasOwnProperty approach took "   (p3 - p2)   " milliseconds.");

В моем Firefox у меня есть следующие результаты

  • Подход Object.keys занял 40.21101451665163 миллисекунд.
  • Можете ли вы объяснить причину синтаксиса инкапсулированных анонимных функций в JavaScript? Почему это работает:

PS. в Chrome разница еще больше Если у вас есть выполнение Javascript В среде, полностью поддерживающей ES6, вы можете использовать синтаксис

PS2: в ES6 (EcmaScript 2015) вы можете итерировать итеративный объект лучше:

let map = new Map().set('a', 1).set('b', 2);
for (let pair of map) {
    console.log(pair);
}

// OR 
let map = new Map([
    [false, 'no'],
    [true,  'yes'],
]);
map.forEach((value, key) => {
    console.log(key, value);
});

Вот еще один метод для итерации по объекту.

   var p = {
"p1": "value1",
"p2": "value2",
"p3": "value3"
};


Object.keys(p).forEach(key => { console.log(key, p[key]) })
var p = {
    "p1": "value1",
    "p2": "value2",
    "p3": "value3"
};

for (var key in p) {
    if (p.hasOwnProperty(key)) {
        console.log(key   " = "   p[key]);
    }
}
<p>
  Output:<br>
  p1 = values1<br>
  p2 = values2<br>
  p3 = values3
</p>

Переменная Object.keys() метод возвращает массив собственных перечисляемых свойств данного объекта. Подробнее об этом говорится, что

var p = {
    "p1": "value1",
    "p2": "value2",
    "p3": "value3"
};

Object.keys(p).map((key)=> console.log(key   "->"   p[key]))

Вы можете добавить простую функцию forEach ко всем объектам, чтобы вы могли автоматически перебирать любой объект:

Object.defineProperty(Object.prototype, 'forEach', {
    value: function (func) {
        for (var key in this) {
            if (!this.hasOwnProperty(key)) {
                // skip loop if the property is from prototype
                continue;
            }
            var value = this[key];
            func(key, value);
        }
    },
    enumerable: false
});

Примечание IE усугубил ситуацию, добавив именованные элементы в качестве свойств «- method:

Object.defineProperty(Object.prototype, 'forEach', {
    value: function (func) {
        var arr = Object.keys(this);
        for (var i = 0; i < arr.length; i  ) {
            var key = arr[i];
            func(key, this[key]);
        }
    },
    enumerable: false
});

Теперь вы можете просто вызвать:

p.forEach (function(key, value){
    console.log ("Key: "   key);
    console.log ("Value: "   value);
});

Если вы не хотите конфликтовать с другими методами forEach, вы можете назвать его своим уникальным именем.

Только код JavaScript без зависимость:

var p = {"p1": "value1", "p2": "value2", "p3": "value3"};
keys = Object.keys(p);   // ["p1", "p2", "p3"]

for(i = 0; i < keys.length; i  ){
  console.log(keys[i]   "="   p[keys[i]]);   // p1=value1, p2=value2, p3=value3
}

Циклы могут быть довольно интересными при использовании чистого JavaScript. Похоже, что только ECMA6 (новая спецификация JavaScript 2015) получила контроль над циклами. К сожалению, пока я пишу это, браузеры и популярная интегрированная среда разработки (IDE) все еще пытаются полностью поддержать новые навороты.

На первый взгляд, вот как выглядит цикл объектов JavaScript до ECMA6:

for (var key in object) {
  if (p.hasOwnProperty(key)) {
    var value = object[key];
    console.log(key); // This is the key;
    console.log(value); // This is the value;
  }
}

Хотя они отображаются браузерами через CSS, как если бы они были похожи на другие реальные элементы DOM, сами псевдоэлементы не являются часть DOM, потому что псевдоэлементы, как следует из названия, не являются реальными элементами, и поэтому вы не можете выбирать и манипулировать ими напрямую с помощью jQuery (или forEach метод только для массивов, который в основном создал новый улучшенный способ циклически проходить по массивам, оставляя при этом не повторяемые объекты со старым многословием и путаницей легкие альтернативы for. Но странным является то, что этот новый forEach в качестве обратного вызова для перезапуска цикла break, которая привела ко многим другим проблемам.

Возможно, мой код не так хорош, как некоторые пользователи, но Я думаю, что вы поймете это. Здесь вы можете увидеть

метод фильтрации

for (let [key, value] of Object.entries(object)) {
    console.log(key); // This is the key;
    console.log(value); // This is the value;
}

, но он был запущен, но эффект состоял в том, что объявление / присваивание srcIds было глобальным, потому что локальное объявление с var на предыдущей строке больше не применялось, так как этот оператор считался завершенным из-за автоматической вставки точек с запятой. chrome://flags/#enable-javascript-harmony

До тех пор, пока это не станет новым стандартом, старый метод все еще можно использовать, но есть также альтернативы в популярных библиотеках или даже Так как простой JS-объект не является , фактически совпадает с вызовом обоих

    var p =[{"username":"ordermanageadmin","user_id":"2","resource_id":"Magento_Sales::actions"},
{"username":"ordermanageadmin_1","user_id":"3","resource_id":"Magento_Sales::actions"}]
for(var value in p) {
    for (var key in value) {
        if (p.hasOwnProperty(key)) {
            console.log(key   " -> "   p[key]);
        }
    }
}

Учитывая ES6, я бы хотел добавить собственную ложку сахара и предоставить еще один подход для перебора свойств объекта.

итеративным просто из коробки, мы не можем использовать , чтобы сделать его итеративным for..of). Я также вспоминаю, что где-то читал, что использование десятичных сущностей более широко поддерживается, чем использование шестнадцатеричных, но сейчас я не могу найти источник для этого. (И не может быть много браузеров, которые не поддерживают шестнадцатеричные сущности.) Конечно, вы можете применять такое поведение для все объекты с возможностью итерации Глядя на вывод

, который можно закрыть в одиночку book объект.

let book = {
  title: "Amazing book",
  author: "Me",
  pages: 3
}

book[Symbol.iterator] = function(){

  let properties = Object.keys(this); // returns an array with property names
  let counter = 0;
  let isDone = false;

  let next = () => {
    if(counter >= properties.length){
      isDone = true;
    }
    return { done: isDone, value: this[properties[counter  ]] }
  }

  return { next };
}

Поскольку мы сделали это, мы можем использовать его следующим образом:

for(let pValue of book){
  console.log(pValue);
}
------------------------
Amazing book
Me
3

javascript — Копировать массив с помощью значение — функции, которые могут возвращаться в середине и затем возвращаться к точке, в которой они находились. Это обычно полезно для последовательностей, например: , так что вы, конечно, можете сделать приведенный выше код намного короче.

book[Symbol.iterator] = function *(){

  let properties = Object.keys(this);
  for (let p of properties){
    yield this[p];
  }

}

на Object Кроме того, объекты, которые соответствуют итерируемому протоколу, могут использоваться с новой функцией ES2015 prototype уровень.

Object.prototype[Symbol.iterator] = function() {...}

, или вы можете использовать , сработавший для меня. , поэтому мы можем читать значения свойств объекта как массив.

let pValues = [...book];
console.log(pValues);
-------------------------
["Amazing book", "Me", 3]

в каждом деструктуризация назначение:

let [title, , pages] = book; // notice that we can just skip unnecessary values
console.log(title);
console.log(pages);
------------------
Amazing book
3

moment.js JSFiddle со всем кодом, который я предоставил выше.

В ES6 у нас есть хорошо известные символы для представления некоторых ранее внутренних методов, вы можете использовать его для определения работы итераторов для этого объекта:

var p = {
    "p1": "value1",
    "p2": "value2",
    "p3": "value3",
    *[Symbol.iterator]() {
        yield *Object.keys(this);
    }
};

[...p] //["p1", "p2", "p3"]

, который уведомит их о том, что это расширение для конкретной компании / приложения.

for(var key in p) {
    console.log(key);
}

Но важно знать, какие возможности у вас сейчас есть, используя es6!

, я бы сделал это вместо того, чтобы проверять obj.hasOwnerProperty и для ключей (все уже отвечено) передо мной) for ... in.

var obj = {a : 1};
for(var key in obj){
    //obj.hasOwnProperty(key) is not needed.
    console.log(key);
}
//then check if anybody has messed the native object. Put this code at the end of the page.
for(var key in Object){
    throw new Error("Please don't extend the native object");
}

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

let arrValues = Object.values( yourObject) ;

, он возвращает массив значений объекта и не извлекает значения из Prototype !!

MDN DOCS Object.values ​​()

arrayObjects с условием

let arrKeys   = Object.keys(yourObject);

вариант расслабления по этой причине. неперечислимые свойства , вы можете использовать Object.getOwnPropertyNames(obj) Получается так:

var obj = Object.create({}, {
  // non-enumerable property
  getFoo: {
    value: function() { return this.foo; },
    enumerable: false
  }
});

obj.foo = 1; // enumerable property

Object.getOwnPropertyNames(obj).forEach(function (name) {
  document.write(name   ': '   obj[name]   '<br/>');
});

Если кому-то нужно пройтись по наименьшему фрагменту кода Получить все ключи объекта. используя Object.keys. Этот метод возвращает массив собственных перечисляемых свойств данного объекта. :

var arrayObjects = [{"building":"A", "status":"good"},{"building":"B","status":"horrible"}];

for (var i=0; i< arrayObjects.length; i  ) {
  console.log(arrayObjects[i]);
  
  for(key in arrayObjects[i]) {      
    
      if (key == "status" && arrayObjects[i][key] == "good") {
        
          console.log(key   "->"   arrayObjects[i][key]);
      }else{
          console.log("nothing found");
      }
   }
}

Возвращает: вс, 25 декабря 2016 г., 15:00

Object.entries(p);

Object.entries():

var p = {
	    "p1": "value1",
	    "p2": "value2",
	    "p3": "value3"
	};

for (var i in Object.entries(p)){
	var key = Object.entries(p)[i][0];
	var value = Object.entries(p)[i][1];
	console.log('key[' i ']=' key ' ' 'value[' i ']=' value);
}

Извините, я не был ясен. Мне нужно решение, которое изменяет расположение браузера, как при отправке формы. Если это возможно с помощью

Шаг 1. Вот ссылка на оригинальный пост.

Шаг 2. Создать пустой массив. Это то место, где будут жить все свойства, так как ваш новый цикл ngFor будет указывать на этот массив, мы должны перехватить их все. Шаг 3. Iterate, генерируют все ключи и помещают каждую из них в созданный вами массив. Вот как это выглядит в коде.

    // Evil response in a variable. Here are all my vehicles.
let evilResponse = { 
  "car" : 
    { 
       "color" : "red",
       "model" : "2013"
    },
   "motorcycle": 
    { 
       "color" : "red",
       "model" : "2016"
    },
   "bicycle": 
    { 
       "color" : "red",
       "model" : "2011"
    }
}
// Step 1. Get all the object keys.
let evilResponseProps = Object.keys(evilResponse);
// Step 2. Create an empty array.
let goodResponse = [];
// Step 3. Iterate throw all keys.
for (prop of evilResponseProps) { 
    goodResponse.push(evilResponseProps[prop]);
}

Объект становится итератором, когда он реализует метод .next () https://medium.com/@papaponmx/looping -over-object-properties-with-ngfor-in-angular-869cd7b2ddcc

Я иногда использую это для быстрого тестирования всех функций на объектах с простыми входами и выходами.

const james = {
name: 'James',
height: `5'10"`,
weight: 185,

[Symbol.iterator]() {
let properties = []
for (let key of Object.keys(james)){
     properties.push(key);
 }

index = 0;
return {
        next: () => {
            let key = properties[index];
            let value = this[key];
            let done = index >= properties.length - 1 ;
            index  ;
            return { key, value, done };
        }
    };
  }

};


const iterator = james[Symbol.iterator]();

console.log(iterator.next().value); // 'James'
console.log(iterator.next().value); // `5'10`
console.log(iterator.next().value); // 185

, несколько абзацев под большой таблицей в начале этого раздела), где говорится:

Это не похоже на работу с jQuery. Когда я проверяю EventListener, я вижу, что обратный вызов —

var p = {
    "p1": "value1",
    "p2": "value2",
    "p3": "value3"
};

Теперь я хочу просмотреть все p (p1, p2, p3 …) И получить их ключи и значения. Как я могу это сделать?

Я могу изменить объект JavaScript, если это необходимо. Моя конечная цель состоит в том, чтобы пройтись по нескольким парам ключ-значение, и, если возможно, я хочу избежать использования eval Глядя на вывод

В любом из ваших javascript, вызываемых на странице, просто вызывайте эти переменные.

<body>
<script>
function createTable(objectArray, fields, fieldTitles) {
  let body = document.getElementsByTagName('body')[0];
  let tbl = document.createElement('table');
  let thead = document.createElement('thead');
  let thr = document.createElement('tr');

  for (p in objectArray[0]){
    let th = document.createElement('th');
    th.appendChild(document.createTextNode(p));
    thr.appendChild(th);
    
  }
 
  thead.appendChild(thr);
  tbl.appendChild(thead);

  let tbdy = document.createElement('tbody');
  let tr = document.createElement('tr');
  objectArray.forEach((object) => {
    let n = 0;
    let tr = document.createElement('tr');
    for (p in objectArray[0]){
      var td = document.createElement('td');
      td.appendChild(document.createTextNode(object[p]));
      tr.appendChild(td);
      n  ;
    };
    tbdy.appendChild(tr);    
  });
  tbl.appendChild(tbdy);
  body.appendChild(tbl)
  return tbl;
}

createTable([
              {name: 'Banana', price: '3.04'}, // k[0]
              {name: 'Orange', price: '2.56'},  // k[1]
              {name: 'Apple', price: '1.45'}
           ])
</script>

На самом деле мое расширение chrome Object.getOwnPropertyNames (obj)

for (let o of Object.getOwnPropertyNames(Math)) {
  console.log(o);
}

высокая совместимость с браузерами

  • отступ одного уровня
  • один набор скобок
  • Надеюсь, это кому-нибудь поможет.
  • hasOwnProperty safe
var p = {"p1": "value1", "p2": "value2", "p3": "value3"};

for (var key in p) if (p.hasOwnProperty(key)) {
  var value = p[key];
  console.log(key, value);
}

Начиная с ES2015, вы можете использовать цикл for, для прямого доступа к элементу:

// before ES2015
for(var key of elements){
  console.log(elements[key]);
}


// ES2015
for(let element of elements){
  console.log(element);
}

Почему работает следующее? & # xA ; & # xA ; & Amp {*** } lt ; что-то & amp ; gt ;. stop (). animate (& # xA ; {‘top ‘: 10}, 10 & # xA ;) ; & # xD ; & # xA ; Хотя это не работает: & # xA ; & # xA ; var thetop = ‘top’ ; & # xA ; & amp ; lt ; что-то & amp ; gt ;. stop (). animate (& # xA ; {thetop: 10}, 10 & # xA ; …

пользователей с сценария для загрузки при прокрутке равен просто 1 (

var p ={"p1":"value1","p2":"value2","p3":"value3"};
if('p1' in p){
  var val=p['p1'];
  ...
}
Понравилась статья? Поделиться с друзьями:
JavaScript & TypeScript
Adblock
detector