Как объединить строковые переменные в Bash
В PHP строки объединяются следующим образом:
$foo = "Hello";
$foo .= " World";
Вот, $foo становится "Hello World".
Как это достигается в Bash?
32 ответа
foo="Hello"
foo="$foo World"
echo $foo
> Hello World
В целом, для объединения двух переменных вы можете просто записать их одну за другой:
a='hello'
b='world'
c="$a$b"
echo $c
> helloworld
Bash также поддерживает += оператор, как показано в этом коде:
$ A="X Y"
$ A+=" Z"
$ echo "$A"
X Y Z
Баш первый
Поскольку этот вопрос предназначен специально для Bash, моя первая часть ответа представит различные способы сделать это правильно:
+=: Добавить к переменной
Синтаксис += может использоваться по-разному:
Добавить к строке var+=...
(Поскольку я скромный, я буду использовать только две переменные foo а также a а затем снова использовать то же самое во всем ответе.;-)
a=2
a+=4
echo $a
24
Используя синтаксис вопроса Stack Overflow,
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: Перестроить переменную с помощью встроенной команды
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"
Shell сейчас
В оболочке POSIX вы не можете использовать bashisms, поэтому нет встроенных printf,
В принципе
Но вы могли бы просто сделать:
foo="Hello"
foo="$foo World"
echo $foo
Hello World
Отформатирован с использованием разветвленного printf
Если вы хотите использовать более сложные конструкции, вы должны использовать форк (новый дочерний процесс, который выполняет задание и возвращает результат через 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
Ты тоже можешь это сделать:
$ var="myscript"
$ echo $var
myscript
$ var=${var}.sh
$ echo $var
myscript.sh
bla=hello
laber=kthx
echo "${bla}ohai${laber}bye"
Будет выходной
helloohaikthxbye
Это полезно, когда $blaohaiприводит к переменной не найден. Или если у вас есть пробелы или другие специальные символы в ваших строках. "${foo}" правильно избегает всего, что вы положили в него.
Вот краткое резюме того, о чем говорит большинство ответов.
Допустим, у нас есть две переменные:
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, 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 в таблице выше)
Смотрите также:
Я бы решил проблему просто
$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
$ a=hip
$ b=hop
$ ab=$a$b
$ echo $ab
hiphop
$ echo $a$b
hiphop
Еще один подход...
> H="Hello "
> U="$H""universe."
> echo $U
Hello universe.
... и еще один.
> H="Hello "
> U=$H"universe."
> echo $U
Hello universe.
Если вы хотите добавить что-то вроде подчеркивания, используйте escape (\)
FILEPATH=/opt/myfile
Это не работает:
echo $FILEPATH_$DATEX
Это отлично работает:
echo $FILEPATH\\_$DATEX
Самый простой способ с кавычками:
B=Bar
b=bar
var="$B""$b""a"
echo "Hello ""$var"
Переменные и массивы (индексированные или ассоциативные *) в bash по умолчанию всегда являются строками, но вы можете использовать флаги для
declare встроенный, чтобы дать им такие атрибуты, как "целое число" (
-i) или "ссылка" ** (
-n), которые меняют их поведение.
Арифметика Bash принимает для ввода числа ASCII / строки, поэтому есть несколько причин для фактического использования целочисленного атрибута.
Также значения переменных не могут содержать ASCII.
NULL (т. е. 8-битный ноль), потому что для их реализации используются обычные строки C с завершающим нулем.
* Т.е. одна или несколько пар ключ + значение.
** Ссылочные переменные расширяются до значения другой переменной, метка которой присвоена ссылочной переменной.
Добавить строку:
$ foo=Hello
$ foo+=' world!'
$ echo "$foo"
Hello world!
$ num=3
$ num+=4
echo "$num"
34 # Appended string (not a sum)
Одна из немногих причин использования целочисленного атрибута заключается в том, что он меняет поведение оператора присваивания:
$ declare -i num=3
$ num+=4
echo "$num"
7 # Sum
Обратите внимание, что это не работает для
-=,
/=и т. д., если вы не сделаете это внутри арифметики (
(( )) а также
$(( ))), где числа уже обрабатываются одинаково с целочисленным атрибутом или без него. См. Раздел «арифметическое вычисление»
man bash для полного списка тех операторов, которые такие же, как для C.
Оператор присваивания также может использоваться для добавления новых элементов в индексированный массив (также известный как «список»):
$ foo=(one)
$ foo+=(two)
$ printf 'Separate element: %s\n' "${foo[@]}"
Separate element: one
Separate element: two
Другой распространенный способ сделать это - использовать счетчик:
$ foo[c++]=one
$ foo[c++]=two
Оболочки POSIX не используют
+=оператор присваивания для добавления строк , поэтому вы должны сделать это следующим образом:
$ foo=Hello
$ foo="$foo world!"
$ echo "$foo"
Hello world!
Это нормально в
bash тоже, поэтому его можно считать более переносимым синтаксисом.
Вы можете объединить без кавычек. Вот пример:
$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
Даже если теперь разрешен оператор +=, он был введен в Bash 3.1 в 2004 году.
Любой сценарий, использующий этот оператор в более старых версиях Bash, завершится с ошибкой "команда не найдена", если вам повезет, или с "синтаксической ошибкой рядом с неожиданным токеном".
Для тех, кому небезразлична обратная совместимость, придерживайтесь старых стандартных методов конкатенации Bash, подобных тем, которые упомянуты в выбранном ответе:
foo="Hello"
foo="$foo World"
echo $foo
> Hello World
Я предпочитаю использовать фигурные скобки ${} для раскрытия переменной в строке:
foo="Hello"
foo="${foo} World"
echo $foo
> Hello World
Вьющиеся скобки подойдут для непрерывного использования строки:
foo="Hello"
foo="${foo}World"
echo $foo
> HelloWorld
В противном случае, используя foo = "$fooWorld" не будет работать.
Несмотря на специальный оператор, +=, для конкатенации есть более простой способ:
foo='Hello'
foo=$foo' World'
echo $foo
Двойные кавычки требуют дополнительного времени вычисления для интерпретации переменных внутри. По возможности избегайте этого.
Есть один конкретный случай, когда вы должны позаботиться:
user=daniel
cat > output.file << EOF
"$user"san
EOF
Будет выходной "daniel"san, и не danielsan, как вы, возможно, хотели. В этом случае вы должны сделать вместо этого:
user=daniel
cat > output.file << EOF
${user}san
EOF
Более безопасный способ:
a="AAAAAAAAAAAA"
b="BBBBBBBBBBBB"
c="CCCCCCCCCCCC"
d="DD DD"
s="${a}${b}${c}${d}"
echo "$s"
AAAAAAAAAAAABBBBBBBBBBBBCCCCCCCCCCCCDD DD
Строки, содержащие пробелы, могут стать частью команды, используйте "$XXX" и "${XXX}", чтобы избежать этих ошибок.
Плюс посмотрите на другой ответ о +=
Если вы пытаетесь разделить строку на несколько строк, вы можете использовать обратную косую черту:
$ a="hello\
> world"
$ echo $a
helloworld
С одним пробелом между:
$ a="hello \
> world"
$ echo $a
hello world
Этот также добавляет только один пробел между:
$ a="hello \
> world"
$ echo $a
hello world
Есть высказанные опасения по поводу производительности, но данные не предлагаются. Позвольте мне предложить простой тест.
(НОТА: 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 МБ. Ваш пробег может отличаться.
a="Hello,"
a=$a" World!"
echo $a
Вот как вы объединяете две строки.
Я хотел построить строку из списка. Не смог найти ответ на этот вопрос, поэтому я разместил его здесь. Вот что я сделал:
list=(1 2 3 4 5)
string=''
for elm in "${list[@]}"; do
string="${string} ${elm}"
done
echo ${string}
и тогда я получаю следующий вывод:
1 2 3 4 5
Если это как ваш пример добавления " World" к исходной строке, то это может быть:
#!/bin/bash
foo="Hello"
foo=$foo" World"
echo $foo
Выход:
Hello World
Обратите внимание, что это не сработает
foo=HELLO
bar=WORLD
foobar=PREFIX_$foo_$bar
как кажется, отбрасывает $foo и оставляет вас с:
PREFIX_WORLD
но это будет работать
foobar=PREFIX_"$foo"_"$bar"
и оставить вас с правильным выводом:
PREFIX_HELLO_WORLD
Вот один через AWK:
$ foo="Hello"
$ foo=$(awk -v var=$foo 'BEGIN{print var" World"}')
$ echo $foo
Hello World
На мой взгляд, самый простой способ объединить две строки - написать функцию, которая сделает это за вас, а затем использовать эту функцию.
function concat ()
{
prefix=$1
suffix=$2
echo "${prefix}${suffix}"
}
foo="Super"
bar="man"
concat $foo $bar # Superman
alien=$(concat $foo $bar)
echo $alien # Superman
Я делаю это так, когда это удобно: используйте встроенную команду!
echo "The current time is `date`"
echo "Current User: `echo $USER`"
Я еще не знаю о PHP, но это работает в Linux Bash. Если вы не хотите влиять на переменную, вы можете попробовать это:
read pp; *# Assumes I will affect Hello to pp*
pp=$( printf $pp ;printf ' World'; printf '!');
echo $pp;
>Hello World!
Вы можете поместить другую переменную вместо "Hello" или "!". Вы также можете объединить больше строк.