Bu soruyu sormam neredeyse 10 yıl Linux kullanmamı sağladı. Hepsi deneme yanılma ve gece geç saatlerde internette sörf yapmanın rastgele bir yanıydı.

Ancak insanlar bunun için 10 yıla ihtiyaç duymamalı. Eğer Linux ile yeni başlıyor olsaydım, şunu bilmek isterdim: Ne zaman takma ad, ne zaman kod yazacak ve ne zaman bir işlev yazacak?

Takma adlar söz konusu olduğunda, takma ad almayan çok basit işlemler için takma ad kullanırım.

alias houston='cd /home/username/.scripts/'

Bu çok açık görünüyor. Ancak bazı insanlar bunu yapar:

alias command="bash bashscriptname"

(ve .bashrcdosyaya ekleyin )

Bunu yapmak için iyi bir sebep var mı? Gerçekten çok çalışıyorum, ancak bunu yapmak istediğim koşulları gerçekten düşünemiyorum. Bu nedenle, bunun bir fark yaratabileceği bir uç vaka varsa, lütfen aşağıdaki yanıtı verin.

Çünkü chmod +xorası PATH’e bir şeyler koyacağım ve yıllar süren Linux deneme yanılma sonucunda ortaya çıkan başka bir şey.

Bu beni bir sonraki konuya getiriyor. Örneğin, ben gizli bir klasörü (katma .scripts/sadece benim için bir satır ekleyerek benim PATH ev dizininde) .bashrc( PATH=$PATH:/home/username/.scripts/yürütülebilir orada automagicallylar otomatik olarak tamamlar olarak), bu yüzden herhangi bir şey.

Gerekirse.

Buna gerçekten ihtiyacım yok, değil mi? Bunu sadece Python gibi kabuk olmayan diller için kullanırdım.

Eğer kabuk buysa, sadece aynı şekilde bir fonksiyon yazabilirim .bashrc:

funcname () {
  somecommand -someARGS "$@"
}

Dediğim gibi, deneme yanılma yoluyla bunun birçoğunu öğrendim. Ve sadece işlevselliklerin güzelliğini gerçekten bilgisayarım öldüğünde gördüm ve çevremdeki insanların bilgisayarlarını kullanmadıkları zamanlarda kullanmak zorunda kaldım.

Komple bir dizini bilgisayardan bilgisayara taşımak yerine, hiç bir zaman bile tek bir değişiklik yapmadıkları için herkesin .bashrc'sini kendim ile değiştirdim.

Ama bir şey özledim mi?

Peki, yeni başlayan bir Linux kullanıcısına ne zaman takma ad, ne zaman kod yazacak ve ne zaman bir fonksiyon yazacaksınız?

Açık değilse, buna cevap verenlerin üç seçeneğin de hepsini kullanacağını farz ediyorum. Yalnızca takma adlar kullanıyorsanız, ya da sadece komut dosyalarını kullanıyorsanız ya da sadece fonksiyonları kullanıyorsanız veya sadece takma adlar ve komut dosyaları veya takma adlar ve fonksiyonlar veya komut dosyaları ve fonksiyonlar kullanıyorsanız, bu soru size yönelik değildir.

Bir takma ad etkin bir şekilde (genel olarak) bir komutun varsayılan seçeneklerini değiştirmekten daha fazlasını yapmamalıdır. Bu, komut adındaki basit metin değişimlerinden başka bir şey değildir. Argümanlarla hiçbir şey yapamaz, fakat onları çalıştığı komuta iletir. Dolayısıyla, tek bir komutun önüne bir argüman eklemeniz gerekirse, bir takma ad çalışır. Ortak örnekler

# Make ls output in color by default.
alias ls="ls --color=auto"
# make mv ask before overwriting a file by default
alias mv="mv -i"

Bir takma addan daha karmaşık bir şey yapmanız gerektiğinde, ancak kendi başına kullanmayacağınız bir işlev kullanılmalıdır. Örneğin, bu cevabıgrep bir boru hattında olup olmadığına bağlı olarak varsayılan davranışını değiştirmek hakkında sorduğum bir soruya yanıtlayın :

grep() { 
    if [[ -t 1 ]]; then 
        command grep -n "$@"
    else 
        command grep "$@"
    fi
}

Bu, işleve mükemmel bir örnek çünkü bir takma ad için çok karmaşık (bir koşula göre farklı varsayılanlar gerektirir), ancak etkileşimli olmayan bir komut dosyasında ihtiyacınız olacak bir şey değil.

Çok fazla işlev veya işlev çok fazla alırsanız, bunları gizli bir dizindeki ayrı dosyalara koyun ve bu dosyaları kendi dizininize yerleştirin ~/.bashrc:

if [ -d ~/.bash_functions ]; then
    for file in ~/.bash_functions/*; do
        . "$file"
    done
fi

Bir senaryo kendi başına durmalıdır. Tekrar kullanılabilecek veya birden fazla amaç için kullanılabilecek bir şey olarak değere sahip olmalıdır.

Diğer cevaplar kişisel zevkinize dayanan bazı yumuşak genel kurallar sağlar, ancak senaryolar, işlevler veya takma adlar arasında karar verirken göz önünde bulundurulması gereken önemli gerçekleri göz ardı edin .

Diğer Adlar ve İşlevler

• Diğer takma ve işlevlerin tüm içeriği kabuğun hafızasına kaydedilir.
• Bunun doğal bir sonucu, takma adlardır ve işlevler yalnızca geçerli kabuk tarafından kullanılabilir ve metin düzenleyicileri, komut dosyaları ve hatta aynı kabuğun alt örnekleri gibi kabuktan çağırabileceğiniz diğer programlar tarafından kullanılamaz.
• Takma adlar ve işlevler geçerli kabuk tarafından yürütülür, yani kabuğun içinde çalışır ve kabuğun o anki çevresini etkiler.

Kodlar

• Kabuklar, komut dosyalarını bellekte tutmaz. Bunun yerine, komut dosyaları her gerektiğinde depolandıkları dosyalardan okunur. Komut dosyası bir $PATHarama yoluyla bulunursa , birçok kabuk ileride yapılacak $PATHaramalarda zaman kazanmak için yol adının bir miktarını bellekte saklar , ancak bu kullanılmadığında bir komut dosyasının hafıza ayak izinin kapsamıdır.

• Komut dosyaları, işlevlerden ve diğer adlardan çok daha fazla şekilde çağrılabilir. Bir yorumlayıcıya argüman olarak geçirilebilir sh script, doğrudan çalıştırılabilir olarak çağrılabilir veya çağrılabilir, bu durumda shebang satırındaki (örneğin #!/bin/sh) yorumlayıcıyı çalıştırmak için çağrılır. Her iki durumda da, komut dosyası, ortamını hiçbir şekilde etkileyemeyen, kabuğundan farklı olan kendi ortamıyla ayrı bir tercüman işlemi tarafından çalıştırılır. Gerçekten de, tercüman kabuğunun çağıran kabuğa uyması bile gerekmez. Bu şekilde çağrılan komut dosyaları herhangi bir sıradan çalıştırılabilir gibi göründüğü için, herhangi bir program tarafından kullanılabilir.

  Son olarak, bir komut dosyası mevcut kabuk tarafından .veya bazı kabuklarda okunabilir ve çalıştırılabilir source. Bu durumda, senaryo sürekli bellekte tutulmak yerine, istek üzerine okunan bir fonksiyon gibi davranır.

Uygulama

Yukarıda verilenleri göz önünde bulundurarak, bir şeyin bir komut dosyası veya işlev / takma isim yapıp yapmamasına ilişkin bazı genel kurallar bulabiliriz.

• Kabuğunuzun dışındaki diğer programların kullanabilmesi gerekiyor mu? Eğer öyleyse, bir senaryo olmalı.

• Yalnızca etkileşimli bir kabuktan erişilebilir olmasını mı istiyorsun? Harici komutları / komut dosyalarını etkilemeden etkileşimli olarak çalıştırıldığında birçok komutun varsayılan davranışını değiştirmek istemek yaygındır. Bu durumda, kabuğun "sadece etkileşimli mod" rc dosyasında ayarlanmış bir diğer ad / işlev kullanın ( bashbunun için .bashrc).

• Kabuğun ortamını değiştirmesi gerekiyor mu? Hem bir işlev / diğer ad hem de kaynak kodlu bir komut dosyası olası seçimlerdir.

• Sık kullandığınız bir şey mi? Bellekte saklamak muhtemelen daha verimlidir, bu nedenle mümkünse bir işlev / diğer ad yapın.

• Tersine, nadiren kullandığınız bir şey mi? Bu durumda, ihtiyacınız olmadığında hafızayı korumanın anlamı yoktur, bu yüzden bir senaryo yapın.

^{Functions İşlevler ve diğer adlar bazı önemli farklılıklara sahip olsa da, işlevler diğer adların yapabileceği her şeyi yapabileceği için birlikte gruplanırlar. Diğer adlar yerel değişkenlere sahip olamazlar ve bağımsız değişkenleri işleyemezler ve bir satırdan daha uzun bir şey için elverişsizdirler.}

^{² Bir Unix sistemindeki her çalışan işlem , varsayılan yerel ayar ve çalıştırılabilir arama yolu belirlemek için olduğu gibi, genellikle genel yapılandırma ayarları içeren bir çift çiftten oluşan bir ortama sahiptir .variable=valueLANGPATH}

Bence her insanın zevkine kalmış. Benim için mantık şöyle gider:

• İlk önce bir takma ad yapmaya çalışıyorum, çünkü en basit olanı.
• Eğer bir şey bir satıra sığmayacak kadar karmaşıksa, onu bir işlev yapmaya çalışırım.
• Fonksiyon bir düzine çizginin ötesinde büyümeye başladığında onu bir betiğe koyarım.

Şey yapmaktan sizi kısıtlamak için hiçbir şey yoktur çalışır .

En azından kısmen kişisel zevk meselesi. Öte yandan, bazı açık fonksiyonel ayrımlar vardır:

• takma adlar: yalnızca basit metin değiştirmeleri için uygun, argüman / parametre yok
• fonksiyonlar: yazması / kullanması kolay, tam kabuk komut dosyası özelliği, yalnızca bash içinde kullanılabilir
• komut dosyaları: az çok benzer işlevler, ancak bash dışında da kullanılabilir (çağrılabilir)

Kabuk komut dosyalarına bakmak Son birkaç yıldır yaptığım takma adları yazmaktan neredeyse hiç vazgeçtim (çünkü hepsi zaman içinde işlevlere dönüşme eğilimindedir) ve sadece bash olmayan ortamlarda da kullanılabilir olmaları gerekiyorsa betikler yazar.

Not: alias command="bash bashscriptname"Aslında bunu yapmak için bir sebep görmüyorum. bashscriptname$ PATH'ta olmasa bile , basit alias c=/path/to/scriptyeterli olacaktır.

İşte takma adlar ve işlevlerle ilgili bazı ek noktalar:

• Aynı adlı diğer ad ve işlev bir arada olabilir
• takma ad alanı önce aranıyor (ilk örneğe bakın)
• takma olamaz (ikinci örneğe bakın) (me) altkabuklarda ya da etkileşimli değildir ortamında belirlenen olmak

Örneğin:

alias f='echo Alias'; f             # prints "Alias"
function f { echo 'Function'; }; f  # prints "Alias"
unalias f; f                        # prints "Function"

Gördüğümüz gibi, takma adlar ve işlevler için ayrı ad alanları vardır; declare -A -p BASH_ALIASESve declare -f f(bunların her ikisi de bellekte saklanır) tanımlarını yazdıran daha fazla ayrıntı bulunabilir .

Takma ad sınırlamalarını gösteren örnek:

alias a='echo Alias'
a        # OK: prints "Alias"
eval a;  # OK: prints "Alias"
( alias a="Nested"; a );  # prints "Alias" (not "Nested")
( unalias a; a );         # prints "Alias"
bash -c "alias aa='Another Alias'; aa"  # ERROR: bash: aa: command not found

Gördüğümüz gibi, takma adlar fonksiyonlardan farklı olarak nesnel değildir. Ayrıca, kullanımı etkileşimli oturumlarla sınırlıdır.

Son olarak, bir takma adda rasgele bir hesaba sahip olabileceğinizi unutmayın, şöyle bir işlevi hemen çağırın.

alias a_complex_thing='f() { do_stuff_in_function; } f'

Git takma adları durumunda zaten yaygın kullanımda olan. Bir işlev bildirmek yerine bunu yapmanın yararı, takma adınızın aynı adlı bir işlevi bildiren .bir komut dosyasını kaynak kullanarak (veya kullanarak ) değiştirilememesidir.

Bir senaryo ne zaman yazılır ...

• Komut dosyaları, yazılım bileşenlerini (diğer bir deyişle araçlar, komutlar, işlemler, çalıştırılabilir programlar, programlar), daha karmaşık bileşenlere monte edilebilecek daha karmaşık bileşenlere birleştirir.
• Betikler genellikle çalıştırılabilir hale getirilir, böylece isimlerle çağrılabilirler. Çağrıldığında, betiğin çalışması için yeni bir alt işlem oluşturulur. Herhangi bir exported değişkeninin ve / veya işlevinin kopyaları betiğe değer olarak iletilir . Bu değişkenlerin değişiklikler yapmak değil geri ana senaryoya yaymak.
• Komut dosyaları, çağıran komut dosyasının parçasıymış gibi yüklenebilir (kaynak kodlu). Bu, diğer bazı dillerin "import" veya "include" dedikleri ile aynıdır. Kaynak verildiğinde mevcut süreç içinde yürütülürler. Hiçbir alt işlem üretilmez.

Ne zaman bir fonksiyon yazılır ...

• İşlevler, önceden yüklenmiş kabuk komut dosyalarıdır. Ayrı bir komut dosyası çağırmaktan biraz daha iyi performans gösteriyorlar, ancak yalnızca mekanik diskten okunması gerekiyorsa. Bugünün flashdrives, SSD'ler ve Linux'un kullanılmayan RAM'deki önbelleğe alınması, bu gelişmeyi büyük ölçüde ölçülemez kılıyor.
• İşlevler, modülerlik, enkapsülasyon ve tekrar kullanımın temel prensibi olarak işlev görür. Senaryoların netliğini, güvenilirliğini ve bakımını arttırırlar.
• Bir işlevi çağırmak için kullanılan sözdizimi kuralları bir çalıştırılabilirini çağırmakla aynıdır. Yürütülebilir dosya adıyla aynı işlev çalıştırılabilir dosya yerine çağrılır.
• İşlevler içinde bulundukları komut dosyasına yereldir.
• İşlevler dışa aktarılabilir ( değere göre kopyalanır ), böylece komut dosyaları içinde kullanılabilirler. Bu nedenle, işlevler yalnızca ebeveynlere değil, yalnızca çocuk işlemlerine yayılır.
• İşlevler, genellikle diğer komut dizilerinden kaynaklanmak üzere kitaplıklara (yalnızca işlev tanımlarına sahip bir komut dosyası) birleştirilen yeniden kullanılabilir komutlar oluşturur.

Takma ad yazarken ...

• Bash takma adları, if / then ve for / do döngüleri gibi kabuk betiği yapıları içerisinde çalışmaz ; bu nedenle etkileşimli bir komut satırında yalnızca klavye kısayolları olarak kullanılmalıdır. Bu nedenle, tüm diğer takma tanımlar genellikle ~/.profileveya gibi uygun giriş betiğinde bulunur ~/.bashrc.

Kütüphane komut dosyaları gibi komut dosyalarında, bazen bir işlevin yeniden adlandırıldığı, ancak geriye dönük uyumluluk gerektiği gibi bir işleve ilişkin takma ad gerekir. Bu, tüm argümanlarını yeni işleve ileten eski isimle basit bir işlev oluşturarak başarılabilir ...

# A bash in-script 'alias'
function oldFunction () { newFunction "$@"; }

İnanmadığım başka bir şey daha ortaya çıktı: bir fonksiyon, çağıran süreç bağlamında yürütülürken, bir komut dosyası yeni bir kabuk çatallıyor.

Bu performans için önemli olabilir - bir fonksiyon daha hızlıdır, çünkü değildir fork()ve exec(). Normal koşullarda, fark önemsizdir, ancak belleği olan ve sayfa deviren bir sistemde hata ayıklama yapıyorsanız, büyük bir fark yaratabilir.

Ayrıca, mevcut kabuk ortamınızı değiştirmek istiyorsanız, bir işlev kullanmalısınız. Örneğin, bir işlev $PATHmevcut kabuk için komut aramasını değiştirebilir , ancak bir betik / çatal kopyasında çalıştığı için bir komut dosyası değiştirilemez $PATH.

Komut dosyası, diğer ad ve komut dosyası ve işlev birbirini dışlamaz. Takma adları ve işlevleri komut dosyalarında saklayabilir ve yapabilirsiniz.

Betikler sadece kalıcı hale getirilmiş kodlardır . Gelecekte kullanmak istediğiniz faydalı işlevler ve diğer adlar komut dosyalarında depolanır. Ancak, bir komut dosyası genellikle birden fazla işlevin bir koleksiyonudur.

Yana adlar parametreli değildir , bunlar çok sınırlıdır; genellikle bazı varsayılan parametreleri tanımlamak için.

Bir işlev, daha küçük ve kullanışlı parçalara ayrılamayan birkaç kod satırından oluşan iyi tanımlanmış bir kavram olan ayrı bir kod birimidir ; biri doğrudan veya diğer işlevler tarafından yeniden kullanılabilir.

Çok hızlı olması gerekiyorsa, bir takma ad veya işlev yapın.

Tercih ettiğiniz kabuğun dışında kullanılabilirse, onu bir komut dosyası yapın. ¹

Argümanlar alırsa, bir işlev veya komut dosyası yap.

Özel karakterler içermesi gerekiyorsa, onu bir diğer ad veya bir komut dosyası yapın. ²

Sudo ile çalışması gerekirse, bir takma ad veya bir komut dosyası yapın. ³

Oturumu kapatıp girmeden kolayca değiştirmek istiyorsanız, bir komut dosyası daha kolaydır. ⁴

Dipnotlar

¹ Ya da bir takma ad yapın, yerleştirin ~/.envve ayarlayın export ENV="$HOME/.env", ancak taşınabilir şekilde çalışması için karmaşık bir işlemdir.

² İşlev adları tanımlayıcı olmalıdır, bu nedenle bir harfle başlamalıdır ve yalnızca harf, rakam ve alt çizgi içerebilir. Mesela bir takma adım var alias +='pushd +1'. Bir fonksiyon olamaz.

^{3 Diğer} adı ekleyin alias sudo='sudo '. Aynen diğer herhangi bir komut gibi strace, gdbvb ilk argüman olarak bir komut alır.

⁴ Ayrıca bakınız: fpath. Tabii ki de yapabilir source ~/.bashrcveya benzer, ancak bunun sıklıkla başka yan etkileri vardır.

Sadece birkaç not eklemek için:

• Sudo ile yalnızca ayrı bir komut dosyası kullanılabilir (örneğin bir sistem dosyasını düzenlemeniz gerekirse), örneğin:

sudo v /etc/rc.conf  #where v runs vim in a new terminal window;

• Yalnızca takma adlar veya işlevler, sistem komutlarını aynı adla değiştirebilir (komut dosyalarınızı PATH'ın sonuna doğru eklerseniz, yanlışlıkla bir sistem komutuna aynı adda bir komut dosyasıyla aynı ad veya kötü niyetli bir komut dosyası oluştururken güvenlik için uygun olduğunu düşünüyorum). Örneğin:

alias ls='ls --color=auto'  #enable colored output;

• Takma adlar ve işlevler yürütme için daha az bellek ve zaman alır, ancak yüklenmeleri zaman alır (çünkü kabuk size sormadan önce hepsini yorumlaması gerekir). Düzenli olarak yeni kabuk işlemleri yapıyorsanız bunu göz önünde bulundurun, örneğin:

# pressing key to open new terminal
# waiting for a few seconds before shell prompt finally appears.

Bunun dışında mümkün olan en basit formu kullanabilirsiniz, örneğin önce takma adı, sonra işlevi, sonra betiği düşünebilirsiniz.

Benim kuralım:

• aliases - bir komut, parametre yok
• fonksiyonlar - bir komut bazı parametreler
• script - birkaç komut, parametre yok

Çok kullanıcılı (veya çok sysamin) bir ortamda, kısa bir 'şey yürütmek ....' sargısı olmasına rağmen her şey için komut dosyaları kullanıyorum.

Elbette, teknik olarak bir takma ad veya işlevden daha yavaş / daha az etkilidir, ancak neredeyse hiçbir zaman önemi yoktur - ve yolunda olması şartıyla, bir komut dosyası her zaman çalışır.

Özelliğiniz cudo'dan, sudo veya env gibi azaltılmış veya değiştirilmiş bir ortama sahip bir şeyden çağrılabilir veya kullanıcı yalnızca sizin için farklı bir kabuk kullanıyor olabilir - tümü veya bir takma adı veya işlevi bozması muhtemeldir.

Performansa duyarlı bir şeyiniz varsa, bunu özel bir durum olarak ele alın veya daha iyisi, daha işlevsel bir betik dilinde yeniden yazmak için bir tetikleyici olduğunu düşünün.

Yalnızca diğer komut dosyalarında kullanılacak özelliklerden bahsediyorsak, standart bir kabuk tanımlamayı ve sadece olabilecek bir fonksiyon kitaplığı komut dosyası yazmayı da düşünebilirsiniz. Ben diğer tüm senaryolara kaynak.

T

Takma Ad Kullanmak İstediğiniz Olası Bir Durum Örneği

Bunun eski bir yazı olduğunu biliyorum ama neredeyse bir komut dosyasıyla bir diğer ad birleşimi kullanmak zorunda kaldığım ve bir işlev kullanmamayı seçtiğim bir durumu belirtmek istiyorum.

Ben ~/.bin/denilen bir komut dosyası var setupaşağıdakileri yapar: ¹

1. beni belirli bir dizine getiriyor.
2. Birkaç değişken tanımlar.
3. dizinin durumu hakkındaki mesajları yazdırır. ²

Mesele şu ki, sadece koşacak setup <project-name>olsaydım, bu değişkenleri tanımlamazdım ve dizine hiç giremezdim. En iyi bulduğum çözüm, bu betiği PATHeklemek alias setup=". ~/.bin/setup", ~/.bashrcya da her neye eklemek oldu .

Notlar:

1. Bu görev için bir komut dosyası kullandım ve bir işlev değil, özellikle uzun sürdüğü için değil, düzenleyebildiğim için ve düzenlemeyi yaptıktan sonra yenilemek istersem dosyayı kaynaklamak zorunda kalmam.
2. Tüm dotfiles'imi yeniden yüklemek için bir senaryo oluştururken de benzer bir durum bana karşı geldi. ³

1. Komut , altındaki dotfiles depomda mevcut .bin/.
2. Senaryo hakkında : Ben, bu senaryona, önceden tanımladığım projenin adı olan bir argüman verdim. Daha sonra komut dosyası, belirli bir csvdosyaya göre bana doğru dizine getirmeyi bilir . Tanımladığı değişkenler bu dizindeki makefile dosyasından alınmıştır. Senaryo daha sonra yayınlanıyor ls -lve git statusbana orada neler olduğunu gösteriyor.
3. Bu script aynı zamanda dotfiles deposunda da mevcut .bin/.

Bir komut dosyası ne zaman yazılmalı

Komutu kabuktan başka bir araçtan çalıştırmak isteyebilirsiniz.

Bu vim (benim için) içerir: yazılı filtreleri ve diğer programları komut :%!my-filterdosyası olarak kullanarak, bir dosyayı program aracılığıyla editörümden filtrelemek gibi bir şey yapabilirim .

Eğer my-filterbir işlev veya takma vardı, bu mümkün olmazdı.