Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Encadenando comandos: operadores de control

9/21
Recursos

Aportes 464

Preguntas 30

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Nota importante:

  • Comandos separados por punto y coma “;” : Se ejecutan uno seguido del otro en el orden en que fueron puesto. Uno no se ejecuta hasta que el otro proceso aya terminado.
    –
  • Comandos separados por & : Se ejecutan todos al mismo tiempo, es decir de forma asíncrona.
    –
  • Comandos separados por && : Se ejecutan solo si el comando anterior se aya ejecutado exitosamente. Suponemos que A, B y C son comando:
    A && B && C
    El B solo se va ejecutar si el A se ejecuta exitosamente, y el C solo se va ejecutar si el B si ejecuta exitosamente. Si el B no se ejecuta exitosamenta el C no se ejecuta. Si el A no se ejecuta exitomante el B y el C no se ejecutan.
    –
  • Comandos separados por || : Solo se ejecuta uno. Sea cuantos comandos tienes separados por || solo ejecuta o toma en cuenta el primer que se ejecuta exitosamente (bajo la redundacia), y descarta automaticamente los demas. Cuando uno de los comandos se ejecuta exitosamente, descarta los demas comandos.

Acoplamiento de comandos con operadores bash

Es posible agregar cierto nivel de lógica, en cuanto a la ejecución de comandos. Para crear este sentido de programación, utilizamos los operadores de programación.

  • Secuencia de comandos linealmente ;
command1 ; command2 ; command3 ; command4 ;
  • Secuencia simultánea &
command1 & command2 & command3 & command4
  • Secuencia condicional &&
command1 && command2 && command3 && command4
  • Secuencia condicional ||
command1 || command2 || command3 || command4

Ejemplo de acoplamiento con git:

alias gt-deploy="git add . && git commit -m 'hot fix' && git push origin master"

Reto realizado aplicando los comadnos de cowsay, lolcat y pipe operators aprendidos en la clase pasada.

📌 Los operadores de control permiten ejecutar más de un comando, encadenando los mismos.

Notas 😄
Encadenando comandos: operadores de control.

  • Son símbolos reservados por la terminal que nos permiten ejecutar varios comandos seguidos, e incluso agregar condicionales ⛓️.
  • Síncronos: Se corre uno detrás de otro, en orden. Se hace esto con ; , por ejemplo ls; mkdir carpeta1; cal 👁️
  • Asíncrono: Por cada comando, se abre una nueva terminal, y cada comando se corre de manera paralela, esto es con &, por ejemplo ls & date & cal ⏲️
  • Condicionales: Podemos agregar lógica a como se corren los comandos:
    • AND: Si se cumple un comando, entonces se ejecuta el siguiente, se usa &&, un ejemplo es mkdir carpeta1 && cd carpeta1 && echo "Si se pudo" . Si no se puede ejecutar el primer comando, no se ejecuta el siguiente. 🚆
    • OR: Se ejecuta el primer comando que se pueda ejecutar, y se usa ||, por ejemplo cd carpeta || echo "No hay carpeta" 🤩

cd asdfasd || touch archivo.txt && echo “Archivo creado”

Tabla de verdad para las operaciones: AND (Multiplicación) y OR (Suma), Salida: [0 = Verdadero , 1 = Falso]:
![](

OPERADORES DE CONTROL
Símbolos reservados por la terminal que permiten ejecutar más de un comando o ejecutarlos. Es posible ejecutarlos de forma síncrona, asíncrona o con condicionales.

  • Forma síncrona: Se ejecutan uno detras de otro. Se colocan los comandos separados por un punto y coma ;.

  • Forma asíncrona: Ejecuta comandos de forma paralela.
    Se colocan los comandos separados por un ampersand &.

  • Forma condicional:

    • AND (&&) Solo se ejecuta si el comando anterior se ejecutó.

    • OR (||) Solo ejecutá el primer comando que sea ejecutable, los demas son ignorados.

¿Por que al no se ejecuta el comando echo después de usar || ?

Esto se debe a que al usar el || se ejecuta el siguiente comando solo si el comando que se esta ejecutando da falso o error.

cd DirectorioNoExiste || echo 'Se ejecuta el comando echo'

// -bash: cd: DirectorioNoExiste: No such file or directory
// Se ejecuta el comando echo

ls -lh || echo ''Se ejecuta el comando echo'

//-rw-r--r-- 1 lggm lggm   53 May 11 19:34  error.txt
//-rw-r--r-- 1 lggm lggm   15 May 11 19:46  input.txt
//-rw-r--r-- 1 lggm lggm   44 May 11 19:33  output.txt
//-rw-r--r-- 1 lggm lggm    0 May 11 16:38  text.txt]

Como se puede observar (lo pueden intentar en su terminal) en el segundo ejemplo el primer comando se ejecuta correctamente pero el segundo no se ejecuta.

Pueden ver la información en el siguiente link.
https://baulderasec.wordpress.com/

Reto:

cd ghsghsgfhsfgh || touch archivo.txt && echo “Archivo creado”

Para ejecutar comandos de manera síncrona, puedes usar dos métodos:

comando-1; comando-2; comando-3

Salida:
Comando-1
comando-2
comando-3
Opción 2

comando-1 && comando-2 && comando-3

Salida:
comando-1
comando-2
comando-3

La diferencia es que si unas la sintaxis “;” y un comando tiene una salida de STANDAR ERROR, los siguientes comandos siguen ejecutandose, en cambio con “&&” si falla un comando, los siguientes ya no se ejecutaran!

investigue el significado de asincrono y sincrono y el profesor usa el significado al reves, cuidado ahi,me confundi la primera vez

Reto:

cd Desktop && touch newfile && echo 'created'

Reto Completado:

Aqui les doy un ejemplo para que lo vean y lo practiquen:

➜  ~ git:(master) ✗ mkdir reto && cd reto && echo "Palabra que uses"         
Palabra que uses
➜  reto git:(master) ✗ 

#NuncaParesDeAprender

Para que nos regrese el echo “Archivo creado” debemos dejarlo con doble && ya que el comando or solo nos regresa un comando exitoso.

Es decir, si ponemos touch archivo.txt || echo “Archivo creado” solo va a tomar el primer comando que sea exitoso. Por lo tanto propongo dos opciones:
1.) Uno de los primeros comandos debe ser exitoso para que se corra el echo “Archivo creado”.

cd falseDirectory || touch archivo.txt && echo “Archivo creado”

2.) Si queremos asegurarnos que el segundo comando (touch archivo.txt) sea creado para que se ejecute el último (lo cual es lo que tiene más sentido), podemos ejecutar:

cd falseDirectory; touch archivo.txt && echo “Archivo creado”

Operadores de control

  • Son simbolors reservados por la terminal que nos permiten encadenar comandos.
  • Cadena Sincrona (😉 → ejecutan los comandos de manera lineal, uno después del otro, si algun comando falla la cadena no se interrumpe
  • Cadena Asincrona (&) → ejecutan los comandos de manera simultánea, abriendo un nuevo proceso por cada comando
  • Condicional and (&&) → Interrumpe la cadena si hay algún error
  • Condicional or (||) → Interrumpe la cadena si hay una ejecucion exitosa

 cd directorio || touch archivo.txt && echo "Archivo creado"   

Hola Profe Enrique, cuando ejecuto los comandos;
ls & date & cal
Debo de dar enter para que regrese el prompt.

¿Por qué no se ejecutó echo "Archivo creado"?
El operador || lo que hace es ejecutar el comando a su derecha solo si el comando anterior no se ejecuta exitosamente.
En el ejemplo, el profesor ejecutó
cd ajknmsdklnmasdn || touch archivo.txt || echo "Archivo creado"
¿Qué sucede?

  1. El primer comando se ejecuta y luego devuelve un error.
  2. El segundo también se ejecuta ya que el anterior devolvió un error, pero se ejecuta exitosamente, sin errores.
  3. El tercero no se ejecuta porque el anterior se ejecutó exitosamente y la condición para que se ejecute un comando que le sigue al operador || es que el anterior se ejecute sin éxito.

En el reto se podría añadir un && antes del echo para que ejecute el echo sin problemas👇👇

cd ajskjs || touch archivo.txt && echo "Archivo creado"
  • En cd (Change directory) ejecuta (No such file or directory)
    ya que no existe el directorio.

  • Doble pipe (or) || ejecutará la creación
    de archivo.txt ya que no depende de que el anterior sea verdadero.

  • Doble ampersand (y) && se ejecuta ya que la linea anterior es verdadera, nos muestra “Archivo creado”.

Los operadores de control
Son los símbolos reservados por la terminal que permiten ejecutar más de un comando; es decir, se puede ejecutar de forma:
síncrona (no paralela) la ejecución de los comandos es uno detrás de otro y se colocan los comandos separados por un punto y coma.
y asíncrona (paralela) la ejecución de los comandos es en forma paralela y se colocan los comandos por un (ampersand) &.
FORMAS CONDICIONALES:

  • AND (&&) se ejecutará sólo si el comando ANTERIOR se ejecutó.

  • OR (II) se ejecutará sólo si el primer comando sea ejecutable, los demás son ignorados.

Probablemente me volé un poco intentando resolver el reto, inmediatamente vino a mi mente un operador if en la ejecución de comandos.
leí esta referencia y no se ve tan descabellado.

https://www.ehu.eus/ehusfera/hpc/2013/10/24/comando-if-en-linux/#:~:text=El condicional if es un,dependiendo de la condición especificada.&text=Aquí si no se cumple,se ejecutan los comandos-3 .

cd directorio inexistente || touch file.txt && echo 'Archivo creado exitosamente' 

Para el reto se me ocurrieron estas dos propuestas.

#FORMA 1
cd hshjsjh || touch archivo.txt | echo "archivo creado"

# FORMA 2
cd asdasd || touch archivo2.txt && echo "ar
chivo creado"

Hola amigos😊, cumpliendo con el reto que dejó el teacher Enrique Devars al final de la clase corrí el siguiente comando:

mkdir "Documents" && echo "Directorio creado exitosamente" | lolcat && cd Documents && touch archivo.txt && echo "Archivo creado exitosamente" | lolcat

Y el resultado es…

Para mí la mejores forma de crear comandos de procesos de alta demanda además dejar corriendo en los servidores así se te caiga la conexión remota a ellos es usando el comando

screen

Luego si se te cae la conexión puedes volver a entrar usando

screen -xrd 

Operadores de control

Condicionales que nos permite ejecutar comandos en funcion de una condicion

; //Al separar comandos con punto y coma, se ejecutan de forma sincronica en el orden en que se colocaron, por ejemplo.
ls ; echo "Termino el ls"; cal

& //Al separar comandos con &, se ejecutan de forma asincronica, abriendo un subproceso por cada comando. Esto nos retornara el proccess id en que fueron ejecutados.
ls & echo "Imprimiendo en otra shell" & cal

&& //Al separar comandos con &&, se ejecutaran de forma sincronica, siempre y cuando el comando anterior se haya ejecutado exitosamente.
ls && echo "Termino el ls" && cal

|| //Al separar comandos con &&, se ejecutara el primer comando que logre terminar de manera exitosa.
cd sadasdasd || touch archivo.txt || echo "Hola!" //creara el archivo touch

Reto:
cd Directorio inexistente || touch test.txt && echo “Archivo creado exitosamente”

Explicación: Esta es una manera de cumplir el reto ya que al no cumplirse el primer comando, es decir el cd, hace que pase al segundo comando y ejecute el comando touch y luego el comando echo. Lo que cambia con lo que se hizo en la clase es que en vez de separar el touch y el echo con un ||, estos se separan con && para que al momento en que se ejecute el touch , también se ejecute el echo. Esto se debe a que si se separaran con ||, solo se ejecuta el touch porque es el primer comando que funciona.

Reto

Operadores de control:

“;” – Síncrono
"&"-- Asíncrono (Ejecución en diferentes hilos)
"&&" – Operador And
"||" – Operador Or

lo hice con mis mp4 ya que son menos xD

find ./ -name "*.mp4" > mis_documentos_de_mp4.txt && cowsay "el proceso de guardado a terminado" | lolcat
cat mis_documentos_de_mp4.txt | lolcat && cowsay "el proceso de lectura a finalizado" | lolcat

CHALLENGE:
Se logro, no me llevo al directory errado, tampoco me creo el archivo pero si me mostro el mensaje:

Codigo del ejercicio

<mkdir ejercicio && cd ejercicio && touch hola.txt  && echo "El archivo se creo correctamente > 

6:03 podría ir esto también:

cd jadfjñ || touch archivo2.txt && echo "Archivo creado"
El operador OR («||») no ejecuta todos lo comandos de la sentencia, solo hasta que uno se ejecute correctamente, como en los lenguajes de programación. Es por eso que en el ejemplo como se ejecutó el «echo» luego de crear el archivo.

Reto

cd carpeta || touch archivo && echo "archivo creado"

Reto de clase

Reto de la clase:

cd asasasa | | touch archivo.txt && cowsay "alohomora" | lolcat

dejo un video para apoyarnos mas https://www.youtube.com/watch?v=gqo1TPqZRH4

Esta clase, aunque me dejó con una duda (la cual dejé en la sección de preguntas) la verdad que fue bien interesante. Mi respuesta a la actividad del profesor es la siguiente:

Para aquellos que no sepan o no hayan hecho la actividad aún, también se puede hacer la misma operación utilizando el “&&” en lugar del “;”. La diferencia consiste en que “;” ejecutará el echo una vez se haya creado el directorio, mientras que si usamos “&&” se ejecutará el echo da igual lo que hagas. Al menos, según tengo entendido. Alguien corrijame si estoy mal por favor.

Ok, también estaba experimentando con la terminal y poniendo y quitando cosas, descubrí esta combinación que posiblemente nunca usarán pero me hizo gracia y me hizo entender un poco más los pipe operators y los nuevos operadores que recién vimos:

No sé, me pareció divertida esa paradoja jajajaj

mkdir test_folder; cd test_folder; touch file.txt; echo “se creo el archivo exitosamente”

cd adfgasdf || (touch hola.txt && echo “El archivo se creo exitosamente”)

mi solución

Reto de la clase:

cd NotExiste || touch index.html && echo "Archivo creado"

Output:

cd: no such file or directory: NotExiste
Archivo creado

Se creo el archivo y nos muestra el mensaje

cd abcder || touch archivo_creado.txt && echo "Archivo creado"

Nos muestra:

-bash: cd: abcder: No such file or directory
Archivo creado
(base) [email protected]:~/miDirectorio$ ls
DirectorioPrueba    directorioprueba.txt  holi             output.txt  vaca.txt
archivo_creado.txt  error.txt             misarchivos.txt  test

Muy bien Explicada esta claseQ Me encantaron los ejemplos!

Respecto a porque no se ejecutó echo “Archivo creado”, es porque en realidad los operadores al parecer evalúan la condición anterior para ejecutar la siguiente instrucción, && evalúa que se true y || evalúa que sea false,
cd ajknmsdklnmasdn = false || entonces ejecuto touch archivo.txt
touch archivo.txt = true (se ejecutó bien) entonces no ejecuto la siguiente instrucción porque el resultado anterior debió ser false

Mi respuesta al ejercicio:

cd Terminal\ y\ Línea\ de\ Comandos/Wildcards/ && mkdir  "Cowsay🐮" && touch comando1.txt comando2.txt && ls -lha | lolcat && cowsay -f dragon-and-cow [Todo bien]

Una pequeña solución para que muestre el mensaje:
cd ajshajsja || touch file.txt && echo “File created”

Mi aporte:

$ mkdir test && cd test || touch file.txt ; echo "Archivo Creado"
Archivo Creado

Para que aparezca el creado exitosamente podemos encadenarlo con un and

$ cd asdsafkjaskfas || touch archivo.txt && echo "archivo creado exitosamente"

Entendido

mkdir prueba && cd prueba && touch prueba.txt && echo "Se crea archivo" && ls -lha

ok

<code> cd test && touch ArchivoPrueba && echo " Archivo creado exitosamente"
<code>

cd skdmskdmksm || touch archivo.txt && echo "Archivo generado exitosamente"
cd jnesdk/ || touch archivoPrueba.txt && echo "Archivo creado"

El término asíncrono se refiere al concepto de que más de una cosa ocurre al mismo tiempo, o múltiples cosas relacionadas ocurren sin esperar a que la previa se haya completado. Por otro lado, el término sincrónico se refiere a la comunicación en tiempo real donde cada lado recibe, procesa o responde, mensajes instantáneamente o lo más cerca posible a instantáneamente.

Reto completado

cd direc || touch archivo.txt && echo "Archivo creado"                                                                    
cd: no such file or directory: direc
Archivo creado

Resumen:

Los operadores de control son simbolos reservados por la terminal que nos permiten ejecutar más de un comando.

Secuencia de comandos lineal ;
Su sintaxis es:

<Comando 1>; <Comando 2>; ... ; <Comando n>; ​

Y ejecuta un comando despues de otro hasta llegar al comando n-ésimo

Secuencia de comandos simultanea &
Su sintaxis es:

<Comando 1> & <Comando 2> & ... & <Comando n>; ​

Y ejecuta los n comandos de forma paralela (al mismo tiempo) en distintas terminales

Secuencia de comandos condicional &&
Su sintaxis es:

<Comando 1> && <Comando 2> && ... && <Comando n>; ​

Y ejecuta el k-ésimo comando si el comando k - 1 se ejecuta correctamente:

k - 1 correcto ⇒ k se ejecuta

Secuencia de comandos condicional ||
Su sintaxis es:

<Comando 1> || <Comando 2> || ... || <Comando n>; ​

Y ejecuta el k-ésimo comando si el comando k - 1 no se ejecuta correctamente:

k - 1 incorrecto ⇒ k se ejecuta

Concluyo:
&: Ejecución Paralela
; : Ejecución Secuencial

Ejecución Condicional
&&: Una secuencia de comandos separados por **&& **termina con el primer comando que falle.

||: Una secuencia de comandos separados por || termina con el primer comando que no falle

Por lo anterior un
if A then B else C puede ser similar a
A && B || C

Un tip adicional que encontré:
COMANDO &: Ejecuta el COMANDO en background.

¡¡¡¡ Advertencia: No se puede detener con Ctrl + C (por si es un proceso que demore ejemplo un tree de todo el disco)!!!

[email protected]:~/test$ ls
archivo.txt  archivo1.txt
[email protected]:~/test$ cd kksnkcn || rm archivo1.txt && echo "Archivo eliminado"
-bash: cd: kksnkcn: No such file or directory
Archivo eliminado
[email protected]:~/test$ ls
archivo.txt

Uso un AND al final para que independientemente de si se pueda mover a un directorio o no, cree el archivo y muestre el mensaje

cd fjsajdkjskjfkjf || touch test.txt && echo "Archivo creado exitosamente"

Cumplí el reto:
Pero en lugar usar echo usé cowsay

cd Documents && touch test.txt && cowsay "archivo creado exitosamente"

Reto:

Yo lo que hice fue poner $cd jdjfd || touch archivo.txt && echo “Archivo creado”

Le puse en doble & debido a que con el | estamos indicando que si ya sucedió la acción anterior, no es necesario seguir a la siguiente. Esto lo pude concluir luego de hacer las siguientes pruebas:

  • $touch archivo2.txt || echo "archivo creado"
    Lo único que hizo es crear el archivo

  • $touch archivo3.txt && echo "Archivo creado"
    Crea el archivo e imprime el mensaje

Encadenado de comando:
-ls; mkdir holi; date >> fecha.txt ; mv fecha.txt holi
-cd holi/&& pwd && echo “Te haz movido de directorio”
-cd ejemplo || touch borrar.txt &&echo “archivo creado”

En mi caso he razonado que quiero guardar el output de un error en mi carpeta errores pero si dicha carpeta por alguna razón no existe que lo haga en la carpeta backup.

cd errores || cd backup || ls Pictures 2> error.txt && echo "Guardo exitosamente"
 cd wer && mkdir dirA && echo "Se creo archivo en el directorio dirA" || cd holi && mkdir dirA && touch fileA.txt && echo "Se creo archivo en el directorio holi"
-bash: cd: wer: No such file or directory
Se creo archivo en el directorio holi

Hice un proceso con el operador && para que todas las sentencias se ejecuten exitosamente antes de poder seguir con la cadena de comandos.

En la primera parte si se coloca primero el mkdir y luego el ls, se crea la carpeta primero y luego ahí si la muestra…

mkdir holi; ls; cal; date

Hola! Yo lo que hice no fue usar el or de manera triple. Solo lo usé en las dos primeras condiciones, donde, o nos mueve el directorio o crea el archivo. Luego que alguna de las dos sentencias se cumpla, muestre en pantalla con && el mensaje.

En el reto:

El operador de control realiza los comandos de manera paralela en segundo plano, muestra el error, pero no muestra la cadena de caracteres del echo.


Una manera para mostrar todo es con el siguiente comando:

cd jaljfadjf || touch archivo.txt & echo "Archivo creado"

Apuntes:

Los operadores de control permiten ejecutar más de un comando, encadenando los mismos.

Comandos separados por ;

  • Con el punto y coma se pueden separar diferentes comandos para que se ejecuten de manera síncrona es decir uno detrás de otro.

Comandos separados por &

  • Con este comando se pueden separar diferentes funciones para que se ejecuten de manera asíncrona es decir todos al tiempo cada una genere un hilo distinto.

comandos separados por &&

  • Comando (AND) ejecuta cada comando solo si el anterior ya se ejecuto exitosamente.

Comandos separados por ||

  • Comando (OR) ejecuta cada comando hasta que uno sea exitoso y descarta los comandos que se encuentren después del que se ejecutó exitosamente.

Reto solucionado, el comando sería:

cd wawawawa || touch archivo2.txt && echo “Archivo creado”

OPERADORES DE CONTROL
Símbolos reservados por la terminal que nos permiten ejecutar más de un comando o concatenarlos.

Operadores de control
Son símbolos que están reservados por la terminal y permiten ejecutar más de un comando

De manera sincrónica

  • ls; mkdir holi; cal
  • Lista, luego crea un directorio “holi”, luego muestra un calendario

De manera asíncrona
Va a utilizar distintos hilos para ejecutar de manera paralela

  • ls & date & cal

De manera condicional

  • mkdir test && cd test
  • Se ejecuta el segundo solo si el primero se ejecuta de manera correcta
  • || es “OR”, hay que tener muy en cuenta la lógica

RETO:

cd asdasd || touch archivo.txt && echo "Archivo creado"

Para el reto, solo habría que cambiar el or por el &&

cd carpeta_no_existe || touch archivo.txt && echo "archivo creado"

Salida:

cd: no such file or directory: carpeta_no_existe
archivo creado

Mi solución al reto (encontré dos maneras de hacerlo)

cd aksjaksj || touch tmp && echo "archivo creado"

cd aksjaksj || touch tmp & echo "archivo creado"

Personalmente me gusta más el output de la primera.

Notas:

Con el comando or ( || ) entendí que en una secuencia de comando se seguira ejecutando cada comando hasta que alguno de ellos no de error, es ahí donde la secuencia de comando se rompe y el resto de comando ya no se ejecutan porque ya se encontró uno que dio success.

cd asddasd || touch archivo.tct || echo "hola"

El cd da error, sigue al siguiente comando, el touch no da error, entoncces ahí se rompe la secuencia y el echo ya no se alcanza a ejecutar.

cd imagenes || touch archivo.txt && cowsay "¡archivo creado exitosamente!" | lolcat

![]()

Se cumple el reto propuesto:

La solución al reto es cambiar los dos últimos pipe ( || ) de OR por dos ampersand ( && ) de AND.

Súper útiles los operadores de control 😄😄😄

Mi soulción para el reto:

$ cd ffifniaefnaiosd || touch archivo.txt; echo "Archivo creado"
cd gshgshbhs ll touch prueba && echo "archive creado"

cd puygujgfddc || touch archivo.txt && echo “Archivo creado”

🤓🤓🤓

Para quienes utilizan wsl, pueden dirigirse al usuario de windows utilizando la operación: cd mnt/c/Users/USUARIO/Desktop

$ cd lknfvkenv || mkdir hola && echo hola

Mostrando el mensaje de archivo creado:

Esta tabla me ayudo a comprender mejor en que casos usar la forma síncrona y asíncrona

😃

❤️