Encadenar comandos — ; && || y comillas

Encadenar comandos — ; && ||

Puedes encadenar varios comandos en una sola línea.

; los ejecuta en orden sin importar el resultado del comando anterior.

&& ejecuta el siguiente comando solo cuando el anterior tuvo éxito, y || ejecuta el siguiente solo cuando el anterior falló.

echo step1 ; echo step2          # ejecutar ambos en orden
mkdir build && echo created      # created si tiene éxito
ls missing.txt || echo not-found # not-found si falla

① Ejecuta echo first; echo second y confirma que ; imprime las dos salidas en orden.

② Ejecuta echo ok && echo done y confirma que && continúa con el siguiente cuando el anterior tiene éxito.

③ Ejecuta cat nofile.txt || echo missing y confirma que || ejecuta el lado derecho solo cuando el anterior falla. (Ejecútalo correctamente y aparecerá una explicación.)

Combinar && y || — ramificar en línea

Puedes escribir && y || uno tras otro en una línea.

cmd && echo ok || echo ng ejecuta echo ok si cmd tiene éxito, y echo ng si falla.

Es la forma habitual cuando quieres escribir en un solo lugar tanto la acción de éxito como la de fallo.

mkdir out && echo created || echo failed   # created en caso de éxito
ls nofile.txt && echo found || echo none   # none en caso de fallo

① Ejecuta ls . && echo found || echo none y confirma que aparece found porque ls . tiene éxito.

② Ejecuta cat nofile.txt && echo found || echo none y confirma que aparece none porque cat falla.

③ Compara los dos resultados y observa cómo la parte tras && y la parte tras || se intercambian según el éxito o el fallo.

En qué se diferencian las comillas — ' y "

Hay dos tipos de comillas para envolver una cadena.

Las comillas simples '...' tratan el contenido como caracteres literales y no reemplazan $VAR.

Las comillas dobles "..." expanden $VAR y $(...) dentro a sus valores.

También se usan para pasar como una sola unidad una cadena que contiene espacios.

place=server
echo 'path is $place'   # literal: path is $place
echo "path is $place"   # expandido: path is server

① Fija una variable con name=Linux.

② Ejecuta echo '$name' y confirma que las comillas simples imprimen $name literalmente.

③ Ejecuta echo "$name" y confirma que las comillas dobles lo expanden al valor Linux.

Incrustar variables y salida de comandos en comillas dobles

Dentro de comillas dobles puedes construir una sola cadena a partir de variables y sustitución de comandos a la vez.

$(...) se reemplaza por la salida del comando.

Por ejemplo, $(pwd) se reemplaza por la ruta de tu ubicación actual antes de mostrarse.

Envolver en comillas dobles es también la forma básica de pasar como un único argumento un valor que contiene espacios.

① Fija una variable con user=guest.

② Ejecuta echo "hello $user" && echo done y confirma que la variable se expande dentro de las comillas dobles y done sigue en caso de éxito.

③ Ejecuta echo "now: $(pwd)" y confirma que el $(...) dentro de las comillas dobles se reemplaza por la ruta actual.

Qué son realmente el éxito y el fallo — estado de salida y echo $?

El 'éxito o fallo' que vigilan && y || lo determina un número llamado estado de salida que un comando deja al terminar.

0 significa éxito y cualquier cosa distinta de 0 significa fallo.

El estado de salida del comando anterior va a la variable especial $?, que puedes consultar con echo $?.

ls .            # un comando que tiene éxito
echo $?         # estado de salida anterior -> 0
cat nofile.txt  # un comando que falla
echo $?         # estado de salida anterior -> distinto de cero (p. ej. 1)

① Ejecuta ls . y luego echo $?, y confirma que muestra 0 porque tuvo éxito.

② Ejecuta cat nofile.txt y luego echo $?, y confirma que muestra un valor distinto de cero (como 1) porque falló.

③ Date cuenta de que el número de echo $? es en lo que se basan && y || para decidir.