Làm thế nào tôi có thể tham gia các phần tử của một mảng trong Bash?

Nếu tôi có một mảng như thế này trong Bash:

FOO=( a b c )

Làm thế nào để tôi tham gia các yếu tố với dấu phẩy? Ví dụ, sản xuất a,b,c.

Viết lại giải pháp của Pascal Pilz như một hàm trong Bash thuần 100% (không có lệnh bên ngoài):

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

Ví dụ,

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

Ngoài ra, chúng tôi có thể sử dụng printf để hỗ trợ các ký tự phân cách nhiều ký tự, sử dụng ý tưởng của @gniourf_gniourf

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

Ví dụ,

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

Một giải pháp khác:

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

echo $bar

Chỉnh sửa: giống nhau nhưng cho dấu phân cách độ dài biến đa ký tự:

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

Có lẽ, ví dụ,

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

echo "$FOOJOIN"

Đáng ngạc nhiên là giải pháp của tôi chưa được đưa ra :) Đây là cách đơn giản nhất đối với tôi. Nó không cần một chức năng:

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

Lưu ý: Giải pháp này được quan sát là hoạt động tốt ở chế độ không POSIX. Trong chế độ POSIX , các yếu tố vẫn được nối đúng, nhưng IFS=,trở thành vĩnh viễn.

Đây là hàm Bash thuần 100% thực hiện công việc:

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

Nhìn:

$ 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


$

Điều này bảo tồn ngay cả các dòng mới, và không cần một lớp con để có được kết quả của hàm. Nếu bạn không thích printf -v(tại sao bạn không thích nó?) Và truyền tên biến, tất nhiên bạn có thể sử dụng biến toàn cục cho chuỗi trả về:

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

Điều này không quá khác biệt so với các giải pháp hiện có, nhưng nó tránh sử dụng một chức năng riêng biệt, không sửa đổi IFStrong vỏ cha mẹ và tất cả chỉ trong một dòng:

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

dẫn đến

a,b,c

Giới hạn: dấu phân cách không thể dài hơn một ký tự.

Không sử dụng lệnh bên ngoài:

$ 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

Cảnh báo, nó giả sử các phần tử không có khoảng trắng.

Tôi sẽ lặp lại mảng dưới dạng một chuỗi, sau đó chuyển đổi khoảng trắng thành nguồn cấp dữ liệu và sau đó sử dụng pasteđể nối mọi thứ trong một dòng như vậy:

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

Các kết quả:

a,b,c

Đây dường như là cách nhanh nhất và sạch nhất đối với tôi!

Với việc sử dụng lại giải pháp @ không quan trọng, nhưng với một tuyên bố bằng cách tránh trạm biến áp $ {: 1} và cần một biến trung gian.

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

printf có 'Chuỗi định dạng được sử dụng lại thường xuyên khi cần thiết để đáp ứng các đối số.' trong các trang man của nó, sao cho các chuỗi của chuỗi được ghi lại. Sau đó, mẹo là sử dụng độ dài LIST để cắt người điều phối cuối cùng, vì việc cắt sẽ chỉ giữ lại chiều dài của LIST khi các trường được tính.

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

giải pháp printf chấp nhận dấu phân cách có độ dài bất kỳ (dựa trên câu trả lời @ không quan trọng)

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

Phiên bản ngắn hơn của câu trả lời hàng đầu:

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

Sử dụng:

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

Kết hợp tốt nhất của tất cả các thế giới cho đến nay với ý tưởng sau đây.

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

Kiệt tác nhỏ này là

• Bash thuần 100% (mở rộng tham số với IFS tạm thời không được đặt, không có cuộc gọi bên ngoài, không printf ...)
• nhỏ gọn, hoàn chỉnh và hoàn hảo (hoạt động với các bộ giới hạn đơn và đa ký tự, hoạt động với các bộ giới hạn chứa khoảng trắng, ngắt dòng và các ký tự đặc biệt khác của vỏ, hoạt động với dấu phân cách trống)
• hiệu quả (không có subshell, không có bản sao mảng)
• đơn giản và ngu ngốc và, ở một mức độ nhất định, đẹp và hướng dẫn là tốt

Ví dụ:

$ 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

Ngay bây giờ tôi đang sử dụng:

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

Cái nào hoạt động, nhưng (trong trường hợp chung) sẽ phá vỡ khủng khiếp nếu các phần tử mảng có một khoảng trắng trong chúng.

(Đối với những người quan tâm, đây là tập lệnh bao quanh pep8.py )

Nỗ lực của tôi.

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

Sử dụng perl cho các phân tách đa vi khuẩn:

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

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

Hoặc trong một dòng:

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

Cảm ơn @gniourf_gniourf đã nhận xét chi tiết về sự kết hợp thế giới tốt nhất của tôi cho đến nay. Xin lỗi vì đăng mã không được thiết kế và kiểm tra kỹ lưỡng. Đây là một thử tốt hơn.

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

Vẻ đẹp này theo quan niệm là

• (vẫn) bash nguyên chất 100% (cảm ơn vì đã chỉ ra rõ ràng rằng printf cũng là một nội dung. Tôi không biết về điều này trước đây ...)
• làm việc với các dấu phân cách đa ký tự
• gọn hơn và đầy đủ hơn và lần này đã suy nghĩ cẩn thận và kiểm tra căng thẳng dài hạn với các chuỗi ngẫu nhiên từ các tập lệnh shell trong số các tập lệnh khác, bao gồm việc sử dụng các ký tự đặc biệt hoặc ký tự điều khiển hoặc không có ký tự trong cả dấu tách và / hoặc tham số, và các trường hợp cạnh và các trường hợp góc và các vấn đề khác như không có đối số nào cả. Điều đó không đảm bảo không có thêm lỗi, nhưng sẽ khó hơn một chút để tìm ra nó. BTW, ngay cả những câu trả lời được bình chọn hàng đầu hiện nay và có liên quan phải chịu đựng những điều như vậy - đó là lỗi ...

Ví dụ khác:

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

Trong trường hợp các phần tử bạn muốn tham gia không phải là một mảng chỉ là một chuỗi được phân tách bằng dấu cách, bạn có thể làm một cái gì đó như thế này:

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

ví dụ, trường hợp sử dụng của tôi là một số chuỗi được truyền trong tập lệnh shell của tôi và tôi cần sử dụng chuỗi này để chạy trên truy vấn SQL:

./my_script "aa bb cc dd"

Trong my_script, tôi cần thực hiện "CHỌN * TỪ bảng WHERE tên IN ('aa', 'bb', 'cc', 'dd'). Sau đó, lệnh trên sẽ hữu ích.

Đây là một trong đó hầu hết các shell tương thích POSIX hỗ trợ:

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

Sử dụng biến gián tiếp để tham chiếu trực tiếp đến một mảng cũng hoạt động. Các tài liệu tham khảo được đặt tên cũng có thể được sử dụng, nhưng chúng chỉ có sẵn trong 4.3.

Ưu điểm của việc sử dụng dạng hàm này là bạn có thể có dấu phân cách tùy chọn (mặc định là ký tự đầu tiên của mặc định IFS, là khoảng trắng; có thể biến nó thành một chuỗi trống nếu bạn muốn) và nó tránh mở rộng giá trị hai lần (lần đầu tiên khi được truyền dưới dạng tham số và thứ hai là "$@"bên trong hàm).

Giải pháp này cũng không yêu cầu người dùng gọi hàm bên trong thay thế lệnh - triệu tập một chuỗi con, để có được một phiên bản nối của chuỗi được gán cho một biến khác.

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.

Hãy sử dụng một tên thoải mái hơn cho chức năng.

Điều này hoạt động từ 3,1 đến 5,0-alpha. Theo quan sát, chỉ định biến không chỉ hoạt động với các biến mà còn với các tham số khác.

Một tham số là một thực thể lưu trữ các giá trị. Nó có thể là tên, số hoặc một trong các ký tự đặc biệt được liệt kê bên dưới trong Thông số đặc biệt. Một biến là một tham số được biểu thị bằng một tên.

Mảng và các phần tử mảng cũng là các tham số (các thực thể lưu trữ giá trị) và các tham chiếu đến các mảng cũng là các tham chiếu kỹ thuật cho các tham số. Và giống như tham số đặc biệt @, array[@]cũng làm cho một tham chiếu hợp lệ.

Các hình thức mở rộng đã thay đổi hoặc chọn lọc (như mở rộng chuỗi con) làm sai lệch tham chiếu khỏi chính tham số không còn hoạt động.

Cập nhật

Trong phiên bản phát hành của Bash 5.0, cảm ứng biến được gọi là mở rộng gián tiếp và hành vi của nó đã được ghi lại rõ ràng trong hướng dẫn:

Nếu ký tự đầu tiên của tham số là dấu chấm than (!) Và tham số không phải là nameref, thì nó đưa ra một mức độ gián tiếp. Bash sử dụng giá trị được hình thành bằng cách mở rộng phần còn lại của tham số làm tham số mới; điều này sau đó được mở rộng và giá trị đó được sử dụng trong phần còn lại của việc mở rộng, thay vì mở rộng tham số ban đầu. Điều này được gọi là mở rộng gián tiếp.

Lưu ý rằng trong tài liệu của ${parameter}, parameterđược gọi là "tham số shell như được mô tả (trong) PARAMETERS hoặc tham chiếu mảng ". Và trong tài liệu về mảng, có đề cập rằng "Bất kỳ phần tử nào của mảng có thể được tham chiếu bằng cách sử dụng ${name[subscript]}". Điều này làm cho __r[@]một tài liệu tham khảo mảng.

Tham gia bằng phiên bản đối số

Xem bình luận của tôi trong câu trả lời của Riccardo Galli .

Cách tiếp cận này chăm sóc các khoảng trắng trong các giá trị, nhưng yêu cầu một vòng lặp:

#!/bin/bash

FOO=( a b c )
BAR=""

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

Nếu bạn xây dựng mảng trong một vòng lặp, đây là một cách đơn giản:

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

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

Đây là cách ngắn nhất để làm điều đó.

Thí dụ,

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

Có lẽ muộn cho bữa tiệc, nhưng điều này làm việc cho tôi:

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

  echo "${output}"
}

Có lẽ tôi đang thiếu một cái gì đó rõ ràng, vì tôi là người mới trong toàn bộ điều bash / zsh, nhưng có vẻ như tôi không cần sử dụng printfgì cả. Nó cũng không thực sự xấu xí để làm mà không có.

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

Ít nhất, nó đã làm việc cho tôi cho đến nay mà không có vấn đề.

Chẳng hạn, join \| *.shtrong đó, giả sử tôi đang ở trong ~thư mục của mình , xuất ra utilities.sh|play.sh|foobar.sh. Đủ tôt cho tôi.

EDIT: Về cơ bản đây là câu trả lời của Nil Geisweiller , nhưng được khái quát thành một chức năng.

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

Điều này cũng quan tâm đến dấu phẩy thừa ở cuối. Tôi không phải là chuyên gia bash. Chỉ là 2c của tôi, vì điều này là cơ bản và dễ hiểu hơn

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

hoặc là

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