No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

ES9: expresiones regulares

22/35
Recursos

La siguiente versi贸n de ECMAScript fue publicada en 2018. Las caracter铆sticas de ES9 o ES2018 que aprender谩s son: expresiones regulares y propiedades de propagaci贸n.

Expresiones regulares

Las expresiones regulares o RegEx (regular expresions) son patrones de b煤squeda y manipulaci贸n de cadenas de caracteres incre铆blemente potente y est谩n presentes en todos los lenguajes de programaci贸n.

En JavaScript se crea este patr贸n entre barras inclinadas (/patr贸n/) y se utiliza m茅todos para hacer coincidir la b煤squeda.

const regexData = /([0-9]{4})-([0-9]{2})-([0-9]{2})/
const match = regexData.exec('2018-04-20')

Este es un tema extenso, por lo que te recomiendo seguir el curso y leer los m茅todos sobre expresiones regulares en JavaScript:

Propiedades de propagaci贸n

Las propiedades de propagaci贸n consisten en expandir las propiedades de un objeto utilizando el spread operator. Sirve para crear nuevos objetos a partir de otros.

const objeto = {
  nombre: "Andres",
  age: 23,
}

const usuario = {
    ...objeto,
    plataforma: "Platzi"
}

Crear copias de objetos utilizando las propiedades de propagaci贸n

Semejante a crear copias de arrays utilizando el operador de propagaci贸n, se puede realizar copias de objetos en un solo nivel mediante las propiedades de propagaci贸n.

De esta manera el segundo objeto tendr谩 una referencia en memoria diferente al original.

const objetoOriginal = {a: 1, b: 2}
const objetoReferencia = objetoOriginal
const objetoCopia = {...objetoOriginal}

objetoReferencia === objetoOriginal // true
objetoOriginal === objetoCopia // false

Cuidado con la copia en diferentes niveles de profundidad

El operador de propagaci贸n sirve para crear una copia en un solo nivel de profundidad, esto quiere decir que si existen objetos o arrays dentro de un objeto a copiar. Entonces los sub-elementos en cada nivel, tendr谩n la misma referencia en la copia y en el original.

const original = { datos: [1, [2, 3], 4, 5] }
const copia = { ...original }

original === copia // false
original["datos"] === copia["datos"] // true

La manera de solucionar esto es m谩s compleja, tendr铆as que utilizar el operador de propagaci贸n para cada elemento en cada nivel de profundidad.

Sin embargo, recientemente sali贸 una forma de crear una copia profunda con StructuredClone. Aunque es una caracter铆stica muy reciente, as铆 que revisa que navegadores tienen soporte.

const original = { datos: [1, [2, 3], 4, 5] }
const copia = structuredClone(original)

original === copia // false
original["datos"] === copia["datos"] // false

Contribuci贸n creada por Andr茅s Guano (Platzi Contributor).

Aportes 33

Preguntas 4

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Cuidado con la copia en diferentes niveles de profundidad

El operador de propagaci贸n sirve para crear una copia en un solo nivel de profundidad, esto quiere decir que si existen objetos o arrays dentro de un objeto a copiar. Entonces los sub-elementos en cada nivel, tendr谩n la misma referencia en la copia y en el original.

const original = { datos: [1, [2, 3], 4, 5] }
const copia = { ...original }

original === copia // false
original["datos"] === copia["datos"] // true

La manera de solucionar esto es m谩s compleja, tendr铆as que utilizar el operador de propagaci贸n para cada elemento en cada nivel de profundidad.

Sin embargo, recientemente sali贸 una forma de crear una copia profunda con StructuredClone. Aunque es una caracter铆stica muy reciente, as铆 que revisa que navegadores tienen soporte.

const original = { datos: [1, [2, 3], 4, 5] }
const copia = structuredClone(original)

original === copia // false
original["datos"] === copia["datos"] // false

Hola Chic@s 馃槂
ES9

  • Regex
const regex = /(\d{4})-(\d{2})-(\d{2})/;
const matchers = regex.exec("2022-01-01");
console.table(matchers);

  • Spread

const user = { username: "gndx", age: 34, coutry: "CO" };
const { username, ...values } = user;
console.log(username);
console.log(values);

Las expresiones regulares suelen ser un dolor de cabeza, pero hay que reconocer una vez dominadas, que son una herramienta super-potente para el programador.

Para quien lo quiera copiar y pegar 馃槃

const regex = /(\d{4})-(\d{2})-(\d{2})/;

Por si quieren ver una un Padled, con bastante informaci贸n sobre las regular expressions. Este fue creado en base al contenido de Modulo de expresiones regulares de ManzDev

Se a帽ade otro curso mas a mi lista de pendientes, Curso de Expresiones Regulares - Platzi

Rest Operator


.
En realidad lo que el profe Oscar explic贸 despu茅s de las regex no es el spread operator, sino el Rest operator.
Ambos tienen la misma sintaxis de 3 puntitos < 鈥 > pero son distintos.
.

Como se diferencia el Rest Operator del Spread Operator?

  • La sintaxis spread 鈥渆xpande鈥 un array en sus elementos, mientras que la sintaxis rest recopila varios elementos y los 鈥渃ondensa鈥 en un solo elemento.
    .
  • Rest tiene dos aplicaciones, como Rest property (en asignaci贸n desestructurada) y como Rest parameters.
    .
  • El ejemplo del profesor muestra el uso de Rest Property, es decir, una asignaci贸n desestructurada aplicada en un objeto.
    .
  • Los rest parameters permiten a una funci贸n aceptar una cantidad indefinida de argumentos (aunque esto no suele ser una buena pr谩ctica).
function sum(...theArgs) {
  let total = 0;
  for (const arg of theArgs) {
    total += arg;
  }
  return total;
}

console.log(sum(1, 2, 3));
// expected output: 6

console.log(sum(1, 2, 3, 4));
// expected output: 10

Para m谩s info check the Documentation.

Interesante, imprimir en la consola el contenido de un array de manera mas clara en una tabla

console.table(values)

Mostrara鈥

(index) | Value

age | 34

country | 鈥楥O鈥

regex鈥

const regex = /(\d{4})-(\d{2})-(\d{2})/; 

const matchers = regex.exec("2023-04-27");

console.table(matchers);

spread, rest

const user = {
    username: "Wil",
    age: 37,
    country: "CO"
};
const {username, ...values} = user;
console.log(username);
console.log(values);

Por si alguien no sabe qu茅 hace exactamente la expresi贸n regular:
/(\d{4})-(\d{2})-(\d{2})/

\d{4} -> busca un string con exactamente 4 d铆gitos de longitud
luego viene un gui贸n -
\d{2} -> busca un string con exactamente 2 d铆gitos de longitud
luego viene otro gui贸n -
y se repite el \d{2}

Entonces la expresi贸n regular har谩 match con strings que tengan 4 d铆gitos - 2 d铆gitos - 2 d铆gitos

Por aqu铆 les dejo unos Apuntes.

馃搫 Archivos del Proyecto 馃搫


Pasos 馃搶

  • 鈥 Dentro de la carpeta src, se crea la carpeta es9.
    • 鈥 Dentro de la carpeta es9, crear el archivo llamado: 00-regex.js
      鈼 El c贸digo queda:
//Compilar: seleccionar el c贸digo + click derecho + Run Code

//Ejercicio #1
const regex = /(\d{4})-(\d{2})-(\d{2})/; //4 caracteres del a帽o, 2 para el mes y 2 para el d铆a
const matchers = regex.exec('2022-01-02'); //interpreta el formato del regex y compara
console.table(matchers); //Permite capturar grupos del regex

/*output:
鈹屸攢鈹鈹鈹鈹鈹鈹鈹鈹鈹攢鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹
鈹 (index) 鈹 Values 鈹
鈹溾攢鈹鈹鈹鈹鈹鈹鈹鈹鈹尖攢鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹
鈹 0'2022-01-02' 鈹
鈹 1'2022' 鈹
鈹 2'01' 鈹
鈹 3'02' 鈹
鈹 index 鈹 0 鈹
鈹 input 鈹 '2022-01-02' 鈹
鈹 groups 鈹 undefined 鈹
鈹斺攢鈹鈹鈹鈹鈹鈹鈹鈹鈹粹攢鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹
*/

  • 鈥 Dentro de la carpeta es9, crear el archivo llamado: 01-spread.js
      • 鈼 El c贸digo queda:
//Compilar: seleccionar el c贸digo + click derecho + Run Code

//Ejercicio #1
const user = {username: 'gndx', age: 34, country: 'CO'};
const{ username, ...values} = user; //A values se le asigna todo lo que est谩 despu茅s de username
console.log(username);
console.log(values);

/*output:
gndx
{ age: 34, country: 'CO' }
*/

PEROQUEEESESTO

const regex = /(\d{4})-(\d{2})-(\d{2})/;

Este c贸digo crea una expresi贸n regular que busca una cadena de texto que tenga el formato de fecha AAAA-MM-DD, donde A es un d铆gito para el a帽o, M es un d铆gito para el mes y D es un d铆gito para el d铆a.

La expresi贸n regular se define como /(\d{4})-(\d{2})-(\d{2})/, lo que significa lo siguiente:

(\d{4}) busca cuatro d铆gitos consecutivos que representan el a帽o y los captura en un grupo de captura (el par茅ntesis).

  • busca un guion literal.
    (\d{2}) busca dos d铆gitos consecutivos que representan el mes y los captura en otro grupo de captura.
  • busca otro guion literal.
    (\d{2}) busca otros dos d铆gitos consecutivos que representan el d铆a y los captura en un tercer grupo de captura.
    Luego, se llama al m茅todo exec en la expresi贸n regular con la cadena de texto 鈥2022-01-01鈥 como argumento. Esto busca la cadena de texto en busca de una coincidencia con el patr贸n de la expresi贸n regular y devuelve un array con la cadena de texto coincidente y los grupos de captura. En este caso, el array resultante ser谩 [ 鈥2022-01-01鈥, 鈥2022鈥, 鈥01鈥, 鈥01鈥 ], donde el primer elemento es la cadena de texto coincidente y los siguientes tres elementos son los grupos de captura correspondientes al a帽o, mes y d铆a.

Finalmente, se imprime la tabla de valores del array resultante utilizando console.table(matchers). Esto muestra el array como una tabla en la consola del navegador o del editor de c贸digo, lo que facilita la visualizaci贸n de los valores capturados en los grupos de captura.

En JavaScript, tanto el operador de propagaci贸n (spread operator) como el operador de descanso (rest operator) utilizan la sintaxis de tres puntos (鈥), pero se usan en situaciones diferentes.

El operador de propagaci贸n se utiliza para descomponer un objeto iterable (como un array o una cadena) en elementos individuales. Por ejemplo, si tienes un array a y quieres crear un nuevo array b que incluya todos los elementos de a junto con algunos elementos adicionales, puedes usar el operador de propagaci贸n de la siguiente manera:

const a = [1, 2, 3];
const b = [...a, 4, 5, 6];
console.log(b); // Output: [1, 2, 3, 4, 5, 6]

El operador de descanso, por otro lado, se utiliza para combinar m煤ltiples elementos en un array. Por ejemplo, si tienes una funci贸n que acepta un n煤mero variable de argumentos y quieres convertirlos en un array, puedes usar el operador de descanso de la siguiente manera:

function myFunction(...args) {
  console.log(args);
}

myFunction(1, 2, 3); // Output: [1, 2, 3]

En este ejemplo, el operador de descanso 鈥rgs recopila todos los argumentos pasados a myFunction() y los combina en un array args.

En resumen, el operador de propagaci贸n se utiliza para descomponer un objeto iterable en elementos individuales, mientras que el operador de descanso se utiliza para combinar m煤ltiples elementos en un array.

Expresiones regulares: Son patrones que describen conjuntos de cadenas de texto. Herramienta para el manejo y manipulaci贸n de cadenas de caracteres.

Para quienquiera copiar y pegar el regex

const regex = /(\d{4})-(\d{2})-(\d{2})/;

馃鉁∣tra manera de hacer copias

Como se mencion贸 en otro aporte, el operador de propagaci贸n solamente es 煤til para realizar copias superficiales, es decir, que no funciona en atributos que contengan objetos anidados.
.
As铆 que otra forma muy sencilla de realizar una copia total de un objeto es usando la t茅cnica llamada serializaci贸n y deserializaci贸n de JSON.
Esta consiste en tomar un Objeto, transformarlo a una cadena de texto en formato Json, para luego volver a transformarlo en un Objeto.

const person = {
  name: "Cris",
  age: 21,
  address: {
    city: "Ciudad G贸tica",
    calle: "Av. Siempre Viva",
  },
};

const personJSON = JSON.stringify(person); //obtenemos un string enformato JSON con una nueva direcci贸n de memoria.
const personCopy = JSON.parse(personJSON); //Finalmente obtenemos una copia exacta del Objeto pero con otra direcci贸n de memoria.

console.log(person); //person Object
console.log(personCopy); //mismos datos exactos de person Object
console.log(person == personCopy); // False porque no tienen la misma direcci贸n de memoria

En muchas ocasiones nos encontraremos en la situaci贸n de querer realizar una o varias acciones si se cumple un determinado caso. Pero muchas veces, esos casos no son tan simples, sino que existe un n煤mero muy alto de situaciones diferentes que no podemos cubrir de formas tradicionales. En esas situaciones es donde las聽expresiones regulares聽quiz谩s nos puedan ser de ayuda.

驴Qu茅 es una RegExp?

Las聽expresiones regulares聽(a menudo llamadas RegExp o RegEx) son un sistema para buscar, capturar o reemplazar texto utilizando聽patrones. Estos patrones permiten realizar una b煤squeda de texto de una forma relativamente sencilla y abstracta, de forma que abarca una gran cantidad de posibilidades que de otra forma ser铆a imposible o muy extensa y compleja.

Estos聽patrones聽se representan mediante una cadena de texto, donde ciertos s铆mbolos tienen un significado especial. Antes de explicar el significado de esos s铆mbolos especiales, vamos a convertirlo en un ejercicio para verlo mejor.

Necesitamos聽detectar si un nombre empieza con las letras 芦p禄 o 芦s禄 y adem谩s termina con las letras 芦o禄 o 芦a禄. Es decir, necesitamos comprobar si se cumplen聽dos restricciones聽con dos posibilidades cada una.

Esto podr铆amos hacerlo de varias formas, por ejemplo:

  • Extraer la primera y 煤ltima letra y detectar los nombres que coinciden.
  • Escribir una expresi贸n regular que detecte los nombres que coinciden.

Vamos a plantear esto con c贸digo:

const names = ["Pedro", "Sara", "Miriam", "Nestor", "Adri谩n", "Sandro"];

// Comprobaci贸n sin usar expresiones regulares
names.forEach(function(name) {
  const firstLetter = name.at(0).toLowerCase();
  const lastLetter = name.at(-1).toLowerCase();

  if ((firstLetter === "p" || firstLetter === "s") && (lastLetter === "o" || lastLetter === "a")) {
    console.log(`El nombre ${name} cumple las restricciones.`);
  }
});

// Comprobaci贸n usando expresiones regulares
names.forEach(function(name) {
  const regex = /^(p|s).+(o|a)$/i;

  if (regex.test(name)) {
    console.log(`El nombre ${name} cumple las restricciones.`);
  }
});

Aunque aqu铆 se puede apreciar un poco, imagina que ahora a帽adimos聽m谩s restricciones: que los nombres puedan empezar por 芦r禄 y 芦t禄, que el nombre sea de longitud entre 5 y 8 car谩cteres, etc鈥 Si son demasiados casos, probablemente, la forma sin expresiones regulares se volver谩 mucho m谩s extensa y larga, mientras que con expresiones regulares se mantendr谩 m谩s o menos igual de corta.

ES9: expresiones regulares

Las expresiones regulares, tambi茅n conocidas como regex o regexp, son patrones de b煤squeda y manipulaci贸n de cadenas de texto. Aqu铆 hay una introducci贸n b谩sica a c贸mo funcionan:

  1. Sintaxis: Las expresiones regulares se componen de caracteres normales y caracteres especiales que definen patrones de b煤squeda. Por ejemplo, /abc/ es una expresi贸n regular que buscar谩 la cadena 鈥渁bc鈥 en cualquier parte de un texto.

  2. Caracteres literales: Los caracteres normales en una expresi贸n regular coinciden con ellos mismos en la cadena. Por ejemplo, /cat/ coincidir谩 con 鈥渃at鈥 en cualquier lugar del texto.

  3. Caracteres especiales: Los caracteres especiales tienen significados especiales en una expresi贸n regular. Algunos ejemplos son:

    • .: Coincide con cualquier car谩cter excepto un salto de l铆nea.
    • *: Coincide con cero o m谩s repeticiones del elemento anterior.
    • +: Coincide con una o m谩s repeticiones del elemento anterior.
    • ?: Coincide con cero o una repetici贸n del elemento anterior.
    • \: Se usa para escapar caracteres especiales y tratarlos como literales.
  4. Clases de caracteres: Las clases de caracteres permiten especificar un conjunto de caracteres que pueden coincidir en un punto dado. Por ejemplo, [aeiou] coincide con cualquier vocal.

  5. Cuantificadores: Los cuantificadores permiten controlar la cantidad de repeticiones de un elemento. Algunos ejemplos son:

    • {n}: Coincide exactamente con n repeticiones.
    • {n, m}: Coincide con al menos n repeticiones y como m谩ximo m repeticiones.
  6. Anclaje: Los caracteres ^ y $ se utilizan para anclar una expresi贸n regular al principio o final de una cadena, respectivamente. Por ejemplo, /^abc/ coincidir谩 solo si 鈥渁bc鈥 est谩 al comienzo de la cadena.

  7. Grupos y Captura: Los par茅ntesis ( ) se utilizan para agrupar elementos y crear grupos. Tambi茅n permiten capturar la parte de la cadena que coincide con el grupo.

  8. Modificadores: Los modificadores se agregan al final de una expresi贸n regular y afectan c贸mo se realiza la b煤squeda. Por ejemplo, el modificador i hace que la b煤squeda sea insensible a may煤sculas y min煤sculas.

  9. Uso con m茅todos: En JavaScript, las expresiones regulares se utilizan con m茅todos de cadena como match, test, exec, replace, search y split para realizar operaciones de b煤squeda y manipulaci贸n en cadenas.


Profundicemos en el uso de m茅todos

  1. test(): Este m茅todo verifica si una cadena coincide con una expresi贸n regular. Devuelve true si hay coincidencia y false si no hay.
const pattern = /apple/;
const text = "I love apples";
const isMatch = pattern.test(text);
console.log(isMatch); // true
  1. match(): Este m茅todo busca todas las coincidencias de una expresi贸n regular en una cadena y las devuelve en un array.
const pattern = /apple/g;
const text = "I have an apple and another apple";
const matches = text.match(pattern);
console.log(matches); // ["apple", "apple"]
  1. exec(): Este m茅todo tambi茅n busca coincidencias en una cadena y devuelve detalles sobre la primera coincidencia en un array. Si no hay coincidencia, devuelve null.
const pattern = /apple/;
const text = "I have an apple";
const matchDetails = pattern.exec(text);
console.log(matchDetails[0]); // "apple"
  1. replace(): Este m茅todo reemplaza las coincidencias de una expresi贸n regular en una cadena con un valor especificado.
const pattern = /apple/g;
const text = "I have an apple and another apple";
const newText = text.replace(pattern, "orange");
console.log(newText); // "I have an orange and another orange"
  1. search(): Este m茅todo busca la primera coincidencia de una expresi贸n regular en una cadena y devuelve la posici贸n del inicio de la coincidencia. Si no hay coincidencia, devuelve -1.
const pattern = /apple/;
const text = "I have an apple";
const position = text.search(pattern);
console.log(position); // 9
  1. split(): Este m茅todo divide una cadena en un array de subcadenas utilizando una expresi贸n regular como delimitador.
const pattern = /[\s,]+/;
const text = "apple,orange,banana";
const fruits = text.split(pattern);
console.log(fruits); // ["apple", "orange", "banana"]


Recuerda que en todos estos m茅todos, puedes utilizar las expresiones regulares para crear patrones de b煤squeda m谩s complejos y poderosos. Cada m茅todo tiene sus propias caracter铆sticas y utilidades, as铆 que aseg煤rate de leer la documentaci贸n oficial de JavaScript para obtener una comprensi贸n completa de c贸mo utilizarlos correctamente.


Espero sea de utilidad. 馃懆鈥嶐煉

Aqu铆 tienes un ejemplo de expresiones regulares en un escenario de validaci贸n de formularios en una aplicaci贸n web. Supongamos que tienes un formulario de registro de usuarios y quieres verificar si el campo de contrase帽a cumple con ciertos requisitos.

const passwordRegex = /^(?=.*[A-Z])(?=.*[a-z])(?=.*\d).{8,}$/;
const passwordInput = document.getElementById('password');

passwordInput.addEventListener('input', function() {
  const password = passwordInput.value;
  const isValid = passwordRegex.test(password);

  if (isValid) {
    passwordInput.classList.remove('invalid');
    passwordInput.classList.add('valid');
  } else {
    passwordInput.classList.remove('valid');
    passwordInput.classList.add('invalid');
  }
});

En este ejemplo, hemos definido una expresi贸n regular llamada passwordRegex que valida la contrase帽a del usuario con los siguientes requisitos:

Al menos una letra may煤scula ((?=.[A-Z])).
Al menos una letra min煤scula ((?=.
[a-z])).
Al menos un d铆gito ((?=.*\d)).
Longitud m铆nima de 8 caracteres (.{8,}).
Luego, hemos obtenido una referencia al campo de contrase帽a en el formulario mediante document.getElementById(鈥榩assword鈥).

A continuaci贸n, hemos a帽adido un evento input al campo de contrase帽a para que cada vez que el usuario escriba o modifique el contenido, se ejecute una funci贸n. Dentro de esta funci贸n, obtenemos el valor del campo de contrase帽a y comprobamos si cumple con el patr贸n definido en la expresi贸n regular utilizando el m茅todo test().

Si la contrase帽a cumple con el patr贸n, se a帽ade la clase CSS 鈥榲alid鈥 al campo de contrase帽a, lo que podr铆a usarse para mostrar un mensaje de retroalimentaci贸n visual o un icono de verificaci贸n. Si la contrase帽a no cumple con el patr贸n, se a帽ade la clase CSS 鈥榠nvalid鈥, lo que podr铆a usarse para mostrar un mensaje de error o un icono de advertencia.

Este ejemplo ilustra c贸mo se puede utilizar una expresi贸n regular en JavaScript para validar y dar retroalimentaci贸n en tiempo real sobre la fortaleza de una contrase帽a en un formulario de registro de usuarios.

Mi resumen:

const user = {
    "name": "John",
    "lastname": "Doe",
    "proaccount": true
}
const disabled = {"proaccount":false}

//mezcla las propiedades, si tienen una propiedad en comun, la remplaza por el valor que tenga la propiedad en el segundo objeto
const update = {...user,...disabled}
console.log(update);

22/35 ES9: expresiones regulares

Las expresiones regulares son patrones de b煤squeda y manipulaci贸n de cadenas de caracteres y en JavaScript se crean entre barras inclinadas (/patron/) y se utilizan m茅todos para hacer coincidir la b煤squeda. Por otro lado, las propiedades de un objeto utilizando el spread operator y crear nuevos objetos a partir de otros.

Un ejemplo de uso de expresiones regulares en JavaScript es buscar una fecha en un texto con un patr贸n espec铆fico:

const objeto = { nombre: "Andres", age: 23, }; 
const usuario = { ...objeto, plataforma: "Platzi" }.

Sin embargo , es importante tener en cuenta que el operador de propagaci贸n solo crea copias en un solo nivel de profundidad y si hay objetos o arrays dentro de un objeto a copiar, los sub-elementos en cada nivel tendr谩n la misma referencia e la copia y en el original. En este caso, se tendr铆a que utilziar el operador de propagaci贸n para cada elemento en cada nivel de profundidad o utilizar StructuredClone para crear una copia profunda.

Una mejor explicaci贸n del Rest Operator aqu铆

Nota spread:

// operador de propagaci贸n c贸mo funciona con conceptos en objetos

// ahora admite el uso de rest y spread con objetos

// operador de ...y copiar lo que est谩 en las claves en nuestros objetos

const user = { username: 'gndx', age:34, country: 'CO'};
const { username, ...values } = user;

console.log(username);
// separamos el username, como se indica en la l铆nea 2, por eso lo podemos declarar
console.log(values);
// y con ..values asignamos el resto de valores a dicho elemento, y por eso lo llamamos

// tiene sentido para transformar objetos y arreglos y haceindo manipulaciones para obtener ciertos objetos

Notas de Regex!

// m谩s detalle en : https://platzi.com/cursos/expresiones-regulares/
// para capturar en grupo, valores que se encuetran en una expresi贸n regular

const regex = /(\d{4})-(\d{2})-(\d{2})/;

// es un manejo de fechas de a帽o (4), mes(2), d铆a(2)

// para validar el grupo de elementos, si cumple con estandar de regex

const matchers = regex.exec('2023-01-03');

//En lugar de utilziar console.log, utilizamos console.table para mostrar la informaci贸n en formato de tabla

console.table(matchers);

// conesto podemos pasar por un valor o una validaci贸n que queramos hacer sobre el string
// para obtener un elemento y seguir avanzando

Para quien desee copiar y pegar la expresi贸n regular: 馃榿

const regex = /([0-9]{4})-([0-9]{2})-([0-9]{2})/;
const match = regex.exec('2022-12-23');

Pagina para generar y probar tus regex:

Regex101

Qu茅 son las expresiones regulares o regExp - regEx?

En resumen, son una forma mas corta de escribir condiciones de un problema por medio de patrones que son representados por cadenas de texto donde algunos simbolos utilizados tienen un significado especial; de otra manera, el c贸digo ser铆a mucho m谩s extenso.

En el siguiente enlace puedes ampliar 茅ste concepto. https://lenguajejs.com/javascript/regexp/expresiones-regulares/