Wie kann ich Elemente eines Arrays in Bash verbinden?

Wenn ich ein Array wie dieses in Bash habe:

FOO=( a b c )

Wie verbinde ich die Elemente mit Kommas? Zum Beispiel produzieren a,b,c.

Umschreiblösung von Pascal Pilz als Funktion in 100% reinem Bash (keine externen Befehle):

function join_by { local IFS="$1"; shift; echo "$*"; }

Zum Beispiel,

join_by , a "b c" d #a,b c,d
join_by / var local tmp #var/local/tmp
join_by , "${FOO[@]}" #a,b,c

Alternativ können wir printf verwenden, um Trennzeichen mit mehreren Zeichen zu unterstützen, wobei die Idee von @gniourf_gniourf verwendet wird

function join_by { local d=$1; shift; echo -n "$1"; shift; printf "%s" "${@/#/$d}"; }

Zum Beispiel,

join_by , a b c #a,b,c
join_by ' , ' a b c #a , b , c
join_by ')|(' a b c #a)|(b)|(c
join_by ' %s ' a b c #a %s b %s c
join_by $'\n' a b c #a<newline>b<newline>c
join_by - a b c #a-b-c
join_by '\' a b c #a\b\c

Noch eine andere Lösung:

#!/bin/bash
foo=('foo bar' 'foo baz' 'bar baz')
bar=$(printf ",%s" "${foo[@]}")
bar=${bar:1}

echo $bar

Bearbeiten: gleich, jedoch für ein mehrstelliges Trennzeichen mit variabler Länge:

#!/bin/bash
separator=")|(" # e.g. constructing regex, pray it does not contain %s
foo=('foo bar' 'foo baz' 'bar baz')
regex="$( printf "${separator}%s" "${foo[@]}" )"
regex="${regex:${#separator}}" # remove leading separator
echo "${regex}"
# Prints: foo bar)|(foo baz)|(bar baz

$ foo=(a "b c" d)
$ bar=$(IFS=, ; echo "${foo[*]}")
$ echo "$bar"
a,b c,d

Vielleicht zB

SAVE_IFS="$IFS"
IFS=","
FOOJOIN="${FOO[*]}"
IFS="$SAVE_IFS"

echo "$FOOJOIN"

Überraschenderweise ist meine Lösung noch nicht gegeben :) Dies ist der einfachste Weg für mich. Es braucht keine Funktion:

IFS=, eval 'joined="${foo[*]}"'

Hinweis: Es wurde beobachtet, dass diese Lösung im Nicht-POSIX-Modus gut funktioniert. Im POSIX-Modus sind die Elemente weiterhin ordnungsgemäß verbunden, werden jedoch IFS=,dauerhaft.

Hier ist eine 100% reine Bash-Funktion, die den Job erledigt:

join() {
    # $1 is return variable name
    # $2 is sep
    # $3... are the elements to join
    local retname=$1 sep=$2 ret=$3
    shift 3 || shift $(($#))
    printf -v "$retname" "%s" "$ret${@/#/$sep}"
}

Aussehen:

$ a=( one two "three three" four five )
$ join joineda " and " "${a[@]}"
$ echo "$joineda"
one and two and three three and four and five
$ join joinedb randomsep "only one element"
$ echo "$joinedb"
only one element
$ join joinedc randomsep
$ echo "$joinedc"

$ a=( $' stuff with\nnewlines\n' $'and trailing newlines\n\n' )
$ join joineda $'a sep with\nnewlines\n' "${a[@]}"
$ echo "$joineda"
 stuff with
newlines
a sep with
newlines
and trailing newlines


$

Dadurch bleiben auch die nachfolgenden Zeilenumbrüche erhalten, und es ist keine Unterschale erforderlich, um das Ergebnis der Funktion zu erhalten. Wenn Ihnen das nicht gefällt printf -v(warum würde es Ihnen nicht gefallen?) Und Sie einen Variablennamen übergeben, können Sie natürlich eine globale Variable für die zurückgegebene Zeichenfolge verwenden:

join() {
    # $1 is sep
    # $2... are the elements to join
    # return is in global variable join_ret
    local sep=$1 IFS=
    join_ret=$2
    shift 2 || shift $(($#))
    join_ret+="${*/#/$sep}"
}

Dies unterscheidet sich nicht allzu sehr von vorhandenen Lösungen, vermeidet jedoch die Verwendung einer separaten Funktion, ändert sich nicht IFSin der übergeordneten Shell und befindet sich in einer einzigen Zeile:

arr=(a b c)
printf '%s\n' "$(IFS=,; printf '%s' "${arr[*]}")"

ergebend

a,b,c

Einschränkung: Das Trennzeichen darf nicht länger als ein Zeichen sein.

Keine externen Befehle verwenden:

$ FOO=( a b c )     # initialize the array
$ BAR=${FOO[@]}     # create a space delimited string from array
$ BAZ=${BAR// /,}   # use parameter expansion to substitute spaces with comma
$ echo $BAZ
a,b,c

Warnung: Es wird davon ausgegangen, dass Elemente keine Leerzeichen haben.

Ich würde das Array als Zeichenfolge wiedergeben, dann die Leerzeichen in Zeilenvorschübe umwandeln und dann pastealles in einer Zeile wie folgt verbinden:

tr " " "\n" <<< "$FOO" | paste -sd , -

Ergebnisse:

a,b,c

Dies scheint mir das schnellste und sauberste zu sein!

Bei der Wiederverwendung von @ spielt die Lösung keine Rolle, aber bei einer One-Anweisung wird die Substitution $ {: 1} vermieden und eine Zwischenvariable benötigt.

echo $(printf "%s," "${LIST[@]}" | cut -d "," -f 1-${#LIST[@]} )

printf hat 'Die Formatzeichenfolge wird so oft wie nötig wiederverwendet, um die Argumente zu erfüllen.' in seinen Manpages, so dass die Verkettungen der Strings dokumentiert werden. Dann besteht der Trick darin, die LIST-Länge zu verwenden, um den letzten Sperator zu zerhacken, da beim Schneiden nur die Länge der LIST beibehalten wird, wenn die Felder zählen.

s=$(IFS=, eval 'echo "${FOO[*]}"')

printf-Lösung, die Trennzeichen beliebiger Länge akzeptiert (basierend auf @ spielt keine Rolle, Antwort)

#/!bin/bash
foo=('foo bar' 'foo baz' 'bar baz')

sep=',' # can be of any length
bar=$(printf "${sep}%s" "${foo[@]}")
bar=${bar:${#sep}}

echo $bar

$ set a 'b c' d

$ history -p "$@" | paste -sd,
a,b c,d

Kürzere Version der Top-Antwort:

joinStrings() { local a=("${@:3}"); printf "%s" "$2${a[@]/#/$1}"; }

Verwendungszweck:

joinStrings "$myDelimiter" "${myArray[@]}"

Kombinieren Sie das bisher Beste aller Welten mit der folgenden Idee.

# join with separator
join_ws()  { local IFS=; local s="${*/#/$1}"; echo "${s#"$1$1$1"}"; }

Dieses kleine Meisterwerk ist

• 100% pure bash (Parametererweiterung mit IFS vorübergehend deaktiviert, keine externen Aufrufe, kein printf ...)
• kompakt, vollständig und fehlerfrei (funktioniert mit Einzel- und Mehrzeichenbegrenzern, funktioniert mit Begrenzern, die Leerzeichen, Zeilenumbrüche und andere Shell-Sonderzeichen enthalten, funktioniert mit leerem Trennzeichen)
• effizient (keine Subshell, keine Array-Kopie)
• einfach und dumm und bis zu einem gewissen Grad auch schön und lehrreich

Beispiele:

$ join_ws , a b c
a,b,c
$ join_ws '' a b c
abc
$ join_ws $'\n' a b c
a
b
c
$ join_ws ' \/ ' A B C
A \/ B \/ C

Im Moment benutze ich:

TO_IGNORE=(
    E201 # Whitespace after '('
    E301 # Expected N blank lines, found M
    E303 # Too many blank lines (pep8 gets confused by comments)
)
ARGS="--ignore `echo ${TO_IGNORE[@]} | tr ' ' ','`"

Was funktioniert, aber (im allgemeinen Fall) schrecklich kaputt geht, wenn Array-Elemente ein Leerzeichen enthalten.

(Für Interessierte ist dies ein Wrapper-Skript um pep8.py )

Mein Versuch.

$ array=(one two "three four" five)
$ echo "${array[0]}$(printf " SEP %s" "${array[@]:1}")"
one SEP two SEP three four SEP five

Verwenden Sie Perl für Trennzeichen mit mehreren Zeichen:

function join {
   perl -e '$s = shift @ARGV; print join($s, @ARGV);' "$@"; 
}

join ', ' a b c # a, b, c

Oder in einer Zeile:

perl -le 'print join(shift, @ARGV);' ', ' 1 2 3
1, 2, 3

Vielen Dank an @gniourf_gniourf für detaillierte Kommentare zu meiner Kombination der besten Welten bisher. Entschuldigung für den nicht gründlich entworfenen und getesteten Posting-Code. Hier ist ein besserer Versuch.

# join with separator
join_ws() { local d=$1 s=$2; shift 2 && printf %s "$s${@/#/$d}"; }

Diese Schönheit von der Empfängnis ist

• (immer noch) 100% reine Bash (danke, dass Sie ausdrücklich darauf hingewiesen haben, dass printf ebenfalls ein eingebautes Bash ist. Das war mir vorher nicht bewusst ...)
• funktioniert mit Trennzeichen für mehrere Zeichen
• kompakter und vollständiger und diesmal sorgfältig überlegt und langfristig mit zufälligen Teilzeichenfolgen aus Shell-Skripten unter anderem auf die Verwendung von Shell-Sonderzeichen oder Steuerzeichen oder keinen Zeichen in Trennzeichen und / oder Parametern sowie Randfällen getestet und Eckfälle und andere Streitfragen mögen überhaupt keine Argumente. Das garantiert nicht, dass es keinen Fehler mehr gibt, aber es wird etwas schwieriger sein, einen zu finden. Übrigens leiden sogar die derzeit am besten bewerteten Antworten und verwandte Antworten unter solchen Dingen - dem Fehler ...

Zusätzliche Beispiele:

$ join_ws '' a b c
abc
$ join_ws ':' {1,7}{A..C}
1A:1B:1C:7A:7B:7C
$ join_ws -e -e
-e
$ join_ws $'\033[F' $'\n\n\n'  1.  2.  3.  $'\n\n\n\n'
3.
2.
1.
$ join_ws $ 
$

Falls die Elemente, die Sie verbinden möchten, kein Array sind, sondern nur eine durch Leerzeichen getrennte Zeichenfolge, können Sie Folgendes tun:

foo="aa bb cc dd"
bar=`for i in $foo; do printf ",'%s'" $i; done`
bar=${bar:1}
echo $bar
    'aa','bb','cc','dd'

Mein Anwendungsfall ist beispielsweise, dass einige Zeichenfolgen in meinem Shell-Skript übergeben werden und ich diese verwenden muss, um eine SQL-Abfrage auszuführen:

./my_script "aa bb cc dd"

In my_script muss ich "SELECT * FROM table WHERE name IN ('aa', 'bb', 'cc', 'dd') ausführen. Dann ist der obige Befehl nützlich.

Hier ist eine, die die meisten POSIX-kompatiblen Shells unterstützen:

join_by() {
    # Usage:  join_by "||" a b c d
    local arg arr=() sep="$1"
    shift
    for arg in "$@"; do
        if [ 0 -lt "${#arr[@]}" ]; then
            arr+=("${sep}")
        fi
        arr+=("${arg}") || break
    done
    printf "%s" "${arr[@]}"
}

Die Verwendung der variablen Indirektion, um direkt auf ein Array zu verweisen, funktioniert ebenfalls. Benannte Referenzen können ebenfalls verwendet werden, wurden jedoch erst in 4.3 verfügbar.

Der Vorteil dieser Form einer Funktion besteht darin, dass Sie das Trennzeichen optional haben können (standardmäßig das erste Standardzeichen IFS, das ein Leerzeichen ist; machen Sie es möglicherweise zu einer leeren Zeichenfolge, wenn Sie möchten), und es vermeidet das zweimalige Erweitern von Werten (zuerst) wenn als Parameter übergeben, und zweitens als"$@" innerhalb der Funktion).

Bei dieser Lösung muss der Benutzer die Funktion auch nicht innerhalb einer Befehlssubstitution aufrufen, die eine Unterschale aufruft, um eine verknüpfte Version einer Zeichenfolge zu erhalten, die einer anderen Variablen zugewiesen ist.

function join_by_ref {
    __=
    local __r=$1[@] __s=${2-' '}
    printf -v __ "${__s//\%/%%}%s" "${!__r}"
    __=${__:${#__s}}
}

array=(1 2 3 4)

join_by_ref array
echo "$__" # Prints '1 2 3 4'.

join_by_ref array '%s'
echo "$__" # Prints '1%s2%s3%s4'.

join_by_ref 'invalid*' '%s' # Bash 4.4 shows "invalid*[@]: bad substitution".
echo "$__" # Prints nothing but newline.

Fühlen Sie sich frei, einen bequemeren Namen für die Funktion zu verwenden.

Dies funktioniert von 3.1 bis 5.0-alpha. Wie beobachtet, funktioniert die Variablen-Indirektion nicht nur mit Variablen, sondern auch mit anderen Parametern.

Ein Parameter ist eine Entität, die Werte speichert. Dies kann ein Name, eine Nummer oder eines der unten unter Sonderparameter aufgeführten Sonderzeichen sein. Eine Variable ist ein Parameter, der durch einen Namen gekennzeichnet ist.

Arrays und Array-Elemente sind ebenfalls Parameter (Entitäten, die Werte speichern), und Verweise auf Arrays sind auch technisch Verweise auf Parameter. Und ähnlich wie die speziellen Parameter @, array[@]macht auch eine gültige Referenz.

Geänderte oder selektive Expansionsformen (wie die Teilstringerweiterung), die vom Parameter selbst abweichen, funktionieren nicht mehr.

Aktualisieren

In der Release-Version von Bash 5.0 wird die variable Indirektion bereits als indirekte Erweiterung bezeichnet und ihr Verhalten ist bereits im Handbuch explizit dokumentiert:

Wenn das erste Zeichen des Parameters ein Ausrufezeichen (!) Ist und der Parameter kein Namensreferenz, wird eine Indirektionsebene eingeführt. Bash verwendet den Wert, der durch Erweitern des restlichen Parameters als neuer Parameter gebildet wird. Dies wird dann erweitert und dieser Wert wird im Rest der Erweiterung anstelle der Erweiterung des ursprünglichen Parameters verwendet. Dies wird als indirekte Expansion bezeichnet.

Beachten Sie, dass in der Dokumentation von ${parameter}, parameterals "Shell-Parameter wie beschrieben (in) PARAMETER oder Array-Referenz " bezeichnet wird. In der Dokumentation von Arrays wird erwähnt, dass "auf jedes Element eines Arrays mit verwiesen werden kann ${name[subscript]}". Dies macht __r[@]eine Array-Referenz.

Join durch Argumente Version

Siehe meinen Kommentar in Riccardo Gallis Antwort .

Dieser Ansatz berücksichtigt Leerzeichen innerhalb der Werte, erfordert jedoch eine Schleife:

#!/bin/bash

FOO=( a b c )
BAR=""

for index in ${!FOO[*]}
do
    BAR="$BAR,${FOO[$index]}"
done
echo ${BAR:1}

Wenn Sie das Array in einer Schleife erstellen, haben Sie folgende einfache Möglichkeit:

arr=()
for x in $(some_cmd); do
   arr+=($x,)
done
arr[-1]=${arr[-1]%,}
echo ${arr[*]}

x=${"${arr[*]}"// /,}

Dies ist der kürzeste Weg, dies zu tun.

Beispiel,

arr=(1 2 3 4 5)
x=${"${arr[*]}"// /,}
echo $x  # output: 1,2,3,4,5

Vielleicht zu spät zur Party, aber das funktioniert bei mir:

function joinArray() {
  local delimiter="${1}"
  local output="${2}"
  for param in ${@:3}; do
    output="${output}${delimiter}${param}"
  done

  echo "${output}"
}

Vielleicht fehlt mir etwas Offensichtliches, da ich ein Neuling in der ganzen Bash / Zsh-Sache bin, aber es sieht für mich so aus, als müssten Sie es überhaupt nicht verwenden printf. Es wird auch nicht wirklich hässlich, darauf zu verzichten.

join() {
  separator=$1
  arr=$*
  arr=${arr:2} # throw away separator and following space
  arr=${arr// /$separator}
}

Zumindest hat es bei mir bisher ohne Probleme geklappt.

Zum Beispiel, join \| *.shwas, sagen wir, ich bin in meinem ~Verzeichnis, ausgegeben wird utilities.sh|play.sh|foobar.sh. Gut genug für mich.

EDIT: Dies ist im Grunde die Antwort von Nil Geisweiller , aber verallgemeinert in eine Funktion.

liststr=""
for item in list
do
    liststr=$item,$liststr
done
LEN=`expr length $liststr`
LEN=`expr $LEN - 1`
liststr=${liststr:0:$LEN}

Dies sorgt auch für das zusätzliche Komma am Ende. Ich bin kein Bash-Experte. Nur mein 2c, da dies elementarer und verständlicher ist

awk -v sep=. 'BEGIN{ORS=OFS="";for(i=1;i<ARGC;i++){print ARGV[i],ARGC-i-1?sep:""}}' "${arr[@]}"

oder

$ a=(1 "a b" 3)
$ b=$(IFS=, ; echo "${a[*]}")
$ echo $b
1,a b,3