Inmutabilidad de Strings y Almacenamiento en Memoria

Clase 9 de 29 • Curso de Estructuras de Datos con JavaScript

Resumen

Comprender cómo funcionan los strings en JavaScript te ayuda a escribir código más claro y eficiente. Aquí verás por qué los strings son inmutables, cómo se guardan en memoria como si fueran un array y qué implica al intentar “modificarlos”. Además, se anticipa el paso a hash tables, una estructura clave que verás a continuación.

¿Cómo se guardan los strings en memoria en JavaScript?

Los strings no son una estructura de datos como tal, pero la forma en que se almacenan en memoria se comporta “como si lo fueran”. En muchos lenguajes, incluido JavaScript, un string se guarda internamente como un array de caracteres, lo que permite acceder a cada letra por índice.

const saludo = "hola";

Se guarda “como un array” de caracteres en memoria.
Permite acceder a cada carácter por su índice.
Facilita recorrer letras y posiciones sin convertir el tipo.

¿Se accede por índice como en un array?

Sí. Al almacenarse como un array, cada letra ocupa una posición y puede leerse por índice, igual que en una colección ordenada.

Acceso directo a letras por posición.
Lectura sin necesidad de transformar el string.

¿Qué implica que los strings sean inmutables?

En JavaScript, los strings son inmutables: una vez creado, su valor no cambia. Cualquier “modificación” produce un nuevo string en memoria.

No se altera el valor original tras su creación.
Para “cambiarlo”, se debe copiar el contenido.
Se buscan nuevos memory slots disponibles y se pega el valor con los nuevos elementos.

¿Cómo impacta en rendimiento y diseño?

Este proceso de copiar y reasignar puede costar más tiempo de cómputo, sobre todo si se repite con frecuencia o con valores grandes.

Copiar y pegar datos implica trabajo extra para el motor.
Puede generar demoras al hacer muchas concatenaciones o cambios repetidos.

¿Qué conceptos y habilidades clave aparecen y qué sigue?

El foco está en entender el modelo de memoria y la inmutabilidad para tomar mejores decisiones al manipular texto. También se adelanta el estudio de hash tables, una estructura más compleja que los arrays.

String inmutable: no se puede modificar in place; cualquier cambio crea un nuevo valor.
Modelo de memoria: los caracteres se guardan “como un array”, con acceso por índices.
Índices: posibilidad de leer letras por posición.
Memory slots: espacios donde se pega el nuevo valor tras copiar.
Tiempo de cómputo: el proceso de copiar y ubicar nuevos memory slots puede tardar más.
Hash tables: próxima estructura de datos mencionada como siguiente paso.

¿Tienes dudas o un ejemplo donde la inmutabilidad te haya sorprendido? Compártelo en comentarios y enriquecemos la explicación juntos.

Juan Esteban Galvis

student•

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

Efraín Hernández García

student•

Entonces al guardar un string, se almacena en un array?

const saludo = ["H", "O","L","A"];

Andres Felipe Pinchao Ramirez

student•

vaya dato que crack

Carlos Eduardo Gomez García

teacher•

Un dato curioso: . ¿Alguna vez te has preguntado por qué se llama string?

. 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" 😉

Gonzalo Vidal

student•

jaja, buen insight, ya me había olvidado de la existencia de los char

Fernando Quinteros Gutierrez

student•

🗒️ Strings

Ideas/conceptos claves

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

Apuntes

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

Jimmy Buriticá Londoño

student•

Muy buen resumen

Nicolás Sañudo

student•

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();

Omar Flores Grimontt

student•

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

Jose Jimenez

student•

Jajaj <3 buenisimo!!

Rubén Esparza

student•

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. .

Jorge Cruz Perez

student•

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 .)

Usuario anónimo

user•

✨ En JavaScript las cadenas son inmutables.

Hector Zurga Ramos

student•

¿Entonces se puede decir que un string es un array de chars?

Juan Sebastián Agudelo

student•

Asi es!

De hecho en otros lenguajes es algo mas instrinsico. Es por eso que si en una variable guardas el valor de hola y si quieres acceder solo a cierta letra puede hacerlo mediante su indice.

let saludo = "hola";

console.log(saludo[0]);

// h

Esto nos permite usar la misma notacion de posiciones que en los arrays

Carlos Eduardo Gomez García

teacher•

Sí ^^ En muchos lenguajes de programación esto es así, te recomiendo leer mi aporte para que lo entiendas, traté de explicarlo lo mejor posible:

https://platzi.com/comentario/2063801/

Juan Sebastián Agudelo

student•

Strings

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.

Cosas a tener en cuenta

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)

Mario Arango

student•

/*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*/

Andres Felipe Pinchao Ramirez

student•

MY NOTES FOR STRINGS :D

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.

BRAYAN STEVEN VANEGAS NUÑEZ

student•

Hola, gente

Sebastian Tamayo Betancur

student•

hola

Pro Code

student•

En este caso el string es inmutable por estar definida con "const" o es igual que definirla con "let" o "var"?

Carlos Eduardo Gomez García

teacher•

Es inmutable porque está definida con "const", recuerda que "const" viene de "constante" que prácticamente significa "un valor que nunca va a cambiar" :D

Sebastian Pedroza

student•

Hola, tengo una duda🤔

En los casos en que el String es declarado con var o let este seguiría siendo inmutable o tendría un comportamiento similar al de un array dinámico?

Laura Valentina Rodriguez Ore

student•

Se discutió sobre los strings en JavaScript, resaltando que aunque no son estructuras de datos, su almacenamiento en memoria es similar a un array. Los strings son inmutables, lo que significa que no se pueden modificar una vez creados. Cualquier cambio implica crear un nuevo string. Esto puede generar problemas de rendimiento, ya que se necesita copiar datos a nuevos slots de memoria. La clase concluyó con la introducción a las hashtables, que se abordarán en la siguiente sesión.

Kyb3r Cipher

student•

Una letra por memoria como un char

Cristian Camilo Cortes Ortiz

student•

En JavaScript, los strings se almacenan como una secuencia inmutable de caracteres Unicode. Cada carácter en un string ocupa una posición específica, accesible mediante índices, comenzando desde cero. A pesar de ser inmutables, lo que significa que no pueden ser modificados directamente una vez creados, se pueden manipular utilizando diversos métodos y operadores que generan nuevos strings a partir de los existentes. La gestión interna de strings en JavaScript incluye la asignación dinámica de memoria, lo que facilita el manejo eficiente de texto en las aplicaciones web

Ulqernesh Karvenae

student•

1 : H 2 : O 3 : L 4 : A

Miguel Negron Garcia

student•

Metodo comunes de usar con strings:

1.substring() este metodo recibe dos argumentos, el primero es para saber desde donde empezara a seleccionar el texto al que quieres modificar y el segundo argumento o valor que recibe el metodo dentro de los parentesis es para indicar cuando detener su seleccion El primer valor es inclusivo y el segundo osea cuando debe parar es exclusivo.

ejemplo:

let saludo = 'Hola'; saludo.substring(0,3) resultado: 'Hol'

cuando digo exclusivo, quiere decir que el valor que pusiste como segundo valor o argumento del metodo, debes de pensar que no sera incluido, como si fuese 3 -1. Osea el valor que pusiste menos 1.

Acuerdense que los numeros son los indices de las letras.

2.slice() funciona de la misma manera pero este acepta indices negativos, lo que quiere decir es que puedes seleccionar las letras pero empezando desde el final y no solo desde el principio osea lado izquierdo.

explicacion de chat gpt:

Kevin Tisoy

student•

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

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();

/*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*/

Inmutabilidad de Strings y Almacenamiento en Memoria

Introducción a las estructuras de datos

Estructuras de Datos en JavaScript para Desarrolladores

Estructuras de Datos: Conceptos Básicos y Aplicaciones Prácticas

Almacenamiento de Datos en Memoria con JavaScript

Arrays y strings

Cómo funcionan arrays en memoria de JavaScript

Construcción de Arrays con Clases en JavaScript

Métodos pop y delete en arrays

Playground: crea tu propia implementación de unshift

Playground: crea tu propia implementación de shift