Strings

Incluso pueden guardar un texto en una variable y usarlo como un Array (Por eso se llaman cadenas de caracteres), miren:

.
Bien, si lo traducimos a español sería algo como “cadena”, sin embargo, su verdadero nombre o traducción es “cadena de caracteres”. si le damos un poco de interpretación a esta traducción podemos deducir que se trata de un carácter ligado a otro y así de forma consecutiva, ¡Sí!, son caracteres singulares que están pegados los unos a los otros y en conjunto forman una cadena, de ahí su nombre string.
.
Para entenderlo mejor, un caracter no es más que un simple símbolo o una simple letra, es decir, la letra “b” sería un caracter.
.
En otros lenguajes como C++ no existe como tal un tipo de dato String, ahí lo más que existe son caracteres, es decir, en C solo puedes guardar un caracter.
.
Esto lleva a que en C, por ejemplo, usemos trucos como declarar un arreglo de caracteres para formar un string, que repito, es básicamente una cadena de caracteres.
.
No le temas a C, claro que igual hay formas más fáciles de implementar strings ahí, simplemente comento esta curiosidad para que sepas por qué lo solemos conocer como “String” 😉

🗒️ Strings

String inmutables se refiere a que una vez definido no lo podemos cambiar

• De por si no es una estructura de datos, pero la forma en la que se guarda en memoria es como una estructura de datos
• Tenemos un string en una variable

const saludo = "Hola";

• Cabe recalcar que en muchos lenguajes incluyendo JavaScript, los strings son inmutables
  • para generar un cambio en el string sera necesario:
    1. Tomar todos los datos de los memory slots
    2. Buscar nuevos memory slots
    3. Pegar en los memory slots necesarios con los nuevos elementos
  • Hacer todos estos pasos puede llegar a ser un problema generando un problema de computo
• Cuando generamos strings con JavaScript casi nunca tenemos modificarlos
• Los strings se guardan como un arreglo

• Teniendo acceso a cada letra de la cadena definida

RESUMEN: Los strings son inmutables es decir que una vez definidos no podemos cambiar “letra por letra” si no que tendremos que tomar todos los items y comenzar a realizar la operación deseada también significa mayor esfuerzo de computo

Hice un ‘Hola Mundo’

class MyStrings{
    constructor(){
        this.length = 0;
        this.data = {};
    }

    push(item){
        this.data[this.length] = item;
        this.length++;
        return this.data;
    }

    print(){
        for(let i = 0; i < this.length; i++){
            console.log(this.data[i]);
        }
    }
}

const myStrings = new MyStrings();
myStrings.push('H');
myStrings.push('o');
myStrings.push('l');
myStrings.push('a');
myStrings.push(' ');
myStrings.push('M');
myStrings.push('u');
myStrings.push('n');
myStrings.push('d');
myStrings.push('o');
myStrings.print();

Les comparto mis notas sobre éste módulo acá 😁.

Al final todo string termina siendo una arreglo de carácteres, basado en esto, podemos recorrer nuestro strings con un loop carácter por carácter.
.

EN JS las cadenas las puedes escribir usando comillas simples o dobles, que se tratan de manera idéntica, si usas la comilla sencilla invertida se vuelve un template literal, que permite evaluar variablkes o expresiones, saludos .)

✨ En JavaScript las cadenas son inmutables.

Los strings no son una estructura de datos perse, pero se pueden comportar como un array, con la diferencia es que un string no es mutable, una vez declarado no se puede modificar dicho valor, se debe crear otra variable, o re asignar el valor.

• Cuando generamos strings con JavaScript casi nunca tenemos modificarlos
• Los strings se guardan como un arreglo (Array), esto nos permite acceder a los caracteres por su indice (Recuerda que siempre empezamos a contar desde el 0)

/*Una forma alternativa*/
class MyArray {
    constructor() {
        this.length = 0;
        this.data = {}
    }
    get(index) {
        return data[index];
    }
    push(item) {
        this.data[this.length] = item
        this.length++;
        return this.data;
    }
    pop() {
        const removeItem = this.data[this.length - 1]
        delete this.data[this.length - 1]
        this.length--;
        return removeItem
    }
    delete(index) {
        const removeItem = this.data[index];
        delete this.data[index];
        for (const key in this.data) {
            if (key < this.length - 1) {
                this.data[index] = this.data[this.length - index]
            }
        }
        delete this.data[this.length - 1]
        this.length--;
        return removeItem
    }
    unshift(item) {
        const newData = {
            '0': item
        }
        for (const key in this.data) {
            newData[parseInt(key) + 1] = this.data[key]
        }
        this.data = { ...newData }
        this.length++;
    }
    shift() {
        const removeItem = this.data['0']
        delete this.data['0']
        const newData = {}
        for (const key in this.data) {
            newData[key - 1] = this.data[key]
        }
        this.data = { ...newData }
        this.length--;
        return removeItem
    }
}

const myArray = new MyArray()
myArray.push('Mario')
myArray.push('Diego')
myArray.push('Clara')
console.log(myArray)
// myArray.pop()
// const deleteItem = myArray.delete(1)
myArray.shift('Jesús')
console.log(myArray)
// console.log(deleteItem)

/*Para ejecutarlo, te ubicas en tu directorio y node nombre_de_tu_archivo.js*/

MY NOTES FOR STRINGS 😄

Los strings no es una estructura de datos pero la forma en la que se guarda la información en memoria es como una estructura de datos

const saludo = “Hola”;

Tenemos un string que se esta guardando en una constante llamada saludo

¿Que tipo de estructura crees que tenga cuando se guarde en memoria?

Los strings son inmutables eso quiere decir que cuando generamos un string ya no lo podemos cambiar o manipular.

Y generar un cambio en el string tendría que tomarse los datos ya guardados en unos memory slots

buscar unos memory slots nuevos y pegarlos ahi.

La información de un string en memoria se hace por cada carácter asignándole una posición como si fuese un array.

En una const podemos almacenar un array en el que cada item ocupe un espacio.

0- H
1- o
2- l
3- a

todos los tipos de datos primitivos en JS son inmutables y estos son los siguientes: undefined, string, number, boolean, symbol(), bigIn 2n, y null , y los siguientes que son mutables serian : Arrays[], object{}

const saludo = "Hola";

// Se puede guardar un texto en una variable y usarlo como un Array (Por eso se llaman cadenas de caracteres)

console.log(saludo[0]); // result : H
console.log(saludo[1]); // result : o
console.log(saludo[2]); // result : l
console.log(saludo[3]); // result : a

// !Tener en cuenta que los arreglos son inmutables es decir:

saludo[0] = "B";
// Esperarias que en vez de "Hola" ahora diga "Bola" pero no es así.
// Dificilmente una vez creas un String quieres cambiar el valor de algun caracter.
console.log(saludo); // result : "Hola"

Es inmutable siempre y cuando sea tipo “const”. Un string guardado en una variable tipo let se puede modificar cuantas veces queramos.

Los string son inmutables una vez declarados. Y se almacenan como un array, con una dirección provista por un índice y una información almacenada en data.

Me intriga el hecho de que el nombre de la variable usa mas bytes que la variable misma. Ya que saludo usa 6 bytes de memoria, mientras que Hola solo 4…
const saludo = "Hola"

En programación, cuando hablamos de una varible que posee información de texto, decimos que su tipo de dato es string

El objeto String se utiliza para representar y manipular una secuencia de caracteres.

// Definiendo constante
const firstName = 'Cristina';

console.log(firstName[0]);
console.log(firstName[1]);
console.log(firstName[2]);
console.log(firstName[3]);

// Como lo guardaría en memoria
const firstnameArr = ['C', 'r', 'i', 's', 't', 'i', 'n', 'a',];

// Como lo mostraria en pantalla
console.log(firstnameArr.join(''));

Un pequeño ejemplo para modificar strings, la desventaja en este caso es que, al ser una variable de tipo let, solo existirá en la función en la que se declare.

const saludo="Hola";
let saludo2=" a todos!";
saludo2=saludo+saludo2;
for (let i=0;i<saludo2.length;i++){
    console.log(`saludo[${i}]: ${saludo2[i]}`);
}

Haber pues supongo que cada caracter ocuparía un slot en memoria

Los Strings al ser un tipo de dato primitivo son inmutables.

Con este pequeño código lo comprobé es cierto.

const string = "No manches lola";

for( let i = 0; i < string.length; i++ ) {
    console.log(string[i]);
}```

Podemos comprobar que un string se comporta como array

const str = 'Hola'

for(letter of str) {
  console.log(letter)
}

//en consola
H
o
l
a

En C no existe el tipo String como tal, se trabaja a partir de Vectores (arrays) y son declarados de manera estática, por lo que debes estimar o estar seguro de la longitud máxima que tendrá tu cadena.