En este tutorial veremos los aspectos de limitaciones y funciones relacionadas con el tienePropiedadPropiedad() método en JavaScript. También aprenderemos sobre sus implementaciones y uso en las secciones.
Introducción
En javascript , el método hasOwnProperty() se define como una propiedad para garantizar si el objeto pertenece al proyecto mencionado o no. Si se descubre que la propiedad pertenece a un objeto reconocido, devolverá una salida basada en una declaración booleana, es decir, verdadera o falsa.
Sintaxis
object.hasOwnProperty(propname)
Argumento
Grabación:
Aquí necesitamos pasar el símbolo o el nombre de la cadena porque este es el lugar de la propiedad donde se verifica si el símbolo o la cadena pertenece al objeto. Esto se hace utilizando el método que se indica a continuación.
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 Un aspecto importante a tener en cuenta aquí es que el método hasOwnProperty() generalmente ignora las propiedades heredadas. Esto significa que el método devolverá verdadero si se descubre que el objeto tiene una propiedad no heredada y el nombre se especifica mediante propname. Si devuelve falso, entonces significa que el objeto no tiene ninguna propiedad con un nombre específico, o ha heredado la propiedad del objeto del tipo de propiedad.
// 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
Otra ventaja adicional de usar el método hasOwnProperty() es que puede inicializar un objeto siguiendo el concepto de pasar una cadena como argumento predeterminado. Responderá rápidamente con verdadero si se encuentra que el valor está disponible para el objeto. De lo contrario, devolverá falso si no se encuentra. Se puede demostrar utilizando el fragmento de código que se proporciona a continuación.
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 En el fragmento de código proporcionado anteriormente, la variable crea un nuevo objeto, Auto . Ahora se puede afirmar que el Coche se inicia con sus propiedades y nombre definidos en el constructor. Aunque es posible que el color no se mencione dentro del objeto cuando se inicia, siempre estará disponible en el prototipo. jerarquía . Por lo tanto, hasOwnProperty() devolverá verdadero siempre para el nombre, pero para el color, devolverá falso.
Cuando se trata de rendimiento, hasOwnProperty() funciona sin problemas mientras recorre el objeto con bucles. A estas alturas, podemos decir que si las propiedades pertenecen específicamente al objeto. No tienen ninguna correlación con el prototipo. La demostración de esto se puede mostrar utilizando el fragmento de código que se proporciona a continuación.
// 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: Al usar el método hasOwnProperty(), puede volverse inútil porque la representación del objeto ocurre al definir una propiedad llamada hasOwnProperty. Para respaldar esto, intente comprender el fragmento de código que se proporciona a continuación.
var harrypotter = { hasOwnProperty: function() { return true; } }; // Outputs: true console.log(harrypotter.hasOwnProperty('ridikulus')); En el fragmento de código anterior, es evidente que Harrypotter ya tiene hasOwnProperty. Por lo tanto, nunca realizará una llamada a object.prototype.hasOwnProperty. Se supone que esto podría encontrar casos en los que podría permitir realizar una llamada, pero eventualmente podría fallar. Por eso, siempre se recomienda estar atento a la posibilidad de llamadas. El siguiente fragmento de código muestra su solución.
// Returns false Object.prototype.hasOwnProperty.call(harrypotter, 'ridikulus');
En el fragmento de código anterior, queda claro que harrypotter define su propio tienePropiedadPropiedad . Nunca realizará llamadas a Object.prototype.hasOwnProperty porque existe la posibilidad de que devuelva falso si encuentra algunos casos en los que el valor es falso y resulta difícil hacer que las cosas funcionen a la vuelta de la esquina. Para respaldar esta declaración, consulte el fragmento de código que se proporciona a continuación.
// Returns false Obje ct.prototype.hasOwnProperty.call(harrypotter, 'ridikulus');
Similar a hasOwnProperty, existe otro método llamado método 'in'. También se utiliza para comprobar si la clave está presente para el objeto o no. Sin embargo, es importante tener en cuenta que la diferencia clave entre el método hasOwnProperty y el in radica en el hecho de que el método in no seguirá el orden de distinguir entre las propiedades que se heredan y las que se crean especialmente para el objeto. Esto se puede mostrar utilizando el fragmento de código que se proporciona a continuación.
lanzamiento de excepción java
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); En el fragmento de código anterior, es evidente que el método 'in' sigue la propiedad del constructor de Object.prototype desde donde se heredan todos los objetos.
Para agregar algunos puntos, ambos métodos tienen una desventaja. Ambos métodos pueden brindarnos fácilmente información sobre una propiedad que ya ha sido declarada, pero no pueden informarnos sobre la propiedad que contiene un valor real.
Considere el siguiente fragmento de código que muestra cómo ambos métodos implementan esta solución.
// 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); Conclusión
En este tutorial, discutimos sobre el método hasOwnProperty() en JavaScript. En general, este método es una excelente opción para que la mayoría de los desarrolladores realicen consultas y eviten problemas relacionados con algunas claves especiales como el constructor. Se recomienda que si encontramos algún objeto que tenga alguna propiedad, utilice hasOwnProperty() de forma predeterminada. En caso de presencia de una función destinada a realizar una llamada verificando el objeto para el método toString(), debemos usar in.