Bash obsługuje również operator +=, Jak pokazano w tym kodzie:

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

Wyjście

X Y Z

Bash first

+=: Dołącz do zmiennej

Składnia += może być stosowany na różne sposoby:

Append to string var+=...

(ponieważ jestem oszczędny, użyję tylko dwóch zmiennych foo i a, a następnie ponownie użyję tego samego w całej odpowiedzi. ;-)

a=2
a+=4
echo $a
24

Za pomocą pytanie o przepełnienie stosu składnia,

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

Dołącz do liczby całkowitej ((var+=...))

Zmienna a jest ciągiem znaków, ale także liczbą całkowitą

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

Dołączenie do tablicy var+=(...)

Nasz a jest również tablicą tylko jednego elementu.

echo ${a[@]}
36

a+=(18)

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

Zauważ, że pomiędzy nawiasami znajduje się oddzielona spacją tablica. Jeśli chcesz zapisać łańcuch zawierający spacje w tablicy, musisz załączyć oni:

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

Hmm.. to nie jest błąd, ale funkcja ... Aby zapobiec próbom rozwoju Basha, możesz:]}

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: Re-construct zmienna za pomocą builtin polecenie

The printf wbudowane polecenie daje potężny sposób rysowania formatu ciągu znaków. Ponieważ jest to Bash wbudowany , istnieje opcja wysyłania sformatowanego ciągu znaków do zmiennej zamiast drukowania na stdout:

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

Jest siedem ciągi w tej tablicy. Możemy więc zbudować sformatowany łańcuch zawierający dokładnie siedem argumentów pozycyjnych: {]}

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

Lub możemy użyć jednego argumentu w formacie string , który będzie powtarzany w ilości przesłanych argumentów...

Zauważ, że nasza a nadal jest tablicą! Zmienia się tylko pierwszy element!

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

W bash, gdy uzyskujesz dostęp do nazwy zmiennej bez podania indeksu, zawsze adresujesz tylko pierwszy element!

Aby odzyskać nasze siedem field array, musimy tylko ponownie ustawić 1st element:

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

Jeden argument formatuje ciąg znaków z wieloma argumentami przekazanymi do:

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

Użycie pytania przepełnienie stosu składnia:

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

Nota: użycie podwójnych cudzysłowów może być przydatne do manipulowania łańcuchami zawierającymi spaces, tabulations i / lub newlines

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

Shell now

Pod POSIX shell, nie można używać bashisms , więc nie ma wbudowanego printf.

W zasadzie

Ale można po prostu zrobić:

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

Sformatowany, za pomocą rozwidlony printf

Jeśli chcesz użyć bardziej wyrafinowanych konstrukcji, musisz użyć fork (nowy proces potomny, który wykonuje zadanie i zwraca wynik poprzez stdout):

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

Historycznie, można użyć backticks do pobierania wyniku widelca :

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

Ale to nie jest łatwe dla zagnieżdżenie:

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

Z backticks, musisz uciec wewnętrzne widelce z backslashes :

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

Ty też możesz to zrobić:

$ var="myscript"

$ echo $var

myscript


$ var=${var}.sh

$ echo $var

myscript.sh

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

Wyświetli

helloohaikthxbye

Jest to przydatne, gdy $blaohai prowadzi do błędu zmiennej not found. Lub jeśli masz spacje lub inne znaki specjalne w ciągach. / Align = "left" /

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

Oto zwięzłe podsumowanie tego, o czym mówi większość odpowiedzi.

Powiedzmy, że mamy dwie zmienne i $1 jest ustawione na 'one':

set one two
a=hello
b=world

Poniższa tabela wyjaśnia różne konteksty, w których możemy połączyć wartości a i b, aby utworzyć nową zmienną, 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

Kilka uwag:

• umieszczenie RHS przypisania w cudzysłowach jest ogólnie dobrą praktyką, choć w wielu przypadkach jest całkiem opcjonalne
• += jest lepszy od w przypadku, gdy ciąg jest konstruowany w małych krokach, szczególnie w pętli
• użyj {} wokół nazw zmiennych, aby rozdzielić ich ekspansję (jak w wierszu 2 w tabeli powyżej). Jak widać w wierszach 3 i 4, nie ma potrzeby stosowania {}, chyba że zmienna jest łączona z łańcuchem rozpoczynającym się znakiem, który jest prawidłowym pierwszym znakiem w nazwie zmiennej powłoki, czyli alfabetem lub podkreśleniem.

Zobacz także:

• BashFAQ / 013-jak Mogę połączyć dwie zmienne?
• Kiedy potrzebujemy kręconych szelek wokół zmiennych powłoki?

The way I ' d solve the problem is just

$a$b

Na przykład,

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

Który wytwarza

Hello World

Jeśli spróbujesz połączyć łańcuch z innym łańcuchem, na przykład,

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

Wtedy echo "$c" wyprodukuje

Hello World

Z dodatkową przestrzenią.

$aWorld

Nie działa, jak możesz sobie wyobrazić, ale

${a}World

Produkuje

HelloWorld

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

Jeszcze jedno podejście...

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

...i jeszcze jeden.

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

Jeśli chcesz dodać coś w rodzaju podkreślenia, użyj escape (\)

FILEPATH=/opt/myfile

To działa a nie :

echo $FILEPATH_$DATEX

To działa dobrze:

echo $FILEPATH\\_$DATEX

Najprostszy sposób ze znakami cudzysłowu:

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

Możesz konkatenować bez cudzysłowów. Oto przykład:

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

To ostatnie polecenie wypisuje "OpenSystems" (bez cudzysłowów).

To jest przykład skryptu Bash:

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

Nawet jeśli operator + = jest teraz dozwolony, został wprowadzony w Bash 3.1 w 2004 roku.

Każdy skrypt korzystający z tego operatora w starszych wersjach Bash zawiedzie z błędem "command not found", jeśli masz szczęście lub "błąd składni w pobliżu nieoczekiwanego tokena".

Dla tych, którzy dbają o kompatybilność wsteczną, trzymaj się starszych standardowych metod konkatenacji Bash, takich jak te wymienione w wybranej odpowiedzi:

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

Wolę używać nawiasów klamrowych ${} do rozszerzania zmiennej w łańcuchu:

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

Nawiasy klamrowe będą pasowały do ciągów ciągłych:

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

W przeciwnym razie użycie foo = "$fooWorld" nie zadziała.

Jeśli próbujesz podzielić łańcuch znaków na kilka linii, możesz użyć odwrotnego ukośnika:

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

Z jedną spacją pomiędzy:

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

Ten dodaje również tylko jedną spację pomiędzy:

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

Bezpieczniejszy sposób:

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

Łańcuchy zawierające spacje mogą stać się częścią polecenia, użyj "$ XXX " i " ${XXX}", aby uniknąć tych błędów.

Plus spójrz na inne odpowiedzi na temat +=

Jest jeden szczególny przypadek, w którym należy zadbać:

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

Wyświetli "daniel"san, a nie danielsan, Jak mogłeś chcieć. W tym przypadku powinieneś zrobić zamiast tego:

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

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

W ten sposób łączy się dwa ciągi.

Pomimo specjalnego operatora, +=, dla konkatenacji istnieje prostszy sposób:

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

Podwójne cudzysłowy wymagają dodatkowego czasu obliczeniowego na interpretację zmiennych wewnątrz. Unikaj tego, jeśli to możliwe.

Jeśli jest to przykład dodania " World" do oryginalnego ciągu znaków, to może być:

#!/bin/bash

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

Wyjście:

Hello World

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

Istnieją wyrażone obawy dotyczące wydajności, ale żadne dane nie są oferowane. Zaproponuję prosty test.

(Uwaga: date na macOS nie oferuje nanosekund, więc musi to być zrobione na Linuksie.)

Stworzyłem append_test.sh na Githubie z zawartością:

#!/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

Test 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

Test 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

Błędy wskazują, że mój Bash dostał się do 335.54432 MB zanim się rozbił. Możesz zmienić kod z podwojenia danych aby dodać stałą, aby uzyskać bardziej ziarnisty wykres i punkt awarii. Ale myślę, że to powinno dać ci wystarczająco dużo informacji, aby zdecydować, czy ci zależy. Osobiście poniżej 100 MB nie mam. przebieg może się różnić.

Chciałem zbudować ciąg znaków z listy. Nie mogłem znaleźć na to odpowiedzi, więc zamieszczam ją tutaj. Oto co zrobiłem:

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

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

echo ${string}

I wtedy otrzymuję następujące Wyjście:

1 2 3 4 5

Zauważ, że to nie zadziała

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

Jak się wydaje upuszcza $foo i zostawia z:

PREFIX_WORLD

Ale to zadziała:

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

I pozostawić z poprawnym wyjściem:

PREFIX_HELLO_WORLD

Tutaj jest jeden przez AWK :

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

Robię to w ten sposób, gdy jest to wygodne: użyj polecenia inline!

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

Moim zdaniem najprostszym sposobem na połączenie dwóch łańcuchów jest napisanie funkcji, która robi to za Ciebie, a następnie użycie tej funkcji.

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

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

foo="Super"
bar="man"

concat $foo $bar   # Superman

alien=$(concat $foo $bar)

echo $alien        # Superman

Lubię robić szybkie funkcje.

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

echo $(combo 'foo''bar')

Nie wiem jeszcze o PHP, ale to działa w Linux Bash. Jeśli nie chcesz wpływać na zmienną, możesz spróbować tego:

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

>Hello World!

Możesz umieścić inną zmienną zamiast' Hello 'lub'!'. Możesz też połączyć więcej strun.