Bash'te bir dizinin öğelerine nasıl katılabilirim?

Bash böyle bir dizi varsa:

FOO=( a b c )

Öğelere virgülle nasıl katılırım? Örneğin, üretmek a,b,c.

Pascal Pilz tarafından% 100 saf Bash işlevi olarak yeniden yazma çözümü (harici komutlar yok):

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

Örneğin,

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

Alternatif olarak, @gniourf_gniourf fikrini kullanarak çok karakterli sınırlayıcıları desteklemek için printf'yi kullanabiliriz

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

Örneğin,

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

Yine başka bir çözüm:

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

echo $bar

Düzenleme: aynı ama çok karakterli değişken uzunluk ayırıcı için:

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

Belki, örneğin,

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

echo "$FOOJOIN"

Şaşırtıcı bir şekilde benim çözüm henüz verilmemiş :) Bu benim için en basit yol. Bir fonksiyona ihtiyaç duymaz:

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

Not: Bu çözümün POSIX olmayan modda iyi çalıştığı gözlemlendi. In POSIX modunda , elemanlar hala düzgün katıldı ancak IFS=,kalıcı hale gelir.

İşte işi yapan% 100 saf Bash işlevi:

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

Bak:

$ 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


$

Bu, sondaki yeni satırları bile korur ve işlevin sonucunu elde etmek için alt kabuğa ihtiyaç duymaz. Eğer böyle yapmazsanız printf -vve bir değişken adı geçen (? Neden böyle olmaz), tabii ki döndürülen dize için küresel değişkeni kullanabilirsiniz:

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

Bu, mevcut çözümlerden çok farklı değildir, ancak ayrı bir işlev kullanmaktan kaçınır IFS, üst kabukta değişiklik yapmaz ve hepsi tek bir satırdadır:

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

sonuçlanan

a,b,c

Sınırlama: ayırıcı bir karakterden uzun olamaz.

Harici komut kullanma:

$ 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

Uyarı, öğelerin boşluklara sahip olmadığını varsayar.

Dizeyi bir dize olarak yankılandı, sonra boşlukları satır beslemelerine dönüştürür ve daha sonra pasteböyle bir satırdaki her şeyi birleştirmek için kullanılır :

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

Sonuçlar:

a,b,c

Bu benim için en hızlı ve en temiz gibi görünüyor!

@ 'Nin yeniden kullanılması önemli bir çözüm değildir, ancak $ {: 1} alt bölümünden ve bir aracı değişken gereksiniminden kaçınarak tek bir ifadeyle.

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

printf 'Biçim dizesi, bağımsız değişkenleri karşılamak için gerektiği sıklıkta yeniden kullanılıyor.' man sayfalarında, dizelerin birleşimleri belgelenir. Sonra, püf noktası, son toplayıcıyı kesmek için LIST uzunluğunu kullanmaktır, çünkü kesim alanlar sayıldıkça yalnızca LIST uzunluğunu koruyacaktır.

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

Herhangi bir uzunluktaki ayırıcıları kabul eden printf çözümü (@ temel alınarak cevap önemli değildir)

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

Üst cevabın daha kısa versiyonu:

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

Kullanımı:

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

Şu ana kadar tüm dünyaların en iyilerini aşağıdaki fikirle birleştirin.

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

Bu küçük şaheser

• % 100 saf bash (IFS ile geçici olarak ayarlanmamış parametre genişletme, harici arama yok, baskı yok ...)
• kompakt, eksiksiz ve kusursuz (tek ve çok karakterli sınırlayıcılarla çalışır, beyaz boşluk, satır kesmeleri ve diğer kabuk özel karakterlerini içeren sınırlayıcılarla çalışır, boş sınırlayıcı ile çalışır)
• verimli (alt kabuk yok, dizi kopyası yok)
• basit ve aptal ve bir dereceye kadar güzel ve öğretici de

Örnekler:

$ 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

Şu anda kullanıyorum:

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

Hangi çalışır, ancak (genel durumda) dizi öğelerinin içinde bir boşluk varsa korkunç bir şekilde kırılacaktır.

(İlgilenenler için bu, pep8.py etrafındaki bir paket betiğidir )

Denemem.

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

Çok karakterli ayırıcılar için perl kullanın:

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

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

Veya tek bir satırda:

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

Şimdiye kadarki en iyi dünya kombinasyonum hakkında detaylı yorumlar için @gniourf_gniourf teşekkürler. Kod iyice tasarlanmış ve test edilmemiş posta gönderme için üzgünüm. İşte daha iyi bir deneme.

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

Bu güzellik anlayışı ile

• (hala)% 100 saf bash (printf'in de bir yerleşik olduğunu açıkça belirttiğiniz için teşekkürler. Daha önce bunun farkında değildim ...)
• çok karakterli sınırlayıcılarla çalışır
• daha kompakt ve daha eksiksizdir ve bu kez dikkatli bir şekilde düşünülmüş ve kabuk komut dosyalarından rastgele alt dizelerle diğerlerinin arasında rastgele alt dizelerle test edilmiştir, kabuk özel karakterlerinin veya kontrol karakterlerinin kullanımını veya ayırıcı ve / veya parametrelerde ve kenar kutularında karakter içermez ve köşe davaları ve hiç tartışmaya benzemeyen diğer tartışmalar. Bu, artık hata olmadığını garanti etmez, ancak bir tane bulmak biraz daha zor olacaktır. BTW, şu anda en çok oy alan cevaplar ve ilgili -e hata gibi şeylerden muzdarip ...

Ek örnekler:

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

Birleştirmek istediğiniz öğelerin yalnızca boşlukla ayrılmış bir dize olmaması durumunda, şöyle bir şey yapabilirsiniz:

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

Örneğin, benim kullanım durumum bazı dizeleri benim kabuk komut dosyasında geçirilir ve bir SQL sorgusu üzerinde çalıştırmak için bunu kullanmanız gerekir:

./my_script "aa bb cc dd"

My_script içinde "SELECT * FROM table WHERE name IN ('aa', 'bb', 'cc', 'dd') yapmam gerekiyor. Sonra yukarıdaki komut yararlı olacaktır.

POSIX uyumlu kabukların çoğunun desteklediği bir özellik:

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

Doğrudan bir diziye başvurmak için değişken dolaylı kullanımı da çalışır. Adlandırılmış referanslar da kullanılabilir, ancak yalnızca 4.3'te kullanılabilir hale geldi.

Bir fonksiyonun bu biçimini kullanmanın avantajı, ayırıcıyı isteğe bağlı (varsayılan olarak varsayılan ilk karakter olan IFSboşluk anlamına gelir; belki de isterseniz boş bir dize haline getirebilirsiniz) ve değerleri iki kez genişletmekten kaçınmasıdır (önce parametre olarak geçtiğinde "$@"ve fonksiyonun içindeki gibi ikinci ).

Bu çözüm, kullanıcının başka bir değişkene atanan bir dizenin birleşik bir sürümünü almak için, işlevi bir alt kabuk çağrısı yapan bir komut ikamesi içinde çağırmasını gerektirmez.

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.

İşlev için daha rahat bir ad kullanmaktan çekinmeyin.

Bu 3.1 ila 5.0-alfa çalışır. Gözlemlendiği gibi, değişken dolaylama sadece değişkenlerle değil, diğer parametrelerle de çalışır.

Parametre, değerleri depolayan bir varlıktır. Bir ad, bir sayı veya aşağıda Özel Parametreler altında listelenen özel karakterlerden biri olabilir. Değişken, bir adla gösterilen bir parametredir.

Diziler ve dizi öğeleri de parametrelerdir (değeri depolayan varlıklar) ve dizilere yapılan başvurular teknik olarak parametrelere de başvurulur. Ve özel parametre gibi @,array[@] aynı zamanda geçerli bir gönderme yapmaktadır.

Referansı parametrenin kendisinden saptıran değiştirilmiş veya seçici genişletme biçimleri (alt dize genişletmesi gibi) artık çalışmaz.

Güncelleme

Bash 5.0'ın yayın sürümünde, değişken dolaylamaya zaten dolaylı genişleme denir ve davranışı kılavuzda zaten açıkça belgelenmiştir:

Parametrenin ilk karakteri bir ünlem işareti (!) İse ve parametre bir aderef değilse, bir dolaylı aktarma düzeyi sağlar. Bash, parametrenin geri kalanını yeni parametre olarak genişleterek oluşan değeri kullanır; bu daha sonra genişletilir ve bu değer, orijinal parametrenin genişletilmesinden ziyade, genişletmenin geri kalanında kullanılır. Buna dolaylı genişleme denir.

Belgelerinde bu not alarak ${parameter}, parameterşu şekilde ifade edilir "tarif edildiği gibi (içinde) gibi bir kabuk parametresi PARAMETRELER veya dizi referans ". Ve dizilerin dokümantasyonunda, "Bir dizinin herhangi bir elemanına ${name[subscript]}" atıfta bulunulabilir " denir . Bu yapar__r[@] bir dizi başvurusu .

Bağımsız değişken sürümüne katıl

Benim Bkz yorumunu içinde Riccardo Galli cevap .

Bu yaklaşım, değerler içindeki boşluklarla ilgilenir, ancak bir döngü gerektirir:

#!/bin/bash

FOO=( a b c )
BAR=""

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

Diziyi bir döngü içinde oluşturursanız, işte basit bir yol:

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

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

Bunu yapmanın en kısa yolu budur.

Misal,

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

Belki partiye geç kaldım, ama bu benim için işe yarıyor:

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

  echo "${output}"
}

Belki de barh bir şeyi kaçırıyorum, çünkü bash / zsh'ın tamamında yeniyim, ama bana hiç kullanmanıza gerek yokmuş gibi görünüyor printf. Ayrıca onsuz yapmak çok çirkin olmaz.

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

En azından benim için şimdiye kadar sorunsuz çalıştı.

Örneğin join \| *.sh, dizinimde olduğumu ~varsayalım, çıktılarutilities.sh|play.sh|foobar.sh . Benim için yeterince iyi.

DÜZENLEME: Bu temel olarak Nil Geisweiller'in cevabıdır , ancak bir fonksiyonda genelleştirilmiştir.

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

Bu, sonunda ekstra virgülle de ilgilenir. Ben bash uzmanı değilim. Sadece 2c'im, çünkü bu daha basit ve anlaşılır

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

veya

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