Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Curso de ECMAScript 6+

Curso de ECMAScript 6+

Oscar Barajas Tavares

Oscar Barajas Tavares

¿Qué se implementó en ES7?

6/14
Recursos

Aportes 170

Preguntas 13

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

https://www.campusmvp.es/recursos/post/JavaScript-ECMAScript-ES6-Existe-ES7-Aclarando-las-diferentes-versiones-del-lenguaje.aspx

El problema con el nombre “ECMAScript 7” o "ES7"
ECMAScriptLa actual versión de ECMAScript es la número 7 (aunque sea la 6ª que sale realmente). El problema es que cuando en la Web buscas información sobre ES7 o ECMAScript 7 realmente de lo que están hablando no es de esta versión.

Se suponía que para esta última versión que acaba de salir se iban a incluir muchas nuevas funcionalidades en el lenguaje. Sin embargo no dio tiempo material y se ha lanzado una actualización muy descafeinada, con solo un par de cositas. La verdadera versión “grande” con enormes cambios fue la del año pasado, ES6 o ES2015. La más reciente, ES2016, es una actualización muy floja.

Así que cuando en Internet leas algo sobre ES7 en realidad están hablando de algo que no existe todavía y que de momento no se sabe cuándo va a estar disponible. Es posible que muchas de las nuevas características estén ya en ECMAScript 2017 (que sería realmente ES8), pero puede que tarden mucho más y sea finalmente en 2019 o 2020 cuando veamos algunas de ellas. Así que mucho cuidado con lo que te digan sobre ES7: probablemente no estén hablando de lo que tú crees.

ECMAScript en los navegadores
Además cada navegador tiene su propia implementación de ECMAScript, es decir, su propio motor de JavaScript. Como todos se han creado siguiendo lo que indica ECMA, en principio son 100% compatibles, pero podemos encontrar pequeñas diferencias entre implementaciones, en especial en aquellas partes del estándar que no dejan 100% claro cómo se debe actuar. Del mismo modo, diferentes implementaciones del motor del lenguaje pueden estar más o menos optimizadas.

Estos son los principales motores de JavaScript en los navegadores y qué versión de ECMAScript implementan a día de hoy (julio de 2016):

Navegador Motor/Implementación Versión de ECMAScript
Google Chrome V8 6
Firefox SpiderMonkey 5.1 con muchas cosas de 6 y 7
Edge Chakra 5.1 con muchas cosas de 6 y 7
Safari JavaScriptCore - Webkit 5.1 con muchas cosas de 6 y 7
Internet Explorer Jscript 9.0 5.1

He incluido enlaces a las versiones Open Source de los motores (excepto el de IE, que no es de código abierto). Por cierto, V8 es el motor que está debajo también de NodeJS.

Como vemos, cada motor implementa el estándar de manera diferente y en el caso concreto de ECMAScript 6 y 7, no todos implementan todo ni de la misma manera. Dado que todos excepto IE son navegadores “Evergreen”, es decir, que se actualizan solos de manera automática, a menudo salen nuevas pequeñas actualizaciones que van añadiendo cada vez más soporte para las últimas versiones de ECMAScript. De hecho se puede afirmar que todos los navegadores modernos soportan ECMAScript 6 casi por completo, y en breve también ES7.

/**
 * Includes
 */
let numbers = [1, 2, 3, 7, 8];
const VALUE = 7;

if (numbers.includes(VALUE)) {
  console.log(`Sí se encuentra el valor ${VALUE}`);
} else {
  console.log(`No se encuentra el valor ${VALUE}`);
}

/**
 * Pow
 */
let base = 4;
let exponent = 4;
let result = base ** exponent;
console.log(`Result -> ${result}`);

clase muy interesante 😃

que loco no conocía el operador **, recuerdo que antes se utilizaba Math.pow

// Antes Math.pow(base, exponente)
console.log(Math.pow(2, 4)); // 16
// hoy en día
console.log(2 ** 4); // 16

cordial saludo compañeros les comparto las versiones que van hasta el momento de ES y su año creacion

Anteriormente a ES7, usábamos otro método para saber si un elemento estaba en un array y es el siguiente:

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

arr.indexOf(1) !== -1; // true
arr.indexOf(10) !== -1; // false

Pero ahora estoy se volvió más legible, tan solo con un includes

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

arr.includes(1) // true
arr.includes(10) // false

Para profundizar más, pueden checar el sgt link: Cómo verificar si un array contiene un valor

includes() utilizado como método genérico
El método includes() es intencionalmente genérico. No requiere que este valor sea un objeto Array, por lo que se puede aplicar a otros tipos de objetos (por ejemplo, objetos tipo array). El siguiente ejemplo ilustra el método includes() llamado en el objeto de argumentos de la función.

(function() {
console.log([].includes.call(arguments, ‘a’)); // true
console.log([].includes.call(arguments, ‘d’)); // false
})(‘a’,‘b’,‘c’);

RESUMEN:
En ES7 que salió en junio de 2016 se añadieron nuevas funcionalidades a JS, dentro de estas está Includes y Potency.
Includes permite identificar un valro dentro de un arreglo o una variable, Potencia, es simplemente una notación para realizar una potencia.

En el siguiente código se muestra el ejemplo:

// Includes: Trabaja sobre un arreglo o string, nos permite saber si hay un elemento dentro de este valor. Es uan forma muy útil de validar elementos dentro de.

let number =[1,2,3,4,6];

if(number.includes(6)){
    console.log("Se encuentra el valor");
}else{
    console.log("No se encuentra el valor");
}

//Elevar a la potencia:

let base =4;
let exponent =3;
let resultado = base**exponent;

console.log(resultado);


Estoy haciendo un proyecto en javascript para comenzar a dominarlo y el metodo “include()” es preciso para lo que voy a hacer. 😃

es7 salio en julio 2016

ES7 - includes() - Nos permite saber si hay un elemento dentro de un valor. - Trabaja sobre un arreglo o un string.

Muy bueno lo del metodo “include()”, una manera mucho mas facil y con menos codigo de evaluar si existe un valor dentro de un arreglo.
Otra manera de hacerlo era usando el metodo “some()” el cual recibia como parametro un callback que evaluava la condicion que se queria obtener.

Me recuerda bastante a Ruby

6. ¿Qué se implementó en ES7?

En esta clase aprendimos a usar el .include y también cómo elevar un número x a una potencia y de manera nativa, les comparto el código de la clase:

//Lesson 5: ¿Qué se implementó en ES7?
//.include(x), busca x dentro del array y devuelve true o false
let numbers = [1, 2, 3, 7, 8];

if(numbers.includes(9)) {
    console.log('Sí se encuentra el valor 7');
} else {
    console.log('No se encuentra.')
}

//elevar a la potencia, usarmos el nuevo operador **
let base = 4;
let exponent = 3;
let result = base ** exponent;
console.log(result);

Mis apuntes

Esto del nuevo operador ** solo lo había visto en python. Hoy he aprendido algo nuevo en JS.

Comparto mi aporte aplicando función flecha y operador ternario.


Pienso que ECMA Internacional más que buscar Standar está haciendo que JavaScript se parezca más a un lenguaje de humanos. No tenía ni idea lo de includes

ECMAScript 2016(ES7) introduced only two new features:
Array.prototype.includes()
Exponentiation operator

includes es genial!, en verdad usar indexOf era muy difícil de entender xD Y el operador de exponente también es genial, este igual se encuentra en PHP ^^

.
Les comparto algunos de las incorporaciones en ES7 (EcmaScript 2016):

  • Se implementaron las funciones asíncronas (Async / Await).
  • Se implementa el operador de potencia (**).
  • Se implementa el método para los Array, include(). Para saber si un elemento se encuentra dentro del arreglo.
  • Se implementa la función Bind Syntax.
  • Se implementa Object.observe y Array.observe, funciones que se disparan al detectar un cambio.
  • Se implementa agregar propiedades directamente dentro de la clase.
  • Se implementan los decoradores, con el fin de extender la funcionalidad de una clase.

//ES7
//Includes - valida si existe un valor dentro de un arreglo
let numbers = [1,2,3,4,5,6,7,8,9,10];

if(numbers.includes(1)){
    console.log('Se encontró el valor especificado');
}else{
    console.log('Valor no encontrado');
}

// ** Simplifica la operación de elevar a la potencia
let base = 4;
let exponent = 3;
let result = base ** exponent;

console.log(result);

Les comparto mis apuntes:

// Includes (+ agregado)

let numbers = [1, 2, 3, 4, 5, 6, 7]

if (numbers.includes(7)) {
  console.log('Encontrado ^^')
} else {
  console.log('No encontrado =(')
}


// Elevar Potencias (+agregado)

let base = 4
let exponent = 4
let result = base ** exponent

console.log(result)
//metodo que nos permite averiguar si un numero determinado se encuentra en un arreglo
let numero = 2;
let numbers = [1,3,4,5,7,5,6,9];

if (numbers.includes(numero)) {
    console.log(`si se encuentra el valor ${numero}`);
} else {
    console.log(`no se encuentra el valor ${numero}`);
}

//elevar a una potencia

let base = 2, exponent = 3
let result = base ** exponent;
console.log(result);

Que bueno el plugin code runner
let num1= 5;
let num2= 2;
let result = num1 ** num2;

console.log(result);

includes() no es compatible con internet explore, pero lo podemos utilizar agregando esta funcion al prototipo String con el siguiente codigo:

if (!String.prototype.includes) {
  String.prototype.includes = function(search, start) {
    'use strict';

    if (search instanceof RegExp) {
      throw TypeError('first argument must not be a RegExp');
    }
    if (start === undefined) { start = 0; }
    return this.indexOf(search, start) !== -1;
  };
}

como lo mencionan en esta seccion https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes

// SEARCH IN ARRAY
const elements = [1, 2, 3, 4];
// old
if (elements.find(e => e === 4))
    console.log('Si contiene el 4')
// es7
if (elements.includes(4))
    console.log('Si contiene el 4')

Aqui la versiones de ES.

Pero si cada año sacan una nueva versión a día de hoy 2022, ya estarán en la versión ES12 🤔

The JavaScript naming convention started with ES1, ES2, ES3, ES5 and ES6.

But, ECMAScript 2016 and 2017 was not called ES7 and ES8.

Since 2016 new versions are named by year (ECMAScript 2016 / 2017 / 2018).

https://www.w3schools.com/js/js_versions.asp

includes(), integrando template strings en la respuesta que mostramos en la consola

//includes

let valueFind = 15;
let matrix = [1,2,3,4,5,6,7,9]

if(matrix.includes(valueFind)){
    console.log(`The number ${valueFind} exist in the matrix`)

}
else{
    console.log(`The number ${valueFind} doesn't exist in the matrix`)
}

Les comporto mis apuntes.



Acontinuacion comparto mis apuntes de la clase.

// ========== ECMAscript 7+ ========
// incluye la funcion .includes

let numbers =[1,23,4,5,6]

 if (numbers.includes(7)){
    console.log("Si esta");
 }else{
     console.log("No hay una mierda");
 }




 // y ademas incluye el operador de potenciacion para elebar variables o numeros con 
 // el doble asterisco (**)

 let base= 4;
 let exponente = 3;
 let resutado = base ** exponente;

 console.log( resutado);

 // Antes Math.pow(base, exponente)
console.log(Math.pow(2, 4));

Oscar es un evangelizador de esos duros cada vez que dice “Nuestro lenguaje favorito”, este curso conectado con el de fundamento de JS permite obtener muy buenas bases para seguir la escuela de JS

Usando operadores ternarios:

let numbers = [1,2,3,4,5]

numbers.includes(4) ? console.log('Incluye el número 4') : console.log('No incluye el número 4')

Es impresión mía o JavaScript se parce mucho a python y no lo digo solo por **, si no también por los for( _ in o of X), en fin pueda que también sea un estándar de los nuevos lenguajes para que su sintaxis sea mas parecida a la sintaxis humana.
Mi favorita de todas las nuevas herramientas son las => functions, me parce algo magnifico a la hora de agilizar el código. JavaScript me esta gustando bastante y creo que me enamorare de TypeScript con los datos tipados ლ(´ڡ`ლ)

Muy buenos cambios para no hacer for en las busquedas

Yo lo hacía con indexOf, que buen metodo!!

Estas han sido las dos implementaciones más fáciles de entender 😃

Resumen de ES7

let numbers = [1,2,3,7,8]
// include para verificar si un valor se encuentra dentro de un arreglo
if (numbers.includes(7)){
    console.log('si se encuentra el valor 7')
} else {
    console.log('No se encuetra')
}

//Para elevar a una potencia
let base = 4;
let exponent = 3;
let result = base ** exponent;
console.log(result);

<h3>🤔 ¿ES6 === ES2015?</h3>

La versiones o ediciones de EcmaScript son publicadas desde 1997. Como puedes ver los nombres son declarados a principio por el número de la edición. Pero luego ocurre un cambio 📌.

<h4>ES6 / ES2015 (Junio 2015)</h4>

Tal vez la causa de toda su confusión comienza aquí 🤕. Verán, ES6 y ES2015 son lo mismo. ES6 fue el nombre popularizado antes del lanzamiento. Sin embargo, el comité que supervisa las especificaciones de ECMAScript tomó la decisión de pasar a las actualizaciones anuales. Con este cambio, la edición pasó a llamarse ES 2015 para reflejar el año de lanzamiento 🤯. Las versiones posteriores también se nombrarán de acuerdo con el año en que se publiquen.

Cada anio en Junio sale una nueva version nueva de JS. En Es7 esta version se agregaron dos cambios muy particulares que son:

  • El valor de include
  • Operaciones en forma exponencial

Include trabaja sobre un arreglo o un string, nos permitira saber si hay un elemento dentro de este valor. Este es un ejemplo:

let numbers = [1,2,3,4,5,6];

if(numbers.includes(7)){
    console.log('Si hay 7');
} else {
    console.log('no hay 7')
}

Otro punto incorporado es como podemos elevar a n potencia. Este numero se puede hacer con el operador ‘**’. Este es el ejemplo:

let base = 4;
let exponente = 3;
let result  = base ** exponente;
console.log(result);
let numeros = [10, 20, 30, 40];

if (numeros.includes(20)){
    console.log("El 20 si esta");
}else{
    console.log("El 20 no esta");
}

//Potencias
let base = 30;
let exponente = 4;
let resultado = base ** exponente;
console.log(resultado);
/**
| The includes() method
*/
const numbers = [ 1, 2, 3, 4, 5, ];
const challenge = 2;
if (numbers.includes(challenge)) {
  console.log(`Si se encuentra el valor '${challenge}'.`);
} else {
  console.log(`No se encuentra el valor '${challenge}'.`);
}

/**
| Pow
*/
const base = 4;
const exponent = 3;
console.log(base ** exponent);

Que se implemento en ES7

// se incorporo los includes

let numbers = [1,2,3,4,5,6,7];

if (numbers.includes(7)){
    console.log(`Si se encuentra el valor 7`);
}
else {
    console.log(`No se encuentra el nummber`)
}

// otro punto incorporado es como se va a implemetar la potencia
// Se hace con doble asterisco **

let base = 3;
let exponent = 4;
let result = base**exponent;
console.log(result);

ES7

//es7
// includes
let numbers = [1,2,3,4,5,6,7,8,9];
let valorBus = 11
if(numbers.includes(valorBus)){
    console.log(`si, se encontro el valor ${valorBus}`)
} else {
    console.log('no. se encuntra el valor')
}

// pow
let base = 3
let expo = 3
let ress = base ** expo
console.log(`result: ${ress}`)

Elevar a la potencia es como Python

ES7 - Potenciación ** - Nos permite elevar un número base a una potencia. Para eso usamos el ** (doble asterisco).

¿Qué theme de VS está usando?

Wow, no conocia include()

lo tengo,

let result = base ** exponente;

😃

creía que ** siempre había estado

let number =[1,2,3,4,6];

if(number.includes(6)){
    console.log("Se encuentra el valor");
}else{
    console.log("No se encuentra el valor");
}

let base =4;
let exponent =3;
let resultado = base**exponent;

console.log(resultado);


//ecmaScript  7 :


// metodo includes
// El metodo includes determina si un array contiene determinado elemento,retornando un valor boleano

const array = [,123,65,0,321,5];

const arrayIncludes = array.includes(0);

console.log(arrayIncludes);

if(array.includes(20)){
    console.log("si se encuentra el valor");
}else{
    console.log("no se encontro el valor");
}

// elevación de potencia
// Es la nueva forma de repesentar una potenciación
// con doble asterisco => base ** exponente

const base = 4;
const exponente = 3;
let result = base ** exponente;
console.log(result);

// ES7 array.includes
let nums = [1, 2]
nums.includes(2) // true
nums.includes(3) // false

// ES7 Exponential
Math.pow(4, 3) // 64
console.log(4 ** 3) // 64

Async, Await?

I already used includes but it is good to know about when it was added to EcmaScript.

Método includes() de JavaScript
Este método funciona con arreglos o cadenas de texto. En cualquier de los dos casos el resultado que devuelve es true o false. Y basicamente, busca el valor que le pasemos para saber si el arreglo o cadena contiene ese valor.

Hay que tener en cuenta que al comparar las cadenas de texto, este método hace distinción entre mayúsculas y minúsculas.

Excelente la forma de elevar la potencia en es7

Good class.

OPERACIONES DE POTENCIA

En EcmaScript 7 se añadió la posibilidad de hacer operaciones de potenciación utilizando el operador de potencia (**).

En el primer ejemplo, realizaremos una operación de potencia con valores asignados en variables y luego mostraremos en consola el resultado.

const base = 3;
const exponente = 2;
const potencia = base ** exponente;
console.log(`El resultado de 3 a la 2 es: ${potencia}`);
// El resultado de 3 a la 2 es: 9 

En el segundo ejemplo, veremos como podemos realizar esta operación directamente como cualquier otra en JavaScript.

console.log(4 ** 2);
// 16 

INCLUDES

Con el método .includes podemos validar si en un array se encuentra cierto elemento.

A este método le podemos pasar dos parámetros (searchElement: element, fromIndex: indexnumber) que básicamente el primer parámetro que le pasemos es el elemento que queremos encontrar y el segundo (que es opcional) es desde que posición del array lo vamos a empezar a buscar. Ejemplo: (“Sebastián”, 20) Buscamos al string Sebastian desde la posición número 20 del array.

Array tipo numérico

const prefijosColombiaVenezuelaYBrasil = [58, 57, 55]
prefijosColombiaVenezuelaYBrasil.includes(56) // false
prefijosColombiaVenezuelaYBrasil.includes(58) // true

Ahora, veremos un ejemplo donde para validar si un elemento se encuentra dentro de un array numérico usaremos un if y un else que imprimirán un resultado en la consola dependiendo si es verdadero o falso. En este ejemplo, solo le pasamos el primer parámetro (searchElement) donde buscaremos si el elemento 7 se encuentra dentro del array.

let numbers = [1, 2, 3, 7, 8, 5, 6];

if (numbers.includes(7)) {
  console.log("Si se encuentra el valor 7");
} else {
  console.log("No se encuentra");
}
// Si se encuentra el valor 7 

Ahora, continuando con el ejemplo, utilizaremos el segundo parámetro (indexFrom) para buscar un elemento de acuerdo a su posición en el índice de nuestro array. En el primer caso, buscará el elemento 3 desde la posición 5, pero esto es falso, por lo tanto retornará que no se encuentra. En el segundo caso, validará si se encuentra el elemento 5 buscandolo desde la posición 4 del array, y como efectivamente se encuentra, imprimirá el bloque dentro del if.

if (numbers.includes(3, 5)) {
  console.log("Se encuentra el 3 desde la p. 5");
} else {
  console.log("No se encuentra");
}

if (numbers.includes(5, 4)) {
  console.log("Se encuentra el 5 desde la p.4");
} else {
  console.log("No se encuentra");
}

// No se encuentra -primer if statement-
// Se encuentra el 5 desde la p.4

Array tipo string

Con los strings funciona igual, lo único que cambia es que en el primer parámetro buscamos el elemento como un string, y el segundo parámetro no cambia en nada.

const nombres = ["Sebastian", "María", "Daniel", "John"];

nombres.includes("Alejandro") // false
nombres.includes("John", 2) // true 
nombres.includes("Sebastian", 2) // false 

Muy interesante como ha ido evolucionando JavaScript primera vez que profundizo acerca de este lenguaje de programacion

Tambien podemos usar el metodo Math.pow() el cual recibe 2 parametros, el primero es el numero base y el segundo es el exponente

Math.pow(base, exponente)

ejemplo de uso:

Math.pow(7, 2);    // 49
Math.pow(7, 3);    // 343
Math.pow(2, 10);   // 1024

Hola, este es un pequeño datos sobre El método INCLUDES.
Cuando le pasamos un segundo parámetro, le estamos indicando desde donde debe comenzar a buscar.

En el caso del INCLUDES con Strings, aquí les dejo un ejemplo:

let palabra = 'Hola';
let letra = 'H';
if(palabra.includes(letra)) {
    console.log(`Si se encuentra el valor ${letra}`);
} else {
    console.log(`No se encontró el valor ${letra}`);
}

Aquí aplique un arrow Function y a su vez un pequeño cálculo con los **

const calcularExponente = (base, exponente) => {
    const resultado = base ** exponente
    return resultado


}

console.log(calcularExponente(34,25))
//Se agrega el metodo includes el cual nos indica si un valor se encuentra dentro de un string o un arreglo, antes usabamos index og  u otro codigo mas complejo

let numbers = [1, 2, 3, 7, 8];

if (numbers.includes(10)) {
    console.log('Si se encuentra el valor 7')
} else {
    console.log('No se encuentra el valor')
}

//Elevar a la potencia, ahora puedes usar el doble ** para elevar potencias asi:

let base = 4;
let exponent = 3;
let result = base ** exponent;

console.log(result);

Mi primer lenguaje fue Python por lo cual esta inclusión de ** potencia me es muy familiar

código

/* includes */
const numbers = [1, 2, 3, 4, 5, 6];
if(numbers.includes(7)){
    console.log('Se encuentra');
} else {
    console.log('No se encuentra');
}

/* exponectiation  comments: 'python style xd' */
console.log( 2 ** 10);

Comparto mis notas de la clase, espero les sea de utilidad y guardarlo

Bastante útil y práctico.

Rápido y sencillo!!

Lo de la potencia ya era algo realmente necesario puesto que en la mayoría de lenguajes lo tratamos de esa forma.

Genial

MIS APUNTES ESCMASCRIPT 7

//Creamos un array de numeros
let numbers = [1, 2, 3, 7, 8];

//Es7 metodo includes se utiliza con un array o string
// Sirve para buscar entre todos los elementos el que se le pasa por parametro
// Si se encuentra el valor que se le pasa por parametro retorna true si no false
// Includes recibe como segundo parametro la posicion del array donde el metodo
//  va a empezar a buscar

//Anteriormente utilizavamos indexOff


if(numbers.includes(7)){

    console.log('Si se encuentra el valor 7')

}else{


    console.log('No se encuentra');
}

// Saber el exponente de un numero lo hacemos con **

let base = 4;
let exponent = 3;
let result = base ** exponent;

console.log(result); // 4 elevado en potencia de 3 = 64

Mismo resultado de .includes( ) y .some( )

No sabia sobre el operador **, muy interesante.

Mi pregunta es, al final la balanza en donde se inclina a usar los métodos anteriores para siempre ser conscientes de un javascript puro y estar preparado para cualquier cambio a futuro o, al final puedo usar los nuevos metodos que simplifican el trabajo así no entiendas que sucede internamente?

interesante en otros lenguaje se utiliza el acento circunflejo 👉^ para las potencias.

Características ES 7

Includes : para buscar dentro de arreglos.
Elevacion a la potencia utilizando operado

**

let numbers = [1, 2, 3, 7, 8, 25];
let numbers = [1, 2, 3, 7, 8, 25];
const VALOR = 54;
if (numbers.includes(VALOR)) {
  console.log(`Si se encuentra el valor ${VALOR}`);
} else {
  console.log(`No se encuentra`);
}

let base = 4;
let exponente = 3;

let resultado = base ** exponente;
console.log(resultado);


Los exponentes son igual que en python eso me gusta

// si hay un valor incluido dentro de un arreglo

let numbers = [1, 2, 3, 7, 8];
if (numbers.includes(7)) {
console.log(“Si hay un 7”);
} else {
console.log(“No hay ese numero”);
}
// Elevar a la potencia un numero

let base = 2;
let exponente = 2;
let result = base ** exponente;

console.log(result);

Muy bueno lo de la forma exponencial.

let numbers = [1,2,5,6,7,3];
if(numbers.includes(7)){
    console.log("Si se encuentra el valor 7")
}
else{
    console.log("No se encuentra");
}


let  base = 4;
let exponente = 3;
let resultado = base** exponente;

console.log(resultado);

Excelente.

que extensiones ocupa el profesor para resaltar el codigo?

includes con arrays y strings
potencia is **

//Elevar a la potencia:
let base = 4
let exponente = 3

let resultado = base ** exponente
console.log(resultado)