Ya debes conocer ES6, el estandar Javascript de 2015 y una actualización radical desde el anterior estandar (2009). Lo que quizá no sabes es que desde entonces se acordó sacar un nuevo estandar JS cada año. Este año se ha aprovado el estandar ES2016.
¿Cuales son las novedades?
Las expectativas eran muy altas y se barajaban muchas opciones interesantes. Al final ha resultado una actualización descafeinada y solo se han incorporado 2 novedades, FAIL!. Veamos de que se trata:
- El método includes() de Array
- El operador de exponenciación (**)
Método includes()
El método includes que se ha añadido a la clase Array sirve para encontrar elementos dentro de un Array, es decir, devuelve true si un elemento se encuentra dentro de Array y false en caso contrario.
Array.prototype.includes(value : any) : boolean
Además, también se ha incorporado este método a los Typed Arrays, como por ejemplo Unit8Array
.
Te enseño algunos ejemplos:
['a', 'b', 'c', 'd'].includes('a'); //true
['a', 'b', 'c', 'd'].includes('x'); //false
['hola', 'caracola'].includes('hola'); //true
Uint8Array.of(12, 5, 3).includes(5); // true
Diferencias con indexOf
Ambos métodos se parecen. Las 2 expresiones siguientes son equivalentes:
myArray.includes('a')
myArray.indexOf('a') >= 0
Sin embargo, includes() es capaz de detectar el valor NaN, mientras que indexOf no puede.
[NaN].includes(NaN); //true
[NaN].indexOf(NaN); //-1
Este includes() me suena de ES6…
Es posible. En ES2015 se incorporó el método includes() a los Strings. Con ES2016 se extiende esta funcionalidad a los Arrays.
//String.prototype.includes de ES6
'hola'.includes('la'); //true
Operador de exponenciación (**)
El operador exponenciación se define con 2 asteriscos seguidos **
y sirve para elevar un número a la potencia de otro. Básicamente hace lo mismo que Math.pow(a, b)
.
Su uso es muy simple, fíjate:
3**2; //9
let num=5;
num **=3; //num = 125
Conclusiones
Es una actualización muy ligera, pero lo cierto es que solo ha pasado un año desde la anterior. Visto así, parece que tiene sentido ir añadiendo funcionalidades de forma gradual año a año, para evitar una elevada curva de aprendizaje como le pasaría a más de uno con ES6.
¿Que nos deparará ES2017? Pues parece que algunos cambios menores y las esperadas async functions. Esperemos que sea cierto 😉
Dime… ¿cual es la característica que más ansías para el próximo año?
Yo espero que vaya en sentido a typescript con los decorators e interfaces :’)
A mi tmb me gusta esa idea, pero me parece que no lo tienen tan avanzado como para que entre en ES2017 🙁
Enrique,
No soy capaz de responder la pregunta que pides en el post, pero quería que sepas que te vamos leyendo 🙂
Son geniales tus «pildoras formativas»… thanks! ..
no se si sería mucho pedir, ¿podrías dedicar una de ellas a los observables?
una duda
let num=5;
num **=3; //num = 125
no debería ser?
let num=5;
num**3 //num=125
Gracias por estar ahí y tranqui, observables está en la lista 🙂
Respecto a la duda, justamente el ejemplo es para mostrar que funciona como otros operadores.
Lo que ves es una combinación entre el operador y la asignación, y se puede hacer con sumas, restas y demás. Es decir,
num**3
te devolvería efectivamente 125, pero no actualizará el valor de num a 125. En cambio, connum**=3
lo que estás haciendo es en realidadnum = num ** 3
, del mismo modo que si hicierasnum +=2
estarías haciendo en realidadnum = num + 2