29 Pregunta: Cómo concatenar variables de cadena en Bash

pregunta creada en Fri, Nov 30, 2018 12:00 AM

En PHP, las cadenas se concatenan juntas de la siguiente manera:

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

Aquí, $foo se convierte en "Hello World".

¿Cómo se logra esto en Bash?

    
2463
  1. foo="Hello" foo=$foo" World" echo $foo esto funcionó para "#! /bin /sh"
    2018-03-27 05: 39: 02Z
  2. ¿Qué hacer si quieres HelloWorld sin espacio?
    2018-07-03 16: 22: 25Z
  3. @ Adi foo1="World" foo2="Hello" foo3="$foo1$foo2"
    2019-04-17 02: 02: 29Z
  4. espacios hace una cuestión en bash)
    2019-05-23 13: 10: 34Z
29 Respuestas                              29                         
 
foo="Hello"
foo="$foo World"
echo $foo
> Hello World

En general, para concatenar dos variables, puede escribirlas una tras otra:

 
a='hello'
b='world'
c="$a$b"
echo $c
> helloworld
    
3335
2018-10-09 10: 44: 48Z
  1. Probablemente sea bueno acostumbrarse a colocar $foo dentro de las comillas dobles, para los momentos en que realmente importa.
    2010-11-15 07: 56: 29Z
  2. Nos enseñan a hacerlo siempre porque cuando se realiza la sustitución, el shell ignorará los espacios, pero las comillas dobles siempre protegerán esos espacios.
    2010-11-16 04: 37: 03Z
  3. ¿Tiene que haber un espacio en su primer ejemplo? ¿Es posible hacer algo como foo="$fooworld"? Supongo que no ...
    2014-01-30 21: 25: 30Z
  4. @ nonsensickle Eso buscaría una variable llamada fooworld. Desambiguación que se hace con llaves, como en foo="${foo}world" ...
    2014-03-07 17: 29: 24Z
  5. @ JVE999 Sí, eso también funciona, aunque en mi opinión no es tan bueno para la claridad del código ... Pero esa puede ser mi preferencia ... Hay Hay otras formas en que también se puede hacer: el punto es asegurarse de que el nombre de la variable esté separado de las partes de nombre no variable para que se analice correctamente.
    2014-12-10 03: 57: 10Z

Bash también admite un operador += como se muestra en este código:

 
$ A="X Y"
$ A+=" Z"
$ echo "$A"
X Y Z
    
1041
2019-02-06 06: 07: 20Z
  1. ¿Puedo usar esta sintaxis con la palabra clave de exportación? p.ej. export A+="Z" o quizás la variable A solo necesita exportarse una vez?
    2014-03-20 17: 13: 56Z
  2. @ levesque: Both :-). Las variables solo deben exportarse una vez, pero export A+=Z también funciona bastante bien.
    2014-03-20 17: 16: 59Z
  3. Como se trata de un bashismo, creo que vale la pena mencionar que nunca debe usar #!/bin/sh en un script que use esta construcción.
    2015-04-28 16: 40: 05Z
  4. Es específicamente ysólo un operador más-igual. Es decir, a diferencia de Javascript, en Bash, echo $A + $B imprime "X Y + Z"
    2017-02-13 19: 04: 09Z
  5. Un bashismo es una función de shell que solo se admite en bash y algunos shells más avanzados. No funcionará bajo busybox sh o dash (que es /bin/sh en una gran cantidad de distribuciones), o algunos otros shells como el /bin/sh proporcionado en FreeBSD.
    2017-09-28 14: 12: 50Z

Bash primero

Como esta pregunta se refiere específicamente a Bash , mi primera parte de la respuesta presentaría diferentes maneras de hacer esto correctamente:

 +=: Añadir a la variable

La sintaxis += se puede utilizar de diferentes maneras:

Añadir a la cadena var+=...

(Debido a que soy frugal, solo usaré dos variables foo y a y luego reutilizaré el mismo en toda la respuesta.  

a=2
a+=4
echo $a
24

Usando la sintaxis de Stack Overflow question ,

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

funciona bien!

Anexar a un entero ((var+=...))

la variable a es una cadena, pero también un número entero

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

Anexar a una matriz var+=(...)

Nuestro a también es una matriz de un solo elemento.

 
echo ${a[@]}
36

a+=(18)

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

Tenga en cuenta que entre paréntesis, hay una matriz separada por espacios . Si desea almacenar una cadena que contenga espacios en su matriz, debe encerrarlos:

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

Hmm ... esto no es un error, sino una función ... Para evitar que bash intente desarrollar !" , podrías:

 
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: Reconstruya la variable usando el comando builtin

El comando printf builtin ofrece una forma eficaz de dibujar un formato de cadena. Como se trata de un builtin Bash, hay una opción para enviar una cadena con formato a una variable en lugar de imprimir en stdout:  

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

Hay siete cadenas en esta matriz. Así que podríamos construir una cadena con formato que contenga exactamente siete argumentos posicionales:

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

O podríamos usar una cadena de formato de argumento que se repetirá como muchos de los argumentos presentados ...

¡Tenga en cuenta que nuestro a sigue siendo una matriz! ¡Sólo se cambia el primer elemento!

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

Bajo bash, cuando accede a un nombre de variable sin especificar el índice, ¡siempre dirija solo el primer elemento!

Para recuperar nuestra matriz de siete campos, solo necesitamos restablecer el primer 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 cadena de formato de argumento con muchos argumentos pasados ​​a:

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

Usando la sintaxis de Stack Overflow question :

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

Nota: el uso de comillas dobles puede ser útil para manipular cadenas que contienen spaces, tabulations y /o newlines

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

Shell ahora

Bajo el POSIX shell, no puedes usar bashisms , por lo que no hay builtin printf.

Básicamente

Pero simplemente puedes hacerlo:

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

Formateado, utilizando bifurcado printf

Si desea usar construcciones más sofisticadas, debe usar un fork (nuevo proceso secundario que hace el trabajo y devuelve el resultado a través de stdout):

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

Históricamente, puedes usar backticks para recuperar el resultado de un fork :

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

Pero esto no es fácil para anidar :

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

con backticks, tienes que escapar de los forks internos con backslashes :

 
foo="Today is: "
foo=`printf "%s %s" "$foo" "\`date\`"`
echo $foo
Today is: Sun Aug 4 11:59:10 CEST 2013
    
898
2018-08-04 05: 39: 43Z
  1. El operador += también es mucho más rápido que $a="$a$b" en mis pruebas ... Lo que tiene sentido.
    2016-02-21 05: 13: 54Z
  2. Esta respuesta es increíble, pero creo que falta el ejemplo var=${var}.sh de otras respuestas, lo cual es muy útil.
    2016-07-20 22: 29: 40Z
  3. ¿Es bash el único shell con el operador +=? Quiero ver si es lo suficientemente portátil
    2016-08-15 15: 41: 24Z
  4. @ dashesy no. Seguramente no es el único shell con el operador +=, pero todas estas formas son bashismos , por lo que no es portátil! ¡Incluso podrías encontrar un error especial en caso de una versión de bash incorrecta!
    2016-08-16 06: 15: 24Z

También puedes hacer esto:

 
$ var="myscript"

$ echo $var

myscript


$ var=${var}.sh

$ echo $var

myscript.sh
    
125
2011-10-28 03: 09: 38Z
  1. Si bien no se usan caracteres especiales, ni espacios, las comillas dobles, las comillas y los corchetes son inútiles: var=myscript;var=$var.sh;echo $var tendría los mismos efectos (esto funciona bajo bash, dash, busybox y otros).
    2014-05-22 19: 28: 04Z
 
bla=hello
laber=kthx
echo "${bla}ohai${laber}bye"

Saldrá

 
helloohaikthxbye

Esto es útil cuando      $blaohai lleva a una variable de error no encontrada. O si tiene espacios u otros caracteres especiales en sus cadenas. "${foo}" escapa adecuadamente de todo lo que pones en él.

    
115
2017-09-27 13: 09: 27Z
  1. No funciona. Obtengo "backupstorefolder: comando no encontrado" de bash donde "backupstorefolder" es el nombre de una variable.
    2013-08-04 04: 41: 18Z
  2. Esto ayuda bastante el resaltado de sintaxis y elimina cierta ambigüedad humana.
    2015-09-15 15: 49: 17Z
 
foo="Hello "
foo="$foo World"

    
42
2014-11-22 10: 32: 51Z
  1. Esta es la respuesta más útil para los scripts de shell. ¡Me he encontrado los últimos 30 minutos porque tenía un espacio antes y después del signo igual!
    2013-02-21 10: 25: 20Z
  2. foo = "${foo} World"
    2016-09-14 13: 43: 39Z

La forma en que solucionaría el problema es simplemente

 
$a$b

Por ejemplo,

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

que produce

 
Hello World

Si intenta concatenar una cadena con otra cadena, por ejemplo,

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

entonces echo "$c" producirá

 
Hello World

con un espacio extra.

 
$aWorld

no funciona, como puedes imaginar, pero

 
${a}World

produce

 
HelloWorld
    
32
2016-05-19 11: 04: 20Z
  1. ... por lo tanto, ${a}\ World produce Hello World
    2017-02-12 17: 59: 20Z
  2. Esto me sorprende; Hubiera esperado que el c=$a$b aquí hiciera lo mismo que el c=$a World (que intentaría ejecutar el World como un comando). Supongo que eso significa que la asignación se analiza antes de expandir las variables ...
    2019-01-18 20: 33: 34Z
 
$ a=hip
$ b=hop
$ ab=$a$b
$ echo $ab
hiphop
$ echo $a$b
hiphop
    
28
2010-11-15 05: 42: 09Z

Aquí hay un resumen concisoAry de lo que la mayoría de las respuestas están hablando.

Supongamos que tenemos dos variables y $1 se establece en 'uno':

 
set one two
a=hello
b=world

La siguiente tabla explica los diferentes contextos en los que podemos combinar los valores de a y b para crear una nueva variable, 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

Algunas notas:

  • encerrar el RHS de una asignación entre comillas dobles es generalmente una buena práctica, aunque en muchos casos es bastante opcional
  •  += es mejor desde el punto de vista del rendimiento si una cadena grande se está construyendo en pequeños incrementos, especialmente en un bucle
  • use {} alrededor de los nombres de variables para desambiguar su expansión (como en la fila 2 de la tabla anterior). Como se ve en las filas 3 y 4, no hay necesidad de {} a menos que una variable se esté concatenando con una cadena que comienza con un carácter que es un primer carácter válido en el nombre de la variable de shell, que es alfabeto o guión bajo.

Ver también:

22
2019-05-20 06: 43: 34Z
  1. Si le preocupa el rendimiento, vea un análisis en mi respuesta stackoverflow. com /a /47878161/117471
    2017-12-18 23: 58: 16Z

Si desea agregar algo como un guión bajo, use escape (\)

 
FILEPATH=/opt/myfile

Esto no funciona:

 
echo $FILEPATH_$DATEX

Esto funciona bien:

 
echo $FILEPATH\\_$DATEX
    
20
2016-06-25 14: 24: 34Z
  1. O alternativamente, ${FILEPATH} _ $DATEX. Aquí {} se utilizan para indicar los límites del nombre de la variable. Esto es apropiado porque el subrayado es un carácter legal en los nombres de las variables, por lo que en su fragmento, bash intenta resolver FILEPATH_, no solo $FILEPATH
    2014-02-15 18: 04: 24Z
  2. para mí tenía una variable, es decir, $var1 y una constante al lado, así que echo $var1_costant_traling_part funciona para mí
    2016-06-28 08: 44: 58Z
  3. Supongo que solo se necesita una reacción para escapar: echo $a\_$b sería suficiente. Como se insinuó en el comentario de Nik O'Lai, el subrayado es un personaje regular. El manejo de los espacios en blanco es mucho más sensible para las cadenas, el eco y la concatenación: se puede usar \ y leer este hilo a fondo, ya que este problema vuelve de vez en cuando.
    2017-02-12 17: 53: 50Z

Otro enfoque más ...

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

... y, sin embargo, otro.

 
> H="Hello "
> U=$H"universe."
> echo $U
Hello universe.
    
19
2013-03-18 08: 24: 46Z
  1. Eso es lo que hice, y lo encontré mucho más simple y directo que las otras respuestas. ¿Hay alguna razón por la que nadie en las respuestas más votadas haya señalado esta opción?
    2016-01-06 12: 03: 09Z
  2. @ quimnuss El hecho de que las cadenas no coincidan con las utilizadas en la pregunta OP puede ser una buena razón.
    2016-11-04 10: 19: 52Z
  3. ... y aún otro más: U=${H}universe. ....
    2017-02-12 17: 56: 17Z

Puedes concatenar sin las comillas. Aquí hay un ejemplo:

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

Esta última declaración imprimiría "OpenSystems" (sin comillas).

Este es un ejemplo de un script Bash:

 
v1=hello
v2=world
v3="$v1       $v2"
echo $v3            # Output: hello world
echo "$v3"          # Output: hello       world
    
15
2014-11-22 10: 33: 24Z
  1. La sintaxis del primer bloque es confusa. ¿Qué significan estos signos de $?
    2017-02-12 17: 47: 13Z

La forma más sencilla con comillas:

 
B=Bar
b=bar
var="$B""$b""a"
echo "Hello ""$var"
    
15
2018-03-21 19: 05: 14Z
  1. Demasiadas comillas, IMHO. var=$B$b"a"; echo Hello\ $var haría, creo
    2017-02-12 17: 20: 49Z
  2. Le sugiero que utilice todas las comillas, ya que si lo coloca en cualquier lugar que no pueda faltar, no tiene que pensar.
    2018-08-02 10: 52: 54Z

Incluso si el operador + = ahora está permitido, se introdujo en Bash 3.1 en 2004.

Cualquier secuencia de comandos que use este operador en versiones anteriores de Bash fallará con un error de "comando no encontrado" si tiene suerte, o un "error de sintaxis cerca del token inesperado".

Para aquellos a quienes les importa la compatibilidad con versiones anteriores, siga los métodos de concatenación Bash estándar más antiguos, como los mencionados en la respuesta elegida:

 
foo="Hello"
foo="$foo World"
echo $foo
> Hello World
    
14
2014-11-22 10: 40: 54Z
  1. Gracias por señalar esto, estaba buscando la versión que se requiere para que esto funcione.
    2015-05-25 21: 11: 33Z

Prefiero usar corchetes ${} para expandir la variable en la cadena:

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

Los corchetes se ajustarán al uso continuo de la cadena:

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

De lo contrario, usar foo = "$fooWorld" no funcionará.

    
13
2017-06-14 05: 35: 20Z

Si lo que intentas hacer es dividir una cadena en varias líneas, puedes usar una barra invertida:

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

Con un espacio en medio:

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

Este también agrega solo un espacio intermedio:

 
$ a="hello \
>      world"
$ echo $a
hello world
    
7
2012-04-03 23: 22: 10Z
  1. Me temo que esto no es lo que se quería decir
    2013-01-25 15: 13: 56Z

Manera más segura:

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

Las cadenas que contienen espacios pueden formar parte del comando, utilice "$XXX" y "${XXX}" para evitar estos errores.

Además, eche un vistazo a otra respuesta sobre +=

    
7
2014-02-26 23: 39: 04Z
  1. El punto de las cadenas con un espacio que se lee as un comando aparece en el punto de definición. Entonces d=DD DD daría DD: command not found --- nota que es el último DD, más bien d que no se encuentra. Si todos los operandos tienen el formato correcto y ya contienen los espacios requeridos, simplemente puede concatenar con s=${a}${b}${c}${d}; echo $s, con menos comillas. También puede usar \ (espacios en blanco escapados) para evitar estos problemas --- d=echo\ echo no iniciará ninguna invocación de eco, mientras que d=echo echo lo hará.
    2017-02-12 17: 37: 05Z

Hay un caso particular en el que deberías cuidarte:

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

Producirá "daniel"san, y no danielsan, como podrías haber deseado. En este caso deberías hacerlo en su lugar:

 
user=daniel
cat > output.file << EOF
${user}san
EOF
    
7
2015-10-28 17: 35: 47Z

Si es como tu ejemplo de agregar " World" a la cadena original, entonces puede ser:

 
#!/bin/bash

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

La salida:

 
Hello World
    
5
2015-04-24 05: 07: 45Z
 
var1='hello'
var2='world'
var3=$var1" "$var2 
echo $var3
    
5
2017-02-07 08: 50: 05Z
  1. También var3=$var1\ $var2 tiene el mismo efecto
    2017-02-12 17: 14: 03Z

Hay inquietudes expresadas sobre el rendimiento, pero no se ofrecen datos. Déjame sugerir una prueba simple.

(NOTA: date en macOS no ofrece nanosegundos, por lo que esto debe hacerse en Linux).

He creado append_test.sh en GitHub con el contenido:

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

Prueba 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

Prueba 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

Los errores indican que mi Bash llegó a 335.54432 MB antes de que se estrellara. Puede cambiar el código de duplicar los datos para añadir una constante para obtener un gráfico más granular y punto de fallo. Pero creo que esto debería darte suficiente información para decidir si te importa. Personalmente, por debajo de 100 MB no lo hago. Su kilometraje puede variar.

    
4
2018-03-21 19: 04: 27Z

Quería construir una cadena a partir de una lista. No pude encontrar una respuesta para eso, así que la publico aquí. Esto es lo que hice:

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

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

echo ${string}

y luego obtengo el siguiente resultado:

 
1 2 3 4 5
    
4
2018-10-21 10: 06: 41Z
 
a="Hello,"
a=$a" World!"
echo $a

Así es como se concatenan dos cadenas.

    
4
2019-03-05 19: 35: 35Z

Ten en cuenta que esto no funcionará

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

ya que parece bajar $foo y te deja con:

  

PREFIX_WORLD

pero esto funcionará:

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

y te dejo con la salida correcta:

  

PREFIX_HELLO_WORLD

    
3
2013-12-30 20: 23: 04Z
  1. esto sucede porque el subrayado es el carácter válido en los nombres de las variables, por lo que bash ve foo_ como una variable. Cuando es necesario decirle a bash los límites exactos de los nombres de las var, se pueden usar las llaves: PREFIX_ ${foo} _ $bar
    2014-02-15 18: 00: 43Z

Lo hago de esta manera cuando es conveniente: ¡Use un comando en línea!

 
echo "The current time is `date`"
echo "Current User: `echo $USER`"
    
1
2014-01-10 00: 33: 00Z
  1. En la 1ª línea, puede eliminar un fork utilizando: date "+The current time is %a %b %d %Y +%T", en lugar de echo ...$(date). Bajo el bash reciente, puedes escribir: printf "The current time is %(%a %b %d %Y +%T)T\n" -1.
    2014-07-23 22: 04: 14Z

Aquí está la una a través de AWK :

 
$ foo="Hello"
$ foo=$(awk -v var=$foo 'BEGIN{print var" World"}')
$ echo $foo
Hello World
    
1
2014-11-22 10: 39: 49Z
  1. Bien, ¡pero creo que podría obtener más precisión usando Python!
    2014-08-26 09: 34: 49Z

Me gusta hacer una función rápida.

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

echo $(combo 'foo''bar')

Otra forma de pelar a un gato. Esta vez con funciones: D

    
- 1
2014-09-08 07: 44: 57Z
  1. Llamar a una función, eso también en una subshell, es demasiado exagerado para un simple concat.
    2018-08-21 18: 06: 14Z

Todavía no sé sobre PHP, pero esto funciona en Linux Bash. Si no desea afectarlo a una variable, puede intentar esto:

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

>Hello World!

Podría colocar otra variable en lugar de 'Hola' o '!'. También puedes concatenar más cadenas.

    
- 1
2018-03-21 19: 01: 52Z
  1. ¡Usar una subshell para hacer una concatenación simple es demasiado caro!
    2018-03-20 19: 58: 41Z

Puedes intentarlo de la siguiente manera. Cuando se realice la sustitución, las comillas dobles mantendrán los espacios.

 
var1="Ram "    
var2="Lakshmana" 
echo $var1$var2
or 
echo var1+=$var2 "bash support += operation.

bcsmc2rtese001 [/tmp]$ var1="Ram "  
bcsmc2rtese001 [/tmp]$ var2="Lakshmana"  
bcsmc2rtese001 [/tmp]$ echo $var1$var2  
Ram Lakshmana  

bcsmc2rtese001 [/tmp]$ var1+=$var2  
bcsmc2rtese001 [/tmp]$ echo $var1  
Ram Lakshmana
    
- 4
2015-01-12 14: 58: 03Z
  1. Esto es lo mismo que en otras respuestas.
    2016-02-29 08: 37: 10Z
fuente colocada aquí