Jak mogę połączyć elementy tablicy w Bash?

Jeśli mam taką tablicę w Bash:

FOO=( a b c )

Jak połączyć elementy przecinkami? Na przykład produkcja a,b,c.

Przepisywanie rozwiązania przez Pascala Pilza jako funkcja w 100% czystej Bash (bez zewnętrznych poleceń):

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

Na przykład,

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

Alternatywnie możemy użyć printf do obsługi ograniczników wieloznakowych, korzystając z pomysłu @gniourf_gniourf

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

Na przykład,

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

Jeszcze inne rozwiązanie:

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

echo $bar

Edycja: tak samo, ale dla wieloznakowego separatora o zmiennej długości:

#!/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

Może np.

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

echo "$FOOJOIN"

Co zaskakujące, moje rozwiązanie nie zostało jeszcze podane :) To dla mnie najprostszy sposób. Nie potrzebuje funkcji:

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

Uwaga: Zaobserwowano, że to rozwiązanie działa dobrze w trybie innym niż POSIX. W trybie POSIX elementy są nadal prawidłowo łączone, ale IFS=,stają się trwałe.

Oto w 100% czysta funkcja Bash, która wykonuje zadanie:

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}"
}

Popatrz:

$ 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


$

Zachowuje to nawet końcowe znaki nowego wiersza i nie wymaga podpowłoki, aby uzyskać wynik funkcji. Jeśli nie podoba ci się printf -v(dlaczego by ci się nie podobało?) I przekazujesz nazwę zmiennej, możesz oczywiście użyć zmiennej globalnej dla zwracanego ciągu:

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}"
}

Nie różni się to zbytnio od istniejących rozwiązań, ale unika używania osobnej funkcji, nie modyfikuje się IFSw powłoce nadrzędnej i znajduje się w jednym wierszu:

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

powodując

a,b,c

Ograniczenie: separator nie może być dłuższy niż jedna postać.

Bez użycia zewnętrznych poleceń:

$ 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

Ostrzeżenie, zakłada, że ​​elementy nie mają białych znaków.

Chciałbym powtórzyć tablicę jako ciąg znaków, a następnie przekształcić spacje w kanały liniowe, a następnie użyć pastedo połączenia wszystkiego w jednym wierszu w taki sposób:

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

Wyniki:

a,b,c

To wydaje mi się najszybsze i najczystsze!

Ponowne użycie @ nie ma znaczenia rozwiązanie, ale z jedną instrukcją, unikając podstacji $ {: 1} i potrzeby zmiennej pośredniej.

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

printf ma „Ciąg formatu jest ponownie wykorzystywany tak często, jak to konieczne, aby spełnić argumenty”. na stronach podręcznika, aby udokumentować konkatenacje łańcuchów. Zatem sztuczką jest użycie długości LISTY do posiekania ostatniego speratora, ponieważ cięcie zachowa tylko długość LISTY w miarę liczenia pól.

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

printf rozwiązanie, które akceptuje separatory dowolnej długości (na podstawie @ nie ma znaczenia odpowiedź)

#/!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

Krótsza wersja najwyższej odpowiedzi:

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

Stosowanie:

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

Połącz najlepsze ze wszystkich dotychczasowych światów z następującym pomysłem.

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

To małe arcydzieło

• 100% czysty bash (rozszerzenie parametrów z IFS tymczasowo rozbrojonym, brak połączeń zewnętrznych, brak printf ...)
• kompaktowy, kompletny i bezbłędny (współpracuje z ogranicznikami jedno- i wieloznakowymi, współpracuje z ogranicznikami zawierającymi białe znaki, podziały linii i inne znaki specjalne powłoki, współpracuje z pustym ogranicznikiem)
• wydajny (bez podpowłoki, bez kopiowania tablicy)
• proste i głupie, a do pewnego stopnia piękne i pouczające

Przykłady:

$ 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

Obecnie używam:

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 ' ' ','`"

Które działa, ale (w ogólnym przypadku) przerwie się okropnie, jeśli elementy tablicy będą miały spację.

(Dla zainteresowanych jest to skrypt otoki wokół pep8.py )

Moja próba

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

Użyj perla dla separatorów wieloznakowych:

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

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

Lub w jednym wierszu:

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

Dziękuję @gniourf_gniourf za szczegółowe komentarze na temat mojej dotychczasowej kombinacji najlepszych światów. Przepraszamy za kod pocztowy, który nie został dokładnie zaprojektowany i przetestowany. Oto lepsza próba.

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

To piękno z założenia jest

• (wciąż) 100% czysty bash (dzięki za wyraźne wskazanie, że printf jest również wbudowany. Nie wiedziałem o tym wcześniej ...)
• współpracuje z ogranicznikami wieloznakowymi
• bardziej zwarta i bardziej kompletna, tym razem dokładnie przemyślana i długoterminowo przetestowana pod obciążeniem z losowymi podciągami między innymi ze skryptów powłoki, obejmująca użycie specjalnych znaków powłoki lub znaków kontrolnych lub brak znaków w separatorze i / lub parametrach oraz przypadki krawędzi , a przypadki narożne i inne spory nie mają żadnych argumentów. To nie gwarantuje, że nie będzie już żadnego błędu, ale znalezienie go będzie trochę trudniejsze. BTW, nawet obecnie najczęściej głosowane odpowiedzi i pokrewne cierpią z powodu takich rzeczy jak ten -e błąd ...

Dodatkowe przykłady:

$ 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 $ 
$

Jeśli elementy, które chcesz połączyć, nie są tablicą, ale ciągiem znaków oddzielonych spacją, możesz zrobić coś takiego:

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

na przykład, moim przypadkiem użycia jest to, że niektóre ciągi znaków są przekazywane w moim skrypcie powłoki i muszę go użyć, aby uruchomić zapytanie SQL:

./my_script "aa bb cc dd"

W moim skrypcie muszę wykonać polecenie „WYBIERZ * Z tabeli, GDZIE nazwa IN („ aa ”,„ bb ”,„ cc ”,„ dd ”). Wtedy powyższe polecenie będzie przydatne.

Oto jeden, który obsługuje większość powłok kompatybilnych z POSIX:

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[@]}"
}

Działa również użycie pośredniej zmiennej do bezpośredniego odniesienia do tablicy. Można również użyć nazwanych referencji, ale stały się one dostępne dopiero w 4.3.

Zaletą korzystania z tej formy funkcji jest to, że separator może być opcjonalny (domyślnie jest to pierwszy znak domyślny IFS, który jest spacją; być może uczyni to pustym ciągiem, jeśli chcesz), i pozwala on uniknąć dwukrotnego zwiększania wartości (najpierw gdy przekazany jako parametry, a drugi jako"$@" wewnątrz funkcji).

To rozwiązanie nie wymaga również od użytkownika wywoływania funkcji w podstawieniu polecenia - które przywołuje podpowłokę, aby otrzymać połączoną wersję ciągu przypisanego do innej zmiennej.

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.

Możesz użyć wygodniejszej nazwy dla tej funkcji.

Działa to od 3.1 do 5.0-alfa. Jak zaobserwowano, pośrednia zmienność działa nie tylko ze zmiennymi, ale także z innymi parametrami.

Parametr to jednostka przechowująca wartości. Może to być nazwa, liczba lub jeden ze znaków specjalnych wymienionych poniżej w części Parametry specjalne. Zmienna jest parametrem oznaczonym nazwą.

Tablice i elementy tablic są również parametrami (encje przechowujące wartość), a odniesienia do tablic są również technicznie odniesieniami do parametrów. I podobnie jak parametr specjalny @,array[@] również stanowi ważne odniesienie.

Zmienione lub selektywne formy rozszerzenia (takie jak rozszerzenie substringu), które odbiegają od odniesienia do samego parametru, już nie działają.

Aktualizacja

W wydanej wersji Bash 5.0 zmienna pośrednia jest już nazywana rozszerzeniem pośrednim, a jej zachowanie jest już wyraźnie udokumentowane w podręczniku:

Jeśli pierwszym znakiem parametru jest wykrzyknik (!), A parametr nie jest nazwą, to wprowadza on poziom pośredni. Bash używa wartości utworzonej przez rozwinięcie reszty parametru jako nowego parametru; jest on następnie rozwijany i ta wartość jest wykorzystywana w pozostałej części rozwinięcia, a nie w rozszerzeniu oryginalnego parametru. Jest to znane jako ekspansja pośrednia.

Biorąc pod uwagę, że w dokumentacji ${parameter}, parameterjest określany jako „parametr powłoki, jak opisano (w) PARAMETRY lub odwołanie do tablicy ”. W dokumentacji tablic wspomniano, że „do dowolnego elementu tablicy można się odwoływać za pomocą ${name[subscript]}”. To sprawia, __r[@]że odwołanie do tablicy.

Dołącz według wersji argumentów

Zobacz mój komentarz w odpowiedzi Riccardo Galli .

To podejście zajmuje się spacjami w obrębie wartości, ale wymaga pętli:

#!/bin/bash

FOO=( a b c )
BAR=""

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

Jeśli budujesz tablicę w pętli, oto prosty sposób:

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

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

To najkrótszy sposób na zrobienie tego.

Przykład,

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

Być może późno na imprezę, ale to działa dla mnie:

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

  echo "${output}"
}

Być może brakuje mi czegoś oczywistego, ponieważ jestem nowicjuszem w całym bash / zsh, ale wydaje mi się, że nie musisz go wcale używać printf. Bez tego nie robi się naprawdę brzydko.

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

Przynajmniej do tej pory działało dla mnie bez problemu.

Na przykład, join \| *.shco powiedzmy, że jestem w moim ~katalogu, generuje dane wyjściowe utilities.sh|play.sh|foobar.sh. Wystarczająco dobrze dla mnie.

EDYCJA: Jest to w zasadzie odpowiedź Nila Geisweillera , ale uogólniona na funkcję.

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

Daje to również dodatkowy przecinek na końcu. Nie jestem ekspertem od bash. Tylko mój 2c, ponieważ jest to bardziej elementarne i zrozumiałe

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

lub

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