พิจารณา:

if (someVar.hasOwnProperty('someProperty') ) {
 // Do something();
} else {
 // Do somethingElse();
}

การใช้งานที่ถูกต้อง / คำอธิบายhasOwnProperty('someProperty')คืออะไร?

ทำไมเราไม่สามารถใช้someVar.somePropertyเพื่อตรวจสอบว่าวัตถุsomeVarมีคุณสมบัติที่มีชื่อsomePropertyหรือไม่?

ทรัพย์สินในกรณีนี้คืออะไร?

JavaScript ตรวจสอบคุณสมบัติอะไร

hasOwnPropertyส่งคืนค่าบูลีนที่ระบุว่าออบเจ็กต์ที่คุณเรียกมันมีคุณสมบัติที่มีชื่อของอาร์กิวเมนต์หรือไม่ ตัวอย่างเช่น:

var x = {
    y: 10
};
console.log(x.hasOwnProperty("y")); //true
console.log(x.hasOwnProperty("z")); //false

อย่างไรก็ตามมันไม่ได้มองไปที่โซ่ต้นแบบของวัตถุ

มีประโยชน์ที่จะใช้เมื่อคุณระบุคุณสมบัติของวัตถุด้วยfor...inโครงสร้าง

หากคุณต้องการดูรายละเอียดทั้งหมดสเปคES5ก็เป็นสถานที่ที่ดีเช่นเคย

นี่คือคำตอบสั้น ๆ และแม่นยำ:

ใน JavaScript ทุกออบเจ็กต์มีคู่คีย์ - ค่าในตัวมากมายที่มีข้อมูลเมตาเกี่ยวกับออบเจ็กต์ เมื่อคุณวนซ้ำคู่คีย์ - ค่าทั้งหมดโดยใช้for...inโครงสร้าง / ลูปสำหรับออบเจ็กต์คุณกำลังวนลูปผ่านคู่คีย์ - ค่าข้อมูลเมตานี้ด้วย (ซึ่งคุณไม่ต้องการแน่นอน)

ใช้การhasOwnPropery(property) กรองข้อมูลเมตาที่ไม่จำเป็นเหล่านี้ออกและตรวจสอบโดยตรงว่าพารามิเตอร์propertyเป็นคุณสมบัติที่ผู้ใช้กำหนดในออบเจ็กต์หรือไม่ โดยการกรองออกฉันหมายความว่านั่นhasOwnProperty(property)ไม่ได้ดูว่าpropertyมีอยู่ในห่วงโซ่ต้นแบบของ Object หรือที่เรียกว่าข้อมูลเมตา

มันส่งคืนบูลีนtrue/falseตามนั้น

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

var fruitObject = {"name": "Apple", "shape": "round", "taste": "sweet"};
console.log(fruitObject.hasOwnProperty("name"));  //true
console.log(Object.prototype.hasOwnProperty("toString");) //true because in above snapshot you can see, that there is a function toString in meta-information

ฉันหวังว่ามันจะชัดเจน!

ตรวจสอบ:

ส่งคืนค่าบูลีนที่ระบุว่าวัตถุมีคุณสมบัติที่มีชื่อที่ระบุหรือไม่

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

ตัวอย่าง:

var s = new String("Sample");
document.write(s.hasOwnProperty("split"));                        //false
document.write(String.prototype.hasOwnProperty("split"));         //true

สรุป:

hasOwnProperty()เป็นฟังก์ชันที่สามารถเรียกใช้กับวัตถุใด ๆ และใช้สตริงเป็นอินพุต ส่งคืนบูลีนซึ่งtrueถ้าคุณสมบัติตั้งอยู่บนวัตถุมิฉะนั้นจะส่งกลับเท็จ hasOwnProperty()ตั้งอยู่Object.prototypeและทำให้พร้อมใช้งานสำหรับวัตถุใด ๆ

ตัวอย่าง:

function Person(name) {
  this.name = name;
}

Person.prototype.age = 25;

const willem = new Person('willem');

console.log(willem.name); // Property found on object
console.log(willem.age); // Property found on prototype

console.log(willem.hasOwnProperty('name')); // 'name' is on the object itself
console.log(willem.hasOwnProperty('age')); // 'age' is not on the object itself

ในตัวอย่างนี้วัตถุบุคคลใหม่ถูกสร้างขึ้น แต่ละคนมีชื่อของตัวเองซึ่งได้รับการเริ่มต้นในตัวสร้าง อย่างไรก็ตามอายุไม่ได้อยู่บนวัตถุ แต่อยู่ที่ต้นแบบของวัตถุ ดังนั้นจึงhasOwnProperty()ไม่กลับมาtrueสำหรับชื่อและfalseอายุ

การใช้งานจริง:

hasOwnProperty()จะมีประโยชน์มากเมื่อวนรอบวัตถุโดยใช้การfor inวนซ้ำ คุณสามารถตรวจสอบได้ว่าคุณสมบัตินั้นมาจากวัตถุหรือไม่ไม่ใช่ต้นแบบ ตัวอย่างเช่น:

function Person(name, city) {
  this.name = name;
  this.city = city;
}

Person.prototype.age = 25;

const willem = new Person('Willem', 'Groningen');

for (let trait in willem) {
  console.log(trait, willem[trait]); // This loops through all properties, including the prototype
}

console.log('\n');

for (let trait in willem) {
  if (willem.hasOwnProperty(trait)) { // This loops only through 'own' properties of the object
    console.log(trait, willem[trait]);
  }
}

คุณใช้ object.hasOwnProperty ( p ) เพื่อตรวจสอบว่าวัตถุมีนับคุณสมบัติพี -

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

ในการพิจารณาว่าpถูกกำหนดไว้ที่ใดก็ได้สำหรับวัตถุให้ใช้ if ( p instanceof object) โดยที่ p จะประเมินเป็นสตริงชื่อคุณสมบัติ

ตัวอย่างเช่นโดยค่าเริ่มต้นออบเจ็กต์ทั้งหมดมีเมธอด 'toString' แต่จะไม่แสดงใน hasOwnProperty

hasOwnProperty เป็นฟังก์ชัน JavaScript ปกติที่ใช้อาร์กิวเมนต์สตริง

ในกรณีของคุณsomevar.hasOwnProperty('someProperty')จะตรวจสอบว่าsomevarฟังก์ชันมีsomeproperyหรือไม่ - ส่งคืนจริงและเท็จ

พูด

function somevar() {
    this.someProperty = "Generic";
}

function welcomeMessage()
{
    var somevar1 = new somevar();
    if(somevar1.hasOwnProperty("name"))
    {
        alert(somevar1.hasOwnProperty("name")); // It will return true
    }
}

hasOwnPropertyเป็นวิธีที่เหมาะสมในการตรวจสอบวัตถุว่ามีคุณสมบัติหรือไม่ someVar.somePropertyไม่สามารถใช้เป็นทางเลือกสำหรับสถานการณ์นี้ได้ เงื่อนไขต่อไปนี้จะแสดงความแตกต่างที่ดี:

const someVar = { isFirst: false };


// The condition is true, because 'someVar' has property 'isFirst'
if (someVar.hasOwnProperty('isFirst')) {
  // Code runs
}


// The condition is false, because 'isFirst' is false.
if (someVar.isFirst) {
  // Code does not runs here
}

ดังนั้นไม่สามารถใช้ทางเลือกที่จะsomeVar.isFirstsomeVar.hasOwnProperty('isFirst')

ฉาก A:

const objA = { a: 1, b: 2 }
for (const key in objA) {
  if (objA.hasOwnProperty(key)) {
    console.log(objA[key])
  }
}

    Output

    1
    2

ฉาก B:

const objB = {
  a: 1,
  b: 2,
  hasOwnProperty() {
    return false
  }
}

for (const key in objB) {
  if (objB.hasOwnProperty(key)) {
    console.log(objB[key])
  }
}

    Outputs nothing

เนื่องจาก JavaScript ไม่ปกป้องคุณสมบัติของ hasOwnProperty คุณสามารถใช้มันได้ดังนี้:

for (const key in objB) {
  if (Object.prototype.hasOwnProperty.call(obj, key)) {
    console.log(objB[key])
  }
}

มันจะตรวจสอบว่าวัตถุที่มีคุณสมบัติ มันทำงานเหมือนกับif(obj.prop)เท่าที่ฉันรู้