Índice

Strings

¿Qué es un string?

Un string es un fragmento de texto. Cada vez que escribes algo entre comillas dobles en Nyx, creas un string:

fn main() {
    let saludo: String = "¡Hola, Mundo!"
    print(saludo)
}

El nombre "string" viene de la idea de que el texto es una "cadena de caracteres" — como cuentas en un collar, cada carácter es una cuenta.

Crear strings

fn main() {
    let nombre: String = "Alice"
    let vacio: String = ""
    let frase: String = "Nyx es un lenguaje compilado."

    print(nombre)
    print(vacio)        // (no imprime nada)
    print(frase)
}

Unir strings — concatenación

Puedes unir dos strings usando el operador +. Esto se llama concatenación:

fn main() {
    let primero: String = "Hola"
    let segundo: String = "Mundo"
    let resultado: String = primero + ", " + segundo + "!"

    print(resultado)    // Hola, Mundo!
}

También puedes concatenar strings con números convirtiéndolos primero:

fn main() {
    let edad: int = 25
    let mensaje: String = "Tengo " + int_to_string(edad) + " años."
    print(mensaje)    // Tengo 25 años.
}

int_to_string() convierte un entero a su representación de texto. Esto es necesario porque + con strings significa "unir texto", no "sumar números".

Longitud del string

El método .length() te dice cuántos caracteres tiene un string:

fn main() {
    let palabra: String = "Nyx"
    print(palabra.length())    // 3

    let vacio: String = ""
    print(vacio.length())    // 0

    let frase: String = "¡Hola, Mundo!"
    print(frase.length())   // 13
}

Acceder a caracteres individuales

Puedes acceder a un solo carácter usando .charAt():

fn main() {
    let palabra: String = "Hello"

    let primero: char = palabra.charAt(0)    // 'H'
    let ultimo: char = palabra.charAt(4)     // 'o'

    // Comparar caracteres usando valores ASCII
    if primero == 72 {    // 72 es ASCII para 'H'
        print("Empieza con H")
    }
}

Nota: .charAt() devuelve un entero (el valor ASCII del carácter). Para comparar, usa el valor ASCII directamente.

Substrings

El método .substring(inicio, fin) extrae una porción de un string. Devuelve los caracteres desde la posición inicio hasta (pero sin incluir) la posición fin:

fn main() {
    let texto: String = "Hello, World!"

    let hello: String = texto.substring(0, 5)
    print(hello)    // Hello

    let world: String = texto.substring(7, 12)
    print(world)    // World
}

Buscar en strings

indexOf

El método .indexOf() encuentra la posición de un substring dentro de un string. Devuelve -1 si no lo encuentra:

fn main() {
    let texto: String = "The quick brown fox"

    let pos: int = texto.indexOf("quick")
    print(pos)     // 4

    let no_encontrado: int = texto.indexOf("slow")
    print(no_encontrado)    // -1
}

startsWith y endsWith

fn main() {
    let archivo: String = "reporte.pdf"

    if archivo.endsWith(".pdf") {
        print("Es un archivo PDF")
    }

    let url: String = "https://nyxlang.com"
    if url.startsWith("https") {
        print("Conexión segura")
    }
}

Dividir strings

El método .split() divide un string en un array basándose en un separador:

fn main() {
    let csv: String = "Alice,Bob,Charlie,Diana"
    let nombres: Array = csv.split(",")

    var i: int = 0
    while i < nombres.length() {
        print(nombres[i])
        i += 1
    }
}

Salida:

Alice
Bob
Charlie
Diana

Convertir entre tipos

fn main() {
    // Entero a string
    let n: int = 42
    let s: String = int_to_string(n)
    print(s)    // "42"

    // String a entero
    let texto: String = "123"
    let num: int = string_to_int(texto)
    print(num + 1)    // 124
}

Ejemplo práctico: contar palabras

fn contar_palabras(texto: String) -> int {
    let palabras: Array = texto.split(" ")
    return palabras.length()
}

fn main() {
    let frase: String = "Nyx es un lenguaje compilado rapido"
    print(contar_palabras(frase))    // 6
}

Ejemplo práctico: invertir un string

fn invertir_string(s: String) -> String {
    var resultado: String = ""
    var i: int = s.length() - 1
    while i >= 0 {
        let c: char = s.charAt(i)
        resultado = resultado + char_to_string(c)
        i -= 1
    }
    return resultado
}

fn main() {
    print(invertir_string("hello"))    // olleh
    print(invertir_string("Nyx"))      // xyN
}

Ejemplo práctico: construir strings por partes

fn repetir_string(s: String, veces: int) -> String {
    var resultado: String = ""
    var i: int = 0
    while i < veces {
        resultado = resultado + s
        i += 1
    }
    return resultado
}

fn main() {
    print(repetir_string("ja", 3))     // jajaja
    print(repetir_string("=-", 10))    // =-=-=-=-=-=-=-=-=-=-
}

Ejercicios

  1. Escribe una función contar_char(s: String, objetivo: String) -> int que cuente cuántas veces aparece un string de un carácter en s. Pista: usa .split() — la longitud del resultado menos 1 da la cuenta.
  1. Escribe una función es_palindromo(s: String) -> bool que devuelva true si un string se lee igual de adelante hacia atrás y viceversa. Pista: compara el string con su reverso.
  1. Escribe una función capitalizar_primera(s: String) -> String que devuelva el string con su primer carácter en mayúscula. Asume que la entrada empieza con una letra minúscula.
  1. Escribe un programa que tome una frase y la imprima palabra por palabra, numerada:

`` 1. Nyx 2. es 3. genial ``

  1. Escribe una función reemplazar_todo(texto: String, viejo: String, nuevo: String) -> String que reemplace todas las ocurrencias de viejo con nuevo. Pista: divide por viejo, luego une con nuevo.

Resumen

Siguiente capítulo: Maps →

← Anterior: Arrays Siguiente: Maps →