Operaciones Básicas con Cadenas en Shell

Introducción

En este laboratorio, aprenderás las operaciones fundamentales con cadenas de texto (strings) en el scripting de shell. Las operaciones con cadenas son esenciales para manipular y extraer datos de textos en diversas tareas de automatización. Explorarás conceptos como determinar la longitud de una cadena, encontrar posiciones de caracteres, extraer subcadenas y reemplazar partes de un texto. Estas habilidades son cruciales para un procesamiento de texto eficaz en scripts de shell.

Guía de Referencia Rápida

Aquí tienes un resumen de las operaciones con cadenas que cubriremos en este laboratorio:

Operación	Sintaxis	Descripción	Ejemplo
Longitud de Cadena	`${#string}`	Calcula el número de caracteres en una cadena	`${#"hello"}` devuelve `5`
Buscar Posición	`$(expr index "$string" "$char")`	Busca la posición de un carácter (basado en 1)	`$(expr index "abcdef" "c")` devuelve `3`
Extraer Subcadena	`${string:start:length}`	Extrae una porción de la cadena (basado en 0)	`${"hello":1:3}` devuelve `ell`
Reemplazar Primera Vez	`${string/pattern/replacement}`	Reemplaza la primera coincidencia de un patrón	`${"hello"/l/L}` devuelve `heLlo`
Reemplazar Todas	`${string//pattern/replacement}`	Reemplaza todas las coincidencias de un patrón	`${"hello"//l/L}` devuelve `heLLo`
Reemplazar al Inicio	`${string/#pattern/replacement}`	Reemplaza el patrón solo si está al principio	`${"hello"/#he/HE}` devuelve `HEllo`
Reemplazar al Final	`${string/%pattern/replacement}`	Reemplaza el patrón solo si está al final	`${"hello"/%lo/LO}` devuelve `helLO`

Creación de un Archivo de Script

Comencemos creando un archivo de script donde escribiremos nuestras operaciones con cadenas.

Abre la terminal en el WebIDE. La terminal es donde escribirás los comandos para interactuar con el sistema Linux.
Navega al directorio del proyecto:
```
cd ~/project
```
Este comando cambia tu directorio actual a ~/project. El símbolo ~ representa tu directorio personal (home), por lo que ~/project es una carpeta llamada "project" en tu directorio personal.
Crea un nuevo archivo llamado string_operations.sh:
```
touch string_operations.sh
```
El comando touch crea un archivo nuevo y vacío. Si el archivo ya existe, actualiza su marca de tiempo.
Abre el archivo en el editor del WebIDE. Puedes hacerlo haciendo clic en el nombre del archivo en el explorador de archivos en el lado izquierdo de tu WebIDE.
Añade la siguiente línea "shebang" en la parte superior del archivo para especificar el intérprete:
```
#!/bin/bash
```
Esta línea, llamada "shebang", le indica al sistema que use el shell Bash para interpretar este script. Siempre debe ser la primera línea de un script de shell.

Longitud de Cadena

Ahora, aprendamos cómo determinar la longitud de una cadena de texto.

Añade el siguiente código a tu archivo string_operations.sh:
```
echo "Step 2: String Length"

STRING="Hello, World!"
LENGTH=${#STRING}

echo "The string is: $STRING"
echo "Its length is: $LENGTH"
```
Desglosemos esto paso a paso:
- Primero, añadimos un comando echo para mostrar un encabezado para esta sección.
```
echo "Step 2: String Length"
```
- Luego, definimos una variable llamada STRING y le asignamos el valor "Hello, World!".
```
STRING="Hello, World!"
```
  En Bash, no necesitamos usar palabras clave especiales para definir variables. Simplemente escribimos el nombre de la variable, seguido del signo igual y el valor.
- Después, calculamos la longitud de la cadena usando la sintaxis ${#variable} y la guardamos en una variable llamada LENGTH.
```
LENGTH=${#STRING}
```
  La expresión ${#variable} es una expansión de parámetros especial del shell que devuelve el número de caracteres en la cadena almacenada en la variable.
- Finalmente, mostramos tanto la cadena original como su longitud.
```
echo "The string is: $STRING"
echo "Its length is: $LENGTH"
```
  El símbolo $ antes del nombre de una variable le indica a Bash que debe reemplazarlo por el valor de dicha variable.
Guarda el archivo. En la mayoría de los editores, puedes hacerlo presionando Ctrl+S (o Cmd+S en Mac).
Haz que el script sea ejecutable:
```
chmod +x string_operations.sh
```
Este comando cambia los permisos del archivo para permitir su ejecución:
- chmod significa "change mode" (cambiar modo).
- +x significa "añadir permiso de ejecución".
- Sin este paso, el sistema no sabría que este archivo debe tratarse como un programa.
Ejecuta el script:
```
./string_operations.sh
```
El prefijo ./ le indica al shell que busque el script en el directorio actual. Sin él, el shell solo buscaría en los directorios listados en tu variable de entorno PATH.

Deberías ver una salida similar a:

Step 2: String Length
The string is: Hello, World!
Its length is: 13

Si no ves esta salida, verifica que hayas guardado el archivo y que le hayas dado permisos de ejecución.

Búsqueda de la Posición de un Carácter

A continuación, aprenderemos cómo encontrar la posición de un carácter dentro de una cadena.

Añade el siguiente código a tu archivo string_operations.sh:
```
echo -e "\nStep 3: Finding Character Position"

STRING="abcdefghijklmnopqrstuvwxyz"
CHAR="j"

POSITION=$(expr index "$STRING" "$CHAR")

echo "The string is: $STRING"
echo "We're looking for the character: $CHAR"
echo "It is at position: $POSITION"
```
Examinemos este código en detalle:
- Comenzamos con un comando echo que incluye la opción -e y una secuencia de escape \n.
```
echo -e "\nStep 3: Finding Character Position"
```
  - La opción -e habilita la interpretación de secuencias de escape.
  - La secuencia \n añade una nueva línea antes del texto, creando una separación visual con la sección anterior.
- Luego, definimos dos variables:
```
STRING="abcdefghijklmnopqrstuvwxyz"
CHAR="j"
```
  - STRING contiene todo el alfabeto en minúsculas.
  - CHAR contiene el carácter "j" que queremos buscar.
- Usamos el comando expr index para encontrar la posición del carácter:
```
POSITION=$(expr index "$STRING" "$CHAR")
```
  - expr es una utilidad para evaluar expresiones.
  - La operación index busca caracteres en una cadena.
  - La sintaxis $() captura la salida del comando y la asigna a la variable POSITION.
  - Envolvemos las variables en comillas dobles ("$STRING") para evitar problemas con caracteres especiales.
  - Importante: Este comando devuelve posiciones comenzando desde 1 (no desde 0).
- Finalmente, imprimimos los resultados:
```
echo "The string is: $STRING"
echo "We're looking for the character: $CHAR"
echo "It is at position: $POSITION"
```
Guarda el archivo y ejecuta el script de nuevo:
```
./string_operations.sh
```

Deberías ver una salida adicional similar a:

Step 3: Finding Character Position
The string is: abcdefghijklmnopqrstuvwxyz
We're looking for the character: j
It is at position: 10

Ten en cuenta que la posición se basa en un índice que empieza en 1, lo que significa que el primer carácter está en la posición 1, no en la 0. Esto es diferente a muchos lenguajes de programación donde la indexación suele empezar en 0.

Extracción de Subcadenas

Ahora, aprenderemos cómo extraer una porción de una cadena de texto.

Añade el siguiente código a tu archivo string_operations.sh:
```
echo -e "\nStep 4: Substring Extraction"

STRING="The quick brown fox jumps over the lazy dog"
START=10
LENGTH=5

SUBSTRING=${STRING:$START:$LENGTH}

echo "The original string is: $STRING"
echo "Extracting 5 characters starting from position 10:"
echo "The substring is: $SUBSTRING"
```
Analicemos este código pieza por pieza:
- Primero, añadimos un encabezado con una nueva línea para separación visual:
```
echo -e "\nStep 4: Substring Extraction"
```
- Luego, definimos nuestras variables:
```
STRING="The quick brown fox jumps over the lazy dog"
START=10
LENGTH=5
```
  - STRING contiene una frase de ejemplo.
  - START es la posición donde queremos empezar la extracción (posición 10).
  - LENGTH es cuántos caracteres queremos extraer (5 caracteres).
- Usamos la sintaxis de extracción de subcadenas de Bash para obtener una parte del texto:
```
SUBSTRING=${STRING:$START:$LENGTH}
```
  - La sintaxis es ${variable:posicion_inicial:longitud}.
  - $START y $LENGTH son variables que contienen los valores 10 y 5.
  - Importante: A diferencia del comando expr index, las posiciones aquí se basan en un índice que empieza en 0, lo que significa que el primer carácter está en la posición 0.
- Finalmente, mostramos los resultados:
```
echo "The original string is: $STRING"
echo "Extracting 5 characters starting from position 10:"
echo "The substring is: $SUBSTRING"
```
Guarda el archivo y ejecuta el script de nuevo:
```
./string_operations.sh
```

Deberías ver una salida adicional similar a:

Step 4: Substring Extraction
The original string is: The quick brown fox jumps over the lazy dog
Extracting 5 characters starting from position 10:
The substring is: brown

En la cadena "The quick brown fox...", la posición 10 (contando desde 0) es la 'b' de "brown", y los siguientes 5 caracteres forman la palabra "brown". Por eso nuestra subcadena extraída es "brown".

Recuerda que la indexación es diferente a la que vimos en el paso anterior:

En expr index (Paso 3), las posiciones empiezan en 1 (el primer carácter es la posición 1).
En la extracción de subcadenas ${STRING:posicion:longitud} (Paso 4), las posiciones empiezan en 0 (el primer carácter es la posición 0).

Esta es una fuente común de confusión en el scripting de shell, por lo que es importante recordar qué operación utiliza cada sistema de indexación.

Reemplazo de Cadenas

Finalmente, aprenderemos cómo reemplazar partes de una cadena.

Añade el siguiente código a tu archivo string_operations.sh:

echo -e "\nStep 5: String Replacement"

STRING="The quick brown fox jumps over the lazy dog"
echo "Original string: $STRING"

## Replace the first occurrence of 'o' with 'O'
NEW_STRING=${STRING/o/O}
echo "Replacing first 'o' with 'O': $NEW_STRING"

## Replace all occurrences of 'o' with 'O'
NEW_STRING=${STRING//o/O}
echo "Replacing all 'o' with 'O': $NEW_STRING"

## Replace 'The quick' with 'The slow' if it's at the beginning of the string
NEW_STRING=${STRING/#The quick/The slow}
echo "Replacing 'The quick' with 'The slow' at the beginning: $NEW_STRING"

## Replace 'dog' with 'cat' if it's at the end of the string
NEW_STRING=${STRING/%dog/cat}
echo "Replacing 'dog' with 'cat' at the end: $NEW_STRING"

Repasemos cada operación de reemplazo:

Primero, imprimimos un encabezado y mostramos la cadena original:

echo -e "\nStep 5: String Replacement"
STRING="The quick brown fox jumps over the lazy dog"
echo "Original string: $STRING"

Reemplazar la primera coincidencia de un carácter:
```
## Replace the first occurrence of 'o' with 'O'
NEW_STRING=${STRING/o/O}
echo "Replacing first 'o' with 'O': $NEW_STRING"
```
- La sintaxis es ${variable/patron/reemplazo}.
- Esto buscará la primera 'o' y la reemplazará por 'O'.
- Solo la primera 'o' en "brown" será reemplazada, dejando las demás igual.
Reemplazar todas las coincidencias de un carácter:
```
## Replace all occurrences of 'o' with 'O'
NEW_STRING=${STRING//o/O}
echo "Replacing all 'o' with 'O': $NEW_STRING"
```
- La sintaxis es ${variable//patron/reemplazo} (nota la doble barra diagonal).
- La doble barra le indica a Bash que reemplace TODAS las coincidencias del patrón.
- Todas las 'o' en toda la cadena serán reemplazadas por 'O'.
Reemplazar un patrón al principio de una cadena:
```
## Replace 'The quick' with 'The slow' if it's at the beginning of the string
NEW_STRING=${STRING/#The quick/The slow}
echo "Replacing 'The quick' with 'The slow' at the beginning: $NEW_STRING"
```
- La sintaxis es ${variable/#patron/reemplazo}.
- El símbolo # especifica que el patrón debe estar al inicio de la cadena.
- Esto solo reemplazará 'The quick' si aparece justo al comenzar el texto.
Reemplazar un patrón al final de una cadena:
```
## Replace 'dog' with 'cat' if it's at the end of the string
NEW_STRING=${STRING/%dog/cat}
echo "Replacing 'dog' with 'cat' at the end: $NEW_STRING"
```
- La sintaxis es ${variable/%patron/reemplazo}.
- El símbolo % especifica que el patrón debe estar al final de la cadena.
- Esto solo reemplazará 'dog' si aparece justo al terminar el texto.

Guarda el archivo y ejecuta el script de nuevo:
```
./string_operations.sh
```

Deberías ver una salida adicional similar a:

Step 5: String Replacement
Original string: The quick brown fox jumps over the lazy dog
Replacing first 'o' with 'O': The quick brOwn fox jumps over the lazy dog
Replacing all 'o' with 'O': The quick brOwn fOx jumps Over the lazy dOg
Replacing 'The quick' with 'The slow' at the beginning: The slow brown fox jumps over the lazy dog
Replacing 'dog' with 'cat' at the end: The quick brown fox jumps over the lazy cat

Estas operaciones de reemplazo son herramientas potentes para manipular texto en scripts de shell. Te permiten realizar cambios específicos basados en patrones y posiciones, lo cual es especialmente útil para tareas como el procesamiento de datos, el formateo de texto o la modificación del contenido de archivos.

Resumen

En este laboratorio, has aprendido y practicado varias operaciones fundamentales con cadenas de texto en el scripting de shell:

Creación y ejecución de un script de shell.
Cálculo de la longitud de una cadena usando ${#string}.
Búsqueda de la posición de un carácter usando $(expr index "$string" "$char").
Extracción de una subcadena a partir de una cadena mayor usando ${string:start:length}.
Realización de diversas operaciones de reemplazo de texto usando:
- ${string/pattern/replacement} - Reemplazar la primera coincidencia.
- ${string//pattern/replacement} - Reemplazar todas las coincidencias.
- ${string/#pattern/replacement} - Reemplazar al inicio de la cadena.
- ${string/%pattern/replacement} - Reemplazar al final de la cadena.

Estas habilidades forman la base para tareas de procesamiento de texto más complejas en el scripting de shell. A medida que sigas trabajando con scripts, descubrirás que estas operaciones son invaluables para manipular y analizar datos de texto en tus proyectos. Recuerda que la práctica es clave para dominar estos conceptos, ¡así que no dudes en experimentar con diferentes cadenas y operaciones!

Operaciones Básicas con Cadenas de Texto

Introducción

Guía de Referencia Rápida

Creación de un Archivo de Script

Longitud de Cadena

Búsqueda de la Posición de un Carácter

Extracción de Subcadenas

Reemplazo de Cadenas

Resumen