Come stampare solo variabili definite (variabili shell e / o ambiente) in bash

Il comando incorporato bash set, se invocato senza argomenti, stamperà tutte le variabili shell e ambiente, ma anche tutte le funzioni definite. Ciò rende l'output inutilizzabile per l'uomo e difficile da realizzare grep.

Come posso fare in modo che il comando incorporato bash setstampi solo le variabili e non le funzioni?

Ci sono altri comandi che stampano solo le variabili della shell, senza le funzioni?

Nota: bash distingue tra variabili shell e variabili d'ambiente. vedi qui Differenza tra variabili d'ambiente e variabili d'ambiente esportate in bash

"Esistono altri comandi che stampano solo le variabili della shell, senza le funzioni?"

In man bash, nella sezione SHELL BUILTIN COMMANDS (nella sezione set) dice: "In modalità posix, sono elencate solo le variabili shell".

(set -o posix; set)

nota: la ()sintassi genera una subshell, se non ti piace il biforcazione basta usare la versione più dettagliata

set -o posix; set; set +o posix

Ecco alcune soluzioni alternative:

$ comm -3 <(declare | sort) <(declare -f | sort)

abbattersi:

1. declare stampa ogni variabile definita (esportata o meno) e funzione.
2. declare -f stampa solo funzioni.
3. comm -3rimuoverà tutte le linee comuni ad entrambi. In effetti questo rimuoverà le funzioni, lasciando solo le variabili.

Per stampare solo variabili che non vengono esportate:

$ comm -3 <(comm -3 <(declare | sort) <(declare -f | sort)) <(env | sort)

Un'altra soluzione alternativa:

$ declare -p

Questo stamperà solo le variabili, ma con alcuni brutti attributi.

declare -- BASH="/bin/bash"
declare -ir BASHPID=""
declare -A BASH_ALIASES='()'
declare -a BASH_ARGC='()'
...

Puoi tagliare gli attributi usando ... cut:

$ declare -p | cut -d " " -f 3

Un aspetto negativo è che il valore di IFS viene interpretato anziché visualizzato.

confrontare:

$ comm -3 <(declare | sort) <(declare -f | sort)
...
IFS=$' \t\n'
...
$ declare -p | cut -d " " -f 3
...
IFS="
"
...

Questo rende abbastanza difficile usare quell'output per ulteriori elaborazioni, a causa di quel solitario "in una riga. Forse un po 'di IFS-fu può essere fatto per evitarlo.

Ancora un'altra soluzione alternativa, usando compgen:

$ compgen -v

Il built-in bash compgendoveva essere usato negli script di completamento. A tal fine, compgen -velenca tutte le variabili definite. Il rovescio della medaglia: elenca solo i nomi delle variabili, non i valori.

Ecco un trucco per elencare anche i valori.

$ compgen -v | while read var; do printf "%s=%q\n" "$var" "${!var}"; done

Il vantaggio: è una soluzione bash pura. Lo svantaggio: alcuni valori sono incasinati a causa dell'interpretazione printf. Anche la subshell dalla pipe e / o dal loop aggiungono alcune variabili extra.

La funzione typesetincorporata stranamente ha un'opzione per mostrare solo le funzioni ( -f) ma non per mostrare solo i parametri. Fortunatamente, typeset(o set) visualizza tutti i parametri prima che tutte le funzioni, i nomi delle funzioni e dei parametri non possano contenere newline o segni di uguale, e le nuove righe nei valori dei parametri siano quotate (appaiono come \n). Quindi puoi fermarti alla prima riga che non contiene un segno uguale:

set | awk -F '=' '! /^[0-9A-Z_a-z]+=/ {exit} {print $1}'

Questo stampa solo i nomi dei parametri; se vuoi i valori, cambia print $1in print $0.

Si noti che questo stampa tutti i nomi dei parametri (parametri e variabili sono usati sinonimo qui), non solo variabili d'ambiente ("variabile d'ambiente" è sinonimo di "parametri esportati").

Si noti inoltre che ciò presuppone che non vi siano variabili d'ambiente con un nome che non corrisponda ai vincoli di bash sui nomi dei parametri. Tali variabili non possono essere create all'interno di bash ma possono essere ereditate dall'ambiente all'avvio di bash:

env 'foo ()
{
  =oops' bash

Non sono sicuro di come si possano rendere setvariabili solo la stampa. Tuttavia, guardando l'output di set, sono stato in grado di elaborare quanto segue che sembra afferrare solo le variabili:

$ set | grep "^\([[:alnum:]]\|[[:punct:]]\)\+=" 

Fondamentalmente, sto cercando le righe che iniziano con lettere, numeri o punteggiatura seguiti da un "=". Dall'output che ho visto, questo afferra tutte le variabili; tuttavia, dubito che questo sia molto portatile.

Se, come suggerisce il titolo, vuoi sottrarre da questo elenco le variabili che vengono esportate e quindi ottenere un elenco di variabili non esportate, allora potresti fare qualcosa del genere

$ set | grep "^\([[:alnum:]]\|[[:punct:]]\)\+=" | sort > ./setvars && env | sort | comm -23 ./setvars - 

Per scomporlo un po ', ecco cosa fa:

1. set | grep "^\([[:alnum:]]\|[[:punct:]]\)\+=" | sort > ./setvars : Si spera che ottenga tutte le variabili (come discusso in precedenza), le ordina e inserisce il risultato in un file.
2. && env | sort: Al termine del comando precedente, chiameremo enve ordineremo il suo output.
3. | comm -23 ./setvars -: Infine, eseguiamo il pipe dell'output ordinato di envin comme utilizziamo l' -23opzione per stampare le righe che sono uniche per il primo argomento, in questo caso le righe uniche per il nostro output dal set.

Al termine, è possibile che si desideri ripulire il file temporaneo creato con il comando rm ./setvars

Basta usare il comando env. Non stampa le funzioni.

Prova il comando printenv:

$printenv

In bash, questo stamperà solo i nomi delle variabili:

compgen -v

Oppure, se sono necessari anche valori, utilizzare:

declare -p

differendo da una shell pulita per garantire che vengano lasciati fuori anche gli errori dagli script rc

## get mostly local vars
diff_env(){
    diff <(bash -cl 'set -o posix && set') \
        <(set -o posix && set && set +o posix) | \
        grep -E "^>|^\+" | \
        grep -Ev "^(>|\+|\+\+) ?(BASH|COLUMNS|LINES|HIST|PPID|SHLVL|PS(1|2)|SHELL|FUNC)" | \
        sed -r 's/^> ?|^\+ ?//'
}

la versione con commsarebbe troppo contorta

La risposta accettata è ottima. Offro un'alternativa che non prevede l'impostazione della modalità POSIX:

Ecco la tecnica che ho usato per memorizzare lo stato della funzione in un file in modo da poterlo continuare in seguito. Il primo produce un dump di stato e il secondo produce solo un elenco dei nomi delle variabili.

set 2>/dev/null | while read a; do [[ $a == *=* ]] || break; echo $a; done 

set 2>/dev/null | while read a; do [[ $a == *=* ]] || break; echo ${a/=*}; done 

Entrambi funzionano eseguendo il dumping delle righe fino a quando non ne trova uno senza un carattere '=', che si verifica quando viene elencata la prima funzione. Quest'ultimo ritaglia l'incarico.