Editar Archivos de Texto en Red Hat Enterprise Linux: Guía Completa

Introducción

En este laboratorio, adquirirás habilidades esenciales para la gestión de archivos de texto y la personalización de tu entorno de shell en Linux. Aprenderás a redirigir la salida estándar y los flujos de error a archivos, a combinar diferentes flujos y a construir potentes tuberías de comandos para automatizar tareas.

Además, explorarás los fundamentos de la edición de archivos de texto utilizando Vim, un editor de texto ampliamente utilizado y potente. Finalmente, aprenderás a configurar y utilizar variables y alias de shell para personalizar tu experiencia en la línea de comandos y mejorar la productividad.

Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel principiante con una tasa de finalización del 86%. Ha recibido una tasa de reseñas positivas del 99% por parte de los estudiantes.

Redirigir la Salida Estándar a Archivos

En este paso, aprenderás a redirigir la salida estándar de los comandos a archivos. Esta es una habilidad fundamental en la administración de sistemas Linux, que te permite capturar los resultados de los comandos para su posterior análisis, registro o procesamiento.

El shell utiliza descriptores de archivo especiales para gestionar la entrada y la salida. Los más comunes son:

0: Entrada Estándar (stdin) - Típicamente desde el teclado.
1: Salida Estándar (stdout) - Típicamente a la pantalla de la terminal.
2: Error Estándar (stderr) - Típicamente a la pantalla de la terminal para mensajes de error.

Nos centraremos en redirigir stdout en esta sección.

Sobrescritura de un Archivo con `>`

El operador > redirige la salida estándar de un comando a un archivo especificado. Si el archivo no existe, se creará. Si el archivo ya existe, su contenido se sobrescribirá.

Comencemos creando un archivo de texto simple con la fecha y hora actuales.

Primero, asegúrate de estar en la carpeta project de tu directorio de inicio.
```
cd ~/project
```
```
[labex@host project]$
```
Ahora, usa el comando date y redirige su salida a un nuevo archivo llamado current_datetime.txt.
```
date > current_datetime.txt
```
Este comando ejecutará date, pero en lugar de imprimir la fecha en tu terminal, la guardará en current_datetime.txt.
Verifica el contenido del archivo usando el comando cat.
```
cat current_datetime.txt
```
```
Mon Day XX HH:MM:SS AM/PM TimeZone YYYY
```
La salida mostrará la fecha y hora actuales, similar al ejemplo anterior.
Ahora, intentemos redirigir la salida de echo al mismo archivo. Esto sobrescribirá el contenido anterior.
```
echo "This is a new line of text." > current_datetime.txt
```
Verifica el contenido del archivo de nuevo.
```
cat current_datetime.txt
```
```
This is a new line of text.
```
Como puedes ver, la fecha y hora originales fueron reemplazadas por la nueva línea de texto.

Anexar a un Archivo con `>>`

El operador >> redirige la salida estándar de un comando a un archivo especificado, anexando el nuevo contenido al final del archivo. Si el archivo no existe, se creará.

Vamos a anexar más contenido a nuestro archivo current_datetime.txt.

Anexa otra línea de texto a current_datetime.txt.

echo "This line is appended." >> current_datetime.txt

Visualiza el contenido del archivo.
```
cat current_datetime.txt
```
```
This is a new line of text.
This line is appended.
```
Observa que la nueva línea se agregó después del contenido existente.
Vamos a anexar la fecha y hora actuales de nuevo.
```
date >> current_datetime.txt
```

Verifica el contenido del archivo una vez más.

cat current_datetime.txt

This is a new line of text.
This line is appended.
Mon Day XX HH:MM:SS AM/PM TimeZone YYYY

La fecha y hora ahora están al final del archivo.

Redireccionamiento de la Salida de Otros Comandos

Puedes redirigir la salida de casi cualquier comando. Intentemos redirigir la salida de ls y wc.

Redirige la salida de ls -l (formato de listado largo) a un archivo llamado file_list.txt.
```
ls -l > file_list.txt
```
Inspecciona el contenido de file_list.txt.
```
cat file_list.txt
```
```
total 4
-rw-r--r-- 1 labex labex 80 Jun  4 07:04 current_datetime.txt
-rw-r--r-- 1 labex labex  0 Jun  4 07:04 file_list.txt
```
Este archivo ahora contiene el listado detallado de archivos en tu directorio actual. Los tamaños y marcas de tiempo exactos de los archivos variarán según cuándo ejecutes los comandos.
Ahora, contemos el número de líneas en file_list.txt usando wc -l y redirijamos ese conteo a otro archivo, line_count.txt.
```
wc -l file_list.txt > line_count.txt
```
Visualiza el contenido de line_count.txt.
```
cat line_count.txt
```
```
3 file_list.txt
```
La salida muestra que file_list.txt tiene 3 líneas (incluida la línea total y las dos entradas de archivo).

Esto concluye la primera parte del redireccionamiento de la salida estándar. Has aprendido a crear y sobrescribir archivos usando > y a anexarles contenido usando >>.

Redirigir el Error Estándar y Combinar Flujos

En este paso, aprenderás a redirigir el error estándar (stderr) y a combinar stdout y stderr en un único flujo. Esto es crucial para gestionar los mensajes de error generados por los comandos, permitiéndote registrarlos o descartarlos según sea necesario.

Recuerda que stderr es el descriptor de archivo 2. Usamos 2> para redirigir los mensajes de error.

Redireccionamiento del Error Estándar a un Archivo

A veces, los comandos producen mensajes de error que deseas capturar por separado de su salida estándar.

Asegúrate de estar en tu directorio ~/project.
```
cd ~/project
```
```
[labex@host project]$
```
Intentemos listar el contenido de un directorio que no existe. Esto generará un mensaje de error.
```
ls non_existent_directory
```
```
ls: cannot access 'non_existent_directory': No such file or directory
```
Puedes ver el mensaje de error impreso directamente en la terminal.
Ahora, redirijamos este mensaje de error a un archivo llamado errors.log.
```
ls non_existent_directory 2> errors.log
```
Esta vez, no verás el mensaje de error en tu terminal.
Verifica el contenido de errors.log.
```
cat errors.log
```
```
ls: cannot access 'non_existent_directory': No such file or directory
```
El mensaje de error ahora se almacena en el archivo.

Descartando el Error Estándar

A menudo, es posible que desees ejecutar un comando que produce mensajes de error ruidosos que no te importan. En tales casos, puedes redirigir stderr a /dev/null. /dev/null es un archivo de dispositivo especial que descarta todos los datos escritos en él.

Intenta el comando ls con el directorio que no existe de nuevo, pero esta vez, descarta el error.
```
ls non_existent_directory 2> /dev/null
```
No verás ninguna salida en la terminal, y no se guarda ningún mensaje de error en un archivo.

Combinando la Salida Estándar y el Error Estándar

Hay situaciones en las que deseas capturar tanto stdout como stderr en el mismo archivo. Esto se puede hacer de varias maneras.

Método 1: `> file 2>&1`

Este método redirige stdout a un archivo, y luego redirige stderr a la misma ubicación que stdout. El orden 2>&1 es importante: significa "redirigir el descriptor de archivo 2 (stderr) al mismo lugar que el descriptor de archivo 1 (stdout)".

Creemos un comando que produzca tanto salida estándar como error estándar. Usaremos find para buscar un archivo en un directorio donde tenemos permisos y en un directorio donde no los tenemos.
```
find ~/project /root -name "current_datetime.txt" > combined_output.log 2>&1
```
Aquí, find ~/project -name "current_datetime.txt" producirá stdout (si se encuentra), y find /root -name "current_datetime.txt" probablemente producirá stderr debido a problemas de permisos.
Examina el archivo combined_output.log.
```
cat combined_output.log
```
```
/home/labex/project/current_datetime.txt
find: ‘/root’: Permission denied
```
Puedes ver que tanto la salida exitosa (la ruta al archivo) como el mensaje de error se capturan en el mismo archivo.

Método 2: `&> file` (Específico de Bash)

Bash proporciona una abreviatura para combinar stdout y stderr en un archivo: &>. Esto es equivalente a > file 2>&1.

Intentemos el mismo comando find usando la abreviatura &>.

find ~/project /root -name "file_list.txt" &> combined_output_shorthand.log

Verifica el contenido de combined_output_shorthand.log.
```
cat combined_output_shorthand.log
```
```
/home/labex/project/file_list.txt
find: ‘/root’: Permission denied
```
El resultado es el mismo que el método anterior, lo que demuestra la conveniencia de &>.

Anexando Flujos Combinados

Al igual que con stdout, puedes anexar stdout y stderr combinados a un archivo usando >> file 2>&1 o &>> file.

Anexa más salida y errores a combined_output.log.

find ~/project /root -name "line_count.txt" >> combined_output.log 2>&1

Visualiza el combined_output.log actualizado.

cat combined_output.log

/home/labex/project/current_datetime.txt
find: ‘/root’: Permission denied
/home/labex/project/line_count.txt
find: ‘/root’: Permission denied

La nueva salida y los errores se anexan al contenido existente.

Ahora has aprendido con éxito a redirigir el error estándar y a combinar la salida estándar y el error estándar en un único archivo. Este conocimiento es esencial para tareas de scripting y administración de sistemas robustas.

Construir y Comprender Tuberías de Comandos

En este paso, aprenderás sobre las tuberías de comandos (command pipelines), una característica poderosa en el shell de Linux que te permite encadenar múltiples comandos. La salida de un comando se convierte en la entrada del siguiente, lo que permite el procesamiento y la manipulación de datos complejos.

El operador de tubería | (barra vertical) se utiliza para conectar comandos en una tubería. Redirige la salida estándar (stdout) del comando a su izquierda a la entrada estándar (stdin) del comando a su derecha.

Tuberías Básicas

Comencemos con un ejemplo simple para comprender cómo funcionan las tuberías.

Asegúrate de estar en tu directorio ~/project.
```
cd ~/project
```
```
[labex@host project]$
```

Primero, enumeremos los archivos en el directorio actual.

ls

combined_output.log
combined_output_shorthand.log
current_datetime.txt
errors.log
file_list.txt
line_count.txt

Ahora, canalicemos la salida de ls al comando wc -l, que cuenta el número de líneas que recibe.
```
ls | wc -l
```
```
6
```
El comando ls enumera los archivos, y su salida (cada nombre de archivo en una nueva línea) se alimenta como entrada a wc -l, que luego cuenta estas líneas, lo que te indica efectivamente cuántos archivos/directorios hay en la ubicación actual.
Intentemos otro caso de uso común: canalizar ls -l a less para una salida paginada. Esto es útil cuando un comando produce demasiada salida para caber en una sola pantalla.
```
ls -l /usr/bin | less
```
```
total 200000
-rwxr-xr-x 1 root root 12345 Jan XX HH:MM [filename]
... (press 'q' to quit less) ...
```
El comando ls -l /usr/bin enumera todos los archivos en /usr/bin con información detallada. Esta salida se envía luego a less, lo que te permite desplazarte por ella página por página. Presiona q para salir de less.

Filtrado de Salida con `grep`

El comando grep se usa a menudo en tuberías para filtrar líneas que coinciden con un patrón específico.

Enumeremos todos los procesos que se ejecutan en el sistema usando ps aux y luego filtremos los procesos relacionados con bash.
```
ps aux | grep bash
```
```
labex     1234  0.0  0.1  12345  6789 ?        Ss   HH:MM   0:00 /usr/bin/bash
labex     5678  0.0  0.0   9876  5432 pts/0    S+   HH:MM   0:00 grep bash
```
El comando ps aux enumera todos los procesos en ejecución. Su salida se canaliza a grep bash, que luego muestra solo las líneas que contienen la palabra "bash". Es posible que veas dos líneas: una para tu shell bash actual y otra para el propio comando grep.
Para excluir el comando grep de la salida, puedes usar grep -v (invertir coincidencia) o refinar tu patrón. Intentemos grep -v grep.
```
ps aux | grep bash | grep -v grep
```
```
labex     1234  0.0  0.1  12345  6789 ?        Ss   HH:MM   0:00 /usr/bin/bash
```
Ahora, solo se muestra el proceso bash real.

Uso de `sort` y `uniq`

sort se utiliza para ordenar líneas de texto, y uniq se utiliza para informar u omitir líneas repetidas. A menudo se usan juntos.

Creemos un archivo con algunas palabras repetidas y sin ordenar.
```
echo -e "apple\nbanana\napple\norange\nbanana" > fruits.txt
```

Visualiza el contenido de fruits.txt.

cat fruits.txt

apple
banana
apple
orange
banana

Ahora, ordenemos las líneas en fruits.txt.

cat fruits.txt | sort

apple
apple
banana
banana
orange

Para obtener solo las palabras únicas ordenadas, canaliza la salida de sort a uniq.
```
cat fruits.txt | sort | uniq
```
```
apple
banana
orange
```
Esta tubería primero ordena las líneas, luego uniq elimina las líneas adyacentes duplicadas.

El Comando `tee`

El comando tee es especial en las tuberías. Lee la entrada estándar, la escribe en la salida estándar y, simultáneamente, la escribe en uno o más archivos. Es como una unión en "T" en una tubería, lo que permite que los datos fluyan en dos direcciones.

Enumeremos los archivos y guardemos la salida en ls_output.txt mientras también la mostramos en la pantalla.

ls -l | tee ls_output.txt

total 24
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output.log
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output_shorthand.log
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM current_datetime.txt
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM errors.log
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM file_list.txt
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM fruits.txt
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM line_count.txt
-rw-r--r-- 1 labex labex 0 Jan XX HH:MM ls_output.txt

Verás la salida de ls -l en tu terminal, y se creará un archivo llamado ls_output.txt con el mismo contenido.

Verifica el contenido de ls_output.txt.

cat ls_output.txt

total 24
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output.log
... (same as above) ...

También puedes usar tee -a para anexar la salida a un archivo.
```
echo "--- End of list ---" | tee -a ls_output.txt
```
```
--- End of list ---
```
La línea "--- End of list ---" se imprime en la terminal y se anexa a ls_output.txt.

Verifica el ls_output.txt actualizado.

cat ls_output.txt

total 24
... (previous ls -l output) ...
--- End of list ---

Las tuberías son increíblemente versátiles y forman la columna vertebral de muchos scripts de shell y comandos de una sola línea potentes. Al combinar comandos simples, puedes realizar transformaciones de datos complejas de manera eficiente.

Editar Archivos de Texto con Fundamentos de Vim

En este paso, aprenderás las operaciones fundamentales de Vim, un editor de texto potente y ampliamente utilizado en el entorno Linux. Vim opera en diferentes modos, lo que puede ser un poco desafiante para los principiantes, pero dominar los conceptos básicos aumentará significativamente tu productividad.

Vim es un editor modal, lo que significa que tiene diferentes modos para diferentes tareas:

Modo Normal (Modo Comando): Este es el modo predeterminado cuando abres Vim. En este modo, las pulsaciones de teclas se interpretan como comandos (por ejemplo, mover el cursor, eliminar texto, copiar texto).
Modo Insertar: En este modo, todo lo que escribes se inserta en el archivo. Entras en el Modo Insertar desde el Modo Normal presionando i (insertar en el cursor), a (añadir después del cursor), o (abrir una nueva línea debajo), etc. Para volver al Modo Normal, presiona Esc.
Modo Visual: Este modo te permite seleccionar bloques de texto para operaciones como copiar, cortar o eliminar. Entras en el Modo Visual desde el Modo Normal presionando v (carácter por carácter), Shift+V (línea por línea) o Ctrl+V (bloque por bloque). Presiona Esc para volver al Modo Normal.
Modo Línea de Comandos (Modo Ex): Este modo se utiliza para ejecutar comandos que típicamente comienzan con dos puntos (:), como guardar (:w), salir (:q) o buscar (/). Entras en este modo desde el Modo Normal presionando :.

Apertura y Navegación Básica

Asegúrate de estar en tu directorio ~/project.
```
cd ~/project
```
```
[labex@host project]$
```
Abre un nuevo archivo llamado my_document.txt usando vim.
```
vim my_document.txt
```
Tu terminal ahora mostrará la interfaz de Vim. Estás en el Modo Normal.
En el Modo Normal, puedes navegar usando las teclas de flecha o h (izquierda), j (abajo), k (arriba), l (derecha). Dado que el archivo está vacío, aún no hay mucho que navegar.

Modo Insertar: Agregar Texto

Para empezar a escribir, necesitas entrar en el Modo Insertar. Presiona i (para insertar).
Deberías ver -- INSERT -- en la parte inferior izquierda de tu terminal, lo que indica que estás en el Modo Insertar.

Escribe las siguientes líneas:

This is the first line.
This is the second line.
This is the third line.

Para salir del Modo Insertar y volver al Modo Normal, presiona la tecla Esc.
El indicador -- INSERT -- debería desaparecer.

Guardar y Salir

En el Modo Normal, para guardar el archivo, escribe :w y presiona Enter.
```
:w
```
Deberías ver my_document.txt [New] 3L, 60B written en la parte inferior, confirmando el guardado.
Para salir de Vim, escribe :q y presiona Enter.
```
:q
```
Volverás al indicador de tu shell.

Verifica el contenido de my_document.txt usando cat.

cat my_document.txt

This is the first line.
This is the second line.
This is the third line.

Editar Archivos Existentes

Abre my_document.txt de nuevo.
```
vim my_document.txt
```
En el Modo Normal, mueve tu cursor al principio de la segunda línea (usando j o las teclas de flecha).
Presiona Shift+V para entrar en el Modo Visual de Línea. Toda la segunda línea se resaltará.
Presiona y para "yank" (copiar) la línea seleccionada.
Mueve tu cursor al final de la tercera línea (usando j o las teclas de flecha).
Presiona p para "put" (pegar) la línea yanked debajo de la línea actual.
La segunda línea ahora aparecerá de nuevo como la cuarta línea.
Ahora, eliminemos una línea. Mueve tu cursor a la cuarta línea (la que acabas de pegar).
Presiona dd (doble d) para eliminar toda la línea.
Para deshacer tu último cambio, presiona u. La línea eliminada reaparecerá.
Para guardar y salir en un solo comando, escribe :wq y presiona Enter.
```
:wq
```
Verifica el contenido de my_document.txt de nuevo.
```
cat my_document.txt
```
```
This is the first line.
This is the second line.
This is the third line.
This is the second line.
```
El archivo ahora debería tener cuatro líneas, con la segunda línea duplicada.

Descartar Cambios

A veces, haces cambios y decides que no quieres guardarlos.

Abre my_document.txt de nuevo.
```
vim my_document.txt
```
Entra en el Modo Insertar presionando i.
Agrega una nueva línea al final:
```
This line should not be saved.
```
Presiona Esc para volver al Modo Normal.
Intenta salir usando :q.
```
:q
```
Vim te advertirá: E37: No write since last change (add ! to override). Esto significa que tienes cambios sin guardar.
Para salir sin guardar, escribe :q! y presiona Enter.
```
:q!
```
Volverás al indicador del shell, y tus cambios se descartarán.

Verifica el contenido de my_document.txt.

cat my_document.txt

This is the first line.
This is the second line.
This is the third line.
This is the second line.

La última línea que agregaste no debería estar presente.

Ahora has cubierto las operaciones muy básicas en Vim: abrir archivos, insertar texto, navegar, guardar, salir y descartar cambios. Estas son las habilidades esenciales para comenzar con Vim.

Configurar y Usar Variables y Aliases de Shell

En este paso, aprenderás a configurar y usar variables y alias de shell. Estas son características poderosas que te permiten personalizar tu entorno de shell, almacenar datos y crear atajos para comandos de uso frecuente, mejorando significativamente tu eficiencia en la línea de comandos.

Variables de Shell

Las variables de shell son entidades con nombre que almacenan datos. Pueden almacenar números, texto u otros datos que pueden ser utilizados por el shell o por programas ejecutados dentro del shell.

Asegúrate de estar en tu directorio ~/project.
```
cd ~/project
```
```
[labex@host project]$
```
Establecer una Variable Local: Creemos una variable simple llamada MY_MESSAGE.
```
MY_MESSAGE="Hello, LabEx!"
```
Ten en cuenta que no hay espacios alrededor del signo =.
Acceder a una Variable: Para acceder al valor de una variable, antepones su nombre con un signo $.
```
echo $MY_MESSAGE
```
```
Hello, LabEx!
```
Expansión de Variables con Llaves: A veces, necesitas delimitar claramente el nombre de la variable, especialmente cuando está seguido de otros caracteres. Usa llaves {} para esto.
```
echo "The message is: ${MY_MESSAGE}."
```
```
The message is: Hello, LabEx!.
```
Si omites las llaves, el shell podría interpretar MY_MESSAGE. como el nombre de la variable, que no existe.
Listar Todas las Variables Establecidas: Puedes usar el comando set para listar todas las variables y funciones de shell actualmente establecidas. Esta salida puede ser muy larga, por lo que a menudo se canaliza a less.
```
set | less
```
```
BASH=/usr/bin/bash
BASHOPTS=checkwinsize:cmdhist:complete_fullquote:expand_aliases:extglob:extquote:force_fignore:histappend:interactive_comments:progcomp:promptvars:sourcepath
... (press 'q' to quit less) ...
```
Presiona q para salir de less.
Desestablecer una Variable: Para eliminar una variable, usa el comando unset.
```
unset MY_MESSAGE
```
Verifica que la variable ya no esté establecida.
```
echo $MY_MESSAGE
```
Deberías ver una línea vacía, lo que indica que la variable no está establecida.

Variables de Entorno

Las variables de entorno son un tipo especial de variable de shell que son heredadas por los procesos secundarios. Esto significa que cualquier programa o script lanzado desde tu shell actual tendrá acceso a estas variables. Se utilizan típicamente para configurar el entorno para las aplicaciones.

Establecer una Variable de Entorno: Usa el comando export para convertir una variable en una variable de entorno.
```
export EDITOR=vim
```
Esto establece la variable de entorno EDITOR, que muchos programas usan para determinar tu editor de texto preferido.
Listar Variables de Entorno: Usa el comando env para listar solo las variables de entorno.
```
env | grep EDITOR
```
```
EDITOR=vim
```
Desexportar una Variable: Puedes desexportar una variable sin desestablecerla usando export -n. Esto la convierte de nuevo en una variable local.
```
export -n EDITOR
```
Verifica que ya no sea una variable de entorno.
```
env | grep EDITOR
```
No deberías ver ninguna salida. Sin embargo, sigue siendo una variable local:
```
echo $EDITOR
```
```
vim
```
Para eliminarla por completo, usa unset.
```
unset EDITOR
```

Alias de Shell

Los alias son atajos para comandos. Te permiten definir un nuevo comando que se expande a un comando más largo o a una secuencia de comandos. Esto es muy útil para comandos de uso frecuente con muchas opciones.

Crear un Alias: Creemos un alias para ls -l para que sea más corto.
```
alias ll='ls -l'
```
Ten en cuenta las comillas simples alrededor del comando para asegurarte de que se trate como una sola cadena.

Usar un Alias: Ahora, simplemente puedes escribir ll en lugar de ls -l.

ll

total 24
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output.log
... (output of ls -l) ...

Listar Alias: Usa el comando alias sin ningún argumento para ver todos los alias definidos.
```
alias
```
```
alias ll='ls -l'
```
Podrías ver otros alias predeterminados dependiendo de la configuración de tu shell.
Crear un Alias Más Complejo: También puedes crear alias para comandos con argumentos o múltiples comandos.
```
alias myip='ip a | grep "inet " | grep -v "127.0.0.1" | awk "{print \$2}" | cut -d/ -f1'
```
Aquí, myip mostrará tu dirección IP principal. Ten en cuenta el \$2 para escapar el signo $ para que se pase a awk y no sea interpretado por el shell cuando se define el alias.
Prueba el alias myip.
```
myip
```
```
172.17.0.2
```
(Tu dirección IP puede variar)
Desestablecer un Alias: Para eliminar un alias, usa el comando unalias.
```
unalias ll
```

Verifica que el alias se haya eliminado.

alias

alias myip='ip a | grep "inet " | grep -v "127.0.0.1" | awk "{print \$2}" | cut -d/ -f1'

ll ya no debería estar en la lista.

Las variables y alias de shell son temporales y se perderán cuando cierres tu sesión de terminal. Para hacerlos permanentes, necesitas agregarlos a los archivos de configuración de tu shell (por ejemplo, ~/.bashrc o ~/.profile), lo cual se cubrirá en temas más avanzados.

Resumen

En este laboratorio, aprendiste habilidades fundamentales de la línea de comandos de Linux, esenciales para la gestión de archivos de texto y el entorno de shell. Comenzaste dominando la redirección de salida, específicamente usando > para sobrescribir archivos y >> para añadir contenido, lo que te permite capturar los resultados de los comandos para el registro o procesamiento posterior. También exploraste la redirección del error estándar (2>) y la combinación de la salida estándar y el error (&>) para gestionar eficazmente toda la salida de los comandos.

Además, adquiriste competencia en la construcción y comprensión de tuberías de comandos utilizando el operador |, lo que te permite encadenar comandos y procesar datos secuencialmente. Se te introdujo la edición de texto básica con Vim, cubriendo comandos esenciales para insertar, guardar y salir de archivos. Finalmente, aprendiste a configurar y usar variables de shell para almacenar datos y crear alias para simplificar los comandos de uso frecuente, mejorando tu eficiencia y personalización en la línea de comandos.

Editar Archivos de Texto en Red Hat Enterprise Linux