Leer Archivos

Un poquito digerido para los que se puedan perder en el qué pasa aquí:
\

• IFS es una variable especial que define un separador de tokens, esto es si quiero obtener partes separadas de una cadena. En este caso no se quiere separar nada de cada línea, entonces se pone en blanco con

IFS=

• La ejecución del while es sobre un comando, entonces corre siempre que el comando sea exitoso
• El comando al interior de while es:

IFS= read linea

Que tiene dos partes:

1. Establecer IFS como vacío solo para la ejecución de read (evita problemas de separaciones no deseadas)
2. Leer una linea del archivo de forma repetida hasta que read falle por fin de archivo. En este caso, por como se ha escrito todo el bloque while, ocurre en general un

read linea < ruta_al_archivo

Esta sintaxis es la redirección de entrada estándar, o sea que le estoy pasando a read que lea como si fuera la entrada interactiva, pero directamente toma el archivo

Hola… saludos.

# ! /bin/bash
# Programa para leer un archivo
# Author Diego Beltran histagram @diegodevelops

echo "Leer archivoss"
cat $1
echo -e "\nAlmacenar valores en un avariable"
valorCat=`cat $1`
echo "$valorCat"

#se usa variable especial IFS (internal file separator) evitar recortes de espacios en blanco
echo -e "\nLeer archivos linea por linea utilizando while "
while IFS= read linea
do
    echo "$linea"
done < $1```

para quien no entendió el bloque de código while les comparto esta explicación detallada del proceso del bloque. Va a ser un poco extenso pero vale la pena leerlo todo ya que refuerzan conocimiento y los relacionan. 1\)Porque el while lee linea por linea: La instrucción `read linea` en el bucle `while` lee línea por línea del archivo `archivo.txt` debido al comportamiento predeterminado del comando `read`. Cada vez que se ejecuta `read linea`, se lee una línea completa del archivo y se almacena en la variable `linea`. El comportamiento de `read` está diseñado de esta manera para facilitar la lectura y procesamiento de archivos línea por línea. El bucle `while` continuará ejecutándose hasta que no haya más líneas que leer en el archivo, y en cada iteración, `read linea` leerá la siguiente línea del archivo. Este enfoque es útil en muchos casos, especialmente cuando estás trabajando con archivos de texto y deseas procesar la información línea por línea, ya que no necesitas cargar todo el archivo en la memoria. La redirección `< archivo.txt` al final del bucle `while` es lo que conecta la entrada estándar del bucle al contenido del archivo `archivo.txt`, permitiendo que `read` lea desde ese archivo en lugar de esperar la entrada del usuario a través del teclado. En resumen, el bucle `while` con la instrucción `read linea` lee línea por línea del archivo `archivo.txt` debido al comportamiento predeterminado del comando `read` y la redirección de entrada (`<`). 2\) IFS: En Bash y en muchos otros shells, cuando se utiliza el comando `read` sin especificar el separador de campos (`IFS`), Bash divide la entrada en palabras basándose en los caracteres definidos en la variable de entorno `IFS` (Internal Field Separator). Por defecto, `IFS` incluye espacios en blanco (espacios, tabulaciones y saltos de línea), por lo que `read` dividirá la entrada en palabras separadas por estos caracteres. Cuando estableces `IFS` en una cadena vacía (`IFS=`) antes de ejecutar el comando `read`, estás indicando a Bash que no use ningún carácter como separador de campos. Esto significa que `read` leerá la línea completa sin dividirla en palabras. Por ejemplo, considera el siguiente código: ```js while read linea do echo "$linea" done < archivo.txt ```Si `archivo.txt` contiene la siguiente línea: Hola mundo El bucle `while` dividirá esa línea en dos palabras, "Hola" y "mundo", porque por defecto Bash utiliza espacios en blanco como separadores. En cambio, si utilizas `IFS=` antes de `read`: ```js while IFS= read linea do echo "$linea" done < archivo.txt ```El bucle `while` leerá la línea completa, incluidos los espacios en blanco, porque `IFS` se ha establecido en una cadena vacía. Esta es una técnica común cuando deseas leer líneas completas de un archivo sin dividirlas en palabras, especialmente cuando manejas archivos que contienen espacios en blanco en los nombres o en el contenido de las líneas. 3\)Conclusión general del bloque: Este bloque de código Bash está diseñado para leer líneas de un archivo cuya ruta se proporciona como argumento al script (`$1`) y luego imprimir cada línea en la consola. Vamos a desglosar el código para entenderlo mejor: `while IFS= read` linea `do` ` echo "$linea"` `done < $1` * `while`: Inicia un bucle `while`, que se repetirá mientras la condición que sigue a la palabra clave `while` sea verdadera. * `IFS=`: Establece la variable `IFS` (Internal Field Separator) en una cadena vacía. Esto evita que Bash divida la entrada en palabras basándose en los espacios en blanco. Al establecer `IFS` en una cadena vacía, se conservan los espacios en blanco alrededor de las líneas. * `read linea`: Lee una línea del archivo de entrada y la almacena en la variable `linea`. * `do`: Inicia el bloque de comandos que se ejecutarán mientras la condición del bucle sea verdadera. * `echo "$linea"`: Imprime la línea leída en la consola. * `done`: Finaliza el bloque de comandos del bucle. * `< $1`: Redirige la entrada estándar del bucle (`done`) desde el archivo cuya ruta se proporciona como argumento al script (`$1`). Entonces, el bucle `while` lee cada línea del archivo especificado en `$1`, estableciendo `IFS` para preservar los espacios en blanco y luego imprime cada línea en la consola. Por ejemplo, si este script se ejecuta con `./script.sh archivo.txt`, donde `archivo.txt` es un archivo que contiene varias líneas de texto, el script imprimirá cada línea en la consola. Esto es útil para procesar archivos línea por línea en un script de Bash.

Queda de la siguiente forma:

# ! /bin/bash
# Programa para ejemplificar como se lee en un archivo
# Autor Jose Suarez

echo "Leer en un Archivos"
cat $1
echo -e "\nAlmacenar valores en un avariable"
valorCat=`cat $1`
echo "$valorCat"

#se usa variable especial IFS (internal field separator) evitar recortes de espacios en blanco
echo -e "\nLeer archivos linea por linea utilizando while "
while IFS= read linea
do
        echo "$linea"
done < $1

Existen 3 métodos:

• A través de echo
• A través de una variable auxiliar
• A través de un loop while línea por línea

<h5>Ejemplo</h5>

# ! /bin/bash
# Programa para ejemplificar cómo se lee en un archivo
# Autor: Juan Manuel

echo "Leer en un archivo"

#Primer método
echo -e "\nLeer directamente todo el archivo"
cat $1

#Segundo método
echo -e "\nAlmacenar los valores en una variable"
valorCat=`cat $1`
echo "$valorCat"

#Tercer método
#Se utiliza la variable especial IFS (Internal File Separator) para evitar que los espacios en blanco se recorten
echo -e "\nLeer archivos línea por línea utilizando while"
while IFS= read linea
do
    echo "$linea"
done < $1

podemos ir copiando y dando enter hasta las lineas que queramos enviar al argumento y se finaliza con control+c

echo “Escribir en un archivo”

lectura = $(cat >> $1)

Muchas gracias profe

En \*\*Bash\*\*, puedes leer archivos de varias maneras, dependiendo de lo que quieras hacer con su contenido. A continuación te muestro algunos de los métodos más comunes para leer archivos en un script de Bash o desde la terminal: \### Métodos para Leer Archivos en Bash 1\. \*\*Usar `cat`\*\*: El comando `cat` es una forma sencilla y directa de mostrar el contenido completo de un archivo. \- Ejemplo: Leer y mostrar el contenido de `archivo.txt`: ```bash cat archivo.txt ``` 2\. \*\*Usar `less` o `more`\*\*: Estos comandos son útiles para leer archivos largos, ya que permiten moverse por el contenido del archivo página por página. \- Ejemplo: Leer `archivo.txt` con `less`: ```bash less archivo.txt ``` \- Con `more`, similar pero con menos opciones de navegación: ```bash more archivo.txt ``` 3\. \*\*Usar `head`\*\*: `head` muestra las primeras líneas de un archivo (por defecto, 10 líneas). \- Ejemplo: Leer las primeras 5 líneas de `archivo.txt`: ```bash head -n 5 archivo.txt ``` 4\. \*\*Usar `tail`\*\*: `tail` muestra las últimas líneas de un archivo. \- Ejemplo: Leer las últimas 10 líneas de `archivo.txt`: ```bash tail archivo.txt ``` \- También puedes usar `tail -f archivo.txt` para ver en tiempo real las nuevas líneas que se agreguen a un archivo (útil para archivos de logs): ```bash tail -f archivo.txt ``` 5\. \*\*Leer archivos línea por línea en un script Bash\*\*: En un script, puedes leer un archivo línea por línea usando un bucle `while` y el comando `read`. \- Ejemplo: Leer el contenido de `archivo.txt` línea por línea: ```bash while IFS= read -r linea; do echo "$linea" done < archivo.txt ``` En este ejemplo: \- `IFS=` evita que se eliminen espacios en blanco iniciales y finales. \- `read -r` asegura que los caracteres de escape como `\\` no se interpreten. 6\. \*\*Usar `mapfile` (o `readarray`)\*\*: `mapfile` lee todo el archivo en un arreglo, donde cada elemento del arreglo es una línea del archivo. \- Ejemplo: Leer un archivo completo en un arreglo: ```bash mapfile -t lineas < archivo.txt ``` \- Para acceder a una línea específica (por ejemplo, la línea 1): ```bash echo "${lineas\[0]}" ``` 7\. \*\*Leer archivos palabra por palabra\*\*: Puedes usar un bucle para leer palabras en lugar de líneas. \- Ejemplo: Leer `archivo.txt` palabra por palabra: ```bash while read -r palabra; do echo "$palabra" done < <(cat archivo.txt) ``` 8\. \*\*Usar `awk` o `sed` para leer y procesar contenido\*\*: `awk` y `sed` son herramientas potentes para leer y procesar archivos en Bash. \- Con `awk`, puedes procesar un archivo línea por línea y dividir las líneas en campos: ```bash awk '{print $1}' archivo.txt # Muestra el primer campo de cada línea ``` \- Con `sed`, puedes buscar y mostrar texto, o hacer cambios en el archivo: ```bash sed -n '1,5p' archivo.txt # Muestra las líneas de la 1 a la 5 ``` \### Ejemplo de Script para Leer Archivos en Bash: Supongamos que tienes un archivo llamado `datos.txt` con contenido, y quieres leerlo línea por línea en un script. ```bash \#!/bin/bash \# Nombre del archivo archivo="datos.txt" \# Verificar si el archivo existe if \[\[ ! -f $archivo ]]; then echo "El archivo no existe." exit 1 fi \# Leer el archivo línea por línea while IFS= read -r linea; do echo "Línea: $linea" done < "$archivo" ``` En este script: \- Primero se verifica si el archivo existe. \- Luego, se lee línea por línea y se muestra el contenido en la terminal. \### Resumen de las Herramientas para Leer Archivos en Bash: \- \*\*`cat`\*\*: Muestra todo el contenido. \- \*\*`less`/`more`\*\*: Muestra el contenido paginado. \- \*\*`head`\*\* y \*\*`tail`\*\*: Muestra las primeras o últimas líneas. \- \*\*Bucle `while`\*\*: Para leer línea por línea. \- \*\*`mapfile`\*\*: Para leer todo el archivo en un arreglo. \- \*\*`awk` y `sed`\*\*: Para procesar y manipular archivos de texto.