0Pricing
C Academy · Lección

strtok y tokenización

Divida strings

strtok y tokenización es una lección gratuita de C Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C Academy incluye 4 lecciones en total.

¿Qué es la tokenización?

La tokenización consiste en dividir una cadena en partes más pequeñas (tokens) separadas por caracteres delimitadores.

Por ejemplo, dividir "a,b,c" usando comas produce los tokens a, b y c. C proporciona strtok para hacerlo.

#include <stdio.h>
#include <string.h>

int main(void) {
    char text[] = "a,b,c";
    char *token = strtok(text, ",");
    printf("First token: %s\n", token);
    return 0;
}

La firma de strtok

char *strtok(char *str, const char *delim);

En la primera llamada se pasa la cadena. En las llamadas posteriores se pasa NULL para continuar donde se quedó. Devuelve el siguiente token o NULL cuando termina.

#include <stdio.h>
#include <string.h>

int main(void) {
    char text[] = "red green blue";
    char *tok = strtok(text, " ");
    while (tok != NULL) {
        printf("%s\n", tok);
        tok = strtok(NULL, " ");
    }
    return 0;
}

strtok modifica la cadena

Importante: strtok cambia la cadena original. Reemplaza cada delimitador por '\0' y devuelve punteros al mismo búfer.

Por eso no puede tokenizar un literal de cadena como "a,b", que es de solo lectura.

#include <stdio.h>
#include <string.h>

int main(void) {
    char data[] = "x:y:z";
    strtok(data, ":");
    printf("data[1] is now: %d (the null byte)\n", data[1]);
    return 0;
}

Cree una copia modificable

Como strtok destruye su entrada, copie primero la cadena si necesita conservar la original.

Use una matriz local de char o copie con strcpy en un búfer.

#include <stdio.h>
#include <string.h>

int main(void) {
    const char *original = "one-two-three";
    char copy[64];
    strcpy(copy, original);
    char *tok = strtok(copy, "-");
    while (tok) {
        printf("%s\n", tok);
        tok = strtok(NULL, "-");
    }
    printf("Original intact: %s\n", original);
    return 0;
}

Varios delimitadores

El argumento delim es un conjunto de caracteres, no una secuencia. Cualquier carácter del conjunto actúa como separador.

Así, " ,;" divide a la vez por espacios, comas y puntos y comas.

#include <stdio.h>
#include <string.h>

int main(void) {
    char text[] = "a,b;c d";
    char *tok = strtok(text, ",; ");
    while (tok) {
        printf("[%s]\n", tok);
        tok = strtok(NULL, ",; ");
    }
    return 0;
}

Delimitadores consecutivos

strtok trata las secuencias de delimitadores como un único separador y omite los tokens vacíos.

Por tanto, "a,,b" produce solo a y b, sin un token vacío intermedio. Téngalo en cuenta al analizar archivos CSV, donde los campos vacíos son importantes.

#include <stdio.h>
#include <string.h>

int main(void) {
    char text[] = "a,,b";
    char *tok = strtok(text, ",");
    while (tok) {
        printf("token: %s\n", tok);
        tok = strtok(NULL, ",");
    }
    return 0;
}

Contar tokens

Una tarea habitual es contar cuántos tokens contiene una cadena. Incremente un contador dentro del bucle.

#include <stdio.h>
#include <string.h>

int main(void) {
    char sentence[] = "the quick brown fox";
    int count = 0;
    char *tok = strtok(sentence, " ");
    while (tok) {
        count++;
        tok = strtok(NULL, " ");
    }
    printf("Word count: %d\n", count);
    return 0;
}

strtok conserva un estado oculto

strtok guarda su posición en una variable interna estática. Por eso NULL permite continuar con la cadena anterior.

La desventaja es que no es reentrante ni segura para subprocesos. No puede tokenizar dos cadenas a la vez.

#include <stdio.h>
#include <string.h>

int main(void) {
    char a[] = "1 2";
    char *t = strtok(a, " ");
    printf("%s\n", t);
    t = strtok(NULL, " ");
    printf("%s\n", t);
    return 0;
}

Almacenar tokens

Para usar los tokens después de dividir la cadena, almacene los punteros devueltos en una matriz. Apuntan al búfer de origen (ya modificado), que debe seguir existiendo.

#include <stdio.h>
#include <string.h>

int main(void) {
    char csv[] = "name,age,city";
    char *fields[10];
    int n = 0;
    char *tok = strtok(csv, ",");
    while (tok && n < 10) {
        fields[n++] = tok;
        tok = strtok(NULL, ",");
    }
    for (int i = 0; i < n; i++)
        printf("Field %d: %s\n", i, fields[i]);
    return 0;
}

La alternativa reentrante

POSIX ofrece strtok_r, que recibe un char **saveptr explícito en lugar de un estado oculto. Esto permite anidar llamadas y usarla de forma segura entre subprocesos.

En el C estándar portable, strtok normal es suficiente para analizar una cadena en un único recorrido.

#include <stdio.h>
#include <string.h>

int main(void) {
    char text[] = "p:q:r";
    char *save;
    char *tok = strtok_r(text, ":", &save);
    while (tok) {
        printf("%s\n", tok);
        tok = strtok_r(NULL, ":", &save);
    }
    return 0;
}

Práctica: dividir una ruta

La tokenización resulta especialmente útil al analizar texto estructurado, como las rutas de archivos. Dividir por / revela cada componente de la ruta.

#include <stdio.h>
#include <string.h>

int main(void) {
    char path[] = "usr/local/bin";
    char *part = strtok(path, "/");
    while (part) {
        printf("-> %s\n", part);
        part = strtok(NULL, "/");
    }
    return 0;
}

Comprobación rápida

Compruebe cuánto entiende sobre el funcionamiento de strtok.

Repaso

Ha aprendido a dividir cadenas con strtok:

  • La primera llamada recibe la cadena; las siguientes reciben NULL.
  • Modifica la entrada y reemplaza los delimitadores por '\0': copie primero las cadenas de solo lectura.
  • El argumento delimitador es un conjunto; los delimitadores consecutivos se agrupan.
  • Usa un estado estático y no es segura para subprocesos; use strtok_r cuando sea necesario.

Preguntas frecuentes

¿La lección «strtok y tokenización» es gratis?

Sí — el texto completo de «strtok y tokenización» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C Academy, actualiza a CoddyKit PRO. El curso de C Academy incluye 4 lecciones en total.

¿Qué aprenderé en «strtok y tokenización»?

Divida strings Practicas C Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C Academy?

No se requiere experiencia previa. C Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «strtok y tokenización»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C Academy?

Sí. Cada lección de C Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. strlen, strcpy, strcat
  2. strcmp y comparación
  3. strtok y tokenización
  4. memcpy y memset
← Volver a C Academy