Bash => Variables internas

Introducción

Una visión general de las variables internas de Bash, dónde, cómo y cuándo usarlas.

Bash variables internas de un vistazo

Variable	Detalles
`$*` / `$@`	Parámetros posicionales de la función / script (argumentos). Expandir de la siguiente manera: `$` y `$@` son lo mismo que `$1 $2 ...` (tenga en cuenta que generalmente no tiene sentido dejarlos sin comillas) `"$"` es lo mismo que `"$1 $2 ..."` ¹ `"$@"` es lo mismo que `"$1" "$2" ...` _{1. Los argumentos están separados por el primer carácter de $ IFS, que no tiene que ser un espacio.}
`$#`	Número de parámetros posicionales pasados al script o función
`$!`	Id. De proceso del último comando (más a la derecha para canalizaciones) en el último trabajo puesto en segundo plano (tenga en cuenta que no es necesariamente el mismo que el Id. De grupo de proceso del trabajo cuando el control de trabajo está habilitado)
`$$`	ID del proceso que ejecutó `bash`
`$?`	Estado de salida del último comando
`$n`	Parámetros posicionales, donde n = 1, 2, 3, ..., 9
`${n}`	Parámetros posicionales (igual que arriba), pero n puede ser> 9
`$0`	En los scripts, ruta con la que se invocó el script; con `bash -c 'printf "%s\n" "$0"' name args'` : `name` (el primer argumento después del script en línea), de lo contrario, el `argv[0]` que recibió `bash` .
`$_`	Último campo del último comando.
`$IFS`	Separador de campo interno
`$PATH`	Variable de entorno PATH usada para buscar ejecutables
`$OLDPWD`	Directorio de trabajo anterior
`$PWD`	Directorio de trabajo actual
`$FUNCNAME`	Conjunto de nombres de funciones en la pila de llamadas de ejecución
`$BASH_SOURCE`	Array que contiene las rutas de origen para los elementos en la matriz `FUNCNAME` . Se puede utilizar para obtener la ruta del script.
`$BASH_ALIASES`	Matriz asociativa que contiene todos los alias definidos actualmente
`$BASH_REMATCH`	Arsenal de partidos del último partido regex
`$BASH_VERSION`	Bash version string
`$BASH_VERSINFO`	Una matriz de 6 elementos con información de la versión Bash
`$BASH`	Ruta absoluta al shell Bash actualmente en ejecución (determinado heurísticamente por `bash` función de `argv[0]` y el valor de `$PATH` ; puede ser incorrecto en los casos de esquina)
`$BASH_SUBSHELL`	Bash subshell level
`$UID`	ID de usuario real (no es efectivo si es diferente) del proceso que ejecuta `bash`
`$PS1`	Línea de comando primaria; ver Uso de las variables PS *
`$PS2`	Indicador de línea de comando secundario (usado para entrada adicional)
`$PS3`	Indicador de línea de comando terciario (usado en el ciclo de selección)
`$PS4`	Indicador de línea de comando cuaternario (usado para agregar información con salida detallada)
`$RANDOM`	Un entero pseudoaleatorio entre 0 y 32767
`$REPLY`	Variable utilizada por `read` por defecto cuando no se especifica ninguna variable. También se utiliza por `select` para devolver el valor proporcionado por el usuario
`$PIPESTATUS`	Variable de matriz que contiene los valores de estado de salida de cada comando en la tubería de primer plano ejecutada más recientemente.

La asignación de variables no debe tener espacio antes y después. a=123 no a = 123 . Este último (un signo igual rodeado de espacios) en forma aislada significa ejecutar el comando a con los argumentos = y 123 , aunque también se ve en el operador de comparación de cadenas (que sintácticamente es un argumento para [ o [[ o la prueba que sea) utilizando).

$ BASHPID

Id. De proceso (pid) de la instancia actual de Bash. Esto no es lo mismo que la variable $$ , pero a menudo da el mismo resultado. Esto es nuevo en Bash 4 y no funciona en Bash 3.

~> $ echo "\$\$ pid = $$  BASHPID = $BASHPID"
$$ pid = 9265  BASHPID = 9265

$ BASH_ENV

Una variable de entorno que apunta al archivo de inicio Bash que se lee cuando se invoca un script.

$ BASH_VERSINFO

Una matriz que contiene la información de la versión completa se divide en elementos, mucho más conveniente que $BASH_VERSION si solo está buscando la versión principal:

~> $ for ((i=0; i<=5; i++)); do echo "BASH_VERSINFO[$i] = ${BASH_VERSINFO[$i]}"; done
BASH_VERSINFO[0] = 3
BASH_VERSINFO[1] = 2
BASH_VERSINFO[2] = 25
BASH_VERSINFO[3] = 1
BASH_VERSINFO[4] = release
BASH_VERSINFO[5] = x86_64-redhat-linux-gnu

$ BASH_VERSION

Muestra la versión de bash que se está ejecutando, esto le permite decidir si puede usar alguna función avanzada:

~> $ echo $BASH_VERSION
4.1.2(1)-release

$ EDITOR

El editor predeterminado que estará involucrado por cualquier script o programa, generalmente vi o emacs.

~> $ echo $EDITOR
vi

$ FUNCNAME

Para obtener el nombre de la función actual, escriba:

my_function()
{
    echo "This function is $FUNCNAME"    # This will output "This function is my_function"
}

Esta instrucción no devolverá nada si la escribe fuera de la función:

my_function

echo "This function is $FUNCNAME"    # This will output "This function is"

$ HOME

El directorio de inicio del usuario.

~> $ echo $HOME
/home/user

$ HOSTNAME

El nombre de host asignado al sistema durante el inicio.

~> $ echo $HOSTNAME
mybox.mydomain.com

$ HOSTTYPE

Esta variable identifica el hardware, puede ser útil para determinar qué binarios ejecutar:

~> $ echo $HOSTTYPE
x86_64

$ GRUPOS

Una matriz que contiene los números de grupos en los que se encuentra el usuario:

#!/usr/bin/env bash
echo You are assigned to the following groups:
for group in ${GROUPS[@]}; do
   IFS=: read -r name dummy number members < <(getent group $group )
   printf "name: %-10s number: %-15s members: %s\n" "$name" "$number" "$members" 
done

$ IFS

Contiene la cadena del separador de campo interno que utiliza bash para dividir cadenas cuando se realiza un bucle, etc. El valor predeterminado es los caracteres de espacio en blanco: \n (nueva línea), \t (pestaña) y espacio. Cambiar esto a otra cosa te permite dividir cadenas usando diferentes caracteres:

IFS=","
INPUTSTR="a,b,c,d"
for field in ${INPUTSTR}; do
    echo $field
done

La salida de lo anterior es:

a
b
c
d

Notas:

Esto es responsable del fenómeno conocido como división de palabras .

$ LINENO

Muestra el número de línea en el script actual. Sobre todo útil cuando se depuran scripts.

#!/bin/bash
# this is line 2
echo something  # this is line 3
echo $LINENO # Will output 4

$ MACHTYPE

Similar a $HOSTTYPE anterior, esto también incluye información sobre el sistema operativo, así como el hardware

~> $ echo $MACHTYPE
x86_64-redhat-linux-gnu

$ OLDPWD

OLDPWD ( OLDP rint W orking D irectory) contiene el directorio antes del último comando de cd :

~> $ cd directory
directory> $ echo $OLDPWD
/home/user

$ OSTYPE

Devuelve información sobre el tipo de sistema operativo que se ejecuta en la máquina, por ejemplo.

~> $ echo $OSTYPE
linux-gnu

$ PATH

La ruta de búsqueda para encontrar binarios para comandos. Los ejemplos comunes incluyen /usr/bin y /usr/local/bin .

Cuando un usuario o script intenta ejecutar un comando, se buscan las rutas en $PATH para encontrar un archivo coincidente con permiso de ejecución.

Los directorios en $PATH están separados por un carácter :

~> $ echo "$PATH"
/usr/kerberos/bin:/usr/local/bin:/bin:/usr/bin

Entonces, por ejemplo, dado el $PATH anterior, si escribe lss en el indicador, el shell buscará /usr/kerberos/bin/lss , luego /usr/local/bin/lss , luego /bin/lss , luego /usr/bin/lss , en este orden, antes de concluir que no existe tal comando.

$ PPID

El ID de proceso (pid) del script o el padre del shell, es decir, el proceso que invoca el script o shell actual.

~> $ echo $$
13016
~> $ echo $PPID
13015

$ PWD

PWD ( P rint W orking D irectory) El directorio de trabajo actual en el que se encuentra en este momento:

~> $ echo $PWD
/home/user
~> $ cd directory
directory> $ echo $PWD
/home/user/directory

$ SEGUNDOS

El número de segundos que se ha estado ejecutando un script. Esto puede ser bastante grande si se muestra en el shell:

~> $ echo $SECONDS
98834

$ SHELLOPTS

Se proporciona una lista de solo lectura de las opciones de bash en el inicio para controlar su comportamiento:

~> $ echo $SHELLOPTS
braceexpand:emacs:hashall:histexpand:history:interactive-comments:monitor

$ SHLVL

Cuando se ejecuta el comando bash, se abre un nuevo shell. La variable de entorno $ SHLVL contiene la cantidad de niveles de shell a los que se ejecuta la shell actual .

En una nueva ventana de terminal, la ejecución del siguiente comando producirá resultados diferentes según la distribución de Linux en uso.

echo $SHLVL

Usando Fedora 25 , la salida es "3". Esto indica que al abrir un nuevo shell, un comando bash inicial se ejecuta y realiza una tarea. El comando bash inicial ejecuta un proceso hijo (otro comando bash) que, a su vez, ejecuta un comando bash final para abrir el nuevo shell. Cuando se abre el nuevo shell, se ejecuta como un proceso secundario de otros 2 procesos de shell, de ahí la salida de "3".

En el siguiente ejemplo (dado que el usuario está ejecutando Fedora 25), la salida de $ SHLVL en un nuevo shell se configurará en "3". A medida que se ejecuta cada comando bash, $ SHLVL se incrementa en uno.

~> $ echo $SHLVL
3
~> $ bash
~> $ echo $SHLVL
4
~> $ bash
~> $ echo $SHLVL
5

Uno puede ver que ejecutar el comando 'bash' (o ejecutar un script bash) abre un nuevo shell. En comparación, la fuente de un script ejecuta el código en el shell actual.

prueba1.sh

#!/usr/bin/env bash
echo "Hello from test1.sh. My shell level is $SHLVL"
source "test2.sh"

prueba2.sh

#!/usr/bin/env bash
echo "Hello from test2.sh. My shell level is $SHLVL"

run.sh

#!/usr/bin/env bash
echo "Hello from run.sh. My shell level is $SHLVL"
./test1.sh

Ejecutar:

chmod +x test1.sh && chmod +x run.sh
./run.sh

Salida:

Hello from run.sh. My shell level is 4
Hello from test1.sh. My shell level is 5
Hello from test2.sh. My shell level is 5

$ UID

Una variable de solo lectura que almacena el número de identificación del usuario:

~> $ echo $UID
12345

$ 1 $ 2 $ 3 etc ...

Los parámetros posicionales pasados al script desde la línea de comandos o desde una función:

#!/bin/bash
# $n is the n'th positional parameter
echo "$1"
echo "$2"
echo "$3"

La salida de lo anterior es:

~> $ ./testscript.sh firstarg secondarg thirdarg
firstarg
secondarg
thirdarg

Si el número de argumentos posicionales es mayor que nueve, se deben usar llaves.

#  "set -- " sets positional parameters
set -- 1 2 3 4 5 6 7 8 nine ten eleven twelve
# the following line will output 10 not 1 as the value of $1 the digit 1
# will be concatenated with the following 0
echo $10   # outputs 1
echo ${10} # outputs ten
# to show this clearly:
set -- arg{1..12}
echo $10 
echo ${10}

PS

Para obtener el número de argumentos de línea de comando o parámetros posicionales, escriba:

#!/bin/bash
echo "$#"

Cuando se ejecuta con tres argumentos, el ejemplo anterior resultará con el resultado:

~> $ ./testscript.sh firstarg secondarg thirdarg
3

PS

Devolverá todos los parámetros posicionales en una sola cadena.

testscript.sh:

#!/bin/bash
echo "$*"

Ejecuta el script con varios argumentos:

./testscript.sh firstarg secondarg thirdarg

Salida:

firstarg secondarg thirdarg

PS

El ID de proceso (pid) del último trabajo ejecutado en segundo plano:

~> $ ls &
testfile1 testfile2
[1]+  Done                    ls
~> $ echo $!
21715

PS

Da salida al último campo del último comando ejecutado, útil para hacer que algo pase a otro comando:

 ~> $ ls *.sh;echo $_
testscript1.sh  testscript2.sh
testscript2.sh

Da la ruta del script si se usa antes que cualquier otro comando:

test.sh:

#!/bin/bash
echo "$_"

Salida:

~> $ ./test.sh # running test.sh
./test.sh

Nota: esta no es una manera infalible de obtener la ruta del script

PS

El estado de salida de la última función o comando ejecutado. Por lo general, 0 significa que cualquier otra cosa indicará una falla:

~> $ ls *.blah;echo $?
ls: cannot access *.blah: No such file or directory
2
~> $ ls;echo $?
testfile1 testfile2
0

$$

El ID de proceso (pid) del proceso actual:

~> $ echo $$
13246

PS

"$@" expande a todos los argumentos de la línea de comandos como palabras separadas. Es diferente de "$*" , que se expande a todos los argumentos como una sola palabra.

"$@" Es especialmente útil para un bucle a través de argumentos y gastos de argumentos con espacios.

Considere que estamos en un script que invocamos con dos argumentos, como este:

$ ./script.sh "␣1␣2␣" "␣3␣␣4␣"

Las variables $* o $@ se expandirán en $1␣$2 , que a su vez se expandirán en 1␣2␣3␣4 modo que el siguiente bucle:

for var in $*; do # same for var in $@; do
    echo \<"$var"\>
done

imprimirá para ambos

<1>
<2>
<3>
<4>

Mientras que "$*" se expandirá a "$1␣$2" que a su vez se expandirá a "␣1␣2␣␣␣3␣␣4␣" y así el bucle:

for var in "$*"; do
    echo \<"$var"\>   
done

solo invocará echo una vez e imprimirá

<␣1␣2␣␣␣3␣␣4␣>

Y finalmente, "$@" se expandirá a "$1" "$2" , que se expandirá a "␣1␣2␣" "␣3␣␣4␣" y así el bucle

for var in "$@"; do
    echo \<"$var"\>
done

imprimirá

<␣1␣2␣>
<␣3␣␣4␣>

preservando así tanto el espaciado interno en los argumentos como la separación de argumentos. Tenga en cuenta que la construcción for var in "$@"; do ... es tan común e idiomático que es el valor predeterminado para un bucle for y se puede reducir for var; do ...

$ HISTSIZE

El número máximo de comandos recordados:

~> $ echo $HISTSIZE
1000

$ RANDOM

Cada vez que se hace referencia a este parámetro, se genera un entero aleatorio entre 0 y 32767. Asignar un valor a esta variable siembra el generador de números aleatorios ( fuente ).

~> $ echo $RANDOM 
27119
~> $ echo $RANDOM 
1349

Modified text is an extract of the original Stack Overflow Documentation

Licenciado bajo CC BY-SA 3.0

No afiliado a Stack Overflow

Bash
Variables internas

Buscar..

Introducción