Ist das Leiten, Verschieben oder Erweitern von Parametern effizienter?

Ich versuche, den effizientesten Weg zu finden, um bestimmte Werte zu durchlaufen, bei denen es sich um eine konsistente Anzahl von Werten handelt, die in einer durch Leerzeichen getrennten Liste von Wörtern voneinander entfernt sind (ich möchte kein Array verwenden). Beispielsweise,

list="1 ant bat 5 cat dingo 6 emu fish 9 gecko hare 15 i j"

Ich möchte also in der Lage sein, nur die Liste zu durchlaufen und nur auf 1,5,6,9 und 15 zuzugreifen.

BEARBEITEN: Ich hätte klarstellen müssen, dass die Werte, die ich aus der Liste abrufen möchte, nicht im Format vom Rest der Liste abweichen müssen. Was sie besonders macht, ist allein ihre Position in der Liste (in diesem Fall Position 1,4,7 ...). Die Liste könnte also lauten,1 2 3 5 9 8 6 90 84 9 3 2 15 75 55aber ich möchte immer noch die gleichen Nummern. Außerdem möchte ich in der Lage sein, dies zu tun, vorausgesetzt, ich kenne die Länge der Liste nicht.

Die Methoden, an die ich bisher gedacht habe, sind:

Methode 1

set $list
found=false
find=9
count=1
while [ $count -lt $# ]; do
    if [ "${@:count:1}" -eq $find ]; then
    found=true
    break
    fi
    count=`expr $count + 3`
done

Methode 2

set list
found=false
find=9
while [ $# ne 0 ]; do
    if [ $1 -eq $find ]; then
    found=true
    break
    fi
    shift 3
done

Methode 3 Ich bin mir ziemlich sicher, dass Piping die schlechteste Option ist, aber ich habe aus Neugier versucht, eine Methode zu finden, bei der set nicht verwendet wird.

found=false
find=9
count=1
num=`echo $list | cut -d ' ' -f$count`
while [ -n "$num" ]; do
    if [ $num -eq $find ]; then
    found=true
    break
    fi
    count=`expr $count + 3`
    num=`echo $list | cut -d ' ' -f$count`
done

Was wäre also am effizientesten, oder fehlt mir eine einfachere Methode?

Ziemlich einfach mit awk. Damit erhalten Sie den Wert jedes vierten Feldes für Eingaben beliebiger Länge:

$ awk -F' ' '{for( i=1;i<=NF;i+=3) { printf( "%s%s", $i, OFS ) }; printf( "\n" ) }' <<< $list
1 5 6 9 15

Dies funktioniert, indem Sie integrierte awkVariablen wie NF(die Anzahl der Felder im Datensatz) nutzen und einige einfache forSchleifen ausführen, um die Felder zu durchlaufen, um die gewünschten zu erhalten, ohne vorher wissen zu müssen, wie viele es geben wird.

Oder, wenn Sie in der Tat nur die in Ihrem Beispiel angegebenen Felder benötigen:

$ awk -F' ' '{ print $1, $4, $7, $10, $13 }' <<< $list
1 5 6 9 15

Bei der Frage nach der Effizienz ist es am einfachsten, diese oder jede Ihrer anderen Methoden zu testen und timezu zeigen, wie lange dies dauert. Sie können auch Tools verwenden, um stracezu sehen, wie die Systemaufrufe ablaufen. Verwendung von timesieht aus wie:

$ time ./script.sh

real    0m0.025s
user    0m0.004s
sys     0m0.008s

Sie können diese Ausgabe zwischen verschiedenen Methoden vergleichen, um festzustellen, welche zeitlich am effizientesten ist. Andere Tools können für andere Effizienzmetriken verwendet werden.

• Erste Regel der Softwareoptimierung: Nicht .

  Solange Sie nicht wissen, wie schnell das Programm ist, müssen Sie nicht darüber nachdenken, wie schnell es ist. Wenn Ihre Liste ungefähr so ​​lang oder nur ~ 100-1000 Elemente lang ist, werden Sie wahrscheinlich nicht einmal bemerken, wie lange es dauert. Es besteht die Möglichkeit, dass Sie mehr Zeit damit verbringen, über die Optimierung nachzudenken, als der Unterschied wäre.
  
  

• Zweite Regel: Messen .

  Das ist der sichere Weg, um herauszufinden, und derjenige, der Antworten für Ihr System gibt. Besonders bei Muscheln gibt es so viele, und sie sind nicht alle identisch. Eine Antwort für eine Shell trifft möglicherweise nicht auf Ihre zu.

  In größeren Programmen gilt auch hier die Profilerstellung. Der langsamste Teil ist möglicherweise nicht der, von dem Sie glauben, dass er es ist.
  
  

• Drittens die erste Regel der Shell-Skriptoptimierung: Verwenden Sie die Shell nicht .

  Ja wirklich. Viele Shells sind nicht besonders schnell (da das Starten externer Programme nicht unbedingt erforderlich ist) und analysieren die Zeilen des Quellcodes möglicherweise jedes Mal neu.

  Verwenden Sie stattdessen etwas wie awk oder Perl. In einem trivialen Mikro-Benchmark war ich awkbeim Ausführen einer einfachen Schleife (ohne E / A) Dutzende Male schneller als jede herkömmliche Shell.

  Wenn Sie jedoch die Shell verwenden, verwenden Sie die integrierten Funktionen der Shell anstelle von externen Befehlen. Hier verwenden Sie, exprwas nicht in Shells integriert ist, die ich auf meinem System gefunden habe, sondern das durch eine Standard-Arithmetik-Erweiterung ersetzt werden kann. ZB i=$((i+1))statt i=$(expr $i + 1)zu inkrementieren i. Ihre Verwendung von cutim letzten Beispiel kann auch durch Standardparametererweiterungen ersetzt werden.

  Siehe auch: Warum wird die Verwendung einer Shell-Schleife zum Verarbeiten von Text als unangemessen angesehen?

Die Schritte 1 und 2 sollten auf Ihre Frage zutreffen.

Ich werde in dieser Antwort nur einige allgemeine Ratschläge geben und keine Benchmarks. Benchmarks sind die einzige Möglichkeit, Fragen zur Leistung zuverlässig zu beantworten. Da Sie jedoch nicht angeben, wie viele Daten Sie bearbeiten und wie oft Sie diesen Vorgang ausführen, gibt es keine Möglichkeit, einen nützlichen Benchmark durchzuführen. Was für 10 Artikel effizienter ist und was für 1000000 Artikel effizienter ist, ist oft nicht dasselbe.

Generell ist das Aufrufen von externen Befehlen teurer als das Ausführen von reinen Shell-Konstrukten, sofern der reine Shell-Code keine Schleife enthält. Andererseits ist eine Shell-Schleife, die über eine große Zeichenfolge oder eine große Anzahl von Zeichenfolgen iteriert, wahrscheinlich langsamer als ein Aufruf eines Spezialwerkzeugs. Beispielsweise kann das Aufrufen einer Schleife cutin der Praxis sehr langsam sein. Wenn Sie jedoch eine Möglichkeit finden, das Ganze mit einem einzigen cutAufruf zu erledigen , ist dies wahrscheinlich schneller als mit der String-Manipulation in der Shell.

Beachten Sie, dass der Grenzwert zwischen den Systemen sehr unterschiedlich sein kann. Dies kann vom Kernel, der Konfiguration des Kernel-Schedulers, dem Dateisystem mit den externen ausführbaren Dateien, dem aktuellen CPU- und Speicherdruck und vielen anderen Faktoren abhängen.

Rufen Sie nicht expran, um zu rechnen, wenn Sie sich überhaupt um die Leistung sorgen. Rufen Sie exprin der Tat gar nicht zum Rechnen auf. Shells verfügen über eine integrierte Arithmetik, die klarer und schneller ist als das Aufrufen expr.

Sie scheinen bash zu verwenden, da Sie bash-Konstrukte verwenden, die in sh nicht existieren. Warum um alles in der Welt würden Sie kein Array verwenden? Ein Array ist die natürlichste und wahrscheinlich auch die schnellste Lösung. Beachten Sie, dass Array-Indizes bei 0 beginnen.

list=(1 2 3 5 9 8 6 90 84 9 3 2 15 75 55)
for ((count = 0; count += 3; count < ${#list[@]})); do
  echo "${list[$count]}"
done

Ihr Skript ist möglicherweise schneller, wenn Sie sh verwenden, wenn Ihr System shstatt bash dash oder ksh as hat . Wenn Sie sh verwenden, erhalten Sie keine benannten Arrays, aber Sie erhalten immer noch einen der Positionsparameter für das Array, die Sie festlegen können set. Um auf ein Element an einer Position zuzugreifen, die erst zur Laufzeit bekannt ist, müssen Sie verwenden eval(achten Sie darauf, dass Sie die Dinge richtig zitieren!).

# List elements must not contain whitespace or ?*\[
list='1 2 3 5 9 8 6 90 84 9 3 2 15 75 55'
set $list
count=1
while [ $count -le $# ]; do
  eval "value=\${$count}"
  echo "$value"
  count=$((count+1))
done

Wenn Sie immer nur einmal auf das Array zugreifen möchten und von links nach rechts gehen (einige Werte überspringen), können Sie shiftanstelle von Variablen Indizes verwenden.

# List elements must not contain whitespace or ?*\[
list='1 2 3 5 9 8 6 90 84 9 3 2 15 75 55'
set $list
while [ $# -ge 1 ]; do
  echo "$1"
  shift && shift && shift
done

Welcher Ansatz schneller ist, hängt von der Shell und der Anzahl der Elemente ab.

Eine andere Möglichkeit ist die Verwendung der Zeichenfolgenverarbeitung. Es hat den Vorteil, dass die Positionsparameter nicht verwendet werden, sodass Sie sie für andere Zwecke verwenden können. Bei großen Datenmengen ist dies langsamer, bei kleinen Datenmengen macht sich dies jedoch kaum bemerkbar.

# List elements must be separated by a single space (not arbitrary whitespace)
list='1 2 3 5 9 8 6 90 84 9 3 2 15 75 55'
while [ -n "$list" ]; do
  echo "${list% *}"
  case "$list" in *\ *\ *\ *) :;; *) break;; esac
  list="${list#* * * }"
done

awkist eine gute Wahl, wenn Sie die gesamte Verarbeitung innerhalb des Awk-Skripts durchführen können. Andernfalls leiten Sie die Awk-Ausgabe einfach an andere Dienstprogramme weiter, wodurch der Leistungszuwachs von zunichte gemacht wird awk.

bashDie Iteration über ein Array ist auch großartig, wenn Sie Ihre gesamte Liste in das Array einpassen können (was bei modernen Shells wahrscheinlich eine Garantie ist) und die Syntaxgymnastik des Arrays nichts ausmacht.

Ein Pipeline-Ansatz:

xargs -n3 <<< "$list" | while read -ra a; do echo $a; done | grep 9

Woher:

• xargs gruppiert die durch Leerzeichen getrennte Liste in Dreiergruppen, wobei jede neue Zeile getrennt ist
• while read verbraucht diese Liste und gibt die erste Spalte jeder Gruppe aus
• grep filtert die erste Spalte (entsprechend jeder dritten Position in der ursprünglichen Liste)

Verbessert meiner Meinung nach die Verständlichkeit. Die Leute wissen bereits, was diese Tools tun, daher ist es einfach, von links nach rechts zu lesen und zu überlegen, was passieren wird. Dieser Ansatz dokumentiert auch eindeutig die Schrittlänge ( -n3) und das Filtermuster ( 9), sodass die Variabilität einfach ist:

count=3
find=9
xargs -n "$count" <<< "$list" | while read -ra a; do echo $a; done | grep "$find"

Wenn wir Fragen zur "Effizienz" stellen, denken Sie unbedingt an die "Gesamtlebensdauereffizienz". Diese Berechnung beinhaltet die Bemühungen der Betreuer, den Code am Laufen zu halten, und wir Fleischsäcke sind die am wenigsten effizienten Maschinen im gesamten Betrieb.

Vielleicht das?

cut -d' ' -f1,4,7,10,13 <<<$list
1 5 6 9 15

Verwenden Sie keine Shell-Befehle, wenn Sie effizient sein möchten. Beschränken Sie sich auf Pipes, Weiterleitungen, Ersetzungen usw. und Programme. Aus diesem Grunde xargsund parallelDienstprogramme vorhanden - weil bash While - Schleifen sind ineffizient und sehr langsam. Verwenden Sie Bash-Loops nur als letzte Lösung.

list="1 ant bat 5 cat dingo 6 emu fish 9 gecko hare 15 i j"
if 
    <<<"$list" tr -d -s '[0-9 ]' | 
    tr -s ' ' | tr ' ' '\n' | 
    grep -q -x '9'
then
    found=true
else 
    found=false
fi
echo ${found} 

Aber mit gut solltest du wohl etwas schneller werden awk.

Meiner Meinung nach besteht die klarste (und wahrscheinlich auch performanteste) Lösung darin, die Variablen RS und ORS awk zu verwenden:

awk -v RS=' ' -v ORS=' ' 'NR % 3 == 1' <<< "$list"

1. Verwenden des GNU- sed und POSIX- Shell-Skripts:

   echo $(printf '%s\n' $list | sed -n '1~3p')

2. Oder mit bashder Parametersubstitution :

   echo $(sed -n '1~3p' <<< ${list// /$'\n'})

3. Nicht- GNU ( dh POSIX ) sedund bash:

   sed 's/\([^ ]* \)[^ ]* *[^ ]* */\1/g' <<< "$list"

   Oder portabler mit POSIX sed und Shell-Skript:

   echo "$list" | sed 's/\([^ ]* \)[^ ]* *[^ ]* */\1/g'

Ausgabe von einem dieser:

1 5 6 9 15