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

Posted 2023-03-13

技术标签:

【中文标题】如何在 Bash 中连接字符串变量【英文标题】：How to concatenate string variables in Bash 【发布时间】：2011-05-10 01:31:33 【问题描述】：

在 php 中，字符串按如下方式连接在一起：

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

在这里，$foo 变为“Hello World”。

这是如何在 Bash 中完成的？

【问题讨论】：

foo="Hello" foo=$foo" World" echo $foo 这相当适用于“#!/bin/sh” 如果你想让HelloWorld没有空间怎么办？ @Adi foo1="World" foo2="Hello" foo3="$foo1$foo2" 空格在 bash 中很重要）举一个插入字符串的例子做echo "sh $HOME/ultimate-utils/run_tb.sh" 【参考方案1】：

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

请注意，这不适用于 -=、/= 等，除非您在算术（(( )) 和 $(( ))）中执行此操作，其中无论是否使用整数属性，数字都已被视为相同.有关这些运算符的完整列表，请参阅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 中也很好，所以它可以被认为是一种更便携的语法。

【讨论】：

【参考方案2】：

Bash 还支持+= 运算符，如下代码所示：

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

输出

X Y Z

【讨论】：

我可以将此语法与 export 关键字一起使用吗？例如export A+="Z" 或者 A 变量只需要导出一次？ @levesque：两者都有:-)。变量只需要导出一次，但export A+=Z 也可以很好地工作。由于这是一个 bashism，我认为值得一提的是，您不应该在使用这种结构的脚本中使用 #!/bin/sh。它是专门的并且只是一个加号运算符。也就是说，与 javascript 不同，在 Bash 中，echo $A+$B 打印“X Y+Z” bashism 是一种 shell 功能，仅在 bash 和某些其他更高级的 shell 中支持。它不适用于busybox sh 或dash（在很多发行版上是/bin/sh），或某些其他shell，如FreeBSD 上提供的/bin/sh。【参考方案3】：

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

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

双引号需要额外的计算时间来解释内部变量。尽量避免。

【讨论】：

【参考方案4】：

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

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

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

【讨论】：

第一个示例中是否必须有空格？是否可以做类似foo="$fooworld" 的事情？我假设不会... @nonsensickle 这将寻找一个名为 fooworld 的变量。使用大括号消除歧义，如foo="$fooworld"... @twalberg 我发现你也可以使用foo=$foo'world' @JVE999 是的，这也行得通，虽然在我看来它对代码的清晰度不太好……但这可能只是我的偏好……还有其他几种方法可以也应该这样做 - 重点是确保变量名与非变量名部分分开，以便正确解析。将整个内容放在双引号中的一个问题，就像foo="$foo World" 一样，如果附加字符串（在这种情况下为“world”）包含变量名，shell 将对其进行解释，等，这通常是不想要的。 IMO，常见情况需要语法$foo="$foo"' world'。【参考方案5】：

在我看来，连接两个字符串的最简单方法是编写一个函数，然后使用该函数。

function concat ()

    prefix=$1
    suffix=$2

    echo "$prefix$suffix"


foo="Super"
bar="man"

concat $foo $bar   # Superman

alien=$(concat $foo $bar)

echo $alien        # Superman

【讨论】：

【参考方案6】：

以下是大多数答案所讨论内容的简明摘要。

假设我们有两个变量，并且 $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 变量名称中的有效第一个字符（即字母或下划线）开头的字符串连接。

另见：

BashFAQ/013 - How can I concatenate two variables? When do we need curly braces around shell variables?

【讨论】：

如果您担心性能，请参阅我的回答中的分析***.com/a/47878161/117471【参考方案7】：

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

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

【讨论】：

这可行，但有时会产生不可预知的结果，因为变量插值不受保护。因此，您不能在所有用例中都依赖此表单。【参考方案8】：

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

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

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

echo $string

然后我得到以下输出：

1 2 3 4 5

【讨论】：

【参考方案9】：

先刷

由于这个问题专门针对Bash，我的第一部分答案将提出正确执行此操作的不同方法：

`+=`: 附加到变量

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

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

（因为我很节俭，我只会使用两个变量foo 和a，然后在整个答案中重复使用相同的变量。;-)

a=2
a+=4
echo $a
24

使用 堆栈溢出问题 语法，

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

嗯..this is not a bug, but a feature...为了防止 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 builtin 命令提供了一种绘制字符串格式的强大方法。由于这是一个 Bash builtin，因此可以选择将格式化字符串发送到变量而不是在 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!>

使用堆栈溢出问题语法：

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

格式化，使用 forked `printf`

如果你想使用更复杂的结构，你必须使用 fork（新的子进程，通过stdout 完成工作并返回结果）：

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

从历史上看，您可以使用 backticks 来检索 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

【讨论】：

在我的测试中，+= 运算符也比 $a="$a$b" 快得多。这是有道理的。这个答案很棒，但我认为它缺少其他答案中的var=$var.sh 示例，这非常有用。 bash 是唯一一个带有 += 运算符的 shell 吗？我想看看它是否足够便携 @dashesy 没有。我肯定不是唯一带有+= 运算符的shell，但所有这些方式都是bashisms，所以不可移植！如果 bash 版本错误，您甚至可能会遇到特殊错误！这是 IMO 的正确答案，因为我正在寻找没有空格的连接，而 += 就像一个魅力。【参考方案10】：

最简单的加引号的方式：

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

【讨论】：

引号太多，恕我直言。 var=$B$b"a"; echo Hello\ $var 会做，我相信我建议使用所有的引号，因为如果你把它放在你不能错过的地方，你不必考虑。【参考方案11】：

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

（注意：macOS 上的date 不提供纳秒，因此必须在 Linux 上完成。）

我创建了append_test.sh on GitHub，内容如下：

#!/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。您可以将 the code 从加倍数据更改为附加一个常量，以获得更精细的图表和故障点。但我认为这应该给你足够的信息来决定你是否关心。就个人而言，我不会低于 100 MB。您的里程可能会有所不同。

【讨论】：

有趣！考虑：

join &lt;(LANG=C bash -c 'a="a" c=1 last=$EPOCHREALTIME//.;while :;do a+=$a;now=$EPOCHREALTIME//.;echo $((c++)) $#a $((now-last));last=$now;done') &lt;(LANG=C bash -c 'a="a" c=1 last=$EPOCHREALTIME//.;while :;do a=$a$a;now=$EPOCHREALTIME//.;echo $((c++)) $#a $((now-last));last=$now;done')|sed -ue '1icnt strlen a+=$a a=$a$a' -e 's/^\([0-9]\+\) \([0-9]\+\) \([0-9]\+\) \2/\1 \2 \3/' | xargs printf "%4s %11s %9s %9s\n"

（在不高效的主机上试试这个！！;）【参考方案12】：

bla=hello
laber=kthx
echo "$blaohai$laberbye"

会输出

helloohaikthxbye

这在以下情况下很有用 $blaohai 导致未找到变量错误。或者，如果您的字符串中有空格或其他特殊字符。 "$foo" 正确地转义了您放入其中的任何内容。

【讨论】：

不起作用。我从 bash 得到“backupstorefolder：找不到命令”，其中“backupstorefolder”是变量的名称。这有助于语法高亮，并消除一些人为的歧义。【参考方案13】：

我更喜欢使用大括号$ 来扩展字符串中的变量：

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

花括号将适合连续字符串用法：

foo="Hello"
foo="$fooWorld"
echo $foo
> HelloWorld

否则使用foo = "$fooWorld" 将不起作用。

【讨论】：

【参考方案14】：

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

【讨论】：

同样var3=$var1\ $var2也有同样的效果【参考方案15】：

如果要附加下划线之类的内容，请使用转义符 (\)

FILEPATH=/opt/myfile

这不起作用：

echo $FILEPATH_$DATEX

这很好用：

echo $FILEPATH\\_$DATEX

【讨论】：

或者，$FILEPATH_$DATEX。这里用来表示变量名的边界。这是适当的，因为下划线是变量名中的合法字符，因此在您的 sn-p bash 中实际上尝试解析 FILEPATH_，而不仅仅是 $FILEPATH 对我来说，我有一个变量，即 $var1 和旁边的常量，所以 echo $var1_costant_traling_part 对我有用我想一个人只需要一次反弹就可以逃脱：echo $a\_$b 可以。正如 Nik O'Lai 的评论所暗示的，下划线是一个常规字符。空格的处理对字符串、回显和连接更为敏感——可以使用\ 并在此问题不时出现时彻底阅读此线程。【参考方案16】：

我解决问题的方法就是

$a$b

例如，

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

产生

Hello World

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

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

然后echo "$c" 将产生

Hello World

有一个额外的空间。

$aWorld

正如您想象的那样，它不起作用，但是

$aWorld

生产

HelloWorld

【讨论】：

...因此$a\ World 产生Hello World 这让我很吃惊；我本来希望c=$a$b 在这里做与c=$a World 相同的事情（它会尝试将World 作为命令运行）。我猜这意味着在扩展变量之前解析分配..【参考方案17】：

有一种特殊情况需要注意：

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

将输出"daniel"san，而不是您可能想要的danielsan。在这种情况下，您应该这样做：

user=daniel
cat > output.file << EOF
$usersan
EOF

【讨论】：

【参考方案18】：

如果是作为你在原始字符串中添加" World"的例子，那么它可以是：

#!/bin/bash

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

输出：

Hello World

【讨论】：

【参考方案19】：

即使现在允许使用 += 运算符，它也已于 2004 年在 Bash 3.1 中引入。

如果幸运的话，在旧 Bash 版本上使用此运算符的任何脚本都会失败，并出现“找不到命令”错误，或者出现“意外令牌附近的语法错误”。

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

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

【讨论】：

感谢您指出这一点，我只是在寻找它需要哪个版本才能工作。【参考方案20】：

这里是AWK：

$ foo="Hello"
$ foo=$(awk -v var=$foo 'BEGINprint var" World"')
$ echo $foo
Hello World

【讨论】：

很好，但我认为我可以通过使用 Python 获得更高的精度！【参考方案21】：

您可以在不使用引号的情况下进行连接。这是一个例子：

$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

【讨论】：

第一个块的语法令人困惑。这些 $ 符号是什么意思？【参考方案22】：

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

【讨论】：

这是对 shell 脚本最有用的答案。我在最后 30 分钟找到了自己，因为等号前后都有一个空格！！ foo="$foo世界" @XXL 当然我宁愿使用方括号来封装 var 的名称。强烈推荐【参考方案23】：

我有点喜欢做一个快速函数。

#! /bin/sh -f
function combo() 
    echo $@


echo $(combo 'foo''bar')

另一种给猫剥皮的方法。这次是函数：D

【讨论】：

在子shell中调用一个函数对于简单的concat来说太过分了。【参考方案24】：

更安全的方式：

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

包含空格的字符串可以成为命令的一部分，使用“$XXX”和“$XXX”来避免这些错误。

另外看看关于 +=

的其他答案

【讨论】：

作为命令读取的带有空格的字符串点显示在定义点。所以d=DD DD 会给出DD: command not found --- 请注意，这是最后一个 DD，而不是未找到的 d。如果所有操作数都已正确格式化并且已经包含所需的空格，则可以简单地与 s=$a$b$c$d; echo $s 连接，使用较少的引号。您也可以使用\ （转义空格）来避免这些问题——d=echo\ echo 不会启动任何回显调用，而d=echo echo 会。【参考方案25】：

方便时我会这样做：使用内联命令！

echo "The current time is `date`"
echo "Current User: `echo $USER`"

【讨论】：

在第一行，您可以使用 date "+The current time is %a %b %d %Y +%T" 而不是 echo ...$(date) 来删除 fork。在最近的 bash 下，你可以写：printf "The current time is %(%a %b %d %Y +%T)T\n" -1 .【参考方案26】：

请注意，这不起作用

foo=HELLO
bar=WORLD
foobar=PREFIX_$foo_$bar

因为它似乎放弃了 $foo 并给你留下：

PREFIX_WORLD

但这会起作用：

foobar=PREFIX_"$foo"_"$bar"

并为您提供正确的输出：

PREFIX_HELLO_WORLD

【讨论】：

发生这种情况是因为下划线是变量名中的有效字符，因此 bash 将 foo_ 视为变量。当需要告诉 bash 确切的 var 名称边界时，可以使用花括号：PREFIX_$foo_$bar【参考方案27】：

另一种方法...

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

...还有一个。

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

【讨论】：

这就是我所做的，我发现它比其他答案简单直接。投票最多的答案中没有人指出这个选项是有原因的吗？ @quimnuss 字符串与 OP 问题中使用的字符串不匹配的事实可能是一个很好的理由。【参考方案28】：

如果你想要做的是将一个字符串拆分成几行，你可以使用反斜杠：

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

中间有一个空格：

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

这个也只加了一个空格：

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

【讨论】：

恐怕不是这个意思【参考方案29】：

你也可以这样做：

$ var="myscript"

$ echo $var

myscript


$ var=$var.sh

$ echo $var

myscript.sh

【讨论】：

虽然没有使用特殊字符，也没有使用空格，但双引号、引号和大括号是无用的：var=myscript;var=$var.sh;echo $var 会产生相同的效果（这在 bash、dash、busybox 等下工作）。跨度> @F.Hauri 感谢您指出这一点。但是如果你要附加一个数字，它就行不通了：例如echo $var2 不会产生 myscript2 @Pynchia 这项工作是因为变量名中的点 . 非法。否则echo $var2 或见my answer【参考方案30】：

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

【讨论】：

以上是关于如何在 Bash 中连接字符串变量的主要内容，如果未能解决你的问题，请参考以下文章

一个bash脚本，用于使用bash脚本连接字符串并在同一文件中编辑一行

如何在 PowerShell 中连接字符串和变量？

Shell编程Bash变量-用户自定义变量

Shell编程Shell中Bash变量-用户自定义变量

bash 字符串连接中的多余空间

bash变量

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

先刷

+=: 附加到变量

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

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

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

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

使用 堆栈溢出问题 语法：

现在壳

基本上

格式化，使用 forked printf

`+=`: 附加到变量

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

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

追加到数组`var+=(...)`

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

使用堆栈溢出问题语法：

格式化，使用 forked `printf`