Neden kabuk otomatik olarak “işe yaramaz kedi kullanımı” nı düzeltmiyor? [kapalı]

Birçok insan satır boyunca kod içeren oneliner ve scriptler kullanır

cat "$MYFILE" | command1 | command2 > "$OUTPUT"

Birincisine catgenellikle "işe yaramaz kedi kullanımı" denir, çünkü teknik olarak, /usr/bin/cateğer komut olsaydı, bundan kaçınılması gereken yeni bir işlem başlatmayı gerektirir.

< "$MYFILE" command1 | command2 > "$OUTPUT"

Çünkü o zaman kabuk sadece başlaması command1ve stdinverilen dosyayı göstermesi yeterlidir .

Kabuk neden bu dönüşümü otomatik olarak yapmıyor? "Kedinin işe yaramaz kullanımı" sözdiziminin okunmasının daha kolay olduğunu ve kabukların otomatik olarak işe yaramaz kediden kurtulmak için yeterli bilgiye sahip olması gerektiğini düşünüyorum. catKabuk yolunda bir ikili kullanmanın içten yerine uygulamaya izin verilmelidir böylece POSIX standardında tanımlanmıştır. Kabuk, yalnızca tam bir argüman sürümü için uygulama içerebilir ve yoldaki ikili dosyaya geri dönebilir.

2 komut eşdeğer değildir: hata işlemeyi düşünün:

cat <file that doesn't exist> | less Borulu programa aktarılacak boş bir akış üretecek ... böylece hiçbir şey göstermeyen bir ekran ile sona erecek.

< <file that doesn't exist> less çubuğu açamayacak ve daha sonra hiç açmayacak.

Birincisini ikinciye değiştirmeye çalışmak, programı potansiyel olarak boş bir girişle çalıştırmayı bekleyen herhangi bir sayıda betiği kırabilir.

"Yararsız kullanımı cat", kodunuzu nasıl yazdığınızla ilgili olarak, komut dosyasını çalıştırdığınızda gerçekte neyin çalıştığından daha fazladır. Bu bir tür tasarım karşıtı model , muhtemelen daha verimli bir şekilde yapılabilecek bir şeye gitmenin bir yolu. Yeni bir araç oluşturmak için verilen araçların en iyi şekilde nasıl birleştirileceğini anlamadaki bir başarısızlıktır. Bir boru hattında birkaç sedve / veya awkkomutları bir araya getirmenin bazen aynı anti-paternin bir belirtisi olduğu söylenebilir.

catBir komut dosyasında "yararsız kullanım" örneklerinin düzeltilmesi, öncelikle komut dosyasının kaynak kodunun elle düzeltilmesi sorunudur. ShellCheck gibi bir araç , bariz durumlara dikkat çekerek bu konuda yardımcı olabilir:

$ cat script.sh
#!/bin/sh
cat file | cat

$ shellcheck script.sh

In script.sh line 2:
cat file | cat
    ^-- SC2002: Useless cat. Consider 'cmd < file | ..' or 'cmd file | ..' instead.

Kabuğu bu işlemi otomatik olarak yapmak, kabuk komut dosyalarının doğası nedeniyle zor olacaktır. Bir komut dosyasının yürütme biçimi, ana işleminden miras alınan ortama ve kullanılabilir dış komutların özel uygulamasına bağlıdır.

Kabuğun ne catolduğunu bilmesi gerekmez . Potansiyelinizdeki herhangi bir yerden herhangi bir komut $PATHveya bir fonksiyon olabilir.

Eğer öyle olsaydı yerleşik bir (bazı kabuklarda olabilir), bu komutun olur onun yerleşik sematiğinde bilemez olarak boru hattını yeniden düzenleme yeteneğine sahip catkomutu. Bunu yapmadan önce, orijinalden sonra boru hattındaki bir sonraki komut hakkında varsayımlarda bulunmak zorunda kalacaktı cat.

Standart girdiden okunmanın bir boruya bağlandığında ve bir dosyaya bağlandığında biraz farklı davrandığını unutmayın. Bir boru aranamayabilir, bu yüzden boru hattındaki bir sonraki komutun ne yaptığına bağlı olarak, boru hattının yeniden düzenlenmiş olması halinde farklı olabilir veya olmayabilir (girişin aranıp aranamayacağını tespit edebilir ve varsa veya farklı olup olmadığına karar vermeye çalışabilir. öyle değil, her durumda farklı davranacaktı).

Bu soru ( çok genel anlamda) " Sözdizimi hatalarını kendi kendine düzeltmeye çalışan herhangi bir derleyici var mı? " (Yazılım Mühendisliği StackExchange sitesinde) olmasına rağmen, bu soru açık bir şekilde sözdizimi hataları ile ilgili olsa da, gereksiz tasarım kalıpları hakkındadır. . Niyeti temel alarak kodu otomatik olarak değiştirme fikri büyük oranda aynıdır.

Çünkü işe yaramaz değil.

Bu durumda cat file | cmd, fd 0(stdin) cmdbir boru olacaktır ve bu durumda cmd <filenormal bir dosya, cihaz vb. Olabilir.

Bir borunun normal bir dosyadan farklı semantikleri var ve semantiği normal bir dosyanın alt kümesi değil :

• düzenli bir dosya anlamlı bir şekilde kullanılamaz select(2)veya poll(2)silinemez; a select(2)üzerinde her zaman "hazır" dönecektir. epoll(2)Linux'taki gibi gelişmiş arayüzler normal dosyalarla çalışmaz.

• Linux sistem çağrıları (vardır splice(2), vmsplice(2), tee(2)) borularda sadece çalışma [1]

Yana catçok kullanılır, bu yerleşik olan ekstra süreci önleyecektir bir kabuk halinde uygulanması mümkündür, ancak bu yolda başladıktan sonra, aynı şey en komutları ile yapılabilir - daha yavaş ve clunkier içine kabuk dönüştürme perlveya python. devamı için boru benzeri bir sözdizimi kullanımı kolay olan başka bir betik dili yazmak muhtemelen daha iyidir ;-)

Eğer değil fırsat için yapılmış basit bir örnek isterseniz [1], siz git "stdin'i gelen exec ikili" benim bakabilirsiniz özünü açıklamada bazı açıklamalar ile burada . catUUoC olmadan çalışmasını sağlamak için içine uygulamak , 2 veya 3 kat daha büyük olurdu.

Çünkü işe yaramaz kediyi tespit etmek gerçekten çok zor.

Yazdığım bir kabuk betiğim vardı

cat | (somecommand <<!
...
/proc/self/fd/3
...
!) 0<&3

Kabuk betiği, çalıştırıldığı catiçin kaldırıldıysa üretimde başarısız oldu su -c 'script.sh' someuser. Görünüşe göre gereksiz catolan, standart girişin sahibinin betiğin çalıştığı kullanıcı olarak değişmesine neden oldu, böylece yeniden /procçalıştı.

tl; dr: Mermiler otomatik olarak yapmaz çünkü maliyetler muhtemel faydaları aşar.

Diğer cevaplar stdin'in boru olması ile dosya olması arasındaki teknik farklılığa işaret etti. Bunu akılda tutarak, kabuk aşağıdakilerden birini yapabilir:

1. catDosyayı v. Boru ayrımını koruyarak yerleşik olarak uygulayın . Bu, bir uygulayıcının ve belki de bir çatalın maliyetini düşürür.
2. Dosya / boru önemli olup olmadığını görmek için kullanılan çeşitli komutların bilgisi ile boru hattının tam bir analizini yapın, sonra buna göre hareket edin.

Daha sonra, her bir yaklaşımın maliyetlerini ve faydalarını göz önünde bulundurmalısınız. Yararları yeterince basit:

1. Her iki durumda da, bir exec (kaçınmak cat)
2. İkinci durumda, yönlendirme ikamesi mümkün olduğunda, bir çataldan kaçınılmalıdır.
3. Bir boru kullanmanız gereken durumlarda, bazen bir çatal / vforktan kaçınmak mümkün olabilir , ancak çoğu zaman bu mümkün olmayabilir. Bunun nedeni, kedi eşdeğerinin, boru hattının geri kalanıyla aynı anda çalışması gerekmesidir.

Bu nedenle, özellikle de çatalı engelleyebiliyorsanız, CPU zamanından ve hafızasından biraz tasarruf edersiniz. Elbette, bu zaman ve hafızadan sadece özellik gerçekten kullanıldığında tasarruf edersiniz. Ve sadece çatal / çalışma zamanını gerçekten kurtarıyorsunuz; daha büyük dosyalarda, zaman çoğunlukla G / Ç zamanıdır (yani, bir dosyayı diskten okuyan kedi). Yani şunu sormak zorundasınız: catperformansın gerçekten önemli olduğu kabuk senaryolarında ne sıklıkla kullanılır (işe yaramaz olarak)? Bunu diğer ortak kabuk yerleşimleriyle karşılaştırın - önemli olan yerlerde kullanılan sıklıkta bir onda bile kullanıldığını testhayal etmek zor . Bu bir tahmin, ölçmedim, bu herhangi bir uygulama denemesinden önce yapmak isteyeceğiniz bir şey. (Ya da benzer şekilde, bir başkasından örneğin bir özellik isteğinde uygulanmasını istemek.)cattest

Sonra sorarsanız: masrafları nelerdir. Akla gelen iki maliyet (a) kabuğunda, büyüklüğünü artıran (ve dolayısıyla hafıza kullanımı) daha fazla bakım çalışması gerektiren ilave kod; böcekler, vb. İçin başka bir nokta; ve (b) geriye dönük uyumluluk sürprizleri, POSIX cat, örneğin, GNU coreutils catgibi birçok özelliği göz ardı eder cat;

1. Ek yerleşik seçenek büyük olasılıkla o kadar da kötü değil - bir grubun zaten bulunduğu yere bir tane daha ekleyerek. Yardımcı olacağını gösteren bir profil verisine sahipseniz, muhtemelen en sevdiğiniz kabuğun yazarlarını eklemeye ikna edebilirsiniz.

2. Boru hattını analiz etmeye gelince, kabukların şu anda böyle bir şey yaptığını sanmıyorum (birkaçı bir boru hattının sonunu biliyor ve bir çataldan kaçınabilir). Temel olarak, kabuğa (ilkel) bir optimizer ekleyecektiniz; optimize ediciler genellikle karmaşık kodlar ve birçok hata kaynağı olarak ortaya çıkıyor. Ve bu hatalar şaşırtıcı olabilir - kabuk komut dosyasındaki ufak değişiklikler, hatadan kaçınarak veya tetikleyerek ortaya çıkabilir.

PostScript: Kedinin işe yaramaz kullanımlarına benzer bir analiz uygulayabilirsiniz. Yararları: okunması daha kolay (eğer bir komut argüman olarak bir dosya alacaksa, muhtemelen değil). Maliyetler: ekstra çatal ve exec (eğer komut1 argüman olarak bir dosyayı alabilirse, muhtemelen daha fazla kafa karıştırıcı hata mesajları olabilir). Analizin, işe yaramazca kedi kullanmanı söylerse, devam et.

catKomut kabul edebilir -için bir işaretleyici olarak Stdin . ( POSIX , " bir dosya ise '-', kedi programı sırasında bu noktada standart girdiden okunur olacaktır. ") Bu basit bir dosyanın kullanım veya izin veren standart giriş aksi takdirde bu izin istendiği durumda.

Kabuk argümanının $1olduğu şu iki önemsiz alternatifi düşünün -:

cat "$1" | nl    # Works completely transparently
nl < "$1"        # Fails with 'bash: -: No such file or directory'

Başka bir zaman catyararlıdır, yalnızca kabuk sözdizimini sürdürmek için kasıtlı olarak no-op olarak kullanıldığı yerdir:

file="$1"
reader=cat
[[ $file =~ \.gz$ ]] && reader=zcat
[[ $file =~ \.bz2$ ]] && reader=bzcat
"$reader" "$file"

Son olarak, UUOC'nin gerçekten doğru bir şekilde söylenebileceği tek zamanın, normal catbir dosya olduğu bilinen bir dosya adıyla kullanıldığında (yani bir cihaz veya boru kullanılmadığında) ve komuta hiçbir bayrak verilmediğine inanıyorum:

cat file.txt

Başka bir durumda, catkendisinin taşıtlıkları gerekebilir.

Cat komutu, kabuğun mutlaka yapamayacağı şeyleri yapabilir (veya en azından kolayca yapamaz). Örneğin, sekmeler, satır başları veya yeni satırlar gibi görünmeyen karakterleri yazdırmak istediğinizi varsayalım. * * Sadece kabuk yerleşik komutları ile bunu yapmanın bir yolu olabilir, ama başımın üstünde hiçbir şey düşünemiyorum. Kedinin GNU versiyonu bunu -Aargümanla veya -v -E -Targümanlarla yapabilir (kedinin diğer versiyonları hakkında bilgim yok). Ayrıca, her bir satırı bir satır numarası ile önek olarak kullanabilirsiniz -n(eğer GNU olmayan sürümler bunu yapabiliyorsa IDK).

Kedinin bir başka avantajı da kolayca birden fazla dosyayı okuyabilmesidir. Bunu yapmak için, bir basit yazabilirsiniz cat file1 file2 file3. Aynı şeyi bir kabukla yapmak, dikkatlice hazırlanmış bir döngü büyük olasılıkla aynı sonucu elde etse de, işler zorlaşacaktır. Bununla birlikte, bu kadar basit bir alternatif varken böyle bir döngü yazmak için zaman ayırmak istiyor musunuz? Yapmıyorum!

Cat ile dosyaları okumak, muhtemelen cat derlenmiş bir program olduğu için kabuktan daha az CPU kullanır (bariz istisna, yerleşik bir kedi içeren herhangi bir kabuktur). Büyük bir dosya grubunu okurken, bu görünebilir, ancak makinelerimde hiç yapmadım, bu yüzden emin olamıyorum.

Cat komutu, bir komutu yapamayacağı durumlarda standart girişi kabul etmeye zorlamak için de yararlı olabilir. Aşağıdakileri göz önünde bulundur:

echo 8 | sleep

"8" sayısı "uyku" komutu tarafından kabul edilmeyecektir, çünkü hiçbir zaman standart girdi kabul etmeyi kastetmemiştir. Böylece uyku, bu girişi göz ardı eder, tartışmaların eksikliğinden şikayet eder ve çıkar. Ancak, eğer bir tür:

echo 8 | sleep $(cat)

Birçok kabuk bunu genişletecek sleep 8ve uyku çıkmadan önce 8 saniye bekleyecek. Ayrıca ssh ile benzer bir şey yapabilirsiniz:

command | ssh 1.2.3.4 'cat >> example-file'

Bu komut, makinede "komut" dan çıkarılmış olanla 1.2.3.4 adresli örnek dosya ekleme ekini içerir.

Ve bu (muhtemelen) sadece yüzeyi çiziktir. İsteseydim, daha yararlı bir kedi örneği bulabileceğime eminim, ama bu yazı olduğu kadar uzun. Bu yüzden şunu söyleyerek bitireceğim: kabuğundan tüm bu senaryoları (ve diğer birkaçını) tahmin etmesini istemek gerçekten mümkün değil.

Bir kullanıcının, catiçinde $PATHtam olarak POSIX olmayan bir içeriğe sahip olabileceğini unutmayın cat(ama belki bir yere bir şeyleri girebilecek bir değişken). Bu durumda, kabuğun çıkarmasını istemezsiniz.

PATH Dinamik değiştirin ve sonra olabilir cat kaç olduğunu düşündüğümüz değil. Hayal ettiğiniz optimizasyonu yaparak bir kabuk yazmak oldukça zor olurdu.

Ayrıca, pratikte cat oldukça hızlı bir programdır. Bundan kaçınmak için birkaç pratik sebep (estetik hariç) vardır.

Ayrıca FOSDEM2018'deki Yann Regis-Gianas'ın mükemmel Ayrıştırma POSIX [s] cehennemi konuşmasına da bakın. Bir kabuğun içinde hayalini kurmaya çalışmaktan kaçınmak için başka iyi nedenler de veriyor.

Performans gerçekten kabuklar için bir sorun olsaydı, birisi karmaşık tüm program derleyici optimizasyonunu, statik kaynak kod analizini ve tam zamanında derleme tekniklerini kullanan bir kabuk önerebilirdi (bu üç alanın onlarca yıllık ilerlemesi ve bilimsel yayınları vardı ve kendini adadı. konferanslar, örneğin SIGPLAN kapsamında ). Ne yazık ki, ilginç bir araştırma konusu olarak, şu anda araştırma kurumları veya girişim kapitalistleri tarafından finanse edilmiyor ve bunun sadece çabaya değmeyeceği sonucuna varıyorum. Başka bir deyişle, kabukları optimize etmek için muhtemelen önemli bir pazar yoktur . Bu tür bir araştırmaya harcayacak yarım milyon avronuz varsa, kolayca yapacak birini bulacaksınız ve bunun değerli sonuçlar vereceğine inanıyorum.

Pratik açıdan, yeniden yazma, performansını artırmak için, daha iyi bir betik dilinde (Python, AWK, Guile, ...) küçük (yüz satır) bir kabuk komut dosyası yapılır. Büyük yazılım kodları yazmak pek de mantıklı değil (pek çok yazılım mühendisliği nedeniyle): yüz satırı aşan bir kod yazarken, daha uygun bir dilde yeniden yazmayı düşünmelisiniz (okunabilirlik ve bakım nedenleriyle) : bir programlama dili olarak kabuk çok zayıf bir dildir . Bununla birlikte, birçok büyük üretilmiş kabuk betiği vardır ve iyi nedenlerden dolayı (örneğin GNU autoconf tarafından üretilen configurekomut dosyaları).

Büyük metinsel dosyalara gelince, onları tek bir argüman catolarak iletmek iyi bir uygulama değildir ve çoğu sysadmins bunu bilir (herhangi bir kabuk betiğinin çalışması bir dakikadan uzun sürerse, onu optimize etmeyi düşünmeye başlarsınız). Büyük gigabayt dosyaları için ise asla bunları işlemek için iyi bir araç.cat

@Kusalananda cevap ekleyerek (ve @ alephzero yorum), kedi bir şey olabilir:

alias cat='gcc -c'
cat "$MYFILE" | command1 | command2 > "$OUTPUT"

veya

echo 'echo 1' > /usr/bin/cat
cat "$MYFILE" | command1 | command2 > "$OUTPUT"

Sistemdeki kedinin (kendi başına) veya / usr / bin / kedinin aslında birleştirme aracı olması için hiçbir neden yoktur.

Kedi için iki "yararsız" kullanım:

sort file.txt | cat header.txt - footer.txt | less

... burada catdosya ve boru girişini karıştırmak için kullanılır.

find . -name '*.info' -type f | sh -c 'xargs cat' | sort

... burada xargsneredeyse sonsuz sayıda dosya adını kabul edebilir ve cathepsini tek bir akış gibi davranırken gerektiği kadar çalıştırabilirsiniz . Bu doğrudan kullanımın xargs sortolmadığı büyük dosya listeleri için işe yarar .

Başka şeylerin yanı sıra, cat-check, kullanımının catgerçekten yararsız olduğu konusunda ek performans ek yükü ve karışıklığı ekler , çünkü IMHO, çünkü bu tür kontroller verimsiz olabilir ve meşru catkullanımla ilgili sorunlar yaratabilir .

Komutlar standart akışlarla ilgilendiğinde, yalnızca standart dosya tanımlayıcılarına okuma / yazma ile ilgilenmeleri gerekir. Komutlar stdin'in aranabilir / aranabilir olup olmadığını bilir , bu bir boru veya dosyayı gösterir.

Karışıma, aslında stdin içeriğinin hangi sürecin sağladığını kontrol edersek, borunun diğer tarafında işlemi bulmamız ve uygun optimizasyon yapmamız gerekir. Bu, Kyle Jones'un Süper Kullanıcı postasındaki gibi kabuğun kendisi ve bu kabuğun kabukları açısından yapılabilir.

(find /proc -type l | xargs ls -l | fgrep 'pipe:[20043922]') 2>/dev/null

bağlantılı gönderide gösterildiği gibi. Bu 3 tane daha komuttur (yani ekstra fork()s ve exec()s) ve özyinelemeli geçişler (çok fazla readdir()arama).

C ve kabuk kaynak kodları açısından, kabuk çocuk sürecini zaten biliyor, bu yüzden özyinelemeye gerek yok, ama ne zaman optimize edeceğimizi ve ne zaman catişe yaramaz olduğunu nasıl bilebiliriz ? Kedinin yararlı kullanımları aslında var gibi

# adding header and footer to file
( cmd; cat file; cmd ) | cmd
# tr command does not accept files as arguments
cat log1 log2 log3 | tr '[:upper:]' '[:lower:]'

Kabuğa bu tür bir optimizasyon eklemek muhtemelen atık ve gereksiz ek yük olacaktır. Kusalanda'nın cevabının daha önce de belirtildiği gibi, UUOC, kullanıcının en iyi sonuçları elde etmek için en iyi komutları nasıl bir araya getirebileceğini anlama konusundaki anlayışsızlığı ile ilgilidir.