Encadenando comandos: operadores de control

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”

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.

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

¿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

¿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.

Reto:

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

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”

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

Reto

Operadores de control:

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

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”.

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.

Les dejo este lugar:
https://www.tecmint.com/chaining-operators-in-linux-with-practical-examples/

Reto

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

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

cd jadfjñ || touch archivo2.txt && echo "Archivo creado"

Codigo del ejercicio

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

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

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

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.

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

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 .

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.

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

Resumen en Notion
https://n9.cl/njmgv

Excelente clase, muy buen tema, quiero regalar un aporte muy bueno que encontré, ya que al intentar ejecutar “cal” me salia este error:

ls; mkdir holi; cal
Command ‘cal’ not found, but can be installed with:
sudo apt install ncal

Para lograr solucionarlo, ejecuté la actualización del caché de mi terminal así:

sudo apt update

Y de esta forma se actualizó el caché de la terminal y ya permitio ejecutar el cal

Y para el reto propuesto por el profe lo logré ejecutando la linea de comando así:

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

Y como resultado se obtuvo:

-bash: cd: errordedirectorio: No such file or directory
Archivo creado

Muchas gracias, espero mi aporte sea de utilidad… saludos

Muy bien Explicada esta claseQ Me encantaron los ejemplos!

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 

cd test || touch archivo.txt && cowsay -f milk.cow "Archivo creado exitosamente!" | lolcat

Lo intente también usando lolcat jijiji 😁

Que divertido que los operadores de and (&&) y de or (||) es igual que en algunos lenguajes de programación como JavaScript.

Mi ejercicio de esta clase

Reto:

cd fjgkgjh || touch hojd.txt && echo "Archivo Creado"

En el minuto 5:50 para un mejor ejemplo me gustaría añadir la instrucción

eduardo@eduardo-ubuntu:~/test$ cd accesorios || touch archivo.txt && echo "Archivo creado"

Mi directorio test (mismo que el del ejemplo de la clase) no contiene nada, por lo que la primera instrucción no se ejecutará, pero sí la siguiente touch archivo.txt y también me imprimirá el mensaje Archivo creado
.

Mensaje que el archivo ha sido creado

Mimo mensaje, pero con la vaca

~/testeo$ cd hhhhhh || touch archibo.txt && echo "creadod"
bash: cd: hhhhhh: No existe el archivo o el directorio
creadod

Desafío:
Yo lo pude ejecutar correctamente de dos formas:

mkdir prueba1; cd prueba1; touch archivo.txt; echo "El archivo se creó"

, y

 mkdir prueba3 && cd prueba3 && touch archivo.txt && echo "El archivo se creó"

Con el operador & no funciona, xq cuando llega al comando cd folder, como se ejecutan en paralelo, aún en ese momento no existe, entonces se corta el flujo de ejecución.
Con el operador ||, tampoco funciona, xq como lo que hace es buscar el valor verdadero, cuando lo encuentra sale del flujo de ejecución, entonces en este caso 1° se crea el directorio, y como ya eso es una condición verdadera, luego deja de ejecutar el resto de la cadena de comandos.

Creo que si funcionó 👍

A mi me salió así:

cd hsjhajshj || touch archivo.jar && echo "Archivo creado"

Clase 9 – Encadenando comandos: operadores de control

¿Qué son los operadores de control?

• Son símbolos reservados por la terminal que nos permiten ejecutar más de un comando o encadenarlo.

¿De qué maneras podemos correr los operadores de control?

• Síncrona.
• Asíncrona
• Condicional.

¿Con que símbolo podemos correr el operador de control que corre los comandos de manera síncrona?

• ;

¿Para qué nos sirve el operador de control que corre los comandos de manera síncrona?

• Para ejecutar varios comandos al mismo tiempo.

¿Cuál es la sintaxis que necesitamos emplear para usar el operador de control síncrono?

• Comando; comando; comando

¿Para qué nos sirve el comando cal?

• Para imprimir en consola un calendario del mes y día en el que nos encontramos en ese momento.

¿Con que símbolo podemos correr el operador de control que corre los comandos de manera asíncrona?

• &

¿Para qué nos sirve el operador de control que corre los comandos de manera asíncrona?

• Este nos permite ejecutar varios comandos al mismo tiempo, pero con la diferencia de que cada comando se ejecutara en un hilo diferente.

¿Cuál es la sintaxis que necesitamos emplear para usar el operador de control asíncrono?

• Comando & comando & comando

¿Para qué nos sirve el comando date?

• Para imprimir la fecha y hora del momento en que ejecutamos el comando.

¿Con que símbolo podemos correr el operador de control que corre los comandos de manera condicional?

• &&

¿Para qué nos sirve el operador de control que corre los comandos de manera condicional?

• Este nos permite ejecutar varios comandos al mismo tiempo, pero solo si el comando anterior se ejecuta correctamente.

¿Cuál es la sintaxis que necesitamos emplear para usar el operador de control condicional?

• Comando && comando && comando

¿Cuál es el símbolo del operador de control condicional or?

• ||.

¿Para qué nos sirve el operador de control condicional or?

• Nos permite ejecutar varios comandos al mismo tiempo sin importarle si el comando anterior se ejecuto correctamente. Este proceso lo hará hasta que ejecute todos los comandos que hayamos escrito en la terminal con dicho operador.

¿Para qué son útiles los operadores de control?

• Para ejecutar múltiples comandos al mismo tiempo.
• Si queremos que un comando se ejecute solo si una condición se cumple.

¿En qué caso de uso en desarrollo web podemos usar los operadores de control?

• Cuando queramos usar Webpack.

¡Las clases hasta ahora muy bien explicadas, muchas gracias!

mkdir archivoscow && mv /home/ubuntu/archivoscow /home/ubuntu/downloads && cowsay -f bunny “¡Exito!” | lolcat

El reto

 cd asdfasd ||  touch archivo.txt && echo "Archivo Creado"

Reto cumplido

antoniotc_~$ mkdir reto && cd reto && touch reto.txt && cowsay "retocumplido" >> reto.txt && cat reto.txt

Comparto el reto, he notado que muchos tienen experiencia programando, yo soy nuevo, estudiar en Platzi es mi primer contacto.

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) abidantriguero@HPi7:~/miDirectorio$ ls
DirectorioPrueba    directorioprueba.txt  holi             output.txt  vaca.txt
archivo_creado.txt  error.txt             misarchivos.txt  test

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)!!!

chrisguerrero@LAPTOP-A73AGLP5:~/test$ ls
archivo.txt  archivo1.txt
chrisguerrero@LAPTOP-A73AGLP5:~/test$ cd kksnkcn || rm archivo1.txt && echo "Archivo eliminado"
-bash: cd: kksnkcn: No such file or directory
Archivo eliminado
chrisguerrero@LAPTOP-A73AGLP5:~/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"