Bash (:) içinde noop aradım, ancak iyi bir bilgi bulamadım. Bu operatörün tam amacı veya kullanım durumu nedir?

Aşağıdakileri denedim ve benim için şu şekilde çalışıyor:

[mandy@root]$ a=11
[mandy@root]$ b=20
[mandy@root]$ c=30
[mandy@root]$ echo $a; : echo $b ; echo $c
10
30

Lütfen bu operatörün herhangi bir kullanım durumunu gerçek zamanlı olarak veya kullanmanın zorunlu olduğu herhangi bir yerde bana bildirin.

Tarihsel nedenlerle daha fazlası var. İki nokta üst üste yerleşimi :tam olarak eşdeğerdir true. trueDönüş değeri önemli olduğunda, örneğin sonsuz döngüde kullanmak gelenekseldir :

while true; do
  echo 'Going on forever'
done

:Kabuk sözdizimi bir komut gerektirdiğinde kullanmak gelenekseldir, ancak yapacak hiçbir şeyiniz yoktur.

while keep_waiting; do
  : # busy-wait
done

:Tüm yerleşik tarihleri yolu geri Thompson kabuğu , öyleydi mevcut yılında Unix v6 . :Thompson kabuğunun gotoaçıklaması için bir etiket göstergesiydi . Etiket herhangi bir metin olabilir, bu nedenle :bir yorum göstergesi olarak ikiye katlanabilir (eğer yoksa goto comment, o : commentzaman etkili bir yorumdur). Bourne kabuğu yoktu gotoama tuttu :.

Yaygın bir deyim kullanır yani :olduğu : ${var=VALUE}, hangi setleri variçin VALUEbu ayar kaldırılamaz ve eğer hiçbir şey yapmazsa varzaten ayarlandı. Bu yapı sadece değişken ikamesi şeklinde mevcuttur ve bu değişken ikamesi bir şekilde bir komutun parçası olmalıdır: işlemsiz bir komut güzelce hizmet eder.

Ayrıca bkz . Kolon inşaası hangi amaca hizmet eder? .

Tüm kodu yorumladığımda if ifadeleri için kullanıyorum. Örneğin bir testiniz var:

if [ "$foo" != "1" ]
then
    echo Success
fi

ancak şunun içinde bulunan her şeyi geçici olarak yorumlamak istiyorsunuz:

if [ "$foo" != "1" ]
then
    #echo Success
fi

Bu, bash'nin sözdizimi hatası vermesine neden olur:

line 4: syntax error near unexpected token `fi'
line 4: `fi'

Bash'de boş bloklar (WTF) olamaz. Yani bir işlemsiz eklersiniz:

if [ "$foo" != "1" ]
then
    #echo Success
    :
fi

veya satırları yorumlamak için op no-op'u kullanabilirsiniz:

if [ "$foo" != "1" ]
then
    : echo Success
fi

Eğer kullanırsanız set- eo zaman || :için harika bir yoldur değil bir başarısızlık olursa senaryoyu çıkmak (açıkça bu da geçer yapar).

:Başarılı olan ancak hiçbir şey yapmayan bir komut sağlamak için kullanırsınız . Bu örnekte, "ayrıntı" komutu, varsayılan olarak, ayarı yapılarak kapatılmıştır :. 'V' seçeneği onu açar.

#!/bin/sh
# example
verbosity=:                         
while getopts v OPT ; do          
   case $OPT in                  
       v)        
           verbosity=/bin/realpath 
       ;;
       *)
           exit "Cancelled"
       ;;             
   esac                          
done                              

# `$verbosity` always succeeds by default, but does nothing.                              
for i in * ; do                   
  echo $i $($verbosity $i)         
done                              

$ example
   file

$ example -v
   file /home/me/file  

aliasArgümanları yoksay

Bazen herhangi bir tartışmaya gerek duymayan bir takma ada sahip olmak istersiniz. Bunu kullanarak yapabilirsiniz ::

> alias alert_with_args='echo hello there'

> alias alert='echo hello there;:'

> alert_with_args blabla
hello there blabla

> alert blabla
hello there

Bir kullanım, çok satırlı yorumlar olarak veya kodunuzun bir bölümünü burada bir dosya ile birlikte kullanarak test amaçlı olarak yorumlamaktır.

: << 'EOF'

This part of the script is a commented out

EOF

EOFİçerideki herhangi bir kodun değerlendirilmemesi için tırnak işaretleri kullanmayı unutmayın $(foo). Aynı zamanda gibi sezgisel sonlandırıcı adını kullanarak değerinde olabilir NOTES, SCRATCHPADya da TODO.

Benim iki tane.

POD yorumlarını katıştırın

Bir çok korkak bir uygulama :içindir bash komut POD yorumlarınızı gömmeMan sayfalarının hızlı bir şekilde oluşturulabilmesi . Elbette, sonunda tüm komut dosyası Perl ;-) ile yeniden yazılırdı.

Çalışma zamanı işlevi bağlama

Bu, çalışma zamanında bağlama işlevleri için bir tür kod modelidir. Fi, yalnızca belirli bir bayrak ayarlanmışsa bir şeyler yapmak için bir hata ayıklama işlevine sahip olun:

#!/bin/bash
# noop-demo.sh 
shopt -s expand_aliases

dbg=${DBG:-''}

function _log_dbg {
    echo >&2 "[DBG] $@"
}

log_dbg_hook=':'

[ "$dbg" ] && log_dbg_hook='_log_dbg'

alias log_dbg=$log_dbg_hook


echo "Testing noop alias..."
log_dbg 'foo' 'bar'

Sen alırsın:

$ ./noop-demo.sh 
Testing noop alias...
$ DBG=1 ./noop-demo.sh 
Testing noop alias...
[DBG] foo bar

Bazen işlemsiz cümlecikler kodunuzu daha okunaklı hale getirebilir.

Bu bir fikir meselesi olabilir, ama işte bir örnek. Diyelim ki iki unix yolu alarak çalışan bir fonksiyon oluşturdunuz. Bir yoldan diğerine cd yapmak için gereken 'değişim yolunu' hesaplar. İşlevinize, yolların her ikisinin de "/" ile başlaması gerektiği VEYA her ikisinin de olmaması gerektiğine dair bir kısıtlama koyarsınız.

function chgpath() {
    # toC, fromC are the first characters of the argument paths.
    if [[ "$toC" == / && "$fromC" == / ]] || [[ "$toC" != / && "$fromC" != / ]]
    then
        true      # continue with function
    else
        return 1  # Skip function.
    fi

Bazı geliştiriciler işlemsizliği kaldırmak isteyecek, ancak bu, koşullu olanı reddetmek anlamına gelir:

function chgpath() {
    # toC, fromC are the first characters of the argument paths.
    if [[ "$toC" != / || "$fromC" == / ]] && [[ "$toC" == / || "$fromC" != / ]]
    then
        return 1  # Skip function.
    fi

Şimdi -bence- if-cümlesinden işlevi yapmayı atlamak isteyeceğiniz koşullar o kadar açık değil. İşlemsizliği ortadan kaldırmak ve bunu açıkça yapmak için, if-cümlesini işlevin dışına taşımak istersiniz:

    if [[ "$toC" == / && "$fromC" == / ]] || [[ "$toC" != / && "$fromC" != / ]]
    then
        cdPath=$(chgPath pathA pathB)   # (we moved the conditional outside)

Bu daha iyi görünüyor, ancak çoğu zaman bunu yapamayız; kontrolün fonksiyon içinde yapılmasını istiyoruz.

Peki bu ne sıklıkla oluyor? Pek sık değil. Belki yılda bir veya iki kez. Yeterince sık oluyor ki bunun farkında olmalısın. Kodumun okunabilirliğini geliştirdiğini düşündüğümde (dilden bağımsız olarak) kullanmaktan çekinmiyorum.

Bir şekilde bu cevapla ilgili olarak, bu işlemsiz , çok dilli komut dosyalarını hacklemek için oldukça uygun buluyorum . Örneğin, burada hem bash hem de vimscript için geçerli bir yorum bulunmaktadır:

":" #    this is a comment
":" #    in bash, ‘:’ is a no-op and ‘#’ starts a comment line
":" #    in vimscript, ‘"’ starts a comment line

Elbette, biz de kullanmış olabiliriz true, ancak :bir noktalama işareti olması ve alakasız bir İngilizce kelime olmaması, bunun bir sözdizimi simgesi olduğunu açıkça ortaya koyuyor.

Birisinin neden çok dilli bir komut dosyası yazmak gibi zor bir şey yapmasına gelince (havalı olmasının yanı sıra): dosyaya Xatıfta bulunarak normalde birkaç farklı dilde birkaç komut dosyası yazdığımız durumlarda yararlıdır Y.

Böyle bir durumda, her iki komut dosyasını da tek bir çok dilli dosyada birleştirmek X, yolun belirlenmesi için herhangi bir çalışmayı önler Y(basitçe "$0"). Daha da önemlisi, programı hareket ettirmeyi veya dağıtmayı daha kolay hale getirir.

• Yaygın bir örnek. Shebang'larla ilgili iyi bilinen, uzun süredir devam eden bir sorun var: çoğu sistem (Linux ve Cygwin dahil) yorumlayıcıya yalnızca bir argümanın aktarılmasına izin veriyor . Aşağıdaki mesele:

  #!/usr/bin/env interpreter --load-libA --load-libB

  aşağıdaki komutu çalıştıracak:

  /usr/bin/env "interpreter --load-libA --load-libB" "/path/to/script"

  ve amaçlanan değil:

  /usr/bin/env interpreter --load-libA --load-libB "/path/to/script"

  Böylece, aşağıdakiler gibi bir sarmalayıcı komut dosyası yazarsınız:

  #!/usr/bin/env sh
  /usr/bin/env interpreter --load-libA --load-libB "/path/to/script"

  Polyglossia'nın sahneye girdiği yer burasıdır.

• Daha spesifik bir örnek. Bir keresinde diğer şeylerin yanı sıra Vim'i çağıran bir bash senaryosu yazmıştım. Vim'e seçenekle yapılabilecek ek kurulum vermem gerekiyordu --cmd "arbitrary vimscript command here". Ancak, bu kurulum önemliydi, bu yüzden onu bir dizede satır içine almak korkunç olurdu (eğer mümkünse). Bu nedenle, daha iyi bir çözüm, onu bir yapılandırma dosyasında extenso'da yazmak ve ardından Vim'in bu dosyayı -S "/path/to/file". Bu yüzden bir polyglot bash / vimscript dosyasıyla sonuçlandım.

Ayrıca varsayılan değişkenleri tanımlamak için komut dosyalarını kullandım.

: ${VARIABLE1:=my_default_value}
: ${VARIABLE2:=other_default_value}
call-my-script ${VARIABLE1} ${VARIABLE2}

bir başkasının başarısına zincirlemek istediğiniz bir komutunuz olduğunu varsayalım:

cmd="some command..."
$cmd
[ $? -eq 0 ] && some-other-command

ancak şimdi komutları koşullu olarak yürütmek istiyorsunuz ve yürütülecek komutları göstermek istiyorsunuz (kuru çalıştırma):

cmd="some command..."
[ ! -z "$DEBUG" ] && echo $cmd
[ -z "$NOEXEC" ] && $cmd
[ $? -eq 0 ] && {
    cmd="some-other-command"
    [ ! -z "$DEBUG" ] && echo $cmd
    [ -z "$NOEXEC" ] && $cmd
}

dolayısıyla DEBUG ve NOEXEC'i ayarlarsanız, ikinci komut asla görünmez. bunun nedeni, ilk komutun hiçbir zaman çalıştırılmamasıdır (çünkü NOEXEC boş değildir), ancak bu gerçeğin değerlendirilmesi sizi 1 dönüşüyle ​​bırakır, bu da alt komutun asla çalıştırılmayacağı anlamına gelir (ancak bunu istersiniz çünkü bir kuru çalışma). bu yüzden bunu düzeltmek için yığında kalan çıkış değerini bir noop ile sıfırlayabilirsiniz:

[ -z "$NOEXEC" ] && $cmd || :