如果我在Bash中有这样的数组:
FOO=( a b c )
如何用逗号将元素加入? 例如,产生a,b,c
。
#1楼
重复使用@无关紧要的解决方案,但是通过避免$ {:1}的替换和避免中间变量的使用来声明。
echo $(printf "%s," "${LIST[@]}" | cut -d "," -f 1-${#LIST[@]} )
printf具有“格式字符串根据需要满足参数重复使用的频率。” 在其手册页中,以便记录字符串的串联。 然后,诀窍是使用LIST长度来切碎最后一个spaster,因为cut将仅保留LIST的长度作为字段数。
#2楼
$ set a 'b c' d
$ history -p "$@" | paste -sd,
a,b c,d
#3楼
不使用外部命令:
$ 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
警告,它假定元素没有空格。
#4楼
也许,例如
SAVE_IFS="$IFS"
IFS=","
FOOJOIN="${FOO[*]}"
IFS="$SAVE_IFS"
echo "$FOOJOIN"
#5楼
现在我正在使用:
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 ' ' ','`"
哪个可行,但是(在一般情况下)如果数组元素中有空格,则会严重破坏。
(对于那些感兴趣的人,这是一个围绕pep8.py的包装脚本)
#6楼
这种方法照顾值内的空格,但需要循环:
#!/bin/bash
FOO=( a b c )
BAR=""
for index in ${!FOO[*]}
do
BAR="$BAR,${FOO[$index]}"
done
echo ${BAR:1}
#7楼
s=$(IFS=, eval 'echo "${FOO[*]}"')
#8楼
如果您要连接的元素不是数组,而只是一个用空格分隔的字符串,则可以执行以下操作:
foo="aa bb cc dd"
bar=`for i in $foo; do printf ",'%s'" $i; done`
bar=${bar:1}
echo $bar
'aa','bb','cc','dd'
例如,我的用例是在我的shell脚本中传递了一些字符串,我需要使用它在SQL查询上运行:
./my_script "aa bb cc dd"
在my_script中,我需要执行“ SELECT * FROM table WHERE name IN('aa','bb','cc','dd')。然后上述命令将非常有用。
#9楼
可以接受任意长度分隔符的printf解决方案(基于@无关紧要的答案)
#/!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
#10楼
Pascal Pilz将解决方案重写为100%纯Bash中的函数(无外部命令):
function join_by { local IFS="$1"; shift; echo "$*"; }
例如,
join_by , a "b c" d #a,b c,d
join_by / var local tmp #var/local/tmp
join_by , "${FOO[@]}" #a,b,c
另外,我们可以使用printf来支持多字符定界符,使用@gniourf_gniourf的想法
function join_by { local d=$1; shift; echo -n "$1"; shift; printf "%s" "${@/#/$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
#11楼
awk -v sep=. 'BEGIN{ORS=OFS="";for(i=1;i<ARGC;i++){print ARGV[i],ARGC-i-1?sep:""}}' "${arr[@]}"
要么
$ a=(1 "a b" 3)
$ b=$(IFS=, ; echo "${a[*]}")
$ echo $b
1,a b,3
#12楼
另一个解决方案:
#!/bin/bash
foo=('foo bar' 'foo baz' 'bar baz')
bar=$(printf ",%s" "${foo[@]}")
bar=${bar:1}
echo $bar
编辑:相同,但对于多字符可变长度分隔符:
#!/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
#13楼
我的尝试。
$ array=(one two "three four" five)
$ echo "${array[0]}$(printf " SEP %s" "${array[@]:1}")"
one SEP two SEP three four SEP five
#14楼
这是完成此任务的100%纯Bash函数:
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}"
}
看:
$ 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
$
这甚至保留了尾随的换行符,并且不需要子shell即可获得函数的结果。 如果您不喜欢printf -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}"
}
#15楼
将perl用于多字符分隔符:
function join {
perl -e '$s = shift @ARGV; print join($s, @ARGV);' "$@";
}
join ', ' a b c # a, b, c
或一行:
perl -le 'print join(shift, @ARGV);' ', ' 1 2 3
1, 2, 3
#16楼
也许我缺少明显的东西,因为我是整个bash / zsh的新手,但是在我看来,您根本不需要使用printf
。 没有它也不会变得非常丑陋。
join() {
separator=$1
arr=$*
arr=${arr:2} # throw away separator and following space
arr=${arr// /$separator}
}
至少到目前为止,它对我没有任何问题。
例如, join \\| *.sh
join \\| *.sh
(假设我位于~
目录中)输出utilities.sh|play.sh|foobar.sh
。 对我来说足够好了。
编辑:这基本上是Nil Geisweiller的答案 ,但被概括为一个函数。
#17楼
令人惊讶的是我的解决方案还没有给出:)这对我来说是最简单的方法。 它不需要功能:
IFS=, eval 'joined="${foo[*]}"'
注意:观察到此解决方案在非POSIX模式下可以很好地工作。 在POSIX模式下 ,元素仍然可以正确连接,但是IFS=,
成为永久的。
#18楼
最佳答案的简短版本:
joinStrings() { local a=("${@:3}"); printf "%s" "$2${a[@]/#/$1}"; }
用法:
joinStrings "$myDelimiter" "${myArray[@]}"
#19楼
我会将数组作为字符串回显,然后将空格转换为换行符,然后使用paste
将所有内容连接到一行中,如下所示:
tr " " "\\n" <<< "$FOO" | paste -sd , -
结果:
a,b,c
这对我来说似乎是最快,最干净的!
#20楼
如果您以循环方式构建数组,请使用以下简单方法:
arr=()
for x in $(some_cmd); do
arr+=($x,)
done
arr[-1]=${arr[-1]%,}
echo ${arr[*]}
#21楼
到目前为止,结合了以下所有想法。
# join with separator
join_ws() { local IFS=; local s="${*/#/$1}"; echo "${s#"$1$1$1"}"; }
这个小杰作是
- 100%纯bash(暂时未设置IFS的参数扩展,无外部调用,无printf ...)
- 紧凑,完整和完美(适用于单字符和多字符限制器,适用于包含空格,换行符和其他外壳特殊字符的限制器,适用于空的分隔符)
- 高效(无子shell,无数组副本)
- 简单而愚蠢,并且在一定程度上也很美丽和具有启发性
例子:
$ 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
#22楼
感谢@gniourf_gniourf对到目前为止我的最佳组合的详细评论。 抱歉,发布代码未经全面设计和测试。 这是一个更好的尝试。
# join with separator
join_ws() { local d=$1 s=$2; shift 2 && printf %s "$s${@/#/$d}"; }
从概念上讲,这种美是
- (仍然)100%纯bash(感谢您明确指出printf也是内置函数。在此之前我没有意识到这一点)
- 与多字符定界符一起使用
- 更紧凑,更完整,这次我们仔细考虑了一下,并使用了来自shell脚本等的随机子字符串进行了长期压力测试,其中包括使用shell特殊字符或控制字符,或者在分隔符和/或参数中均不使用字符,以及使用边沿情况,以及极端情况和其他怪癖,就像根本没有参数一样。 那不能保证不再有bug,但是要找到一个bug会比较困难。 顺便说一句,即使是目前票数最高的答案及相关问题,也受到诸如-e bug之类的困扰...
其他示例:
$ 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 $
$
#23楼
使用变量间接指向直接引用数组也可以。 也可以使用命名引用,但是它们仅在4.3中可用。
使用这种形式的函数的优点是,您可以使分隔符为可选(默认为默认IFS
的第一个字符,它是一个空格;如果愿意,可以将其设置为空字符串),并且避免将值扩展两次(首先是作为参数传递,其次是函数内部的"$@"
)。
此解决方案也不需要用户在命令替换内调用该函数-召唤一个子外壳,以获得分配给另一个变量的字符串的合并版本。
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.
这适用于3.1到5.0-alpha。 正如观察到的那样,变量间接寻址不仅适用于变量,还适用于其他参数。
参数是存储值的实体。 它可以是名称,数字或特殊参数下面列出的特殊字符之一。 变量是用名称表示的参数。
数组和数组元素也是参数(存储值的实体),从技术上讲,对数组的引用也是对参数的引用。 与特殊参数@
, array[@]
也提供有效的引用。
与参数本身不同的引用的扩展或选择性扩展形式(如子字符串扩展)不再起作用。
更新资料
在Bash 5.0的发行版中, 变量间接已被称为间接扩展 ,其行为已在手册中明确记录:
如果parameter的第一个字符是感叹号(!),并且parameter不是nameref,则它引入一个间接级别。 Bash使用通过扩展其余参数形成的值作为新参数; 然后对其进行扩展,并在其余扩展中使用该值,而不是原始参数的扩展。 这称为间接扩展。
请注意,在${parameter}
的文档中, parameter
称为shell参数,如在PARAMETERS中描述的那样或在数组引用中 。 并且在数组的文档中,提到可以使用${name[subscript]}
来引用数组的任何元素。 这使__r[@]
成为数组引用。
按参数加入版本
请参阅Riccardo Galli的答案中的 评论 。
#24楼
这与现有解决方案并没有太大不同,但是它避免了使用单独的函数,不修改父外壳中的IFS
,并且全部在一行中:
arr=(a b c)
printf '%s\n' "$(IFS=,; printf '%s' "${arr[*]}")"
导致
a,b,c
限制:分隔符不能超过一个字符。
#25楼
这是大多数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[@]}"
}
#26楼
x=${"${arr[*]}"// /,}
这是最短的方法。
例,
arr=(1 2 3 4 5)
x=${"${arr[*]}"// /,}
echo $x # output: 1,2,3,4,5
#27楼
liststr=""
for item in list
do
liststr=$item,$liststr
done
LEN=`expr length $liststr`
LEN=`expr $LEN - 1`
liststr=${liststr:0:$LEN}
最后还要注意多余的逗号。 我不是bash专家。 只是我的2c,因为这比较基础并且可以理解
#28楼
$ foo=(a "b c" d)
$ bar=$(IFS=, ; echo "${foo[*]}")
$ echo "$bar"
a,b c,d