Schnellste Möglichkeit zum drucken einer einzelnen Zeile in einer Datei

Drop die nutzlose Verwendung von cat und tun:

$ sed -n '1{p;q}' file

Diese wird beendet, die sed script nach der Zeile gedruckt worden ist.

Benchmarking-Skript:

#!/bin/bash

TIMEFORMAT='%3R'
n=25
heading=('head -1 file' 'sed -n 1p file' "sed -n '1{p;q} file" 'read line < file && echo $line')

# files upto a hundred million lines (if your on slow machine decrease!!)
for (( j=1; j<=100,000,000;j=j*10 ))
do
    echo "Lines in file: $j"
    # create file containing j lines
    seq 1 $j > file
    # initial read of file
    cat file > /dev/null

    for comm in {0..3}
    do
        avg=0
        echo
        echo ${heading[$comm]}    
        for (( i=1; i<=$n; i++ ))
        do
            case $comm in
                0)
                    t=$( { time head -1 file > /dev/null; } 2>&1);;
                1)
                    t=$( { time sed -n 1p file > /dev/null; } 2>&1);;
                2)
                    t=$( { time sed '1{p;q}' file > /dev/null; } 2>&1);;
                3)
                    t=$( { time read line < file && echo $line > /dev/null; } 2>&1);;
            esac
            avg=$avg+$t
        done
        echo "scale=3;($avg)/$n" | bc
    done
done

Speichern Sie einfach als benchmark.sh und führen bash benchmark.sh.

Ergebnisse:

head -1 file
.001

sed -n 1p file
.048

sed -n '1{p;q} file
.002

read line < file && echo $line
0

**Die Ergebnisse aus der Datei mit 1.000.000 Zeilen.* * *

Also die Zeiten für sed -n 1p wächst Linear mit der Länge der Datei, aber das timing für die anderen Varianten wird konstant (und vernachlässigbar), wie Sie beenden Sie alle nach dem Lesen der ersten Zeile:

Hinweis: timings sind vom original abweichen post wegen wird auf eine schnellere Linux-box.

InformationsquelleAutor

Wenn du wirklich nur immer die erste Zeile und Lesen Hunderte von Dateien, dann erwägen, shell gelieferten statt externe externe Befehle verwenden read was ist ein shell-builtin von bash und ksh. Dadurch entfällt der overhead für die Prozess-Erstellung mit awk, sed, head usw.

Dem anderen Problem zu tun timed performance-Analyse auf der I/O. Das erste mal, wenn Sie öffnen und dann eine Datei Lesen, Datei ist wahrscheinlich nicht im Arbeitsspeicher zwischengespeichert. Jedoch, wenn Sie versuchen, eine zweite Befehl auf die gleiche Datei wieder die Daten, als auch die inode zeigt, die zwischengespeichert wurden, so die zeitgesteuerte Ergebnisse sind möglicherweise schneller, so ziemlich unabhängig von dem Befehl, den Sie verwenden. Plus, inodes bleiben können zwischengespeichert praktisch immer. Auf Solaris beispielsweise. Oder jedenfalls mehrere Tage.

Zum Beispiel, linux-caches alles und die Küchenspüle, die eine gute performance-Attribut. Aber es macht benchmarking problematisch, wenn Sie nicht bewusst sind das Problem.

Alle diese caching-Effekt "Störungen" ist beides, Betriebssystem und hardware abhängig.

So wählen Sie eine Datei, Lesen Sie es mit einem Kommando. Jetzt ist es zwischengespeichert. Führen Sie den gleichen test-Befehl mehrere Dutzend mal, das ist sampling die Wirkung des Befehls und der Kind-Prozess geschaffen haben, nicht Ihren I/O-hardware.

dies ist sed vs Lesen für 10 Iterationen immer die erste Zeile in der gleichen Datei, nach Lesen Sie die Datei einmal:

sed: sed '1{p;q}' uopgenl20121216.lis

real    0m0.917s
user    0m0.258s
sys     0m0.492s

Lesen: read foo < uopgenl20121216.lis ; export foo; echo "$foo"

real    0m0.017s
user    0m0.000s
sys     0m0.015s

Dies ist eindeutig künstlich, sondern zeigt den Unterschied zwischen builtin performance vs mit einem Befehl.

InformationsquelleAutor jim mcnamara