如何在Bash中连接字符串变量

Question

在PHP中,字符串连接在一起如下:

$foo = "Hello";
$foo .= " World";

在这里,$foo成为"Hello World".

在Bash中如何实现？

Answer 1

foo="Hello"
foo="${foo} World"
echo "${foo}"
> Hello World

通常,要连接两个变量,您可以一个接一个地编写它们:

a='Hello'
b='World'
c="${a} ${b}"
echo "${c}"
> Hello World

Answer 2

Bash还支持+=运算符,如下代码所示:

$ A="X Y"
$ A+=" Z"
$ echo "$A"
X Y Z

Answer 3

Bash第一

由于这个问题专门针对Bash,我的答案的第一部分将提供不同的方法来正确地做到这一点:

+=:附加到变量

语法+=可以以不同方式使用:

附加到字符串 var+=...

(因为我节俭,我只会用两个变量foo和a,然后在整个答案重复使用相同的;-).

a=2
a+=4
echo $a
24

使用Stack Overflow问题语法,

foo="Hello"
foo+=" World"
echo $foo
Hello World

工作良好!

附加到整数 ((var+=...))

变量a是一个字符串,但也是一个整数

echo $a
24
((a+=12))
echo $a
36

附加到数组 var+=(...)

我们a也是一个只有一个元素的阵列.

echo ${a[@]}
36

a+=(18)

echo ${a[@]}
36 18
echo ${a[0]}
36
echo ${a[1]}
18

请注意,在括号之间,有一个空格分隔的数组.如果要在数组中存储包含空格的字符串,则必须将它们括起来:

a+=(one word "hello world!" )
bash: !": event not found

嗯...... 这不是一个bug,而是一个功能 ......为了防止bash尝试开发!",你可以:

a+=(one word "hello world"! 'hello world!' $'hello world\041')

declare -p a
declare -a a='([0]="36" [1]="18" [2]="one" [3]="word" [4]="hello world!" [5]="h
ello world!" [6]="hello world!")'

printf:使用builtin命令重新构造变量

该printf 内建命令给出绘制字符串格式的一种强有力的方式.由于这是一个Bash 内置,因此可以选择将格式化字符串发送到变量而不是打印stdout:

echo ${a[@]}
36 18 one word hello world! hello world! hello world!

这个数组中有七个字符串.所以我们可以构建一个包含七个位置参数的格式化字符串:

printf -v a "%s./.%s...'%s' '%s', '%s'=='%s'=='%s'" "${a[@]}"
echo $a
36./.18...'one' 'word', 'hello world!'=='hello world!'=='hello world!'

或者我们可以使用一个参数格式字符串,这将重复提交多个参数...

请注意,我们a仍然是一个数组!只有第一个元素被改变了!

declare -p a
declare -a a='([0]="36./.18...'\''one'\'' '\''word'\'', '\''hello world!'\''=='\
''hello world!'\''=='\''hello world!'\''" [1]="18" [2]="one" [3]="word" [4]="hel
lo world!" [5]="hello world!" [6]="hello world!")'

在bash下,当您在不指定索引的情况下访问变量名时,您始终只能查询第一个元素!

所以要检索我们的七个字段数组,我们只需要重新设置第一个元素:

a=36
declare -p a
declare -a a='([0]="36" [1]="18" [2]="one" [3]="word" [4]="hello world!" [5]="he
llo world!" [6]="hello world!")'

传递给许多参数的一个参数格式字符串:

printf -v a[0] '<%s>\n' "${a[@]}"
echo "$a"
<36>
<18>
<one>
<word>
<hello world!>
<hello world!>
<hello world!>

使用Stack Overflow问题语法:

foo="Hello"
printf -v foo "%s World" $foo
echo $foo
Hello World

NOTA:使用双引号可以是用于操作包含字符串有用spaces,tabulations和/或newlines

printf -v foo "%s World" "$foo"

壳牌现在

在POSIX shell下,你不能使用bashisms,所以没有内置 printf.

基本上

但你可以这样做:

foo="Hello"
foo="$foo World"
echo $foo
Hello World

格式化,使用分叉 printf

如果你想使用更复杂的结构,你必须使用fork(创建作业的新子进程并通过它返回结果stdout):

foo="Hello"
foo=$(printf "%s World" "$foo")
echo $foo
Hello World

从历史上看,您可以使用反引号来检索fork的结果:

foo="Hello"
foo=`printf "%s World" "$foo"`
echo $foo
Hello World

但这对于嵌套来说并不容易:

foo="Today is: "
foo=$(printf "%s %s" "$foo" "$(date)")
echo $foo
Today is: Sun Aug 4 11:58:23 CEST 2013

使用反斜杠,你必须使用反斜杠逃避内叉:

foo="Today is: "
foo=`printf "%s %s" "$foo" "\`date\`"`
echo $foo
Today is: Sun Aug 4 11:59:10 CEST 2013

Answer 4

你也可以这样做:

$ var="myscript"

$ echo $var

myscript


$ var=${var}.sh

$ echo $var

myscript.sh

Answer 5

bla=hello
laber=kthx
echo "${bla}ohai${laber}bye"

会输出

helloohaikthxbye

当$blaohai 导致变量未找到错误时,这很有用 .或者如果字符串中有空格或其他特殊字符."${foo}"适当地逃避你投入的任何东西.

Answer 6

foo="Hello "
foo="$foo World"

     

Answer 7

我解决问题的方法就是

$a$b

例如,

a="Hello"
b=" World"
c=$a$b
echo "$c"

哪个产生

Hello World

例如,如果您尝试将字符串与另一个字符串连接起来,

a="Hello"
c="$a World"

然后echo "$c"会产生

Hello World

有一个额外的空间.

$aWorld

你可能想象不起作用,但是

${a}World

产生

HelloWorld

Answer 8

$ a=hip
$ b=hop
$ ab=$a$b
$ echo $ab
hiphop
$ echo $a$b
hiphop

Answer 9

以下是大多数答案所讨论的简要总结.

假设我们有两个变量:

set one two
a=hello
b=world

下表解释了我们可以组合a和b创建新变量的值的不同上下文c.

Context                               | Expression            | Result (value of c)
--------------------------------------+-----------------------+---------------------
Two variables                         | c=$a$b                | helloworld
A variable and a literal              | c=${a}_world          | hello_world
A variable and a literal              | c=$1world             | oneworld
A variable and a literal              | c=$a/world            | hello/world
A variable, a literal, with a space   | c=${a}" world"        | hello world
A more complex expression             | c="${a}_one|${b}_2"   | hello_one|world_2
Using += operator (Bash 3.1 or later) | c=$a; c+=$b           | helloworld
Append literal with +=                | c=$a; c+=" world"     | hello world

几点说明:

• 用双引号括起赋值的RHS通常是一种很好的做法,尽管在很多情况下它是非常可选的
• += 如果以较小的增量构建一个大字符串,尤其是在循环中,从性能角度来看会更好
• 使用{}变量名称来消除其扩展的歧义(如上表中的第2行)

也可以看看:

• BashFAQ/013 - 如何连接两个变量？
• 我们什么时候需要围绕shell变量的花括号？

Answer 10

如果你想追加下划线之类的东西,请使用escape(\)

FILEPATH=/opt/myfile

这并不能正常工作:

echo $FILEPATH_$DATEX

这很好用:

echo $FILEPATH\\_$DATEX

Answer 11

又一种方法......

> H="Hello "
> U="$H""universe."
> echo $U
Hello universe.

......还有一个.

> H="Hello "
> U=$H"universe."
> echo $U
Hello universe.

Answer 12

引号最简单的方法:

B=Bar
b=bar
var="$B""$b""a"
echo "Hello ""$var"

Answer 13

您可以在没有引号的情况下连接.这是一个例子:

$Variable1 Open
$Variable2 Systems
$Variable3 $Variable1$Variable2
$echo $Variable3

最后一个语句将打印"OpenSystems"(没有引号).

这是Bash脚本的一个示例:

v1=hello
v2=world
v3="$v1       $v2"
echo $v3            # Output: hello world
echo "$v3"          # Output: hello       world

Answer 14

即使现在允许+ =运算符,它也已在2004年的Bash 3.1中引入.

在较旧的Bash版本上使用此运算符的任何脚本都将失败,如果您幸运的话,"找不到命令"错误,或者"意外令牌附近的语法错误".

对于那些关心向后兼容性的人,请坚持使用旧的标准Bash级联方法,如所选答案中提到的那些:

foo="Hello"
foo="$foo World"
echo $foo
> Hello World

Answer 15

默认情况下，Bash 中的变量和数组（索引或关联*）始终是字符串，但您可以使用内置标志declare，为它们提供“整数”( -i) 或“引用”** ( -n) 等属性，这会改变它们的方式表现。

Bash 算术接受 ASCII/字符串数字作为输入，因此几乎没有理由实际使用整数属性。

另外，变量值不能包含 ASCII NULL（即 8 位零），因为使用常规的空终止 C 字符串来实现它们。

* 即一个或多个键+值对。
** 引用变量扩展为另一个变量的值，该变量的标签被分配给引用变量

附加一个字符串：

$ foo=Hello
$ foo+=' world!'
$ echo "$foo"

Hello world!

$ num=3
$ num+=4
echo "$num"

34 # Appended string (not a sum)

使用整数属性的少数原因之一是它改变了赋值运算符的行为+=：

$ declare -i num=3
$ num+=4
echo "$num"

7 # Sum

请注意，这不适用于-=、等，除非您在算术 (和)/=内执行此操作，其中无论有或没有整数属性，数字都已被视为相同。有关这些运算符的完整列表，请参阅“算术评估”部分，这些运算符与 C 语言相同。(( ))$(( ))man bash

赋值运算符+=还可以用于将新元素附加到索引数组（也称为“列表”）：

$ foo=(one)
$ foo+=(two)
$ printf 'Separate element: %s\n' "${foo[@]}"

Separate element: one
Separate element: two

另一种常见的方法是使用计数器：

$ foo[c++]=one
$ foo[c++]=two

POSIX shell 不使用赋值+=运算符来附加字符串，因此您必须这样做：

$ foo=Hello
$ foo="$foo world!"
$ echo "$foo"

Hello world!

这在 Bash 中也很好，因此它可以被认为是一种更可移植的语法。

Answer 16

我更喜欢使用花括号${}来扩展字符串中的变量:

foo="Hello"
foo="${foo} World"
echo $foo
> Hello World

卷曲括号适合连续字符串使用:

foo="Hello"
foo="${foo}World"
echo $foo
> HelloWorld

否则使用foo = "$fooWorld"将无法正常工作.

Answer 17

如果您要做的是将字符串拆分为多行,则可以使用反斜杠:

$ a="hello\
> world"
$ echo $a
helloworld

中间有一个空格:

$ a="hello \
> world"
$ echo $a
hello world

这个也只增加了一个空格:

$ a="hello \
>      world"
$ echo $a
hello world

Answer 18

更安全的方式:

a="AAAAAAAAAAAA"
b="BBBBBBBBBBBB"
c="CCCCCCCCCCCC"
d="DD DD"
s="${a}${b}${c}${d}"
echo "$s"
AAAAAAAAAAAABBBBBBBBBBBBCCCCCCCCCCCCDD DD

包含空格的字符串可以成为命令的一部分,使用"$ XXX"和"$ {XXX}"来避免这些错误.

再看看关于+ =的其他答案

Answer 19

有一个特殊情况需要注意:

user=daniel
cat > output.file << EOF
"$user"san
EOF

会输出"daniel"san,而不是danielsan你可能想要的输出.在这种情况下,你应该做:

user=daniel
cat > output.file << EOF
${user}san
EOF

Answer 20

尽管有特殊运算符 ,+=用于连接，但还有一种更简单的方法：

foo='Hello'
foo=$foo' World'
echo $foo

双引号需要额外的计算时间来解释内部变量。如果可能，请避免它。

Answer 21

a="Hello,"
a=$a" World!"
echo $a

这是连接两个字符串的方式。

Answer 22

如果它是添加" World"到原始字符串的示例,那么它可以是:

#!/bin/bash

foo="Hello"
foo=$foo" World"
echo $foo

输出:

Hello World

Answer 23

var1='hello'
var2='world'
var3=$var1" "$var2 
echo $var3

Answer 24

有人对性能表示担忧，但没有提供数据。让我建议一个简单的测试。

（注意：date在 macOS 上不提供纳秒，所以这必须在 Linux 上完成。）

我在 GitHub 上创建了append_test.sh的内容：

#!/bin/bash -e

output(){
    ptime=$ctime;
    ctime=$(date +%s.%N);
    delta=$(bc <<<"$ctime - $ptime");
    printf "%2s. %16s chars  time: %s  delta: %s\n" $n "$(bc <<<"10*(2^$n)")" $ctime $delta;
}

method1(){
    echo 'Method: a="$a$a"'
    for n in {1..32}; do a="$a$a"; output; done
}

method2(){
    echo 'Method: a+="$a"'
    for n in {1..32}; do a+="$a";  output; done
}

ctime=0; a="0123456789"; time method$1

测试 1：

$ ./append_test.sh 1
Method: a="$a$a"
 1.               20 chars  time: 1513640431.861671143  delta: 1513640431.861671143
 2.               40 chars  time: 1513640431.865036344  delta: .003365201
 3.               80 chars  time: 1513640431.868200952  delta: .003164608
 4.              160 chars  time: 1513640431.871273553  delta: .003072601
 5.              320 chars  time: 1513640431.874358253  delta: .003084700
 6.              640 chars  time: 1513640431.877454625  delta: .003096372
 7.             1280 chars  time: 1513640431.880551786  delta: .003097161
 8.             2560 chars  time: 1513640431.883652169  delta: .003100383
 9.             5120 chars  time: 1513640431.886777451  delta: .003125282
10.            10240 chars  time: 1513640431.890066444  delta: .003288993
11.            20480 chars  time: 1513640431.893488326  delta: .003421882
12.            40960 chars  time: 1513640431.897273327  delta: .003785001
13.            81920 chars  time: 1513640431.901740563  delta: .004467236
14.           163840 chars  time: 1513640431.907592388  delta: .005851825
15.           327680 chars  time: 1513640431.916233664  delta: .008641276
16.           655360 chars  time: 1513640431.930577599  delta: .014343935
17.          1310720 chars  time: 1513640431.954343112  delta: .023765513
18.          2621440 chars  time: 1513640431.999438581  delta: .045095469
19.          5242880 chars  time: 1513640432.086792464  delta: .087353883
20.         10485760 chars  time: 1513640432.278492932  delta: .191700468
21.         20971520 chars  time: 1513640432.672274631  delta: .393781699
22.         41943040 chars  time: 1513640433.456406517  delta: .784131886
23.         83886080 chars  time: 1513640435.012385162  delta: 1.555978645
24.        167772160 chars  time: 1513640438.103865613  delta: 3.091480451
25.        335544320 chars  time: 1513640444.267009677  delta: 6.163144064
./append_test.sh: fork: Cannot allocate memory

测试 2：

$ ./append_test.sh 2
Method: a+="$a"
 1.               20 chars  time: 1513640473.460480052  delta: 1513640473.460480052
 2.               40 chars  time: 1513640473.463738638  delta: .003258586
 3.               80 chars  time: 1513640473.466868613  delta: .003129975
 4.              160 chars  time: 1513640473.469948300  delta: .003079687
 5.              320 chars  time: 1513640473.473001255  delta: .003052955
 6.              640 chars  time: 1513640473.476086165  delta: .003084910
 7.             1280 chars  time: 1513640473.479196664  delta: .003110499
 8.             2560 chars  time: 1513640473.482355769  delta: .003159105
 9.             5120 chars  time: 1513640473.485495401  delta: .003139632
10.            10240 chars  time: 1513640473.488655040  delta: .003159639
11.            20480 chars  time: 1513640473.491946159  delta: .003291119
12.            40960 chars  time: 1513640473.495354094  delta: .003407935
13.            81920 chars  time: 1513640473.499138230  delta: .003784136
14.           163840 chars  time: 1513640473.503646917  delta: .004508687
15.           327680 chars  time: 1513640473.509647651  delta: .006000734
16.           655360 chars  time: 1513640473.518517787  delta: .008870136
17.          1310720 chars  time: 1513640473.533228130  delta: .014710343
18.          2621440 chars  time: 1513640473.560111613  delta: .026883483
19.          5242880 chars  time: 1513640473.606959569  delta: .046847956
20.         10485760 chars  time: 1513640473.699051712  delta: .092092143
21.         20971520 chars  time: 1513640473.898097661  delta: .199045949
22.         41943040 chars  time: 1513640474.299620758  delta: .401523097
23.         83886080 chars  time: 1513640475.092311556  delta: .792690798
24.        167772160 chars  time: 1513640476.660698221  delta: 1.568386665
25.        335544320 chars  time: 1513640479.776806227  delta: 3.116108006
./append_test.sh: fork: Cannot allocate memory

错误表明我的 Bash在崩溃之前达到了335.54432 MB。您可以将代码从将数据加倍更改为附加常量以获得更细粒度的图形和故障点。但我认为这应该给你足够的信息来决定你是否关心。就个人而言，低于 100 MB 我没有。你的旅费可能会改变。

Answer 25

我想从列表中构建一个字符串。找不到答案，所以我把它贴在这里。这是我所做的：

list=(1 2 3 4 5)
string=''

for elm in "${list[@]}"; do
    string="${string} ${elm}"
done

echo ${string}

然后我得到以下输出：

1 2 3 4 5