No tienes acceso a esta clase

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

Strings

9/29
Recursos

Aportes 32

Preguntas 4

Ordenar por:

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

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

<h3>Un dato curioso:
.
驴Alguna vez te has preguntado por qu茅 se llama string?</h3>

.
Bien, si lo traducimos a espa帽ol ser铆a algo como 鈥渃adena鈥, sin embargo, su verdadero nombre o traducci贸n es 鈥渃adena 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 鈥淪tring鈥 馃槈

馃棐锔 Strings

<h4>Ideas/conceptos claves</h4>

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

<h4>Apuntes</h4>
  • 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 鈥渓etra 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 鈥楬ola 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谩 馃榿.

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.

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

<h3>Strings</h3>

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.

<h4>Cosas a tener en cuenta</h4>
  • 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 = 鈥淗ola鈥;

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 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
1 : H 2 : O 3 : L 4 : A
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:

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 鈥渃onst鈥. 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.