PHPでは、文字列は次のように連結されます。

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

こちら$fooは「ハローワールド」になります。

これはBashでどのように達成されますか？

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

一般に、2つの変数を連結するには、次々にそれらを書き込むだけです。

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

+=次のコードに示すように、bashは演算子もサポートしています。

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

最初にバッシュ

この質問は特にBashを表しているので、私の回答の最初の部分では、これを適切に行うためのさまざまな方法を示します。

+=：変数に追加

構文+=はさまざまな方法で使用できます。

文字列に追加 var+=...

（私は質素なので、私は2つの変数のみを使用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も1つだけの要素の配列です。

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!

この配列には7つの文字列があります。したがって、正確に7つの位置引数を含むフォーマットされた文字列を作成できます。

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

または、送信された引数の数だけ繰り返される1つの引数フォーマット文字列を使用できます...

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では、インデックスを指定せずに変数名にアクセスすると、常に最初の要素のみがアドレス指定されます。

したがって、7つのフィールド配列を取得するには、最初の要素を再設定するだけです。

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!")'

多くの引数が渡される1つの引数フォーマット文字列：

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シェル、あなたが使用することができませんでしbashismsを、そう何もありません組み込みが printf。

基本的に

しかし、あなたは単に行うことができます：

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

フォーマット済み、forkedを使用 printf

より洗練された構造を使用したい場合は、フォーク（ジョブを作成して結果を返す新しい子プロセス）を使用する必要がありますstdout。

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

歴史的には、フォークの結果を取得するためにバックティックを使用できます。

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

あなたもこれを行うことができます：

$ var="myscript"

$ echo $var

myscript


$ var=${var}.sh

$ echo $var

myscript.sh

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

出力されます

helloohaikthxbye

これは$blaohai 、変数が見つからないというエラーが発生する場合に役立ち ます。または、文字列にスペースやその他の特殊文字が含まれている場合。"${foo}"あなたがそれに入れたものを適切にエスケープします。

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

私が問題を解決する方法はただです

$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

以下は、ほとんどの回答が話していることの簡潔な要約です。

2つの変数があり、$ 1が「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で見られるように{}、変数がシェル変数名の有効な最初の文字である文字、つまりアルファベットまたはアンダースコアで始まる文字列と連結されていない限り、必要はありません。

以下も参照してください。

• BashFAQ / 013-2つの変数を連結するにはどうすればよいですか？
• シェル変数を中括弧で囲む必要があるのはいつですか？

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

さらに別のアプローチ...

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

...そしてさらにもう1つ。

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

アンダースコアなどを追加する場合は、エスケープ（\）を使用します

FILEPATH=/opt/myfile

これは機能しません：

echo $FILEPATH_$DATEX

これはうまくいきます：

echo $FILEPATH\\_$DATEX

引用符を使用する最も簡単な方法：

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

引用符なしで連結できます。次に例を示します。

$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

+ =演算子が現在許可されている場合でも、2004年にBash 3.1で導入されました。

以前のBashバージョンでこの演算子を使用するスクリプトは、運が良ければ「コマンドが見つかりません」エラー、または「予期しないトークンに近い構文エラー」で失敗します。

下位互換性を重視する場合は、選択した回答で言及されているような、古い標準のBash連結メソッドを使用してください。

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

私${}は文字列内の変数を展開するために中括弧を使用することを好みます：

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

中括弧は連続文字列の使用に適合します：

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

それ以外の場合は使用foo = "$fooWorld"できません。

文字列を複数の行に分割する場合は、バックスラッシュを使用できます。

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

間にスペースが1つある場合：

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

これも、間にスペースを1つだけ追加します。

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

より安全な方法：

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

スペースを含む文字列はコマンドの一部になる可能性があります。これらのエラーを回避するには、「$ XXX」および「$ {XXX}」を使用してください。

プラス+ =について他の回答を見てください

注意が必要な特定のケースが1つあります。

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

あなたが望んだかもしれ"daniel"sanないようにdanielsan、ではなく、出力します。この場合、代わりに行う必要があります。

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

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

これは、2つの文字列を連結する方法です。

" World"元の文字列に追加する例の場合、次のようになります。

#!/bin/bash

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

出力：

Hello World

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

パフォーマンスについては懸念事項がありますが、データは提供されていません。簡単なテストを提案させてください。

（注：datemacOSではナノ秒を提供しないため、これは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を取得したことを示しています。データを2倍にすることから定数を追加することまでコードを変更して、より詳細なグラフと障害点を取得できます。しかし、これはあなたが気にするかどうかを決定するのに十分な情報をあなたに与えるべきだと思います。個人的には、100 MB未満ではありません。あなたのマイレージは異なる場合があります。

リストから文字列を作成したかった。その答えが見つからなかったので、ここに投稿します。これが私がしたことです：

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

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

echo ${string}

そして、私は次の出力を取得します：

1 2 3 4 5

特別な演算子にもかかわらず、+=連結のために、より簡単な方法があります：

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

二重引用符は、内部の変数の解釈に余分な計算時間がかかります。可能であれば避けてください。

これは機能しないことに注意してください

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

$ fooをドロップして、次のように残しているようです：

PREFIX_WORLD

しかしこれはうまくいきます：

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

そして正しい出力をあなたに残してください：

PREFIX_HELLO_WORLD

これがAWKを介したものです。

$ foo="Hello"
$ foo=$(awk -v var=$foo 'BEGIN{print var" World"}')
$ echo $foo
Hello World

都合の良いときにこのようにしています：インラインコマンドを使用してください！

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

私の意見では、2つの文字列を連結する最も簡単な方法は、それを行う関数を記述してから、その関数を使用することです。

function concat ()
{
    prefix=$1
    suffix=$2

    echo "${prefix}${suffix}"
}

foo="Super"
bar="man"

concat $foo $bar   # Superman

alien=$(concat $foo $bar)

echo $alien        # Superman

ちょっと関数を作ってみたいです。

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

echo $(combo 'foo''bar')

猫の皮をむくためのさらに別の方法。今回は機能付き：D

PHPについてはまだ知りませんが、これはLinux Bashで動作します。変数に影響を与えたくない場合は、これを試すことができます。

read pp;  *# Assumes I will affect Hello to pp*
pp=$( printf $pp ;printf ' World'; printf '!');
echo $pp;

>Hello World!

「Hello」や「！」の代わりに別の変数を配置することもできます。より多くの文字列を連結することもできます。