Bash
Variabili interne

introduzione

Bash variabili interne a colpo d'occhio

Variabile	Dettagli
$* / $@	Parametri posizionali funzione / script (argomenti). Espandi come segue: $* e $@ sono gli stessi di $1 $2 ... (si noti che in genere non ha senso lasciare quelli non quotati) "$*" è uguale a "$1 $2 ..." 1 "$@" è uguale a "$1" "$2" ... 1. Gli argomenti sono separati dal primo carattere di $ IFS, che non deve essere uno spazio.
$#	Numero di parametri posizionali passati allo script o alla funzione
$!	ID processo dell'ultimo comando (righ-most per pipeline) nell'ultimo lavoro inserito in background (si noti che non è necessariamente uguale all'ID del gruppo processo del lavoro quando è abilitato il controllo dei processi)
$$	ID del processo che ha eseguito bash
$?	Esce lo stato dell'ultimo comando
$n	Parametri posizionali, dove n = 1, 2, 3, ..., 9
${n}	Parametri posizionali (come sopra), ma n può essere> 9
$0	Negli script, percorso con cui è stato richiamato lo script; con bash -c 'printf "%s\n" "$0"' name args' : name (il primo argomento dopo lo script inline), altrimenti, l' argv[0] che bash ricevuto.
$_	Ultimo campo dell'ultimo comando
$IFS	Separatore di campo interno
$PATH	Variabile di ambiente PATH utilizzata per cercare i file eseguibili
$OLDPWD	Elenco di lavoro precedente
$PWD	Presente directory di lavoro
$FUNCNAME	Matrice di nomi di funzioni nello stack di chiamate di esecuzione
$BASH_SOURCE	Array contenente i percorsi di origine per gli elementi dell'array FUNCNAME . Può essere usato per ottenere il percorso dello script.
$BASH_ALIASES	Array associativo contenente tutti gli alias attualmente definiti
$BASH_REMATCH	Matrice di corrispondenze dall'ultima corrispondenza regolare
$BASH_VERSION	Stringa di versione di Bash
$BASH_VERSINFO	Un array di 6 elementi con informazioni sulla versione di Bash
$BASH	Il percorso assoluto alla shell Bash attualmente in esecuzione (determinato euristicamente da bash basato su argv[0] e il valore di $PATH ; potrebbe essere sbagliato nei casi d'angolo)
$BASH_SUBSHELL	Bash subshell level
$UID	Reale (non efficace se diverso) ID utente del processo che esegue bash
$PS1	Prompt della riga di comando primario; vedi Usare le variabili PS *
$PS2	Prompt della riga di comando secondario (utilizzato per l'input aggiuntivo)
$PS3	Prompt di riga di comando terziario (utilizzato nel ciclo di selezione)
$PS4	Prompt di riga di comando quaternario (utilizzato per aggiungere informazioni con output dettagliato)
$RANDOM	Un intero pseudo casuale compreso tra 0 e 32767
$REPLY	Variabile utilizzata da read per impostazione predefinita quando non viene specificata alcuna variabile. Usato anche da select per restituire il valore fornito dall'utente
$PIPESTATUS	Variabile di matrice che contiene i valori di stato di uscita di ciascun comando nella pipeline in primo piano eseguita più recentemente.

Assegnazione variabile non deve avere spazio prima e dopo. a=123 non a = 123 . Il secondo (un segno di uguale circondato da spazi) in isolamento significa eseguire il comando a con argomenti = e 123 , sebbene sia visto anche nell'operatore di confronto delle stringhe (che sintatticamente è un argomento per [ o [[ o qualsiasi test tu sia usando).

$ BASHPID

Process ID (pid) dell'istanza corrente di Bash. Questo non è lo stesso della variabile $$ , ma spesso dà lo stesso risultato. Questo è nuovo in Bash 4 e non funziona in Bash 3.

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

$ BASH_ENV

Una variabile di ambiente che punta al file di avvio di Bash che viene letto quando viene richiamato uno script.

$ BASH_VERSINFO

Un array contenente le informazioni sulla versione completa suddivise in elementi, molto più conveniente di $BASH_VERSION se stai solo cercando la versione principale:

~> $ 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

Mostra la versione di bash in esecuzione, ciò ti consente di decidere se puoi utilizzare qualsiasi funzione avanzata:

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

$ EDITOR

L'editor predefinito che verrà evocato da qualsiasi script o programma, in genere vi o emacs.

~> $ echo $EDITOR
vi

$ FUNCNAME

Per ottenere il nome della funzione corrente, digitare:

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

Questa istruzione non restituirà nulla se la digiti al di fuori della funzione:

my_function

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

$ HOME

La home directory dell'utente

~> $ echo $HOME
/home/user

$ HOSTNAME

Il nome host assegnato al sistema durante l'avvio.

~> $ echo $HOSTNAME
mybox.mydomain.com

$ HOSTTYPE

Questa variabile identifica l'hardware, può essere utile per determinare quali binari eseguire:

~> $ echo $HOSTTYPE
x86_64

$ GRUPPI

Una matrice contenente i numeri di gruppi in cui si trova l'utente:

#!/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 stringa Internal Field Separator che bash usa per dividere stringhe durante il looping ecc. Il valore predefinito è i caratteri dello spazio bianco: \n (newline), \t (tab) e lo spazio. La modifica di questo in qualcos'altro ti consente di dividere stringhe utilizzando caratteri diversi:

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

L'output di quanto sopra è:

a
b
c
d

Gli appunti:

• Questo è responsabile per il fenomeno noto come scissione di parole .

$ LINENO

Emette il numero di linea nello script corrente. Principalmente utile durante il debug degli script.

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

$ MACHTYPE

Simile a $HOSTTYPE sopra, questo include anche informazioni sul sistema operativo e sull'hardware

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

$ OLDPWD

OLDPWD ( OLDP rint W orking D irectory) contiene la directory prima dell'ultimo comando cd :

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

$ OSTYPE

Restituisce informazioni sul tipo di sistema operativo in esecuzione sulla macchina, ad es.

~> $ echo $OSTYPE
linux-gnu

$ PATH

Il percorso di ricerca per trovare i binari per i comandi. Esempi comuni includono /usr/bin e /usr/local/bin .

Quando un utente o uno script tenta di eseguire un comando, i percorsi in $PATH vengono ricercati per trovare un file corrispondente con il permesso di esecuzione.

Le directory in $PATH sono separate da un : carattere.

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

Quindi, ad esempio, dato il precedente $PATH , se si digita lss al prompt, la shell cercherà /usr/kerberos/bin/lss , quindi /usr/local/bin/lss , quindi /bin/lss , quindi /usr/bin/lss , in questo ordine, prima di concludere che non esiste un tale comando.

$ PPID

L'ID di processo (pid) dello script o del genitore della shell, ovvero il processo che ha invocato lo script o la shell corrente.

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

$ PWD

PWD ( P rint W orking D irectory) La directory di lavoro corrente in cui ti trovi al momento:

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

$ SECONDI

Il numero di secondi in cui è stato eseguito uno script. Questo può diventare piuttosto grande se mostrato nella shell:

~> $ echo $SECONDS
98834

$ SHELLOPTS

Un elenco di opzioni di sola lettura viene fornito all'avvio per controllarne il comportamento:

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

$ SHLVL

Quando viene eseguito il comando bash viene aperta una nuova shell. La variabile di ambiente $ SHLVL contiene il numero di livelli di shell su cui la shell corrente è in esecuzione.

In una nuova finestra di terminale, l'esecuzione del seguente comando produrrà risultati diversi in base alla distribuzione Linux in uso.

echo $SHLVL

Usando Fedora 25 , l'output è "3". Questo indica che quando si apre una nuova shell, un comando bash iniziale viene eseguito ed esegue un'attività. Il comando bash iniziale esegue un processo figlio (un altro comando bash) che, a sua volta, esegue un comando bash finale per aprire la nuova shell. Quando si apre la nuova shell, è in esecuzione come un processo figlio di altri 2 processi shell, quindi l'output di "3".

Nell'esempio seguente (dato che l'utente sta eseguendo Fedora 25), l'output di $ SHLVL in una nuova shell sarà impostato su "3". Quando viene eseguito ogni comando di bash, $ SHLVL aumenta di uno.

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

Si può vedere che l'esecuzione del comando 'bash' (o l'esecuzione di uno script bash) apre una nuova shell. In confronto, l'approvvigionamento di uno script esegue il codice nella shell corrente.

test1.sh

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

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

Eseguire:

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

Produzione:

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 variabile di sola lettura che memorizza il numero ID dell'utente:

~> $ echo $UID
12345

$ 1 $ 2 $ 3 ecc ...

Parametri posizionali passati allo script dalla riga di comando o da una funzione:

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

L'output di quanto sopra è:

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

Se il numero di argomenti posizionali è maggiore di nove, è necessario utilizzare le parentesi graffe.

#  "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}

$ #

Per ottenere il numero di argomenti della riga di comando o di parametri posizionali, digitare:

#!/bin/bash
echo "$#"

Quando viene eseguito con tre argomenti, l'esempio sopra verrà generato con l'output:

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

$ *

Restituirà tutti i parametri posizionali in una singola stringa.

testscript.sh:

#!/bin/bash
echo "$*"

Esegui lo script con diversi argomenti:

./testscript.sh firstarg secondarg thirdarg 

Produzione:

firstarg secondarg thirdarg

$!

L'ID processo (pid) dell'ultimo lavoro eseguito in background:

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

$ _

Emette l'ultimo campo dall'ultimo comando eseguito, utile per far passare qualcosa a un altro comando:

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

---

Fornisce il percorso dello script se usato prima di qualsiasi altro comando:

test.sh:

#!/bin/bash
echo "$_"

Produzione:

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

Nota: questo non è un modo infallibile per ottenere il percorso dello script

$?

Lo stato di uscita dell'ultima funzione o comando eseguito. Di solito 0 significa OK, qualsiasi altra cosa indicherà un errore:

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

$$

L'ID processo (pid) del processo corrente:

~> $ echo $$
13246

$ @

"$@" espande in tutti gli argomenti della riga di comando come parole separate. È diverso da "$*" , che si espande a tutti gli argomenti come una singola parola.

"$@" è particolarmente utile per il looping degli argomenti e la gestione degli argomenti con spazi.

Considera che siamo in uno script che abbiamo invocato con due argomenti, in questo modo:

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

---

Le variabili $* o $@ si espandono in $1␣$2 , che a loro volta si espandono in 1␣2␣3␣4 quindi il ciclo sottostante:

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

stamperà per entrambi

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

---

Mentre "$*" sarà espanso in "$1␣$2" che a sua volta si espanderà in "␣1␣2␣␣␣3␣␣4␣" e così il ciclo:

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

invocherà solo echo una volta e stamperà

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

---

E infine "$@" si espanderà in "$1" "$2" , che si espanderà in "␣1␣2␣" "␣3␣␣4␣" e così il ciclo

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

stamperà

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

preservando così sia la spaziatura interna negli argomenti sia la separazione degli argomenti. Si noti che la costruzione for var in "$@"; do ... è così comune e idiomatico che è l'impostazione predefinita per un ciclo for e può essere abbreviata for var; do ...

$ HISTSIZE

Il numero massimo di comandi memorizzati:

~> $ echo $HISTSIZE
1000

$ RANDOM

Ogni volta che si fa riferimento a questo parametro, viene generato un numero intero casuale compreso tra 0 e 32767. Assegnare un valore a questa variabile semina il generatore di numeri casuali ( fonte ).

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