which命令可能有用。男子谁

如果找到可执行文件，则返回0；如果找不到或不可执行，则返回1：

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

这样做的好处是，它可以确定可执行文件在运行环境中是否可用-这节省了一些问题。。。

尝试使用：

test -x filename

or

[ -x filename ]

从条件表达式下的Bash手册页：

-x文件如果文件存在且可执行，则为True。

这取决于您是否想知道它是否存在于$PATH变量中的某个目录中，或者您是否知道它的绝对位置

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

否则使用

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

在第一个示例中，重定向到/dev/null/会抑制哪个程序的输出。

如果您可以：

which programname

...

type -P programname

答复

POSIX兼容：

command -v <the_command>

示例用法：

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

对于Bash特定环境：

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

解释

避免使用。它不仅是一个外部进程，你启动它的目的很小（这意味着像哈希、类型或命令这样的内置程序要便宜得多），你还可以依赖内置程序来实际执行你想要的操作，而外部命令的效果很容易因系统而异。

为什么要在意？

许多操作系统都有一个甚至不设置退出状态的函数，这意味着if-which foo在那里甚至不起作用，并且总是报告foo存在，即使它不存在（注意，有些POSIX shell似乎也会为hash设置）。许多操作系统都会做一些自定义和邪恶的事情，比如更改输出，甚至挂接到包管理器。

所以，不要使用哪个。请使用以下选项之一：

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; }

（次要的补充说明：有些人会建议2>&-与2>/dev/null相同，但更短–这是不正确的。2>&关闭FD 2，这会在程序尝试写入stderr时导致错误，这与成功写入stderr并丢弃输出非常不同（而且很危险！））

如果你的hash bang是/bin/sh，那么你应该关心POSIX怎么说。POSIX并没有很好地定义类型和哈希的退出代码，当命令不存在时，可以看到哈希成功退出（还没有看到这种类型）。POSIX很好地定义了命令的退出状态，所以使用它可能是最安全的。

如果您的脚本使用bash，POSIX规则就不再重要了，类型和散列都变得非常安全。type现在有一个-P来搜索PATH，而hash的副作用是命令的位置将被散列（以便下次使用时更快地查找），这通常是一件好事，因为为了实际使用它，您可能会检查它的存在。

作为一个简单的例子，这里有一个函数，如果gdate存在，则运行它，否则运行date：

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

具有完整功能集的替代方案

您可以使用常见的脚本来满足您的需要。

要检查是否安装了某些东西，可以执行以下操作：

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

我从来没有得到以前的答案来处理我可以访问的盒子。首先，类型已经安装（做更多的事情）。因此需要内置指令。此命令适用于我：

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

对于感兴趣的人来说，如果您希望检测已安装的库，则前面的答案中的方法都不起作用。我想你要么要检查路径（可能是头文件之类的），要么就这样（如果你是基于Debian的发行版）：

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

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

从上面可以看到，查询中的“0”表示未安装包。这是“grep”的函数-“0”表示找到匹配项，“1”表示没有找到匹配项。

我找不到一个可行的解决方案，但编辑了一下后，我想到了这个。这对我有用：

dpkg --get-selections | grep -q linux-headers-$(uname -r)

if [ $? -eq 1 ]; then
        apt-get install linux-headers-$(uname -r)
fi

我在.bashrc中定义了一个函数，这使得这更容易。

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

下面是一个如何使用它的示例（来自我的.bash_profile）

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

我同意lhunath不鼓励使用which，他的解决方案对Bash用户完全有效。但是，为了更便于携带，应使用命令-v：

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

命令命令符合POSIX。参见此处了解其规范：command-execute一个简单的命令

注意：类型符合POSIX，但类型-P不符合。

我必须检查Git是否作为部署CI服务器的一部分安装。我最后的Bash脚本如下（Ubuntu服务器）：

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

为了模拟Bash的-P cmd类型，我们可以使用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; }

要像@lhunath建议的那样在Bash脚本中使用哈希：

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

此脚本运行哈希，然后检查最近命令的退出代码（存储在$？中的值）？，等于1。如果hash没有找到foo，则退出代码将为1。如果存在foo，则退出代码将为0。

&>/dev/null重定向哈希的标准错误和标准输出，以便它不会出现在屏幕上，echo>&2将消息写入标准错误。

哈希变量有一个陷阱：例如，可以在命令行中键入

one_folder/process

以执行进程。为此，one_folder的父文件夹必须位于$PATH中。但当您尝试散列此命令时，它总是会成功：

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

checkexists() {
    while [ -n "$1" ]; do
        [ -n "$(which "$1")" ] || echo "$1": command not found
        shift
    done
}

如果您检查程序是否存在，您可能会稍后运行它。为什么不先尝试运行它？

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

这是一个更值得信赖的检查程序运行，而不仅仅是查看PATH目录和文件权限。

此外，您可以从程序中获得一些有用的结果，例如其版本。

当然，缺点是有些程序启动起来会很重，有些程序没有--version选项可以立即（并成功）退出。

我支持使用“命令-v”。例如：

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

检查多个依赖项并向最终用户通知状态

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

样本输出：

latex     OK
pandoc    missing

将10调整为最大命令长度。这不是自动的，因为我看不到一种非冗长的POSIX方法：如何在Bash中对齐空格分隔表的列？

检查一些apt包是否与dpkg-s一起安装，否则安装。

请参阅：检查是否安装了apt-get包，如果它不在Linux上，则安装它

前面提到过：如何检查Bash脚本中是否存在程序？

hash foo 2>/dev/null:适用于Zshell（Zsh）、Bash、Dash和ash。

type-p foo：它似乎可以使用Z shell、Bash和ash（BusyBox），但不能使用Dash（它将-p解释为一个参数）。

命令-vfoo：适用于Z shell、Bash、Dash，但不适用于ash（BusyBox）（-ash:command:not found）。

还要注意，内置的ash和Dash不可用。

以下是检查命令是否存在于$PATH中并可执行的便携式方法：

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

例子：

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

需要进行可执行检查，因为如果$PATH中找不到具有该名称的可执行文件，bash将返回一个不可执行文件。

还请注意，如果$PATH中存在与可执行文件同名的不可执行文件，则dash会返回前者，即使后者会被执行。这是一个bug，违反了POSIX标准。[错误报告][标准]编辑：从破折号0.5.11（Debian 11）开始，这似乎是固定的。

此外，如果要查找的命令已定义为别名，则此操作将失败。

如果没有任何可用的外部类型命令（在这里是理所当然的），我们可以使用符合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

至少在Mac OS X v10.6.8（雪豹）上，使用Bash 4.2.24（2）命令-vls与移动的/bin/ls温度不匹配。

我的Debian服务器设置：

当多个包包含相同的名称时，我遇到了问题。

例如apache2。这就是我的解决方案：

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
}

如果你的男人/女孩不能在这里得到答案中的东西，并且你的头发从你的背部，尝试使用bash-c运行相同的命令。看看这个梦游性谵妄。这是运行$（子命令）时真正发生的情况：

第一它可以给你完全不同的输出。

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

第二它根本不会给你任何输出。

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

我使用这个，因为它非常简单：

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

or

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

它使用shell内置程序和程序的回声状态进行标准输出，而不使用标准错误。另一方面，如果找不到命令，它只会将状态返回到标准错误。

扩展@lhunath和@GregV的答案，下面是那些希望将该检查轻松放入if语句的人的代码：

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

以下是使用方法：

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

我想说，由于悬挂别名，没有任何可移植和100%可靠的方法。例如：

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

当然，只有最后一个是有问题的（林戈没有冒犯！）。但从command-v的角度来看，它们都是有效的别名。

为了拒绝像ringo这样的悬空命令，我们必须解析shell内置别名命令的输出并递归到它们中（这里命令-v并不优于别名）。没有任何可移植的解决方案，即使是特定于Bash的解决方案也相当乏味。

注意，类似这样的解决方案将无条件拒绝别名ls='ls-F'：

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

如果你想检查一个程序是否存在，是否真的是一个程序，而不是Bash内置命令，那么命令、类型和散列不适合测试，因为它们都会返回内置命令的0退出状态。

例如，时间程序提供了比时间内置命令更多的功能。要检查程序是否存在，我建议使用以下示例中的哪个：

# 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

GIT=/usr/bin/git                     # STORE THE RELATIVE PATH
# GIT=$(which git)                   # USE THIS COMMAND TO SEARCH FOR THE RELATIVE PATH

if [[ ! -e $GIT ]]; then             # CHECK IF THE FILE EXISTS
    echo "PROGRAM DOES NOT EXIST."
    exit 1                           # EXIT THE PROGRAM IF IT DOES NOT
fi

# DO SOMETHING ...

exit 0                               # EXIT THE PROGRAM IF IT DOES

剧本

#!/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"'

后果

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

这里有很多选择，但我很惊讶没有快速的一句话。这是我在脚本开始时使用的方法：

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

这是基于此处选择的答案和另一个来源。

如果为要测试的<Command>设置了POSIX_BUILTINS选项，则命令-v可以正常工作，但如果没有，则可能会失败。（多年来，它一直对我有效，但我最近遇到了一个不起作用的地方。）

我发现以下内容更能防止故障：

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

因为它测试三件事：路径、存在和执行权限。

我会尝试调用程序，例如--version或--help，并检查命令是否成功或失败

与set-e一起使用时，如果找不到程序，脚本将退出，您将得到一条有意义的错误消息：

#!/bin/bash
set -e
git --version >> /dev/null

这将根据位置判断程序是否存在：

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

假设您已经遵循了安全壳做法：

set -eu -o pipefail
shopt -s failglob

./dummy --version 2>&1 >/dev/null

这假设命令可以以这样的方式调用，即它（几乎）什么都不做，比如报告其版本或显示帮助。

如果找不到伪命令，Bash将退出并返回以下错误。。。

./my-script: line 8: dummy: command not found

这比其他命令-v（和类似的）回答更有用，也更不冗长，因为错误消息是自动生成的，并且还包含相关的行号。

我想回答同样的问题，但要在Makefile中运行。

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

它可能更简单，只是：

#!/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                                                                                 

将foo更改为vi以激发其他条件。

迟到的回答，但这就是我最后做的。

我只是检查我执行的命令是否返回错误代码。如果返回0，则表示程序已安装。此外，您还可以使用它检查脚本的输出。以这个脚本为例。

foo.sh

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

示例：

# 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

基本上，所有这些都是检查命令运行的退出代码。即使命令退出代码不是0，这个问题上最被接受的答案也将返回true。

仅zsh，但对于zsh脚本非常有用（例如，在编写完成脚本时）：

zsh/parameter模块可以访问内部命令哈希表等。来自man zshmodules：

THE ZSH/PARAMETER MODULE
       The zsh/parameter module gives access to some of the internal hash  ta‐
       bles used by the shell by defining some special parameters.


[...]

       commands
              This  array gives access to the command hash table. The keys are
              the names of external commands, the values are the pathnames  of
              the  files  that would be executed when the command would be in‐
              voked. Setting a key in this array defines a new entry  in  this
              table  in the same way as with the hash builtin. Unsetting a key
              as in `unset "commands[foo]"' removes the entry  for  the  given
              key from the command hash table.

尽管它是一个可加载的模块，但只要zsh不与--simulate一起使用，它似乎是默认加载的。

例子：

martin@martin ~ % echo $commands[zsh]
/usr/bin/zsh

要快速检查某个命令是否可用，只需检查哈希中是否存在密钥：

if (( ${+commands[zsh]} ))
then
  echo "zsh is available"
fi

请注意，散列将包含$PATH文件夹中的任何文件，无论它们是否可执行。为了绝对确定，您必须对此进行统计：

if (( ${+commands[zsh]} )) && [[ -x $commands[zsh] ]]
then
  echo "zsh is available"
fi

#!/bin/bash
a=${apt-cache show program}
if [[ $a == 0 ]]
then
echo "the program doesn't exist"
else
echo "the program exists"
fi

#程序不是字面意思，您可以将其更改为要检查的程序名称