กำลังตรวจสอบว่าสามารถทำซ้ำได้หรือไม่

ในเอกสาร MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of

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

ฉันได้พยายามค้นหาคุณสมบัติทั่วไปสำหรับอาร์เรย์ตัวทำซ้ำและตัวกำเนิด แต่ไม่สามารถทำได้

นอกเหนือจากการทำfor ... ofใน try block และการตรวจสอบข้อผิดพลาดประเภทมีวิธีที่ชัดเจนในการทำเช่นนี้หรือไม่?

วิธีที่เหมาะสมในการตรวจสอบความสามารถในการทำซ้ำมีดังนี้:

function isIterable(obj) {
  // checks for null and undefined
  if (obj == null) {
    return false;
  }
  return typeof obj[Symbol.iterator] === 'function';
}

เหตุใดจึงใช้งานได้ (โปรโตคอลเชิงลึกซ้ำได้): https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols

เนื่องจากเรากำลังพูดถึงเรื่อง for..of ฉันถือว่าเราอยู่ในแนวความคิด ES6

นอกจากนี้อย่าแปลกใจที่ฟังก์ชันนี้จะส่งคืนtrueif objเป็นสตริงเนื่องจากสตริงจะวนซ้ำบนอักขระของพวกเขา

ทำไมต้อง verbose?

const isIterable = object =>
  object != null && typeof object[Symbol.iterator] === 'function'

ทางออกที่ง่ายที่สุดคือ:

function isIterable (value) {
  return Symbol.iterator in Object(value);
}

Objectจะรวมสิ่งที่ไม่ใช่วัตถุไว้ในตัวเดียวทำให้ตัวinดำเนินการสามารถทำงานได้แม้ว่าค่าดั้งเดิมจะไม่ใช่วัตถุก็ตาม nullและundefinedกลายเป็นวัตถุว่างเปล่าดังนั้นจึงไม่จำเป็นต้องมีการตรวจจับขอบเคสและสตริงจะรวมเข้ากับอ็อบเจกต์ String ซึ่งสามารถทำซ้ำได้

ในฐานะที่เป็น sidenote ให้ระวังเกี่ยวกับความหมายของiterable ถ้าคุณมาจากภาษาอื่น ๆ ที่คุณคาดหวังบางสิ่งบางอย่างที่คุณสามารถย้ำไปกับการพูดการforห่วงคือiterable ฉันกลัวว่าไม่กรณีที่นี่ที่iterableหมายถึงสิ่งที่ใช้โพรโทคอซ้ำ

เพื่อให้สิ่งต่างๆชัดเจนขึ้นตัวอย่างทั้งหมดข้างต้นให้ส่งคืนfalseอ็อบเจ็กต์นี้{a: 1, b: 2}เนื่องจากอ็อบเจ็กต์นั้นไม่ได้ใช้โปรโตคอลการวนซ้ำ ดังนั้นคุณจะไม่สามารถทำซ้ำได้for...of แต่คุณยังสามารถทำได้ด้วยไฟล์for...in.

ดังนั้นหากคุณต้องการหลีกเลี่ยงข้อผิดพลาดที่เจ็บปวดทำให้รหัสของคุณมีความเฉพาะเจาะจงมากขึ้นโดยการเปลี่ยนชื่อวิธีการของคุณดังที่แสดงด้านล่าง:

/**
 * @param variable
 * @returns {boolean}
 */
const hasIterationProtocol = variable =>
    variable !== null && Symbol.iterator in Object(variable);

ปัจจุบันตามที่ระบุไว้แล้วเพื่อทดสอบว่าobjสามารถทำได้หรือไม่เพียงแค่ทำ

obj != null && typeof obj[Symbol.iterator] === 'function' 

คำตอบในอดีต (ไม่ถูกต้องอีกต่อไป)

for..ofสร้างเป็นส่วนหนึ่งของ ECMAScript 6 ฉบับภาษาข้อมูลจำเพาะร่าง ดังนั้นจึงสามารถเปลี่ยนแปลงได้ก่อนเวอร์ชันสุดท้าย

ในแบบร่างนี้อ็อบเจ็กต์ที่ทำซ้ำได้ต้องมีฟังก์ชันiteratorเป็นคุณสมบัติ

คุณสามารถตรวจสอบว่าวัตถุสามารถทำซ้ำได้เช่นนี้หรือไม่:

function isIterable(obj){
   if(obj === undefined || obj === null){
      return false;
   }
   return obj.iterator !== undefined;
}

สำหรับตัววนซ้ำแบบasyncคุณควรตรวจสอบ 'Symbol.asyncIterator' แทน 'Symbol.iterator':

async function* doSomething(i) {
    yield 1;
    yield 2;
}

let obj = doSomething();

console.log(typeof obj[Symbol.iterator] === 'function');      // false
console.log(typeof obj[Symbol.asyncIterator] === 'function'); // true

หากคุณต้องการตรวจสอบข้อเท็จจริงว่าตัวแปรเป็นวัตถุ ( {key: value}) หรืออาร์เรย์ ( [value, value]) คุณสามารถทำได้:

const isArray = function (a) {
    return Array.isArray(a);
};

const isObject = function (o) {
    return o === Object(o) && !isArray(o) && typeof o !== 'function';
};

function isIterable(variable) {
    return isArray(variable) || isObject(variable);
}