Comment puis-je joindre des éléments d'un tableau dans Bash?

Si j'ai un tableau comme celui-ci dans Bash:

FOO=( a b c )

Comment joindre les éléments avec des virgules? Par exemple, produire a,b,c.

Solution de réécriture de Pascal Pilz en fonction en 100% pur Bash (pas de commandes externes):

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

Par exemple,

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

Alternativement, nous pouvons utiliser printf pour prendre en charge les délimiteurs à plusieurs caractères, en utilisant l'idée de @gniourf_gniourf

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

Par exemple,

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

Encore une autre solution:

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

echo $bar

Edit: idem mais pour séparateur à longueur variable multi-caractères:

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

Peut-être, par exemple,

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

echo "$FOOJOIN"

Étonnamment, ma solution n'est pas encore donnée :) C'est le moyen le plus simple pour moi. Il n'a pas besoin d'une fonction:

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

Remarque: Cette solution a été observée pour bien fonctionner en mode non-POSIX. En mode POSIX , les éléments sont toujours joints correctement, mais IFS=,deviennent permanents.

Voici une fonction Bash 100% pure qui fait le travail:

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

Regardez:

$ 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


$

Cela préserve même les nouvelles lignes de fin et n'a pas besoin d'un sous-shell pour obtenir le résultat de la fonction. Si vous n'aimez pas le printf -v(pourquoi ne l'aimeriez-vous pas?) Et en passant un nom de variable, vous pouvez bien sûr utiliser une variable globale pour la chaîne retournée:

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

Ce n'est pas trop différent des solutions existantes, mais cela évite d'utiliser une fonction distincte, ne modifie pas IFSdans le shell parent et est tout sur une seule ligne:

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

résultant en

a,b,c

Limitation: le séparateur ne peut pas dépasser un caractère.

Sans aucune commande externe:

$ 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

Attention, cela suppose que les éléments n'ont pas d'espaces.

Je voudrais faire écho au tableau sous forme de chaîne, puis transformer les espaces en sauts de ligne, puis utiliser pastepour joindre tout en une seule ligne comme suit:

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

Résultats:

a,b,c

Cela me semble être le plus rapide et le plus propre!

Avec la réutilisation de @, la solution n'a pas d'importance, mais avec une seule instruction en évitant la sous-station $ {: 1} et le besoin d'une variable intermédiaire.

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

printf a 'La chaîne de format est réutilisée aussi souvent que nécessaire pour satisfaire les arguments.' dans ses pages de manuel, afin que les concaténations des chaînes soient documentées. Ensuite, l'astuce consiste à utiliser la longueur de la LISTE pour hacher le dernier spérateur, car la coupe ne conservera que la longueur de la LISTE lorsque les champs compteront.

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

solution printf qui accepte des séparateurs de n'importe quelle longueur (basé sur @ n'a pas d'importance réponse)

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

Version plus courte de la première réponse:

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

Usage:

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

Combinez le meilleur de tous les mondes jusqu'à présent avec l'idée suivante.

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

Ce petit chef-d'œuvre est

• 100% pur bash (extension des paramètres avec IFS temporairement non défini, pas d'appels externes, pas d'impression ...)
• compact, complet et sans défaut (fonctionne avec des limiteurs à un ou plusieurs caractères, fonctionne avec des limiteurs contenant des espaces blancs, des sauts de ligne et d'autres caractères spéciaux du shell, fonctionne avec un délimiteur vide)
• efficace (pas de sous-shell, pas de copie de tableau)
• simple et stupide et, dans une certaine mesure, beau et instructif aussi

Exemples:

$ 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

En ce moment j'utilise:

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

Ce qui fonctionne, mais (dans le cas général) se cassera horriblement si les éléments du tableau ont un espace en eux.

(Pour ceux qui sont intéressés, il s'agit d'un script wrapper autour de pep8.py )

Ma tentative.

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

Utilisez perl pour les séparateurs multicaractères:

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

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

Ou en une seule ligne:

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

Merci @gniourf_gniourf pour les commentaires détaillés sur ma combinaison des meilleurs mondes jusqu'à présent. Désolé pour le code de publication non conçu et testé à fond. Voici un meilleur essai.

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

Cette beauté par conception est

• (toujours) 100% pure bash (merci d'avoir précisé explicitement que printf est également un module intégré. Je n'en étais pas conscient avant ...)
• fonctionne avec des délimiteurs à plusieurs caractères
• plus compact et plus complet et cette fois soigneusement réfléchi et testé à long terme avec des sous-chaînes aléatoires de scripts shell, entre autres, couvrant l'utilisation de caractères spéciaux de shell ou de caractères de contrôle ou aucun caractère dans le séparateur et / ou les paramètres, et les cas de bord , et les cas d'angle et autres problèmes comme aucun argument du tout. Cela ne garantit pas qu'il n'y a plus de bogue, mais ce sera un peu plus difficile d'en trouver un. BTW, même les réponses actuellement les mieux votées et liées souffrent de choses comme ce bogue -e ...

Exemples supplémentaires:

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

Dans le cas où les éléments que vous souhaitez joindre ne sont pas un tableau juste une chaîne séparée par des espaces, vous pouvez faire quelque chose comme ceci:

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

par exemple, mon cas d'utilisation est que certaines chaînes sont passées dans mon script shell et je dois l'utiliser pour exécuter une requête SQL:

./my_script "aa bb cc dd"

Dans mon_script, je dois faire "SELECT * FROM table WHERE name IN ('aa', 'bb', 'cc', 'dd'). La commande ci-dessus sera alors utile.

En voici un que la plupart des shells compatibles POSIX prennent en charge:

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

L'utilisation d'indirection variable pour se référer directement à un tableau fonctionne également. Les références nommées peuvent également être utilisées, mais elles ne sont devenues disponibles qu'en 4.3.

L'avantage de l'utilisation de cette forme de fonction est que le séparateur peut être facultatif (par défaut, le premier caractère par défaut IFS, qui est un espace; peut-être en faire une chaîne vide si vous le souhaitez), et cela évite d'étendre les valeurs deux fois (d'abord lorsqu'il est passé en tant que paramètres, et en second lieu "$@"à l'intérieur de la fonction).

Cette solution n'exige pas non plus que l'utilisateur appelle la fonction à l'intérieur d'une substitution de commande - qui invoque un sous-shell, pour obtenir une version jointe d'une chaîne affectée à une autre variable.

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.

N'hésitez pas à utiliser un nom plus confortable pour la fonction.

Cela fonctionne de 3.1 à 5.0-alpha. Comme observé, l'indirection variable ne fonctionne pas seulement avec des variables mais aussi avec d'autres paramètres.

Un paramètre est une entité qui stocke des valeurs. Il peut s'agir d'un nom, d'un nombre ou de l'un des caractères spéciaux répertoriés ci-dessous sous Paramètres spéciaux. Une variable est un paramètre désigné par un nom.

Les tableaux et les éléments de tableau sont également des paramètres (entités qui stockent de la valeur), et les références aux tableaux sont également des références techniques aux paramètres. Et tout comme le paramètre spécial @, array[@]fait également une référence valide.

Les formes d'expansion modifiées ou sélectives (comme l'expansion de la sous-chaîne) qui dévient la référence du paramètre lui-même ne fonctionnent plus.

Mise à jour

Dans la version finale de Bash 5.0, l' indirection variable est déjà appelée expansion indirecte et son comportement est déjà explicitement documenté dans le manuel:

Si le premier caractère du paramètre est un point d'exclamation (!) Et que le paramètre n'est pas un nom, il introduit un niveau d'indirection. Bash utilise la valeur formée en développant le reste du paramètre comme nouveau paramètre; celle-ci est ensuite développée et cette valeur est utilisée dans le reste de l'expansion, plutôt que dans l'expansion du paramètre d'origine. C'est ce qu'on appelle l'expansion indirecte.

Prenant note que dans la documentation de ${parameter}, parameterest appelé "un paramètre shell comme décrit (dans) PARAMETRES ou une référence de tableau ". Et dans la documentation des tableaux, il est mentionné que "Tout élément d'un tableau peut être référencé en utilisant ${name[subscript]}". Cela fait __r[@]une référence de tableau.

Join by arguments version

Voir mon commentaire dans la réponse de Riccardo Galli .

Cette approche prend soin des espaces dans les valeurs, mais nécessite une boucle:

#!/bin/bash

FOO=( a b c )
BAR=""

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

Si vous construisez le tableau en boucle, voici un moyen simple:

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

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

C'est le moyen le plus court de le faire.

Exemple,

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

Peut-être en retard pour la fête, mais cela fonctionne pour moi:

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

  echo "${output}"
}

Peut-être que je manque quelque chose d'évident, car je suis un nouveau dans le bash / zsh, mais il me semble que vous n'avez pas besoin du tout d'utiliser printf. Il ne devient pas vraiment moche de s'en passer.

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

Au moins, cela a fonctionné pour moi jusqu'à présent sans problème.

Par exemple, join \| *.shqui, disons que je suis dans mon ~répertoire, sort utilities.sh|play.sh|foobar.sh. Suffisant pour moi.

EDIT: Ceci est essentiellement la réponse de Nil Geisweiller , mais généralisé en fonction.

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

Cela prend également en charge la virgule supplémentaire à la fin. Je ne suis pas un expert bash. Juste mon 2c, car c'est plus élémentaire et plus compréhensible

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

ou

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