I have a javascript 객체여야 다음과 같습니다.
var p = {
"p1": "value1",
"p2": "value2",
"p3": "value3"
};
이제 모든 요소를 반복하고 싶다 'p' ('p1', 'p2', 'p3'). 가서 자신의 키와 값을. 그렇게 할 수 있습니까?
내가 필요한 경우 javascript 객체여야 수정할 수 있습니다. 내가 원하는 일부 키 값 쌍이 나의 궁극적인 목표는 반복하고, 가능하면 사용하지 않는 것이 '평가'.
대한 인 '반복' 다른 사람이 같이 사용할 수 있습니다. 그러나 여러분은 있는지 확인하기 위해 주요 확보하십시오 doesn&, t come from # 39 는 객체의 실제 등록 및 원형 (prototype).
var p = {
"p1": "value1",
"p2": "value2",
"p3": "value3"
};
for (var key in p) {
if (p.hasOwnProperty(key)) {
console.log(key + " -> " + p[key]);
}
}
끝 - < 스니핏 >;!
<! - begin 스니핏: js 숨기십시오: 거짓값 콘솔: 진정한 바벨. > 거짓값 -;
var p = {
0: "value1",
"b": "value2",
key: "value3"
};
for (var key of Object.keys(p)) {
console.log(key + " -> " + p[key])
}
끝 - < 스니핏 >;!
'위한' 디이브이 사용할 경우 it 에 대한 인 사용하지 않는 대신 ',' 라는 속성 및 로비치스키스 () 은 정의되지 않은 반환되므로 사용하지 않고, 오직 object& # 39 의 고유한 속성 속성 전체 프로토타입 체인
Ecmascript) 에서 5 결합할 수 있습니다 '로비치스키스 ()' 및 '아리스프로토티페스포리치 ()':
var obj = { first: "John", last: "Doe" };
Object.keys(obj).forEach(function(key) {
console.log(key, obj[key]);
});
ECMAScript 6 자도으로 ['퍼트로프'] (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for.of):
for (const key of Object.keys(obj)) {
console.log(key, obj[key]);
}
ECMAScript 8 자도으로 '오브ject.렌트리스 ()' 의 기피하고 있는 조회할 수 있어 각 값마다 원래 오브젝트도:
Object.entries(obj).forEach(
([key, value]) => console.log(key, value)
);
',', '와' 오브ject.렌트리스 데스트루스튜링 퍼트로프 결합할 수 있습니다.
for (const [key, value] of Object.entries(obj)) {
console.log(key, value);
}
로비치스키스 오브ject.렌트리스 () 는 모두 ' ()' 와 'a' for.in '속성' 같은 순서로 루프 그러나 무시하시겠습니까 프로토타입 체인 . # 39 의 고유한 속성, 열거 object& 만 이터레이션됩니다.
이 때문에 매우 신중해야 한다고 하지만, 이러한 종류의 루프 (loop) 는 모든 함께 속성을 사용할 때 프로토타입 체인을 .
따라서 대한 인 루프, 항상 사용할 때 활용할 수 있는지 여부를 결정할 수 있는 방법을 사용하면 현재 등록 정보 '진짜' 해스운프로페티 이터레이션은 재산에 대한 확인 you& 객체에는 # 39, re:
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
}
만약 우리가 don& # 39, t, t # 39 won& 완료해야 하는 얘기는 전혀 다른 방법을 통해 루프을 객체에는.
요즘 많은 방법을 통해 자신의 컬렉션을 통해 잘 알려진 자바스크립트 라이브러리는 반복, 및 객체에는, 즉 어레이를 같은 어레이입니다 객체에는. 이러한 방식이 완전히 호환됩니까 편리하게 사용할 수 있으며 어떤 브라우저를.
$ 그레이크 (obj, 함수 (키 값) { 콘솔드로그 (key, 값). }).
_.each (obj, 함수 (가치, 키) { 콘솔드로그 (key, 값). }).
_.forIn (obj, 함수 (가치, 키) { 콘솔드로그 (key, 값). }).
일반적으로 모든 설명됨 방법이 동일한 동작 없이 객체에는 공급했다. 빠른 토종 'for.in' 루프는 일반적으로 사용하는 것 외에 어떤 경쟁업체보다도 추상화 같은 수 () ',' 이케리드레이크 이러한 방식이 매우 쉽게 사용할 수 있는 코딩 제공하십시오 소비량이 더 나은 오류 처리.
[2]: http://underscorejs.org/ # 각 [3]: http://lodash.com/docs # 포리치 [4]: http://lodash.com/docs # 프로린 [5]: http://lodash.com/docs # 포운
Ecma 스크립트 '-' 에서 5 의 새로운 분야에 이터레이션에 ipv6-literal. 로비치스키스 외곽진입 합니다.
자세한 내용은 [매든] [6] 에서 볼 수 있습니다
내 선택은 아래 빠른 솔루션을 최신 브라우저 (, FF25 Chrome30 IE10)
var keys = Object.keys(p),
len = keys.length,
i = 0,
prop,
value;
while (i < len) {
prop = keys[i];
value = p[prop];
i += 1;
}
이 방식은 다른 구현을 통해 성능을 비교할 수 있는 jsperf.com:
브라우저 지원 [Kangax& # 39 의 호환성 표] [4] 에서 볼 수 있습니다
늙은 일반 및 [전체] [6] 있지만브라우저에 폴리필 합니다.
'perfjs.info' 이 건에 대해 질문을 가장 많이 사용되는 모든 성능 비교:
[객체에는 ipv6-literal. 이터레이션에] [8]
[3] :http://jsperf.com/object-keys-iteration/30
[6] :https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys [7] :http://jsperf.com/object-literal-iteration/5 [8] /384a61ca-da2e-4fd2-a113-080010d4a42b: http://perfjs.info/ #!
서론:
2018년 이곳에서 너회의 옵션을 통해 루프을 object& # 39 의 특성은 (따라 몇 가지 예를 들면 목록):
D ',' 함께 모두야 아니했노라 대한 인 you& # 39 를 사용하여 chunghwa 루프을 함정이거나 어레이입니다 ('는', '위한', '포리치' 등).
예를 들면 다음과 같다:
<! - begin 스니핏: js 숨기십시오: 진정한 콘솔: 진정한 바벨. > 거짓값 -;
// 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}`);
}
끝 - < 스니핏 >;!
<! - begin 스니핏: js 숨기십시오: 진정한 콘솔: 진정한 바벨. > 거짓값 -;
// 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}`);
}
끝 - < 스니핏 >;!
<! - begin 스니핏: js 숨기십시오: 진정한 콘솔: 진정한 바벨. > 거짓값 -;
// 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}`);
}
끝 - < 스니핏 >;!
<! - begin 스니핏: js 숨기십시오: 진정한 콘솔: 진정한 바벨. > 거짓값 -;
// 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}`);
}
끝 - < 스니핏 >;!
<! - begin 스니핏: js 숨기십시오: 진정한 콘솔: 진정한 바벨. > 거짓값 -;
// 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}`);
}
끝 - < 스니핏 >;!
<! - begin 스니핏: js 숨기십시오: 진정한 콘솔: 진정한 바벨. > 거짓값 -;
// 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}`);
}
끝 - < 스니핏 >;!
<! - begin 스니핏: js 숨기십시오: 진정한 콘솔: 진정한 바벨. > 거짓값 -;
// 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}`);
}
끝 - < 스니핏 >;!
, 모든 속성 등 비사양 열거 상속됨 수준들과:
<! - begin 스니핏: js 숨기십시오: 진정한 콘솔: 진정한 바벨. > 거짓값 -;
// 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;
}
끝 - < 스니핏 >;!
[2]: https://tc39.github.io/ecma262/ # 미국 증권거래위원회 (sec) 에 대해, 그리고 문
[4]: https://tc39.github.io/ecma262/ # sec-object.keys
[6]: https://tc39.github.io/ecma262/ # sec-object.values
[8]: https://tc39.github.io/ecma262/ # sec-object.entries
[10]: https://tc39.github.io/ecma262/ # sec-object.getownpropertynames
[12): https://tc39.github.io/ecma262/ # sec-object.getownpropertysymbols
[14]: https://tc39.github.io/ecma262/ # sec-reflect.ownkeys
[16]: https://tc39.github.io/ecma262/ # sec-object.getprototypeof
이 때문에 점점 더 많이 나는 이 글을 es2015 오토메이티드 사용을 포함하는 발생기입니다 및 반복자가 부드럽게 회전하려면 반복할 ' [키, 가치]' 쌍. 예를 들어 있기 때문에 가능한 다른 언어로 루비.
여기서 확인을 는 코드:
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}`);
}
할 수 있는 방법에 대한 모든 정보를 반복자가 및 발생기입니다 http://support. 개발자 mizilla 호출이네요 찾을 수 있습니다.
희망을 사람에게 도움이 됐다는 것입니다.
이를 통해 '반복' 에는 '오브ject.렌트리스 es2017 발쿰치로 [키 값을]' 쌍으로 객체에는 더욱 간편해집니다. 이는 지금까지 알려진 것 ts39 에 따르면 일부 표준 스태이징할 정보.
내가 생각하는 것보다 훨씬 더 많은 시간이 내 것이 될 수 있는 최신 업데이트하려면 it& # 39, s now let it 되었다.
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}`);
}
사용) 에 대해 더 많이 찾을 수 있습니다. 매든 페이지
for (var key in p) {
console.log(key + ' => ' + p[key]);
// key is key
// value is p[key]
}
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
<! - 모든 언어: lang-js->.
var map = {well:'hello', there:'!'};
for (let key of Object.keys(map))
console.log(key + ':' + map[key]);
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);
그래서 내 long as you 포함시키십시오 심 (아래 참조).
//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& # 39 의 다른 기능 (시밍 없이 그들을 모두) 그래도 그들이성년에 사용할 수 있기 때문에 이제 이트레이블 이제 그냥 깔끔한 객체에는 표기법 (make a 로부터 맵을 객체에는 it!
//shown in demo
var realMap = new Map({well:'hello', there:'!'});
//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;
}
이제 그냥 평범한 함수 호출, 영향을 받는 정보기술 (it) 을 아무것도아니야 아무도요
var realMap = new Map(getObjIterator({well:'hello', there:'!'}))
또는
for (let pair of getObjIterator(ordinaryObject))
[There& # 39 에 있는 이유도 wouldn& # 39, 빗나갔다.] (
)Welcome to the future.
다음은 또 다른 방법은 객체를 반복할 수 있습니다.
<! - begin 스니핏: js 숨기십시오: 거짓값 콘솔: 진정한 바벨. > 거짓값 -;
<! - 언어: > js 랭 -;
var p = { p1" ";: " value1"; p2" ";: " value2"; p3" ";: " value3"; };
로비치스키스 (p) 스포리치 (키 = >. {콘솔드로그 (key, p [] 키를)})
끝 - < 스니핏 >;!
>. 로비치스키스 (목표): Array< string>;
>. 모든 소중한 구체화하십시오 키 (비 상속) 모든 열거 읽어들입니다 İç 이다.
따라서 동일한 키를 키로 해스운프로페티 테스트를 통해 각 객체에는 보기입니다 목록니다 생각이 있습니다. # 39 더 이상 시험 운영에 필요한 너회가 don& 스포리치 로비치스키스 (목표), t (함수 (키) {}) '와' 더 빠른 것으로 돼 있다. # 39 의 let& 입증할 수 있다.
<! - begin 스니핏: js 숨기십시오: > 거짓값 -;
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 다음과 같은 결과가
밀리초입니다. 40.21101451665163 - 로비치스키스 외곽진입 있었다.
크롬 (http://codepen.io/dsheiko/pen/JdrqXa) 에서 ps. 더욱 큰 차이
PS2: 2015년 의 ES6 (EcmaScript) 이트레이블 괜찮게 객체에는 반복할 수 있습니다.
<! - begin 스니핏: js 숨기십시오: > 거짓값 -;
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);
});
끝 - < 스니핏 >;!
<! - begin 스니핏: js 숨기십시오: 거짓값 콘솔: 진정한 바벨. > 거짓값 -;
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>
끝 - < 스니핏 >;!
이 방법 () ',' 로비치스키스 배열입니다 # 39 의 고유한 열거 되돌려줍니다 주어진 object& 이다. 이에 대한 자세한 내용은 here
<! - begin 스니핏: js 숨기십시오: 거짓값 콘솔: 진정한 바벨. > 거짓값 -;
var p = {
"p1": "value1",
"p2": "value2",
"p3": "value3"
};
Object.keys(p).map((key)=> console.log(key + "->" + p[key]))
끝 - < 스니핏 >;!
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
});
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);
});
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 불과한 것으로 보인다 (새로운 2015년 JavaScript 사양명세) attaboy 루프가 go-dell 제어입니다. # 39 m 로, 이 글을 쓰는 죄송합니다. I& 브라우저 및 통합 개발 환경 (IDE) 은 모두 지원할 수 있는 새로운 종을 완전히 벗어나지 못하고 있으며 걸.
전에 어떤 ECMA6 at-a-glance 슬라이드에서는 JavaScript 객체로 루프 것 같습니다.
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;
}
}
또한 이 범위 밖에 있는 ECMAScript 5.1 그러니까말이야 추가했어야 포리치 '방법' 이 질문을 하지만 2011년 만들어진 반복하고 있는 새로운 방법을 스토리지에만 기본적으로 향산된 동시에 "에 대한 자세한 정보 및 이전 어레이에는 것가운데 비사양 이트레이블 객체에는 루프지 것이다 ' 그러나 이 사실은 '방법' 브레이크 '새' 포리치 홀수입니다 지원하지 않는 모든 신규인지 주도한 다른 문제.
2011년, 실제 솔리드로 기본적으로 다른 방법이 없는 것보다 루프 JavaScript 로 널리 사용되는 라이브러리 (jQuery, 밑줄 등) 을 다시 구현 했다.
2015년 기준으로, 이제 더 좋은 방법은 바로 루프 () 와 브레이크 (break) 모든 개체 유형 (등 시스템 및 문장열). 다음은 주요 권장안을 때 JavaScript 에서 결국 어떤 루프 같이 됩니다.
for (let [key, value] of Object.entries(object)) {
console.log(key); // This is the key;
console.log(value); // This is the value;
}
단, t 지원, 2016년 18일 6월 현재 대부분의 브라우저에서 won& # 39 위 코드는. 심지어 이 특별한 국기를 활성화하십시오 크롬 할 때 사용할 수 있습니다. # javascript 활성화하십시오 조화 chrome://flags/ ''
이 새로운 표준이 될 때까지 계속 사용할 수 있는 대안을 수축됐는데 이전 방법 또한 널리 사용되는 라이브러리 또는 심지어 가벼운 대안을 # 39, 이러한 라이브러리를 사용하는 사람들을 위한 aren& 없다.