Rozważać:

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

Jakie jest właściwe użycie / wyjaśnienie hasOwnProperty('someProperty')?

Dlaczego nie możemy po prostu użyć someVar.somePropertydo sprawdzenia, czy obiekt someVarzawiera właściwość o nazwie someProperty?

Czym jest nieruchomość w tym przypadku?

Jaką właściwość sprawdza ten JavaScript?

hasOwnPropertyzwraca wartość logiczną wskazującą, czy obiekt, dla którego go wywołujesz, ma właściwość z nazwą argumentu. Na przykład:

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

Jednak nie patrzy na łańcuch prototypów obiektu.

Przydaje się, gdy wyliczasz właściwości obiektu za pomocą for...inkonstrukcji.

Jeśli chcesz zobaczyć wszystkie szczegóły, specyfikacja ES5 jest, jak zawsze, dobrym miejscem do obejrzenia.

Oto krótka i precyzyjna odpowiedź:

W JavaScript każdy obiekt ma kilka wbudowanych par klucz-wartość, które zawierają metainformacje o obiekcie. Kiedy przeglądasz wszystkie pary klucz-wartość za pomocą for...inkonstrukcji / pętli dla obiektu, również przechodzisz przez te pary klucz-wartość metainformacji (których zdecydowanie nie chcesz).

Używając hasOwnPropery(property) filtrów eliminuj te niepotrzebne pętle przez metainformacje i bezpośrednio sprawdza, czy parametr propertyjest właściwością podaną przez użytkownika w obiekcie, czy nie. Przez filtrowanie mam na myśli to, że hasOwnProperty(property)nie wygląda na to, że propertyistnieje w łańcuchu prototypów Object, czyli metainformacjach.

Na tej true/falsepodstawie zwraca wartość logiczną .

Oto przykład:

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

Mam nadzieję, że to jasne!

Sprawdza:

Zwraca wartość logiczną wskazującą, czy obiekt ma właściwość o określonej nazwie

Metoda hasOwnProperty zwraca wartość true, jeśli obiekt ma właściwość o określonej nazwie, false, jeśli jej nie ma. Ta metoda nie sprawdza, czy właściwość istnieje w łańcuchu prototypów obiektu; właściwość musi należeć do samego obiektu.

Przykład:

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

Podsumowanie:

hasOwnProperty()jest funkcją, którą można wywołać na dowolnym obiekcie i pobiera ciąg znaków jako dane wejściowe. Zwraca wartość logiczną, która oznacza true, że właściwość znajduje się na obiekcie, w przeciwnym razie zwraca wartość false. hasOwnProperty()znajduje się na Object.prototypei dzięki temu jest dostępny dla każdego obiektu.

Przykład:

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

W tym przykładzie tworzony jest nowy obiekt Person. Każda osoba ma własną nazwę, która jest inicjalizowana w konstruktorze. Jednak wiek nie znajduje się na obiekcie, ale na prototypie obiektu. Dlatego hasOwnProperty()wraca truepo imię i falsewiek.

Praktyczne zastosowania:

hasOwnProperty()może być bardzo przydatne podczas wykonywania pętli po obiekcie za pomocą for inpętli. Możesz za jego pomocą sprawdzić, czy właściwości pochodzą z samego obiektu, a nie z prototypu. Na przykład:

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

Używasz object.hasOwnProperty ( p ) do określenia, czy obiekt ma wyliczalną właściwość p -

Obiekt może mieć własny prototyp, w którym do każdej instancji obiektu przypisane są „domyślne” metody i atrybuty. hasOwnProperty zwraca wartość true tylko dla właściwości, które zostały specjalnie ustawione w konstruktorze lub dodane do wystąpienia później.

Aby określić, czy p jest w ogóle zdefiniowane w dowolnym miejscu dla obiektu, użyj if ( p instanceof object), gdzie p jest wynikiem łańcucha nazwy właściwości.

Na przykład domyślnie wszystkie obiekty mają metodę „toString”, ale nie pojawi się ona w hasOwnProperty.

hasOwnProperty to normalna funkcja JavaScript, która przyjmuje argument w postaci ciągu.

W twoim przypadku somevar.hasOwnProperty('someProperty')sprawdza, czy somevarfunkcja ma, someproperyczy nie - zwraca prawdę i fałsz.

Mówić

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

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

hasOwnPropertyjest właściwym sposobem sprawdzenia, czy obiekt ma właściwość, czy nie. someVar.somePropertynie może być alternatywą dla tej sytuacji. Następujący stan pokaże dobrą różnicę:

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
}

W związku z tym someVar.isFirstnie można używać alternatywy dla someVar.hasOwnProperty('isFirst').

Scena A:

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

    Output

    1
    2

Scena 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

Ponieważ JavaScript nie chroni właściwości hasOwnProperty. Możesz więc używać tego w następujący sposób:

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

To sprawdza, czy obiekt ma właściwość . Działa tak samo jak if(obj.prop), o ile wiem.