una - saber si un objeto esta vacio javascript
¿Comprobando si existe una clave en un objeto JavaScript? (19)
Aquí hay una función de ayuda que encuentro bastante útil
¡Este keyExists(key, search) puede usarse para buscar fácilmente una clave dentro de objetos o matrices!
Simplemente pase la clave que desea encontrar y busque el objeto (el objeto o la matriz) en el que desea encontrarlo.
function keyExists(key, search) {
if (!search || (search.constructor !== Array && search.constructor !== Object)) {
return false;
}
for (var i = 0; i < search.length; i++) {
if (search[i] === key) {
return true;
}
}
return key in search;
}
Cómo usarlo:
Buscando claves en matrices
keyExists(''apple'', [''apple'', ''banana'', ''orange'']); // true
keyExists(''fruit'', [''apple'', ''banana'', ''orange'']); // false
Buscando claves en objetos
keyExists(''age'', {''name'': ''Bill'', ''age'': 29 }); // true
keyExists(''title'', {''name'': ''Jason'', ''age'': 29 }); // false
Ha sido bastante confiable y funciona bien en varios navegadores.
¿Cómo verifico si una clave en particular existe en un objeto o matriz de JavaScript?
Si no existe una clave y trato de acceder a ella, ¿devolverá falsa? O lanzar un error?
Solución ES6
usando Array#some y Object.keys . Devolverá verdadero si existe una clave dada en el objeto o falso si no existe.
var obj = {foo: ''one'', bar: ''two''};
function isKeyInObject(obj, key) {
var res = Object.keys(obj).some(v => v == key);
console.log(res);
}
isKeyInObject(obj, ''foo'');
isKeyInObject(obj, ''something'');
Ejemplo de una línea.
console.log(Object.keys({foo: ''one'', bar: ''two''}).some(v => v == ''foo''));
respuesta rápida
¿Cómo verifico si una clave en particular existe en un objeto o matriz de JavaScript? Si una clave no existe e intento acceder a ella, ¿devolverá false? O lanzar un error?
El acceso directo a una propiedad faltante utilizando un estilo de matriz (asociativa) o un estilo de objeto devolverá una constante indefinida .
El método de operador y hasOwnProperty es lento y confiable.
Como las personas ya han mencionado aquí, podría tener un objeto con una propiedad asociada con una constante "indefinida".
var bizzareObj = {valid_key: undefined};
En ese caso, tendrá que usar hasOwnProperty o en el operador para saber si la clave está realmente allí. Pero, ¿ pero a qué precio?
entonces te digo ...
in operator y hasOwnProperty son "métodos" que utilizan el mecanismo de descriptor de propiedades en Javascript (similar a la reflexión de Java en el lenguaje Java).
http://www.ecma-international.org/ecma-262/5.1/#sec-8.10
El tipo de descriptor de propiedad se usa para explicar la manipulación y la reificación de los atributos de propiedad nombrados. Los valores del tipo de descriptor de propiedad son registros compuestos de campos con nombre donde el nombre de cada campo es un nombre de atributo y su valor es un valor de atributo correspondiente como se especifica en 8.6.1. Además, cualquier campo puede estar presente o ausente.
Por otro lado, al llamar a un método o clave de objeto se utilizará el mecanismo Javascript [[Get]]. ¡Eso es mucho más rápido!
punto de referencia
http://jsperf.com/checking-if-a-key-exists-in-a-javascript-array
.
Utilizando en operadorvar result = "Impression" in array;
El resultado fue
12,931,832 ±0.21% ops/sec 92% slower
Usando hasOwnProperty
var result = array.hasOwnProperty("Impression")
El resultado fue
16,021,758 ±0.45% ops/sec 91% slower
Accediendo elementos directamente (estilo paréntesis)
var result = array["Impression"] === undefined
El resultado fue
168,270,439 ±0.13 ops/sec 0.02% slower
Accediendo a los elementos directamente (estilo de objeto)
var result = array.Impression === undefined;
El resultado fue
168,303,172 ±0.20% fastest
EDITAR: ¿Cuál es la razón para asignar a una propiedad el valor undefined ?
Esa pregunta me desconcierta. En Javascript, hay al menos dos referencias de objetos ausentes para evitar problemas como este: null e undefined .
null es el valor primitivo que representa la ausencia intencional de cualquier valor de objeto, o en términos cortos, la falta de valor confirmada . Por otro lado, undefined es un valor desconocido (no definido). Si hay una propiedad que se usará más adelante con un valor adecuado , considere usar una referencia null lugar de undefined porque en el momento inicial se confirma que la propiedad carece de un valor.
Comparar:
var a = {1: null};
console.log(a[1] === undefined); // output: false. I know the value at position 1 of a[] is absent and this was by design, i.e.: the value is defined.
console.log(a[0] === undefined); // output: true. I cannot say anything about a[0] value. In this case, the key 0 was not in a[].
Asesorar
Evita objetos con valores undefined . Verifique directamente siempre que sea posible y use null para inicializar los valores de propiedad. De lo contrario, use el método slow in operator o hasOwnProperty() .
EDITAR: 12/04/2018 - NO ES PERTINENTE ANTES
Como la gente ha comentado, las versiones modernas de los motores de Javascript (con la excepción de Firefox) han cambiado el enfoque de las propiedades de acceso. La implementación actual es más lenta que la anterior para este caso en particular, pero la diferencia entre la clave de acceso y el objeto es despreciable.
Para aquellos que han incluido lodash en su proyecto:
Existe un método lodash _.get que intenta obtener claves "profundas":
Obtiene el valor en la ruta del objeto. Si el valor resuelto no está definido, se devuelve el valor predeterminado en su lugar.
var object = { ''a'': [{ ''b'': { ''c'': 3 } }] };
console.log(
_.get(object, ''a[0].b.c''), // => 3
_.get(object, [''a'', ''0'', ''b'', ''c'']), // => 3
_.get(object, ''a.b.c''), // => undefined
_.get(object, ''a.b.c'', ''default'') // => ''default''
)
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>
Esto comprobará de manera efectiva si esa clave, aunque sea profunda , está definida y no generará un error que podría dañar el flujo de su programa si esa clave no está definida.
Podemos usar - hasOwnProperty.call(obj, key);
La forma de underscore.js
if(_.has(this.options, ''login'')){
//key ''login'' exists in this.options
}
_.has = function(obj, key) {
return hasOwnProperty.call(obj, key);
};
Esta es una pregunta antigua, pero creo que nunca es tarde para dar una respuesta.
Imagina que tienes un objeto "productos" y dos artículos. Si desea ver si ya existe una identificación en este objeto, puede usar find ()
products = [
{
"id": 1,
"name": "Name 1"
},
{
"id": 2,
"name": "Name 2"
},
]
item1 =
{
"id": 3,
"name": "Name 3",
}
item2 =
{
"id": 1,
"name": "Name 1",
}
if(products.find(x => x.id === item1.id)){
console.log(''id is in products'');
}else {
console.log(''id is not in products'');
}
if(products.find(x => x.id === item2.id)){
console.log(''id is in products'');
}else {
console.log(''id is not in products'');
}
Iniciar sesión:
id is not in products
id is in products
Estos ejemplos pueden demostrar las diferencias entre los distintos caminos. Espero que te ayude a elegir el adecuado para tus necesidades:
// Lets create object `a` using create function `A`
function A(){};
A.prototype.onProtDef=2;
A.prototype.onProtUndef=undefined;
var a=new A();
a.ownProp = 3;
a.ownPropUndef = undefined;
// Let''s try different methods:
a.onProtDef; // 2
a.onProtUndef; // undefined
a.ownProp; // 3
a.ownPropUndef; // undefined
a.whatEver; // undefined
a.valueOf; // ƒ valueOf() { [native code] }
a.hasOwnProperty(''onProtDef''); // false
a.hasOwnProperty(''onProtUndef''); // false
a.hasOwnProperty(''ownProp''); // true
a.hasOwnProperty(''ownPropUndef''); // true
a.hasOwnProperty(''whatEver''); // false
a.hasOwnProperty(''valueOf''); // false
''onProtDef'' in a; // true
''onProtUndef'' in a; // true
''ownProp'' in a; // true
''ownPropUndef'' in a; // true
''whatEver'' in a; // false
''valueOf'' in a; // true (on the prototype chain - Object.valueOf)
Object.keys(a); // ["ownProp", "ownPropUndef"]
La comprobación de la falta de definición no es una forma precisa de comprobar si existe una clave. ¿Qué pasa si la clave existe pero el valor es en realidad undefined ?
var obj = { key: undefined };
obj["key"] != undefined // false, but the key exists!
En su lugar, debe utilizar el operador in :
"key" in obj // true, regardless of the actual value
Si desea verificar si una clave no existe, recuerde usar paréntesis:
!("key" in obj) // true if "key" doesn''t exist in object
!"key" in obj // ERROR! Equivalent to "false in obj"
O, si desea probar particularmente las propiedades de la instancia del objeto (y no las propiedades heredadas), use hasOwnProperty :
obj.hasOwnProperty("key") // true
Para la comparación de rendimiento entre los métodos que se encuentran in , hasOwnProperty y la clave undefined está undefined , vea este jsben.ch/#/WqlIl
La forma más fácil de comprobarlo es
"key" in object
por ejemplo:
var obj = {
a: 1,
b: 2,
}
"a" in obj // true
"c" in obj // false
El valor devuelto como verdadero implica que la clave existe en el objeto.
La respuesta aceptada se refiere al Object . Tenga cuidado al usar el operador in en Array para encontrar datos en lugar de claves:
("true" in ["true", "false"])
// -> false (Because the keys of the above Array are actually 0 and 1)
Para probar los elementos existentes en una matriz: ¿La mejor manera de encontrar si un elemento está en una matriz de JavaScript?
Nueva solución impresionante con la destrucción de JavaScript :
let obj = {
"key1": "value1",
"key2": "value2",
"key3": "value3",
};
let {key1, key2, key3, key4} = obj;
// key1 = "value1"
// key2 = "value2"
// key3 = "value3"
// key4 = undefined
// Can easily use `if` here on key4
if(!key4) { console.log("key not present"); } // Key not present
Verifica otro uso de JavaScript Destructura
Si bien esto necesariamente comprueba si existe una clave, comprueba la veracidad de un valor. Que undefined y null caen bajo.
Boolean(obj.foo)
Esta solución funciona mejor para mí porque uso obj.hasOwnProperty(''foo'') y el uso de cadenas como ''foo'' in obj u obj.hasOwnProperty(''foo'') para verificar si una clave existe o no, no me proporciona intellisense.
Si desea verificar cualquier clave a cualquier profundidad en un objeto y tener en cuenta los valores de falsey, considere esta línea para una función de utilidad:
var keyExistsOn = (o, k) => k.split(".").reduce((a, c) => a.hasOwnProperty(c) ? a[c] || 1 : false, Object.assign({}, o)) === false ? false : true;
Resultados
var obj = {
test: "",
locals: {
test: "",
test2: false,
test3: NaN,
test4: 0,
test5: undefined,
auth: {
user: "hw"
}
}
}
keyExistsOn(obj, "")
> false
keyExistsOn(obj, "locals.test")
> true
keyExistsOn(obj, "locals.test2")
> true
keyExistsOn(obj, "locals.test3")
> true
keyExistsOn(obj, "locals.test4")
> true
keyExistsOn(obj, "locals.test5")
> true
keyExistsOn(obj, "sdsdf")
false
keyExistsOn(obj, "sdsdf.rtsd")
false
keyExistsOn(obj, "sdsdf.234d")
false
keyExistsOn(obj, "2134.sdsdf.234d")
false
keyExistsOn(obj, "locals")
true
keyExistsOn(obj, "locals.")
false
keyExistsOn(obj, "locals.auth")
true
keyExistsOn(obj, "locals.autht")
false
keyExistsOn(obj, "locals.auth.")
false
keyExistsOn(obj, "locals.auth.user")
true
keyExistsOn(obj, "locals.auth.userr")
false
keyExistsOn(obj, "locals.auth.user.")
false
keyExistsOn(obj, "locals.auth.user")
true
También vea este paquete NPM: https://www.npmjs.com/package/has-deep-value
Si está utilizando la biblioteca underscore.js operaciones de objeto / matriz se vuelven simples.
En su caso se puede utilizar el método _.has. Ejemplo:
yourArray = {age: "10"}
_.has(yourArray, "age")
devuelve verdadero
Pero,
_.has(yourArray, "invalidKey")
devuelve falso
Tres formas de verificar si una propiedad está presente en un objeto javascript:
- !! obj.la propiedad
Convertirá valor a bool. devuelve VERDADERO para todos menos el valor ''falso'' - ''theProperty'' en obj
Devolverá verdadero si la propiedad existe, sin importar su valor (incluso vacío) - obj.hasOwnProperty (''theProperty'')
No comprueba la cadena del prototipo. (ya que todos los objetos tienen el método ''toString'', 1 y 2 devolverán verdadero en él, mientras que 3 pueden devolver falso en él.)
Referencia:
Volverá undefined .
var aa = {hello: "world"};
alert( aa["hello"] ); // popup box with "world"
alert( aa["goodbye"] ); // popup box with "undefined"
undefined es un valor constante especial. Así que puedes decir, por ejemplo,
// note the three equal signs so that null won''t be equal to undefined
if( aa["goodbye"] === undefined ) {
// do something
}
Esta es probablemente la mejor manera de verificar si faltan llaves. Sin embargo, como se señala en un comentario a continuación, es teóricamente posible que desee que el valor real undefined esté undefined . Nunca he necesitado hacer esto y no puedo pensar en una razón de por qué querría hacerlo, pero solo por razones de integridad, puede usar el operador in
// this works even if you have {"goodbye": undefined}
if( "goodbye" in aa ) {
// do something
}
vanila js
yourObjName.hasOwnProperty(key) : true ? false;
Si desea comprobar si el objeto tiene al menos una propiedad en es2015
Object.keys(yourObjName).length : true ? false
Responder:
if ("key" in myObj)
{
console.log("key exists!");
}
else
{
console.log("key doesn''t exist!");
}
Explicación:
El operador in comprobará si la clave existe en el objeto. Si comprobó si el valor no estaba definido: if (myObj["key"] === ''undefined'') , podría tener problemas porque posiblemente podría haber una clave en su objeto con el valor undefined .
Por esa razón, es una práctica mucho mejor usar primero el operador in y luego comparar el valor que está dentro de la clave una vez que ya sabes que existe.
"key" in obj
Es probable que solo pruebe valores de atributos de objetos que son muy diferentes de las claves de matriz