ใน PHP สตริงจะถูกรวมเข้าด้วยกันดังนี้:

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

ที่นี่$fooกลายเป็น "Hello World"

สิ่งนี้สำเร็จได้อย่างไรใน Bash

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

โดยทั่วไปแล้วการรวมสองตัวแปรเข้าด้วยกันคุณสามารถเขียนมันทีละตัว:

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

Bash ยังรองรับ+=โอเปอเรเตอร์ดังที่แสดงในรหัสนี้:

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

ทุบตีก่อน

เมื่อคำถามนี้ตรงกับ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

อืม .. นี่ไม่ใช่ข้อผิดพลาด แต่เป็นคุณสมบัติ ... เพื่อป้องกันการทุบตีเพื่อพยายามพัฒนา!"คุณสามารถ:

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 เมื่อคุณเข้าถึงชื่อตัวแปรโดยไม่ระบุดัชนีคุณจะต้องพิจารณาองค์ประกอบแรกเท่านั้น!

ดังนั้นในการเรียกข้อมูลอาเรย์เจ็ดของเราเราจำเป็นต้องตั้งค่าองค์ประกอบที่ 1 อีกครั้ง:

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เปลือกคุณไม่สามารถใช้bashismsดังนั้นไม่มีbuiltin printf

เป็นพื้น

แต่คุณสามารถทำได้:

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

จัดรูปแบบโดยใช้ทางแยก printf

หากคุณต้องการใช้สิ่งปลูกสร้างที่ซับซ้อนมากขึ้นคุณต้องใช้ทางแยก (กระบวนการลูกใหม่ที่ทำให้งานและส่งคืนผลลัพธ์ผ่าน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

ด้วย backticks คุณต้องหลบหนีจากส้อมด้านในด้วยแบ็กสแลช :

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

นี่เป็นบทสรุปโดยสังเขปของสิ่งที่คำตอบส่วนใหญ่พูดถึง

สมมติว่าเรามีสองตัวแปรและ $ 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 - ฉันจะเชื่อมสองตัวแปรเข้าด้วยกันได้อย่างไร
• เมื่อไหร่ที่เราต้องการเครื่องมือจัดฟันแบบโค้งรอบ ๆ ตัวแปรเชลล์

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

อีกวิธีหนึ่ง ...

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

... และยังเป็นอีกหนึ่ง

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

หากคุณต้องการผนวกสิ่งที่ขีดเส้นใต้ให้ใช้ escape (\)

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

แม้ว่าตอนนี้จะอนุญาตให้ใช้เครื่องหมาย + = ได้ถูกนำมาใช้ในBash 3.1ในปี 2004

สคริปต์ใด ๆ ที่ใช้ตัวดำเนินการนี้ในเวอร์ชัน 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

ด้วยหนึ่งช่องว่างระหว่าง:

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

อันนี้ยังเพิ่มเพียงหนึ่งช่องว่างในระหว่าง:

$ 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}" เพื่อหลีกเลี่ยงข้อผิดพลาดเหล่านี้

ลองดูคำตอบอื่น ๆ เกี่ยวกับ+ =

มีกรณีหนึ่งที่คุณควรระวัง:

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

นี่คือวิธีที่คุณเชื่อมโยงสองสายเข้าด้วยกัน

ถ้ามันเป็นตัวอย่างของคุณในการเพิ่ม" World"สตริงเดิมก็สามารถ:

#!/bin/bash

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

ผลลัพธ์:

Hello World

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

มีข้อกังวลเกี่ยวกับประสิทธิภาพ แต่ไม่มีการเสนอข้อมูล ฉันขอแนะนำการทดสอบอย่างง่าย

(หมายเหตุ: dateบน macOS ไม่มีนาโนวินาทีดังนั้นจะต้องทำบน Linux)

ฉันได้สร้างappend_test.sh บน 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ก่อนที่จะเกิดปัญหา คุณสามารถเปลี่ยนรหัสจากการเพิ่มข้อมูลเป็นสองเท่าเพื่อผนวกค่าคงที่เพื่อให้ได้กราฟที่ละเอียดยิ่งขึ้นและจุดความล้มเหลว แต่ฉันคิดว่านี่ควรให้ข้อมูลที่เพียงพอแก่คุณในการตัดสินใจว่าคุณใส่ใจหรือไม่ ส่วนตัวต่ำกว่า 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

ฉันทำแบบนี้เมื่อสะดวก: ใช้คำสั่ง inline!

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

ในความคิดของฉันวิธีที่ง่ายที่สุดในการเชื่อมสองสายคือการเขียนฟังก์ชั่นที่เหมาะกับคุณแล้วใช้ฟังก์ชั่นนั้น

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' หรือ '!' คุณสามารถต่อสตริงเข้าด้วยกันได้เช่นกัน