Cómo usar Some en Javascript (ES6)

por jesuscuesta el en Javascript

Una de las funciones interesantes que podemos hacer uso con Javascript, para hacer nuestro código más elegante es Some. ¿Qué hace esta función? ¿Cuándo es aconsejable usarla?

El método some() comprueba si un elemento del array cumple con una condición, y nos devuelve un booleano. Esto implica que esta función la utilizaremos cuando trabajemos con arrays de cualquier tipo, sean arrays de strings, array de objetos, etc.

Sintaxis

La sintaxis completa del método sería:

arr.some(callback(element[, index[, array]])[, thisArg])

Como podemos observar, además de utilizar el array y el elemento que compararemos, también nos tendremos la posibilidad (como en el resto de métodos de JS), la posibilidad de utilizar el index (posición dentro del array) y el array completo.

 

Parámetros

callbackFunción que verifica cada elemento, toma tres argumentos:

element
El elemento actual siendo procesado en el array.
index Optional
El índice del elemento del array que se está procesando.
array Optional
El array sobre el que ha sido llamada la función some().

thisArg OptionalValor a usar como this cuando se ejecute callback.

 

Compatibilidad Navegadores

Será importante que tengamos en cuenta que versión de navegador está utilizando en cliente, sobre todo si estamos en un proyecto de intranet.

Además deberemos tener en cuenta, que fue agregado al estándar ECMA-262 en el 5ta edición, por ello puede no estar presente en todas las implementaciones estándar.

Ejemplos

Básico

En este ejemplo básico, podemos ver como se crear una variable para el array que se recorrerá, otra variable para la condición que tendremos en cuenta con some y por último, la variable que almacenará el resultado cuando realice la función. Hemos añadido dos ejemplos, uno que devuelva true y otro false.

const array = [1, 2, 3, 4, 5];
// Comprueba cualquier elemento si cumple la condición. En el caso de que uno cumpla la condición, devolverá true.
// En este caso, comprobamos si algún elemento es par
const even = (element) => element % 2 === 0;
// Le pasamos a some, la condición
console.log(array.some(even));
// resultado: true

const arrayDos = [1, 3, 5];
const evenDos = (element) => element % 2 === 0;
console.log(arrayDos.some(evenDos));
// resultado: false

 

Sin Variable

Si estamos trabajando con condiciones muy sencillas y/o condiciones que solo vamos a utilizar una vez, podemos realizarlo sin tener que asignarlo a una variable la condición.

const array = [1, 3, 3, 4, 5];
console.log(array.some(data => data %2));
// expected output: true

 

Con Function

En el caso de que no estemos familiarizados con las arrow function, sigue siendo compatible el uso de function. No tenemos que olvidar, que entonces deberemos añadir el return y las llaves al comienzo y al final.

const array = [1, 3, 3, 4, 5];
console.log(array.some(function(data) { return data => data %2; }));
// expected output: true

 

Recorriendo un Objeto

Lo más probable, es que acabéis utilizando el método some para recorrer arrays de objetos.

const array = [
  {
    id: 1,
    lenguaje: 'javascript'
  },
  {
    id: 2,
    lenguaje: 'typescript'
  }
];

console.log(array.some(data => data.lenguaje === 'javascript'));
// expected output: true

 

Condiciones complejas sin variable

En el caso de que queráis utilizar comparaciones más complejas en varias líneas y que no queráis añadirlas a una variable, deberemos utilizar un sistema parecido al indicado con function. Deberemos abrir unas llaves y añadir return para que devuelva el resultado.

Este tipo de aproximaciones, generalmente se desaconsejan, dado que suelen complicar la realización de test unitarios, la comprensión del código, además de no utilizar ciertos patrones de desarrollo.

const array = [
  {
    id: 1,
    lenguaje: 'javascript',
    
  },
  {
    id: 2,
    lenguaje: 'typescript'
  }
];

console.log(array.some(data => 
        {
            let result = false;
            result = data.lenguaje === 'javascript' && data.id == 1;
            return result;
        }
    )
);
// expected output: true

 

Con todos los parámetros

En algunos casos nos interesará aplicar ciertas condiciones solamente a ciertas posiciones del array. En este ejemplo, solo tenemos en cuenta, que los elementos del array por encima de la posición 3, sean mayores que 10.

const array = [1, 2, 3, 4, 12];

function isBiggerThan10(element, index, array) {
  return index > 3 && element > 10;
}

console.log(array.some(isBiggerThan10));
// expected output: true

 

Otras Implementaciones

Según las personas y el equipo donde estemos trabajando nos podremos encontrar diferentes implementaciones y usos de este método. Además, en algunos casos, puede que sean más o menos correctos, pero al menos, podremos comprender el código más rápidamente, si ya los hemos visto.

 

Directamente contra el Array

console.log([2, 5, 8, 1, 4].some(elem => elem > 10));

 

Sobre Ternaria

const array = [1, 2, 3, 4, 5];
const even = (element) => element % 2 === 0;

const result = array.some(even) ? 'primero': 'segundo';

console.log(result);
// expected output: primero

 

Modificando el array

Además del elemento y el index, también tendremos acceso al array. Deberemos tener cuidado, dado que se parará de recorrer el array, cuando encuentre el primer valor a true.

const array = [1, 2, 3, 4, 5];

// checks whether an element is even
function validacion(element, index, array) {
  const result = element % 2 === 0;
  array[index] = 0;
  return result;
}

console.log(array.some(validacion));
// true
console.log(array);
// Array [0, 0, 3, 4, 5]

 

Performance

 

Bibliografía