Cómo comprobar si existe una clave en un objeto/matriz de JavaScript

Un objeto en JavaScript es una colección desordenada de pares clave-valor (clave: valor). Cada clave se conoce como una propiedad y es una cadena que representa una propiedad na...

Introducción

Un objeto en JavaScript es una colección desordenada de pares clave-valor (clave: valor). Cada clave se conoce como propiedad y es una cadena que representa el nombre de una propiedad. Si se proporciona una clave que no es una cadena, se usará su representación en forma de cadena. El valor de una propiedad puede ser de cualquier tipo de datos que se ajuste conceptualmente a la propiedad: una cadena, un número, una matriz o incluso una función.

Una matriz, por otro lado, es un conjunto ordenado de valores. Cada valor se denomina elemento, que se identifica mediante un índice numérico. Una matriz puede incluir valores de casi cualquier tipo. Por ejemplo, puede almacenar elementos como números enteros, cadenas, booleanos, funciones, etc. Las matrices de JavaScript tampoco están restringidas a un solo tipo, lo que significa que una matriz determinada puede contener múltiples tipos diferentes dentro de ella.

Cuando trabaje en JavaScript, es posible que, en un momento determinado, necesite determinar si existe una clave en un objeto o matriz determinados.

En este artículo, veremos los diversos métodos que podríamos usar para verificar si existe una clave en particular en un objeto/arreglo de JavaScript.

Uso del operador in

El operador in en JavaScript se usa para determinar si una determinada propiedad existe en un objeto o sus propiedades heredadas (también conocidas como su cadena de prototipo). Si la propiedad proporcionada existe, el operador in devuelve verdadero.

Comprobación de un objeto
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};
  
// Check if key exists
  
'name' in user; // Returns true
'profession' in user; // Returns true
'Daniel' in user; // Returns false becuase no key like that exists
'Farmer' in user; // Returns false because 'Farmer' is not a key, but a value
Comprobación de una matriz

Ya que demostramos que el operador in de JavaScript se puede usar con objetos, es posible que se pregunte si también se puede usar con matrices. En JavaScript, todo es una instancia del tipo de objeto (excepto las primitivas), por lo que las matrices también admiten el operador in.

Confirmemos si es una instancia del tipo Objeto usando el operador instanceof:

1
2
3
let numbers = [22, 3, 74, 35];
  
numbers instanceof Object // Returns true

Ahora, volvamos a usar el operador in:

1
2
3
4
5
6
7
8
9
let numbers = [12, 33, 14, 45, 6];

// Checking if index 1 is present
1 in numbers; // Returns true
// Checking if index 3 is present
3 in numbers; // Returns true

8 in numbers; // Returns false because the 8 index does exist in the array 
6 in numbers; // Returns false because the 6 index does not exist in the array

Esto también devolverá true para las propiedades del método en un tipo de matriz, de las cuales la matriz de números es una instancia.

1
'map' in number; // Returns true because 'map' is a method attribute of the array type

Usando el método hasOwnProperty()

En JavaScript, la función hasOwnProperty() se utiliza para determinar si el objeto tiene la propiedad proporcionada como propiedad propia. Esto es importante para determinar si el objeto heredó el atributo en lugar de ser propio.

Comprobación de un objeto
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};
  
// Check if key exists
let hasKey = user.hasOwnProperty('name'); 
  
if (hasKey) {
    console.log('This key exists.');
} else {
    console.log('This key does not exist.');
}
Comprobación de una matriz

Puede comenzar a preguntarse si esto funcionaría para matrices. Como establecimos anteriormente, una matriz es en realidad un prototipo (instancia) del tipo ‘Objeto’, por lo que también tiene disponible este método.

1
2
3
4
5
6
let number = [12, 33, 14, 45];

// Check if key exists
number.hasOwnProperty(1); // Returns true
number.hasOwnProperty(0); // Returns true
number.hasOwnProperty(7); // Returns false because 7 is not an existing index on the array

Usando el método Object.key()

El método estático Object.key genera y devuelve una matriz cuyos componentes son cadenas de nombres (claves) de las propiedades de un objeto. Esto se puede usar para recorrer las claves del objeto, que luego podemos usar para verificar si alguna coincide con una determinada clave en el objeto.

Usando el método some()

some() es un método de JavaScript que prueba una función de devolución de llamada en todos los elementos de la matriz de llamadas y devuelve verdadero si la función de devolución de llamada devuelve verdadero para cualquiera de ellos.

Uso de some() para objetos
1
2
3
4
5
6
7
8
9
let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};
  
// Check if key exists
Object.keys(user).some(key => key === 'name'); // Returns true
Object.keys(user).some(key => key === 'role'); // Returns false

También podríamos personalizar esto en una función reutilizable:

1
2
3
4
5
6
const checkKey = (obj, keyName) => {
    let keyExist = Object.keys(obj).some(key => key === keyName);
    console.log(keyExist);
};
  
checkKey(user, 'name'); // Return true
Uso de some() para una matriz
1
2
3
4
5
let number = [12, 33, 14, 45];
    
// Check if key exists
number.some(value => value === 1); // Returns true
number.some(value => value === 7); // Returns false

Nuevamente, al igual que con el objeto, también podríamos hacer uso de una función reutilizable personalizada similar para verificar la existencia de un valor en una matriz:

1
2
3
4
5
6
7
const checkVal = (arr, val) => {
    let valExist = arr.some(value => value === val);
    console.log(valExist);
};

checkVal(number, 7); // Returns false
checkVal(number, 0); // Returns true
Usando el método indexOf()

El método indexOf() de JavaScript devolverá el índice de la primera instancia de un elemento en la matriz. Si el elemento no existe, se devuelve -1.

Uso de indexOf() para un objeto

El tipo Objeto en JavaScript en realidad no es compatible con el método indexOf, ya que sus propiedades/claves no tienen inherentemente posiciones indexadas en el objeto. En cambio, podemos obtener las claves del objeto como una matriz y luego verificar la existencia de una clave usando el método indexOf:

1
2
3
4
5
6
7
8
9
let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};

// Check if key exists
Object.keys(user).indexOf('name') // Returns 0
Object.keys(user).indexOf('role') // Returns -1

Tenga en cuenta que los objetos de JavaScript no siempre conservan el orden de las claves, por lo que el índice devuelto puede no ser tan significativo como en las matrices. En este caso, el índice debe usarse principalmente para determinar solo la existencia de una clave.

Aquí hay un ejemplo de cómo usar esto en una función de utilidad:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
const checkKey = (obj, keyName) => {
    if (Object.keys(obj).indexOf(keyName) !== -1) {
        console.log('This key exists');
    } else {
        console.log('This key does not exist');
    }
};
  
checkKey(user, 'name'); // Logs 'This key exists'
checkKey(user, 'role'); // Logs 'This key does not exists'
Uso de indexOf() para una matriz

Como vimos en el ejemplo anterior, las matrices admiten el método indexOf, a diferencia de los objetos. Para usarlo, pase el valor del elemento que está buscando a indexOf, que luego devolverá la posición de ese valor si existe en la matriz:

1
2
3
4
5
let number = [12, 33, 14, 45];
    
// Find position of the item in the array
number.indexOf(14); // Returns 2
number.indexOf(7);  // Returns -1

Conclusión

En este artículo, hemos visto todas las formas posibles en las que podemos verificar si una clave o elemento existe en un objeto/matriz de JavaScript. Mostramos cómo utilizar el operador in, el método hasOwnProperty() y el método some. También vimos cómo los objetos JS y las matrices son similares en el sentido de que las matrices se heredan de los objetos y, por lo tanto, contienen muchos de los mismos métodos.