29 Вопрос: Как объединить строковые переменные в Bash

вопрос создан в Fri, Nov 30, 2018 12:00 AM

В PHP строки объединяются следующим образом:

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

Здесь $foo становится «Привет, мир».

Как это достигается в Bash?

    
2463
  1. foo="Hello" foo=$foo" World" echo $foo это скорее работает для "#! /bin /sh"
    2018-03-27 05: 39: 02Z
  2. Что делать, если вы хотите HelloWorld без пробелов?
    2018-07-03 16: 22: 25Z
  3. @ Adi foo1="World" foo2="Hello" foo3="$foo1$foo2"
    2019-04-17 02: 02: 29Z
  4. пробелы имеют значение в bash)
    2019-05-23 13: 10: 34Z
29 ответов                              29                         
foo="Hello"
foo="$foo World"
echo $foo
> Hello World

В общем, для объединения двух переменных вы можете просто записать их одну за другой:

a='hello'
b='world'
c="$a$b"
echo $c
> helloworld
    
3335
2018-10-09 10: 44: 48Z
  1. Вероятно, полезно иметь привычку помещать $foo внутри двойных кавычек, для случаев, когда это действительно имеет значение.
    2010-11-15 07: 56: 29Z
  2. Нас учат всегда делать это, потому что, когда происходит подстановка, пробелы игнорируются пробелами, но двойные кавычки всегда защищают эти пробелы.
    2010-11-16 04: 37: 03Z
  3. Должен ли быть пробел в первом примере? Можно ли сделать что-то вроде foo="$fooworld"? Я бы предположил, что нет ...
    2014-01-30 21: 25: 30Z
  4. @ nonsensickle Это будет искать переменную с именем fooworld. Устранение неоднозначности, что делается с помощью фигурных скобок, как в foo="${foo}world" ...
    2014-03-07 17: 29: 24Z
  5. @ JVE999 Да, это также работает, хотя, на мой взгляд, это не так хорошо для ясности кода ... Но это может быть моим предпочтением ... Там Есть несколько других способов, которыми это может быть сделано - главное, чтобы имя переменной было отделено от частей без имени переменной, чтобы она анализировалась правильно.
    2014-12-10 03: 57: 10Z

Bash также поддерживает оператор +=, как показано в этом коде:

$ A="X Y"
$ A+=" Z"
$ echo "$A"
X Y Z
    
1041
2019-02-06 06: 07: 20Z
  1. Можно ли использовать этот синтаксис с ключевым словом экспорта? например export A+="Z" или, может быть, переменную A нужно экспортировать только один раз?
    2014-03-20 17: 13: 56Z
  2. @ levesque: Both :-). Переменные нужно экспортировать только один раз, но export A+=Z также работает довольно хорошо.
    2014-03-20 17: 16: 59Z
  3. Так как это bashism, я думаю, стоит упомянуть, что вы должны nevиспользуйте #!/bin/sh в сценарии, использующем эту конструкцию.
    2015-04-28 16: 40: 05Z
  4. Это специально и только оператор плюс-равно. То есть, в отличие от Javascript, в Bash echo $A + $B печатает "X Y + Z"
    2017-02-13 19: 04: 09Z
  5. Башизм - это функция оболочки, которая поддерживается только в bash и некоторых других более продвинутых оболочках. Он не будет работать с busybox sh или dash (который является /bin/sh на многих дистрибутивах) или с некоторыми другими оболочками, такими как /bin/sh, предоставленными во FreeBSD.
    2017-09-28 14: 12: 50Z

Bash first

Поскольку этот вопрос предназначен специально для Bash , моей первой части ответа представит различные способы сделать это правильно:

+=: Добавить к переменной

Синтаксис += может использоваться по-разному:

Добавить к строке var+=...

(Поскольку я скромен, я буду использовать только две переменные foo и a, а затем повторно использовать их во всем ответе.; -)

a=2
a+=4
echo $a
24

Использование синтаксиса Вопрос переполнения стека ,

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

Хм .. это не ошибка, а особенность ... Чтобы предотвратить попытку разработки bash !" Вы могли бы:

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 встроенная предоставляет мощный способ рисования формата строки. Поскольку это Bash встроенный , существует возможность отправки отформатированной строки в переменную вместо печати по 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!>

Использование синтаксиса вопроса о переполнении стека :

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

Примечание: использование двойных кавычек может быть полезно для манипулирования строками, которые содержат spaces, tabulations и /или newlines

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

Оболочка сейчас

В оболочке POSIX вы не можете использовать bashisms , поэтому нет встроенного printf.

В основном

Но вы могли бы просто сделать:

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

отформатирован с использованием разветвленной printf

Если вы хотите использовать более сложные конструкции, вы должны использовать fork (новый дочерний процесс, который выполняет задание и возвращает результат через stdout):

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

Исторически, вы могли использовать обратные ссылки для получения результата разветвления :

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

с обратными чертами вы должны выходить из внутренних вилок с помощью обратной косой черты :

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. Оператор += также намного быстрее, чем $a="$a$b" в моих тестах. Что имеет смысл.
    2016-02-21 05: 13: 54Z
  2. Этот ответ потрясающий, но я думаю, что в других ответах отсутствует пример var=${var}.sh, что очень полезно.
    2016-07-20 22: 29: 40Z
  3. Является ли bash единственной оболочкой с оператором +=? Я хочу посмотреть, достаточно ли он портативен
    2016-08-15 15: 41: 24Z
  4. @ dashesy no. Конечно, это не единственная оболочка с оператором +=, но все эти способы - bashisms , так что не переносимы! Даже вы можете столкнуться со специальной ошибкой в ​​случае неправильной версии bash!
    2016-08-16 06: 15: 24Z

Вы тоже можете это сделать:

$ var="myscript"

$ echo $var

myscript


$ var=${var}.sh

$ echo $var

myscript.sh
    
125
2011-10-28 03: 09: 38Z
  1. Хотя специальные символы и пробелы не используются, двойные кавычки, кавычки и фигурные скобки бесполезны: var=myscript;var=$var.sh;echo $var будет иметь те же эффекты (Это работает в bash, dash, busybox и другие).
    2014-05-22 19: 28: 04Z
bla=hello
laber=kthx
echo "${bla}ohai${laber}bye"

Будет выводить

helloohaikthxbye

Это полезно, когда     $blaohai приводит к переменной не найден. Или если у вас есть пробелы или другие специальные символы в ваших строках. "${foo}" правильно экранирует все, что вы в него вставляете.

    
115
2017-09-27 13: 09: 27Z
  1. Не работает. Я получаю «backupstorefolder: команда не найдена» из bash, где «backupstorefolder» - это имя переменной.
    2013-08-04 04: 41: 18Z
  2. Это помогает немного подсвечивать синтаксис и устраняет некоторую двусмысленность между людьми.
    2015-09-15 15: 49: 17Z
foo="Hello "
foo="$foo World"

р>     

42
2014-11-22 10: 32: 51Z
  1. Это наиболее полезный ответ для сценариев оболочки. Я нашел себя последние 30 минут, потому что у меня был пробел до и после знака равенства !!
    2013-02-21 10: 25: 20Z
  2. foo = "${foo} World"
    2016-09-14 13: 43: 39Z

Я бы решил проблему просто

$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
    
32
2016-05-19 11: 04: 20Z
  1. ... следовательно ${a}\ World производит Hello World
    2017-02-12 17: 59: 20Z
  2. Это меня удивляет; Я ожидал бы, что c=$a$b здесь сделает то же самое, что и c=$a World (который попытается запустить World в качестве команды). Я предполагаю, что это означает, что присвоение анализируется до раскрытия переменных.
    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

Вот краткое резюме того, о чем говорит большинство ответов.

Допустим, у нас есть две переменные, а для $1 установлено значение 'one':

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, в {} нет необходимости, если только переменная не конкатенируется со строкой, которая начинается с символа, который является допустимым первым символом в имени переменной оболочки, то есть алфавита или подчеркивания.

Смотрите также:

22
2019-05-20 06: 43: 34Z
  1. Если вас беспокоит производительность, посмотрите анализ в моем ответе stackoverflow. ком /а /47878161/117471
    2017-12-18 23: 58: 16Z

Если вы хотите добавить что-то вроде подчеркивания, используйте escape (\)

FILEPATH=/opt/myfile

Это не работает:

echo $FILEPATH_$DATEX

Это отлично работает:

echo $FILEPATH\\_$DATEX
    
20
2016-06-25 14: 24: 34Z
  1. Или, альтернативно, ${FILEPATH} _ $DATEX. Здесь {} используются для указания границ имени переменной. Это приемлемо, потому что подчеркивание является допустимым символом в именах переменных, поэтому в вашем фрагменте bash фактически пытается разрешить FILEPATH_, а не только $FILEPATH
    2014-02-15 18: 04: 24Z
  2. для меня у меня была одна переменная, т.е. $var1 и константа рядом с ней, так что echo $var1_costant_traling_part работает для меня
    2016-06-28 08: 44: 58Z
  3. Я полагаю, что для экранирования нужен только один люфт: echo $a\_$b сделает. Как намекает в комментарии Ник О'Лай, подчеркивание является регулярным символом. Обработка пробелов намного более чувствительна к строкам, эхо и конкатенации - можно использовать \ и внимательно прочитайте эту ветку, так как эта проблема возникает время от времени.
    2017-02-12 17: 53: 50Z

Еще один подход ...

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

... и еще один.

> H="Hello "
> U=$H"universe."
> echo $U
Hello universe.
    
19
2013-03-18 08: 24: 46Z
  1. Это то, что я сделал, и я нашел это гораздо проще и понятнее, чем другие ответы. Есть ли причина, по которой никто в ответах с наибольшим количеством голосов не указал эту опцию?
    2016-01-06 12: 03: 09Z
  2. @ quimnuss Тот факт, что строки не соответствуют тем, которые используются в вопросе OP, может быть хорошей причиной.
    2016-11-04 10: 19: 52Z
  3. ... и еще один еще один: U=${H}universe. ....
    2017-02-12 17: 56: 17Z

Вы можете объединить без кавычек. Вот пример:

$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
    
15
2014-11-22 10: 33: 24Z
  1. Синтаксис первого блока сбивает с толку. Что означают эти знаки $?
    2017-02-12 17: 47: 13Z

Самый простой способ с кавычками:

B=Bar
b=bar
var="$B""$b""a"
echo "Hello ""$var"
    
15
2018-03-21 19: 05: 14Z
  1. Слишком много кавычек, ИМХО. var=$B$b"a"; echo Hello\ $var сделал бы, я полагаю
    2017-02-12 17: 20: 49Z
  2. Я предлагаю использовать все кавычки, потому что, если вы поставите его везде, где вы не можете пропустить, вам не нужно думать.
    2018-08-02 10: 52: 54Z

Даже если теперь разрешен оператор + =, он был введен в Bash 3.1 в 2004 году.

Любой сценарий, использующий этот оператор в старых версиях Bash, завершится с ошибкой «команда не найдена», если вам повезет, или с «ошибкой синтаксиса рядом с неожиданным токеном».

Для тех, кто заботится об обратной совместимости, придерживайтесь старых стандартных методов конкатенации Bash, подобных тем, которые упомянуты в выбранном ответе:

foo="Hello"
foo="$foo World"
echo $foo
> Hello World
    
14
2014-11-22 10: 40: 54Z
  1. Спасибо за указание на это, я просто искал, какая версия требуется для этой работы.
    2015-05-25 21: 11: 33Z

Я предпочитаю использовать фигурные скобки ${} для расширения переменной в строке:

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

Вьющиеся скобки подойдут для использования непрерывной строки:

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

В противном случае использование foo = "$fooWorld" не будет работать.

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

Если вы пытаетесь разбить строку на несколько строк, вы можете использовать обратную косую черту:

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

С одним пробелом между ними:

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

Этот также добавляет только один пробел между ними:

$ a="hello \
>      world"
$ echo $a
hello world
    
7
2012-04-03 23: 22: 10Z
  1. Боюсь, это не то, что имелось в виду
    2013-01-25 15: 13: 56Z

Более безопасный способ:

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

Строки, содержащие пробелы, могут стать частью команды, используйте «$XXX» и «${XXX}», чтобы избежать этих ошибок.

Плюс взгляните на другой ответ о + =

    
7
2014-02-26 23: 39: 04Z
  1. Точка строк с пробелом, которые считываются как команда, отображается в точке определения. Таким образом, d=DD DD даст DD: command not found --- примечание, что это последний DD, а d, который не найден. Если все операнды правильно отформатированы и уже содержат необходимые пробелы, вы можете просто объединить их с s=${a}${b}${c}${d}; echo $s с меньшим количеством кавычек. Также вы можете использовать \ (экранированный пробел), чтобы избежать этих проблем: d=echo\ echo не будет запускать эхо-вызов, тогда как d=echo echo будет.
    2017-02-12 17: 37: 05Z

В одном конкретном случае вам следует позаботиться:

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

Выводит "daniel"san, а не danielsan, как вы, возможно, хотели. В этом случае вы должны сделать вместо этого:

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

Если это пример добавления " World" к исходной строке, то это может быть:

#!/bin/bash

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

Вывод:

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. Кроме того, var3=$var1\ $var2 имеет тот же эффект
    2017-02-12 17: 14: 03Z

Есть высказанные опасения по поводу производительности, но данные не предоставляются. Позвольте мне предложить простой тест.

(ПРИМЕЧАНИЕ: 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 МБ до того, как он вышел из строя. Вы можете изменить код от удвоения данных до добавления константы, чтобы получить более детальный график и точку сбоя. Но я думаю, что это должно дать вам достаточно информации, чтобы решить, заботитесь ли вы. Лично я меньше 100 МБ. т. Ваш пробег может варьироваться.

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

Я хотел построить строку из списка. Не смог найти ответ на этот вопрос, поэтому я разместил его здесь. Вот что я сделал:

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

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

echo ${string}

и затем я получаю следующий вывод:

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

Так вы объединяете две строки.

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

Обратите внимание, что это не сработает

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

так как кажется, что он отбрасывает $foo и оставляет вас с:

  

PREFIX_WORLD р>

но это будет работать:

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

и оставлю вам правильный вывод:

  

PREFIX_HELLO_WORLD р>

    
3
2013-12-30 20: 23: 04Z
  1. это происходит потому, что подчеркивание является допустимым символом в именах переменных, поэтому bash видит foo_ как переменную. Когда необходимо указать bash точные границы имени переменной, можно использовать фигурные скобки: PREFIX _ ${foo} _ $bar
    2014-02-15 18: 00: 43Z

Я делаю это так, когда удобно: используйте встроенную команду!

echo "The current time is `date`"
echo "Current User: `echo $USER`"
    
1
2014-01-10 00: 33: 00Z
  1. В 1-й строке вы можете удалить fork , используя: date "+The current time is %a %b %d %Y +%T" вместо echo ...$(date). В недавнем bash вы можете написать: printf "The current time is %(%a %b %d %Y +%T)T\n" -1.
    2014-07-23 22: 04: 14Z

Вот один из них через AWK :

$ foo="Hello"
$ foo=$(awk -v var=$foo 'BEGIN{print var" World"}')
$ echo $foo
Hello World
    
1
2014-11-22 10: 39: 49Z
  1. Хорошо, но я думаю, что я мог бы добиться большей точности, используя Python!
    2014-08-26 09: 34: 49Z

Мне нравится делать быструю функцию.

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

echo $(combo 'foo''bar')

Еще один способ снять шкуру с кошки. На этот раз с функциями: D

    
- 1
2014-09-08 07: 44: 57Z
  1. Вызов функции, которая тоже в подоболочке, является слишком большим излишним для простого concat.
    2018-08-21 18: 06: 14Z

Я еще не знаю о PHP, но это работает в Linux Bash. Если вы не хотите влиять на переменную, попробуйте следующее:

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

>Hello World!

Вы можете поместить другую переменную вместо «Hello» или «!». Вы также можете объединить больше строк.

    
- 1
2018-03-21 19: 01: 52Z
  1. Использование подоболочки для простой конкатенации слишком дорого!
    2018-03-20 19: 58: 41Z

Вы можете попробовать следующий способ. Когда происходит замена, двойные кавычки сохраняют пробелы.

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. Это то же самое, что и в других ответах.
    2016-02-29 08: 37: 10Z
источник размещен Вот