W tym samouczku przyjrzymy się aspektom ograniczeń i funkcji związanych z maWłasnąWłaściwość() metoda w JavaScript. W kolejnych rozdziałach dowiemy się także o jego implementacjach i zastosowaniu.

Wstęp

W JavaScript , metoda hasOwnProperty() jest zdefiniowana jako właściwość sprawdzająca, czy obiekt należy do wspomnianego projektu, czy nie. Jeśli okaże się, że właściwość należy do rozpoznanego obiektu, zwróci wynik oparty na instrukcji logicznej, tj. prawda lub fałsz.

Składnia

 object.hasOwnProperty(propname) 

Argument

Nagranie:

Tutaj musimy przekazać symbol lub nazwę ciągu znaków, ponieważ jest to miejsce właściwości, w którym sprawdzane jest, czy symbol lub ciąg znaków należy do obiektu. Odbywa się to za pomocą metody podanej poniżej.

 var movie = { name: 'iron man', genre: 'super hit', } var song = { name: 'cardigan', } movie.hasOwnProperty('name'); // returns true movie.hasOwnProperty('type'); // returns false song.hasOwnProperty('name'); // returns true song.hasOwnProperty('status'); // returns false 

Należy tu zwrócić uwagę na jeden ważny aspekt: ​​metoda hasOwnProperty() generalnie ignoruje właściwości dziedziczone. Oznacza to, że metoda zwróci wartość true, jeśli okaże się, że obiekt ma niedziedziczoną właściwość, a nazwa jest określona przez propname. Jeśli zwróci false, oznacza to, że obiekt nie posiada żadnej właściwości o podanej nazwie lub odziedziczył tę właściwość od obiektu o danym typie.

 // Create an object var o = new Object(); // Define a noninherited local property o.x = 3.14; o.hasOwnProperty('x'); // Returns true: x is a local property of o o.hasOwnProperty('y'); // Returns false: o doesn't have a property y o.hasOwnProperty('toString'); // Returns false: toString property is inherited hasOwnProperty() will return true even if you define the undefined or null value. let a = new Object(); a.propertyOne = null; a.hasOwnProperty('propertyOne') // output: true a.propertyTwo = undefined; a.hasOwnProperty('propertyTwo') //Output: true 

Kolejną dodatkową zaletą stosowania metody hasOwnProperty() jest to, że może ona zainicjować obiekt, kierując się koncepcją przekazania ciągu znaków jako argumentu domyślnego. Powinien szybko odpowiedzieć prawdą, jeśli okaże się, że wartość jest dostępna dla obiektu. W przeciwnym razie zwróci wartość false, jeśli nie zostanie znaleziona. Można to zademonstrować za pomocą fragmentu kodu podanego poniżej.

 function Car(name) { this.name = name; } Car.prototype.color = 'red'; const bmw = new Car('x1'); console.log(bmw.name); // property found on object console.log(bmw.color); // color property found on prototype console.log(bmw.hasOwnProperty('name')); // name is found on the object itself console.log(bmw.hasOwnProperty('color')); // color property is not found on the object itself 

We fragmencie kodu podanym powyżej zmienna tworzy nowy obiekt, Samochód . Można teraz stwierdzić, że Samochód jest inicjowany mając zdefiniowane w konstruktorze swoje właściwości i nazwę. Chociaż kolor może nie być wymieniony w obiekcie po zainicjowaniu, będzie on zawsze dostępny na prototypie hierarchia . Dlatego funkcja hasOwnProperty() zawsze zwróci wartość true dla nazwy, ale dla koloru zwróci wartość false.

Jeśli chodzi o wydajność, funkcja hasOwnProperty() działa płynnie, przechodząc przez obiekt za pomocą pętli. Do tej pory możemy powiedzieć, że jeśli właściwości konkretnie należą do obiektu. Nie mają żadnego związku z pierwowzorem. Demonstrację tego można pokazać za pomocą fragmentu kodu podanego poniżej.

matematyka losowa Java

 // declaring a Car function function Car(name) { this.name = name; } // setting up new prop with prototype Car.prototype.color = 'red'; // creating a new Car object const BMW = new Car('x1'); // looping through every car prop including prototype as well for (let car in BMW) { car + ':', BMW[car]; } /* output: name: x1 output: color: red */ /**************************************/ /*will loop through only self properties of the object, excludes property generated through prototype method */ for (let car in BMW) { if (BMW.hasOwnProperty(car)) { console.log(car + ':', BMW[car]); } } // output: name: 

Używanie metody hasOwnProperty() może okazać się bezużyteczne, ponieważ renderowanie obiektu następuje podczas definiowania właściwości o nazwie hasOwnProperty. Aby to potwierdzić, spróbuj zrozumieć fragment kodu podany poniżej.

 var harrypotter = { hasOwnProperty: function() { return true; } }; // Outputs: true console.log(harrypotter.hasOwnProperty('ridikulus')); 

Z powyższego fragmentu kodu widać, że harrypotter ma już właściwość hasOwnProperty. Dlatego nigdy nie wywoła wywołania obiektu.prototype.hasOwnProperty. Zakłada się, że może to spotkać przypadki, w których może pozwolić na wykonanie połączenia, ale może ostatecznie zakończyć się niepowodzeniem. Dlatego zawsze zaleca się mieć świadomość możliwości wykonywania połączeń. Poniższy fragment kodu przedstawia obejście tego problemu.

Aktor Amrita Rao

 // Returns false Object.prototype.hasOwnProperty.call(harrypotter, 'ridikulus'); 

Z powyższego fragmentu kodu jasno wynika, że ​​harrypotter definiuje swój własny ma własną nieruchomość . Nigdy nie będzie wywoływać właściwości Object.prototype.hasOwnProperty, ponieważ istnieje możliwość, że zwróci wartość false w przypadku napotkania przypadków, w których wartość jest fałszywa i trudno będzie sprawić, by wszystko działało za rogiem. Na poparcie tego stwierdzenia zobacz fragment kodu podany poniżej.

 // Returns false Obje ct.prototype.hasOwnProperty.call(harrypotter, 'ridikulus'); 

Podobnie jak hasOwnProperty, istnieje inna metoda zwana metodą „in”. Służy również do sprawdzania, czy klucz jest obecny dla obiektu, czy nie. Należy jednak zauważyć, że kluczowa różnica między metodą hasOwnProperty a metodą in polega na tym, że metoda in nie będzie zgodna z kolejnością rozróżniania właściwości, które są dziedziczone, od tych, które odziedziczone właściwości są tworzone specjalnie dla obiektu. Można to pokazać za pomocą fragmentu kodu podanego poniżej.

 var fantasyLit = { tolkien: 'The Lord of the Rings', lewis: 'The Chronicles of Narnia' }; // Outputs: true console.log('tolkien' in fantasyLit); // Outputs: false console.log('asimov' in fantasyLit); // Outputs: true console.log('constructor' in fantasyLit); 

Z powyższego fragmentu kodu widać, że metoda „in” jest zgodna z właściwością konstruktora obiektu Object.prototype, skąd dziedziczone są wszystkie obiekty.

Aby dodać kilka punktów, obie metody mają wady. Obie metody mogą łatwo dostarczyć nam informacji o właściwości, która została już zadeklarowana, ale nie mogą nam powiedzieć o właściwości zawierającej rzeczywistą wartość.

Rozważ następujący fragment kodu, który pokazuje, w jaki sposób obie metody realizują to obejście.

 // Puts a 'declared' property on the global object // (window in browsers) var declared; // Outputs: true console.log('declared' in window); // Outputs: true console.log(window.hasOwnProperty('declared')); // Outputs: undefined console.log(declared); var obj = { myUndefined: undefined }; // Outputs: true console.log('myUndefined' in obj); // Outputs: true console.log(obj.hasOwnProperty('myUndefined')); // Outputs: undefined console.log(obj.myUndefined); 

Wniosek

W tym samouczku omawialiśmy metodę hasOwnProperty() w JavaScript. Ogólnie rzecz biorąc, ta metoda jest doskonałym wyborem dla większości programistów, aby zapytać i uniknąć problemów związanych z niektórymi kluczami specjalnymi, takimi jak konstruktor. Zaleca się, aby jeśli znajdziemy jakiś obiekt posiadający jakąkolwiek właściwość, domyślnie użył funkcji hasOwnProperty(). W przypadku obecności funkcji mającej na celu wykonanie wywołania poprzez sprawdzenie obiektu pod kątem metody toString() należy skorzystać z in.