การนับจำนวนหมายถึงอะไร

ฉันถูกนำไป MDN ของหน้า for..inเมื่อมันกล่าวว่า "for..in iterates กว่าคุณสมบัติที่นับของวัตถุ."

จากนั้นฉันไปที่หน้าEnumerability และเป็นเจ้าของคุณสมบัติซึ่งกล่าวว่า "คุณสมบัติที่นับได้คือคุณสมบัติที่สามารถวนซ้ำโดย for..in loop"

พจนานุกรมกำหนดให้นับได้ว่านับได้ แต่ฉันไม่สามารถจินตนาการได้ว่ามันแปลว่าอะไร ฉันขอตัวอย่างสิ่งที่นับได้หรือไม่

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

ถ้าคุณสมบัติไม่ถูกระบุว่านับได้ลูปจะไม่สนใจว่ามันอยู่ในวัตถุ

var obj = { key: 'val' };

console.log('toString' in obj); // true
console.log(typeof obj.toString); // "function"

for (var key in obj)
    console.log(key); // "key"

คุณสมบัติถูกระบุว่าเป็นนับหรือไม่ได้โดยตัวของมันเองแอตทริบิวต์[[Enumerable]] คุณสามารถดูสิ่งนี้เป็นส่วนหนึ่งของตัวบอกคุณสมบัติ :

var descriptor = Object.getOwnPropertyDescriptor({ bar: 1 }, 'bar');

console.log(descriptor.enumerable); // true
console.log(descriptor.value);      // 1

console.log(descriptor);
// { value: 1, writable: true, enumerable: true, configurable: true }

for..inห่วงแล้ว iterates ผ่านชื่อคุณสมบัติของวัตถุ

var foo = { bar: 1, baz: 2};

for (var prop in foo)
    console.log(prop); // outputs 'bar' and 'baz'

แต่จะประเมินเฉพาะคำสั่งของ - console.log(prop);ในกรณีนี้ - สำหรับคุณสมบัติของผู้ที่มีแอตทริบิวต์[[Enumerable]]true

เงื่อนไขนี้เกิดขึ้นเนื่องจากวัตถุมีคุณสมบัติมากมายโดยเฉพาะจากการสืบทอด :

console.log(Object.getOwnPropertyNames(Object.prototype));
// ["constructor", "toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", /* etc. */]

แต่ละคุณสมบัติเหล่านี้ยังคงมีอยู่บนวัตถุ :

console.log('constructor' in foo); // true
console.log('toString' in foo);    // true
// etc.

แต่พวกเขาถูกข้ามโดยfor..inวงเพราะพวกเขาไม่นับ

var descriptor = Object.getOwnPropertyDescriptor(Object.prototype, 'constructor');

console.log(descriptor.enumerable); // false

หากคุณสร้างวัตถุผ่านmyObj = {foo: 'bar'}หรือบางสิ่งบางอย่างในบริเวณนั้นคุณสมบัติทั้งหมดจะนับได้ ดังนั้นคำถามที่ง่ายกว่าในการถามคืออะไรที่นับไม่ได้? วัตถุบางอย่างมีคุณสมบัติที่ไม่นับจำนวนตัวอย่างเช่นถ้าคุณเรียกใช้Object.getOwnPropertyNames([])(ซึ่งส่งกลับอาร์เรย์ของคุณสมบัติทั้งหมดที่นับได้หรือไม่บน []) มันจะส่งคืน['length']ซึ่งรวมถึงคุณสมบัติที่ไม่นับได้ของอาร์เรย์ 'ความยาว' .

คุณสามารถสร้างคุณสมบัติที่ไม่นับได้ด้วยตนเองโดยโทรObject.defineProperty:

var person = { age: 18 };
Object.defineProperty(person, 'name', { value: 'Joshua', enumerable: false });

person.name; // 'Joshua'
for (prop in person) {
  console.log(prop);
}; // 'age'

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

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

มันน่าเบื่อมากกว่าสิ่งที่ควรมองเห็น

มีคุณสมบัติอย่างแท้จริงในคุณสมบัติทั้งหมดที่เรียกว่า "นับได้" เมื่อมีการตั้งค่าเป็นเท็จfor..inวิธีการจะข้ามคุณสมบัตินั้นทำท่าว่าไม่มีอยู่

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

คุณสามารถสร้างคุณสมบัติที่ไม่นับได้ของคุณเองโดยใช้Object.definePropertyวิธีการ:

  var car = {
    make: 'Honda',
    model: 'Civic',
    year: '2008',
    condition: 'bad',
    mileage: 36000
  };

  Object.defineProperty(car, 'mySecretAboutTheCar', {
    value: 'cat pee in back seat',
    enumerable: false
  });

ตอนนี้ความจริงที่ว่ามีความลับเกี่ยวกับรถซ่อนอยู่ แน่นอนว่าพวกเขายังคงสามารถเข้าถึงอสังหาริมทรัพย์ได้โดยตรงและรับคำตอบ:

console.log(car.mySecretAboutTheCar); // prints 'cat pee in back seat'

แต่พวกเขาจะต้องรู้ว่าทรัพย์สินมีอยู่ก่อนเพราะหากพวกเขาพยายามที่จะเข้าถึงมันผ่านfor..inหรือObject.keysมันจะยังคงเป็นความลับอย่างสมบูรณ์:

console.log(Object.keys(car)); //prints ['make', 'model', 'year', 'condition', 'mileage']

พวกเขาควรจะเรียกมันว่า "forInAble"

หากคุณมีปัญหาในการมองเห็นภาพ "การนับจำนวนหมายความว่าอะไร? ทำไมไม่ถามตัวเองว่าสิ่งที่ไม่ได้หมายความว่าจะnonenumerable ?

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

var o = {};
o['foo'] =  0;                               // enumerable, normal
Object.defineProperty(o, 'bar', {value: 1}); // nonenumerable, weird

ในตอนนี้for..inลองจินตนาการว่ามันเหมือนpseudocode

for property in o:
    if not property enumerable continue // skip non-enumerable, "bar"
    else do /* whatever */              // act upon enumerable, "foo"

ตำแหน่งที่ร่างกายของลูปที่คุณพิมพ์ในJavaScriptอยู่ในตำแหน่ง/* whatever */

ฉันจะเขียนนิยามหนึ่งบรรทัดของENUMERABLE

Enumerable:ระบุว่าคุณสมบัติสามารถส่งคืนได้ใน for / in loop

var obj = {};
Object.defineProperties(obj, {
    set1: {enumerable: true},
    set2: {enumerable: false},
});
Object.keys(obj); // ["set1"]
Object.getOwnPropertyNames(obj); // ["set1", "set2"]

วิธีการไม่นับจำนวน หรือค่อนข้างสร้างขึ้นในวิธีการไม่ .. tho หลังจากค้นหาสิ่งที่นับความ หมายจาวาสคริปต์; มันหมายถึงคุณสมบัติของคุณสมบัติ .. วัตถุที่สร้างขึ้นทั้งหมดใน ecma3 นั้นนับได้และ ecma5 คุณสามารถกำหนดได้ .... แค่นั้นแหละ .. : D: ฉันใช้เวลาเล็กน้อยในการหาคำตอบ แต่ฉันเชื่อว่ามันพูดถึงในหนังสือของเดวิดฟลานาแกน .. ดังนั้นฉันเดาว่ามันหมายถึง "ซ่อนเร้น" หรือไม่ "ซ่อนเร้น" ในวิธีการที่ไม่ปรากฏในการวนรอบและจึง "ซ่อน"

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

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