[GELÖST] Drei Array-Inhalte pro Schleifendurchlauf anzeigen

[BrotherJ]

Hallo,

ich stehe gerade auf dem Schlauch. Mit folgenden Script

Code: Alles auswählen

#!/bin/bash
a=0
for i in $(ls -t *.jpg | sort -n)
do
        array[$a]=$i
        ((a++))
done

k=1
for j in "${array[@]}"
do
        n=${array[j+1]}
        m=${array[j+2]}
        echo "$k: $j $n $m"
        j=`expr $j + 3`
        k=`expr $k + 1`
done

will ich folgende Ausgabe erzeugen:

1: 00001.jpg 00002.jpg 00003.jpg
2: 00004.jpg 00005.jpg 00006.jpg
3: 00007.jpg 00008.jpg 00009.jpg

erhalten tue ich aber das hier

Zeile 12: 00001.jpg: Syntaxfehler: Ungültiger arithmetischer Operator. (Fehlerverursachendes Zeichen ist \".jpg\").

Wie bekomme ich es hin, dass im j. Durchlauf bereits die Array-Inhalte von j, dem von j+1 und dem von j+2 anzeigt werden und die Schleife im darauf folgenden Durchlauf j um 3 erhöht?

Besten Dank

BrotherJ

[JTH]

Die Schleife in der Form for x in y geht direkt über alle Elemente des Arrays, nicht über die Indizes.

Zeile 12: 00001.jpg: Syntaxfehler: Ungültiger arithmetischer Operator. (Fehlerverursachendes Zeichen ist \".jpg\").

Du hast in der bemängelten Zeile also etwa so etwas stehen – was offensichtlich für ein Array mit numerischen Indizes unsinnig ist:

Code: Alles auswählen

for j in "${array[@]}"; do
        n=${array["00001.jpg+1"]}
        […]
done

Die naheliegenste Lösung für deine Aufgabe ist eine Schleife im C-Stil:

Code: Alles auswählen

a=( a b c d e )

for ((i = 0; i < ${#a[@]}; i += 3)); do
	echo "${a[i]} ${a[i + 1]} ${a[i + 2]}"
done

Falls du set -u benutzt, musst du bei den Einträgen i+1 und i+2 extra prüfen, ob die noch in der Indexmenge des Arrays sind (also kleiner sind als ${#a[@]}).


Nebenbei:
An ein Array anhängen geht auch ohne manuelles Hochzählen des Index’:

Code: Alles auswählen

array=()
for i in $(ls -t *.jpg | sort -n); do
        array+=( $i )
done

Und warum sortierst du erst nach Datum (ls -t) und die Liste dann nochmal nach numerischem Namen (sort -n)? Die Namen aller JPEGs bekommst du auch einfacher per Globbing, ohne ls-Aufruf. Die Sortierung dürfte für den Anwendungsfall die gleiche sein:

Code: Alles auswählen

array=()
for i in *.jpg; do
        array+=( $i )
done

Und das geht dann sogar noch kürzer als Einzeiler:

Code: Alles auswählen

array=( *.jpg )

Letztere Sachen sind die Stärken einer Shell

[Meillo]

Weil ich gerade Lust darauf hatte:

Code: Alles auswählen

$ ls | awk '{l=l" "$0} NR%3==0{printf("%d:%s\n", NR/3, l);l=""}'    
1: 00001.jpg 00002.jpg 00003.jpg
2: 00004.jpg 00005.jpg 00006.jpg
3: 00007.jpg 00008.jpg 00009.jpg

[BrotherJ]

Vielen Dank für Deine Hinweise, vor allem der "Schleife im C-Stil".

[eggy]

@Meillo: da fehlt noch nen END{...} mit Test auf mod und Ausgabe unfertiger Zeilen, falls NR nicht glatt durch drei teilbar

[Meillo]

@Meillo: da fehlt noch nen END{...} mit Test auf mod und Ausgabe unfertiger Zeilen, falls NR nicht glatt durch drei teilbar

Ach menno ... jetzt ist meine Umsetzung gar nicht mehr schoen.

Danke fuer den Hinweis. Da muss ich wohl noch mal ran ...

[Meillo]

Hier nun eine Version, die auch eine halbe letzte Zeile korrekt ausgibt:

Code: Alles auswählen

awk '
        {l=l" "$0}
        NR%3==0 {printf("%d:%s\n", NR/3, l);l=""}
        END {if(l)printf("%d:%s\n",NR/3+1,l)}
'

Schoen ist die aber nicht, darum habe ich nochmal frisch angesetzt und diese Variante entworfen:

Code: Alles auswählen

awk '{printf" "$0} NR%3==0{print""}'|awk '{print NR":"$0}'

Die gefaellt mir viel besser, zudem kann sie auch bequem an einer einzigen Stelle auf mehr oder weniger Spalten angepasst werden.

[JTH]

Ich bin wohl angesteckt, mal mehr mit awk rumzubasteln (mehr als eine Spalte/ein Feld auswählen und ausgeben war das bisher meist nicht)

Da hab ich aber auch den Ehrgeiz, alles in einem awk-Skript zu lösen Das wären meine Varianten (adaptiert von Meillo oben) - die Anzahl auszugebender Elemente pro Zeile taucht auch nur einmal auf:

Code: Alles auswählen

awk -vM=3 '(NR-1)%M==0{printf "%d:", NR/M} {printf " "$0} NR%M==0{print ""} END{print ""}'

awk -vM=3 'i==0{printf "%d:", NR/M} {printf " "$0; ++i} i==M{print ""; i=0} END{print ""}'

awk -vM=3 'l==""{l=sprintf("%d:", NR/M)} {l=l" "$0} NR%M==0{print l; l=""} END{if(l) print l}' 

Die kommen allerdings nicht gegen die Kürze der zwei gepipeten awk-Aufrufe an.

[Meillo]

Ich bin wohl angesteckt, mal mehr mit awk rumzubasteln (mehr als eine Spalte/ein Feld auswählen und ausgeben war das bisher meist nicht)

Da hab ich aber auch den Ehrgeiz, alles in einem awk-Skript zu lösen

Damit verfolgst du die falschen Ziele ... vielleicht solltest du es dann besser mit Perl versuchen.

Eigentlich war awk nie dazu gedacht, groessere Programme zu schreiben, sondern gerade die Integration in Shell-Pipelines ist es was awk ausmacht. Auch aus Divide-and-Conquer-Sicht solltest du die Aufteilung in die zwei Teilaufgaben Spaltierung und Zeilennummerierung nicht abwerten. Falls naemlich die Form der Nummerierung nicht genau so sein muss, kann man den zweiten awk-Aufruf einfach durch nl(1) ersetzen. Ich wuerde daher sagen, dass die Aufteilung in zwei Programme eher positiv gewertet werden sollte.

Das wären meine Varianten (adaptiert von Meillo oben) - die Anzahl auszugebender Elemente pro Zeile taucht auch nur einmal auf:

Code: Alles auswählen

awk -vM=3 '(NR-1)%M==0{printf "%d:", NR/M} {printf " "$0} NR%M==0{print ""} END{print ""}'

awk -vM=3 'i==0{printf "%d:", NR/M} {printf " "$0; ++i} i==M{print ""; i=0} END{print ""}'

awk -vM=3 'l==""{l=sprintf("%d:", NR/M)} {l=l" "$0} NR%M==0{print l; l=""} END{if(l) print l}' 

Die klammerlose Schreibweise von printf() und die spacelosen String-Verkettungen sind nicht unbedingt ein toller Stil ... den ich nur manchmal wegen der Kuerze aus Vergnuegen einsetze. Es macht ja auch Spass, alle nicht unbedingt noetigen Spaces wegzulassen ... hier beispielsweise alle bis auf den im String:

Code: Alles auswählen

awk -vM=3 'i==0{printf"%d:",NR/M}{printf" "$0;++i}i==M{print"";i=0}END{print""}'

... sieht doch schon viel kuschliger aus!

[eggy]

Die Vorzüge von END werden viel zu selten genutzt, daher ist meine bevorzugte Variante für solche Fälle:

Code: Alles auswählen

seq 1 10 | awk 'NR%3==1{if (NR>1){L=L"\n"}; L=L int(NR/3)+1 ":"} {L=L" "$0} END{print L}' 

oder um sich den erneuten Vergleich in jedem Durchlauf zu sparen:

Code: Alles auswählen

seq 1 10 | awk 'NR%3==1{L=L"\n"int(NR/3)+1 ":"} {L=L" "$0} END{print substr(L, 2, length(L) - 1)}' 

Die zweite Variante nur zur Befriedigung akademischer Neugier. Bei seq 1 10000000 und jeweils einmaligen Test nach dev/null mit ner ungefähren Laufzeit von je knapp über 4 Sekunden, nicht mal ne halbe Sekunde Unterschied. Da brauch ich wesentlich länger die Syntax von substring nachzuschlagen, als diese "Optimierung" bei mir je einsparen wird.

Um noch Meillos schickes "awk | awk" aufzugreifen, der zweite Teil geht aber auch kürzer. Gemäß dem Motto "one tool - one task":

Code: Alles auswählen

 seq 1 11 | awk '{printf" "$0} NR%3==0{print""}' | nl -s ":"

Edit: /me hat mal wieder Tomatensalat auf den Augen gehabt nl hatte Meillo ja schon selbst genannt

[Meillo]

Die Vorzüge von END werden viel zu selten genutzt, daher ist meine bevorzugte Variante für solche Fälle:

Code: Alles auswählen

seq 1 10 | awk 'NR%3==1{if (NR>1){L=L"\n"}; L=L int(NR/3)+1 ":"} {L=L" "$0} END{print L}' 

oder um sich den erneuten Vergleich in jedem Durchlauf zu sparen:

Code: Alles auswählen

seq 1 10 | awk 'NR%3==1{L=L"\n"int(NR/3)+1 ":"} {L=L" "$0} END{print substr(L, 2, length(L) - 1)}' 

Tendenziell finde ich Ansaetze, die alles in den Speicher lesen, nicht so schoen, wenn das nicht sein muss. Die Substring-Idee finde ich aber -- gerade in dieser absurden Form -- dann doch irgendwie cool.

Irgendwie denke ich bei awk nie mit substr(), sondern wuerde immer sub() stattdessen verwenden ... weil das besser zu awk passt. Hier konkret frage ich mich, warum du beim substr() das dritte Argument nicht weglaesst? (Das muesstest du noch nicht mal nachlesen, weil fast alle Substring-Implementierungen das so anbieten.)

Um noch Meillos schickes "awk | awk" aufzugreifen, der zweite Teil geht aber auch kürzer. Gemäß dem Motto "one tool - one task":

Code: Alles auswählen

 seq 1 11 | awk '{printf" "$0} NR%3==0{print""}' | nl -s ":"

Leider kann nl(1) nicht genau so gesteuert werden wie es hier gewuenscht ist, denn bei deinem Vorschlag gibt es noch leading Spaces. Am ehesten kommt das hin:

Code: Alles auswählen

nl -s: -w1

Aber wenn die Zahlen zweistellig werden, schneidet das einfach die zweite Stelle ab. (Schade, dass nl(1) nicht die Angabe eines printf-Formats erlaubt; das wuerde alle Moeglichkeiten oeffnen.)


Insgesamt festigt sich bei mir die Meinung, dass der geteilte Ansatz mit Spaltierung und Nummerierung der beste Weg ist.

[eggy]

Hier konkret frage ich mich, warum du beim substr() das dritte Argument nicht weglaesst?

grep str *.awk | head -1

[Meillo]

Hier konkret frage ich mich, warum du beim substr() das dritte Argument nicht weglaesst?

grep str *.awk | head -1

Versteh' ich nicht.

[eggy]

War die erste Fundstelle in meinem Scriptverzeichnis. Ich war zu faul in der Manpage zu suchen ... und das hab ich nun davon (in der Datei in der ich das mal benutzt hatte war's ursprünglich nämlich -3 und nicht -1, da also mit drei Parametern da dann sinnvoll)

[Meillo]

Aber wenn du angefangen haettest nachzudenken, dann waere dir doch auch bewusst geworden, dass Substring-Funktionen in vielen Sprachen einen optionalen Ende-Parameter haben. Z.B.:
https://www.gnu.org/software/bash/manua ... -Expansion
https://www.php.net/substr
https://docs.oracle.com/javase/7/docs/a ... tring(int)
etc.

... wahrscheinlich programmierst du aber coolere Sprachen, die sich nicht mit so imperativem Kram rumschlagen.

[eggy]

Nachdenken?! ... wie kommst Du denn bloß auf so abwegige Ideen .. Leute gibts

[Meillo]

Ich hab mir nochmal was ausgedacht (da ich ja keine derartige Abneigung gegen das Denken habe ):

Code: Alles auswählen

sed 'n;n;s/$/\n/'|fmt|awk '/./{print++i":",$0}'

(Extra in whitespacearmer Schnuckelform. )

[eggy]

nice - da hat sich das Denken aber mal gelohnt

[Meillo]

... kannst dieses abwegige Denk-Ding ja auch mal ausprobieren ... nur so fuer die Erfahrung ... kannst's dann ja auch wieder lassen, wenn's nicht so dein's ist.

[JTH]

Ich hab mir nochmal was ausgedacht (da ich ja keine derartige Abneigung gegen das Denken habe ):

Hehe, definitiv die kreativste Lösung bisher.

Bei meinen ganzen Dateinamen mit über 80 Zeichen bricht das 3-Namen-in-einer-Zeile aber leider wieder am fmt in der Mitte

Code: Alles auswählen

printf "%080d.viel %080d.zu %080d.lange %080d.Namen" 1 2 3 4 | sed 'n;n;s/$/\n/'|fmt|awk '/./{print++i":",$0}'

Die klammerlose Schreibweise von printf() und die spacelosen String-Verkettungen sind nicht unbedingt ein toller Stil ...

(Extra in whitespacearmer Schnuckelform. )

Jaja, normalerweise bin ich großzügiger mit der Formatierung Das passte nur nicht mehr so gut in eine Zeile im Forum.

vielleicht solltest du es dann besser mit Perl versuchen.

Hatte das Vergnügen schon bei der Wartung von ein paar CGIs. Nähere Auseinandersetzung mit Perl steht trotzdem mal auf der Todo-Liste.

Ich wuerde daher sagen, dass die Aufteilung in zwei Programme eher positiv gewertet werden sollte.

Nach beruflicher Erfahrung mit einem Bash-basierten, unkontrolliert gewachsenen Backend, das für kleinste Dinge ewig brauchte, bin ich ziemlich dafür sensibilisiert, dass Subshells und Pipelines für jede Kleinigkeit sich irgendwann zeitlich bemerkbar machen. Deshalb der Ehrgeiz, das meiste mit Shell-Builtins oder zumindest möglichst wenigen Werkzeugen zu lösen. Vielleicht verlier ich dabei manchmal die Stärke mancher Helferlein aus den Augen

[eggy]

... kannst dieses abwegige Denk-Ding ja auch mal ausprobieren ... nur so fuer die Erfahrung ... kannst's dann ja auch wieder lassen, wenn's nicht so dein's ist.

Nee blos nicht, beim letzten Mal gab's drei Tage furchtbares Koppweh

@JTH: fmt -w irgendwas ... ka, was da das Maximum ist (MAXINT vermutlich )

[JTH]

@JTH: fmt -w irgendwas ... ka, was da das Maximum ist (MAXINT vermutlich )

Sollte man erwarten:

Code: Alles auswählen

~$ fmt -w 2501
fmt: invalid width: ‘2501’: Numerical result out of range
~$ echo Löppt! | fmt -w 2500
Löppt!

Nanu, wo kommt denn die Grenze her. Ich werd mal grad was nachschlagen.

Edit: „arbitrary limits“, immer nett

[eggy]

Um nochmal etwas ontopic zu bleiben, mir lässt die nl Sache keine Ruhe.

Code: Alles auswählen

seq 1 3000 | awk '{printf" "$0} NR%3==0{print""}' | nl -s ":" -w1

Theoretisch™ sollte das rechtsbündig ohne Spaces ja irgendwie einfach machbar sein, -n in kombination mit -w scheint kaputt, aber wenn oben man statt -w1 z.B -w4 mitgibt geht's in die richtige Richtung. Nur wie kommt jetzt am besten an den jeweils passenden Wert für w?
Meine erste Idee wäre den Wert via ((wc eingabe) mod 3) zu finden, evtl noch mit bc draufkloppen, nur und da hängt es grade noch, wie bekomm ich das seq bzw ls am besten parallel verarbeitet? tee? ... mal etwas liegenlassen und drüber schlafen
(@Meillo: ich hab grad schon überlegt, ob man da was mit namend pipes und parallel basteln könnte ... dieses schreckliche Nachdenken macht alles nur schlimmer )

[Meillo]

Bzgl. `fmt -w': Man muss es ja auch nicht uebertreiben. Doppelte Terminalbreite sollte in so Faellen so gut wie immer ausreichen. Irgendwie soll das Script ja auch einen Sinn haben ... der sich mir bei 2000 Zeichen langen Zeilen irgendwie nicht mehr so ganz erschliesst.

Anfangs hatte ich in meinem Code ein `-w200' drin, hab es dann aber weggelassen, weil ich es nicht unbedingt noetig fand und dachte, dass man das ja dann gleich merkt und in der Manpage problemlos findet.

Um nochmal etwas ontopic zu bleiben, mir lässt die nl Sache keine Ruhe.

Code: Alles auswählen

seq 1 3000 | awk '{printf" "$0} NR%3==0{print""}' | nl -s ":" -w1

Theoretisch™ sollte das rechtsbündig ohne Spaces ja irgendwie einfach machbar sein, -n in kombination mit -w scheint kaputt, aber wenn oben man statt -w1 z.B -w4 mitgibt geht's in die richtige Richtung. Nur wie kommt jetzt am besten an den jeweils passenden Wert für w?

nl ist ja so 'n neumodisches Ding, das eigentlich niemand braucht, weil man seit 1977 ja `awk '{print NR, $0}'' verwenden kann.

So wirklich ueberzeugt mich nl nicht. Was ist denn der Sinn von `-w', wenn es die Zahl einfach abschneidet, falls sie zu gross wird? Da verschiebe ich doch lieber das Layout anstatt Information wegzuwerfen. (So wie printf(3) das bei `%3d' auch macht.) Wenn ich mir die Manpage anschaue, dann weiss ich auch nicht recht ... das wirkt vom Stil so un-unix-artig, finde ich.

Waere mal interessant, zu recherchieren wo nl herstammt (also was das Design angeht, wer das entworfen hat, welchen Background die Person hatte, wofuer es geschrieben worden ist). Meine FreeBSD-Manpage sagt, dass es zuerst in SystemV R2 aufgetaucht ist. Das Utility ist sogar in POSIX spezifiziert: https://pubs.opengroup.org/onlinepubs/9 ... es/nl.html

[eggy]

Die Debianversion ist aus den coreutils
https://sources.debian.org/src/coreutil ... /src/nl.c/

/* Written by Scott Bartram (nancy!scott@uunet.uu.net)
Revised by David MacKenzie (djm@gnu.ai.mit.edu) */