No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Curso de Programaci贸n en Bash Shell

Curso de Programaci贸n en Bash Shell

Marco Antonio Toscano Freire

Marco Antonio Toscano Freire

Leer Archivos

32/43
Recursos

Aportes 15

Preguntas 1

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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

Admiro el esfuerzo del profesor por tratar de ser elocuente y sacar el curso, pero en esta clase se hizo bolas muy feo. Me da la sensaci贸n de que copi贸 el c贸digo de otro monitor con notas porque explico poco cuando mucho, y confundir un signo de pesos con una S may煤scula es una cosa muy extra帽a. Este curso necesita actualizarse. Cumple su prop贸sito pero podr铆a mejorar mucho.

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 鈥淓scribir en un archivo鈥

lectura = $(cat >> $1)

Muchas gracias profe

No entiendo porque cuando coloca un comando en el script a veces usa el formato ls a veces $(ls) o a veces simplemento lo coloca as铆 sin m谩s 驴cu谩l es la diferencia, cuando se usa uno u otro?

Un ejemplo que explica para que sirve la variable IFS:
IFS

La sustituci贸n de comandos permite usar la salida de un comando como si fuera el valor de una variable
La sintaxis antigua es : variable='comando`
pero actualmente se prefiere usar : variable=$(comando)

A estas alturas ya nadie se queja del 鈥渢ema鈥

hola buenas tardes no es nada facil para mi hacer las comillas dobles , lo hice con control y la tecla + , si sabes otra forma coenta por favor

Listo y entendido

#!/bin/bash

# Reading a file
cat $1

# Saving the read response in a variable
cat_response=`cat $1`
echo "$cat_response"

# Reading a file line by line with IFS to read also the blank spaces
while IFS= read line
do
    echo "$line"
done < $1