在 PHP 中，字符串按如下方式连接在一起：
$foo = "Hello";
$foo .= " World";
在这里，$foo变成了“Hello World”。
这是如何在 Bash 中完成的？
问问题
4382494 次
30 回答
4389
foo="Hello"
foo="${foo} World"
echo "${foo}"
> Hello World
通常，要连接两个变量，您可以一个接一个地编写它们：
a='Hello'
b='World'
c="${a} ${b}"
echo "${c}"
> Hello World
于 2010-11-15T05:41:36.770 回答
1269
Bash 还支持+=如下代码所示的运算符：
A="X Y"
A+=" Z"
echo "$A"
输出
XYZ
于 2010-11-15T08:33:24.583 回答
1043
先猛击
由于这个问题专门针对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
嗯..这不是一个错误，而是一个功能......为了防止 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: 使用内置命令重新构造变量
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
注意：使用双引号可能有助于处理包含spaces,tabulations和/或newlines
printf -v foo "%s World" "$foo"
现在壳
在POSIX shell 下，你不能使用bashisms，所以没有builtin 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
于 2013-08-04T10:04:37.863 回答
138
你也可以这样做：
$ var="myscript"
$ echo $var
myscript
$ var=${var}.sh
$ echo $var
myscript.sh
于 2011-10-28T03:09:38.833 回答
126
bla=hello
laber=kthx
echo "${bla}ohai${laber}bye"
将输出
helloohaikthxbye
$blaohai
这在导致未找到变量错误时很有用
。或者，如果您的字符串中有空格或其他特殊字符。"${foo}"正确逃脱您放入其中的任何内容。
于 2013-07-25T15:48:20.060 回答
50
foo="Hello "
foo="$foo World"
于 2010-11-15T05:44:10.817 回答
39
这是大多数答案所谈论内容的简明摘要。
假设我们有两个变量，并且 $1 设置为“一个”：
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 行）。如第 3 行和第 4 行所示，{}除非将变量与以 shell 变量名称中的有效第一个字符（即字母或下划线）开头的字符串连接，否则不需要。
也可以看看：
于 2017-12-06T04:04:34.083 回答
35
我解决问题的方法就是
$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
于 2014-03-07T16:43:07.200 回答
32
$ a=hip
$ b=hop
$ ab=$a$b
$ echo $ab
hiphop
$ echo $a$b
hiphop
于 2010-11-15T05:42:09.320 回答
20
还有一种方法...
> H="Hello "
> U="$H""universe."
> echo $U
Hello universe.
……还有一个。
> H="Hello "
> U=$H"universe."
> echo $U
Hello universe.
于 2013-03-18T08:24:46.480 回答
19
如果要附加下划线之类的内容，请使用转义符 (\)
FILEPATH=/opt/myfile
这不起作用：
echo $FILEPATH_$DATEX
这工作正常：
echo $FILEPATH\\_$DATEX
于 2013-09-20T19:15:27.370 回答
16
最简单的带引号的方法：
B=Bar
b=bar
var="$B""$b""a"
echo "Hello ""$var"
于 2016-12-21T15:23:16.280 回答
15
即使现在允许使用 += 运算符，它也已于2004 年在Bash 3.1中引入。
如果幸运的话，在旧 Bash 版本上使用此运算符的任何脚本都会失败，并出现“找不到命令”错误，或者出现“意外令牌附近的语法错误”。
对于那些关心向后兼容性的人，请坚持使用较旧的标准 Bash 连接方法，例如所选答案中提到的方法：
foo="Hello"
foo="$foo World"
echo $foo
> Hello World
于 2014-11-04T19:57:34.607 回答
14
您可以在没有引号的情况下连接。这是一个例子：
$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
于 2010-11-15T07:40:15.563 回答
14
我更喜欢使用大括号${}来扩展字符串中的变量：
foo="Hello"
foo="${foo} World"
echo $foo
> Hello World
花括号将适合连续字符串用法：
foo="Hello"
foo="${foo}World"
echo $foo
> HelloWorld
否则使用foo = "$fooWorld"将不起作用。
于 2017-06-14T05:35:20.803 回答
8
如果您要尝试将字符串拆分为多行，则可以使用反斜杠：
$ a="hello\
> world"
$ echo $a
helloworld
中间有一个空格：
$ a="hello \
> world"
$ echo $a
hello world
这一个也只在两者之间添加了一个空格：
$ a="hello \
> world"
$ echo $a
hello world
于 2012-04-03T23:22:10.990 回答
8
尽管有特殊运算符 ,+=用于连接，还有一种更简单的方法：
foo='Hello'
foo=$foo' World'
echo $foo
双引号需要额外的计算时间来解释内部变量。尽可能避免它。
于 2019-09-18T06:28:18.270 回答
7
更安全的方式：
a="AAAAAAAAAAAA"
b="BBBBBBBBBBBB"
c="CCCCCCCCCCCC"
d="DD DD"
s="${a}${b}${c}${d}"
echo "$s"
AAAAAAAAAAAABBBBBBBBBBBBCCCCCCCCCCCCDD DD
包含空格的字符串可以成为命令的一部分，使用“$XXX”和“${XXX}”来避免这些错误。
另外看看关于+=的其他答案
于 2014-02-26T23:39:04.497 回答
7
有一种特殊情况需要注意：
user=daniel
cat > output.file << EOF
"$user"san
EOF
将输出"daniel"san, 而不是danielsan, 如您所愿。在这种情况下，您应该改为：
user=daniel
cat > output.file << EOF
${user}san
EOF
于 2015-10-28T17:35:47.760 回答
6
a="Hello,"
a=$a" World!"
echo $a
这就是连接两个字符串的方式。
于 2019-03-05T19:35:35.990 回答
5
如果它是作为添加" World"到原始字符串的示例，那么它可以是：
#!/bin/bash
foo="Hello"
foo=$foo" World"
echo $foo
输出：
Hello World
于 2015-04-24T05:07:45.297 回答
5
var1='hello'
var2='world'
var3=$var1" "$var2
echo $var3
于 2017-02-07T08:50:05.217 回答
5
有人对性能表示担忧，但没有提供数据。让我建议一个简单的测试。
（注意：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。你的旅费可能会改变。
于 2017-12-18T23:56:05.463 回答
5
我想从列表中构建一个字符串。找不到答案，所以我把它贴在这里。这是我所做的：
list=(1 2 3 4 5)
string=''
for elm in "${list[@]}"; do
string="${string} ${elm}"
done
echo ${string}
然后我得到以下输出：
1 2 3 4 5
于 2018-10-21T10:06:41.923 回答
3
请注意，这不起作用
foo=HELLO
bar=WORLD
foobar=PREFIX_$foo_$bar
因为它似乎放弃了 $foo 并给你留下：
PREFIX_WORLD
但这会起作用：
foobar=PREFIX_"$foo"_"$bar"
并为您提供正确的输出：
PREFIX_HELLO_WORLD
于 2013-12-30T20:23:04.140 回答
2
这是通过AWK的一个：
$ foo="Hello"
$ foo=$(awk -v var=$foo 'BEGIN{print var" World"}')
$ echo $foo
Hello World
于 2014-08-24T11:09:58.730 回答
2
bash 中的变量和数组（索引或关联*）在默认情况下始终是字符串，但您可以使用declare内置函数的标志，为它们赋予“整数”（-i）或“引用”**（-n）等属性，从而改变它们的方式表现。
Bash 算法接受 ASCII/字符串数字作为输入，因此没有什么理由实际使用整数属性。
此外，变量值不能包含 ASCII NULL（即 8 位零），因为使用常规的以 null 结尾的 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
请注意，这不适用于-=,/=等，除非您在算术 ( (( ))and $(( ))) 中执行此操作，其中无论是否使用 integer 属性，数字都已被视为相同。有关这些运算符的完整列表，请参阅“算术评估”部分man bash，这些运算符与 C 相同。
+=赋值运算符还可用于将新元素附加到索引数组（又名“列表”）：
$ 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，所以它可以被认为是一种更便携的语法。
于 2021-06-10T12:16:54.763 回答
1
方便时我会这样做：使用内联命令！
echo "The current time is `date`"
echo "Current User: `echo $USER`"
于 2014-01-10T00:26:34.097 回答
0
In my opinion, the simplest way to concatenate two strings is to write a function that does it for you, then use that function.
function concat ()
{
prefix=$1
suffix=$2
echo "${prefix}${suffix}"
}
foo="Super"
bar="man"
concat $foo $bar # Superman
alien=$(concat $foo $bar)
echo $alien # Superman
于 2019-07-09T04:08:53.557 回答
-1
我有点喜欢做一个快速的功能。
#! /bin/sh -f
function combo() {
echo $@
}
echo $(combo 'foo''bar')
给猫剥皮的另一种方法。这次有功能：D
于 2014-09-08T07:44:57.203 回答