Bir dosyanın ilk birkaç ve son birkaç satırını gösterme komutu

Çok satırlı bir dosyam var ve her satırın başında bir zaman damgası var.

[Thread-3] (21/09/12 06:17:38:672) logged message from code.....

Bu nedenle, sık sık bu günlük dosyasındaki 2 şeyi kontrol ediyorum.

1. İlk birkaç satır, küresel şartlara sahip ve başlangıç ​​zamanı da verilmiştir.
2. Son birkaç satır, başka bir bilgi ile çıkış durumuna sahip.

Dosyanın sadece ilk ve son birkaç satırını görüntülememe izin verecek hızlı ve tek bir komut var mı?

Tek komutla yapmak için sedveya kullanabilirsiniz awk. Bununla birlikte, hızda kaybedersiniz, nedense sedve awkyine de tüm dosyayı taramanız gerekir. Hız açısından, bir işlev yapmak veya her zaman tail+ kombinasyonuna geçmek daha iyidir head. Bu, giriş bir boru ise çalışmamanın bir dezavantajına sahiptir, ancak kabuğunuzun desteklemesi durumunda işlem yerine koyma işlemini kullanabilirsiniz (aşağıdaki örneğe bakın).

first_last () {
    head -n 10 -- "$1"
    tail -n 10 -- "$1"
}

ve sadece olarak başlat

first_last "/path/to/file_to_process"

işlem değişikliğine devam etmek (bash, zsh, sadece kabuklar gibi ksh):

first_last <( command )

ps. grep"global şartlarınız" olup olmadığını kontrol etmek için bile ekleyebilirsiniz .

@rush, head + tail komutunu büyük dosyalar için daha verimli kullanmak konusunda haklıdır, ancak küçük dosyalar için (<20 satır), bazı satırlar iki kez çıkarılabilir.

{ head; tail;} < /path/to/file

eşit derecede verimli olurdu, ancak yukarıdaki sorun olmazdı.

{ head; tail; }Solüsyon çünkü boruların (veya priz ya da başka herhangi olmayan aranabilir dosyalar) üzerinde çalışma olmaz heado bloklar tarafından okur olarak çok fazla veri tüketmeye olabilir ve potansiyel ötesinde dosya içindeki imleci bırakarak bir boruya geri aday olmayacağını ne tailkastedilmektedir seçmek.

Böylece, kabuğunki gibi bir anda bir karakter okuyan bir araç kullanabilirsiniz read(burada baş satır ve kuyruk satırlarını argüman olarak alan bir işlev kullanarak).

head_tail() {
  n=0
  while [ "$n" -lt "$1" ]; do
    IFS= read -r line || { printf %s "$line"; break; }
    printf '%s\n' "$line"
    n=$(($n + 1))
  done
  tail -n "${2-$1}"
}
seq 100 | head_tail 5 10
seq 20 | head_tail 5

veya tailörneğin awk olarak uygulayın:

head_tail() {
  awk -v h="$1" -v t="${2-$1}" '
    {l[NR%t]=$0}
    NR<=h
    END{
      n=NR-t+1
      if(n <= h) n = h+1
      for (;n<=NR;n++) print l[n%t]
    }'
}

İle sed:

head_tail() {
  sed -e "1,${1}b" -e :1 -e "$(($1+${2-$1})),\$!{N;b1" -e '}' -e 'N;D'
}

(bazı seduygulamaların desen uzaylarının boyutunda düşük bir sınırlamaya sahip olmasına rağmen , kuyruk çizgilerinin sayısının büyük değerleri için başarısız olur).

bashİşlem değişikliğini kullanarak aşağıdakileri yapabilirsiniz:

make_some_output | tee >(tail -n 2) >(head -n 2; cat >/dev/null) >/dev/null

Satırların düzenli olmalarının garanti edilmediğini, ancak 8kB'den daha uzun dosyalar için büyük olasılıkla olacağını unutmayın. Bu 8kB kesme, okuma arabelleğinin tipik boyutudur ve | {head; tail;}küçük dosyalar için neden çalışmadığıyla ilgilidir .

cat >/dev/nullTutmak için gerekli olan headcanlı boru hattı. Aksi takdirde teeerken ayrılır ve çıktı alırken tail, giriş yerine, sonuna değil de bir yere ait olur.

Son olarak, neden bir başkasına gitmek >/dev/nullyerine ? Aşağıdaki durumda:tail|

make_some_output | tee >(head -n 2; cat >/dev/null) | tail -n 2  # doesn't work

headstdout tailkonsoldan ziyade boruya besleniyor , bu bizim istediğimiz şey değil.

Kullanarak ed(ki bu dosyanın tamamını RAM'e okuyacak):

# cf. http://wiki.bash-hackers.org/howto/edit-ed
printf '%s\n' 'H' '1,10p' '$-10,$p' 'q' | ed -s file

Stephane'in bir fonksiyondaki ilk çözümü, böylece argümanları kullanabilirsiniz (herhangi bir Bourne benzeri veya POSIX kabuğunda çalışır):

head_tail() {
    head "$@";
    tail "$@";
}

Şimdi bunu yapabilirsiniz:

head_tail -n 5 < /path/to/file

Elbette bu, yalnızca bir dosyaya baktığınızı ve Stephane'nin çözümünün (düzenli) yalnızca normal (aranabilir) dosyalar üzerinde çalıştığını (güvenilir) çalıştığını varsayar.

İle -u( --unbufferedGNU) seçeneğiyle sedkullanabileceğiniz sed -u 2qbir tamponsuz alternatif olarak head -n2:

$ seq 100|(sed -u 2q;tail -n2)
1
2
99
100

(head -n2;tail -n2)Son satırlar tarafından tüketilen girdi bloğunun bir parçası olduğunda başarısız olur head:

$ seq 1000|(head -n2;tail -n2)
1
2
999
1000
$ seq 100|(head -n2;tail -n2)
1
2

Bugün böyle bir şeye rastladım; burada bir akıntının önünden sadece son hatta ve birkaç satırda ihtiyacım vardı.

sed -n -e '1{h}' -e '2,3{H}' -e '${H;x;p}'

Bunu şu şekilde okudum: ilk satırın içeriğiyle birlikte tutma alanını başlat, tutma alanına 2-3 satır ekle, EOF'da tutma satırına son satırı ekle, tutma ve desen alanını değiştir ve deseni yazdır alanı.

Belki de sahip sedolduğumdan daha fazla -fazına sahip biri , bu soruda belirtilen akışın son birkaç satırını yazdırmak için bunun nasıl genelleştirileceğini bulabilir, ancak buna ihtiyacım olmadı ve $adrese göre matematik yapmanın kolay bir yolunu bulamadım. içinde sedya da belki zaman sadece son birkaç satır içinde olacak şekilde yer tutmaya yöneterek EOFulaşılır.

Eğer kurulu ise Perl'i deneyebilirsiniz:

perl -e '@_ = <>; @_=@_[0, -3..-1]; print @_'

Bu, çoğu dosya için çalışır, ancak işlemden önce tüm dosyayı belleğe okur. Perl dilimlerini bilmiyorsanız, köşeli parantez içindeki "0" "ilk satırı al" ve "-3 ...- 1" "son üç satırı al" anlamına gelir. İkisini de ihtiyaçlarınıza göre uyarlayabilirsiniz. Gerçekten büyük dosyaları işlemeniz gerekiyorsa ('büyük olan' RAM'inize ve belki de takas boyutlarına bağlı olabilir), şunları yapmak isteyebilirsiniz:

perl -e 'while($_=<>){@_=(@_,$_)[0,-3..-1]}; print @_'

biraz daha yavaş olabilir, çünkü her tekrarda bir dilim yapar, ancak dosya boyutunda bağımsızdır.

Her iki komut da hem borularda hem de normal dosyalarda çalışmalıdır.