Bir programın Bash betiğinden olup olmadığını nasıl kontrol edebilirim?

Bir programın var olduğunu, bir hata döndürüp çıkacak veya komut dosyasıyla devam edecek şekilde nasıl doğrularım?

Kolay olmalı gibi görünüyor, ama beni çok yoruyor.

Cevap

POSIX uyumlu:

command -v <the_command>

Bash'a özgü ortamlar için:

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

açıklama

Kaçının which. Bu sadece (anlam builtins gibi çok az yapıyor kaldın fırlatma harici süreç sensin hash, typeya commandbir yol ucuzdur) dış komutları etkileri kolayca değişebilir ederken, aynı zamanda, aslında ne istediğinizi yapmak yerleşikleri güvenebilirsiniz sistemden sisteme.

Neden önemsiyorsun?

• Birçok işletim sistemleri var whicholduğunu bile bir çıkış durumunu ayarlamak gelmez , yani if which fooorada bile çalışmaz ve olacak her zaman rapor fooo (bazı POSIX kabukları için yapmasını görünen notu olmasa bile, var olan hashçok).
• Birçok işletim sistemi which, çıktıyı değiştirmek veya hatta paket yöneticisine bağlanmak gibi özel ve kötü şeyler yapar.

Yani, kullanma which. Bunun yerine aşağıdakilerden birini kullanın:

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

(Küçük yan not: bazıları 2>&-aynı 2>/dev/nullama daha kısa önerecektir - bu yanlıştır . Stderr'e yazmaya çalıştığında programda 2>&-bir hataya neden olan FD 2'yi kapatır , bu da başarılı bir şekilde yazmaktan ve çıktıyı atmaktan çok farklıdır. (ve tehlikeli!))

Eğer karma patlamanız ise /bin/shPOSIX'in söylediklerine dikkat etmelisiniz. typeve hash'nin çıkış kodları POSIX tarafından çok iyi tanımlanmamıştır hashve komut mevcut olmadığında başarılı bir şekilde çıktığı görülür (bunu henüz görmedim type). command'nin çıkış durumu POSIX tarafından iyi tanımlanmıştır, böylece muhtemelen en güvenli olanıdır.

Senaryonuz kullandığı takdirde bashde, POSIX kuralları meselesi artık gerçekten yok ve her iki typeve hashkullanımına tamamen güvenli hale gelir. typeşimdi var -Psadece arama yapmak PATHve hashkomutun konumu muhtemelen aslında amacıyla varlığını kontrol kullandığımızdan genellikle iyi bir şey olduğu, (daha hızlı arama dahaki sefere bunu kullanmak için) karma olacağını yan etkisi yoktur .

Basit bir örnek olarak, gdatevarsa, çalışan bir işlev , aksi takdirde date:

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

Aşağıdakiler, bir komutun var olup olmadığını $PATH ve yürütülebilir olup olmadığını kontrol etmenin taşınabilir bir yoludur :

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

Misal:

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

Yürütülebilir denetim gereklidir; çünkü bu adda yürütülebilir bir dosya bulunmazsa bash yürütülebilir olmayan bir dosya döndürür $PATH.

Ayrıca, yürütülebilir dosya ile aynı ada sahip yürütülebilir olmayan bir dosya daha önce varsa $PATH, sonrakinin yürütülmesine rağmen dash'in ilkini döndürdüğünü unutmayın. Bu bir hatadır ve POSIX standardını ihlal etmektedir. [ Hata raporu ] [ Standart ]

Ayrıca, aradığınız komut bir takma ad olarak tanımlanmışsa bu başarısız olur.

Lhunath'ın kullanımını caydırmak için katılıyorum whichve çözümü Bash kullanıcıları için tamamen geçerli . Ancak, daha portatif command -volmak için, bunun yerine kullanılacaktır:

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

Komut commandPOSIX uyumlu. Özellikleri için buraya bakın: komut - basit bir komut yürütme

Not: typePOSIX uyumludur, ancak type -Pdeğildir.

Bunu kolaylaştıran .bashrc dosyamda tanımlanan bir fonksiyonum var.

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

İşte nasıl kullanıldığına dair bir örnek (benim .bash_profile.)

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

$PATHDeğişken içindeki dizinlerden birinde var olup olmadığını bilmek veya değişkenin mutlak yerini bilmek isteyip istemediğinize bağlıdır . $PATHDeğişkende olup olmadığını bilmek istiyorsanız ,

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

aksi takdirde kullanın

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

/dev/null/İlk örnekte yeniden yönlendirme , whichprogramın çıktısını bastırır .

@ Lhunath ve @ GregV'nin cevaplarını genişleterek, bu kontrolü bir ififadeye kolayca koymak isteyenlerin kodu :

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

Bunu nasıl kullanacağınız aşağıda açıklanmıştır:

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

Kullanmayı deneyin:

test -x filename

veya

[ -x filename ]

Koşullu İfadeler altındaki Bash kılavuzundan :

 -x file
          True if file exists and is executable.

Kullanmak için hash, @lhunath anlaşılacağı gibi bir Bash komut:

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

Bu komut dosyası çalışır hashve en son kaydedilen komutun çıkış kodunun $?eşit olup olmadığını denetler 1. Eğer hashbulamazsa foo, çıkış kodu olacaktır 1. Varsa foo, çıkış kodu0 .

&> /dev/nullyönlendirmeleri standart hatasını ve standart çıktıyı gelen hashbu ekranda görünmez şekilde ve echo >&2standart hata mesajı yazar.

Erişebileceğim kutuda çalışmak için önceki cevapları hiç almadım. Birincisi, typekuruldu (ne moreyapıyor). Yani yerleşik yönerge gereklidir. Bu komut benim için çalışıyor:

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

Birden fazla bağımlılığı kontrol edin ve durumu son kullanıcılara bildirin

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

Örnek çıktı:

latex     OK
pandoc    missing

10Maksimum komut uzunluğunu ayarlayın . Otomatik değil, çünkü bunu yapmak için ayrıntılı olmayan bir POSIX yolu göremiyorum: Bash'ta boşlukla ayrılmış bir tablonun sütunlarını nasıl hizalayabilirim?

Bazı aptpaketlerin kurulu olup olmadığını kontrol edin dpkg -sve aksi halde kurun .

Bkz: apt-get paketinin kurulu olup olmadığını kontrol edin ve Linux'ta değilse kurun

Daha önce şu adreste bahsedildi: Bir programın Bash betiğinden olup olmadığını nasıl kontrol edebilirim?

Programın varlığını kontrol ederseniz, muhtemelen daha sonra yine de çalıştıracaksınız. Neden ilk etapta çalıştırmaya çalışmıyorsunuz?

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

Programın çalışıp çalışmadığını yalnızca PATH dizinlerine ve dosya izinlerine bakmaktan daha güvenilir bir şekilde kontrol edin.

Ayrıca, sürümü gibi programınızdan bazı yararlı sonuçlar alabilirsiniz.

Tabii ki dezavantajları bazı programların başlatılması için ağır olabileceği ve bazılarının --versionhemen (ve başarılı bir şekilde) çıkma seçeneğinin olmamasıdır.

hash foo 2>/dev/null: Z kabuğu (Zsh), Bash, Dash ve ash ile çalışır .

type -p foo: Z kabuğu, Bash ve ash ( BusyBox ) ile çalışıyor gibi görünüyor , ancak Dash ile değil ( -pargüman olarak yorumlanıyor ).

command -v foo: Z kabuğu, Bash, Dash ile çalışır, ancak ash (BusyBox) ( -ash: command: not found) ile çalışmaz .

Ayrıca builtinkül ve Dash ile mevcut olmadığını da unutmayın .

Aşağıdakileri yapabiliyorsanız Bash yerleşiklerini kullanın:

which programname

...

type -P programname

-vPOSIX_BUILTINS seçeneği sınanacak şekilde ayarlanmışsa komut iyi çalışır <command>, ancak değilse başarısız olabilir. (Benim için yıllarca çalıştı, ama son zamanlarda işe yaramadığı bir yerde karşılaştım.)

Aşağıdakilerin daha başarısız olduğunu düşünüyorum:

test -x $(which <command>)

Üç şeyi test ettiğinden: yol, varlık ve yürütme izni.

İlgilenenler için, yüklü bir kitaplığı algılamak istiyorsanız önceki yanıtlardaki yöntemlerden hiçbiri çalışmaz. Ya (fiziksel olarak üstbilgi dosyaları ve benzeri için) yolu veya böyle bir şey (Debian tabanlı bir dağıtımda iseniz) fiziksel olarak kontrol ile bırakıldığını hayal:

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

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

Yukarıdan görebileceğiniz gibi, sorgudan bir "0" cevabı paketin kurulu olmadığı anlamına gelir. Bu "grep" işlevidir - "0" bir eşleşme bulunduğunu, "1" eşleşmenin bulunmadığını gösterir.

Burada bir ton seçenek var, ama hızlı bir gömlek olmamasına şaşırdım. Senaryolarımın başında kullandığım şey bu:

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

Bu, burada seçilen cevaba ve başka bir kaynağa dayanmaktadır.

Sarkan aliases nedeniyle taşınabilir ve% 100 güvenilir bir yol olmadığını söyleyebilirim . Örneğin:

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

Tabii ki, sadece sonuncusu sorunlu (Ringo'ya suç yok!). Ancak hepsi alias, bakış açısından geçerli eslerdir command -v.

Böyle sarkan olanları reddetmek ringoiçin, kabuk yerleşik aliaskomutunun çıktısını ayrıştırıp bunlara geri dönmeliyiz ( burada command -vdaha üstün değil alias.) Bunun için taşınabilir bir çözüm ve hatta bir Bash- özel çözüm oldukça sıkıcıdır.

Böyle bir çözümün koşulsuz olarak reddedileceğini unutmayın alias ls='ls -F':

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

Bu, programın var olup olmadığını konuma göre söyleyecektir:

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

whichKomut yararlı olabilir. hangi adam

Yürütülebilir dosya bulunursa 0, yürütülebilir ya da yürütülebilir değilse 1 döndürür:

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

Güzel bir şey which, çalıştırılabilir ortamda whichçalıştırılabilir ortamda kullanılabilir olup olmadığını anlamasıdır - birkaç sorundan tasarruf sağlar ...

Debian kurulumum sunucusu :

Birden fazla paket aynı adı içerdiğinde sorun yaşadım.

Örneğin apache2. Bu benim çözümümdü:

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
}

Sizler / kızlar sizin cevaplarınızdaki şeyleri işe yaramıyorsa ve saçınızı sırtınızdan çekiyorsanız, aynı komutu kullanarak bash -c . Sadece bu somnambular deliryuma bakın. $ (Alt-komut) çalıştırdığınızda gerçekten olan budur:

İlk. Size tamamen farklı çıktılar verebilir.

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

İkinci. Size hiç çıktı veremez.

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

Hash-variant'ın bir tuzağı vardır: Komut satırına örneğin şunu yazabilirsiniz:

one_folder/process

işlemin yürütülmesi. Bunun için one_folder öğesinin üst klasörü $ PATH olmalıdır . Ancak bu komutu hash etmeye çalıştığınızda, her zaman başarılı olacaktır:

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

İkincisi "komut -v" kullanımını. Örneğin şöyle:

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

Git'in CI sunucumuzu dağıtmanın bir parçası olarak kurulduğunu kontrol etmek zorunda kaldım . Son Bash betiğim şöyleydi (Ubuntu sunucusu):

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

Bash'ları taklit etmek type -P cmdiçin POSIX uyumlu kullanabiliriz 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; }

Kullanılabilir herhangi bir harici typekomut yoksa ( burada verildiği gibi ) POSIX uyumlu kullanabiliriz 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

En azından Bash 4.2.24 kullanan Mac OS Xv10.6.8'de (Snow Leopard) (2)command -v ls eşleşmiyor /bin/ls-temp.

Bir program varsa durumunda denetlemek istediğiniz bir programı ve gerçekten bir Bash yerleşik komutu , daha sonra command, typevehash olmayan komutlar yerleşik için onlar gibi tüm return 0 çıkış durumu test etmek için benimsedikleri görülmüştür.

Örneğin, yerleşik zaman komutundan daha fazla özellik sunan bir zaman programı vardır . Programın var olup olmadığını kontrol etmek için aşağıdaki örnekte olduğu gibi kullanılmasını öneririm :which

# 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

Aynı sorunun bir Makefile içinde cevaplanmasını istedim.

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

Senaryo

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

Sonuç

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

Bunu kullanıyorum, çünkü çok kolay:

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

veya

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

Standart çıktıya kabuk yerleşiklerini ve programların yankı durumunu kullanır ve standart hataya hiçbir şey kullanmaz. Diğer yandan, bir komut bulunmazsa, durumu yalnızca standart hataya yansıtır.