Neste tutorial, veremos os aspectos de limitações e funções relacionadas ao hasOwnProperty() método em JavaScript. Também aprenderemos sobre suas implementações e uso nas seções.

Introdução

Em JavaScript , o método hasOwnProperty() é definido como uma propriedade para garantir se o objeto pertence ou não ao projeto mencionado. Se for descoberto que a propriedade pertence a um objeto reconhecido, ela retornará uma saída baseada em uma instrução booleana, ou seja, verdadeira ou falsa.

Sintaxe

 object.hasOwnProperty(propname) 

Argumento

Gravação:

Aqui precisamos passar o símbolo ou o nome da string porque este é o local da prop onde é verificado se o símbolo ou string pertence ao objeto. Isso é feito usando o método fornecido abaixo.

 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 

Um aspecto importante a ser observado aqui é que o método hasOwnProperty() geralmente ignora propriedades herdadas. Isso significa que o método retornará verdadeiro se o objeto tiver uma propriedade não herdada e o nome for especificado por propname. Se retornar falso, significa que o objeto não possui nenhuma propriedade com um nome especificado ou herdou a propriedade do objeto do proptype.

 // 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 

Outra vantagem adicional de usar o método hasOwnProperty() é que ele pode inicializar um objeto seguindo o conceito de passar uma string como argumento padrão. Ele responderá rapidamente com true se o valor estiver disponível para o objeto. Caso contrário, retornará falso se não for encontrado. Isso pode ser demonstrado usando o trecho de código fornecido abaixo.

 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 

No trecho de código fornecido acima, a variável cria um novo objeto, Carro . Pode-se agora afirmar que o Carro é iniciado tendo suas propriedades e nome definidos no construtor. Embora a cor possa não ser mencionada no objeto quando iniciada, ela estará sempre disponível no protótipo hierarquia . Portanto, hasOwnProperty() retornará true sempre para o nome, mas para cor retornará false.

Quando se trata de desempenho, hasOwnProperty() funciona perfeitamente enquanto percorre o objeto com loops. Até agora, podemos dizer isso se as propriedades pertencem especificamente ao objeto. Eles não têm nenhuma correlação com o protótipo. A demonstração disso pode ser mostrada usando o trecho de código fornecido a seguir.

 // 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: 

Ao usar o método hasOwnProperty(), ele pode se tornar inútil porque a renderização do objeto ocorre ao definir uma propriedade chamada hasOwnProperty. Para apoiar isso, tente entender o trecho de código fornecido abaixo.

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

No trecho de código acima, é evidente que harrypotter já possui hasOwnProperty. Assim, ele nunca fará uma chamada para object.prototype.hasOwnProperty. Supõe-se que isso pode ocorrer em casos em que pode permitir a realização de uma chamada, mas pode eventualmente falhar. Então, é sempre recomendável ficar atento à possibilidade de ligações. O trecho de código abaixo mostra sua solução alternativa.

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

No trecho de código acima, fica claro que Harrypotter define seu próprio temOwnProperty . Ele nunca fará chamadas para Object.prototype.hasOwnProperty porque existe a possibilidade de retornar false se encontrar alguns casos em que o valor é false e se tornar difícil fazer as coisas funcionarem rapidamente. Para apoiar esta afirmação, consulte o trecho de código fornecido abaixo.

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

Semelhante ao hasOwnProperty, existe outro método chamado método 'in'. Também é usado para verificar se a chave está presente ou não para o objeto. No entanto, é importante observar que a principal diferença entre hasOwnProperty e o método in reside no fato de que o método in não seguirá a ordem de distinção entre as propriedades que são herdadas e as propriedades herdadas que são criadas especialmente para o objeto. Isso pode ser mostrado usando o trecho de código fornecido abaixo.

vlc para baixar o youtube

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

No trecho de código acima, é evidente que o método 'in' segue a propriedade construtora de Object.prototype de onde todos os objetos são herdados.

Para acrescentar alguns pontos, há uma desvantagem para ambos os métodos. Ambos os métodos podem facilmente nos fornecer informações sobre uma propriedade que já foi declarada, mas não podem nos informar sobre a propriedade que contém um valor real.

Considere o seguinte trecho de código que mostra como ambos os métodos executam essa solução alternativa.

 // 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); 

Conclusão

Neste tutorial, discutimos sobre o método hasOwnProperty() em JavaScript. Em geral, este método é uma ótima opção para a maioria dos desenvolvedores consultarem e evitarem problemas relacionados a algumas chaves especiais, como o construtor. É recomendado que se encontrarmos qualquer objeto com alguma propriedade, ele usará hasOwnProperty() por padrão. No caso da presença de função destinada a fazer uma chamada verificando o objeto para o método toString(), devemos utilizar in.