Cadenas y métodos para trabajar con ellas

4.1 Introducción a las cadenas

Las cadenas en JavaScript son secuencias de caracteres y son uno de los tipos de datos fundamentales. Las cadenas se pueden crear usando comillas simples ('texto'), comillas dobles ("texto"), o comillas invertidas (`texto`).

Ejemplos de cadenas:

    
      let singleQuote = 'Hello, World!';
      let doubleQuote = "Hello, World!";
      let backticks = `Hello, World!`;
    
  

En el objeto String se pueden llamar métodos como:

4.2 Métodos principales para trabajar con cadenas

Ejemplos del uso de los métodos

1. Propiedad length

Devuelve la longitud de la cadena:

    
      let str = 'Hello';
      console.log(str.length); // 5
    
  

2. Método charAt(index)

Devuelve el carácter en la posición especificada:

    
      let str = 'Hello';
      let result = str.charAt(1);
      console.log(result); // 'e'
    
  

3. Métodos toUpperCase() y toLowerCase():

Convierte la cadena a mayúsculas o minúsculas:

    
      let str = 'Hello';
      console.log(str.toUpperCase()); // 'HELLO'
      console.log(str.toLowerCase()); // 'hello'
    
  

4. Método indexOf(substring)

Devuelve el índice de la primera aparición de la subcadena o -1 si no se encuentra:

    
      let str = 'Hello, world!';
      let result = str.indexOf('world');
      console.log(result); // 7
    
  

5. Método includes(substring)

Verifica si la cadena contiene la subcadena especificada, devuelve true o false:

    
      let str = 'Hello, world!';
      let result = str.includes('world');
      console.log(result); // true
    
  

6. Método trim()

Elimina espacios en blanco al principio y al final de la cadena:

    
      let str = '   Hello, world!   ';
      console.log(str.trim()); // 'Hello, world!'
    
  

7. Método replace(searchValue, newValue)

Reemplaza la subcadena especificada por una nueva subcadena:

    
      let str = 'Hello, world!';
      console.log(str.replace('world', 'JavaScript')); // 'Hello, JavaScript!'
    
  

8. Método split(separator)

Divide la cadena en un arreglo de subcadenas usando el separador especificado:

    
      let str = 'Hello, world!';
      let words = str.split(' ');
      console.log(words); // ['Hello,', 'world!']
    
  

9. Método substring(start, end)

Devuelve una subcadena entre dos índices:

    
      let str = 'Hello, world!';
      console.log(str.substring(0, 5)); // 'Hello'
    
  

10. Método substr(start, length)

Devuelve una subcadena desde el índice especificado y de la longitud especificada:

    
      let str = 'Hello, world!';
      console.log(str.substr(0, 5)); // 'Hello'
    
  

11. Método slice(start, end)

Extrae parte de la cadena y devuelve una nueva cadena:

    
      let str = 'Hello, world!';
      console.log(str.slice(0, 5)); // 'Hello'
    
  

12. Método startsWith(substring)

Verifica si la cadena comienza con la subcadena especificada, devuelve true o false:

    
      let str = 'Hello, world!';
      console.log(str.startsWith('Hello')); // true
    
  

13. Método endsWith(substring)

Verifica si la cadena termina con la subcadena especificada, devuelve true o false:

    
      let str = 'Hello, world!';
      console.log(str.endsWith('world!')); // true
    
  

14. Método repeat(count)

Devuelve una nueva cadena que contiene el número especificado de copias de la cadena original:

    
      let str = 'Hello';
      console.log(str.repeat(3)); // 'HelloHelloHello'

      let str2 = '-';
      console.log(str2.repeat(30)); // '---------------------------------------------------------------'
    
  

4.3 Cadenas de la nueva generación

Las cadenas de plantillas (template strings) fueron adicionadas recientemente en JavaScript. Proveen una forma más conveniente y legible de trabajar con texto en comparación con las cadenas normales. Se encierran en comillas invertidas (`) y soportan interpolación de expresiones y texto multilinea.

Sintaxis:

    
      `cadena de la nueva generación`
    
  

Ejemplo:

El literal de plantilla greeting se crea usando comillas invertidas.

    
      const greeting = `Hello, World!`;
      console.log(greeting); // "Hello, World!"
    
  

Características principales de las cadenas de plantillas:

• Interpolación de expresiones: las cadenas de plantillas permiten incluir expresiones y variables dentro de la cadena usando ${}
• Texto multilinea: las cadenas de plantillas soportan texto multilinea sin necesidad de usar caracteres especiales para saltos de línea
• Expresiones embebidas: dentro de las cadenas de plantillas se puede usar cualquier expresión de JavaScript, incluyendo funciones

Veamos ejemplos de uso de las cadenas de plantillas.

Interpolación de expresiones

Las cadenas de plantillas permiten insertar fácilmente valores de variables y resultados de expresiones dentro de la cadena:

    
      let name = "Alice";
      let age = 30;
      let greeting = `Hello, ${name}! You are ${age} years old.`;
      console.log(greeting); // "Hello, Alice! You are 30 years old."
    
  

En este ejemplo, las variables name y age se insertan dentro de la cadena usando ${}.

Texto multilinea

Las cadenas de plantillas facilitan la creación de cadenas multilinea sin necesidad de usar caracteres para saltos de línea (\n):

    
      let multiLine = `Lorem ipsum odor, consectetuer adipiscing elit.
      Sit lorem mattis eget maximus.`;

      console.log(multiLine);
    
  

Expresiones embebidas

Dentro de las cadenas de plantillas se puede usar cualquier expresión de JavaScript, incluyendo llamadas a funciones:

    
      let a = 5;
      let b = 10;
      let result = `The sum of ${a} and ${b} is ${a + b}.`;
      console.log(result); // "The sum of 5 and 10 is 15."

      function getGreeting(name) {
        return `Hello, ${name}!`;
      }

      let greeting = `${getGreeting("Bob")}`;
      console.log(greeting); // "Hello, Bob!"
    
  

Es mejor no llamar funciones dentro de las cadenas, pero si realmente lo deseas, puedes hacerlo.