comando - bash concatenate strings with underscore



Come concatenare le variabili stringa in Bash (19)

In PHP, le stringhe sono concatenate insieme come segue:

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

Qui, $foo diventa "Hello World".

Come viene realizzato in Bash?


Answer #1

Bash prima

Poiché questa domanda è specifica per Bash , la mia prima parte della risposta presenterà diversi modi per farlo correttamente:

+= : Aggiungi alla variabile

La sintassi += può essere utilizzata in diversi modi:

Aggiungi alla stringa var+=...

(Dato che sono parsimonioso, userò solo due variabili foo e a e poi riutilizzerò lo stesso nell'intera risposta. ;-)

a=2
a+=4
echo $a
24

Utilizzando la sintassi della domanda Overflow dello stack ,

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

funziona bene!

Aggiungi a un numero intero ((var+=...))

la variabile a è una stringa, ma anche un intero

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

Aggiungi a un array var+=(...)

Il nostro a è anche un array di un solo elemento.

echo ${a[@]}
36

a+=(18)

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

Si noti che tra parentesi, c'è una matrice separata dallo spazio . Se si desidera memorizzare una stringa contenente spazi nell'array, è necessario includerli:

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

Hmm .. questo non è un bug, ma una funzionalità ... Per evitare che bash provi a sviluppare !" , Potresti:

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 : ricostruisci la variabile usando il comando builtin

Il comando incorporato di printf offre un modo potente per disegnare il formato di una stringa. Poiché questo è un builtin di Bash, c'è un'opzione per inviare una stringa formattata a una variabile invece di stampare su stdout :

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

Ci sono sette stringhe in questo array. Quindi potremmo costruire una stringa formattata contenente esattamente sette argomenti posizionali:

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

Oppure potremmo usare una stringa di formato di argomento che verrà ripetuta come molti argomenti inviati ...

Si noti che il nostro a è ancora un array! Solo il primo elemento è cambiato!

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

Sotto bash, quando si accede a un nome di variabile senza specificare l'indice, si rivolge sempre solo al primo elemento!

Quindi, per recuperare il nostro array di sette campi, dobbiamo solo reimpostare il primo elemento:

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

Una stringa di formato di argomento con molti argomenti passati a:

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

Utilizzando la sintassi della domanda Overflow dello stack :

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

Nota: l'uso di virgolette può essere utile per manipolare stringhe che contengono spaces , tabulations e / o newlines

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

Shell ora

Sotto la shell POSIX , non è possibile usare i bashismi , quindi non c'è un printf integrato .

Fondamentalmente

Ma potresti semplicemente fare:

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

Formattato, usando printf forcella

Se si desidera utilizzare costruzioni più sofisticate, è necessario utilizzare un fork (nuovo processo figlio che esegue il lavoro e restituisce il risultato tramite stdout ):

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

Storicamente, è possibile utilizzare i backtick per recuperare il risultato di una forcella :

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

Ma questo non è facile per la nidificazione :

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

con i backtick, devi sfuggire alle forcelle interne con i backslash :

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

Answer #2

Anche se l'operatore + = è ora consentito, è stato introdotto in Bash 3.1 nel 2004.

Qualsiasi script che usi questo operatore nelle versioni precedenti di Bash fallirà con un errore "comando non trovato" se sei fortunato, o un "errore di sintassi vicino a un token imprevisto".

Per coloro che si preoccupano della retrocompatibilità, attenersi ai vecchi metodi di concatenazione Bash standard, come quelli menzionati nella risposta scelta:

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

Answer #3

Bash supporta anche un operatore + = come mostrato nella seguente trascrizione:

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

Answer #4

C'è un caso particolare in cui dovresti fare attenzione:

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

"daniel"san , e non danielsan , come avresti voluto. In questo caso dovresti fare invece:

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

Answer #5

Ecco quello attraverso AWK :

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

Answer #6

Ecco un breve riassunto di ciò di cui la maggior parte delle risposte sta parlando.

Diciamo che abbiamo due variabili:

a=hello
b=world

La tabella seguente spiega i diversi contesti in cui possiamo combinare i valori di b per creare una nuova variabile, 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, 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

Alcune note:

  • racchiudere l'RHS di un incarico tra virgolette è generalmente una buona pratica, anche se in molti casi è abbastanza facoltativo
  • += è migliore dal punto di vista delle prestazioni se una grande stringa viene costruita in piccoli incrementi, specialmente in un ciclo
  • usa {} attorno a nomi di variabili per disambiguare la loro espansione (come nella riga 2 nella tabella sopra)

Guarda anche:


Answer #7

Il modo più semplice con le virgolette:

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

Answer #8

Lo faccio in questo modo quando conveniente: usa un comando in linea!

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

Answer #9

Modo più sicuro:

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

Le stringhe contenenti spazi possono diventare parte del comando, utilizzare "$ XXX" e "$ {XXX}" per evitare questi errori.

Inoltre dai un'occhiata ad altre risposte su + =


Answer #10

Non so ancora PHP, ma funziona su Linux Bash. Se non vuoi influenzarlo con una variabile, puoi provare questo:

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

>Hello World!

Potresti inserire un'altra variabile invece di "Ciao" o "!". Puoi anche concatenare più stringhe.


Answer #11

Puoi concatenare senza le virgolette. Ecco un esempio:

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

Quest'ultima affermazione stamperebbe "OpenSystems" (senza virgolette).

Questo è un esempio di uno script Bash:

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

Answer #12

Puoi farlo anche tu:

$ var="myscript"

$ echo $var

myscript


$ var=${var}.sh

$ echo $var

myscript.sh

Answer #13

Se è il tuo esempio di aggiungere " World" alla stringa originale, allora può essere:

#!/bin/bash

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

L'output:

Hello World

Answer #14

Se quello che stai cercando di fare è dividere una stringa in più righe, puoi usare una barra rovesciata:

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

Con uno spazio in mezzo:

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

Questo aggiunge anche solo uno spazio in mezzo:

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

Answer #15

Si noti che questo non funzionerà

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

dato che sembra cadere $ pippo e ti lascia con:

PREFIX_WORLD

ma questo funzionerà:

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

e ti lascia con l'output corretto:

PREFIX_HELLO_WORLD


Answer #16

Volevo costruire una stringa da una lista. Non ho trovato una risposta per questo, quindi la postò qui. Ecco cosa ho fatto:

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

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

echo ${string}

e poi ottengo il seguente risultato:

1 2 3 4 5

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

Uscirà

helloohaikthxbye

Questo è utile quando $blaohai porta a un errore di variabile non trovato. O se hai spazi o altri caratteri speciali nelle tue corde. "${foo}" evita correttamente qualsiasi cosa tu abbia inserito.


Answer #18
foo="Hello "
foo="$foo World"


Answer #19
var1='hello'
var2='world'
var3=$var1" "$var2 
echo $var3




string-concatenation