ฉันจะวนซ้ำหรือระบุวัตถุ JavaScript ได้อย่างไร


2877

ฉันมีวัตถุ JavaScript ดังต่อไปนี้:

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

ตอนนี้ผมต้องการที่จะห่วงผ่านทุกpองค์ประกอบ ( p1, p2,p3 ... ) และได้รับคีย์และค่าของพวกเขา ฉันจะทำสิ่งนั้นได้อย่างไร

ฉันสามารถแก้ไขวัตถุ JavaScript ได้ถ้าจำเป็น evalเป้าหมายสูงสุดของผมคือการห่วงผ่านบางคู่ค่าที่สำคัญและถ้าเป็นไปได้ผมอยากจะหลีกเลี่ยงการใช้


9
ฉันเปลี่ยน JSON เป็น JavaScript (object) เพื่อหลีกเลี่ยงความสับสนของตัวอักษรวัตถุและ JSON
เฟลิกซ์คลิง

คำตอบ:


4365

คุณสามารถใช้ for-inวนซ้ำตามที่แสดงโดยผู้อื่น อย่างไรก็ตามคุณต้องให้แน่ใจว่ากุญแจที่คุณได้รับนั้นเป็นสมบัติที่แท้จริงของวัตถุและไม่ได้มาจากต้นแบบ

นี่คือตัวอย่าง:

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

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

For-of with Object.keys () ทางเลือก:

var p = {
    0: "value1",
    "b": "value2",
    key: "value3"
};

for (var key of Object.keys(p)) {
    console.log(key + " -> " + p[key])
}

สังเกตการใช้for-ofแทนfor-inถ้าไม่ได้ใช้มันจะส่งคืนไม่ได้กำหนดคุณสมบัติที่มีชื่อและObject.keys()ทำให้มั่นใจได้ว่าการใช้คุณสมบัติของวัตถุเท่านั้นโดยไม่ต้องมีคุณสมบัติต้นแบบโซ่ทั้งหมด

ใช้Object.entries()วิธีการใหม่:

หมายเหตุ:วิธีนี้ไม่ได้รับการสนับสนุนโดย Internet Explorer คุณอาจพิจารณาใช้ Polyfill สำหรับเบราว์เซอร์รุ่นเก่า

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

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

34
จะเสนอให้คุณเปลี่ยนสายการแจ้งเตือนเพื่อความชัดเจนalert(key + " -> " + JSON.stringify(p[key]));
Steve Midgley

80
คุณช่วยอธิบายถึงความจำเป็นในการ hasOwnProperty ได้ไหม? ต้นแบบหมายถึงอะไร
kamaci

331
ใน javascript วัตถุทุกชิ้นมีคู่ของคีย์ - ค่าในตัวที่มีข้อมูลเมตา เมื่อคุณวนลูปผ่านคู่คีย์ - ค่าทั้งหมดสำหรับวัตถุที่คุณกำลังลูปมันด้วย hasOwnPropery () กรองสิ่งเหล่านี้ออก
danieltalsky

57
ที่จริงแล้วสำหรับ ... ในไม่ได้ถูกปฏิเสธ สำหรับแต่ละ ... ในคือ แต่ฉันชอบนักโบราณคดีคำจริงๆ... ฉันจะต้องเริ่มใช้มัน
Ben Y

17
วัตถุในจาวาสคริปต์ (ที่จริงคู่ค่าคีย์) แต่ละคนมีคุณสมบัติที่เรียกว่าหรือ__proto__ prototypeคุณสมบัตินี้มีการอ้างอิงถึงวัตถุแม่ วัตถุจะสืบทอดคุณสมบัติโดยอัตโนมัติจากพาเรนต์ นี่คือเหตุผลของการใช้hasOwnPropertyซึ่งบ่งบอกว่าเราสนใจวัตถุของตัวเองไม่ใช่วัตถุหลัก
Zubair Alam

1104

ภายใต้ ECMAScript 5 คุณสามารถรวม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ห่วงแต่ไม่สนใจห่วงโซ่ต้นแบบ เฉพาะคุณสมบัติที่นับได้ของวัตถุเท่านั้นที่ทำซ้ำ


21
ทำไมมาตรฐานObject.forEach(obj, function (value, key) {...})ไม่ให้ :( แน่นอนobj.forEach(function...)จะสั้นกว่าและสมบูรณ์Array.prototype.forEachแต่ที่จะมีความเสี่ยงวัตถุกำหนดตัวเองforEachคุณสมบัติฉันคิดว่า. Object.keysป้องกันการโทรกลับปรับเปลี่ยนคีย์ของวัตถุ.
เดวิด Harkness

7
Object.forEach = function (obj, callback) { Object.keys(obj).forEach(function (key) { callback(obj[key], key); }); }
David Harkness

7
@DavidHarkness มี Object.entries ใน ES2017 คุณสามารถทำสิ่งต่อไปนี้ได้: Object.entries(obj).map/forEach(([key, value]) => console.log(key, value))([key, value] คือการทำลายอาร์เรย์เพื่อเข้าถึงทั้งสองรายการโดยตรงและคุณต้องใส่พารามิเตอร์ใน parens เพิ่มเติม)
Andreas Linnert

ฉันจะรับindexคีย์ใน json ได้อย่างไร หรือถ้าจำเป็นฉันควรใช้ตัวแยกต่างหาก?
Saravanabalagi Ramachandran

3
for...ofเป็นมาตรฐาน ES6 ไม่ใช่ ES2016
Rax Weber

342

คุณต้องใช้วงใน

แต่ต้องระวังมากเมื่อใช้ชนิดของวงนี้เพราะนี้จะห่วงทุกคุณสมบัติตามห่วงโซ่ต้นแบบ

ดังนั้นเมื่อใช้ for-in loops ให้ใช้hasOwnPropertyวิธีการเพื่อตรวจสอบว่าคุณสมบัติปัจจุบันในการวนซ้ำเป็นคุณสมบัติของวัตถุที่คุณกำลังตรวจสอบอยู่หรือไม่:

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
}

31
สิ่งนี้ดีกว่าโซลูชันของ levik เพราะมันช่วยให้ตรรกะหลักเป็นเพียงลูปซ้อนในหนึ่งแทนที่จะเป็นสอง ทำให้อ่านรหัสได้ง่ายขึ้น แม้ว่าฉันจะทำวงเล็บในรอบต่อไป พวกเขาฟุ่มเฟือย
SystemicPlural

52
ฉันจะไม่ลบ{ }บุคคลเป็นการส่วนตัวเพราะifหากไม่มีพวกเขาทำให้มันไม่ชัดเจนว่าเป็นส่วนหนึ่งของifอะไรและไม่ใช่อะไร แต่ฉันเดาว่ามันเป็นแค่เรื่องของความเห็น :)
pimvdb

34
ใช่ฉันชอบเก็บเป็น{ }หลักเพื่อหลีกเลี่ยงความสับสนหากภายหลังจำเป็นต้องเพิ่มบางสิ่งลงในifขอบเขต
Andreas Grech

8
การอ่านความคิดเห็นก่อนหน้าของฉันฉันรู้ว่าฉันไม่ได้ใช้คำศัพท์ที่ถูกต้องเพราะฉันพูดว่า "if scope"; แต่โปรดทราบว่า JavaScript มีขอบเขตฟังก์ชั่นเท่านั้น ดังนั้นสิ่งที่ฉันหมายถึงจริง ๆ ก็คือ "ถ้าบล็อก"
Andreas Grech

1
eomeroff หากคุณเป็นห่วงคุณสามารถทำสิ่งต่าง ๆ ได้เช่น: Object.prototype.hasOwnProperty.call(p, prop) อย่างไรก็ตามสิ่งนี้ก็ไม่สามารถป้องกันการ
โกง

252

คำถามจะไม่สมบูรณ์หากเราไม่พูดถึงวิธีการอื่นในการวนลูปผ่านวัตถุ

ที่รู้จักกันดีในปัจจุบันห้องสมุด JavaScript หลายแห่งที่มีวิธีการของตัวเองสำหรับวนกว่าคอลเลกชันคือมากกว่าอาร์เรย์ , วัตถุและอาร์เรย์เหมือนวัตถุ วิธีการเหล่านี้สะดวกในการใช้และเข้ากันได้กับเบราว์เซอร์ใด ๆ

  1. หากคุณทำงานกับjQueryคุณอาจใช้jQuery.each()วิธีการ มันสามารถใช้ในการวนซ้ำอย่างต่อเนื่องทั้งวัตถุและอาร์เรย์:

    $.each(obj, function(key, value) {
        console.log(key, value);
    });
  2. ในUnderscore.jsคุณสามารถค้นหาวิธี_.each()ที่วนซ้ำรายการองค์ประกอบโดยให้แต่ละฟังก์ชันเป็นฟังก์ชันที่ให้มา (ให้ความสนใจกับลำดับของอาร์กิวเมนต์ในฟังก์ชันiteratee !):

    _.each(obj, function(value, key) {
        console.log(key, value);
    });
  3. Lo-Dashมีหลายวิธีสำหรับการวนซ้ำคุณสมบัติวัตถุ พื้นฐาน_.forEach()(หรือมันนามแฝง_.each()(!)) จะเป็นประโยชน์สำหรับการวนลูปทั้งวัตถุและอาร์เรย์ แต่วัตถุที่มีlengthคุณสมบัติได้รับการปฏิบัติเช่นอาร์เรย์และเพื่อหลีกเลี่ยงพฤติกรรมนี้ก็จะแนะนำให้ใช้_.forIn()และ_.forOwn()วิธีการ (เหล่านี้ยังมีvalueข้อโต้แย้งมาครั้งแรก):

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

    _.forIn()iterates มากกว่าตัวเองและได้รับการถ่ายทอดคุณสมบัตินับของวัตถุในขณะที่_.forOwn()iterates เพียงกว่าตัวเองคุณสมบัติของวัตถุ (โดยทั่วไปการตรวจสอบกับhasOwnPropertyฟังก์ชั่น) สำหรับวัตถุอย่างง่ายและตัวอักษรวัตถุใด ๆ วิธีการเหล่านี้จะทำงานได้ดี

โดยทั่วไปวิธีการที่อธิบายไว้ทั้งหมดจะมีพฤติกรรมเดียวกันกับวัตถุใด ๆ ที่ให้มา นอกจากการใช้การfor..inวนซ้ำดั้งเดิมจะเร็วกว่าสิ่งที่เป็นนามธรรมเช่นjQuery.each()วิธีการเหล่านี้ใช้งานง่ายกว่ามากต้องใช้การเข้ารหัสน้อยกว่าและให้การจัดการข้อผิดพลาดที่ดีขึ้น


4
ในการรับค่า: $ .each (obj, function (key, value) {console.log (value.title);});
Ravi Ram

2
เพียงแค่ตลกว่าขีดและพารามิเตอร์ jQuery เปลี่ยนแปลง :)
ppasler

52

ใน ECMAScript 5 คุณมีวิธีการใหม่ในการวนซ้ำของตัวอักษร - Object.keys

ข้อมูลเพิ่มเติมที่คุณสามารถเห็นได้บนMDN

ตัวเลือกของฉันด้านล่างเป็นโซลูชันที่เร็วกว่าสำหรับเบราว์เซอร์รุ่นปัจจุบัน (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;
}

คุณสามารถเปรียบเทียบประสิทธิภาพของวิธีนี้กับการใช้งานที่แตกต่างกันบนjsperf.com :

การสนับสนุนเบราว์เซอร์ที่คุณเห็น โต๊ะรองรับของ Kangax

สำหรับเบราว์เซอร์เก่าที่คุณมีที่เรียบง่ายและเต็ม polyfill

UPD:

การเปรียบเทียบประสิทธิภาพสำหรับกรณียอดนิยมทั้งหมดในคำถามนี้ที่ perfjs.info :

การทำซ้ำวัตถุตามตัวอักษร


แน่นอนฉันต้องการโพสต์วิธีนี้ แต่คุณเอาชนะฉันได้ :(
เจมี่ฮัทเบอร์

50

คำนำ:

  • คุณสมบัติของวัตถุสามารถเป็นของตัวเอง (คุณสมบัติอยู่ในวัตถุเอง) หรือสืบทอด (ไม่ได้อยู่ที่ตัววัตถุเองบนต้นแบบตัวใดตัวหนึ่ง)
  • คุณสมบัติของวัตถุสามารถนับได้หรือไม่นับได้ได้ คุณสมบัติที่ไม่นับได้ถูกปล่อยออกจากการแจกแจง / อาร์เรย์คุณสมบัติมากมาย
  • ชื่อคุณสมบัติสามารถเป็นสตริงหรือสัญลักษณ์ คุณสมบัติที่มีชื่อเป็นสัญลักษณ์จะถูกปล่อยออกจากการแจกแจง / อาร์เรย์คุณสมบัติมากมาย

ที่นี่ในปี 2018 ตัวเลือกของคุณสำหรับการวนลูปผ่านคุณสมบัติของวัตถุคือ (ตัวอย่างบางรายการติดตามรายการ):

  1. for-in[ MDN , spec ] - โครงสร้างลูปที่วนซ้ำตามชื่อของคุณสมบัติที่นับได้ของวัตถุรวมถึงอันที่สืบทอดมาซึ่งมีชื่อเป็นสตริง
  2. Object.keys[ MDN , สเป็ค ] - ฟังก์ชั่นให้อาร์เรย์ของชื่อของวัตถุด้วยตัวเอง , นับคุณสมบัติที่มีชื่อสตริง
  3. Object.values[ MDN , สเป็ค ] - ฟังก์ชั่นให้อาร์เรย์ของที่ค่าของวัตถุเอง , นับคุณสมบัติ
  4. Object.entries[ MDN , สเป็ค ] - ฟังก์ชั่นให้อาร์เรย์ของชื่อที่และค่านิยมของวัตถุเอง , นับคุณสมบัติ (แต่ละรายการในอาร์เรย์เป็น[name, value]อาร์เรย์)
  5. Object.getOwnPropertyNames[ MDN , สเป็ค ] - ฟังก์ชั่นให้อาร์เรย์ของชื่อของวัตถุนั้นเองคุณสมบัติ (แม้แต่คนที่ไม่ได้นับ) ที่มีชื่อสตริง
  6. Object.getOwnPropertySymbols[ MDN , สเป็ค ] - ฟังก์ชั่นให้อาร์เรย์ของชื่อของวัตถุนั้นเองคุณสมบัติ (แม้แต่คนที่ไม่ได้นับ) ที่มีชื่อสัญลักษณ์
  7. Reflect.ownKeys[ MDN , สเป็ค ] - ฟังก์ชั่นให้อาร์เรย์ของชื่อของวัตถุที่ตัวเองคุณสมบัติ (แม้แต่คนที่ไม่ได้นับ) ไม่ว่าจะเป็นชื่อผู้ที่มีสายหรือสัญลักษณ์
  8. หากคุณต้องการทั้งหมดของคุณสมบัติของวัตถุรวมทั้งคนที่ได้รับมรดกที่ไม่นับคุณจะต้องใช้ห่วงและObject.getPrototypeOf[ MDN , สเป็ค ] และการใช้งานObject.getOwnPropertyNames, Object.getOwnPropertySymbolsหรือReflect.ownKeysในแต่ละวัตถุในห่วงโซ่ต้นแบบ (ตัวอย่างเช่นที่ด้านล่างของคำตอบนี้)

กับทุกคนยกเว้นfor-inคุณจะใช้ประเภทของบ่วงสร้างบางอย่างเกี่ยวกับอาร์เรย์ ( for, for-of, forEachฯลฯ )

ตัวอย่าง:

for-in:

Object.keys (กับfor-ofวง แต่คุณสามารถใช้โครงสร้างลูปใด ๆ ) :

Object.values:

Object.entries:

Object.getOwnPropertyNames:

Object.getOwnPropertySymbols:

Reflect.ownKeys:

คุณสมบัติทั้งหมดรวมถึงคุณสมบัติที่ไม่สามารถสืบทอดได้:


นอกจากนี้ยังมีคุณสมบัติของวัตถุที่นับได้ / ไม่สามารถทำงานร่วมกันได้ดี
serraosays

49

คุณสามารถทำซ้ำได้มากกว่าเช่น:

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

โปรดทราบว่าkeyจะไม่ใช้กับมูลค่าของทรัพย์สินเป็นเพียงค่าดัชนี


13
สิ่งนี้ซ้ำแล้วซ้ำอีกและยังไม่ถูกต้องทั้งหมด คุณจำเป็นต้องมีการตรวจสอบของ hasOwnProperty เพื่อให้งานนี้ถูกต้อง
Vatsal

4
ตอนแรกฉันลงคะแนนนี้ตามความคิดเห็นข้างต้นจนกระทั่งฉันรู้ว่าคำตอบนี้มาก่อนดังนั้นจึงไม่ "ซ้ำ" มันอาจจะไม่สมบูรณ์ แต่ใช้งานได้ดีสำหรับหลายกรณี
billynoah

27

เนื่องจาก 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

หวังว่ามันช่วยใครบางคน

แก้ไข:

ES2017 จะรวมถึงการObject.entriesทำซ้ำใน[key, value]คู่ของวัตถุได้ง่ายยิ่งขึ้น ตอนนี้เป็นที่ทราบกันแล้วว่ามันจะเป็นส่วนหนึ่งของมาตรฐานตาม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


มันดูไม่จำเป็นเลยสำหรับฉัน คุณจะเพิ่มมันลงในทุกวัตถุในระบบของคุณหรือไม่? ฉันคิดว่าจุดของการให้ตัววนซ้ำเป็นไปได้เพื่อที่คุณจะสามารถทำเพื่อ (const [k, v] ของ myObject) ' ดูเหมือนว่ารหัสพิเศษที่ให้คุณค่าเพิ่มเติมเพียงเล็กน้อย
Dean Radcliffe

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

หมายเหตุ: คุณสามารถทำได้ผ่านอาร์เรย์ แต่คุณจะทำซ้ำlengthคุณสมบัติและคุณสมบัติอื่น ๆ เช่นกัน


4
เมื่อใช้ for for loop แบบนั้นkeyจะใช้ค่าดัชนีดังนั้นจะแจ้งเตือนเป็น 0, 1, 2, ฯลฯ ... คุณต้องเข้าถึง p [key]
ไบรอัน

1
มันเป็นวิธีที่ช้าที่สุดของการวนซ้ำอาร์เรย์ใน JavaScript คุณสามารถตรวจสอบสิ่งนี้บนคอมพิวเตอร์ของคุณ - วิธีที่ดีที่สุดในการวนซ้ำอาร์เรย์ใน JavaScript
Pencroff

5
@Pencroff: ปัญหาคือคำถามไม่ได้เกี่ยวกับการวนลูปผ่านอาร์เรย์ ... ;)
Sk8erPeter

นี่คือสิ่งที่ฉันไม่เข้าใจใน stackoverflow Richard ให้คำตอบที่ถูกต้องและเขาเป็นคนแรกที่ให้คำตอบนั้น แต่เขาไม่ได้รับ +1? @Bryan var p = {"p1":"q","p2":"w"}; for(key in p) { alert( key ); }กำลัง popping "p1" และ "p2" ในการแจ้งเตือนดังนั้นมีอะไรผิดปกติเกี่ยวกับสิ่งนั้น ???
เซบาสเตียน

5
ฉันคิดว่าความแตกต่างที่สำคัญคือคุณภาพ: คำตอบอื่น ๆ ไม่เพียง แต่บอก แต่ยังบอก caveats (เช่นต้นแบบ) และวิธีการจัดการกับ caveats เหล่านั้น IMHO คำตอบอื่นนั้นดีกว่าของฉัน :)
Richard Levasseur

20

หลังจากดูคำตอบทั้งหมดในที่นี้ hasOwnProperty ไม่จำเป็นสำหรับการใช้งานของฉันเองเพราะวัตถุ json ของฉันสะอาด ไม่มีเหตุผลในการเพิ่มการประมวลผลจาวาสคริปต์ใด ๆ เพิ่มเติม นี่คือทั้งหมดที่ฉันใช้:

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

18
วัตถุ JSON นั้นสะอาดหรือไม่นั้นไม่เกี่ยวข้อง หากในเวลาอื่น ๆ โค้ดบางส่วนตั้งค่าคุณสมบัติบนแล้วก็จะมีการแจกแจงObject.prototype for..inถ้าคุณแน่ใจว่าคุณไม่ได้ใช้ห้องสมุดใด ๆ hasOwnPropertyที่ทำอย่างนั้นแล้วคุณไม่จำเป็นต้องโทร
G-Wiz

4
มันสามารถทำความสะอาดได้อย่างสมบูรณ์ถ้าสร้างด้วยObject.create(null)
Juan Mendes

20

ผ่านทางต้นแบบที่มี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

2
ระมัดระวังกับต้นแบบ: ผลิตobj = { print: 1, each: 2, word: 3 } TypeError: number is not a functionการใช้ฟังก์ชั่นที่forEachคล้ายกันArrayอาจลดความเสี่ยงได้บ้าง
David Harkness

18

เป็นคนที่น่าสนใจในคำตอบเหล่านี้ได้สัมผัสทั้งสองอย่างObject.keys()และfor...ofไม่เคยรวมกัน:

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

คุณก็ไม่สามารถเพราะมันไม่ได้เป็น iterator และหรือไอเอ็นจีน่าเกลียด / ไม่มีประสิทธิภาพ ฉันดีใจที่ผู้คนส่วนใหญ่งดเว้นจาก(ไม่ว่าจะมีหรือไม่มีการตรวจสอบ) เนื่องจากมันค่อนข้างยุ่งดังนั้นนอกเหนือจากคำตอบของฉันด้านบนฉันมาที่นี่เพื่อพูด ...for...ofObjectfor...index.forEach()Object.keys()
for...in.hasOwnProperty()


คุณสามารถสร้างความสัมพันธ์ของวัตถุธรรมดาซ้ำได้! ทำตัวเหมือนกับMapใช้โดยตรงกับfor...of
DEMO แฟนซีที่ทำงานใน Chrome และ FF (ฉันถือว่า ES6 เท่านั้น)

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

ตราบใดที่คุณรวม shim ของฉันด้านล่าง:

//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;
    }};
};

โดยไม่ต้องสร้างวัตถุแผนที่จริงที่ไม่มีน้ำตาล syntactic ที่ดี

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

อันที่จริงแล้วด้วย shim นี้หากคุณยังต้องการใช้ประโยชน์จากฟังก์ชั่นอื่น ๆ ของ 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))

ไม่มีเหตุผลว่าทำไมมันไม่ทำงาน

ยินดีต้อนรับสู่อนาคต


1
กรณี ใน จุด ตราบใดที่ผู้คนเลื่อนลงและพบว่ามีประโยชน์นั่นคือทั้งหมดที่สำคัญ โดยปกติแล้วฉันจะพยายามทำบางสิ่งไม่ชอบสิ่งที่ฉันเห็นทางออนไลน์ลงเอยด้วยการคิดออกแล้วกลับมาแชร์อีกครั้ง เป็น doco ที่ดีฉันเจอคำตอบของตัวเองก่อนที่จะทำสิ่งที่ฉันลืมไปเลย!
Hashbrown

@HelpMeStackOverflowMyOnlyHope โดยส่วนตัวฉันไม่ชอบการแก้ไขต้นแบบของวัตถุที่ฉันไม่ได้กำหนดตัวเอง
Janus Troelsen

@ JanusTroelsen คุณได้อ่านคำตอบทั้งหมดหรือยัง? For those who don't like to shim, or mess with prototype in general, feel free to make the function on window instead, calling it something like getObjIterator() then;
Hashbrown

โปรดทราบว่าเทคนิคนี้ใช้ไม่ได้กับวัตถุธรรมดา แต่มีประโยชน์อย่างไรก็ตาม
noɥʇʎԀʎzɐɹƆ

มันใช้งานได้กับวัตถุธรรมดานั่นคือจุดรวม (เช่นเดียวกับชื่อตัวแปรที่ต้องการordinaryObjectเน้นว่าเวทมนต์ยังใช้ได้กับประเภทเหล่านั้น) คุณตรวจสอบการสาธิต; @ noɥʇʎԀʎzɐɹƆใช้ไม่ได้กับอะไร (PS รูปโปรไฟล์ SE ของคุณคือบอส)
Hashbrown

13

Object.keys (obj): Array

ดึงกุญแจที่มีค่าสตริงทั้งหมดของคุณสมบัติทั้งหมดที่เป็นของตัวเอง (ไม่สืบทอด)

ดังนั้นจึงให้รายการของคีย์เดียวกันกับที่คุณต้องการโดยการทดสอบแต่ละคีย์อ็อบเจ็กต์ด้วย 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 มิลลิวินาที
  • สำหรับ ... วิธี / inOwnProperty ใช้เวลา 98.26163508463651 มิลลิวินาที

PS บน Chrome ความแตกต่างที่ยิ่งใหญ่กว่าคือhttp://codepen.io/dsheiko/pen/JdrqXa

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


หากคุณไม่รู้สึกอยากปล่อยสัญลักษณ์ {} คุณยังสามารถใช้งานได้of โดยไม่ต้องสร้างMaps
Hashbrown

13

นี่เป็นอีกวิธีในการทำซ้ำผ่านวัตถุ

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


Object.keys(p).forEach(key => { console.log(key, p[key]) })


3
วิธีนี้ค่อนข้างเจ๋ง แต่สำหรับวัตถุขนาดใหญ่forวิธีนี้อาจมีประสิทธิภาพมากกว่า
Rolf


12

นอกจากนี้คุณยังสามารถใช้ Object.keys () และทำซ้ำคีย์ของวัตถุเช่นด้านล่างเพื่อรับค่า:

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

Object.keys(p).forEach((key)=> {
 console.log(key +' -> '+ p[key]);
});


คุณประหยัดเวลาของฉันขอบคุณ
Swap-IOS-Android

มีความสุขที่ได้รู้ :)
Onera

8

รหัส 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
}

8

Object.keys()วิธีการส่งกลับอาร์เรย์ของคุณสมบัตินับเป็นวัตถุที่กำหนดเอง อ่านเพิ่มเติมได้ที่นี่

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

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


8

ประสิทธิภาพ

วันนี้ 2020.03.06 ฉันทำการทดสอบโซลูชันที่เลือกใน Chrome v80.0, Safari v13.0.5 และ Firefox 73.0.1 บน MacOs High Sierra v10.13.6

สรุปผลการวิจัย

  • โซลูชันที่ใช้for-in(A, B) นั้นรวดเร็ว (หรือเร็วที่สุด) สำหรับเบราว์เซอร์ทั้งหมดสำหรับวัตถุขนาดใหญ่และขนาดเล็ก
  • for-ofวิธีการแก้ปัญหาที่น่าประหลาดใจ(H) รวดเร็วบนโครเมียมสำหรับวัตถุขนาดเล็กและขนาดใหญ่
  • โซลูชันที่อิงตามดัชนีชัดเจนi(J, K) ค่อนข้างเร็วสำหรับเบราว์เซอร์ทั้งหมดสำหรับวัตถุขนาดเล็ก (สำหรับ Firefox ยังเร็วสำหรับ ojbects ขนาดใหญ่ แต่ใช้ความเร็วปานกลางกับเบราว์เซอร์อื่น ๆ )
  • โซลูชันที่ใช้ตัววนซ้ำ (D, E) ช้าที่สุดและไม่แนะนำ
  • สารละลาย C ช้าสำหรับวัตถุขนาดใหญ่และปานกลางช้าสำหรับวัตถุขนาดเล็ก

ป้อนคำอธิบายรูปภาพที่นี่

รายละเอียด

ทำการทดสอบประสิทธิภาพสำหรับ

  • วัตถุขนาดเล็ก - มี 3 ช่อง - คุณสามารถทำการทดสอบบนเครื่องของคุณที่นี่
  • วัตถุ 'ใหญ่' - มี 1,000 ฟิลด์ - คุณสามารถทำการทดสอบบนเครื่องของคุณได้ที่นี่

ตัวอย่างด้านล่างแสดงโซลูชันที่ใช้แล้ว

และนี่คือผลลัพธ์สำหรับวัตถุขนาดเล็กบนโครเมียม

ป้อนคำอธิบายรูปภาพที่นี่


7

คุณสามารถเพิ่มฟังก์ชั่น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
});

สำหรับคนที่ไม่ชอบ " สำหรับ ... ใน " - วิธีการ:

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

หากคุณไม่ต้องการรับข้อขัดแย้งกับวิธีการอื่น ๆ คุณสามารถตั้งชื่อด้วยชื่อเฉพาะของคุณได้


3
การดัดแปลงต้นแบบของวัตถุในตัว (เช่นObject) โดยทั่วไปถือว่าเป็นรูปแบบการต่อต้านเพราะอาจทำให้เกิดความขัดแย้งกับรหัสอื่นได้ง่าย ดังนั้นแผลจึงไม่แนะนำให้ทำเช่นนี้
Moritz

6

ลูปนั้นค่อนข้างน่าสนใจเมื่อใช้จาวาสคริปต์ที่บริสุทธิ์ ดูเหมือนว่ามีเพียง ECMA6 (ข้อกำหนดใหม่ของ JavaScript ปี 2015) เท่านั้นที่มีการวนซ้ำภายใต้การควบคุม น่าเสียดายที่ฉันเขียนสิ่งนี้ทั้งเบราว์เซอร์และสภาพแวดล้อมการพัฒนาแบบบูรณาการยอดนิยม (IDE) ยังคงดิ้นรนเพื่อสนับสนุนระฆังและนกหวีดใหม่อย่างสมบูรณ์

คร่าว ๆ นี่คือลักษณะของวงจาวาสคริปต์ที่มีหน้าตาเหมือนกับ 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;
  }
}

นอกจากนี้ฉันรู้ว่านี่ไม่ใช่ขอบเขตของคำถามนี้ แต่ในปี 2011 ECMAScript 5.1 ได้เพิ่มforEachวิธีการสำหรับอาร์เรย์เท่านั้นซึ่งโดยทั่วไปสร้างวิธีการปรับปรุงแบบใหม่เพื่อวนลูปผ่านอาร์เรย์ในขณะที่ยังคงปล่อยวัตถุที่ไม่สามารถทำซ้ำได้forซ้ำได้ แต่ส่วนที่แปลกคือforEachวิธีการใหม่นี้ไม่รองรับbreakซึ่งนำไปสู่ปัญหาอื่น ๆ ได้ทุกประเภท

โดยพื้นฐานแล้วในปี 2554 ไม่มีวิธีการวนซ้ำอย่างแท้จริงใน JavaScript นอกเหนือไปจากไลบรารียอดนิยมมากมาย (jQuery, Underscore และอื่น ๆ ) ตัดสินใจที่จะนำไปใช้ใหม่

ในปี 2015 ตอนนี้เรามีวิธีที่ดีกว่าในการวนลูป (และทำลาย) ชนิดของวัตถุใด ๆ (รวมถึงอาร์เรย์และสตริง) นี่คือสิ่งที่วนรอบใน JavaScript ในที่สุดจะมีลักษณะเหมือนเมื่อคำแนะนำกลายเป็นกระแสหลัก:

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

โปรดทราบว่าเบราว์เซอร์ส่วนใหญ่จะไม่สนับสนุนรหัสด้านบนตั้งแต่วันที่ 18 มิถุนายน 2016 แม้ใน Chrome คุณต้องเปิดใช้งานการตั้งค่าสถานะพิเศษนี้เพื่อให้สามารถใช้งานได้: chrome://flags/#enable-javascript-harmony

จนกว่าสิ่งนี้จะกลายเป็นมาตรฐานใหม่วิธีการเก่ายังคงสามารถใช้ได้ แต่ยังมีทางเลือกในห้องสมุดยอดนิยมหรือแม้แต่ทางเลือกที่มีน้ำหนักเบาสำหรับผู้ที่ไม่ได้ใช้ห้องสมุดเหล่านี้


คุณช่วยไขปริศนานี้ได้หรือไม่? นี่คือความพยายามของฉัน jsfiddle.net/abalter/sceeb211
abalter

@abalter ขออภัยฉันรู้ว่าฉันพิมพ์ผิดในรหัสของฉัน ฉันแก้ไขแล้วและอัปเดต JsFiddle ของคุณที่นี่: jsfiddle.net/sceeb211/2
Nicolas Bouvrette

Uncaught TypeError: Object.entries is not a functionผมอยู่ในโครเมี่ยมและได้รับ ยังไม่ได้ใช้งานในโครเมียมหรือไม่
หยุดงาน

@abalter มันคือ ตรวจสอบให้แน่ใจว่าคุณมี Chrome รุ่น 51 และคุณได้เปิดใช้งานการตั้งค่าสถานะตามที่อธิบายไว้ในการแก้ไขและความคิดเห็น Jsfiddle ของฉัน คุณสามารถตรวจสอบรายละเอียดได้ที่นี่: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/
......

ขออภัยที่ฉันพลาดเกี่ยวกับธง ฉันเห็นว่ายังใช้งานไม่ได้เลย
หยุดยั้ง

5

ใน ES6 เรามีสัญลักษณ์ที่รู้จักกันดีเพื่อแสดงวิธีการภายในบางอย่างก่อนหน้านี้คุณสามารถใช้เพื่อกำหนดวิธีการวนซ้ำสำหรับวัตถุนี้:

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

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

สิ่งนี้จะให้ผลลัพธ์เหมือนกับที่ใช้สำหรับ ... ใน es6 loop

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

แต่สิ่งสำคัญคือการรู้ถึงความสามารถที่คุณมีในขณะนี้ด้วยการใช้ es6!


1
ตัววนซ้ำวัตถุที่กำหนดเองเรียกตัวทำซ้ำอาร์เรย์ในตัวของอาร์เรย์ที่สร้างโดยObject.keys()และจัดสรรในหน่วยความจำ ... เจ๋ง!
ooo

5

ฉันจะทำสิ่งนี้แทนที่จะตรวจสอบ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");
}

5

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


json = [{"key1":"value1","key2":"value2"},{"key1":"value3","key2":"value4"}] for (var i = 0; i < json.length; i++) { for (var key in json[i]) { if (json[i].hasOwnProperty(key)) { console.log(key + " -> " + json[i][key]); } } }
Marek Bernád

5

ใช้for-ofในObject.keys()

ชอบ:

let object = {
   "key1": "value1"
   "key2": "value2"
   "key3": "value3"
};

for (var key of Object.keys(p)) {
   console.log(key + " : " + object[key])
}

4

ถ้าคุณต้องการวนซ้ำคุณสมบัติที่ไม่สามารถนับได้เช่นกันคุณสามารถใช้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/>');
});


2
ขอบคุณมากสำหรับการโพสต์คำตอบนี้ ฉันต้องการตรวจสอบErrorวัตถุและไม่สามารถรับคุณสมบัติในลูปหรือการ_.forIn(err)โทร การใช้Object.getOwnPropertyNames(err)ทำให้ฉันสามารถเข้าถึงทุกส่วนของสิ่งErrorที่ฉันไม่เคยทำได้มาก่อน ขอบคุณ!
Pierce

4

หากใครต้องการวนลูปผ่านarrayObjects ด้วยเงื่อนไข :

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


4

เมื่อพิจารณา ES6 ฉันต้องการเพิ่มน้ำตาลของฉันเองและให้วิธีหนึ่งเพิ่มเติมเพื่อย้ำคุณสมบัติของวัตถุ

เนื่องจากวัตถุ JS ธรรมดาไม่สามารถทำซ้ำได้นอกกรอบเราจึงไม่สามารถใช้การfor..ofวนซ้ำเพื่อทำซ้ำเนื้อหาได้ แต่ไม่มีใครหยุดเราได้iterable

เรามามี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

หรือถ้าคุณรู้จักพลังของเครื่องกำเนิดไฟฟ้า ES6 ดังนั้นคุณสามารถทำให้รหัสข้างบนสั้นลงอย่างมาก

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

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

}

แน่นอนว่าคุณสามารถใช้พฤติกรรมดังกล่าวสำหรับวัตถุทั้งหมดที่มีการทำObjectiterable ในprototypeระดับ

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

นอกจากนี้วัตถุที่สอดคล้องกับโปรโตคอล iterable สามารถใช้ร่วมกับตัวดำเนินการแพร่กระจายฟีเจอร์ ES2015 ใหม่ได้ดังนั้นเราจึงสามารถอ่านค่าคุณสมบัติของวัตถุเป็นอาร์เรย์ได้

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

คุณสามารถตรวจสอบJSFiddleด้วยรหัสทั้งหมดที่ฉันให้ไว้ข้างต้น


ฉันพบรหัสจะสร้างค่า แต่ไม่มีคีย์ เป็นไปได้หรือไม่ที่จะทำซ้ำค่ากับคีย์?
Pika

ใช่คุณสามารถ. เพียงแค่กลับ "ผลผลิต [กุญแจ obj [กุญแจ]];" จากฟังก์ชันตัวสร้างของคุณจากนั้นใช้เหมือนดังต่อไปนี้ "สำหรับ (ปล่อยให้ [คีย์, ค่า] จาก {}) {}"
Artyom Pranovich

4

ตั้งแต่ ES06 คุณสามารถรับค่าของวัตถุเป็นอาร์เรย์ได้

let arrValues = Object.values( yourObject) ;

มันคืนค่าอาร์เรย์ของค่าวัตถุและไม่ดึงค่าจาก Prototype !!

MDN DOCS Object.values ​​()

และสำหรับกุญแจ (alldod ตอบฉันก่อนที่นี่)

let arrKeys   = Object.keys(yourObject);

คำตอบจะขอวิธีการแก้ปัญหาที่ส่งคืนทั้งคีย์และค่า
Sean Lindo

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.