Saltar al contenido principal

Strings

La manipulación de strings es esencial en la programación. Así es como diferentes lenguajes manejan operaciones con strings, concatenación y formateo.

Creación de Strings y Operaciones Básicas​

// String literals
const str1 = "Hello";
const str2 = 'World';
const str3 = `Template`;

// Concatenation
const combined = str1 + " " + str2;
const template = `${str1} ${str2}`;

// Length
const len = str1.length;

// Access character
const char = str1[0];  // 'H'

// Substring
const sub = str1.substring(0, 3);  // 'Hel'

Métodos de Manipulación de Strings​

const str = "Hello World";

// Case conversion
str.toUpperCase();      // "HELLO WORLD"
str.toLowerCase();      // "hello world"

// Search
str.indexOf("World");   // 6
str.includes("World");  // true
str.startsWith("Hello"); // true
str.endsWith("World");   // true

// Replace
str.replace("World", "Universe");  // "Hello Universe"
str.replaceAll("l", "L");  // "HeLLo WorLd"

// Split
str.split(" ");  // ["Hello", "World"]

// Join
["Hello", "World"].join(" ");  // "Hello World"

// Reverse
str.split("").reverse().join("");  // "dlroW olleH"

// Repeat
"ha".repeat(3);  // "hahaha"

// Trim
"  hello  ".trim();  // "hello"
"  hello  ".trimStart();  // "hello  "
"  hello  ".trimEnd();  // "  hello"

// Pad
"5".padStart(3, "0");  // "005"
"5".padEnd(3, "0");    // "500"

// Capitalize
str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();  // "Hello world"

// Count occurrences
(str.match(/l/g) || []).length;  // 3

// Check empty
str.length === 0;  // false
str.length > 0;    // true

Puntos Clave​

  • Inmutabilidad -- Los strings son inmutables en Java, Python, JavaScript, C# y Swift—cada "modificación" crea un nuevo string. C y C++ usan arrays de char mutables; Rust ofrece tanto &str (slice inmutable) como String (propio, mutable mediante métodos como push_str). La inmutabilidad simplifica el razonamiento sobre concurrencia y previene errores de aliasing accidental. Elige strings mutables (C/C++) solo cuando necesites modificación in situ para código crítico en rendimiento; de lo contrario, la inmutabilidad es más segura.

  • Codificación y Unicode -- Go y Rust tratan los strings como bytes UTF-8; acceder a un "carácter" en Go requiere []rune(str) porque str[0] devuelve un byte. Swift usa clústeres de grafemas para el manejo correcto de emojis y caracteres combinados. C usa arrays de bytes terminados en null sin garantía de codificación. Los strings de Python 3 son Unicode por defecto. Para aplicaciones internacionalizadas, prefiere Swift, Python o Rust; para trabajo solo ASCII o de bajo nivel, el acceso por bytes de C/Go está bien.

  • Interpolación de strings -- JavaScript usa template literals (`${name} is ${age}`); Python usa f-strings (f"{name} is {age}"); C# usa $"{name} is {age}"; Ruby usa "#{name} is #{age}". C depende de sprintf o concatenación manual. La interpolación mejora la legibilidad y evita errores de inyección por concatenación de strings. Elige un lenguaje con interpolación de primera clase para código de UI y logging.

  • Semántica de longitud -- len(str) en Go devuelve bytes; str.count en Swift devuelve caracteres (clústeres de grafemas). str.len() en Rust es bytes; usa str.chars().count() para caracteres. len(str) en Python cuenta puntos de código Unicode. Esto importa para validación (e.g., "máximo 10 caracteres") y truncamiento. Para límites de longitud orientados al usuario, usa APIs basadas en caracteres (Swift, Python); para almacenamiento o red, la longitud en bytes es correcta.

  • Operaciones comunes -- La mayoría de lenguajes proporcionan split, replace, trim, upper/lower y contains. Go usa funciones de paquete (strings.Split, strings.Replace); Python y JavaScript usan métodos (str.split(), str.replace()). Zig y C requieren bucles manuales o librerías externas. Si haces procesamiento intensivo de strings, prefiere Python, JavaScript o C# por sus ricas APIs incorporadas; para código embebido o de sistemas, espera implementar o importar utilidades.