Respuesta

Compatible con POSIX:

command -v <the_command>

Ejemplo de uso:

if ! command -v COMMAND &> /dev/null
then
    echo "COMMAND could not be found"
    exit
fi

Para entornos específicos de Bash:

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

Explicación

Evitando which. No solo es un proceso externo que está iniciando para hacer muy poco (es decir, incorporaciones como hash, type or command son mucho más baratos), también puede confiar en las funciones integradas para hacer realmente lo que desee, mientras que los efectos de los comandos externos pueden variar fácilmente de un sistema a otro.

¿Por qué importa?

• Muchos sistemas operativos tienen which esta ni siquiera establece un estado de salida, significando el if which foo ni siquiera funcionará allí y lo hará siempre informar de que foo existe, incluso si no lo hace (tenga en cuenta que algunos shells POSIX parecen hacer esto para hash también).
• Muchos sistemas operativos hacen which hacer cosas personalizadas y malvadas como cambiar la salida o incluso conectarse al administrador de paquetes.

Entonces, no uses which. En su lugar, use uno de estos:

$ 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 al margen menor: algunos sugerirán 2>&- es el mismo 2>/dev/null pero más corto - esto es falso. 2>&- cierra FD 2 lo que provoca una error en el programa cuando intenta escribir en stderr, que es muy diferente de escribir con éxito y descartar la salida (¡y peligroso!))

Si tu hash bang es /bin/sh entonces debería preocuparse por lo que dice POSIX. type y hashLos códigos de salida no están muy bien definidos por POSIX, y hash se ve salir con éxito cuando el comando no existe (no he visto esto con type todavía). commandEl estado de salida está bien definido por POSIX, por lo que probablemente uno sea el más seguro de usar.

Si su secuencia de comandos usa bash sin embargo, las reglas POSIX ya no importan y tanto type y hash sea ​​perfectamente seguro de usar. type ahora tiene un -P para buscar solo el PATH y hash tiene el efecto secundario de que la ubicación del comando será hash (para una búsqueda más rápida la próxima vez que lo use), lo cual suele ser algo bueno, ya que probablemente verifique su existencia para poder usarlo realmente.

Como ejemplo simple, aquí hay una función que se ejecuta gdate si existe, de lo contrario date:

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

Alternativa con un conjunto completo de funciones

Puedes usar scripts-comunes para alcanzar su necesidad.

Para comprobar si hay algo instalado, puede hacer:

checkBin <the_command> || errorMessage "This tool requires <the_command>. Install it please, and then run this tool again."

La siguiente es una forma portátil de comprobar si existe un comando en $PATH y es ejecutable:

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

Ejemplo:

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

La verificación ejecutable es necesaria porque bash devuelve un archivo no ejecutable si no se encuentra ningún archivo ejecutable con ese nombre en $PATH.

También tenga en cuenta que si un archivo no ejecutable con el mismo nombre que el ejecutable existe anteriormente en $PATH, dash devuelve el primero, aunque se ejecute el último. Esto es un error y viola el estándar POSIX. [Informe de error] [Estándar]

Además, esto fallará si el comando que está buscando se ha definido como un alias.

Estoy de acuerdo con lhunath para desalentar el uso de which, y su solución es perfectamente válida para usuarios de Bash. Sin embargo, para ser más portátil, command -v se utilizará en su lugar:

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

Comando command es compatible con POSIX. Vea aquí su especificación: comando - ejecutar un comando simple

Nota: type es compatible con POSIX, pero type -P no es.

Tengo una función definida en mi .bashrc que facilita esto.

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

Aquí hay un ejemplo de cómo se usa (de mi .bash_profile.)

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

Depende de si desea saber si existe en uno de los directorios del $PATH variable o si conoce la ubicación absoluta de la misma. Si quieres saber si está en el $PATH variable, uso

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

de lo contrario usar

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

La redirección a /dev/null/ en el primer ejemplo suprime la salida del which .

Ampliando las respuestas de @ lhunath y @ GregV, aquí está el código para las personas que quieren poner fácilmente ese cheque dentro de un if declaración:

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

He aquí cómo usarlo:

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

Intente usar:

test -x filename

or

[ -x filename ]

Desde la página de manual de Bash en Expresiones condicionales:

 -x file
          True if file exists and is executable.

Para utilizar hash, como sugiere @lhunath, en un script de Bash:

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

Este script se ejecuta hash y luego verifica si el código de salida del comando más reciente, el valor almacenado en $?, es igual a 1. Si hash no encuentra foo, el código de salida será 1. Si foo está presente, el código de salida será 0.

&> /dev/null redirecciones Error estándar y salida estándar del hash para que no aparezca en pantalla y echo >&2 escribe el mensaje en error estándar.

Si comprueba la existencia del programa, probablemente lo ejecutará más tarde de todos modos. ¿Por qué no intentar ejecutarlo en primer lugar?

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

Es una verificación más confiable que el programa se ejecute que simplemente mirar los directorios PATH y los permisos de los archivos.

Además, puede obtener algunos resultados útiles de su programa, como su versión.

Por supuesto, los inconvenientes son que algunos programas pueden ser pesados ​​al iniciar y otros no tienen --version opción para salir inmediatamente (y con éxito).

Nunca obtuve las respuestas anteriores para trabajar en el cuadro al que tengo acceso. Para uno, type ha sido instalado (haciendo lo que more lo hace). Por tanto, se necesita la directiva incorporada. Este comando funciona para mí:

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

Verifique múltiples dependencias e informe el estado a los usuarios finales

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

Muestra de salida:

latex     OK
pandoc    missing

Ajustar el 10 a la longitud máxima del comando. No es automático, porque no veo una forma POSIX no detallada de hacerlo: ¿Cómo puedo alinear las columnas de una tabla separada por espacios en Bash?

Compruebe si algunos apt los paquetes se instalan con dpkg -s e instalarlos de otra manera.

Ver: Compruebe si hay un paquete apt-get instalado y luego instálelo si no está en Linux

Se mencionó anteriormente en: ¿Cómo puedo comprobar si existe un programa a partir de un script Bash?

hash foo 2>/dev/null: funciona con shell Z (Zsh), Bash, Dash y ceniza.

type -p foo: parece funcionar con Z shell, Bash y ash (BusyBox), pero no Dash (interpreta -p como argumento).

command -v foo: funciona con shell Z, Bash, Dash, pero no ash (BusyBox) (-ash: command: not found).

También tenga en cuenta que builtin no está disponible con Ash y Dash.

Hay un montón de opciones aquí, pero me sorprendió que no hubiera una sola línea rápida. Esto es lo que usé al comienzo de mis scripts:

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

Esto se basa en la respuesta seleccionada aquí y en otra fuente.

Comando -v funciona bien si la opción POSIX_BUILTINS está configurada para el <command> para probar, pero puede fallar si no. (Me ha funcionado durante años, pero recientemente me encontré con uno en el que no funcionó).

Encuentro que lo siguiente es más a prueba de fallas:

test -x "$(which <command>)"

Ya que prueba tres cosas: ruta, existencia y permiso de ejecución.

Utilice incorporados de Bash si puede:

which programname

...

type -P programname

Para los interesados, ninguna de las metodologías de las respuestas anteriores funciona si desea detectar una biblioteca instalada. Me imagino que le queda comprobar físicamente la ruta (potencialmente para archivos de encabezado y demás), o algo así (si está en una distribución basada en Debian):

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

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

Como puede ver en lo anterior, una respuesta "0" de la consulta significa que el paquete no está instalado. Esta es una función de "grep": un "0" significa que se encontró una coincidencia, un "1" significa que no se encontró ninguna coincidencia.

Yo diría que no hay ninguna forma portátil y 100% confiable debido a que cuelga aliases. Por ejemplo:

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

Por supuesto, solo el último es problemático (¡sin ofender a Ringo!). Pero todos son validos aliases desde el punto de vista de command -v.

Para rechazar los colgantes como ringo, tenemos que analizar la salida del shell incorporado alias comando y recurrir a ellos (command -v no es superior a alias aquí.) No hay ninguna solución portátil para ello, e incluso una solución específica de Bash es bastante tediosa.

Tenga en cuenta que una solución como esta rechazará incondicionalmente alias ls='ls -F':

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

Esto le dirá según la ubicación si el programa existe o no:

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

Mi configuración para un Debian servidor:

Tuve el problema cuando varios paquetes contenían el mismo nombre.

Por ejemplo: apache2. Entonces esta fue mi solución:

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
}

Si ustedes chicos / chicas no pueden hacer que las cosas en las respuestas aquí funcionen y se están arrancando el pelo de la espalda, intente ejecutar el mismo comando usando bash -c. Basta con mirar este delirio sonámbulo. Esto es lo que realmente sucede cuando ejecuta $ (subcomando):

Primero. Puede darle una salida completamente diferente.

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

Segundo. No le puede dar ningún resultado.

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

En caso de que quiera comprobar si existe un programa y es realmente un programa, no un comando integrado de Bash, entonces command, type y hash no son apropiados para las pruebas, ya que todos devuelven un estado de salida 0 para los comandos integrados.

Por ejemplo, existe el equipo programa que ofrece más funciones que el equipo comando incorporado. Para verificar si el programa existe, sugeriría usar which como en el siguiente ejemplo:

# 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

Quería que se respondiera la misma pregunta pero que se ejecutara dentro de un Makefile.

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

Podría ser más simple, simplemente:

#!/usr/bin/env bash                                                                
set -x                                                                             

# if local program 'foo' returns 1 (doesn't exist) then...                                                                               
if ! type -P foo; then                                                             
    echo 'crap, no foo'                                                            
else                                                                               
    echo 'sweet, we have foo!'                                                    
fi                                                                                 

Cambiar y guardar foo a vi para conseguir que la otra condición se dispare.

La variante hash tiene un problema: en la línea de comando puede, por ejemplo, escribir

one_folder/process

ejecutar el proceso. Para esto, la carpeta principal de one_folder debe estar en $ RUTA. Pero cuando intentas aplicar un hash a este comando, siempre tendrá éxito:

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

Secundo el uso de "comando -v". Por ejemplo, así:

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

El which El comando puede ser útil. hombre que

Devuelve 0 si se encuentra el ejecutable y devuelve 1 si no se encuentra o no es ejecutable:

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

Lo bueno de which es que averigua si el ejecutable está disponible en el entorno que which se ejecuta - ahorra algunos problemas ...

Tuve que comprobar si Git se instaló como parte de la implementación de nuestro CI servidor. Mi último script de Bash fue el siguiente (servidor Ubuntu):

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

Para imitar a Bash type -P cmd, podemos usar el compatible con POSIX 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; }

Si no hay ninguna externa type comando disponible (como se da por sentado aquí), podemos usar compatible con POSIX 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

Al menos en MacOS X v10.6.8 (Snow Leopard) usando Bash 4.2.24 (2) command -v ls no coincide con un movido /bin/ls-temp.

Respuesta tardía, pero esto es lo que terminé haciendo.

Solo verifico si el comando que ejecuto devuelve un código de error. Si devuelve 0, significa que el programa está instalado. Además, puede usar esto para verificar la salida de un script. Tomemos, por ejemplo, este guión.

foo.sh

#!/bin/bash
echo "hello world"
exit 1 # throw some error code

Ejemplos:

# outputs something bad... and exits
bash foo.sh $? -eq 0 || echo "something bad happened. not installed" ; exit 1

# does NOT outputs nothing nor exits because dotnet is installed on my machine
dotnet --version $? -eq 0 || echo "something bad happened. not installed" ; exit 1

Básicamente, todo lo que está haciendo es verificar el código de salida de una ejecución de comando. la respuesta más aceptada a esta pregunta será verdadera incluso si el código de salida del comando no es 0.