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

În general, pentru a concatena două variabile pe care le pot doar scrie-le unul după altul:

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

Bash susține, de asemenea, un += operator așa cum se arată în acest cod:

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

Bash prima

Ca această întrebare stand special pentru Bash, prima mea parte din răspuns ar prezenta diferite moduri de a face acest lucru în mod corespunzător:

+=: Append variabile

Sintaxa += pot fi utilizate în diferite moduri:

Pentru a adăuga string var+=...

(Pentru că eu sunt modest, nu va utiliza numai două variabile " foo " și " a " și apoi re-utiliza aceleași în întregul răspuns. ;-)

a=2
a+=4
echo $a
24

Folosind Stiva Preaplin întrebare sintaxă,

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

funcționează bine!

Pentru a adăuga un număr întreg ((var+=...))

variabila " a " este un șir de caractere, dar, de asemenea, un număr întreg

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

Pentru a adăuga o matrice var+=(...)

Noastre " a " este, de asemenea, o serie de doar un element.

echo ${a[@]}
36

a+=(18)

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

Rețineți că, între paranteze, acolo este o spațiu separat matrice. Dacă doriți pentru a stoca un șir de caractere care conțin spații în matrice, trebuie să le includeți:

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

Hmm.. acesta nu este un bug, ci o caracteristică... Pentru a preveni bash pentru a încerca să dezvolte !", ai putea:

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-construi variabilei interna comanda

La "printf" interna comandă oferă o modalitate puternică de desen format șir. Ca acesta este un Bash interna, există o opțiune pentru a trimite formatat șir la o variabilă în loc de imprimare pe stdout`:

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

Există șapte siruri de caractere în această matrice. Deci, am putea construi un string formatat conțin exact șapte pozițional argumente:

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

Sau am putea folosi un argument șir format care va fi repetat de câte argument prezentat...

Rețineți că " a " este încă o serie! Numai primul element este schimbat!

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

Sub bash, atunci când accesați un nume de variabilă fără a preciza index, întotdeauna adresa primului element numai!

Deci, pentru a prelua șapte domeniul matrice, avem nevoie doar de a re-set 1 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!")'

Un argument șir format cu multe argument a trecut la:

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

Folosind Stiva Preaplin întrebare sintaxa:

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

Nota: utilizarea de dublu-citate poate fi util pentru manipularea siruri de caractere care conțin spatii, tabele "și/sau" newline

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

Coajă acum

Sub POSIX shell, nu puteai folosi bashisms, astfel încât nu există nici interna "printf".

Practic

Dar ai putea face pur și simplu:

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

Formatat, folosind incarcatori "printf"

Dacă doriți să utilizați mai sofisticate construcții trebuie să utilizați o furculiță (nou proces copil care face de locuri de muncă și întoarce rezultatul prin stdout):

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

Din punct de vedere istoric, ai putea folosi backticks pentru preluarea rezultatul unei furculiță:

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

Dar acest lucru nu este ușor pentru cuib:

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

cu backticks, trebuie să scape de interior furci cu bare oblice inverse:

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

Puteți face acest lucru:

$ var="myscript"

$ echo $var

myscript

$ var=${var}.sh

$ echo $var

myscript.sh

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

Va ieșire

helloohaikthxbye

Acest lucru este util atunci când $blaohai duce la o variabilă nu a fost găsit de eroare. Sau dacă aveți spații sau alte caractere speciale în siruri de caractere. "${foo}" corect scapă nimic ai pus în ea.

Cum am'd rezolva problema este doar

$a$b

De exemplu,

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

care produce

Hello World

Dacă încercați să înlănțui un șir de caractere cu un alt șir, de exemplu,

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

apoi echo "$c" va produce

Hello World

cu un plus de spațiu.

$aWorld

nu't de lucru, după cum vă puteți imagina, dar

${a}World

produce

HelloWorld

Aici este un rezumat a ceea ce cele mai multe răspunsuri sunt vorbesc despre.

Las's spune că avem două variabile și $1 este setat la 'o':

set one two
a=hello
b=world

Tabelul de mai jos explică diferitele contexte în care putem combina valorile " a " și " b " pentru a crea o nouă variabilă, 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

Cateva note:

• inchiderea la RHS de o misiune în ghilimele duble este, în general, o bună practică, deși este destul de opțional în multe cazuri
• += este mai bine de un spectacol de vedere, dacă un șir de mare este construită în trepte mici, mai ales într-o buclă
• utilizarea {} în jurul valorii de nume de variabile pentru confundată extinderea lor (ca în rândul 2 din tabelul de mai sus). După cum se vede pe rândurile 3 și 4, nu este nevoie de {} dacă o variabilă este concatenat cu un șir care începe cu un personaj, care este valabil primul caracter din coajă de numele variabilei, care este alfabetul sau subliniere.

Vezi de asemenea și:

• BashFAQ/013 - Cum pot concatena două variabile?
• https://stackoverflow.com/questions/8748831/when-do-we-need-curly-braces-around-shell-variables

Dacă doriți să adăugați ceva ca o subliniere, utilizarea escape (\)

FILEPATH=/opt/myfile

Acest lucru nu nu de lucru:

echo $FILEPATH_$DATEX

Aceasta funcționează bine:

echo $FILEPATH\\_$DATEX

O altă abordare...

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

...și totuși, încă unul.

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

Chiar dacă += operator permis acum, acesta a fost introdus în Bash 3.1 în 2004.

Orice script folosind acest operator în vârstă Bash versiuni va eșua, cu o "comanda nu a fost găsit" eroare dacă ești norocos, sau un "eroare de sintaxă lângă simbol neașteptat".

Pentru cei care îi pasă de compatibilitate, stick cu vârstă standard Bash concatenare metode, cum ar fi cele menționate în răspunsul ales:

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

Puteți înlănțui fără ghilimele. Aici este un exemplu:

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

Această ultimă afirmație ar imprima "OpenSystems" (fără ghilimele).

Acesta este un exemplu de un script Bash:

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

Cel mai simplu mod cu ghilimele:

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

Eu prefer să folosesc acolade ${} pentru extinderea variabilă în șir:

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

Acolade se va potrivi la șir Continuu de utilizare:

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

În caz contrar, folosind foo = "$fooWorld" nu va funcționa.

Dacă ceea ce încearcă să facă este să split un șir de caractere în mai multe rânduri, puteți să utilizați o bară oblică:

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

Cu un spațiu în între:

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

Aceasta adaugă, de asemenea, doar un spațiu în între:

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

Nu's un caz special în care trebuie să aveți grijă:

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

Va ieșire `"daniel"san", și nu " danielsan, cum le-ar fi dorit. În acest caz, ar trebui să faci în schimb:

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

Mod mai sigur:

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

Siruri de caractere care conțin spații pot deveni parte din comandă, utilizați "$XXX" și "${XXX}" pentru a evita aceste erori.

Plus ia o privire la alte răspunsul despre +=

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

Acesta este modul de concatenare a două șiruri.

Dacă este ca de exemplu adăugarea de `" Lume" să șirul original, atunci acesta poate fi:

#!/bin/bash

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

Ieșire:

Hello World