# data[].attributes.body
Tabla de Contenidos

¿Qué es Bash?

¿Por qué usar Bash Script?

Comandos Bash

Comandos Bash básicos para tu primer script bash

1. Comentarios

2. Variables

3. Comando echo

4. Funciones

5. Bucles

6. Declaraciones condicionales

7. Lectura y escritura de archivos

4 funciones sencillas para probar en tu primer bash script

Comienza con una función echo sencilla

Utiliza pocos parámetros

Crea directorios y cambia rutas

Combinar bucles y condicionales

Cómo ejecutar un script Bash

Uso del comando bash

Uso del comando ./

Ejecutar el script desde un directorio diferente

Bash script – Preguntas frecuentes

¿Es fácil aprender Bash?

¿Es Bash más fácil que Python?

¿Para qué sirve Bash?

# data[].attributes.attachment_link.readable_text
Bash es una herramienta popular de scripts disponible en Unix. Es la abreviación de Bourne Again Shell. Es una herramienta poderosa para todo usuario de Linux o administrador de sistemas. ¡Entonces empecemos a aprender sobre Bash script en Linux!

Unix tiene 2 categorías principales de shells.

Bourne shell se clasifica además como:

Korn shell (ksh)

Bourne shell (sh)

POSIX shell (sh)

Bourne Again shell (bash)

C shell también se clasifica además como:

Los Bash scripts son un componente muy potente y útil para el desarrollo. Puede reducir tareas repetitivas y cortas a una sola línea. Se pueden consolidar muchos comandos largos en un solo código ejecutable.

Bash está disponible en casi todas las versiones de Linux y no requiere de instalación adicional. La lista de shells disponibles se puede verificar escribiendo el siguiente comando:

cat /etc/shells

El resultado será algo similar a esto:

/bin/bash
/bin/sh
/bin/tcsh
/bin/csh

¿Por qué usar los scripts Bash?

Las funciones Bash pueden:

Eliminar tareas repetitivas

Ahorrar tiempo

Proporciona una secuencia de actividades bien estructurada, modular y formateada

Con scripts, podemos proporcionar valores dinámicos a comandos usando argumentos de línea de comando

Puede simplificar comandos complejos en una sola unidad en ejecución

Una vez creado, se puede ejecutar cualquier cantidad de veces por cualquier persona. Construye una vez y ejecuta muchas veces.

Los flujos lógicos se pueden construir utilizando funciones bash

Las funciones Bash se pueden ejecutar al inicio del servidor o agregando un cron job programado

Los comandos pueden ser depurados

Puede tener comandos de shell interactivos

Bash es definitivamente una gran herramienta para facilitar tu trabajo y mejorar tus proyectos. Los usos potenciales son ilimitados, así que hoy solo te enseñaremos los conceptos básicos. ¡Prepárate para escribir tu primer script de bash en Linux!

Comenzando con Bash

Antes de comenzar, tendrás que acceder a tu servidor VPS mediante SSH. Si tienes dificultades para hacerlo, consulta este útil tutorial.

Para comenzar con las opciones básicas de los comandos, puedes consultar las páginas del manual de bash escribiendo:

man bash

A continuación, tendremos que crear un archivo .sh. Para esto usaremos VIM Editor. Para crear un archivo, usa un comando como este:

vim sampleFunction.sh

Ahora seremos llevados al archivo .sh, donde podemos editarlo.

Esto generará un resultado con los comandos Bash y su uso. Todo script de bash en Linux debe comenzar con la siguiente línea:

#!/bin/bash

El siguiente comando muestra la ruta del script bash.

which bash

Esto mostrará el siguiente resultado:

/bin/bash

La sintaxis común de bash es:

function functionName {
first command
second command
}

Esto también se puede escribir como:

functionName (){
first command
second command
}

En una sola línea, esto se puede escribir así:

functionName() { first command; second command; }

Un ejemplo de dicha función se muestra a continuación, donde primero creamos un directorio y luego cambiamos la ruta para que apunte al nuevo directorio:

sampleFunction () {
mkdir -p $1
cd $1
}

$1 representa el argumento de entrada de la línea de comando. Bash puede crear entradas dinámicas dentro del comando. Para verificar esta función, puedes ejecutar:

sampleFunction myDir

Aquí myDir es un nombre de directorio válido. Si revisas el directorio de trabajo actual utilizando el comando pwd, puedes ver que actualmente estás dentro del myDir recién creado.

Igualmente, cualquier comando de uso común se puede agregar como una función bash.

Recuerda que cuando hayas terminado de usar el editor VIM para editar el archivo .sh, puedes guardar y salir presionando ESC para ingresar al modo de comando, y luego escribir :wq para guardar y salir.

Funciones básicas de Bash

Uno de los ejemplos básicos de la función bash en Linux se muestra a continuación:

#!/bin/bash
testfunction(){
   echo "My first function"
}
testfunction

Si guardas este script en testFunction.sh y lo ejecutas como ./testFunction.sh, podrás ver el resultado como:

My first function

Echo imprime la salida en la consola. Si intercambias la posición de la definición de la función con la llamada, esto generará un error. El siguiente fragmento dará un error.

#!/bin/bash
testfunction
testfunction(){
   echo "My first function"
}

Entonces, primero tendrás que definir la función y luego invocarla.

Las funciones bash pueden aceptar cualquier número de parámetros. El siguiente ejemplo acepta dos parámetros:

#!/bin/bash
testfunction(){
   echo $1
   echo $2
}

testfunction "Hello" "World"

También puedes usar entradas interactivas y realizar funciones bash. Uno de estos ejemplos es el que se muestra a continuación:

#!/bin/bash
addition(){
   sum=$(($1+$2))
   return $sum
}
read -p "Enter a number: " int1
read -p "Enter a number: " int2
add $int1 $int2
echo "The result is : " $?

En el ejemplo anterior, el valor de addition se asigna en una suma variable, y esto es lo que entrega la función. La entrada interactiva se toma usando read para ambos números. Finalmente, el resultado se imprime con $? que almacena el valor $sum generado por la función.

Las funciones bash siempre devuelven un único valor.

Puedes dejar comentarios dentro del archivo agregando el símbolo # para dejar notas útiles.

Los scripts bash soportan:

A continuación se muestra un breve ejemplo del bucle While.

#!/bin/bash
isvalid=true
count=1
while [ $isvalid ]
do
echo $count
if [ $count -eq 5 ];
then
break
fi
((count++))
done

El ejemplo anterior usa las declaraciones while y if. Esto ejecuta el bucle while 5 veces antes de salir después de verificar la declaración condicional if.

El resultado de esto será:

1
2
3
4
5

El bucle for se puede usar para incrementar o disminuir los contadores. Un ejemplo del bucle for es el que se muestra a continuación:

#!/bin/bash
for (( count=10; count>0; count-- ))
do
echo -n "$count "
done

La salida de este bucle será:

10 9 8 7 6 5 4 3 2 1

En Bash && representa el elemento lógico AND, mientras que || representa a OR.

Con las declaraciones If, también podemos definir Else if. Veamos un ejemplo:

#!/bin/bash
echo "Enter a valid number"
read n
if [ $n -eq 101 ];
then
echo "This is first number"
elif [ $n -eq 510 ];
then
echo " This is second number "
elif [ $n -eq 999 ];
then
echo " This is third number "
else
echo "No numbers over here"
fi

El mismo ejemplo anterior también se puede escribir utilizando la declaración case como se muestra a continuación:

#!/bin/bash
echo " Enter a valid number"
read n
case $n in
101)
Echo " This is the first number " ;;
510)
echo " This is the second number " ;;
999)
echo " This is the third number " ;;
*)
echo " No numbers over here " ;;
esac

En las declaraciones case ;; representa una ruptura de case.

Conclusión

Así terminamos nuestra revisión general de las funciones básicas de bash script. Bash es una herramienta realmente poderosa y se puede aprender fácilmente. Desde aquí puedes profundizar en la creación de más ejemplos y divertirte explorando más usos potenciales de los scripts bash. ¡Buena suerte!

# data[].attributes.attachment_link.description
Bash script es genial para acelerar tu trabajo, eliminando tareas repetitivas y mejorando la calidad del trabajo para los usuarios Unix. ¡Aprende Bash hoy!

# data[].attributes.body
Gestión de usuarios

Gestión de ficheros

Gestión de permisos

Gestión de procesos

Gestión de sistemas, búsquedas, etc.

# data[].attributes.attachment_link.readable_text
Todas las versiones compatibles de Windows y Windows Server tienen un conjunto de comandos de consola Win32 integrados. En este conjunto de documentación se describen los comandos de Windows que puede usar para automatizar tareas mediante scripts o herramientas de scripting.

Shells de línea de comandos

Windows tiene dos shells de línea de comandos: el shell de comandos y PowerShell. Cada shell es un programa de software que proporciona comunicación directa entre el usuario y el sistema operativo o la aplicación, proporcionando un entorno para automatizar las operaciones de TI.

El Shell de comandos fue el primer shell integrado en Windows para automatizar tareas rutinarias, como la administración de cuentas de usuario o las copias de seguridad nocturnas, con archivos por lotes (.bat). Con Windows Script Host, puede ejecutar scripts más sofisticados en el Shell de comandos. Para obtener más información, consulte cscript o wscript. Puede realizar operaciones de forma más eficaz mediante scripts que mediante la interfaz de usuario. Los scripts aceptan todos los comandos disponibles en la línea de comandos.

PowerShell se diseñó para ampliar las funcionalidades del Shell de comandos para ejecutar comandos de PowerShell denominados cmdlets. Los cmdlets son similares a los comandos de Windows, pero proporcionan un lenguaje de scripting más extensible. Puede ejecutar tanto los comandos de Windows como los cmdlets de PowerShell en PowerShell, pero el Shell de comandos solo puede ejecutar comandos de Windows y no cmdlets de PowerShell.

Para la automatización de Windows más sólida y actualizada, se recomienda usar PowerShell en lugar de comandos de Windows o Windows Script Host para automatización de Windows.

Puede encontrar una referencia de códigos de salida y error para los comandos de Windows en los artículos Códigos de error del sistema de depuración que pueden resultar útiles para comprender los errores generados. Los comandos de Windows también incluyen operadores de redireccionamiento de comandos. Para obtener más información sobre su uso, consulte Uso de operadores de redireccionamiento de comandos.

Nota:

También puede descargar e instalar PowerShell Core, la versión de código abierto de PowerShell.

Finalización automática del archivo del Shell de comandos y el nombre del directorio

Puede configurar el Shell de comandos para completar automáticamente los nombres de archivo y directorio en un equipo o sesión de usuario cuando se presiona un carácter de control especificado. De forma predeterminada, este carácter de control está configurado para que sea la tecla de tabulador para los nombres de archivo y directorio, aunque pueden ser diferentes. Para cambiar este carácter de control, ejecute regedit.exe y vaya a cualquiera de las siguientes claves y entradas del Registro, en función de si desea cambiar el valor solo para el usuario actual o para todos los usuarios del equipo.

Precaución

La edición incorrecta del Registro puede dañar gravemente el sistema. Antes de realizar los siguientes cambios en el Registro, debe hacer una copia de seguridad de los datos de valor guardados en el equipo.

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Command Processor\CompletionChar HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Command Processor\PathCompletionChar

Establezca estos valores en los del carácter de control que desea usar. Consulte códigos de clave virtual para obtener una lista completa. Para deshabilitar un carácter de terminación determinado en el Registro, use el valor para espacio (0×20) porque no es un carácter de control válido. El tipo de valor de esta entrada de Registro es REG_DWORD y se puede especificar también mediante un valor hexadecimal o decimal.

También puede habilitar o deshabilitar la finalización del nombre de archivo y directorio por instancia de un Shell de comandos mediante la ejecución de cmd.exe con el parámetro y el conmutador /F:ON o /F:OFF. Si la finalización del nombre está habilitada con el conmutador y el parámetro /F:ON, los dos caracteres de control usados son Ctrl-D para la finalización del nombre de directorio y Ctrl-F para la finalización del nombre de archivo. La configuración especificada por el usuario tiene prioridad sobre la configuración del equipo y las opciones de línea de comandos tienen prioridad sobre la configuración del registro.

Referencia A-Z de la línea de comandos

Para buscar información sobre un comando específico, en el siguiente menú A-Z, seleccione la letra con la que empieza el comando y, a continuación, seleccione el nombre del comando.

A

B

C

D

E

F

G

H

I

J

K

L

M

N

O

P

Q

R

S

T

U

V

W

X

# data[].attributes.body
Todas los comandos u órdenes admitidas después del símbolo del sistema pueden introducirse también en un fichero por lotes. Además, existen una serie de órdenes diseñadas específicamente para estos ficheros:

Orden   Breve descripción

Echo      Controla el eco de las órdenes y visualiza mensajes.

Rem      Introduce comentarios.

Pause   Detiene temporalmente el desarrollo de un programa

Goto     Desvía incondicionalmente el desarrollo de un programa

If             Desvía condicionalmente el desarrollo de un programa.

Choice  Permite elegir entre unas opciones establecidas.

For         Repite una misma orden en un conjunto de ficheros.

Call         Llama a un fichero por lotes desde otro.

Shift      Desplaza el valor de los parámetros

Set /p Permite establecer el valor de una variable para una línea de entrada escrita por el usuario.

La siguiente tabla muestra aquellos símbolos empleados exclusivamente en los ficheros por lotes

Símbolo              Significado

:etiqueta            Nombre de una etiqueta

%número           Parámetro del fichero por lotes.

%variable%       Variable del entorno.

%%variable       Variable de la orden For.

# data[].attributes.body
Comandos_de_Windows ................................... 2

Sistemas Operativos .......................................... 16

Redireccionamiento y tuberias-opt ............... 17

comandos bat-opt ............................................. 19

Comando IF v.castellano ................................. 22

cadenas.en.batch .............................................. 28

comando.for.extendido ................................... 32

Funciones en Windows ................................... 35

# data[].attributes.attachment_link.readable_text
Tutorial y manual de creación y edición de scripts en Windows usando CMD. Comandos para crear bat y batch ejecutables con un archivo de texto. Guía paso por paso, ejemplos prácticos, reglas y trucos.

Sencillo manual en el que se explica de forma detallada los principios elementales, para crear las aplicaciones ejecutables conocidas popularmente como archivos BATCH o BAT.
Introducción al mundo de la programación batch, uso de los comandos más comunes de la consola de CMD, para crear aplicaciones que se pueden usar en Windows para infinidad de tareas prácticas.
Como crear un archivo batch paso a paso.
Ejemplos prácticos para copiar y pegar el código, consejos y trucos.
Precauciones a tener en cuenta.
Herramientas para descargar que facilitan la creación de estas aplicaciones y probarlas correctamente.

¿Que son los archivos batch?

Los archivos batch, también conocidos popularmente como archivos BAT, son aplicaciones ejecutables.
Son simplemente pequeños archivo de texto plano, que contienen códigos o instrucciones escritos en el lenguaje de MSDOS, estos códigos son lo que se conoce como comandos.
Estos archivos son guardados con la extensión de archivo .bat o .cmd. Al ejecutarse alguno de ellos (dar dos clics), Windows automáticamente inicia la consola o interprete de comandos de MSDOS y ejecuta las instrucciones o códigos que contienen en grupo, de forma secuencial.
La consola de CMD, también conocida como Símbolo del sistema, intérprete de comandos o consola de MSDOS, durante muchos años fue el medio de comunicación o intérprete entre la máquina y el usuario.
En los años 80 para utilizar una PC era necesario ser informático, lo que limitaba el uso de estos equipos a un grupo reducido de personas. Al surgir el primer sistema operativo Windows, este incluye una interface entre el usuario y la computadora, que permite que un clic u otra acción del usuario, se conviertan en una secuencia de comandos.
Con el paso del tiempo lógicamente, disminuye el uso de la consola de CMD pero se mantiene completamente vigente el empleo de los comandos en las aplicaciones batch.
Cualquier usuario, aun con pocos conocimientos, puede crear tus propios archivos batch para facilitar la ejecución de varias tareas en Windows.
El propósito de este artículo es estimular y facilitar el uso de estas aplicaciones.

Uso y empleo de los archivos batch en Windows

El principal uso de estos archivos en la actualidad, es la de realizar tareas sencillas pero tediosas y repetitivas, de acuerdo a la labor en que usemos cada uno nuestra PC y así evitar la instalación de software de terceros, que a la larga harán la misma función, que un archivo batch creado con un simple archivo de texto.
Los archivos batch son ideales para varias funciones, por ejemplo hacer copias, extraer y listar información, eliminar virus, planificar tareas, ejecutar limpiezas en el sistema, hacer respaldos de datos e información, automatizar descargas de internet, en fin infinidad de aplicaciones.

Un ejemplo, la manera más eficiente actualmente de descargar archivos de internet es mediante WGET, (se explica su uso en otro artículo), para eso se utiliza un batch que tiene solo el siguiente código:
wget -c -S -r dirección url.
Uso de Wget para descargar archivos de internet

¿Cómo crear un archivo batch en Windows?

Para crear un archivo batch solo es necesario un editor de texto plano, que puede ser el Notepad++ (recomendado) o hasta el simple Bloc de notas de Windows.
Notepad++ lo puedes descargar gratis de sourceforge.net, resalta con colores diferentes la sintaxis, lo que permite percatarse fácilmente de cualquier error en el código empleado.
No es necesario conocimientos de informática, solo comprender simples reglas que verás más abajo y familiarizarse con algunos de los comandos más empleados.
La estructura de un archivo batch es sencilla:

* Una primera línea: @ECHO OFF (no es imprescindible para que funcione)
* Las instrucciones que pueden constar de una simple línea o de varias, todas se irán ejecutando en su orden.
* Al final generalmente se emplea EXIT o EOF que cierra la ventana de la consola.

Al hacer tus primeros batch siempre emplea PAUSE después de las instrucciones, su uso como la palabra indica, pausa y permite ver mensajes de error, en caso de que exista alguno, de otra forma la consola se cerrará y será imposible conocer lo que lo ha causado.

Trucos para crear archivos batch rápidamente

Script para crear plantilla de archivos batch

Pequeña aplicación que facilita crear un archivo batch en blanco, solo con el encabezado @ECHO OFF, dentro de un archivo de texto con la extensión .CMD.
Es de extrema utilidad si necesitamos crear regularmente estos archivos.
Para crear el script o aplicación, haz lo siguiente:
1- Crea un nuevo archivo de texto y pega en su interior las siguientes instrucciones:

Set FSO = CreateObject("Scripting.FileSystemObject") Set lf = FSO.OpenTextFile("batch.cmd", 8, True) msg = "@echo off" lf.WriteLine(msg) lf.Close Set lf=Nothing Set FSO=Nothing

2- Guárdalo, pero con la extensión de archivo .VBS.
Es todo.
Al ejecutarlo se crea en el mismo directorio, un nuevo archivo llamado "batch.cmd".
Solo necesitas comenzar a agregarle código.
Lee más información: Qué son los archivos VBS, usos prácticos y como crearlos

Comando para crear plantilla de archivos batch

Crea de forma rápida una sencilla plantilla de un archivo batch, mediante un comando.
Copia y pegar el siguiente código en la herramienta Ejecutar (WIN + R) y presiona la tecla Enter:

cmd.exe /c echo @echo off>%userprofile%\Desktop\sample.cmd

Se creará una pequeña plantilla en tu escritorio llamada "sample.cmd"
Para utilizarla da un clic derecho encima y en el menú selecciona "Editar", para abrirla con el Bloc de Notas.
Introduce el comando a ejecutar y guarda los cambios mediante CRL + G.
Por ejemplo introduce:

echo Hola esto es un batch pause>nul

Sin cerrar el Bloc de notas, prueba el batch.

Crear un archivo batch, método paso por paso

* Comenzaremos creando un Simple y clásico "Hola Mundo", escribiendo en tu plantilla el siguiente código:

@echo off
echo Hola Mundo
pause
exit

* Guardamos el archivo como nombre.cmd y lo ejecutamos, el archivo tomará el icono de una rueda dentada y nos aparecerá una pantalla negra que dirá "Hola Mundo", luego una línea abajo mostrará "Presione una tecla para continuar"
La explicación:

echo

Muestra un texto en pantalla, que es el texto que viene después, en este caso es: Hola Mundo.

pause

Como bien se lee, pausa la ejecución del código. Además muestra el texto: "Presione una tecla para continuar".

exit

Cierra la ventana de comandos.

Funciones de algunos comandos

CD o CHDIR:
Sirve para cambiar de Directorio o mostrar el nombre del actual. Para usarlo, usa CD o CHDIR seguido de la ubicación del directorio al cual nos moveremos.Por ejemplo:

CD C:\

CHDIR C:\

Los ejemplos anteriores hacen exactamente lo mismo, cambian al Disco C
COPY:
Copia uno o más archivos a otro destino.
Su sintaxis es la siguiente:

COPY "Dirección del archivo" "Nueva dirección"

Por ejemplo:

Copy C:\archivo.txt C:\archivo2.txt

Aquí copiaríamos un archivo del Disco C llamado archivo.txt como archivo2.txt, para acortar un poco podríamos usar:

CD  Copy archivo.txt archivo2.txt

Donde primero cambiamos de directorio al Disco C con CD C:\ y luego al copiar no tenemos que especificar que el archivo está en el Disco C, ya que ya nos encontramos en él.
DEL:
Elimina uno o más archivos, su sintaxis es:

DEL ARCHIVO

También se puede usar con los siguientes parámetros:

DEL /F /Q archivo

Donde /Q logra que la consola no pida la confirmación de eliminar el archivo y /F permite eliminar archivos que poseen el atributo de solo lectura
MOVE:
Sirve para mover un archivo. Su sintaxis es:

Move Dirección Archivo Nueva Dirección

CLS:
Sirve para limpiar el contenido de la pantalla.
Por ejemplo:

@echo off
ECHO Hola, Cuando pulses una tecla se borrará el contenido y cambiará por otro.
PAUSE
CLS
ECHO ¿Ves?
pause
exit

Si quisiéramos averiguar más sobre las funciones, o conocer algunas nuevas por nuestra propia cuenta podemos escribir en el CMD el nombre del comando seguido de /? y aparecerá toda la información necesaria.

Ejemplos prácticos de archivos batch

Cargar una página de internet

El comando START permite iniciar una aplicación.
Al usarlo con la dirección URL de una página web de internet, inicia el navegador web predeterminado y carga la página solicitada.
Por ejemplo:

@echo off
START https://norfipc.com

Se pueden incluir varias líneas con direcciones diferentes, incluso usar un navegador determinado, especificando el nombre de su ejecutable justo antes de la dirección.

Copiar, mover y eliminar archivos

Con el siguiente código podemos crear un archivo batch que copie un archivo, luego lo mueva a otro directorio, borre el original y vuelva a copiar el copiado.
En la carpeta donde crearás el archivo batch, crea un archivo de texto llamado copiame.txt. En él, escribe lo que quieras. Este será el archivo que copiaremos.
Código:

@echo off
echo Hola, Copiaremos un archivo
pause
COPY copiame.txt copiado.txt
MOVE copiado.txt C:\copiado.txt
DEL copiame.txt
CD C:\
COPY copiado.txt copiado2.txt
EXIT

Guárdalo en la carpeta como prueba.cmd, y ejecútalo. Después, si vamos al Disco C, veremos que hay dos nuevos archivos de texto, uno llamado: copiado.txt y otro: copiado2.txt.
También si vamos a la carpeta del batch, comprobaremos que no está el archivo de texto original, copiame.txt.

Crear nuevos archivos

Usando archivos batch podemos crear otros archivos diferentes, para eso podemos usar algo como lo siguiente:

echo TEXTO DE PRIMERA LINEA > nombre.extensión echo TEXTO SEGUNDA LINEA >> nombre.extensión echo TEXTO SIGUIENTE LINEA >> nombre.extensión

Al escribir ECHO seguido de un texto y el signo > creamos un archivo con el nombre que siga.
Si ocupamos un ECHO seguido de un texto y el doble signo >> se escribirá en la siguiente linea vacía del archivo que prosiga.
Hagamos la prueba:

echo Creando un Archivo de texto > nuevo.txt
echo Esta es la Segunda linea >> nuevo.txt
echo Y esta es la Siguiente >> nuevo.txt
echo Esto esta genial >> nuevo.txt

Aj ejecutarlo, la pantalla negra se abrirá y cerrará, pero en la carpeta en la que está nuestro batch, se habrá creado un nuevo archivo nuevo.txt que si lo abrimos, dentro tendrá escrito lo que especificamos anteriormente.
Además se puede jugar con los caracteres. Un ejemplo, donde se cambiaron los colores, los caracteres y el pause:

El código empleado es el siguiente:

@echo off
color 30
echo ==================================
echo = =
echo = Personalizado =
echo = =
echo ==================================
echo.
echo.
echo Para salir presiona una tecla.
pause>nul
exit

Vale mencionar que ECHO, seguido de un punto, sirve para saltarse una línea.

Usar variables en los archivos batch

Las variables son muy importantes y prácticas en los archivos batch, aprende como crearlas.

SET NOMBREVARIABLE = VALOR

Para escribir una variable creada anteriormente, debemos escribir su nombre entre los signos %%
Por ejemplo:

@echo off
set Nombre = Norfi Carrodeguas
echo %Nombre%
pause

En el caso anterior primero creamos la variable llamada Nombre y le dimos un valor, posteriormente la escribimos.
También podemos crear variables dinámicas y dar la opción que el usuario la defina, se hace de la siguiente forma:

@echo off
SET /P Nombre = Escriba su Nombre:

En este caso al ejecutar el archivo batch, solo se mostrará en la consola el mensaje: "Escriba su Nombre:"
Al usuario ingresar los caracteres que decida y oprimir la tecla Enter, el batch ejecutará la acción contenida en el código, usando como valor de la variable el texto que el usuario ingresó.

Realizar operaciones matemáticas con archivos batch

Mediante archivos batch también podemos realizar operaciones como multiplicar, sumar, dividir, etc. usando el modificador /A, por ejemplo de la siguiente forma hacemos la operación: 2 + 43 = 45.

SET numero1 = 2
SET numero2 = 43
SET /A suma = %numero1% + %numero2%
echo %suma%
pause
exit

Usando el modificador /A, lo que quede a la derecha del signo igual (=). se consideran expresiones numéricas a evaluar. Su pueden usar los siguientes caracteres como operadores matemáticos:

Consejos y tips para la creación y uso de los archivos batch

➔ Para comentar, es decir escribir comentarios dentro del código de tus batch, antepone REM al comienzo de la línea, esta no será interpretada por la consola.
También es posible utilizar dos puntos dobles "::"(sin las comillas).
➔ Cuando al ejecutar un batch, este se cierre y te quedas con la duda de lo que sucedió, agrega PAUSE antes del final del código, lo que te permitirá saber si hay algún error, también puedes insertar varios en diferentes líneas, e ir ejecutándolo por partes.
Al igual que PAUSE puedes utilizar PAUSE>NUL, entonces no se mostrará el famoso mensaje "Presione una tecla para continuar...."

Como usar redireccionadores en los archivos batch

➔ Puedes combinar varios comandos en un archivo batch intercalando el signo |, esto indica que se ejecutará el segundo comando utilizando el resultado del primero, un ejemplo es:

ipconfig|FINDSTR /C:"Máscara de subred"

Esta línea abre IPCONFIG y a continuación busca la cadena Mascara de subred y si existe muestra el resultado.
➔ Si empleas dos barras el segundo comando se ejecutará solo si el primero falla, por ejemplo:

COPY D:\NOEXISTE C:\ || ECHO No se pudo copiar el archivo

➔ Para redireccionar un primer comando a un segundo, intercala un amspersand entre ambos, pero si usas dos caracteres estas condicionando la ejecución del segundo al éxito del primero, es como insertar la frase "Si es así, entonces", por ejemplo:

START calc.exe && ECHO La calculadora se inicio con éxito

➔ Para direccionar el resultado de un comando a un archivo de texto utiliza:

Comando > archivo.txt

➔ Si deseas seguir agregando datos al mismo archivo creado utilizando otro comando utiliza:

Comando2 >> archivo.txt

➔ Para pasar el contenido de un archivo de texto a un comando usa:

Comando < archivo.txt

➔ Para mostrar un archivo de texto en pantalla usa:

TYPE texto.txt

Algunos ejemplos, se explican solos:

DIR C:\ >Lista_de_C.txt & DIR D:\ >Lista_de_D.txt FIND /i "Alberto" < texto.txt > resultado.txt MEM /C >> MemLog.txt DATE /T >> MemLog.txt TYPE texto.txt > texto.html

➔ Donde quiera que haya una cadena que tenga espacios tienes que utilizar las comillas, en las rutas a los archivos también es recomendado utilizarlas.
➔ Cuando la ruta a un archivo determinado es muy complicada, lo más fácil es dar clic en las Propiedades del archivo y copiar la ruta que allí aparece.
También para eso puedes instalar una clave del registro que agrega al menú contextual del mouse la facilidad de que al hacer clic en un archivo del explorador y seleccionar "Copiar Ruta" puedes pegarla en tu batch.
◄ Agregar en el menú contextual la opción de Copiar la ruta del archivo o carpeta
➔ Para crear un mensaje en un batch, es decir una ventana que muestra una indicación o comentario al usuario, escribe en el batch lo siguiente:

MSG * Este Es Mi Mensaje

➔ Para que se muestre en el batch la fecha y la hora utiliza las variables DATE y TIME de la siguiente forma:

@echo off
echo Fecha:%date%
echo Hora:%time%

➔ Para detener un proceso o programa determinado averigua su nombre o identidad exacta en el Administrador de tares y utiliza:

taskkill /im /f programaespecifico.exe taskkill /f /im wmplayer.exe taskkill /f /im explorer.exe

En el caso del explorer se utiliza mucho para poder solucionar los bloqueos del explorador de Windows, al cerrarse el explorador para iniciarlo abre el administrador de tareas, selecciona Nueva tarea y escribe:

Start explorer.exe

➔ Para ejecutar los comandos no siempre es necesario abrir la consola, puedes ejecutarlos introduciéndolos directamente en el cuadro que se encuentra en Inicio, solo anteponiendo CMD o CMD.EXE de las siguientes dos formas:
Introduce CMD /K comando+ opción y oprime Enter.
Se ejecutará el comando con la opción y dejara abierta la ventana de cmd.
Introduce CMD /C comando+ opción y oprime Enter.
Se ejecutará el comando con la opción y cerrará la ventana de cmd al terminar.
Dos sencillos ejemplos:

CMD /K IPCONFIG /ALL CMD /C START http://google.com

Ojala que este artículo le haya interesado y le haya servido de alguna ayuda y estímulo para introducirse en este mundo tan interesante y práctico.
En las páginas de este sitio encontrarás bastante contenido relacionado, así como muchos archivos para descargar.

Páginas relacionadas

# data[].attributes.attachment_link.title
Crear archivos bat y batch útiles en Windows, ejemplos

# data[].attributes.attachment_link.description
Tutorial y manual de creación y edición de scripts en Windows usando CMD. Comandos para crear bat y batch ejecutables con un archivo de texto

# data[].attributes.attachment_link.title
Tutorial Curso en BATCH 1# : Inicio + Comandos Iniciales

# data[].attributes.body
Gestión de usuarios

Gestión de ficheros

Gestión de permisos

Gestión de procesos

Gestión de sistemas, búsquedas, etc.

# data[].attributes.attachment_link.readable_text
En el momento de escribir esto, Linux tiene una cuota de mercado mundial del 2,68% en ordenadores de escritorio, pero más del 90% de toda la infraestructura en la nube y los servicios de alojamiento se ejecutan en este sistema operativo. Solo por esta razón, es crucial estar familiarizado con los comandos populares de Linux.

Según la encuesta de StackOverflow de 2020, Linux es el sistema operativo más utilizado por los desarrolladores profesionales, con un impresionante 55,9% de la cuota de mercado. No es solo una coincidencia. Linux es gratuito y de código abierto, tiene mejor seguridad que sus competidores y cuenta con una potente línea de comandos que hace que los desarrolladores y usuarios avanzados sean más eficaces. También tiene acceso a un potente gestor de paquetes y a un montón de herramientas de desarrollo como DevKinsta.

Tanto si eres un administrador de sistemas con experiencia como si eres un recién llegado a Linux, puedes aprovechar esta guía.

¡Comencemos!

¿Qué es un comando de Linux?

Un comando Linux es un programa o utilidad que se ejecuta en la línea de comandos. Una línea de comandos es una interfaz que acepta líneas de texto y las procesa en forma de instrucciones para tu ordenador.

Cualquier interfaz gráfica de usuario (GUI) no es más que una abstracción de los programas de línea de comandos. Por ejemplo, cuando cierras una ventana haciendo clic en la "X", hay un comando que se ejecuta detrás de esa acción.

Un flag es una forma de pasar opciones al comando que se ejecuta. La mayoría de los comandos de Linux tienen una página de ayuda que podemos llamar con la flag -h. La mayoría de las veces, las flag son opcionales.

Un argument o parámetro es la input que damos a un comando para que pueda ejecutarse correctamente. En la mayoría de los casos, el argumento es una ruta de archivo, pero puede ser cualquier cosa que se escriba en el terminal.

Puedes invocar flags utilizando guiones (-) y guiones dobles (--), mientras que la ejecución de los argumentos depende del orden en que los pase a la función.

Los comandos de Linux más utilizados

Antes de pasar a los comandos más utilizados de Linux, asegúrate de abrir un terminal. En la mayoría de las distribuciones de Linux, usarás Ctrl + Alt + T para hacerlo. Si esto no funciona, busca en tu panel de aplicaciones "terminal".

Ahora vamos a sumergirnos en los 40 comandos de Linux más utilizados. Muchos de ellos tienen múltiples opciones que puedes encadenar, así que asegúrate de revisar el manual de los comandos.

1. Comando ls

ls es probablemente el primer comando que todo usuario de Linux teclea en su terminal. Te permite listar el contenido del directorio que quieras (el directorio actual por defecto), incluyendo archivos y otros directorios anidados.

Tiene muchas opciones, así que puede ser bueno obtener algo de ayuda usando el flag --help. Este flag devuelve todas los flag que puedes utilizar con ls.

Por ejemplo, para colorear la salida del comando ls, puede utilizar lo siguiente:

ls --color=auto

Ahora la salida del comando ls está coloreada, y se puede apreciar la diferencia entre un directorio y un archivo.

Pero escribir ls con el flag de color sería ineficiente; por eso usamos el comando alias.

El comando alias te permite definir alias temporales en tu sesión de shell. Al crear un alias, se indica al shell que sustituya una palabra por una serie de comandos.

Por ejemplo, para que ls tenga color sin tener que teclear el flag --color cada vez, se usaría:

alias ls="ls --color=auto"

Como puedes ver, el comando alias toma un par de parámetros clave-valor: alias NAME="VALUE". Ten en cuenta que el valor debe estar entre comillas.

Si quieres listar todos los alias que tienes en tu sesión de shell, puedes ejecutar el comando alias sin argumento.

3. Comand unalias

Como su nombre indica, el comando unalias tiene como objetivo eliminar un alias de los ya definidos. Para eliminar el alias ls anterior, puedes utilizar:

4. Comando pwd

El comando pwd significa "imprimir el directorio de trabajo" y muestra la ruta absoluta del directorio en el que se encuentra. Por ejemplo, si tu nombre de usuario es "john" y está en tu directorio Documentos, tu ruta absoluta sería /home/john/Documents.

Para utilizarlo, basta con escribir pwd en el terminal:

pwd # My result: /home/kinsta/Documents/linux-commands

5. Comando cd

El comando cd es muy popular, junto con ls. Se refiere a " cambiar de d irectorio" y, como su nombre indica, te cambia al directorio al que intentas acceder.

Por ejemplo, si estás dentro del directorio Documentos y tratas de acceder a una de sus subcarpetas llamada Vídeos, puedes entrar en ella escribiendo:

También puedes proporcionar la ruta absoluta de la carpeta:

cd /home/kinsta/Documents/Videos

Hay algunos trucos con el comando cd que pueden ahorrarte mucho tiempo al jugar con él:

1. Ir a la carpeta de inicio

2. Sube un nivel

3. Volver al directorio anterior

6. Comando cp

Es tan fácil copiar archivos y carpetas directamente en el terminal de Linux que a veces puede sustituir a los gestores de archivos convencionales.

Para utilizar el comando cp, basta con escribirlo junto con los archivos de origen y destino:

cp file_to_copy.txt new_file.txt

También puede copiar directorios enteros utilizando el flag recursiva:

cp -r dir_to_copy/ new_copy_dir/

Recuerda que en Linux, las carpetas terminan con una barra diagonal (/).

7. Comando rm

Ahora que sabes cómo copiar archivos, te será útil saber cómo eliminarlos.

Puedes utilizar el comando rm para eliminar archivos y directorios. Sin embargo, ten cuidado al usarlo, porque es muy difícil (aunque no imposible) recuperar los archivos eliminados de esta manera.

Para borrar un archivo normal, escribirías:

rm file_to_copy.txt

Si deseas eliminar un directorio vacío, puedes utilizar el flag recursiva (-r):

rm -r dir_to_remove/

Por otro lado, para eliminar un directorio con contenido en tu interior, es necesario utilizar el flag force (-f) y recursive:

rm -rf dir_with_content_to_remove/

Info

Ten cuidado con esto: ¡puedes borrar todo un día de trabajo si usas mal estas dos flags!

8. Comando mv

El comando mv se utiliza para mover (o renombrar) archivos y directorios en el sistema de archivos.

Para utilizar este comando, debes escribir tu nombre con los archivos de origen y destino:

mv source_file destination_folder/ mv command_list.txt commands/

Para utilizar las rutas absolutas, utilizarías:

mv /home/kinsta/BestMoviesOfAllTime ./

...donde ./ es el directorio en el que te encuentras.

También puedes usar mv para renombrar archivos mientras los mantienes en el mismo directorio:

mv old_file.txt new_named_file.txt

9. Comando mkdir

Para crear carpetas en el shell, se utiliza el comando mkdir. Solo tienes que especificar el nombre de la nueva carpeta, asegurarte de que no existe y ya está.

Por ejemplo, para crear un directorio para guardar todas tus imágenes, solo tienes que escribir:

mkdir images/

Para crear subdirectorios con un simple comando, utiliza el flag padre (-p):

mkdir -p movies/2004/

10. Comando man

Otro comando esencial de Linux es man. Muestra la página del manual de cualquier otro comando (siempre que tenga uno).

Para ver la página del manual del comando mkdir, escribe:

Incluso puedes consultar la página del manual man:

11. Comando touch

El comando touch permite actualizar los tiempos de acceso y modificación de los archivos especificados.

Por ejemplo, tengo un archivo antiguo que fue modificado por última vez el 12 de abril:

Para cambiar su fecha de modificación a la hora actual, necesitamos utilizar el flag -m:

touch -m old_file

Ahora la fecha coincide con la de hoy (que en el momento de escribir este artículo era el 8 de agosto).

No obstante, la mayoría de las veces no se utilizará touch para modificar las fechas de los archivos, sino para crear nuevos archivos vacíos:

touch new_file_name

12. Comando chmod

El comando chmod te permite cambiar el modo de un archivo (permisos) rápidamente. Tienes un montón de opciones disponibles con él.

Los permisos básicos que puede tener un archivo son:

Uno de los casos más comunes de uso de chmod es hacer que un archivo sea ejecutable por el usuario. Para ello, escriba chmod y el flag +x, seguido del archivo en el que desea modificar los permisos:

chmod +x script

Se utiliza para hacer ejecutables los scripts, lo que permite ejecutarlos directamente utilizando la notación ./.

13. Comando ./

Tal vez la notación ./ no sea un comando en sí mismo, pero vale la pena mencionarlo en esta lista. Permite a tu shell ejecutar un archivo ejecutable con cualquier intérprete instalado en tu sistema directamente desde el terminal. Se acabó el hacer doble clic en un archivo en un gestor de archivos gráfico!

Por ejemplo, con este comando puedes ejecutar un script de Python o un programa solo disponible en formato .run, como XAMPP. Cuando ejecutes un ejecutable, asegúrate de que tiene permisos de ejecución (x), que puedes modificar con el comando chmod.

Aquí tenemos un sencillo script de Python y cómo lo ejecutaríamos con la notación ./:

 #! /usr/bin/python3 # filename: script for i in range(20): print(f"This is a cool script {i}")

Así es como convertiríamos el script en un ejecutable y lo ejecutaríamos:

chmod +x script ./script

14. Comando exit

El comando exit hace exactamente lo que tu nombre sugiere: Con él, puedes terminar una sesión de shell y, en la mayoría de los casos, cerrar automáticamente el terminal que estás utilizando:

15. Comando sudo

Este comando significa "superuser do", y te permite actuar como superusuario o usuario root mientras ejecutas un comando específico. Es la forma en que Linux se protege a sí mismo y evita que los usuarios modifiquen accidentalmente el sistema de archivos de la máquina o instalen paquetes inapropiados.

Sudo se utiliza comúnmente para instalar software o para editar archivos fuera del directorio personal del usuario:

sudo apt install gimp sudo cd /root/

Te pedirá la contraseña de administrador antes de ejecutar el comando que hayas escrito después.

16. Comando shutdown

Como puedes adivinar, el comando shutdown te permite apagar tu máquina. Sin embargo, también puede utilizarse para detenerla y reiniciarla.

Para apagar el ordenador inmediatamente (el valor predeterminado es un minuto), escriba:

shutdown now

También puedes programar el apagado de tu sistema en un formato de 24 horas:

shutdown 20:40

Para cancelar una llamada de shutdown anterior, puedes utilizar el flag -c:

17. Comando htop

htop es un visor de procesos interactivo que te permite gestionar los recursos de tu máquina directamente desde el terminal. En la mayoría de los casos, no está instalado de forma predeterminada, así que asegúrate de leer más sobre él en su página de descargas.

18. Comando unzip

El comando unzip permite extraer el contenido de un archivo .zip desde el terminal. Una vez más, este paquete puede no estar instalado por defecto, así que asegúrate de instalarlo con tu gestor de paquetes.

Aquí, estamos descomprimiendo un archivo .zip lleno de imágenes:

unzip images.zip

Independientemente de la distribución de Linux que utilices, es probable que uses gestores de paquetes para instalar, actualizar y eliminar el software que utilizas a diario.

Puedes acceder a estos gestores de paquetes a través de la línea de comandos, y utilizarás uno u otro dependiendo de la distro que ejecute tu máquina.

Los siguientes ejemplos instalarán GIMP, un software libre y de código abierto que suele estar disponible en la mayoría de los gestores de paquetes:

1. Basado en Debian (Ubuntu, Linux Mint)

sudo apt install gimp

2. Basado en Red Hat (Fedora, CentOS)

sudo yum install gimp

3. Basado en Arch (Manjaro, Arco Linux)

sudo pacman -S gimp

20. Comando echo

El comando echo muestra el texto definido en el terminal - es así de simple:

echo "Cool message"

Su uso principal es imprimir las variables de entorno dentro de esos mensajes:

echo "Hey $USER" # Hey kinsta

21. Comando cat

Cat, abreviatura de "concatenate", permite crear, visualizar y concatenar archivos directamente desde el terminal. Se utiliza principalmente para previsualizar un archivo sin abrir un editor de texto gráfico:

cat long_text_file.txt

22. Comando ps

Con ps, puedes echar un vistazo a los procesos que tu sesión de shell actual está ejecutando. Imprime información útil sobre los programas que está ejecutando, como el ID del proceso, el TTY (Teletipo), la hora y el nombre del comando.

En caso de que quieras algo más interactivo, puedes utilizar htop.

23. Comando kill

Es molesto cuando un programa no responde y no puedes cerrarlo por ningún medio. Afortunadamente, el comando kill resuelve este tipo de problemas.

En pocas palabras, kill envía una señal TERM o kill a un proceso que lo termina.

Puedes matar procesos introduciendo el PID (ID de los procesos) o el nombre binario del programa:

kill 533494 kill firefox

Ten cuidado con este comando - con kill, corres el riesgo de borrar accidentalmente el trabajo que has estado haciendo.

24.Comando ping

ping es la utilidad de terminal de red más popular que se utiliza para probar la conectividad de la red. ping tiene un montón de opciones, pero en la mayoría de los casos, lo utilizarás para solicitar un dominio o una dirección IP:

ping google.com ping 8.8.8.8

25. Comando vim

vim es un editor de texto de terminal libre y de código abierto que se utiliza desde los años 90. Te permite editar archivos de texto plano utilizando combinaciones de teclas eficientes.

Algunas personas consideran que es difícil de usar - salir de Vim es una de las preguntas más vistas en StackOverflow- pero una vez que te acostumbras a él, se convierte en tu mejor aliado en la línea de comandos.

Para activar Vim, solo tienes que escribir:

26. Comando history

Si te cuesta recordar un comando, el history es muy útil. Este comando muestra una lista enumerada con los comandos que has utilizado en el pasado:

27. Comando passwd

passwd te permite cambiar las contraseñas de las cuentas de usuario. En primer lugar, te pide que introduzcas tu contraseña actual y, a continuación, te pide una nueva contraseña y una confirmación.

Es similar a cualquier otro cambio de contraseña que hayas visto en otros lugares, pero en este caso, es directamente en tu terminal:

Ten cuidado al usarlo: ¡no querrás estropear tu contraseña de usuario!

28. Comando which

El comando which muestra la ruta completa de los comandos del shell. Si no puede reconocer el comando dado, arrojará un error.

Por ejemplo, podemos usar esto para comprobar la ruta binaria para Python y el navegador web Brave:

which python # /usr/bin/python which brave # /usr/bin/brave

29. Comando shred

Si alguna vez has querido que un archivo sea casi imposible de recuperar, shred puede ayudarte con esta tarea. Este comando anula el contenido de un archivo repetidamente, y como resultado, el archivo dado se vuelve extremadamente difícil de recuperar.

Aquí hay un archivo con poco contenido:

Ahora, hagamos que shred haga lo suyo escribiendo el siguiente comando:

shred file_to_shred.txt

Si deseas eliminar el archivo de inmediato, puedes utilizar el flag -u:

shred -u file_to_shred.txt

30. Comando less

less (opuesto a more) es un programa que permite inspeccionar archivos hacia atrás y hacia adelante:

less large_text_file.txt

Lo bueno de less es que incluye los comandos more y vim en su interfaz. Si necesitas algo más interactivo que cat, less es una buena opción.

31. Comando tail

Similar a cat, tail imprime el contenido de un archivo con una advertencia importante: sólo imprime las últimas líneas. Por defecto, imprime las últimas 10 líneas, pero puedes modificar ese número con -n.

Por ejemplo, para imprimir las últimas líneas de un archivo de texto de gran tamaño, se utilizaría:

tail long.txt

Para ver solo las cuatro últimas líneas:

tail -n 4 long.txt

32. Comando head

Éste es complementario al comando tail. head muestra las primeras 10 líneas de un archivo de texto, pero puede establecer cualquier número de líneas que desee mostrar con la flag -n:

head long.txt head -n 5 long.txt

33. Comando grep

Grep es una de las utilidades más potentes para trabajar con archivos de texto. Busca líneas que coincidan con una expresión regular y las imprime:

grep "linux" long.txt

Puede contar el número de veces que se repite el patrón utilizando el flag -c:

grep -c "linux" long.txt # 2

34. Comando whoami

El comando whoami (abreviatura de "who am i") muestra el nombre de usuario actualmente en uso:

whoami # kinsta

Se obtendría el mismo resultado utilizando echo y la variable ambiental $USER:

echo $USER # kinsta

35. Comando whatis

whatis imprime una descripción de una sola línea de cualquier otro comando, lo que lo convierte en una referencia útil:

whatis python # python (1) - an interpreted, interactive, object-oriented programming language whatis whatis # whatis (1) - display one-line manual page descriptions

36. Comando wc

Wc significa "word count" (recuento de palabras) y, como su nombre indica, devuelve el número de palabras de un archivo de texto:

wc long.txt # 37 207 1000 long.txt

Vamos a desglosar la salida de este comando:

37 líneas

207 palabras

1000 bytes de tamaño

El nombre del archivo (long.txt)

Si solo necesitas el número de palabras, utiliza el indicador -w:

wc -w long.txt 207 long.txt

37. Comando uname

uname (abreviatura de "Unix name") imprime la información del sistema operativo, lo que resulta útil cuando se conoce la versión actual de Linux.

La mayoría de las veces, usted utilizará el flag -a (-all), ya que la salida por defecto no es tan útil:

uname # Linux uname -a # Linux kinstamanjaro 5.4.138-1-MANJARO #1 SMP PREEMPT Thu Aug 5 12:15:21 UTC 2021 x86_64 GNU/Linux

38. Comando neofetch

Neofetch es una herramienta CLI (command-line interface) que muestra información sobre tu sistema -como la versión del kernel, el shell y el hardware- junto a un logotipo ASCII de tu distribución de Linux:

En la mayoría de las máquinas, este comando no está disponible por defecto, así que asegúrate de instalarlo primero con tu gestor de paquetes.

39. Comando find

El comando find busca archivos en una jerarquía de directorios basándose en una expresión regex. Para utilizarlo, sigue la siguiente sintaxis:

find [flags] [path] -name [expression]

Para buscar un archivo llamado long.txt en el directorio actual, introduce lo siguiente

find ./ -name "long.txt" # ./long.txt

Para buscar archivos que terminen con una extensión .py (Python), puedes utilizar el siguiente comando:

find ./ -type f -name "*.py" ./get_keys.py ./github_automation.py ./binarysearch.py

40. Comando wget

wget (World Wide Web get) es una utilidad para recuperar contenidos de Internet. Tiene una de las mayores colecciones de flags que existen.

Así es como se descarga un archivo de Python desde un repositorio de GitHub:

wget https://raw.githubusercontent.com/DaniDiazTech/Object-Oriented-Programming-in-Python/main/object_oriented_programming/cookies.py

Hoja de trucos de los comandos de Linux

Siempre que quiera una referencia rápida, solo tiene que revisar la siguiente tabla:

Resumen

Puede llevar algún tiempo aprender Linux, pero una vez que domines algunas de sus herramientas, se convertirá en tu mejor aliado, y no te arrepentirás de haberlo elegido como tu conductor diario.

Una de las cosas destacables de Linux es que, incluso si eres un usuario experimentado, nunca dejarás de aprender para ser más productivo usándolo.
Hay muchos más comandos de Linux útiles. Si nos hemos dejado algo, ¡comparte tus comandos Linux favoritos en los comentarios de abajo!

Consigue todas tus aplicaciones, bases de datos, and Sitios de WordPress online y bajo un mismo techo. Nuestra plataforma en la nube de alto rendimiento y repleta de funciones incluye:

Fácil configuración y gestión en el panel de MyKinsta

Soporte experto 24/7

El mejor hardware y red de Google Cloud Platform, con tecnología Kubernetes para una escalabilidad máxima

Una integración de Cloudflare a nivel empresarial para mayor velocidad y seguridad

Alcance de audiencia global con hasta 35 centros de datos y 260 PoPs en todo el mundo

Empieza con una prueba gratuita de nuestro Alojamiento de Aplicaciones o Alojamiento de Bases de Datos. Explora nuestros %planes o habla con el departamento de ventas para encontrar el que mejor se adapte a ti.

# data[].attributes.attachment_link.title
Los 40 Comandos de Linux Más Utilizados que Debes Conocer

# data[].attributes.attachment_link.description
Linux es uno de los sistemas operativos más populares entre los profesionales. En este artículo, conocerás los 40 comandos de Linux más utilizados.

# data[].attributes.attachment_link.readable_text
El intérprete de comandos o shell es un programa que permite a los usuarios interactuar con el sistema, procesando las órdenes que se le indican. Los comandos invocables desde el shell pueden clasificarse en internos (corresponden en realidad a órdenes interpretadas por el propio shell) y externos (corresponden a ficheros ejecutables externos al shell). Además de comandos, los shells ofrecen otros elementos para mejorar su funcionalidad, tales como variables, funciones o estructuras de control. El conjunto de comandos internos y elementos disponibles, así como su sintaxis, dependerá del shell concreto empleado.

Además de utilizar el shell desde la línea de comandos (basada en el prompt como la indicación del shell para anunciar que espera una orden del usuario), puede emplearse para la interpretación de shell-scripts. Un shell-script o "guión de órdenes" es un fichero de texto que contiene un conjunto de comandos y órdenes interpretables por el shell.

En los S.O.'s Unix existen múltiples implementaciones de shell (en Windows, el equivalente serían los programas "command.com" o "cmd.exe"). Atendiendo al shell del que proceden y a su similitud sintáctica (incluyendo sus comandos internos), los shells de Unix pueden clasificarse en dos grandes familias (existen algunos shell adicionales, de uso residual y dentro de los shells de una misma familia también existen diferencias, pero gran parte de su sintaxis es común):

1. sh (Bourne Shell): este shell fue usado desde las primeras versiones de Unix (Unix Versión 7). Recibe ese nombre por su desarrollador, Stephen Bourne, de los Laboratorios Bell de AT&T. A raíz de él han surgido múltiples shells, tales como zsh (Z shell), ash (almquist shell), bash (Bourne again shell), dash (Debian almquist shell) o ksh (Korn shell). Por su mayor uso pueden destacarse:

bash: fue desarrollado para ser un superconjunto de la funcionalidad del Bourne Shell (en la que incluye funcionalidades de ksh y csh), siendo el intérprete de comandos asignado por defecto a los usuarios en las distribuciones de Linux, por lo que es el shell empleado en la mayoría de las consolas de comandos de Linux. Se caracteriza por una gran funcionalidad adicional a la del Bourne Shell. Como ficheros personales de los usuarios emplea $HOME/.bashrc y .bash_profile.

dash (Debian almquist shell), derivado directo de ash, se caracteriza por ser mucho más ligero (depende de menos bibliotecas) y rápido que otros shells, tales como bash, aunque con menos características funcionales. El fichero personal del usuario es $HOME/.profile.

ksh (Korn shell): destaca por sus funciones avanzadas para manejar archivos, pudiendo competir con lenguajes de programación especializados tales como awk o perl.

Bourne Shell ha llegado a convertirse en un estándar de facto de tal modo que todos los sistemas Unix tienen, al menos, una implementación del Bourne Shell (o un shell compatible con él), ubicada en /bin/sh. En el caso concreto de los S.O.'s UNIX Linux, no existe ninguna implementación del Bourne Shell, manteniéndose la entrada /bin/sh (así como su manual man sh) como un enlace simbólico a una implementación de shell compatible. En concreto:

En algunos S.O's Linux se enlaza a /bin/bash.

En Debian, desde Debian Lenny "5.0" (en Ubuntu desde la versión 6.10) se enlaza a /bin/dash: de este modo, estas distribuciones pretenden hacer uso de:

dash: para los shell scripts empleados en el arranque del sistema (cuyo shebang tradicionalmente siempre ha sido #!/bin/sh), aprovechando la mayor rapidez de este intérprete.

bash: en las consolas de comandos y scripts de servicios de los usuarios, de modo que éstos puedan aprovechar la mayor funcionalidad que éste intérprete ofrece.

2. csh (C shell): caracterizado por presentar una sintaxis muy parecida a la del lenguaje de programación C. Como shell derivados destaca tcsh. Estos shell cuentan con un nivel de uso muy inferior respecto a los de la familia Bourne Shell.
Para intentar homogeneizar esta diversidad de shells, el IEEE definió un estándar de "intérprete de comandos" bajo la especificación POSIX 1003.2 (también recogida como ISO 9945.2). La creación de dicho estándar se basó en la sintaxis que presentaban múltiples shells de la familia Bourne shell (el propio Bourne Shell de Unix Versión 7, implementaciones en UNIX System V y BSD, así como ksh). Esto ha llevado a que la gran mayoría de los shells derivados del Bourne Shell, tales como bash, dash o ksh, den soporte a este estándar POSIX (mientras que los derivados del csh no). En concreto:

bash: respeta completamente el estándar POSIX, sobre el que añade un número considerable de extensiones (estructura select, arrays, mayor número de operadores,...).

dash: conforme al estándar POSIX IEEE 1003.2, sólo ampliado con algunas extensiones Berkeley. De forma precisa, tal como indica el manual del intérprete dash de su sistema (man dash), la línea de desarrollo de dash pretende que éste satisfaga el estándar POSIX de shells IEEE 1003.2, propósito casi logrado en la actualidad (sólo presenta algunas características faltantes, como la variable $LINENO).

1. Ejecute en su sistema Debian el comando ls -l /bin/sh, y compruebe cómo efectivamente corresponde a un enlace simbólico al intérprete /bin/dash. Asimismo, consulte el manual man sh, comprobando cómo efectivamente obtiene el manual del intérprete dash.

2. Ejecute los comandos ls -l /bin/dash y ls -l /bin/bash para comprobar cómo efectivamente dispone de dichos shells en su sistema. Puede obtener las versiones instaladas mediante dpkg -s dash y bash -version.

3. La mayoría de los shell-scripts implicados en el proceso de arranque del sistema se encuentran en la carpeta /etc/init.d/. Por ejemplo, mire el contenido del fichero /etc/init.d/rc (encargado del arranque de los servicios) y compruebe cómo la primera línea de dicho script es #!/bin/sh, lo que indica que es interpretado por el shell /bin/dash.

4. Analice el fichero /etc/passwd y compruebe cómo los usuarios dit y root tienen asignado el shell bash. Abra una consola de comandos con el usuario dit y ejecute el comando ps ax | grep bash, comprobando cómo el proceso del intérprete de comandos usado efectivamente corresponde al shell bash (proceso -bash). Abra una sesión con el usuario root y realice la misma prueba, comprobando cómo igualmente se está usando bash.

El objetivo es introducir el uso del lenguaje de programación de shell-scripts. Consecuentemente, nos centraremos en la sintaxis de shell propuesta por el estándar POSIX IEEE 1003.2 lo que, conforme a lo antes indicado, se traduce en que todo lo visto aquí podrá ser utilizado en dash, bash y cualquier otro shell que satisfaga dicho estándar. Sobre la base de este documento podrá profundizarse analizando las funcionalidades adicionales añadidas por cada shell, siendo de especial interés, dado su uso, las aportadas por bash.

Estándar de "intérprete de comandos" de la especificación POSIX ( IEEE Standard 1003.1 2004/ISO 9945.2)

The Linux Command Line (Openbook)". E. William, Jr. Shotts. San Francisco, 2011.

Linux bible". Christopher Negus. Indianapolis, IN. Wiley, 2011. ISBN: 9780470929988.

Pro Linux System Administration". James Turnbull, Peter Lieverdink, Dennis Matotek. Berkeley, CA. Apress, 2009. ISBN: 978-1-4302-1912-5.

Linux Network Administrator's Guide (Openbook)". Olaf Kirch, Terry Dawson. O'Reilly, 2000. ISBN: 1-56592-400-2

Web oficial de Dash

Manual de referencia de Bash

Descarga de los shell-scripts de esta página

Para que no tenga que escribir los scripts que se muestran en esta página a mano, puede descargarse dichos scripts así como la solución a los ejercicios propuestos en el fichero comprimido shellscripts.tar.gz . Descomprímalo con el comando:
tar xfvz ./shellscripts.tar.gz
En el directorio scripts están los ejemplos y en el directorio aplicacion los ejercicios propuestos resueltos.

Descarga en PDF (versión original)

Puede descargarse también la versión original de este documento en formato PDF: FAST_t3-practica.pdf .

En su forma más básica, un shell-script puede ser un simple fichero de texto que contenga uno o varios comandos. Para ayudar a la identificación del contenido a partir del nombre del archivo, es habitual que los shell scripts tengan la extensión ".sh", por lo que seguiremos este criterio (pero recuerde que es algo meramente informativo y opcional). Por ejemplo, el siguiente fichero sería un shell-script:

echo "Contenido carpeta personal:"
ls ~/

1. Compruebe que el fichero "script.sh" tiene permisos de ejecución generales (si no los tuviese, para asignárselos bastaría ejecutar "chmod +x script.sh").

2. Invoque el script para que sea interpretado, usando por ejemplo el comando:
cd ./script.sh

Además de comandos, los shell-scripts pueden contener otros elementos, aportados por el shell para mejorar la funcionalidad de los scripts. De forma resumida, la estructura básica de un shell-script es la siguiente:

#!/bin/dash
# Esto no se interpreta
echo Hola
ps w
echo "Proceso lee el script: $$"

<-- Shebang
<-- Comentarios
<-- Contenido

Como contenido del script pueden utilizarse múltiples elementos (comandos, variables, funciones, estructuras de control, comentarios,...) que se analizarán en el siguiente apartado.

El "shebang" permite especificar el intérprete de comandos con el que deseamos que sea interpretado el resto del script cuando se usa invocación implícita (ver más adelante). La sintaxis de esta línea es la secuencia #! seguida del ejecutable del shell deseado, sobre lo que deben realizarse la siguientes advertencias:

Es imprescindible que sea la primera línea del script, ya que, en caso contrario, sería interpretado como un comentario (comienza con el carácter #).

Puede haber espacios entre #! y el ejecutable del "shell".

El shebang no es obligatorio (cuando se usa invocación implícita, si no se indica se intentará usar el mismo tipo de shell desde el que se ha invocado el script).

Sintaxis estricta

La sintaxis de los shell-scripts se caracteriza por ser bastante estricta en su escritura, especialmente en lo que se refiere a la inserción u omisión de espacios en blanco entre las palabras especiales. Tenga esto muy en cuenta a la hora de escribir los scripts que se proponen.

La utilización del shebang está condicionada por la forma en que sea invocado el shell-script, existiendo 3 opciones:

Explícita: escribiendo explícitamente qué shell se desea invocar y pasando como argumento el nombre del script, cargándose en memoria un nuevo proceso para dicho shell (subshell o proceso shell hijo del shell padre responsable de la línea de comandos desde la que se ha invocado el script). En este caso se ignora el shebang.

Implícita: invocando al script como si fuera un ejecutable, lo que requiere asignar permisos de ejecución al script. Se lee el shebang para determinar qué shell deberá usarse para leer el script, cargándose en memoria un proceso hijo (subshell) para dicho shell (si el script no presenta shebang, para el subshell se utilizará el mismo tipo de shell que el encargado de la línea de comandos desde la que se ha hecho la invocación). Tenga en cuenta que los shell-scripts son ficheros de texto leídos por el intérprete de comandos, esto es, se interpretan, NO se ejecutan. La asignación del permiso de ejecución a un shell-script es una utilidad del sistema de ficheros para acelerar la invocación de scripts, pero cuyo funcionamiento interno es cargar un nuevo proceso de shell (subshell) para que éste interprete el script.

Implícita con . (equivale a importar): el script será interpretado por el mismo proceso del shell responsable de la línea de comandos desde la que se está invocando el script (luego aquí no se abre ningún subshell). Consecuentemente, en este caso también se ignora el shebang.

En los casos en los que se crean subshells, salvo que se fuerce lo contrario (con su -c por ejemplo), el subshell pertenecerá al mismo usuario al que pertenecía el shell padre que lo ha creado. El usuario al que pertenece el proceso shell que interpreta un script condiciona las operaciones que se podrán hacer desde dentro del script (por ejemplo, si el shell pertenece al usuario dit , el script no podrá modificar el fichero /etc/passwd , mientras que si el shell pertenece al superusuario root , sí podrá hacerlo). Tenga en cuenta este aspecto para determinar qué operaciones puede realizar dentro de un script, y con qué usuario debe invocarlo.

1. En una consola de comandos ejecute el comando ps w y localice el proceso asociado al shell responsable de la línea de comandos desde la que está trabajando.

2. Invoque dicho script mediante los distintos métodos de invocación. Para cada uno de ellos, analice la salida obtenida para determinar en cada caso cuál es el proceso shell que está interpretando el script, el usuario al que pertenece dicho proceso y si se ha abierto un subshell o no:

Explícita:
/bin/sh script_ejemplo.sh

/bin/dash script_ejemplo.sh

/bin/bash script_ejemplo.sh

Implícita con ".":
. script_ejemplo.sh

Implícita: compruebe que el script tiene permiso de ejecución y ejecútelo con:
./script_ejemplo.sh

Modifique el script eliminando el shebang, y vuelva a ejecutarlo. Analice si hay alguna diferencia respecto a la ejecución anterior.

Conforme se ha indicado en la introducción, si bien tanto bash como dash siguen el estándar POSIX, especialmente bash añade múltiples extensiones particulares, no soportadas por otros shells como dash. Consecuentemente, cada vez que diseñemos un script deberemos tener en cuenta el shell o shells que lo soportan, asegurando que sea invocado por uno de ellos. Para que se haga una idea de la importancia de este aspecto, considere los dos scripts siguientes, basados en el uso de la estructura for (que se usará más adelante):

#!/bin/sh for VAR in 0 1 2 3
do
   echo $VAR
done

#!/bin/bash
for ((VAR=0 ; VAR<4 ; VAR++ ))
do
   echo $VAR
done

Ambos scripts realizan la misma funcionalidad, pero script_estandar.sh está escrito bajo la sintaxis POSIX, mientras que script_bash.sh utiliza una sintaxis no estándar soportada por bash.

1. Invoque el guión script_estandar.sh (recuerde que debe disponer de ellos ya creados en el directorio scripts/) mediante los siguientes comandos, debiendo comprobar que todas funcionan correctamente y con igual resultado (la primera y segunda llamada realmente son la misma, usando el shell dash):
/bin/sh script_estandar.sh

/bin/dash script_estandar.sh

/bin/bash script_estandar.sh

2. Ahora invoque el guión script_bash.sh mediante los siguientes comandos:
/bin/dash script_bash.sh

/bin/bash script_bash.sh

Podrá comprobar cómo, debido a la sintaxis no estándar del script, la segunda invocación funciona, pero la primera (que emplea dash) da un error de sintaxis.

En este apartado se describe el lenguaje de comandos shell definido en el estándar POSIX. Veremos el funcionamiento general del shell, así como su sintaxis. Puede encontrar la descripción detallada del estándar POSIX en el siguiente enlace: POSIX Shell Command Language

Aquí se resumen las características más utilizadas. Se recomienda acudir al estándar para obtener una descripción más detallada y exhaustiva.

El lenguaje shell es un lenguaje interpretado, en el que se leen líneas de texto (terminadas en \n), se analizan y se procesan. Las líneas a interpretar son leídas de:

La entrada estándar (teclado por defecto). En este caso el shell se dice que es un shell interactivo.

Un fichero shell-script.

Los argumentos, con la opción -c al ejecutar el shell. Ejemplo: bash -c "ls -l"

Con las líneas leídas, el shell realiza los siguientes pasos (en este orden):

1. Se dividen las líneas en distintos elementos: palabras y operadores. Los elementos se separan usando espacios, tabuladores y operadores. El carácter # sirve para incluir un comentario, que se elimina del procesamiento.

2. Se distingue entre comandos simples, comandos compuestos y definiciones de función.

3. Se realizan distintas expansiones y sustituciones (ver más adelante). Se detecta el comando a ejecutar y los argumentos que se le van a pasar.

4. Se realizan las redirecciones de entrada/salida y se eliminan los elementos asociados a las redirecciones de la lista de argumentos. Las redirecciones de entrada/salida ya se han explicado en un tema anterior (si desea ampliar información, consulte el anexo).

5. Se ejecuta el elemento ejecutable, que podría ser una función, un comando interno del shell, un fichero ejecutable o un shell-script, pasando los argumentos como parámetros posicionales (ver más adelante).

6. Opcionalmente, se espera a que termine el comando y se guarda el código de salida.

Advertencia

A lo largo de la memoria se utilizará la palabra "ejecutar" para referirse a la ejecución de un programa binario (un programa compilado, por ejemplo), al inicio de la interpretación de un script o a la invocación de una función o comando interno. Se considerarán, por tanto, elementos ejecutables, programas binarios y scripts (con el permiso de ejecución), comandos internos y funciones.

Cuando se escriben comandos desde el teclado y se intenta introducir un elemento que está formado por más de una línea, una vez que teclee la primera línea y pulse Intro, el shell mostrará el indicador secundario de petición de orden > (en lugar del prompt), solicitándole que continúe escribiendo el elemento. Cuando el intérprete dé por concluida la introducción del elemento, la interpretará, volviendo a mostrar el prompt de la línea de comandos. Si utiliza el cursor ↑ para intentar ver el comando introducido, en general verá cómo el shell ha rescrito la entrada para aplicarle la sintaxis con la que todo el elemento es escrito en una sola línea. Si desea cancelar la introducción de una línea (o líneas) sin necesidad de borrar lo que lleva escrito, puede pulsar Ctrl-C.

Escriba el contenido del script script_estandar.sh visto en el apartado 2 directamente en una consola de comandos.

El shell tiene una lista de caracteres que trata de manera especial (operadores) y una serie de palabras reservadas (palabras que tienen un significado especial para el Shell). Puede ver un listado de caracteres especiales y palabras reservadas en los apartados 2.2 y 2.4 del estándar.

Cuando queremos utilizar un carácter especial del shell o una palabra reservada del lenguaje sin que sea interpretada como tal o prevenir una expansión o sustitución indeseada (las expansiones y sustituciones se verán en un apartado posterior) es necesario indicárselo al shell mediante las comillas (simples o dobles) o el carácter de escape. Por ejemplo, para escribir el nombre de un fichero que contenga espacios, para pasar el símbolo < como argumento a un programa.

El carácter de escape \ : indica que el siguiente carácter debe preservar su valor literal. El carácter de escape se elimina de la línea una vez procesado. Si aparece al final de una línea, significa "continuación de línea" e indica que el comando continúa en la siguiente línea (puede ser utilizado para dividir líneas muy largas).

Comillas simples ' ' : todo texto 'entrecomillado' con comillas simples mantendrá su valor literal, no se producirá ninguna expansión ni sustitución y será considerado como una única palabra.

Comillas dobles ": es equivalente a usar comillas simples, salvo que en este caso sí se hacen expansiones y sustituciones (todas menos las expansiones de tilde y ruta y la sustitución de alias que veremos más adelante).

El entrecomillado de una cadena vacía ( '' o ") genera una palabra vacía (palabra que no tiene ningún carácter).

Vea el apartado 2.2 del estándar para obtener información detallada.

Ejecute los siguientes comandos en el terminal y analice los resultados:

cd
echo $PWD
echo \$PWD
echo '$PWD'
echo "$PWD"
echo hola \> a y b
#se crea el fichero a
echo hola > a y b
ls
cat a
#se crea el fichero 'a y b'
echo hola >"a y b"
ls
cat a\ y\ b

Como en cualquier lenguaje de programación, en el lenguaje shell se pueden crear y utilizar variables, que aquí se llaman parámetros. Existen varios tipos de parámetros:

1. Si el nombre es un número se denominan parámetros posicionales.

2. Si el nombre es un carácter especial se denominan parámetros especiales.

3. El resto se denominan simplemente variables.

A continuación se detallan cada uno de estos tipos. Vea el apartado 2.5 del estándar para obtener más información.

El shell permite realizar las siguientes operaciones básicas con las variables:

Sobre ello deben realizarse las siguientes observaciones respecto a:

1. Definición y uso:

Las variables sólo existen en el proceso shell en que son definidas (locales al proceso).

Las variables sólo son accesibles desde el momento de su definición hacia abajo del script, esto es, siempre deben definirse primero e invocarse después (no puede usarse una variable que es definida más adelante). Pueden utilizarse también dentro de funciones (ver más adelante) aunque se hayan declarado fuera de ellas. En el estándar POSIX todas las variables son globales, aunque existen variantes (como bash) que permiten la creación de variables locales a las funciones.

No es necesario definir las variables previamente a su uso, ya que se crean al asignarles la primera vez un valor. Al definir una variable sin inicialización, su valor por omisión es la cadena nula, esto es, las siguientes entradas son equivalentes:

Con el comando set (sin argumentos) puede ver todas las variables (y funciones) definidas en el shell actual.

2. Nombrado: téngase en cuenta que Linux es "case sensitive" (sensible a mayúsculas y minúsculas) en general, lo que incluye el nombre de las variable. Así, VAR y var serán tomadas como dos variables independientes . Para el nombre de una variable puede usarse :

1er carácter: una letra o el carácter de subrayado _.

2º y posteriores caracteres: una letra, dígito o el carácter de subrayado.

3. Inicialización/Modificación del valor de una variable:

Es importante no incluir ningún espacio ni antes ni después del signo =. Si se hace, el shell intentará interpretar el nombre de la variable como un comando (recuerde que la sintaxis del shell es especialmente estricta en lo que a espacios se refiere).

El valor de una variable siempre es tomado por el shell como una cadena de caracteres.

Si el valor de una variable contiene caracteres especiales, espacios, u otros elementos que puedan ser malinterpretados por el shell, tendrá que ir entrecomillado o deberá incluir el carácter de escape donde sea necesario.

4. Expansión de una variable: el uso de las llaves {} sólo es necesario si justo tras el nombre de la variable se desean escribir más caracteres, sin añadir ningún espacio antes. Se verá más adelante con más detalle.

Existe un conjunto de variables que afectan al funcionamiento del shell. Muchas ya han sido analizadas en temas anteriores, por ejemplo: HOME, PATH, LANG,... Puede volver a ver una descripción de ellas en el apartado 2.5.3 del estándar.

Aquí vamos a destacar la variable IFS (Input Field Separators). El valor de esta variable es una lista de caracteres que se emplearán en el proceso de división de campos realizado tras el proceso de expansión (que se verá más adelante, en el apartado 3.4) y por el comando read (ver el apartado 3.8.1 de comandos internos). El valor por defecto es <espacio><tab><nueva-línea>. Podrá ver un ejemplo de uso de esta variable cuando realice los ejercicios propuestos (ver solución a script_user.sh).

Son los parámetros de la línea de comandos con la que se ha invocado al script (equivalen a la variable argv de C). Están denotados por un número y para obtener su valor se emplea $X o ${X} para los parámetros del 1 al 9 y ${X} para parámetros mayores (números de más de un dígito). Se pueden modificar con los comando set (los crea) y shift (los desplaza de posición).

Son parámetros identificados por un carácter especial creados por el Shell y cuyo valor no puede ser modificado directamente. En esta tabla se muestran los parámetros especiales definidos en el estándar:

Se expande a todos los parámetros posicionales desde el 1. Si se usa dentro de comillas dobles, se expande como una única palabra formada por los parámetros posicionales separados por el primer carácter de la variable IFS (si la variable IFS no está definida, se usa el espacio como separador y si está definida a la cadena nula, los campos se concatenan).

Opciones actuales del shell (modificables con el comando set). Consulte las opciones disponibles con el comando man dash .

Mire el contenido del script script_var-shell.sh, que deberá contener lo siguiente:

Compruebe que dispone del permiso de ejecución. Invóquelo el comando y analice la salida:

./script_var-shell.sh arg1 arg2

Cuando un proceso (proceso padre, como por ejemplo el shell) ejecuta otro proceso (proceso hijo, otro programa o script), el proceso padre, además de los parámetros habituales ( argc y argv en C), le pasa un conjunto de variables de entorno al proceso hijo (cada lenguaje de programación tiene su método propio para obtenerlas y modificarlas). Las variables de entorno pasadas pueden ser utilizadas por el proceso hijo para modificar su comportamiento. Por ejemplo, un programa en C puede usar la función getenv declarada en biblioteca estándar stdlib.h para obtener dichas variables (puede obtener más información ejecutando man getenv).

El comando interno del shell export permite que una variable (previamente definida o no) sea configurada para que su valor sea copiado a los procesos hijos que sean creados desde el shell actual (por ejemplo otros shell). Presenta la sintaxis:

export VAR=valor

En este último caso, sí es posible añadir un espacio antes o después del signo =.

Debe advertirse que "exportación" significa "paso de parámetros por valor", esto es, en el proceso hijo se creará una variable de igual nombre que en el shell padre, y con igual valor, pero serán variables independientes (esto es, la modificación de valor de la variable en el proceso hijo no afectará al valor de la variable en el shell padre). El proceso hijo no puede crear ni modificar variables del proceso padre.

Mire el contenido de los siguientes scripts en su sistema:

Compruebe que dispone del permiso de ejecución. Ejecute el comando:

./script_padre.sh

Analice el resultado.

No debe confundirse la exportación con la invocación de shell-scripts mediante el mecanismo implícito basado en .. En este caso no hay ninguna copia de variables por valor, simplemente el script invocado es interpretado por el mismo shell.

Mire el contenido de los siguientes scripts en su sistema:

Compruebe que dispone del permiso de ejecución general. Ejecute el siguiente commando y analice el resultado:

En los S.O.'s Linux suele ser habitual encontrar scripts que se dedican exclusivamente a contener la inicialización de un conjunto de variables, o la definición de un conjunto de funciones. Otros scripts del sistema hacen uso del mecanismo de invocación implícito basado en ., para cargar o importar las variables o funciones definidas en dichos scripts.

Por ejemplo, visualice el contenido del script del sistema encargado del arranque de los servicios /etc/init.d/rc. Observe cómo contiene las líneas:

. /etc/default/rcS

. /lib/lsb/init-functions

Visualice el contenido de esos archivos rcS e init-functions y compruebe cómo sólo contienen definiciones de variables y funciones (la sintaxis para la definición de las funciones se analizará más adelante), respectivamente. De hecho, todos los ficheros de la carpeta /etc/default/ son scripts dedicados exclusivamente a contener la inicialización de variables, siendo importadas desde otros scripts del sistema. Por ejemplo, observe cómo:

La variable VERBOSE es inicializada en rcS y luego es usada por rc.

La función log_failure_msg() es definida en init-functions y luego es usada por rc.

Como se vio en el apartado de funcionamiento general del shell (apartado 3.1), en un paso previo a la ejecución del elemento ejecutable se realizan una serie de expansiones y sustituciones. En este apartado se describe cuáles son y cómo se realizan. Puede ver una descripción detallada en el apartado 2.6 del estándar.

Existen los siguientes tipos de expansiones y sustituciones (que desarrollaremos más adelante):

1. Expansión de ~ (virgulilla o tilde de la ñ).

2. Expansión de parámetros o variables.

3. Sustitución de comando.

4. Expansión aritmética.

5. Expansión de ruta.

Aparte de estas expansiones está el concepto de alias (ver apartado 2.3.1 del estándar) que se utiliza para crear sinónimos de comandos y sólo se realiza en el elemento ejecutable de la línea antes de cualquier otra expansión o sustitución. Su utilización es muy limitada y puede conseguirse un comportamiento similar usando funciones que permiten además parámetros (las funciones se verán más adelante). Puede ver los alias definidos usando el comando alias. Puede ver ejemplos de definición de alias en el fichero ~/.bashrc.

El orden de ejecución de estas expansiones es el siguiente:

1. Primero se hacen en orden las siguientes expansiones:

Expansión de ~.

Expansión de parámetros o variables.

Sustitución de comando.

Expansión aritmética.

2. Los campos generados en el primer paso son divididos utilizando como separadores los caracteres de la variable IFS. Si la variable IFS es nula (cadena nula) no se produce la división. Si la variable no está definida, se utilizan por defecto los caracteres espacio, tabulador y nueva línea.

3. Se realiza a continuación la última expansión:

4. Expansión de ruta.

5. Por último, se eliminan las comillas simples o dobles que existan y se utilicen como tal (no se eliminan las comillas que hayan perdido su significado especial, por ejemplo usando el carácter de escape).

Puede utilizar las expansiones en cualquier ubicación donde se pueda usar una cadena de texto (incluido el nombre de comandos), exceptuando las palabras reservadas del lenguaje (if, else, ...).

Las apariciones de la virgulilla (o tilde de la ñ) dentro de una línea, que no se encuentren entrecomilladas, se expanden de la siguiente manera:

Comente la línea del script script_var-shell.sh, visto en el apartado 3.3, donde aparece la palabra "firefox". Ejecute los siguientes comandos observando el valor de las variables posicionales:

./script_var-shell.sh ~ ~root

./script_var-shell.sh ~noexiste ~dit

El formato general para incluir una expansión de variables o parámetros, como se ha visto en apartados anteriores es:

Las llaves pueden omitirse, salvo cuando se trate de un parámetro posicional con más de un dígito o cuando se quiera separar el nombre de la variable de otros caracteres. Por ejemplo:

echo $PAR #puede omitirse

echo ${10} #no puede omitirse

${PAR}TEXTO #no se omite

Si la expansión de parámetros ocurre dentro de comillas dobles, sobre el resultado no se realizará la expansión de ruta ni la división de campos (pasos b y c). En el caso del parámetro especial @, se hace la división de campos siempre.

Aparte de este formato general, se pueden utilizar otros formatos que permiten establecer valores por defecto, comprobar si la variable está definida, eliminar sufijos y prefijos, contar el número de caracteres, etc. Puede ver la lista de formatos junto con ejemplos en el apartado 2.6.2 del estándar. Por ejemplo, los siguientes:

${PAR:-alternativo}

Valor de la variable. Si la variable no tiene ningún valor, la construcción se sustituye por el valor alternativo.

${PAR:=alternativo}

Ídem al anterior, pero asignando el valor alternativo a la variable.

Elimina el sufijo más pequeño del valor de la variable. sufijo es un patrón como los utilizados en la expansión de ruta. Si en vez de % se pone %% se elimina el sufijo más grande.

${PAR#prefijo}

Elimina el prefijo más pequeño del valor de la variable. prefijo es un patrón como los utilizados en la expansión de ruta. Si en vez de # se pone ## se elimina el prefijo más grande.

Los siguientes scripts muestran un posible ejemplo de ambas construcciones:

Mire el contenido de los scripts anteriores en su sistema, invóquelos y analice los resultados.

Permite que la salida estándar de un programa se utilice como parte de la línea que se va a interpretar.

Existen dos opciones, con el mismo funcionamiento:

En el segundo caso se está utilizando la tilde francesa o acento grave, que no debe confundirse con las comillas simples. Para escribirla, hay que pulsar la tecla correspondiente a ` y pulsar espacio.

El shell ejecutará comando, capturará su salida estándar y sustituirá $(comando) por la salida capturada.

Por ejemplo, para almacenar en una variable el nombre de todos los ficheros con extensión .sh del directorio actual, podría escribir:

O, por ejemplo, para matar el proceso con nombre firefox-bin, podría usar:

kill -9 $(pidof firefox-bin)

El formato para realizar una expansión aritmética es el siguiente:

Permite evaluar las cadenas indicadas en la expresión como enteros, admitiendo gran parte de los operadores usados en el lenguaje C, pudiendo usar paréntesis como parte de la expresión y el signo - para números negativos (a las cadenas que contengan letras se les asigna el valor 0). Tras la evaluación aritmética, el resultado vuelve a ser convertido a una cadena. La conversión de un número a un carácter puede realizarse con $'\xxx' (en bash) o con '\xxx' (en dash), ambos con comillas simples, pero ello no está recogido en el estándar POSIX.

Si se usan variables en la expresión, no es necesario que vayan precedidas por el carácter $ si ya contienen un valor entero válido (sí es necesario para los parámetros posicionales y especiales).

Puede ver más detalles en el apartado 2.6.4 del estándar.

Mire el contenido del script script_expansion3.sh, que deberá contener lo siguiente:

Compruebe que dispone del permiso de ejecución. Invóquelo mediante el comando:

./script_expansion3.sh

Analice el resultado.

Los campos que incluyan los caracteres *, ?y [ (asterisco, interrogación y apertura de corchetes) no entrecomillados serán sustituidos por la lista de ficheros que cumplan ese patrón. Si no hay ningún fichero con ese patrón no se sustituye nada. El uso de estos caracteres ya se ha utilizado en otros cursos. Puede ver más detalles en el apartado 2.13 del estándar.

Utilice el script script_var-shell.sh, visto en el apartado 3.3, pero modifíquelo eliminando las líneas con la palabra "firefox", para evitar que moleste en las siguientes pruebas. Ejecute los siguientes comandos observando el valor de la variable especial @:

./script_var-shell.sh s*_for?.sh

./script_var-shell.sh s*_for*.sh

./script_var-shell.sh s*_exp*.sh

./script_var-shell.sh s*_exp*[12].sh

./script_var-shell.sh s*_e*.sh

Un comando puede ser clasificado en las siguientes tipos de comandos (de menor a mayor nivel):

Cada uno de estos tipos se forma mediante la composición de elementos de los tipos inferior. Pero también se permite anidar distintos tipos de comandos (no todas las combinaciones son posibles como se verá más adelante), por lo que podríamos encontrarnos: tuberías de comandos compuestos, comandos compuestos formados por otros comandos compuestos, etc.

En general, el valor devuelto por un comando compuesto (tipo b y superiores) será el valor devuelto por el último comando simple ejecutado.

A continuación describiremos cada uno de los tipos. Puede ver más detalles en el apartado 2.9 del estándar.

Un comando simple está formado por (todos los elementos son opcionales) una secuencia de asignación de variables y redirecciones (en cualquier orden) seguida de palabras (elemento ejecutable y sus argumentos) y redirecciones. A continuación se muestra la estructura genérica de un comando simple (los corchetes [ ] indican qué elementos son opcionales, que es la notación usada en el resto de este documento):

Pudiendo ser el ejecutable programas "ejecutables" (comandos internos y ejecutables externos) e "interpretables" (funciones).

Es decir, en un mismo comando simple se puede hacer simultáneamente la asignación de variables y la ejecución de un programa. Cuando un comando simple no incluye un programa a ejecutar, la asignación de variables afecta a todo el shell, de lo contrario la asignación sólo afecta al programa que se va a ejecutar.

Si en un mismo comando simple hubiera que hacer expansiones en las palabras y en la asignación de variables, primero se hace las expansiones de las palabras.

Ejemplos de comandos simples:

El anterior comando asigna el valor x a la variable VAR y afecta a todo el proceso shell actual.

VAR=x programa

Asigna el valor x a la variable VAR y afecta solo al programa.

VAR=x programa $VAR

Se asigna el valor y a la variable VAR y el valor z a la variable OTRA, que afectan a todo el shell. A continuación, asigna el valor x a la variable VAR y afecta sólo al programa, al cual se le pasa como primer argumento y. A continuación se imprime y por pantalla.

VAR=x > fichero programa

VAR=x programa > fichero #equivalente

Una tubería es una secuencia de uno o más comandos (simples o compuestos, pero no ningún tipo de lista) separados por el operador |. La salida estándar de un comando se conecta a la entrada estándar del siguiente comando (cada comando se ejecuta en otro subshell simultáneamente). Esta conexión se hace previamente a cualquier redirección. El formato es:

Opcionalmente, se puede añadir delante el carácter ! que hace la negación lógica del valor devuelto por el último comando, de tal manera que el valor devuelto por la tubería sería 1 si el último comando devuelve 0, o 0 en caso contrario.

Una lista AND es una secuencia de tuberías (tenga en cuenta que una tubería puede ser sólo un comando simple) separadas por el operador &&. El formato es:

Se van ejecutando las tuberías de izquierda a derecha hasta que una de ellas devuelva un valor distinto de cero. No se realiza ninguna expansión en una tubería hasta que el shell no determine que tiene que ejecutar dicha tubería (dependerá del resultado de la tubería anterior).

Una lista OR es una secuencia de tuberías separadas por el operador ||. El formato es:

Se van ejecutando las tuberías de izquierda a derecha hasta que una de ellas devuelva un valor cero. No se realiza ninguna expansión en una tubería hasta que el shell no determine que tiene que ejecutar dicha tubería.

Una lista AND-OR es el resultado de combinar listas AND y/o OR en una misma línea. Los operadores && y || se evalúan con la misma prioridad de izquierda a derecha. Ejemplo:

tuberia1 || tuberia2 && tuberia3

Las listas son secuencias de una o más listas AND-OR separadas por los operadores ; o &. Los operadores ; y & no pueden aparecer seguidos (por ejemplo, daría error prog1 & ; prog2)

Según el operador las listas pueden ser secuenciales, asíncronas o mixtas (combinación de ambas).

Se utiliza como separador el operador ;. Se van ejecutando los distintos comandos secuencialmente (no se ejecuta un comando hasta que haya terminado el anterior). Cada lista AND-OR debe estar terminada por el operador ; a excepción de la última donde es opcional. El formato es:

Se utiliza como separador el operador &. Se van ejecutando los distintos comandos sin esperar a que el comando anterior termine (ejecución en segundo plano). El formato es:

En este caso, a menos que se haga una redirección explícita de la entrada estándar, si un programa en segundo plano lee de la entrada estándar recibirá un error de fin de fichero (EOF).

Son combinaciones de listas secuenciales y asíncronas. Por ejemplo:

#asíncrona y secuencial lANDOR1 & lANDOR2 [ ; ]

#secuencial y asíncrona lANDOR1 ; lANDOR2 &

#asíncrona y secuencial lANDOR1 & lANDOR2 & lANDOR3 ; lANDOR4

#secuencial, asíncrona, secuencial lANDOR1 ; lANDOR2 & lANDOR3

No es más que una secuencia de listas (apartado 3.5.4), separadas por el carácter de nueva línea (intros), terminada por el operador ;, el operador &, el carácter de nueva línea (intro) o un comando compuesto. La utilidad de este tipo de listas se verá sobre todo cuando se expliquen los comandos compuestos.

Mire el contenido del script script_operadores.sh, que deberá contener lo siguiente:

Compruebe que dispone del permiso de ejecución. Invóquelo y analice su funcionamiento.

Desde la línea de comandos, cree listas y tuberías de todos los tipos vistos usando combinaciones de los comandos ls, echo, cat y ps.

Los comandos compuestos son lo que en otros lenguajes de programación se conocen como estructuras de control. Cada uno de estos comandos compuestos (o estructuras de control) están delimitados por una palabra reservada u operador de control al principio y otro al final (terminador). Si se hace una redirección a continuación del terminador, en la misma línea, esa redirección se aplicará a todos los comandos que se encuentre en ese comando compuesto, a menos que se haga otra redirección explícita en un comando en concreto.

A continuación se hace un repaso por todas las estructuras de control disponibles en el estándar POSIX. Puede consultar el apartado 2.9.4 del estándar para más información.

La agrupación de comandos permite mejorar la legibilidad del código, aplicar una redirección a un conjunto de comandos y crear un subshell entre otras cosas.

Existen dos formas de agrupar comandos, con los siguientes formatos:

( lista-compuesta )
Se ejecuta la lista compuesta en un subshell. Los cambios que se produzcan en este subshell no afectarán al shell actual. Si la lista compuesta está terminada por el carácter de nueva línea, este carácter puede omitirse.

{ lista-compuesta }
Se ejecuta la lista compuesta en el shell actual. Recuerde que las listas compuestas están terminadas por los operadores ;, & o nueva línea (el último comando debe estar separado de la llave de cierre por esos operadores).

En ambos casos, se permite añadir una redirección al final (detrás del ) o }) que afectará a todos los comandos del grupo.

Presenta la siguiente sintaxis:

Las entradas elif tienen el significado de un else seguido de un nuevo if. Puede haber tantas entradas elif como se desee. Tanto las entradas elif como la entrada else son opcionales.

En esta estructura, lo primero que se hace es ejecutar la lista-compuestaA1, si el valor devuelto es 0 (ADVERTENCIA: 0 significa verdadero aquí), se ejecutaría lista-compuestaB1 y terminaría la estructura if. Si el valor devuelto no es 0 se comprueba el siguiente elif. Si ninguna de las listas-compuestas A devuelve 0 se ejecutaría el bloque del else. En otras palabras, las listas compuestas B solo se ejecutan si se ha comprobado su respectiva lista-compuesta A y ha devuelto 0.

A veces, para mejorar la legibilidad, las listas-compuestas se encierran entre llaves (agrupación de comandos) pero es opcional. Asimismo, then estará en una línea u otra dependiendo del operador (&, ; o nueva línea) utilizado para terminar la lista compuesta. Si desea dejar una lista-compuesta vacía (no quiere realizar ninguna operación en un determinado caso), puede utilizar el comando : (comando nulo).

Por ejemplo, si tenemos un programa llamado condicion que devuelve 0 si algo es verdadero y 1 si es falso, los siguientes ejemplos son equivalentes:

if condicion; then { comando1; comando2; } fi

if condicion; then comando1; comando2; fi

if condicion then comando1; comando2; fi

if condicion then comando1 comando2 fi

if condicion; then comando1; comando2; fi

if condicion; then { comando1; comando2; } fi

Recuerde que si usa las llaves, debe separarlas del resto de elementos. Por ejemplo:

if condicion; then {c omando1; comando2;} fi

if condicion; the n{ comando1; comando2;} fi

if condicion; then { comando1; comando 2} fi

darán error de sintaxis.

Respecto a la condición; que puede usarse, basta cualquier lista compuesta que devuelva un valor (por ejemplo, pueden usarse los comandos internos true o false). El valor de una lista compuesta es el valor del último comando simple ejecutado en la lista compuesta.

Un programa habitual que se utiliza como condición es el programa test. El comando test se puede ejecutar de dos formas (ambas equivalentes):

test expresion

[ expression ] #los [] deben estar separados

En la segunda forma los corchetes no son operadores ni indican que la expresión sea opcional, sino que realmente son el nombre del programa.

Puede ver la descripción del comando test según el estándar.

Como expresiones más habituales pueden usarse las siguientes:

Cualquiera de las condiciones anteriores puede ser precedida por el operador negación !, en cuyo caso la condición será cierta si no se satisface la comparación indicada. Por ejemplo, ! -d $DIR se cumplirá si $DIR NO es un directorio.

Asimismo, se permite crear condiciones múltiples mediante los operadores:

Recuerde las restricciones de sintaxis del shell en lo que respecta a los espacios, especialmente importantes en la escritura de las condiciones. Por ejemplo, la siguiente entrada dará error de sintaxis (el espacio tras ; sí puede omitirse):

Y la siguiente dará error porque buscaría el comando [comando] (incluyendo los corchetes como parte del nombre del comando), que en general no encontrará (mostrando un mensaje de orden no encontrada).

1. El comando test se puede ejecutar sin necesidad de utilizarlo en una estructura de control. Escriba la siguiente instruccion y analice su comportamiento (pruebe asignando también 1 a la variable V y una cadena de texto):
V=0; [ $V -eq 0 ] && { echo ES; echo 0; } || echo ES 1

2. El siguiente comando imprime por pantalla si el usuario actual es root. Ejecútelo como root y como un usuario normal:
if [ "`id -u`" -eq 0 ]; then echo ROOT; fi

3. Mire el contenido del siguiente script en su sistema y compruebe que tiene el permiso de ejecución:

4. Ejecute los comandos siguientes y analice el resultado:
rm -f /tmp/archivo

./script_if.sh

5. Ejecute ahora los comandos siguientes y vuelva a analizar el resultado:
touch /tmp/archivo

chmod -w /tmp/archivo

./script_if.sh

Presenta la siguiente sintaxis:

case cadena_texto in patron1) lista-compuesta1;; patron2) lista-compuesta2;; ... * ) lista-defecto[;;] #coincide con todo esac

cadena_texto debe aparecer obligatoriamente en la misma línea que la palabra reservada case (la palabra reservada in puede estar en la siguiente línea). En esta estructura, primero se expande cadena_texto (si es necesario) y busca el primer patrón que encaje con dicho valor. Cuando lo encuentre, ejecuta la lista-compuesta correspondiente y finaliza la estructura. Los patronN se interpretan como cadenas de caracteres y si es necesario se expanden (por ejemplo, pueden contener variables). Admite los mismos caracteres que los usados para la expansión de ruta (*, ? y []). Asimismo, pueden usarse patrones múltiples mediante el operador | y opcionalmente pueden comenzar con el paréntesis:

patronA | patronB)

(patronA | patronB)

El doble punto y coma ;; permite determinar el final de los elementos a interpretar cuando se cumpla su patrón asociado. Por ese motivo, el ;; del último patrón puede omitirse. Es posible añadir espacios entre los patrones y los paréntesis abiertos ) que marcan el final del patrón. Conforme a esto, serían sintaxis válidas alternativas las siguientes:

case cadena_texto in patron1) cmd1; cmd2;; esac

case cadena_texto in patron1 ) cmd1 cmd2 esac

case cadena_texto in patron1) cmd1; cmd2;; esac

case cadena_texto in (patron1) cmd1; cmd2; esac

1. Mire el contenido del siguiente script en su sistema y compruebe que tiene el permiso de ejecución:

2. Ejecute los comandos siguientes y analice el resultado:
./script_case.sh archivo

./script_case.sh file

./script_case.sh file.c

./script_case.sh file.c++

Presenta la siguiente sintaxis:

El nombre de la variable VAR debe aparecer obligatoriamente junto con la palabra reservada for en la misma línea. lista_valores debe estar obligatoriamente en la misma línea que la palabra reservada in. El punto y coma ; puede sustituirse por un salto de línea, y viceversa. Así, por ejemplo, serían sintaxis válidas las siguientes:

for VAR in lista_valores; do lista-compuesta done

for VAR in lista_valores do lista-compuesta done

for VAR in lista_valores do lista-compuesta done

lista_valores se corresponde con un conjunto de valores (tomándose cada valor como una cadena de caracteres que puede ser objeto de expansión y como caracteres de separación los caracteres definidos en la variable IFS). La estructura for define la variable VAR (si no ha sido previamente definida). Para cada uno de los valores del resultado de expandir lista_valores, la estructura inicializa la variable VAR con dicho valor y realiza una iteración (ejecutando lista-compuesta, en la cual suele ser habitual acceder al valor de la variable VAR).

Es posible omitir in lista_valores. Si se omite equivale a haber escrito: in "$@"

1. Ejecute el siguiente comando y compruebe como se puede utilizar una expansión de ruta dentro de un bucle for:
for i in ~/.*; do echo Fichero oculto: $i; done

2. Mire el contenido del siguiente script en su sistema, compruebe que tiene el permiso de ejecución, invóquelo y compruebe el contenido del fichero "ficherosalida" que crea: Mire el contenido del siguiente script en su sistema, compruebe que tiene el permiso de ejecución e invóquelo.

Suele ser habitual el uso del comando externo seq para generar una lista de valores. Si bien este comando no está recogido en el estándar POSIX, es habitual su presencia en la mayoría de los sistemas UNIX. El comando seq presenta la sintaxis:

seq valor_inicial valor_final

siendo ambos valores números enteros. La salida del comando es la secuencia de números enteros entre ambos valores extremos indicados.

1. Ejecute el comando siguiente y observe su salida:

2. Mire el contenido del siguiente script en su sistema, compruebe que tiene el permiso de ejecución general e invóquelo:
Compruebe cómo se obtiene el mismo resultado que se tenía al invocar el fichero script_for1.sh.

Presentan la siguiente sintaxis:

La lista-comp-condicion es una lista compuesta que se rige por las mismas directrices indicadas en la estructura if. La estructura:

while va iterando (interpreta la lista-compuesta) mientras se cumpla la condición indicada (lista-comp-condicion devuelve el valor 0)

until va iterando (interpreta la lista-compuesta) mientras NO se cumpla la condición indicada (lista-comp-condicion devuelve un valor distinto de 0).

Así, por ejemplo, serían válidas y equivalentes las sintaxis siguientes, si la condición del until es la condición del while negada:

while lista-comp-condW do cmd1 cmd2 done

until lista-comp-condU do cmd1 cmd2 done

while lista-comp-condW ; do cmd1; cmd2; done

while lista-comp-condW ; do { cmd1; cmd2; } done

1. Mire el contenido del siguiente script en su sistema, compruebe que tiene el permiso de ejecución e invóquelo:

2. Mire el contenido del siguiente script en su sistema, compruebe que tiene el permiso de ejecución e invóquelo:
Podrá comprobar cómo ambos scripts devuelven la misma salida.

Igual que en otros lenguajes de programación, como en el lenguaje C, es posible romper el funcionamiento normal de las estructuras repetitivas ( for, while y until). Sin embargo, hacerlo supone hacer código no estructurado. Por coherencia con lo visto en otras asignaturas, no se aconseja su uso.

En shell script esto se realiza con dos comandos internos: continue y break

Ambos son comandos internos de la shell con la siguiente sintaxis y funcionalidad:

1. continue: utilizado en estructuras de control repetitivas para detener la iteración actual y continuar con la siguiente. Su sintaxis es:
El parámetro opcional n es un número entero positivo que permite especificar la estructura de control en la que se desea detener la iteración. Si se tienen varias estructuras de control anidadas, la estructura actual en la que se encuentra el continue corresponde a la estructura 1; la estructura superior que engloba a ésta sería la estructura 2, y así sucesivamente. Así, el valor de n referencia a la estructura de control en la que deseamos detener la iteración actual y continuar con la siguiente (por omisión, "n=1").

2. break: utilizado en estructuras de control repetitivas para detener todas las iteraciones restantes de la estructura de control actual. Su sintaxis es:
El parámetro opcional n es un número entero positivo que permite indicar si se desean cancelar varias estructuras de control anidadas (por omisión, "n=1", que referencia a la estructura actual en la que se encuentra el break).

Presentan la siguiente sintaxis:

El paréntesis siempre debe estar vacío (sólo indica que se está definiendo una función). Pueden insertarse espacios antes, entre y después del paréntesis. El comando compuesto puede ser cualquier de los que se han visto (agrupación de comandos, estructuras condicionales, estructuras repetitivas). Opcionalmente pueden aplicarse redirecciones a la función (afecta a los comandos que contiene, salvo que contengan una redirección explícita). A continuación se muestran ejemplos básicos de definición de funciones:

fnombre(){ comando1 comando2 }

fnombre(){ comando1; comando2; }

fnombre() { comando1; comando2; }

En lo que se refiere al nombrado de las funciones, se aplican los mismos criterios antes expuestos para el nombrado de las variables.

El estándar permite que dentro de una función se invoque a otra. Los argumentos pasados a la función en su invocación son accesibles desde el cuerpo de la función mediante los parámetros posicionales $1, $2,..., $9, ${10},... Por tanto, dentro de la función, los parámetros posicionales no corresponden a los argumentos usados en la invocación del script.

Al igual que las variables, las funciones son:

Locales: sólo existen en el proceso shell en que son definidas.

Sólo son accesibles desde el momento de su definición hacia abajo del script, esto es, siempre deben definirse primero e invocarse después (no puede invocarse a una función que es definida más adelante).

Dentro de la función son visibles todas las variables y funciones definidas antes de su invocación. Y las variables definidas dentro de la función son visibles fuera tras la invocación de la función.

Dentro del cuerpo de la función suele ser habitual el uso del comando return, el cual provoca la salida inmediata de la función con el valor de retorno (número) indicado:

Mire el contenido del siguiente script en su sistema, compruebe que tiene el permiso de ejecución, invóquelo con 2 números enteros como argumentos y analice su funcionamiento :

Con objeto de alcanzar una mayor homogeneización entre los sistemas, el estándar POSIX recoge una lista de comandos que deben ser implementados en cualquier sistema, clasificándolos según sean ordenes internas del shell (built-in) o aplicaciones externas.

Los comandos internos corresponden a órdenes interpretadas por el propio shell (luego no existe ningún fichero ejecutable asociado al comando). Se distinguen dos tipos de comandos internos:

Especiales: un error producido al ejecutar este comando da lugar a que el shell termine. Por consiguiente, el script termina con un error y un valor de retorno mayor de cero (vea el apartado 2.8.2 del estándar para saber el valor de retorno).

Regulares: el shell no tiene que terminar cuando se produce un error en estos comandos.

En la siguiente tabla se recogen los comandos especiales definidos en el estándar.

Puede obtener más información en el estándar.

Como comandos internos regulares, el estándar define los siguientes:

Consulte el estándar para más información.

Entre dichos comandos (especiales y regulares), por su utilidad en los shell-scripts deben destacarse los siguientes:

La sintaxis de este comando es:

exit provoca la eliminación inmediata del proceso correspondiente al shell que está leyendo el script. El parámetro opcional es un número entero que corresponde al valor devuelto por el script. Si no se indica ningún parámetro, el valor devuelto por el script será el del último comando ejecutado.

1. Abra una consola de comandos. Mediante el comando su abra una sesión con el superusuario. Al abrir la sesión con root, se ha creado un nuevo proceso en memoria correspondiente al shell encargado del intérprete de comando en la sesión del root. Use el comando ps ax para localizar dicho proceso.

2. Ejecute el comando exit, volviendo al usuario normal. Esto habrá provocado la eliminación del proceso shell encargado de la línea de comandos como en la que trabajaba root. Ejecute de nuevo ps ax comprobando cómo dicho proceso ha desaparecido

3. Mire el contenido del script script_exit.sh, que deberá contener lo siguiente:

4. Compruebe que dispone del permiso de ejecución general. Vuelva a usar el comando su para abrir una sesión con el superusuario. Desde dicha sesión ejecute el comando anterior mediante las siguientes invocaciones:
/bin/bash script_exit.sh

./script_exit.sh

Ambas invocaciones provocan la creación de un subshell (un nuevo proceso shell) encargado de leer el script. Por ello, cuando se llega al comando exit se para la interpretación del script y dicho subshell es eliminado, volviendo al proceso shell padre correspondiente a la línea de comandos desde la que estábamos trabajando.

Ejecute el comando echo $? para comprobar cómo el script ha devuelto el código de error "3".

5. Ejecute los siguientes comandos:

script_exit.sh && echo Hola, comprobando que no se imprime la cadena Hola debido a que el script devuelve un código de error (>0).

script_exit.sh || echo Hola, comprobando que ahora sí se imprime.

Edite el script para que el comando exit devuelva cero (exit 0), y vuelva a invocar el comando script_exit.sh && echo Hola, comprobando que ahora también se imprime la cadena Hola.

6. Vuelva a invocar el script pero ahora mediante:
. script_exit.sh

Verá cómo la sesión del root se cierra automáticamente y vuelve a la sesión del usuario normal. Esto se debe a que en este caso no se está creando ningún nuevo subshell, sino que el propio shell de la línea de comandos del usuario root es el encargado de interpretar el script. Al llegar al comando exit, éste provoca la eliminación del proceso shell que lee el script, esto es, la eliminación de la sesión del usuario root.

Ejecute el comando echo $? para comprobar cómo el script ha devuelto el código de error 0 (sin error) correctamente.

7. Ejecute y analice el funcionamiento de los siguientes comandos:
sh -c "exit 0" && echo "Sin error1A" || echo "Con error1B"

sh -c "exit 1" && echo "Sin error2A" || echo "Con error2B"

El comando readread lee una línea de la entrada estándar (teclado) y la guarda en variables. Solo funciona en shell interactivos (leyendo la entrada del teclado), de lo contrario no hace nada. En su forma más básica, presenta la siguiente sintaxis:

read VAR1 [VAR2 ...]

Este comando espera a que el usuario introduzca una línea de texto incluyendo espacios (la entrada termina cuando el usuario pulsa la tecla "Intro"; la pulsación "Intro" no forma parte del valor asignado a la cadena). Esta línea se divide en campos (según la variable IFS). Tras ello, el comando define las variables dadas como argumentos, inicializándolas con los campos obtenidos en la división. Si hay más campos que variables, los campos restantes se asignan a la última variable. Si hay más variables que campos, las variables sobrantes reciben como valor la cadena vacía "".

Consulte la página del estándar para obtener más información.

Algunos intérpretes de comandos como bash añaden otras opciones a este comando, como la posibilidad de imprimir un mensaje usando la opción -p (vea la ayuda de read en bash con el comando man bash).

El comando read también puede ser útil, por ejemplo, para detener la interpretación del script hasta que el usuario pulse una tecla:

Resulta habitual el uso de estructuras while, combinadas con case y read, para crear menús interactivos, permitiendo mantenerse dentro del menú.

1. Edite el script script_case_menu.sh para que tenga el siguiente contenido:

#!/bin/sh
clear
SALIR=0
OPCION=0
while [ $SALIR -eq 0 ]; do
   echo "Menu:"
   echo "1) Opcion 1"
   echo "2) Opcion 2"
   echo "3) Salir"
   echo "Opcion seleccionada: "
   read OPCION
   case $OPCION in
       1)
           echo "Opcion 1 seleccionada" ;;
       2)
           echo "Opcion 2 seleccionada" ;;
       3)
           SALIR=1 ;;
       *)
         echo "Opcion erronea";;
   esac
done

El comando clear, tampoco recogido en el estándar POSIX, también suele encontrarse habitualmente en la mayoría de los sistemas UNIX. Su funcionalidad es, simplemente, limpiar la información impresa en la consola de comandos.

2. Ejecute el comando siguiente y seleccione las opciones del menú:
script_case_menu.sh

El comando eval construye un comando mediante la concatenación de sus argumentos (pueden ser variables, etc.) separados por espacios. Dicho comando construido es leído por el shell e interpretado. La sintaxis del comando es:

eval [argumentos ...]

Un posible uso es la creación de referencias indirectas a variables (parecido a usar punteros en lenguaje de programación C). En la tarea siguiente se muestra esto.

Los comandos externos corresponden a ficheros ejecutables externos al shell. Cualquier posible aplicación pertenecería a esta categoría de comandos ( ps, firefox, emacs,...). El estándar POSIX recoge una lista de comandos externos que aconsejablemente deberían estar en un sistema UNIX, clasificándolos en obligatorios u opcionales según se exija o no su implementación para satisfacer el estándar. Entre los comandos externos obligatorios, el estándar define los siguientes:

Busque información sobre el comando echo y printf. Ejecute los siguientes comandos y analice su funcionamiento:

echo -n Uno; echo Dos

echo -e "Uno\nDos"

printf "Hola %s. Adios %s\n" $NOMBRE $NOMBRE

Si bien la programación de shell-scripts no se puede depurar fácilmente, los shells suelen ofrecer algunos mecanismos en este aspecto. En concreto, tanto "bash" como "dash" ofrecen los siguientes argumentos, que pueden usarse simultáneamente:

También es posible depurar sólo parte del script insertando en él los siguientes comandos (pueden usarse igualmente en la propia línea de comandos):

1. Mire el contenido del siguiente script en su sistema y compruebe que tiene el permiso de ejecución general:

2. Invoque dicho script con las siguientes opciones de depuración y analice la salida:
/bin/bash script_depuracion.sh

/bin/bash -x script_depuracion.sh

/bin/bash -v script_depuracion.sh

/bin/bash -xv script_depuracion.sh

/bin/dash -x script_depuracion.sh

/bin/dash -v script_depuracion.sh

/bin/dash -xv script_depuracion.sh

3. Modifique el script para que tenga el siguiente contenido:

4. Invoque dicho script con los siguientes comandos y analice la salida:
script_depuracion2.sh

/bin/dash script_depuracion2.sh

/bin/bash script_depuracion2.sh

A continuación se le propone la creación de una serie de scripts. Para ello, será necesario tanto usar los conocimientos expuestos en este documento, como otros relativos a la administración de Linux:

1. Los ficheros /etc/profile (leído en el arranque del sistema y común para todos los usuarios), ~/.bashrc, ~/.bash_profile (leídos al abrir una sesión con el usuario correspondiente, no es necesario que existan ambos), usados para cargar las variables de entorno, son en realidad shell-scripts. Analice el contenido de dichos scripts y modifíquelos convenientemente para definir los alias:

alias red='ifconfig -a': para todos los usuarios del sistema.

alias casa='echo $PWD': sólo para el usuario normal.

alias sockets='netstat -l': sólo para el usuario root.

Repita lo anterior pero utilizando funciones en vez de alias.

2. Cree los siguientes scripts:

variables.sh: debe inicializar las variables CONFIG='-a', ARP='-n' y ROUTE.

funciones.sh: debe definir las funciones arranque_red() (encargada de activar la tarjeta "eth0"), parada_red() (encargada de desactivar la tarjeta eth0) y estado_red() (encargada de ejecutar los comandos ifconfig, arp y route aplicándoles los parámetros pasados a la función en los argumentos 1, 2 y 3, respectivamente).

script1.sh: debe importar las variables y funciones definidas por los dos scripts anteriores. Mostrará al usuario un menú en el que le pregunte si desea arrancar la red (invocando la función arranque_red()), pararla (función parada_red()) o mostrar su estado (función estado_red()). Debe comprobar si alguna de las variables CONFIG, ARP y ROUTE es nula y, en caso de serlo, permitirle al usuario escribir interactivamente (mediante la función read) los parámetros con los que invocar el comando correspondiente.

3. script_copy.sh: script que copie un fichero regular en otro, ambos pasados como argumentos. Si no se le pasan los argumentos, lo comprobará, y solicitará al usuario que los introduzca interactivamente.

4. script_print.sh: script que imprima en pantalla el contenido de un fichero de datos, o el contenido de todos los ficheros de un directorio, según se le pase como argumento un fichero regular o un directorio.

5. script_borrar.sh: script que borre con confirmación todos los ficheros pasados como argumentos.

6. script_sesiones.sh: script al que, pasándole el login de un usuario, devuelva cuántas sesiones tiene abiertas en el sistema.

7. script_mostrar.sh: script que para cada argumento que reciba (puede recibir una lista de argumentos) realice una de las siguientes operaciones:

Si es un directorio, ha de listar los ficheros que contiene.

Si es un fichero regular, tiene que imprimir su contenido por pantalla.

En otro caso, debe indicar que no es ni un fichero regular ni un directorio (por ejemplo, un fichero de bloques o de caracteres del directorio /dev).

8. script_ejecucion.sh: script que asigne el permiso de ejecución a los ficheros regulares o directorios pasados como argumento (puede admitir una lista de ficheros).

9. script_doble.sh: script que pida un número por teclado y calcule su doble. Comprobará que el número introducido es válido y, antes de terminar, preguntará si deseamos calcular otro doble, en cuyo caso no terminará.

10. script_tipos.sh: script que devuelva el número de ficheros de cada tipo (ficheros regulares o directorios) que hay en una determinada carpeta, así como sus nombres. Tendrá un único argumento (opcional) que será la carpeta a explorar. Si se omite dicho argumento, se asumirá el directorio actual. Devolverá 0 (éxito) si se ha invocado de forma correcta o 1 (error) en caso contrario.

11. script_user.sh: script que reciba como argumento el login de un usuario e imprima por pantalla la siguiente información: login, nombre completo del usuario, directorio home, shell que utiliza, número de sesiones actualmente abiertas y procesos pertenecientes a dicho usuario. El script debe permitir las siguientes opciones:

-p: sólo muestra la información de los procesos.

-u: muestra toda la información excepto la referente a los procesos.

--help: muestra información de ayuda (uso del script).

12. script_menu.sh: script que ofrezca al usuario un menú (con una opción para salir) desde el que el usuario pueda seleccionar cual de los scripts anteriores (apartados "b)" a "k)") quiere utilizar.

13. script_puerto.sh: script que reciba como argumento un número de puerto TCP (PUERTO) y comprobará si el valor es un número entero positivo en el rango "[1, 1023]", de modo que:

Si es así: el script analizará si los puertos TCP "PUERTO" y "PUERTO+1" del equipo local se encuentran a la escucha. Tras ello, imprimirá un mensaje indicando el estado obtenido. Para ello, puede analizar la salida del comando netstat.

En otro caso: imprimirá por pantalla un mensaje indicando que el valor indicado no es un puerto de sistema.

14. script_arp.sh: script que reciba como argumento un número entero, guardándolo en la variable POS_ARP. El script comprobará si el valor de la variable POS_ARP es un número entero positivo, de modo que:

Si es así: el script calculará el número de entradas que actualmente tiene la caché ARP del equipo, guardándolo en la variable NENTRADAS. Si el valor de POS_ARP es mayor que NENTRADAS, imprimirá por pantalla un mensaje tal como: Ninguna entrada en la posición POS_ARP. En caso de que POS_ARP sea menor o igual que NENTRADAS, imprimirá por pantalla un mensaje con la posición de la entrada ARP POS_ARP, seguido del contenido de dicha entrada ARP.

En otro caso: Imprimirá por pantalla un mensaje indicando que el valor indicado no es un número entero: Posición de entrada ARP no válida

Se solicitan dos posibles soluciones:

script_arp1.sh: Basada en el comando read y estructuras de control.

script_arp2.sh: Analizando la salida del comando arp mediante comandos de análisis de texto.

15. script_param.sh: Considere que en el shell actual se dispone de la variable:
VAR="nombre=v1&edad=v2&tlf=v3"
Escriba un shell-script que analice el valor de dicha variable y para cada uno de los parámetros extraiga su valor y lo imprima por pantalla. Por ejemplo, que la salida sea:
Cadena analizada: nombre=v1&edad=v2&tlf=v3 nombre: v1, edad: v2, tlf: v3.
Se solicitan dos posibles soluciones:

script_param1.sh: Usando la variable de entorno IFS.

script_param2.sh: Sin usar IFS.

Para facilitar el acceso a los distintos recursos del sistema (zona de almacenamiento en disco, teclado, pantalla, socket,...), el kernel de Linux vincula cada recurso con un fichero, real (espacio en disco) o virtual (en memoria, como /dev y /proc). Ejemplos habituales son:

Cuando un proceso necesita acceder a un recurso, debe realizar las siguientes operaciones:

1. Abrir el fichero correspondiente a dicho recurso: el proceso indica al sistema la ruta del fichero, especificando su intención de abrirlo para lectura (obtener información del recurso), escritura (enviar información al recurso) o lectura/escritura; el sistema concederá el tipo de acceso solicitado según las características del recurso (teclado, pantalla, ...) y los permisos que el usuario efectivo del proceso posea sobre el fichero. Como respuesta, el sistema devolverá al proceso el descriptor (o descriptor de fichero) con el que el proceso podrá acceder al fichero.

2. Acceder al fichero/recurso usando el descriptor suministrado por el sistema: el proceso indicará el descriptor al kernel, éste localiza el fichero y accede al recurso asociado.

Un descriptor no es más que un número entero "n", con las siguientes características:

Cada proceso tiene su propia tabla de descriptores para acceder a los recursos/ficheros; el fichero que un proceso tenga asociado al descriptor "n" es independiente del que puedan tener asociado para ese mismo descriptor los demás procesos del sistema. El conjunto de descriptores que tiene asociados un determinado proceso puede obtenerse con ls /proc/PID/fd/, cambiando PID por el identificador de dicho proceso.

Se dice que un descriptor es de entrada, salida o entrada/salida según el fichero al que esté asociado en ese instante (es posible cambiar el fichero al que está asociado un descriptor) haya sido abierto por el proceso que posee dicho descriptor para lectura, escritura o lectura/escritura, respectivamente.

Al trabajar con un intérprete de comandos encontramos que, de manera habitual, los comandos suelen imprimir su información en pantalla y obtenerla del teclado. Este funcionamiento se debe a los dos motivos siguientes:

1. Muchas aplicaciones, especialmente pensadas para ser usadas en modo consola, son programadas para que, por defecto (sus procesos):

datos del (recurso asociado al) descriptor "0": dado que éste es el descriptor del que convencionalmente las aplicaciones obtienen información, este descriptor suele denominarse "entrada estándar (a pesar de este nombre, dado su uso especial, internamente los descriptores "0, 1, 2" son de entrada/salida).

su información al (recurso asociado al) descriptor "1": dado que éste es el descriptor al que convencionalmente las aplicaciones envían su información, este descriptor suele denominarse "salida estándar".

su información de errores al (recurso asociado al) descriptor "2": dado que éste es el descriptor al que convencionalmente las aplicaciones envían su información de errores, este descriptor suele denominarse "salida de error estándar".

2. De forma habitual, el proceso (shell) de cualquier consola en modo comandos asocia el descriptor:
0: al recurso "teclado (siempre, a través del fichero asociado a esos dispositivos (/dev/uinput,...), que puede variar según su tipo).

Sobre este comportamiento habitual, los intérpretes de comandos de Linux permiten:

Modificar el fichero (recurso) asociado a cada descriptor estándar "0, 1, 2".

Asociar ficheros a los descriptores no estándar (3 y posteriores).

Para ello, la sintaxis a aplicar varía según el proceso sobre el que queramos establecer la nueva asociación fichero-descriptor sea el propio proceso shell que estamos utilizando, o sobre un comando (proceso hijo) invocado desde este shell (en programación C, por ejemplo, se realizaría con la función "open", entre otras).

Para ello se emplea el comando "exec", mediante las siguientes sintaxis:

Por ejemplo, el siguiente comando permite asociar el archivo /tmp/fichero con el descriptor "4":

exec 4< /tmp/fichero

A partir de ello, cada vez que queramos que un comando realice operaciones de lectura/escritura sobre ese archivo, podremos aplicar los operadores de redirección (detallados más abajo) con dicho descriptor (en lugar de usar el nombre del archivo). Por ejemplo, para que el comando ls; envíe su información a ese archivo:

Ello se consigue mediante la técnica de " redirección", basada en la siguiente sintaxis (es importante que no haya espacios entre n y op) :

comando [n]op fichero/descriptor

donde:

comando: comando sobre el que aplicar la redirección. Recuerde que, conforme a la sintaxis de los comandos simples, la redirección puede escribirse tanto después como antes del comando.

n (número entero, opcional): descriptor (asociado actualmente o no a algún fichero en el shell actual). POSIX exige que se soporten, al menos, los valores 0, 1,..., 9. El valor por omisión depende del operador empleado.

op: operador de redirección. Si se "escapa" el descriptor n se usará el descriptor por omisión (e.g. echo \2>fichero asumirá el descriptor 1). Si se escapa el operador de redirección, no se aplicará redirección alguna (e.g., echo 2\>fichero imprime 2\>fichero al recurso del descriptor 1)

fichero/descriptor; a asociar (según indique el operador) con el descriptor n descriptor.

Al aplicar esa redirección sobre el comando, para el descriptor n, el comando (el proceso hijo que se crea) no heredará (aún en el caso de ser n=0, 1 o 2) la asociación descriptor-fichero del proceso shell padre, sino que asociará a dicho descriptor n el "fichero" explícitamente indicado.

A continuación se resumen los operadores de redirección definidos por el estándar POSIX, agrupadas según operen sobre descriptores para entrada (lectura de fichero) o salida (escritura en fichero):

1. Redirecciones de entrada: por omisión, toman n=0 (entrada estándar).

Funcionalidad: El shell invoca comando como proceso hijo, configurándolo para que:

Asocie el descriptor de entrada (recuérde que, para abreviar, se está usando el calificativo "descriptor de entrada" para indicar que en ese instante el descriptor está asociado con un fichero abierto para lectura, pero puede cambiar) n; con fich (archivo regular). Por omisión n=0, esto es, cmd < fich hace que para el proceso cmd, el descriptor 0 quede asociado a fich para lectura.

Asocie el descriptor de entrada n con el mismo fichero al que actualmente está asociado el descriptor m. Dicho fichero estará así referenciado desde dos descriptores (duplicado de descriptores). m es obligatorio.

Cierre el descriptor de entrada n (elimina su asociación con el fichero al que actualmente esté vinculado). Si el descriptor no está asociado con ningún fichero, dará error.

Asocie el descriptor de entrada n con el recurso especial Here-Document (texto empotrado). Tras ejecutar la orden, aparecerá en consola el carácter >; el texto introducido a partir de entonces será guardado en el recurso Here-Document, terminando cuando se introduzca una línea que sólo contenga (incluidos espacios en blanco) la cadena delim (delimitador) y se pulse nueva línea; en dicho momento, comando será ejecutado (pudiendo acceder al contenido del recurso Here-Document a través del descriptor n). Si al escribir la orden, la cadena delim se introduce entre comillas, el shell las eliminará, de modo que para terminar de escribir en el recurso Here-Document, habrá que escribir la cadena delim sin comillas.

Ídem <<, pero las tabulaciones añadidas al principio de línea será omitidas, no insertándose en el recurso Here-Document.

2. Redirecciones de salida: por omisión, toman n=1 (salida estándar).

Funcionalidad: El shell invoca comando como proceso hijo, configurándolo para que:

Asocie el descriptor de salida n con fich (archivo regular). Por omisión n=1, esto es, cmd > fich hace que para el proceso cmd, el descriptor 1 quede asociado a fich. Si fich no existe, será creado; si existe, será limpiado previamente. Salvo que se haya activado en el shell la opción "no sobrescribir" con el comando set -C (recuerde que el comando set permite modificar el comportamiento del shell, incluyendo opciones y el valor de sus variables) en cuyo caso dará error.

Ídem >, sin limpiar previamente el fichero si existe (insertando al final del contenido existente).

Asocie el descriptor de salida n con el mismo fichero al que está asociado el descriptor m. Dicho fichero estará así referenciado desde dos descriptores (duplicado de descriptores). m es obligatorio.

Cierre el descriptor de salida n (elimina su asociación con el fichero al que actualmente esté vinculado). Si el descriptor no está asociado con ningún fichero, dará error.

3. Redirecciones de entrada/salida: por omisión, toman n=1 (salida estándar).

Funcionalidad: El shell invoca comando como proceso hijo, configurándolo para que:

Asocie el descriptor n de entrada y salida con fichero (archivo regular, será creado si no existe).

Además de las anteriores, existe un tipo especial de redirección denominado tubería o "pipeline", en la cual el "recurso" sería esa "tubería" que conecta dos descriptores. Esta redirección se basa en la siguiente sintaxis:

bajo la cual, el descriptor 0 de comando2 se asociaría con el descriptor 1 de comando1 (esto es, lo que comando1 envíe a su salida estándar será redirigido a la entrada estándar de comando2). Pueden usarse dos o más comandos separados por |.

A continuación se proponen varios ejemplos de redirección y su explicación:

cat < fichero

Por omisión cat tiene el recurso "teclado" asociado al descriptor 0 (POSIX). Con este comando, cat es invocado para que su descriptor 0 quede asociado al recurso fichero, de modo que cat toma la entrada de dicho fichero.

ls es invocado para que su descriptor 1 esté asociado a fichero (y no a la "pantalla" a que está asociado en el shell desde el que es invocado), esto es, ls envía su salida a fichero.

Toda la información escrita tras invocar el comando es guardada en el recurso especial Here-Document, pasándose al comando cat cuando se introduzca la línea fin y se pulse nueva línea.

El descriptor de salida de ls se conecta con el de entrada de more, de modo que toda la salida ls de entrega a more como entrada.

Adicionalmente a lo anterior, deben realizarse las siguientes aclaraciones sobre las redirecciones:

1. Las redirecciones son aplicables a cualquier comando, incluso a subshells (shell abierto desde otro shell), de modo que todos los comandos abiertos desde dicho subshell heredarán por defecto su asociación de los descriptores 0, 1, 2. Por ejemplo, si en un shell ejecutamos:
echo "Hola" > /tmp/fichero

/bin/bash < /tmp/fichero

este comando hereda la configuración del subshell, teniendo igualmente asociado el descriptor 0 con el archivo /tmp/fichero. El comando cat, al ser invocado sin argumentos, sigue el estándar POSIX, imprimiendo en el recurso asociado al descriptor 2 (la pantalla en este caso) la información obtenida del recurso asociado al descriptor 0, que en este caso será el archivo fichero; (y no el teclado). Consecuentemente, el resultado es que dicho comando cat imprime directamente por pantalla el contenido de fichero. El orden de lectura de los comandos es importante. Por ejemplo, (cat << fin) < fichero no hará que fichero se pase a cat, dado que < fichero no se aplicará hasta que no haya terminado el comando cat. Por ejemplo:

cat ["Ctrl-D" para terminar, que equivale a enviar EOF]

cat << fin [Teclear "fin" y Enter para terminar]

2. El orden en el que se escriban las redirecciones es importante, pudiendo cambiar el resultado. Por ejemplo, en el comando:

ls /tmp 2> file 1>&2 : sucedería lo siguiente (en este orden):

El descriptor 2 se asocia con file.

El descriptor 1 se asocia con el mismo fichero al que está asociado el descriptor 2, luego con file también.

Se ejecuta el comando ls, que enviará sus salidas estándar (1) y de errores (2) a file. En un comando simple, el comando siempre se ejecuta tras aplicar las posibles expansiones/sustituciones e interpretar las redirecciones (leyéndose en orden de izquierda a derecha).

1>&2 ls /tmp 2> file : sucederá lo siguiente (en este orden):

El descriptor 1 se asocia con el mismo fichero (o recurso, e.g. pantalla) al que actualmente esté asociado el descriptor 2.

El descriptor 2 se asocia con file.

Se ejecuta el comando ls, que enviará su salida de errores a file, y su salida estándar (1) con ese recurso (posiblemente pantalla) al que inicialmente estuviese asociado el descriptor 2.

3. Para redireccionar una información a "ninguna parte" se usa el fichero nulo /dev/null (fichero que podría considerarse asociado al recurso virtual "destructor de información") . Por ejemplo, el siguiente comando haría toda la información que ls envíe a la salida estándar (descriptor 1) y a la salida de errores (descriptor 2) sea enviada a /dev/null (se elimina):
ls -l /usr > /dev/null 2>&1

Ejecute y analice el funcionamiento de las redirecciones empleadas en los siguientes comandos:

cat << END > fichero : lee información del teclado, hasta que se introduce una línea con END. Entonces copia toda la información tecleada al archivo fichero.

ls -l /bin/bash ./script > fichero 2> error : redirige la salida estándar al archivo fichero y la salida de error al fichero error.

ls -l /bin/bash ./script > fichero 2>&1 : redirige las salidas estándar y de error al archivo fichero.

ls 2> /dev/null 1>&2 : redirige las salidas estándar y de error al archivo nulo.

Por último, advertir que la explicación anterior corresponde al estándar POSIX. Algunos intérpretes de comandos como Bash soportan otros operadores (además de los POSIX). A continuación se resumen algunos de los ofrecidos por Bash:

Descargar versión antigua en PDF

# data[].attributes.attachment_link.description
El intérprete de comandos o shell es un programa que permite a los usuarios interactuar con el sistema, procesando las órdenes que se le indican. Los comandos invocables desde el shell pueden clasificarse en internos (corresponden en realidad a órdenes interpretadas por el propio shell) y externos (corresponden a ficheros ejecutables externos al shell).

# data[].attributes.body
shell ............................................................. 2

Ayuda_1_UNIX_Comandos_Basicos.......... 7

comandos.comunes.en.linux................... 10

redirecciones.y.tuberias .......................... 22

usuarios.y.grupos .................................... 24

permisos_en_linux .................................... 32

dispositivos.en.linux ................................. 41

procesos.en.linux ...................................... 47

# data[].attributes.body
Automatización de procesos y tareas mediante Scripts en Windows y Linux

# data[].attributes.body
Guía rápida de comandos de Linux

# data[].attributes.attachment_link.readable_text
Como decíamos anteriormente, el CMD contempla diferentes usos. Se utiliza muy habitualmente, especialmente, entre programadores. Sus ventajas más destacables son:

Consume muy pocos recursos: No necesitarás mucho procesamiento de tu ordenador, pues se manejan únicamente con texto. Esto te permitirá realizar cualquier tarea de forma muy rápida.

Conciso y eficaz: Sabemos que un programa dispone de numerosas herramientas y funcionalidades ocultas. Sin embargo, mediante el comando correcto podrás acceder prácticamente a cualquier funcionalidad. Los comandos destacan por su simpleza y practicidad.

Utilizados por los profesionales: Tiene sentido que, al consumir tan pocos recursos y ser tan prácticos, cada vez más expertos en el campo de las ingenierías y las ciencias de la computación se decanten por utilizarlos. Con todo, esto no quiere decir que todos los profesionales lo empleen, simplemente es una tendencia que cada vez se ve más.

Fácil automatización: Como decíamos, su funcionamiento se basa principalmente en texto. Es por ello que es muy fácil unir varios comandos en uno formando scripts, o lo que es lo mismo, piezas de código con una función muy específica. De esta forma, es posible organizar archivos, por ejemplo, o aplicar una edición rápida a un documento concreto.

Productividad: conseguiremos ser más productivos a la hora de realizar diferentes tareas. Por ejemplo, a la hora de manipular archivos, por la vía de comandos es mucho más rápido. Como os decíamos, consumen menos recursos del ordenador y , por tanto, no irá lento.

Cómo abrirlos

Los usuarios para los que el CMD o símbolo del sistema es un gran desconocido se estarán preguntando: ¿y dónde está esta herramienta o programa? Aparece en muchos tutoriales y nos permite todo tipo de opciones gracias a los comandos que veremos más adelante, pero antes de saber cómo llevar a cabo los comandos necesitaremos saber cómo se abre. Por esto mismo os explicaremos las dos vías que existen para abrirlos en un PC:

Desde la barra de búsquedas

La opción más rápida para abrir CMD es buscarlo a través del ordenador y del botón de Inicio de Windows. Debemos saber que para abrir el CMD o la ventana del símbolo de sistema lo único que tenemos que hacer es escribir "símbolo del sistema" o "cmd" en la caja de la barra de búsqueda de la barra de tareas y hacer clic en la aplicación desde la lista de resultados. Para ello, ve al espacio de tu escritorio donde se sitúa el icono de Windows y escribe "símbolo del sistema".

Ventana de Ejecutar

La siguiente opción también es rápida y sencilla: abrimos la ventana de ejecutar, pulsando a la vez las teclas de Windows y R. Automáticamente nos aparecerá en la esquina inferior izquierda una ventana que en la parte superior pone "Ejecutar", junto a un texto que dice "Escriba el nombre del programa, carpeta, documento o recurso de internet que desea abrir en Windows ". En ese recuadro debemos escribir " cmd " y pulsar enter o Aceptar.

En algunas ocasiones, necesitaremos permisos de administrador para ejecutar alguna acción en el sistema, algo que nos puede ocurrir también desde la línea de comandos. Para ejecutar el CMD con permisos de administrador, debemos escribir "símbolo del sistema" o "CMD" en la caja de búsqueda de la barra de tareas y, sobre el resultado, hacemos clic con el botón derecho del ratón para seleccionar la opción Ejecutar como administrador.

Diferencias entre CMD y PowerShell

El CMD, símbolo del sistema o también conocido como Command prompt es un intérprete de línea de comandos que lleva acompañando al sistema operativo de Microsoft durante décadas. Tanto es así que es el Shell original para el sistema operativo Microsoft DOS y el Shell predeterminado en Windows hasta la compilación 14791 de Windows 10, momento en el que Windows Powershell pasó a ser la opción predeterminada del sistema.

Con el símbolo del sistema podemos lanzar o ejecutar comandos básicos, preparar scripts relativamente sencillos y realizar muchas de las tareas que podemos hacer desde la interfaz gráfica del sistema operativo de Microsoft. Ahora bien, cuando necesitamos realizar desarrollos más avanzados, acceder a ciertas áreas del sistema o automatizar tareas es donde aparece Windows PowerShell.

A medida que Windows ha ido avanzando y evolucionando, Microsoft también ha decidido incorporar una herramienta más moderna y potente al CMD o símbolo del sistema. Y es que Windows PowerShell es un lenguaje de scripts y Shell avanzado escrito en Microsoft .NET Framework y al que se han añadido ciertos cmdlets que permiten realizar tareas en segundo plano o incluso de forma remota, así como la automatización de tareas. Una herramienta más pensada para administradores de sistemas y que se perfila como el lógico reemplazo de CMD.

Comandos internos y externos

Los comandos internos son aquellos que se transfieren a la memoria en el momento en que se carga el sistema operativo. Se almacenan en un archivo y se pueden ejecutar sin tener que tener DOS en la unidad en la que estamos. Pueden ser COPY, RENAME, PATH y muchos otros. Por su parte, los externos se almacenan en archivos externos o independientes, por lo que se requiere que esté el archivo en la unidad por defecto para poder ejecutar la orden, como puede ser el caso de CHDSK o FORMAT, entre otros. Los comandos externos se pueden copiar de un disco al otro y cuentan con su propio nombre.

Ahora que sabemos en qué consisten, y que se suman a las órdenes básicas y redireccionamientos, vamos a comentar los principales comandos a los que vas a necesitar acogerte en algún momento, bien por necesidad o por decisión propia.

Comandos básicos CMD

Una vez que nos encontramos delante de la línea de comandos del CMD debemos saber que hay ciertos comandos y teclas que nos van a ayudar a sacarle el máximo partido. Hay algunos comandos muy básicos que son los primeros que debemos tener siempre a mano si queremos utilizar el CMD. Nos ayudarán a tareas sencillas.

Debes tener en cuenta que cualquier comando que utilices debe estar escrito a la perfección o copiado de la siguiente lista. Puede que un simple espacio o una barra mal colocada ya implique que lo que has escrito no sea reconocido y que no sirva para nada, así que vigila su escritura. Aunque puede variar en algún caso, siempre debemos escribir el comando aquí explicado y pulsar enter para ejecutarlo.

Es difícil aprenderte todos de memoria, pero hay algunos que conviene tener siempre presentes porque los utilizaremos muchas veces en nuestro ordenador. En cualquier caso, aquí siempre tendrás disponibles toda esa serie de comandos básicos CMD a la que echar mano en tu día a día de manera rápida:

Help

El primer comando que debemos aprender es el comando Help. Es el que más nos va a servir. Para ejecutar este comando, lo único que tenemos que hacer es escribir help en la línea de comandos y pulsar Enter. Automáticamente, veremos cómo nos aparece un listado de los comandos básicos que podemos utilizar en la consola del sistema y para qué sirve cada uno de ellos.

/?

Todos los comandos que ejecutemos requieren que tengan una sintaxis correcta para que se ejecuten sin problemas. Dado que no podemos memorizar todas y cada una de estas sintaxis, el propio CMD ofrece un comando para consultar la sintaxis de uso de cualquier comando. Para ello, lo único que tenemos que hacer es escribir el nombre del comando, dejar un espacio y a continuación escribir los caracteres /? y pulsar Enter. Por ejemplo, si queremos saber cuál es la sintaxis correcta para utilizar el comando cd, que más adelante veremos para qué sirve, tendremos que ejecutar cd /?. Automáticamente, veremos cómo nos aparece la sintaxis correcta que nos permite utilizar dicho comando.

CD

Por defecto, el símbolo del sistema se abre en la ruta C:Usersnombreusuario, sin embargo, puede que necesitemos movernos por otras carpetas o unidades del sistema para realizar las tareas oportunas. Para ello, vamos a usar el comando cd, que permite movernos entre carpetas:

Para entrar dentro de una carpeta en la ruta en la que estamos, lo único que tenemos que hacer es ejecutar el comando: cd nombrecarpeta.

Para ir directamente a una carpeta dentro de esa ruta sin tener que pasar por las carpetas previas podemos ejecutar: cd carpeta1carpeta2carpeta3.

Si por el contrario queremos retroceder, es decir, salir de una carpeta y volver a la que la contiene, entonces basta con ejecutar el comando cd.., mientras que si queremos salir de una sola vez a la raíz de la unidad donde nos encontramos, entonces tenemos que ejecutar cd.

Cambiar de unidad

Si disponemos de varias particiones o unidades en nuestro disco o tenemos conectado algún dispositivo de almacenamiento interno y queremos ir hasta esa unidad desde el símbolo del sistema, lo único que tenemos que hacer es escribir la letra de dicha unidad seguida de dos puntos y pulsar Enter desde la ruta donde estemos y automáticamente se seleccionará dicha unidad, por ejemplo E:.

DIR: Cuando estamos en una ruta determinada y queremos saber las carpetas o archivos que hay dentro de ella, al igual que podemos hacer desde el explorador de archivos en la interfaz gráfica de Windows, lo que tenemos que hacer es ejecutar el comando dir. Automáticamente se nos mostrará por línea de comandos todas las carpetas y archivos que contiene la carpeta en la que estamos. Para identificar lo que es una carpeta y un archivo basta con fijarnos si delante del nombre aparece <DIR>, lo cual indica que es un directorio o carpeta. Si es un archivo, a la izquierda del nombre aparecerá el tamaño del mismo.

CLS: Con este comando borramos todo lo que aparece en la línea de comando y quedará completamente limpio para que podamos empezar otra vez desde cero. Basta con escribir cls y pulsar Enter. Borra todos los comandos anteriores y sus respuestas como si acabaras de abrir el símbolo del sistema.

SYSTEMINFO: Como su propio nombre indica, este comando nos permite obtener información sobre nuestro ordenador y el sistema operativo que estamos usando. Con el simple hecho de ejecutar el comando, nos aparecerá por línea de comandos información del equipo como nombre del sistema, procesador, memoria RAM, placa base, almacenamiento disponible, BIOS, tarjeta de red, etc.

VER: Seguro que en más de una ocasión hemos necesitado saber la versión exacta que tenemos instalada de nuestro sistema operativo Windows. Pues bien, con el simple hecho de ejecutar el comando ver desde la línea de comandos, se nos mostrará la versión exacta de nuestro sistema. Es una función interesante cunado tenemos dudas y queremos buscar esta información en una fuente fiable.

EXIT: Si escribimos el comando exit y pulsamos Enter para ejecutarlo desde la línea de comandos, veremos cómo la ventana de CMD o símbolo del sistema se cierra automáticamente. Y es que el comando exit es el que tenemos que utilizar para cerrar la consola.

CONTROL PANEL: Una de las cosas que más de menos echan algunos usuarios de Windows 10 es la posibilidad de abrir de forma rápida y sencilla el panel de control. Desde la línea de comandos es posible hacerlo de forma muy rápida: con el simple hecho de ejecutar el comando control panel, automáticamente se nos abrirá la ventana del panel de control del sistema.

POWERCFG: Se trata de un comando muy útil, ya que crea un informe detallado del consumo de energía en un PC. Usando este comando, tenemos acceso a todas las funciones referentes al consumo de energía de nuestro equipo, las que están disponibles en el panel de control y otras más avanzadas. Muy útil sobre todo para ordenadores portátiles, ya que analiza la causa de que la batería esté durando menos de los normal y que, además, elabora un completo informe donde podemos consultar el estado de la batería.

Driverquery: Con este comando podrás conocer cuáles son los dispositivos que hay conectados en tu ordenador junto con el tipo de controlador, nombre, fecha de vínculo o directorio en que se encuentra instalado. Su importancia radica en que si tienes problemas con los controladores de tu ordenador puedes saber aquí cuáles están y cuáles no y así podrás tomar mejores decisiones al respecto.

Assoc: Este es uno de los comandos más básicos y comunes. Ayuda a asociar (como sugiere el nombre) algunas extensiones de archivo a algunos programas. Por ejemplo: cuando hacemos clic en .doc (extensión), el ordenador puede decidir que necesita asociarlo con Microsoft Word.

Comandos para manejar archivos y carpetas

Desde la línea de comandos también podemos crear nuevas carpetas y archivos, eliminarlos o mover archivos de una ruta a otra como hacemos desde el explorador de archivos de Windows. De esta forma, no tendremos que llegar a completar estas acciones desde la interfaz del ordenador, por lo que podremos ahorrar tiempo y recursos del equipo.

Y no solo esto, sino que también podemos crear copias de seguridad sin necesidad de ir tocando el ratón (clic derecho, copiar). Puedes gestionar todos los archivos o carpetas del ordenador desde este CMD que ya te hemos enseñado a usar de forma básica. Es algo más complicado que lo anterior, pero solo será cuestión de ir acostumbrándose.

MD: Si lo que queremos es crear una nueva carpeta o directorio dentro de una ruta desde la línea de comandos, lo único que tenemos que hacer es ir hasta dicha ruta y una vez ahí ejecutamos el comando: md nombrecarpeta. Sustituimos nombrecarpeta por el nombre que queramos dar al nuevo directorio. Si queremos crear una ruta de subcarpetas dentro de una carpeta, el comando es el mismo, pero en lugar de indicar el nombre de la carpeta, tendremos que escribir la ruta con el nombre de las subcarpetas. Por ejemplo: md carpeta1carpeta2carpeta3.

RD: Para borrar alguna carpeta, lo primero que debemos hacer es asegurarnos de que dicho directorio esté vacío, ya que en ese caso no nos permitirá eliminar la carpeta. Una vez que la carpeta está vacía, desde la ruta que contiene a esa carpeta tendremos que ejecutar el comando: rd nombrecarpeta

COPY: Copy es el comando que nos permite copiar archivos, es decir, copiar un archivo de un directorio a otro. El comando a ejecutar si queremos mover el archivo1.ext a la carpeta pruebas, dentro de la ruta donde estamos, es copy archivo1.ext pruebas. Ahora bien, también podemos copiar el archivo1.ext a la carpeta pruebas, pero con otro nombre archivo2.ext, en este caso el comando a ejecutar es: copy archivo1.ext pruebasarchivo2.ext
El comando copy también nos puede servir para crear un archivo de texto dentro de cualquier carpeta desde el CMD. Para ello, lo único que tendremos que hacer es escribir y ejecutar el comando copy con nombrearchivo.txt. Nada más pulsar la tecla Enter para ejecutar el comando, se nos quedará el cursor justo en la línea de debajo y entonces podemos comenzar a escribir lo que queremos que contenga el archivo txt que vamos a crear. Para indicar que hemos finalizado, pulsamos Ctrl+Z y pulsamos Enter y ya podremos comprobar cómo dentro de la ruta indicada ya aparece el fichero de texto que acabamos de crear con el texto indicado.

XCOPY: Para copiar todos los archivos de un directorio o carpeta a otra vamos a utilizar el comando xcopy. De esta forma, podemos ejecutar: xcopy carpeta1 carpeta2. Veremos cómo los archivos de la carpeta1 se copian a la carpeta2. Si al final del comando añadimos el parámetro /S, estaremos indicando que se copien directorios y subdirectorios, excepto los que están vacíos. Si añadimos el parámetro /E, entonces se realizará la copia de todos, incluidos los vacíos.

MOVE: El comando move nos permite, como su propio nombre indica, mover archivos y carpetas en CMD. La sintaxis de este comando nos permite mover archivos de una carpeta a otra, incluso una carpeta y su contenido dentro de otra carpeta. Si lo que queremos es mover un archivo a otra carpeta, vamos desde el símbolo del sistema a la carpeta donde se encuentra el fichero que queremos cambiar de ubicación y ejecutamos el comando move archivo.ext carpeta1. Si el destino está en una ruta distinta, entonces podemos usar el comando de la siguiente manera: move archivo.ext c:rutadestino
También tenemos que saber que Move nos permite mover un archivo a otra ubicación y a la vez cambiarlo de nombre, el comando en esta ocasión sería: move archivo.ext C:rutadestinonombrenuevo.ext

FSUTIL FILE CREATENEW: Para crear otro tipo de archivos, por ejemplo, un documento de Word, desde el símbolo del sistema, vamos a echar mano del comando fsutil file createnew de la siguiente manera. Fsutil file createnew C:rutanombrearchivo.ext NNN, donde C:ruta debe ser sustituido por la ruta donde queremos crear dicho archivo, nombrearchivo.ext debe indicar el nombre y extensión del mismo y NNN el tamaño con el que queremos crear el documento de Word o tipo de archivo que sea.

DEL: Para eliminar o borrar un archivo, vamos a utilizar el comando del. Para ello, nos movemos hasta la ruta donde se encuentra dicho archivo y ejecutamos: del nombrearchivo.ext. Automáticamente el archivo quedará eliminado de dicha ruta.

REN: El comando ren nos permite renombrar tanto archivos como carpetas. En el caso que queramos cambiar el nombre de un archivo, nos situaremos sobre la carpeta que lo contiene y ejecutaremos: ren nombrearchivo.ext nombrenuevo.ext. Para renombrar una carpeta el comando sería igual, pero sin especificar la extensión: ren carpeta1 carpeta2

TREE: Aunque el comando dir mencionado anteriormente nos muestra un listado de todo lo que contiene una carpeta, puede que en muchas ocasiones queramos ver el árbol de directorios y su contenido desde el CMD o símbolo del sistema. Para ello, podemos echar mano del comando tree que, si lo ejecutamos tal cual, nos devolverá el árbol de carpetas por debajo de la ruta donde estamos, pero que, si lo ejecutamos como tree /f, además nos mostrará todos los archivos que contiene cada uno de los directorios en forma de árbol.

TYPE: Al igual que podemos crear un archivo de texto fácilmente desde la línea de comandos, es posible ver su contenido gracias al comando type. Para ello, basta con escribir: type archivo.txt
Automáticamente se nos mostrará el contenido del archivo de texto en la consola. Este comando permite pasar dos parámetros, es decir, dos archivos de texto, por lo que podremos ver el contenido de dos archivos con ejecutar un único comando: type archivo1.txt archivo2.txt

FORMAT: Aunque hay que tener mucha precaución con el uso de este comando, cabe mencionarlo para evitar problemas. Se trata del comando que permite formatear una unidad de nuestro disco duro desde la línea de comandos. Su sintaxis es muy sencilla: format c:

WINGET: La herramienta de línea de comandos winget permite a los usuarios detectar, instalar, actualizar, quitar y configurar aplicaciones en equipos con Windows 10 y Windows 11. Esta herramienta es la interfaz cliente para el servicio del Administrador de paquetes de Windows.
Después de instalar Instalador de aplicación, puedes ejecutar winget si escribes "winget" desde un símbolo del sistema. Uno de los escenarios de uso más comunes es buscar e instalar una herramienta favorita.
Para buscar una herramienta, escribe winget search <nombre de la app>. Una vez que hayas confirmado que la herramienta que quieres está disponible, puedes instalar la herramienta escribiendo winget install <nombre del programa>. La herramienta winget iniciará el instalador e instalará la aplicación en tu PC.
Esta herramienta también es realmente útil paraactualizar de golpe todas las aplicaciones y programas pendientes de tener la versión última. Para este proceso, realiza las siguientes acciones en CMD:

Primero comprueba qué programas pueden actualizarse.

Para ello, ejecuta el siguiente comando: "winget update".

Es posible que te solicite en primer lugar que aceptes una serie de permisos con la pregunta ¿Está de acuerdo con todos los términos de los contratos de origen?. Pulsamos Y para la respuesta afirmativa y continuamos.

Una vez que te haya devuelto la lista completa de aplicaciones a actualizar, puedes introducir otro código para que se encargue de tener todas en la última versión.

En este caso, el comando a introducir será "winget update -all".

Comandos básicos de red e Internet

Si quieres gestionar mejor tu red, lo primero que tienes que hacer es conocer cuáles son los comandos básicos que existen, cuál es su sintaxis y cómo funciona cada uno de ellos para saber qué es lo que puedes hacer y cuál te puede ser más útil.

Por eso, te mostramos algunos comandos que puedes necesitar. Descubre cuáles son y cómo funcionan, con el paso del tiempo te familiarizarás con ellos y encontrarás la mejor manera de usarlos a tu conveniencia. Estos son los comandos básicos de red a tener en cuenta en todo momento:

ipconfig

Es uno de los comandos más útiles y utilizados, ya que nos ofrece información muy importante. Nada más ejecutar dicho comando, se nos mostrará en la línea de comandos información sobre los valores de configuración de red TCP/IP, dirección IP, puerta de enlace predeterminada, datos de nuestro adaptador de red, etc.

Su sintaxis es: ipconfig [/allcompartments] [/? | /all | /renew [adaptador] | /release [adaptador] | /renew6 [adaptador] | /release6 [adaptador] | /flushdns | /displaydns | /registerdns | /showclassid adaptador | /setclassid adaptador [id._clase] | /showclassid6 adaptador | /setclassid6 adaptador [id._clase] ]

Opciones del comando:

ipconfig: Muestra la información.

ipconfig /all: Muestra información detallada.

ipconfig /renew: Renueva todos los adaptadores.

ipconfig /renew EL*: Renueva cualquier conexión cuyo nombre comience con EL.

ipconfig /release *Con*: Libera todas las conexiones coincidentes, por ejemplo: "Conexión cableada Ethernet 1" o "Conexión cableada Ethernet 2".

ipconfig /allcompartments: Muestra información sobre todos los compartimientos.

ipconfig /allcompartments /all: Muestra información detallada sobre todos los compartimientos.

ipconfig /flushdns: Vaciar la caché DNS.

ping

Es otro de los comandos de red más básicos y utilizados. Nos permite probar el estado de la comunicación del host local con uno o varios equipos remotos de una red IP. Por medio del envío de paquetes ICMP, diagnostica el estado, velocidad y calidad de una red determinada. Muy útil también para identificar problemas de red.

Al ejecutar este comando de red seguido de una dirección IP o URL de internet, veremos si el servidor de destino responde indicando la latencia y los paquetes perdidos.

Su sintaxis es:

ping [-t] [-a] [-n count] [-l size] [-f] [-i TTL] [-v TOS] [-r count] [-s count] [[-j host-list] | [-k host-list]] [-w timeout] [-R] [-S srcaddr] [-c compartment] [-p] [-4] [-6] nombre_destino

Ejemplos de uso de ping:

ping -a 10.0.99.221: sirve para probar el destino 10.0.99.221 con 10 mensajes 'Echo Request', cada uno de los cuales tiene un campo data de 1000 bytes.

ping -n 10 -l 1000 10.0.99.221: sirve para probar el destino 10.0.99.221 y registrar la ruta de cuatro veces.

ping -j 10.12.0.1 10.29.3.1 10.1.44.1 10.0.99.221: sirve para probar el destino 10.0.99.221 y especificar la ruta de origen de 10.12.0.1-10.29.3.1-10.1.44.1.

ping -n 5 8.8.8.8: con este comando se lanza una solicitud a la dirección 8.8.8.8, que representa el DNS de Google. Este siempre debería responder. Por tanto, si funciona, podemos deducir que la información ha llegado correctamente y existe buena conectividad.

tracert

Este comando permite determinar o conocer la ruta que toma un paquete de protocolo de Internet (IP) para llegar a su destino. TRACERT envía el primer paquete de eco con un TTL de 1 y aumenta el TTL en 1 en cada transmisión posterior, hasta que el destino responde o hasta que se alcanza el TTL máximo.

Su sintaxis es:

tracert [-d] [-h saltos_máximos] [-j lista_de_hosts] [-w tiempo_de_espera]
[-R] [-S srcaddr] [-4] [-6] nombre_destino

Ejemplos de uso de tracert

tracert corp7.microsoft.com: sirve para rastrear la ruta de acceso al host local de microsoft.com.

tracert -d corp7.microsoft.com: sirve para rastrear la ruta al host local de microsoft.com y evitar la resolución de cada dirección IP a su nombre.

tracert -j 10.12.0.1 10.29.3.1 10.1.44.1 corp7.microsoft.com: sirve para trazar la ruta al host local de microsoft.com y utilizar la ruta de origen 10.12.0.1-10.29.3.1-10.1.44.1.

Más opciones del comando:

-d: No convierte direcciones en nombres de hosts.

-h: saltos_máximos Máxima cantidad de saltos en la búsqueda del objetivo.

-j: lista-host Enrutamiento relajado de origen a lo largo de la lista de hosts (solo IPv4).

-w: tiempo_espera Tiempo de espera en milisegundos para esperar cada respuesta.

-R: Seguir la ruta de retorno (solo IPv6).

-S srcaddr: Dirección de origen para utilizar (solo IPv6).

-4: Forzar usando IPv4.

-6: Forzar usando IPv6.

clip

Hasta ahora seguro que para copiar el texto que te aparecía en el símbolo del sistema tras el resultado de ejecutar algún comando, lo que hacías era seleccionar este texto y utilizar la combinación de teclas Ctrl + C. Pues bien, debes saber que vamos a poder ejecutar el comando y a la vez copiarlo en el portapapeles con un simple comando, que es clip.

Por ejemplo, podemos probar con el comando ipconfig, que seguro que ya conocéis porque es muy utilizado para todas las gestiones relacionadas con la configuración de nuestra dirección IP y otras funciones de red. Lo único que tenemos que hacer es, después de haber tecleado ipconfig (o el comando que queráis), pero antes de darle a Intro, escribir dejando un espacio lo siguiente " | clip". El símbolo "|" lo obtenemos con la combinación de teclas AltGr + 1 (no confundir con la barra invertida que se obtiene con Shift + 7). De modo que el código completo quedaría así: ipcongig | clip.

Una vez hecho esto, además de haber ejecutado el comando ipconfig, también hemos copiado en nuestro portapapeles todo lo que aparece en la pantalla del símbolo del sistema. Ahora sólo tienes que ir hasta Word, el Bloc de notas, un correo, o donde quieras, y copiar el texto con Ctrl + V o clic derecho del ratón y seleccionar "pegar". Ya verás como ahora que conoces este uso del CMD vas a usarlo más.

getmac

Como su propio nombre indica, este comando de red de CMD muestra las direcciones MAC de los adaptadores de red instalados en el sistema. Es decir, nos va a devolver la MAC del equipo donde lo ejecutamos. Recordemos que la dirección MAC es un identificador de 48 bits que corresponde de forma única a una tarjeta o dispositivo de red. También se la conoce como dirección física y es única para cada dispositivo.

Su sintaxis es: getmac [/S sistema [/U nombre_usuario [/P [contraseña]]]] [/FO formato] [/NH] [/V]

Parámetros de getmac:

/S sistema: Especifica el sistema remoto al que conectarse. /U [dominio]usuario Especifica el contexto de usuario con en el que el comando se debe ejecutar.

/P [contraseña]: Especifica la contraseña para el contexto de usuario dado. Pide entrada si se omite.

/FO formato: Especifica en qué formato se va a mostrar la salida. Valores válidos: "TABLE", "LIST" y "CSV".

/NH: Especifica que el "encabezado de columna" no debe mostrarse en la salida. Solo se usa con los formatos TABLE y CSV.

/V: Especifica que se muestra la salida detallada.

arp

Muestra y modifica las tablas de conversión de direcciones IP en direcciones físicas que utiliza el protocolo de resolución de direcciones (ARP). Resulta muy útil para visualizar la caché de resolución de direcciones.

Los formatos de uso de arp son:

arp -s inet_addr eth_addr [if_addr]
arp -d inet_addr [if_addr]
arp -a [inet_addr] [-N if_addr] [-v]

Ejemplos de uso de arp:

arp -a -N 10.0.0.99: sirve para mostrar las tablas de caché del protocolo de resolución de direcciones de todas las interfaces.

arp -a -N 10.0.0.99: muestra la tabla de caché del protocolo de resolución de direcciones de la dirección IP 10.0.0.99.

arp -s 10.0.0.80 00-AA-00-4F-2A-9C: para añadir una entrada de caché estática del protocolo de resolución que resuelva la dirección IP 10.0.0.80 a la dirección física 00-AA-00-4F-2A-9C.

nslookup

El comando nslookup se utiliza para saber si el DNS está resolviendo correctamente los nombres y las IPs. Es decir, nos permite consultar de forma manual los servidores de nombres para resolver un nombre de host. Por lo tanto, permite conocer la dirección IP detrás de un determinado nombre de dominio.

Uso de nslookup:

nslookup [-opt ...] # modo interactivo que usa el servidor predeterminado.

nslookup [-opt ...] - servidor # modo interactivo que usa 'servidor'.

nslookup [-opt ...] host # solo consulta 'host' mediante el servidor predeterminado.

nslookup [-opt ...] host servidor # solo consulta 'host' mediante 'servidor'.

route

El comando de red de CMD route nos permite visualizar y modificar la tabla de rutas en un servidor. De esta manera, podremos llevar un mejor control sobre la tabla de enrutamiento del sistema.

route [-f] [-p] [-4|-6] comando [destino] [MASK máscara_red] [puerta_enlace] [METRIC métrica] [IF interfaz]

Opciones del comando más habituales:

-n: Muestra la tabla de enrutamiento en formato numérico [dirección IP].

-e: Muestra la tabla de enrutamiento en formato hostname.

add: Añade una nueva ruta a la tabla de enrutamiento.

del: Elimina una ruta de la tabla de enrutamiento

netsh

En primer lugar, hay que saber que Netsh es un comando que nos ofrece varias opciones para la configuración de nuestra red, como modificar, administrar, diagnosticar la configuración de una red o cambiar la configuración de nuestros interfaces de red, tanto para IPv4 como para IPv6. Además, debemos tener en cuenta que Netsh también proporciona una característica de scripting que permite ejecutar un grupo de comandos en modo de lotes con un equipo concreto. Su sintaxis es:

netsh [-a ArchAlias] [-c Contexto] [-r EquipoRemoto] [-u [NombreDominio]NombreUsuario] [-p ontraseña | *] [Comando | -f ArchivoScript]

hostname

El comando hostname muestra el nombre del host local actual. Se trata probablemente de uno de los comandos de red más sencillos y usados.

Si no cuentas con una IP específica para conectarte a un host dentro de una red donde comparten un segmento de red, es posible hacerle a través del nombre del host. En este caso, para ejecutarlo debemos teclear en la consola hostname.

La sintaxis del comando es:

hostname [-a | -d | -f | -h | -i | -s]

Si bien los anteriores comandos nos ofrecen información interesante para saber cómo gestionar nuestras redes y nos permiten hacerlo con mayor eficacia, también es interesante conocer aquellos que nos ofrecen estadísticas relevantes que debemos valorar y analizar. Por eso, también comentamos los comandos más básicos que debes conocer con respecto a las estadísticas. Estas te permitirán conocer ciertos datos, pero también solucionar algunos problemas.

pathping

Combina la utilidad de ping y tracert, aunque se trata de más un comando informativo. Proporciona información sobre la latencia de la red y la pérdida de la red en saltos intermedios entre una fuente y un destino. Es decir, después de enviar los paquetes a un determinado destino, se analiza la ruta y se calcula la pérdida de paquetes.

Podríamos decir que, de manera similar a tracert, pathping envía ping de forma periódica a los enrutadores durante un tiempo determinado y calcula las estadísticas en función del número devuelto de cada uno.

La sintaxis es:

pathping [-g lista_host] [-h saltos_máx] [-i dirección] [-n] [-p período] [-q núm_consultas] [-w tiempo_espera] [-4] [-6] nombre_destino

Opciones del comando:

-g lista_host: Ruta de origen no estricta en la lista de host.

-h saltos_máx: Número máximo de saltos para buscar en el destino.

-i dirección: Utilizar la dirección de origen especificada.

-n: No resolver direcciones como nombres de host.

-p período: Período de espera en milisegundos entre llamadas ping.

-q núm_consultas: Número de consultas por salto.

-w tiempo_espera: Tiempo de espera en milisegundos para cada respuesta.

-4: Fuerza utilizando IPv4.

-6: Fuerza utilizando IPv6.

netstat

Netstat es el comando de red del CMD que, como su nombre indica, muestra estadísticas de protocolo y conexiones de red de TCP/IP actuales. Concretamente, muestra un listado de las conexiones activas en nuestro ordenador, tanto entrantes como salientes, incluyendo datos como el protocolo utilizado, tablas de ruteo, estadísticas de las interfaces o el estado de la conexión.

Su sintaxis es:

netstat [-a] [-b] [-e] [-f] [-n] [-o] [-p proto] [-r] [-s] [-x] [-t] [intervalo]

Ejemplos de uso de netstat

netstat -e -s: este comando sirve para mostrar las estadísticas de Ethernet, así como la del resto de protocolos y conexiones de red.

netstat -s -p tcp udp: si escribimos este comando, tendremos acceso a las estadísticas únicamente de los protocolos de tipo TCP y de tipo UDP.

netstat -o 5: sirve para mostrar las conexiones TCP que se encuentran activas y los códigos ID de los procesos cada cinco segundos.

netstat -n -o: el comando sirve para mostrar las conexiones TCP activas, así como los códigos ID de todos los procesos mediante la utilización de la forma numérica.

NBTStat

Este comando muestra estadísticas del protocolo y conexiones TCP/IP actuales utilizando NBT o lo que viene a ser NetBIOS sobre TCP/IP. Muy útil para solucionar problemas con la resolución de nombres llevada a cabo por NetBIOS.

La sintaxis del comando es:

nbtstat[ [-a Nombreremoto] [-A dirección IP] [-c] [-n] [-r] [-R] [-RR] [-s] [-S] [intervalo] ]

Opciones del comando:

-a: (estado del adaptador) Lista la tabla de nombres de máquinas remotas dado su nombre.

-A: (estado del adaptador) Lista la tabla de nombres de máquinas remotas dada su dirección IP.

-c: (caché) Muestra la caché global de nombres remotos incluyendo las direcciones IP.

-C: (caché) Muestra la caché global de nombres remotos con direcciones IP por dispositivo.

-n: (nombres) Muestra nombres locales NetBIOS.

-r: (resueltos) Muestra los nombres resueltos por difusión y vía WINS.

-R: (Recargar) Purga y vuelve a cargar la tabla caché de nombres remotos.

-S: (Sesiones) Muestra tablas de sesiones con las direcciones IP de destino.

-s: (sesiones) Muestra las tablas de sesiones para convertir las direcciones IP de destino a nombres de host usando el archivo hosts.

-RR: (LiberarActualizar) Envía paquetes de liberación de nombres a WINS y luego inicia la actualización.

Nombre remoto: Nombre de la máquina de host remota.

Dirección IP: Representación de la dirección IP con separación de punto decimal.

Intervalo: Vuelve a mostrar las estadísticas seleccionadas, indicando la pausa en segundos entre cada muestra. Presione Ctrl+C para interrumpir el ciclo de estadísticas.

Bitsadmin

Bitsadmin es una herramienta de línea de comandos que se usa para crear, descargar o cargar trabajos y supervisar su progreso. Funciona en Windows Server 2022, Windows Server 2019, Windows Server 2016, Windows Server 2012 R2, Windows Server 2012, Windows 10. Hay varias modificaciones disponibles de este comando, varias de ellas que inician con bitsadmin /cache, aunque hay muchas más.

Cómo crear, habilitar y deshabilitar usuarios

El hecho de compartir el ordenador con otras personas hace que sea necesario crear nuevas cuentas de usuario. Esto es algo que el propio Windows nos permite hacer desde la configuración del sistema (suele ser más rápido), pero también podemos gestionar nuestras cuentas de usuario desde el símbolo del sistema o CMD.

Net user es el comando que nos va a facilitar la tarea de crear una cuenta de usuario en el sistema. Su sintaxis es muy sencilla, pero siempre podemos consultarla ejecutando net user /?. De cualquier forma, para crear una nueva cuenta de usuario tendremos que ejecutar: net user Usuario Contraseña /add. Usuario y Contraseña se deben sustituir por el nombre de usuario que queramos crear y la contraseña a utilizar. Este mismo comando nos permite también habilitar o deshabilitar una cuenta de usuario, para ello utilizaremos el comando de la siguiente manera: net user Usuario /active:no o net user Usuario /active:yes

Además de los básicos y los que te permiten conocer estadísticas relevantes, hay varios comandos que conviene que conozcas y que puedes usar para controlar otros equipos remotos o configurar recursos compartidos. Puede que no los necesites tanto como los anteriores, pero no está de más conocerlos.

Net Use. Este es un comando que se usa para conectarte, configurar y eliminar conexiones a recursos compartidos como impresoras de red y unidades asignadas. Hay otros como net send, net user, net view, net time y otros. Podrás conectarte a discos de equipos remotos y loguearte en Internet.

Taskkill. Este comando te permite finalizar tareas o procesos en ejecución, lo que es interesante para finalizar procesos en equipos remotos. Tasklist /V da información detallada de cada tarea ejecutándose; Tasklist /SVC da información adicional de los servicios hospedados en cada proceso; Tasklist /FO formato especifica el formato de salida; Tasklist /M modulo muestra todas las tareas que usan un módulo DLL o EXE especificado; y Tasklist /FI filtro filtra la información dolitada con un criterio específico.

Shutdown. Este es un comando mediante el que podrás reiniciar o apagar ordenadores remotos o locales, de uno en uno. Si quieres apagar un equipo tienes que escribir shutdown -s, mientras que si quieres hacerlo en cierto límite de tiempo deberás escribir shutdown -s -t Tiempo (tiempo determinado en milisegundos). Para cerrar sesión deberás escribir shutdown -l y para reiniciar shutdown -r.

Telnet. Este permite abrir la comunicación con un equipo remoto que ejecuta el servicio del servidor telnet, por lo que se requiere que esté instalado antes de ejecutarlo.

Comandos para solucionar algunos errores del sistema

Al igual que encontramos algunos reparadores de errores en la interfaz gráfica de Windows, el sistema operativo de Microsoft cuenta con otras herramientas basadas en comandos que nos permiten reparar o solucionar ciertos problemas en el sistema.

DISM: Son las siglas de Deployment Image Servicing and Management y hacen referencia a una herramienta desarrollada por Microsoft, basada en la línea de comandos que nos permite realizar el mantenimiento y preparación de las imágenes del sistema.
Los comandos DISM nos permiten capturar y aplicar imágenes de Windows, añadir o eliminar imágenes de un archivos .win o incluso dividir archivos .win en otros más pequeños. Para realizar un análisis de una imagen de Windows con el fin de detectar errores o archivos corruptos podemos ejecutar el comando:Dism /Online /Cleanup-Image /ScanHealth.
Como siempre, podemos ver el resto de opciones y parámetros ejecutando dism /?. Hay que tener en cuenta que para usar la herramienta DISM, tendremos que abrir el símbolo del sistema o CMD con permisos de administrador.

SFC: Otro comando interesante en este sentido es SFC, que nos permite buscar archivos dañados del sistema y en caso de encontrarlos, automáticamente tratará de repararlos o sustituirlos. Su uso es muy sencillo, lo único que tenemos que hacer es abrir una ventana del símbolo del sistema con permisos de administrador y a continuación ejecutar sfc /scannow. Ahora, solo tenemos que esperar a que el proceso finalice, ya que tratará de reparar cualquier archivo del sistema dañado de forma automática.

FC: Otro comando muy común utilizado es FC, también conocido como Comparación de archivos. Esta es una característica interesante que permite comparar archivos que se han modificado a lo largo del tiempo. Este comando incluye algunos parámetros para que sea más exacto:

Parámetro- /a: este parámetro ayuda a precisar la salida cuando se realiza una comparación ASCII. Muestra la primera y la última línea en la lista de diferencias.

Parámetro /c: este parámetro ignora el aspecto de mayúsculas y minúsculas de las letras.

Parámetro /w: este parámetro es muy útil cuando se comparan archivos. Facilita el proceso de comparación de archivos al comprimir o eliminar el espacio en blanco en el proceso de comparación. Es decir, ignora el espacio en blanco, si lo hay, al principio y al final de la línea.

CHKDSK: En esta ocasión, el comando chkdsk nos ayuda a detectar problemas en nuestro disco duro o unidad de almacenamiento del equipo. De esta manera, ejecutando la herramienta desde la línea de comandos podremos detectar problemas en nuestro disco para evitar errores mayores. Su uso es muy sencillo, únicamente tenemos que escribir el comando chkdsk seguido de un espacio y de la letra de la unidad junto con dos puntos (:), que se corresponde con la partición o disco que queremos analizar. El comando admite una serie de parámetros para indicar si queremos que además de detectarlos los intente corregir (/F, para usar este parámetro, el disco debe estar bloqueado), si encuentra sectores defectuosos que trata de recuperar la información (/R), etc. Todos ellos los podemos ver ejecutando el comando "chkdsk /?".

Cómo apagar o reiniciar el PC desde CMD

Si quieres apagar el ordenador desde CMD, puedes hacerlo con un comando específico. Se trata de shutdown. Si queremos apagar el equipo desde el símbolo del sistema o CMD, Shutdown es el comando que debemos utilizar. Además, nos permite indicar si queremos que el apagado sea inmediato o incluso si queremos que se realice pasado un tiempo concreto. Por ejemplo, para apagar el PC de forma automática basta con escribir y ejecutar el comando: shutdown /s /p.

En este caso, /s indica que se realice el apagado del sistema y /p que se realice de forma inmediata sin esperar el tiempo predeterminado del comando que es unos 30 segundos. Si por el contrario queremos que nuestro PC se apague dentro de 1 hora, entonces debemos ejecutar el comando: shutdown /s /t 3600

En este ejemplo, 3600 son los segundos que esperará para apagarse. Podemos ver todas las opciones de shutdown ejecutando el comando shutdown /?. Si por cualquier cosa queremos cancelar el apagado del equipo programado por shutdown, entonces tendremos que ejecutar el comando shutdown /a.

Para reiniciar el equipo, entonces tendremos que usar este mismo comando, pero junto con el parámetro /r. Si ejecutamos el comando: shutdown /r /t 60. Nuestro equipo se reiniciará en 60 segundos.

Atajos de teclado útiles en el símbolo del sistema

Como casi toda herramienta que se precie, el CMD o símbolo del sistema también nos permite utilizar ciertas combinaciones de teclas o atajos de teclado para realizar determinadas tareas de forma rápida. Esto nos agilizará realizar ciertas acciones, así que no está de más conocerlos.

ESC. Cuando estamos escribiendo algún comando en el símbolo del sistema y queremos borrarlo, basta con pulsar la tecla Escape de nuestro teclado y lo borrará todo automáticamente sin tener que ir carácter a carácter.

Flecha hacia arriba y abajo. Las teclas con las flechas hacia arriba y hacia abajo de nuestro teclado nos permiten en el CMD movernos por los comandos ejecutados en la consola desde que la abrimos. Con el cursor de la flecha hacia arriba iremos moviéndonos por los comandos ejecutados anteriormente y en con la flecha hacia abajo volveremos a los ejecutados después.

F7. La tecla F7 nos muestra una ventana con el historial de comandos utilizados en el símbolo del sistema. De esta manera, podremos verlos todos de una sola vez y ejecutar cualquiera de ellos nuevamente con simplemente seleccionarlo y pulsar Enter.

Ctrl+c. Este atajo de teclado nos permite cancelar el proceso en ejecución. Si por ejemplo hemos lanzado un comando que está tardando mucho en ejecutarse y lo queremos cancelar, podremos hacerlos con Ctrl+c.

F11. F11 activa el modo de pantalla completa para que la ventana del símbolo del sistema se haga grande y podamos trabajar más cómodamente. Si en algún momento queremos volverla a hacer de tamaño más pequeño, basta con volver a pulsar F11.

F3. La tecla F3 nos vuelve a escribir el último comando ejecutado en CMD sin que tengamos que volver a escribirlo.

F1. F1 nos escribe de nuevo el último comando ejecutado en el símbolo del sistema, pero en esta ocasión lo hace carácter a carácter con cada pulsación de la tecla F1.

Trucos de comandos que te interesa conocer

Es importante que conozcas algunos trucos o atajos que te facilitarán el uso de comandos para ahorrar tiempo y ser más funcional. Así, será más fácil el uso de los diferentes comandos explicados y, con el tiempo, incluso, servirán de ayuda para aprender aquellos que más puedan interesarte.

Copiar y pegar texto en la línea de comandos

Como vamos a ver a continuación, ciertos comandos de red de CMD o símbolo del sistema puede tener sintaxis complicadas. Es decir, nombres de comandos o parámetros que nos pueden resultar extraños y difíciles de escribir en su conjunto, sobre todo si no tenemos mucha experiencia en el uso de la línea de comandos en Windows.

En este caso, es probable que en algún momento nos hayamos encontrado con ciertos problemas a la hora de copiar y pegar texto en la línea de comandos. Lo habitual es utilizar los comandos Ctrl+C y Ctrl+V para copiar y pegar texto, o bien seleccionar aquello que queremos copiar y haciendo clic con el botón derecho del ratón sobre el texto, seleccionar la opción Copiar para posteriormente repetir la opción y seleccionar Pegar donde queramos llevarlo.

En línea de comando podemos usar otros atajos, ya que un clic con el botón derecho del ratón pegará directamente aquello que tengamos guardado en el portapapeles. De cualquier forma, ante cualquier problema a la hora de seleccionar texto, copiar o pegar, podemos hacer clic sobre el icono de CMD que se muestra en la esquina superior izquierda de la ventana del símbolo del sistema y ahí se nos mostrará un menú donde aparecen las opciones para Marcar, Seleccionar, Copiar o Pegar y sus atajos de teclado, Ctrl+M, Ctrl+A, Enter y Ctrl+V respectivamente.

De esta manera, podremos copiar y pegar, seleccionar o repetir comandos de red de CMD con total comodidad. Eso sin olvidad que las propias teclas de los cursores nos permiten movernos por el historial de comandos ejecutados. Algo que, sin duda, nos facilitará bastante el hecho de repetir o reutilizar un comando sin tenerlo que volver a escribir por completo.

Ver el historial de comandos

Aunque es cierto que puedes ver el historial de comandos con el F7, algo que harás con frecuencia, con este truco podrás alimentar, guardar o manipular la salida de información.

Para ver los comandos escritos desde que has iniciado la sesión, tienes que usar la orden"doskey /history". Esta es una de las funciones más interesantes de la utilidad de Microsoft Doskey, pero como has visto hay más.

Si lo que quieres en realidad es ver el historial del DNS, te basta con escribir el comando ipconfig /displaydns y pulsa el botón Intro para que se ejecute.

Ejecutar varios comandos a la vez

Si lo que quieres es ejecutar varios comandos a la vez porque cada uno de ellos requiere cierto tiempo de ejecución, puedes utilizar la orden "cd C: && echo..." Así, los comandos se van a ejecutar tal como lo escribiste, de izquierda a derecha. Hasta que finaliza el primer comando utilizado no se ejecuta el siguiente, así hasta que se acaban todos.

Esto es muy práctico si quieres ejecutar varios comandos a la vez y no quieres estar pendiente de hacerlo uno por uno cuando finaliza el otro. Además, te permite gestionarte mejor ya que elegirás desde el primer momento cuál se ejecuta antes.

comandoA & comandoB (el comando B se ejecuta directamente tras el A)

comandoA && comandoB (el comando B se ejecuta si el A se ejecutó con éxito)

comandoA || comandoB (el comando B solo se ejecuta si el A no funcionó)

comandoA && comandoB || comandoC (el comando B solo se ejecuta si el A se ejecutó con éxito. En caso contraria, se ejecuta C)

Repetir un comando anterior

Si quieres repetir o recuperar un comando anterior, te basta con presionar la tecla de flecha hacia arriba en tu teclado. Si sigues presionando seguirá repitiendo comandos anteriores, siempre empezando por el más utilizado más recientemente.

Aunque puede parecer similar a la tecla F8, con este truco te colocas al final del comando. Con el F8 te colocas al principio. Con esto podrás repetir o modificar el comando anterior que te interesa.

Cancelar un comando que se encuentra en ejecución

Si estás ejecutando un comando y quieres cancelarlo, o te parece que tarda mucho en ser ejecutado, puedes detenerlo usando "Ctrl + C". Esta función también sirve si quieres detener un servicio o app en ejecución. Si no te funciona, prueba con "Crtl+Pausa".

Te ahorrarás la cantidad de tiempo que te supone tener que esperar a que se ejecute un comando que no avanza, y así podrás dejarlo para otro momento o continuar con otro comando.

Función autocompletar

Si eres un usuario avanzado de Windows seguramente uses muy a menudo el símbolo del sistema. Desde la línea de comandos a veces puede ser un poco engorroso navegar por los directorios de nuestro equipo, ya que tenemos que escribir la ruta de forma literal para poder acceder a los archivos.

Una forma de poder movernos por los directorios de forma rápida es con la tecla TAB. Mientras estamos trabajando con la línea de comandos podemos pulsar sobre esa tecla para poder movernos por las carpetas dentro de un mismo directorio. Podemos escribir cd y a continuación pulsar sobre la tecla tabulador para ir mostrando las carpetas y archivos que compone ese directorio y así poder movernos entre directorios de una forma mucho más rápida.

Esta función la podemos habilitar o deshabilitar si una vez iniciamos el símbolo del sistema introducimos la siguiente orden cmd /F. Con el comando habilitado la tecla TAB deja de mostrarnos los archivos del directorio y se sustituye esa función por la combinación de teclas Crtl + F.

Listado completo de comandos por orden alfabético

Además de todos los comandos que hemos visto anteriormente en sus respectivas secciones, Windows nos ofrece comandos CMD que podemos utilizar en diferentes situaciones. Conocerás tanto los que te hemos mostrado anteriormente como muchos otros que podrás utilizar para diferentes fines. Solo tienes que buscar el que te interesa. Son los siguientes:

active

add

add alias

add volume

append

arp

assign

assoc

at

atmadm

attach-vdisk

attrib

attributes

auditpol

autochk

autoconv

autofmt

automount

bcdboot

bcdedit

bdehdcfg

begin backup

begin restore

bitsadmin

bootcfg

break

cacls

call

cd

certreq

certutil

change

chcp

chdir

chglogon

chgport

chgusr

chkdsk

chkntfs

choice

cipher

clean

cleanmgr

clip

cls

cmd

cmdkey

cmstp

color

comp

compact

compact vdisk

convert

copy

cprofile

create

cscript

date

dcgpofix

defrag

del

delete

detach vdisk

detail

dfsdiag

dfsrmig

diantz

dir

diskcomp

diskcopy

diskpart

diskperf

diskraid

diskshadow

dispdiag

dnscmd

doskey

driverquery

echo

edit

endlocal

end restore

erase

eventcreate

eventquery

eventtriggers

Evntcmd

exec

exit

expand

expand vdisk

expose

extend

extract

fc

filesystems

find

findstr

finger

flattemp

fondue

for

forfiles

format

freedisk

fsutil

ftp

ftype

fveupdate

getmac

gettype

goto

gpfixup

gpresult

gpt

gpupdate

graftabl

help

helpctr

hostname

icacls

if

import (shadowdisk)

import (diskpart)

inactive

inuse

ipconfig

ipxroute

irftp

jetpack

klist

ksetup

ktmutil

ktpass

label

list

load metadata

lodctr

logman

logoff

lpq

lpr

macfile

makecab

manage bde

mapadmin

md

merge vdisk

mkdir

mklink

mmc

mode

more

mount

mountvol

move

mqbkup

mqsvc

mqtgsvc

msdt

msg

msiexec

msinfo32

mstsc

nbtstat

netcfg

net print

netsh

netstat

nfsadmin

nfsshare

nfsstat

nlbmgr

nslookup

ntbackup

ntcmdprompt

ntfrsutl

offline

online

openfiles

pagefileconfig

path

pathping

pause

pbadmin

pentnt

perfmon

ping

pnpunattend

pnputil

popd

powershell

powershell ise

print

prncnfg

prndrvr

prnjobs

prnmngr

prnport

prnqctl

prompt

pubprn

pushd

pushprinterconnections

pwlauncher

qappsrv

qprocess

query process

query session

query termserver

query user

quser

qwinsta

rcp

rd

rdpsign

recover

recover disk group

refsutil

reg

regini

regsvr32

relog

rem

remove

ren

rename

repair

replace

rescan

reset

retain

revert

rexec

risetup

rmdir

robocopy

route ws2008

rpcinfo

rpcping

rsh

rundll32

rundll32 printui

rwinsta

san

sc config

sc create

sc delete

sc query

schtasks

scwcmd

secedit

select

serverceipoptin

servermanagercmd

serverweroptin

set environmental variables

set shadow copy

setx

sfc

shadow

shift

showmount

shrink

shutdown

simulate restore

sort

start

set device (subcomando)

set drivergroup (subcomando)

set drivergroupfilter (subcomando)

set driverpackage (subcomando)

set image (subcomando)

set imagegroup (subcomando)

set image (subcomando)

set transportserver (subcomando)

set multicasttransmission (subcomando)

start namespace (subcomando)

start server (subcomando)

start transportserver (subcomando)

stop server (subcomando)

stop transportserver (subcomando)

subst

sxstrace

sysocmgr

systeminfo

takeown

tapicfg

taskkill

tasklist

tcmsetup

telnet

tftp

time

timeout

title

tlntadmn

tpmtool

tpmvscmgr

tracerpt

tracert

tree

tscon

tsdiscon

tsecimp

tskill

tsprof

type

typeperf

tzutil

unexpose

uniqueid

unlodctr

ver

verifier

verify

vol

vssadmin

waitfor

wbadmin

wdsutil

wecutil

wevtutil

where

whoami

winnt

winnt32

winpop

winrs

winsat mem

winsat mfmedia

wmic

writer

wscript

xcopy

# data[].attributes.attachment_link.title
Los comandos de la consola o CMD de Windows más útiles

# data[].attributes.attachment_link.description
Guía de comandos CMD. Estos son los comandos más básicos y útiles y cómo usarlos en el símbolo del sistema

# data[].attributes.attachment_link.title
Vídeo 01. Hola a todos desde Shell Script de linux. Script de iniciación.