Come posso verificare se esiste un programma da uno script Bash?

Come verificherei l'esistenza di un programma, in modo da restituire un errore e uscire o continuare con lo script?

Sembra che dovrebbe essere facile, ma mi ha stordito.

Risposta

POSIX compatibile:

command -v <the_command>

Per ambienti specifici di Bash:

hash <the_command> # For regular commands. Or...
type <the_command> # To check built-ins and keywords

Spiegazione

Evitare which. Non solo è un processo esterno si stai lanciando per fare molto poco (builtins significato piace hash, typeo commandsono il modo più economico), si può anche fare affidamento sui comandi incorporati effettivamente fare quello che vuoi, mentre gli effetti di comandi esterni possono facilmente variare da da sistema a sistema.

Perché preoccuparsene?

• Molti sistemi operativi hanno uno whichche non imposta nemmeno uno stato di uscita , il che significa if which fooche non funzionerà nemmeno lì e segnalerà sempre che fooesiste, anche se non lo fa (si noti che alcune shell POSIX sembrano farlo hashanche per questo ).
• Molti sistemi operativi fanno whichcose personalizzate e malvagie come cambiare l'output o persino agganciarsi al gestore dei pacchetti.

Quindi, non usare which. Invece usa uno di questi:

$ command -v foo >/dev/null 2>&1 || { echo >&2 "I require foo but it's not installed.  Aborting."; exit 1; }
$ type foo >/dev/null 2>&1 || { echo >&2 "I require foo but it's not installed.  Aborting."; exit 1; }
$ hash foo 2>/dev/null || { echo >&2 "I require foo but it's not installed.  Aborting."; exit 1; }

(Nota a margine minore: alcuni suggeriranno che 2>&-è lo stesso 2>/dev/nullma più breve - questo non è vero . 2>&-Chiude FD 2 che causa un errore nel programma quando tenta di scrivere su stderr, che è molto diverso dal scrivere con successo su di esso e scartare l'output (e pericoloso!))

Se il tuo hash bang è /bin/shallora dovresti preoccuparti di ciò che dice POSIX. typee hashi codici di uscita non sono terribilmente ben definiti da POSIX, ed hashè visto per uscire con successo quando il comando non esiste (non l'ho ancora visto type). commandLo stato di uscita è ben definito da POSIX, quindi è probabilmente il più sicuro da usare.

Se lo script utilizza bash, tuttavia, le regole POSIX non contano più ed entrambe typee hashdiventano perfettamente sicure da usare. typeora ha una -Pricerca solo PATHe hashha l'effetto collaterale che la posizione del comando sarà sottoposta a hash (per una ricerca più veloce la prossima volta che la usi), che di solito è una buona cosa poiché probabilmente verifichi la sua esistenza per usarla effettivamente .

Come semplice esempio, ecco una funzione che viene eseguita gdatese esiste, altrimenti date:

gnudate() {
    if hash gdate 2>/dev/null; then
        gdate "$@"
    else
        date "$@"
    fi
}

Di seguito è riportato un modo portatile per verificare se esiste un comando $PATH ed è eseguibile:

[ -x "$(command -v foo)" ]

Esempio:

if ! [ -x "$(command -v git)" ]; then
  echo 'Error: git is not installed.' >&2
  exit 1
fi

Il controllo eseguibile è necessario perché bash restituisce un file non eseguibile se non viene trovato alcun file eseguibile con quel nome $PATH.

Si noti inoltre che se in precedenza esiste un file non eseguibile con lo stesso nome dell'eseguibile $PATH, trattino restituisce il primo, anche se quest'ultimo verrà eseguito. Questo è un bug e viola lo standard POSIX. [ Segnalazione bug ] [ Standard ]

Inoltre, ciò fallirà se il comando che stai cercando è stato definito come alias.

Concordo con lhunath per scoraggiare l'uso whiche la sua soluzione è perfettamente valida per gli utenti di Bash . Tuttavia, per essere più portatile, command -vdeve essere utilizzato invece:

$ command -v foo >/dev/null 2>&1 || { echo "I require foo but it's not installed.  Aborting." >&2; exit 1; }

Il comando commandè conforme a POSIX. Vedi qui per le sue specifiche: comando - esegue un comando semplice

Nota: typeè conforme POSIX, ma type -Pnon lo è.

Ho una funzione definita nel mio .bashrc che rende tutto più semplice.

command_exists () {
    type "$1" &> /dev/null ;
}

Ecco un esempio di come viene utilizzato (dal mio .bash_profile.)

if command_exists mvim ; then
    export VISUAL="mvim --nofork"
fi

Dipende se vuoi sapere se esiste in una delle directory nella $PATHvariabile o se conosci la sua posizione assoluta. Se vuoi sapere se è nella $PATHvariabile, usa

if which programname >/dev/null; then
    echo exists
else
    echo does not exist
fi

altrimenti usa

if [ -x /path/to/programname ]; then
    echo exists
else
    echo does not exist
fi

Il reindirizzamento /dev/null/nel primo esempio elimina l'output del whichprogramma.

Espandendo le risposte di @lhunath e @ GregV, ecco il codice per le persone che vogliono inserire facilmente quel controllo all'interno di una ifdichiarazione:

exists()
{
  command -v "$1" >/dev/null 2>&1
}

Ecco come usarlo:

if exists bash; then
  echo 'Bash exists!'
else
  echo 'Your system does not have Bash'
fi

Prova a usare:

test -x filename

o

[ -x filename ]

Dalla manpage di Bash in Espressioni condizionali :

 -x file
          True if file exists and is executable.

Per usare hash, come suggerisce @lhunath , in uno script Bash:

hash foo &> /dev/null
if [ $? -eq 1 ]; then
    echo >&2 "foo not found."
fi

Questo script viene eseguito hashe quindi controlla se il codice di uscita del comando più recente, il valore archiviato $?, è uguale a 1. In caso hashcontrario foo, il codice di uscita sarà 1. Se foopresente, il codice di uscita sarà 0.

&> /dev/nullreindirizza l'errore standard e l'output standard in hashmodo che non appaia sullo schermo e echo >&2scriva il messaggio nell'errore standard.

Non ho mai avuto le risposte precedenti per lavorare sulla casella a cui ho accesso. Per uno, typeè stato installato (facendo quello che morefa). Quindi è necessaria la direttiva integrata. Questo comando funziona per me:

if [ `builtin type -p vim` ]; then echo "TRUE"; else echo "FALSE"; fi

Verificare la presenza di più dipendenze e informare lo stato degli utenti finali

for cmd in latex pandoc; do
  printf '%-10s' "$cmd"
  if hash "$cmd" 2>/dev/null; then
    echo OK
  else
    echo missing
  fi
done

Uscita campione:

latex     OK
pandoc    missing

Regolare la 10lunghezza massima del comando. Non è automatico, perché non vedo un modo POSIX non dettagliato per farlo: come posso allineare le colonne di una tabella separata dallo spazio in Bash?

Controllare se alcuni aptpacchetti sono installati con dpkg -se installarli altrimenti .

Vedi: Controlla se è installato un pacchetto apt-get e installalo se non è su Linux

È stato precedentemente menzionato in: Come posso verificare se esiste un programma da uno script Bash?

Se controlli l'esistenza del programma, probabilmente lo eseguirai in seguito comunque. Perché non provare a eseguirlo in primo luogo?

if foo --version >/dev/null 2>&1; then
    echo Found
else
    echo Not found
fi

È un controllo più affidabile che il programma viene eseguito piuttosto che guardare semplicemente le directory PATH e le autorizzazioni dei file.

Inoltre puoi ottenere alcuni risultati utili dal tuo programma, come la sua versione.

Naturalmente gli svantaggi sono che alcuni programmi possono essere pesanti da avviare e alcuni non hanno --versionun'opzione per uscire immediatamente (e con successo).

hash foo 2>/dev/null: funziona con Z shell (Zsh), Bash, Dash e Ash .

type -p foo: sembra funzionare con Z shell, Bash e ash ( BusyBox ), ma non Dash (interpreta -pcome argomento).

command -v foo: funziona con Z shell, Bash, Dash, ma non ash (BusyBox) ( -ash: command: not found).

Si noti inoltre che builtinnon è disponibile con ash e Dash.

Usa i built-in di Bash se puoi:

which programname

...

type -P programname

Il comando -vfunziona correttamente se l'opzione POSIX_BUILTINS è impostata per<command> test per, ma può non riuscire in caso contrario. (Ha funzionato per me per anni, ma di recente mi sono imbattuto in uno in cui non ha funzionato.)

Trovo che quanto segue sia più a prova di errore:

test -x $(which <command>)

Dal momento che verifica tre cose: percorso, esistenza e permesso di esecuzione.

Per gli interessati, nessuna delle metodologie nelle risposte precedenti funziona se si desidera rilevare una libreria installata. Immagino che ti rimanga con il controllo fisico del percorso (potenzialmente per i file di intestazione e simili), o qualcosa del genere (se sei su una distribuzione basata su Debian):

dpkg --status libdb-dev | grep -q not-installed

if [ $? -eq 0 ]; then
    apt-get install libdb-dev
fi

Come puoi vedere da quanto sopra, una risposta "0" dalla query indica che il pacchetto non è installato. Questa è una funzione di "grep" - uno "0" significa che è stata trovata una corrispondenza, un "1" significa che non è stata trovata alcuna corrispondenza.

Ci sono un sacco di opzioni qui, ma sono rimasto sorpreso senza una battuta veloce. Questo è quello che ho usato all'inizio dei miei script:

[[ "$(command -v mvn)" ]] || { echo "mvn is not installed" 1>&2 ; exit 1; }
[[ "$(command -v java)" ]] || { echo "java is not installed" 1>&2 ; exit 1; }

Questo si basa sulla risposta selezionata qui e su un'altra fonte.

Direi che non esiste alcun modo portatile e affidabile al 100% a causa di penzoloni alias. Per esempio:

alias john='ls --color'
alias paul='george -F'
alias george='ls -h'
alias ringo=/

Certo, solo l'ultimo è problematico (senza offesa per Ringo!). Ma tutti sono validi aliasdal punto di vista di command -v.

Per respingere quelli penzolanti come ringo, dobbiamo analizzare l'output del aliascomando integrato della shell e ricorrere in essi ( command -vnon è un superiore a aliasqui.) Non esiste alcuna soluzione portatile per esso, e nemmeno un Bash- la soluzione specifica è piuttosto noiosa.

Si noti che una soluzione come questa rifiuterà incondizionatamente alias ls='ls -F':

test() { command -v $1 | grep -qv alias }

Questo dirà in base alla posizione se il programma esiste o no:

    if [ -x /usr/bin/yum ]; then
        echo "This is Centos"
    fi

Il whichcomando potrebbe essere utile.uomo che

Restituisce 0 se viene trovato l'eseguibile e restituisce 1 se non viene trovato o non eseguibile:

NAME

       which - locate a command

SYNOPSIS

       which [-a] filename ...

DESCRIPTION

       which returns the pathnames of the files which would
       be executed in the current environment, had its
       arguments been given as commands in a strictly
       POSIX-conformant shell. It does this by searching
       the PATH for executable files matching the names
       of the arguments.

OPTIONS

       -a     print all matching pathnames of each argument

EXIT STATUS

       0      if all specified commands are 
              found and executable

       1      if one or more specified commands is nonexistent
              or not executable

       2      if an invalid option is specified

La cosa bella whichè che capisce se l'eseguibile è disponibile nell'ambiente in cui whichviene eseguito - salva alcuni problemi ...

La mia configurazione per un Debian server :

Ho avuto il problema quando più pacchetti contenevano lo stesso nome.

Per esempio apache2. Quindi questa era la mia soluzione:

function _apt_install() {
    apt-get install -y $1 > /dev/null
}

function _apt_install_norecommends() {
    apt-get install -y --no-install-recommends $1 > /dev/null
}
function _apt_available() {
    if [ `apt-cache search $1 | grep -o "$1" | uniq | wc -l` = "1" ]; then
        echo "Package is available : $1"
        PACKAGE_INSTALL="1"
    else
        echo "Package $1 is NOT available for install"
        echo  "We can not continue without this package..."
        echo  "Exitting now.."
        exit 0
    fi
}
function _package_install {
    _apt_available $1
    if [ "${PACKAGE_INSTALL}" = "1" ]; then
        if [ "$(dpkg-query -l $1 | tail -n1 | cut -c1-2)" = "ii" ]; then
             echo  "package is already_installed: $1"
        else
            echo  "installing package : $1, please wait.."
            _apt_install $1
            sleep 0.5
        fi
    fi
}

function _package_install_no_recommends {
    _apt_available $1
    if [ "${PACKAGE_INSTALL}" = "1" ]; then
        if [ "$(dpkg-query -l $1 | tail -n1 | cut -c1-2)" = "ii" ]; then
             echo  "package is already_installed: $1"
        else
            echo  "installing package : $1, please wait.."
            _apt_install_norecommends $1
            sleep 0.5
        fi
    fi
}

Se voi / ragazze non riuscite a far funzionare le cose nelle risposte qui e vi state strappando i capelli dalla schiena, provate a eseguire lo stesso comando usando bash -c . Guarda questo delirio sonnambulo. Questo è ciò che accade realmente quando si esegue $ (comando secondario):

Primo. Può darti un output completamente diverso.

$ command -v ls
alias ls='ls --color=auto'
$ bash -c "command -v ls"
/bin/ls

Secondo. Non può darti alcun risultato.

$ command -v nvm
nvm
$ bash -c "command -v nvm"
$ bash -c "nvm --help"
bash: nvm: command not found

La variante hash ha una trappola: nella riga di comando è possibile ad esempio digitare

one_folder/process

per eseguire il processo. Per questo la cartella principale di one_folder deve essere in $ PATH . Ma quando provi a eseguire l'hashing di questo comando, riuscirà sempre:

hash one_folder/process; echo $? # will always output '0'

In secondo luogo l'uso di "comando -v". Ad esempio in questo modo:

md=$(command -v mkdirhier) ; alias md=${md:=mkdir}  # bash

emacs="$(command -v emacs) -nw" || emacs=nano
alias e=$emacs
[[ -z $(command -v jed) ]] && alias jed=$emacs

Ho dovuto verificare se Git era installato come parte della distribuzione del nostro server CI . Il mio script finale di Bash era il seguente (server Ubuntu):

if ! builtin type -p git &>/dev/null; then
  sudo apt-get -y install git-core
fi

Per imitare Bash type -P cmd, possiamo usare il POSIX conforme env -i type cmd 1>/dev/null 2>&1.

man env
# "The option '-i' causes env to completely ignore the environment it inherits."
# In other words, there are no aliases or functions to be looked up by the type command.

ls() { echo 'Hello, world!'; }

ls
type ls
env -i type ls

cmd=ls
cmd=lsx
env -i type $cmd 1>/dev/null 2>&1 || { echo "$cmd not found"; exit 1; }

Se non è typedisponibile alcun comando esterno (come dato scontato qui ), possiamo utilizzare POSIX conforme env -i sh -c 'type cmd 1>/dev/null 2>&1':

# Portable version of Bash's type -P cmd (without output on stdout)
typep() {
   command -p env -i PATH="$PATH" sh -c '
      export LC_ALL=C LANG=C
      cmd="$1"
      cmd="`type "$cmd" 2>/dev/null || { echo "error: command $cmd not found; exiting ..." 1>&2; exit 1; }`"
      [ $? != 0 ] && exit 1
      case "$cmd" in
        *\ /*) exit 0;;
            *) printf "%s\n" "error: $cmd" 1>&2; exit 1;;
      esac
   ' _ "$1" || exit 1
}

# Get your standard $PATH value
#PATH="$(command -p getconf PATH)"
typep ls
typep builtin
typep ls-temp

Almeno su Mac OS X v10.6.8 (Snow Leopard) utilizzando Bash 4.2.24 (2) command -v lsnon corrisponde a uno spostamento /bin/ls-temp.

Nel caso in cui si desideri verificare se esiste un programma ed è davvero un programma, non un comando incorporato di Bash , quindi command, typee hashnon sono appropriati per il test in quanto restituiscono tutti 0 stato di uscita per i comandi integrati.

Ad esempio, esiste il programma orario che offre più funzioni rispetto al comando incorporato time . Per verificare se il programma esiste, suggerirei di utilizzare whichcome nell'esempio seguente:

# First check if the time program exists
timeProg=`which time`
if [ "$timeProg" = "" ]
then
  echo "The time program does not exist on this system."
  exit 1
fi

# Invoke the time program
$timeProg --quiet -o result.txt -f "%S %U + p" du -sk ~
echo "Total CPU time: `dc -f result.txt` seconds"
rm result.txt

Volevo che rispondesse alla stessa domanda ma che fosse eseguita in un Makefile.

install:
    @if [[ ! -x "$(shell command -v ghead)" ]]; then \
        echo 'ghead does not exist. Please install it.'; \
        exit -1; \
    fi

copione

#!/bin/bash

# Commands found in the hash table are checked for existence before being
# executed and non-existence forces a normal PATH search.
shopt -s checkhash

function exists() {
 local mycomm=$1; shift || return 1

 hash $mycomm 2>/dev/null || \
 printf "\xe2\x9c\x98 [ABRT]: $mycomm: command does not exist\n"; return 1;
}
readonly -f exists

exists notacmd
exists bash
hash
bash -c 'printf "Fin.\n"'

Risultato

✘ [ABRT]: notacmd: command does not exist
hits    command
   0    /usr/bin/bash
Fin.

Lo uso perché è molto semplice:

if [ `LANG=C type example 2>/dev/null|wc -l` = 1 ];then echo exists;else echo "not exists";fi

o

if [ `LANG=C type example 2>/dev/null|wc -l` = 1 ];then
echo exists
else echo "not exists"
fi

Utilizza lo stato dell'eco dei programmi incorporati della shell e dell'output standard e nulla per l'errore standard. D'altra parte, se non viene trovato un comando, viene visualizzato lo stato solo l'errore standard.