Bash හි නූල් විචල්යයන් සංයුක්ත කරන්නේ කෙසේද

2787

PHP හි, නූල් පහත පරිදි එකට බැඳී ඇත:

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

මෙන්න, $foo"හෙලෝ වර්ල්ඩ්" බවට පත්වේ.

මෙය Bash හි ඉටු කරන්නේ කෙසේද?

bash  shell  syntax  concat  string-concatenation 
— ස්ට්රෝබෙරි
source
6
foo="Hello" foo=$foo" World" echo $foo මෙය "#! / bin / sh" සඳහා වැඩ කර ඇත
— පැරෂිෂ්
1
ඔබට ඉඩක් නොමැතිව හෙලෝ වර්ල්ඩ් අවශ්‍ය නම් කුමක් කළ යුතුද?
— ආදි
D ආඩිfoo1="World" foo2="Hello" foo3="$foo1$foo2"
— ජිනෙකෝඩ්
අවකාශය
— කඩිනමින්

Answers:

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

පොදුවේ ගත් කල විචල්‍යයන් දෙකක් සංයුක්ත කිරීම සඳහා ඔබට ඒවා එකින් එක ලිවිය හැකිය:

a='Hello'
b='World'
c="${a} ${b}"
echo "${c}"
> Hello World
— codaddict
source
314
$fooද්විත්ව මිල ගණන් ඇතුලත් කිරීමේ පුරුද්දට පිවිසීම බොහෝ විට හොඳයි , එය ඇත්ත වශයෙන්ම වැදගත් වන කාලයන් සඳහා.
— කැස්කබෙල්
105
සෑම විටම එසේ කිරීමට අපට උගන්වා ඇත්තේ ආදේශනය සිදු වූ විට අවකාශය කවචය විසින් නොසලකා හරිනු ඇත, නමුත් ද්විත්ව උපුටා දැක්වීම් සෑම විටම එම අවකාශයන් ආරක්ෂා කරනු ඇත.
— ස්ට්රෝබෙරි
62
ඔබේ පළමු උදාහරණයේ ඉඩක් තිබිය යුතුද? වැනි දෙයක් කළ foo="$fooworld"හැකිද? මම හිතන්නේ නැහැ ...
— විකාර
341
onsnonsensickle එය නම් විචල්‍යයක් සොයනු ඇත fooworld. එය මෙන් වරහන් වලින් සිදු කරනු ලැබේ foo="${foo}world"...
— twalberg
4
V JVE999 ඔව්, එයද ක්‍රියාත්මක වේ, මගේ මතය අනුව එය කේත පැහැදිලිකම සඳහා එතරම් හොඳ නැත ... නමුත් එය මගේ මනාපය විය හැකිය ... එය කළ හැකි තවත් ක්‍රම කිහිපයක් තිබේ - කාරණය වන්නේ විචල්ය නාමය විචල්ය නොවන නාම කොටස් වලින් වෙන් කර ඇති බවට වග බලා ගැනීමෙන් එය නිවැරදිව විග්‍රහ කරයි.
— twalberg
1132

+=මෙම කේතයේ පෙන්වා ඇති පරිදි බෑෂ් ක්‍රියාකරුට සහය දක්වයි :

$ A="X Y"
$ A+=" Z"
$ echo "$A"
X Y Z
— thkala
source
2
අපනයන යතුරුපදය සමඟ මට මෙම සින්ටැක්ස් භාවිතා කළ හැකිද? උදා: export A+="Z"හෝ Aවිචල්‍යය එක් වරක් පමණක් අපනයනය කළ යුතුද?
— levesque
3
vevevesque: දෙකම :-). විචල්යයන් එක් වරක් පමණක් අපනයනය කළ යුතු නමුත් එය export A+=Zඉතා හොඳින් ක්රියා කරයි.
— thkala
39
මෙය බාෂිවාදයක් බැවින්, #!/bin/shමෙම ඉදිකිරීම භාවිතා කරමින් ඔබ කිසි විටෙකත් පිටපතක භාවිතා නොකළ යුතු බව සඳහන් කිරීම වටී යැයි මම සිතමි .
— ලකුණු_අන්ඩර්
2
එය නිශ්චිතවම සහ ප්ලස්-සමාන ක්‍රියාකරු පමණි. එනම්, ජාවාස්ක්‍රිප්ට් මෙන් නොව, බාෂ් හි, $ A + $ B මුද්‍රණය "X Y + Z"
— phpguru
6
Bashism යනු ෂෙල් ලක්ෂණයකි, එය සහය දක්වන්නේ bashතවත් සමහර දියුණු කවච පමණි. එය යටතේ busybox shහෝ dash( /bin/shබොහෝ ඩිස්ට්‍රෝස් වල) හෝ ෆ්‍රීබීඑස්ඩී හි /bin/shසපයා ඇති වෙනත් ෂෙල් වෙඩි යටතේ ක්‍රියා නොකරනු ඇත .
— ලකුණු_අන්ඩර්
964

මුලින්ම බාෂ් කරන්න

මෙම ප්‍රශ්නය විශේෂයෙන් බාෂ් සඳහා වන බැවින් , මගේ පිළිතුරේ පළමු කොටසේ මෙය නිසි ලෙස කළ හැකි විවිධ ක්‍රම ඉදිරිපත් කරයි:

+=: විචල්යයට එකතු කරන්න

සින්ටැක්ස් +=විවිධ ආකාරවලින් භාවිතා කළ හැකිය:

නූල් එකතු කරන්න 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

හ්ම් .. මෙය දෝෂයක් නොව අංගයකි ... දියුණු කිරීමට උත්සාහ කිරීම වළක්වා ගැනීම සඳහා !", ඔබට හැකි:

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 builtin විධානය string ආකෘතිය උකහාගැනීමේ බලවත් ක්රමයක් ලබා දෙයි. මෙය Bash buildin එකක් බැවින් , මුද්‍රණය කිරීම වෙනුවට විචල්යයකට ආකෘතිගත නූල් යැවීමට විකල්පයක් ඇත 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!>

Stack Overflow ප්‍රශ්න සින්ටැක්ස් භාවිතා කිරීම :

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

Nota: භාවිතය ද්විත්ව මිල කැඳවීම් අඩංගු නූල් හැසිරවීමේ සඳහා ප්රයෝජනවත් විය හැකි බව spaces, tabulationsසහ / හෝnewlines

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

දැන් ෂෙල් කරන්න

යටතේ POSIX කටු, ඔබ භාවිතා කල නො හැකි bashisms , එසේ නොමැති builtin printf .

මූලික වශයෙන්

නමුත් ඔබට සරලවම කළ හැකිය:

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

ෆෝක් භාවිතා කරමින් ආකෘතිගත කර ඇත printf

ඔබට වඩාත් නවීන ඉදිකිරීම් භාවිතා කිරීමට අවශ්‍ය නම් ඔබ දෙබලක භාවිතා කළ යුතුය (නව ළමා ක්‍රියාවලියක් මඟින් එම කාර්යය සිදු කර ප්‍රති result ලය ලබා දෙනු ඇත stdout):

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

Ically තිහාසිකව , දෙබලක ප්‍රති result ල ලබා ගැනීම සඳහා ඔබට බැක්ටික්ස් භාවිතා කළ හැකිය :

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
— එෆ්. හවුරි
source
4
මෙම +=ක්රියාකරු ද වඩා වේගවත් වේ $a="$a$b"තේරුමක් කුමන මගේ පරීක්ෂණ .. දී.
— මතෙ
7
මෙම පිළිතුර නියමයි, නමුත් මම හිතන්නේ එය var=${var}.shවෙනත් පිළිතුරු වලින් ආදර්ශය මග හැරී ඇති අතර එය ඉතා ප්‍රයෝජනවත් වේ.
— genorama
1
ය bashසමග එකම ෂෙල් +=ක්රියාකරු? මට එය අතේ ගෙන යා හැකි දැයි බැලීමට අවශ්‍යයි
— ඩැෂි
1
@ ඩැෂි අංක. මම නිසැකවම +=ක්‍රියාකරු සමඟ ඇති එකම කවචය නොවේ , නමුත් මේ සියලු ක්‍රම බාෂිස්ම් වේ , එබැවින් අතේ ගෙන යා නොහැක! වැරදි බැෂ් අනුවාදයකදී ඔබට විශේෂ දෝෂයක් පවා හමුවිය හැකිය!
— එෆ්. හවුරි
135

ඔබට මෙයද කළ හැකිය:

$ var="myscript"

$ echo $var

myscript


$ var=${var}.sh

$ echo $var

myscript.sh
— userend
source
4
විශේෂ අක්ෂර හෝ අවකාශයන් භාවිතා නොකරන අතර, ද්විත්ව උපුටා දැක්වීම්, උපුටා දැක්වීම් සහ කැරලි වරහන් නිෂ් less ල ය: var=myscript;var=$var.sh;echo $varසමාන ප්‍රති have ල ඇති කරයි (මෙම කාර්යය බාෂ්, ඩෑෂ්, කාර්යබහුල පෙට්ටිය සහ වෙනත් අය යටතේ).
— එෆ්. හවුරි
@ එෆ්. හවුරි එය පෙන්වා දීම ගැන ඔබට ස්තූතියි. නමුත් ඔබ අංකයක් එකතු කළහොත් එය ක්‍රියා නොකරනු ඇත: උදා: echo $var2නිපදවන්නේ නැතmyscript2
— පින්චියා
YnPynchia .විචල්ය නාමයෙන් තිත් නීති විරෝධී නිසා මෙම කාර්යය . වෙනත් නම් echo ${var}2හෝ මගේ පිළිතුර
— එෆ්. හවුරි
120 
bla=hello
laber=kthx
echo "${bla}ohai${laber}bye"

ප්‍රතිදානය කරයි

helloohaikthxbye

$blaohai විචල්‍යයක් සොයාගත නොහැකි දෝෂයකට තුඩු දෙන විට මෙය ප්‍රයෝජනවත් වේ . නැතහොත් ඔබේ නූල් වල අවකාශ හෝ වෙනත් විශේෂ අක්ෂර තිබේ නම්. "${foo}"ඔබ එයට දැමූ ඕනෑම දෙයක් නිසි ලෙස ගැලවී යයි.

— orkoden
source
3
වැඩ කරන්නේ නැහැ. මට "backupstorefolder: විධානය හමු නොවීය" යන්න "backupstorefolder" යනු විචල්‍යයක නමකි.
— සියාන් චෝයි
7
මෙය සින්ටැක්ස් තරමක් ඉස්මතු කිරීමට උපකාරී වන අතර මිනිස් අවිනිශ්චිතතාවයන් ඉවත් කරයි.
— රේ ෆොස්
44 
foo="Hello "
foo="$foo World"

     

— විනෝත්කර්
source
10
ෂෙල් ස්ක්‍රිප්ටින් සඳහා වඩාත්ම ප්‍රයෝජනවත් පිළිතුර මෙයයි. සමාන ලකුණට පෙර සහ පසු මට ඉඩක් තිබූ නිසා මම අවසාන මිනිත්තු 30 සොයා ගත්තා !!
— ස්ටෙෆාන්
8
foo = "$ o foo} World"
— XXL
@XXL නිසැකවම මම වර්‍ග භාවිතා කර var ගේ නම සංකේතවත් කරමි. ඉහළින්ම නිර්දේශිතයි
— සර්ජියෝ ඒ.
33

මම ගැටලුව විසඳන ආකාරය සාධාරණයි

$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
— ක්‍රිස් ස්මිත්
source
1
... එබැවින් ${a}\ Worldනිෂ්පාදනය කරයිHello World
— සේවියර්ස්ටුව්
මෙය මා පුදුමයට පත් කරයි; ( විධානයක් ලෙස ක්‍රියාත්මක වීමට උත්සාහ කරන ) c=$a$bඑකම දේ කිරීමට මම මෙහි බලාපොරොත්තු වන්නෙමි . මම හිතන්නේ ඒ කියන්නේ විචල්යයන් පුළුල් වීමට පෙර පැවරුම විග්‍රහ කර ඇති බවයි ..c=$a WorldWorld
— mwfearnley
31

බොහෝ පිළිතුරු ගැන කතා කරන දේ පිළිබඳ සංක්ෂිප්ත සාරාංශයක් මෙන්න.

අපි විචල්යයන් දෙකක් ඇති අතර $ 1 'එකක්' ලෙස සකසා ඇත:

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 පේළි වල දැකිය හැකි පරිදි {}, විචල්යයක් ෂෙල් විචල්ය නාමයේ වලංගු පළමු අක්‍ෂරයක් වන අකාරාදියකින් හෝ අවධාරනය කර ඇති අක්ෂරයකින් ආරම්භ වන නූලක් සමඟ සංයුක්ත වේ නම් මිස අවශ්ය නොවේ.

මෙයද බලන්න:

— codeforester
source
2
ඔබ කාර්ය සාධනය ගැන සැලකිලිමත් වන්නේ නම්, මගේ පිළිතුරෙහි විශ්ලේෂණයක් බලන්න stackoverflow.com/a/47878161/117471
— බ un නෝ බ්‍රොනොස්කි
29 
$ a=hip
$ b=hop
$ ab=$a$b
$ echo $ab
hiphop
$ echo $a$b
hiphop
— bcosca
source
20

තවත් ප්‍රවේශයක් ...

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

... තව එකක්.

> H="Hello "
> U=$H"universe."
> echo $U
Hello universe.
— අක්සෙලි පලන්
source
1
ඒක තමයි මම කළේ, අනෙක් පිළිතුරු වලට වඩා එය ඉතා සරල හා forward ජුව ඉදිරියට යන බව මට පෙනී ගියේය. වැඩිපුරම ඡන්දය දුන් පිළිතුරු වලින් කිසිවෙකු මෙම විකල්පය පෙන්වා දීමට හේතුවක් තිබේද?
— quimnuss
1
@quimnuss OP ප්‍රශ්නයේදී භාවිතා කරන ලද නූල් නොගැලපීම හොඳ හේතුවක් විය හැකිය.
— jlliagre
20

ඔබට අවධාරනය කිරීමක් වැනි යමක් එකතු කිරීමට අවශ්‍ය නම්, පැන යාම (\) භාවිතා කරන්න

FILEPATH=/opt/myfile

මෙය ක්‍රියාත්මක නොවේ : 

echo $FILEPATH_$DATEX

මෙය හොඳින් ක්‍රියාත්මක වේ: 

echo $FILEPATH\\_$DATEX
— පරිශීලක 2800471
source
11
හෝ විකල්පයක් ලෙස, $ {FILEPATH} _ $ DATEX. විචල්ය නාමයේ මායිම් දැක්වීමට {} භාවිතා වේ. අවධාරනය විචල්ය නාමවල නෛතික චරිතයක් වන නිසා මෙය අනුමත වේ, එබැවින් ඔබේ ස්නිපෙට් බෑෂ් තුළ ඇත්ත වශයෙන්ම FILEPATH_ විසඳීමට උත්සාහ කරයි, $ FILEPATH
— Nik O'Lai
1
මට නම් එක් විචල්‍යයක් එනම් $ var1 සහ නියතයක් ඇත, එබැවින් echo $ var1_costant_traling_part මා වෙනුවෙන් ක්‍රියා කරයි
— YouAreAwesome
2
මම හිතන්නේ කෙනෙකුට පැන echo $a\_$bයෑමට අවශ්‍ය වන්නේ එක් පසුබෑමක් පමණයි . නික් ඕ ලයිගේ අදහස් දැක්වීමේදී ඉඟි කර ඇති පරිදි අවධාරනය සාමාන්‍ය චරිතයකි. සුදු අවකාශයන් හැසිරවීම නූල්, දෝංකාරය සහ සංක්ෂිප්තකරණය සඳහා වඩාත් සංවේදී වේ --- යමෙකුට \ මෙම ත්‍රෙඩ් එක හොඳින් භාවිතා කර කියවිය හැකිය .
— සේවියර්ස්ටුව්
16

උද්ධෘත ලකුණු සහිත සරලම ක්‍රමය:

B=Bar
b=bar
var="$B""$b""a"
echo "Hello ""$var"
— betontalpfa
source
1
උද්ධෘත ලකුණු වැඩිය, IMHO. var=$B$b"a"; echo Hello\ $varමම විශ්වාස කරනවා
— සේවියර්ස්ටුව්
උපුටා දැක්වීමේ ලකුණු සියල්ලම භාවිතා කිරීමට මම යෝජනා කරමි, හේතුව ඔබට එය අතපසු කළ නොහැකි සෑම තැනකම තැබුවහොත් ඔබට සිතීමට අවශ්‍ය නැත.
— betontalpfa
15

උපුටා දැක්වීම් නොමැතිව ඔබට සමපාත විය හැකිය. මෙන්න උදාහරණයක්:

$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
— මරියානා සොෆර්
source
1
පළමු කොටසෙහි වාක්‍ය ඛණ්ඩය අවුල් සහගතය. මෙම ලකුණු වලින් අදහස් කරන්නේ කුමක්ද?
— සේවියර්ස්ටුව්
15

+ = ක්‍රියාකරුට දැන් අවසර දී ඇතත්, එය 2004 දී Bash 3.1 හි හඳුන්වා දී ඇත.

පැරණි බාෂ් අනුවාද වල මෙම ක්‍රියාකරු භාවිතා කරන ඕනෑම ස්ක්‍රිප්ටයක් ඔබ වාසනාවන්ත නම් "විධානයක් හමු නොවීය" හෝ "අනපේක්ෂිත ටෝකනය අසල සින්ටැක්ස් දෝෂයක්" සමඟ අසමත් වනු ඇත.

පසුගාමී ගැළපුම ගැන සැලකිලිමත් වන අය සඳහා, තෝරාගත් පිළිතුරෙහි සඳහන් කර ඇති ආකාරයට පැරණි සම්මත බාෂ් සංයුක්ත ක්‍රම සමඟ බැඳී සිටින්න:

foo="Hello"
foo="$foo World"
echo $foo
> Hello World
— ලුවී-ෆීලික්ස්
source
1
මෙය පෙන්වා දීමට ස්තූතියි, මෙය ක්‍රියාත්මක වීමට අවශ්‍ය අනුවාදය කුමක්දැයි මම සොයමින් සිටියෙමි.
— රෝ ෆි
14

${}විචල්ය නූල් විස්තාරණය කිරීම සඳහා කැරලි වරහන් භාවිතා කිරීමට මම කැමැත්තෙමි :

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

අඛණ්ඩ නූල් භාවිතයට කැරලි වරහන් ගැලපේ:

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

එසේ නොමැතිනම් භාවිතා කිරීම සාර්ථක foo = "$fooWorld"නොවනු ඇත.

— නික් ට්සායි
source
8

ඔබ කිරීමට උත්සාහ කරන්නේ නූලක් පේළි කිහිපයකට බෙදීම නම්, ඔබට බැක්ස්ලෑෂ් භාවිතා කළ හැකිය:

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

අතර එක් ඉඩක් සමඟ:

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

මෙය එක් ඉඩක් පමණක් එක් කරයි:

$ a="hello \
>      world"
$ echo $a
hello world
— jcarballo
source
මම බිය වන්නේ මෙය අදහස් නොකෙරේ
— installlero
7

ආරක්ෂිත මාර්ගය:

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

අවකාශයන් අඩංගු නූල් විධානයෙහි කොටසක් බවට පත්විය හැකිය, මෙම දෝෂ මඟහරවා ගැනීම සඳහා "$ XXX" සහ "$ {XXX}" භාවිතා කරන්න.

+ = ගැන වෙනත් පිළිතුරක් බලන්න

— බොඩන්
source
විධානයක් ලෙස කියවන අවකාශයක් සහිත නූල් වල ලක්ෂ්‍යය අර්ථ දැක්වීමේ මොහොතේ පෙන්වයි. එබැවින් d=DD DDලබා දෙනු ඇත DD: command not found--- එය අවසාන ඩීඩී ය, ඒ වෙනුවට සොයාගත නොහැකි ඩී. සියළුම ඔපෙරන්ඩ් නිසි ලෙස සංයුති කර ඇති අතර දැනටමත් අවශ්‍ය අවකාශයන් තිබේ නම්, ඔබට s=${a}${b}${c}${d}; echo $sඅඩු මිල ගණන් සහිතව සමපාත විය හැකිය . \ මෙම ගැටළු මඟහරවා ගැනීම සඳහා ඔබට (පැන ගිය සුදු අවකාශය) භාවිතා කළ හැකිය --- d=echo\ echoකිසිදු ප්‍රතිරාවය කිරීමක් d=echo echoසිදු නොකරනු ඇත.
— සේවියර්ස්ටුව්
7

ඔබ සැලකිලිමත් විය යුතු එක් විශේෂ අවස්ථාවක් තිබේ:

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

ඔබට අවශ්‍ය පරිදි ප්‍රතිදානය කරනු ඇත "daniel"san, නැත danielsan. මෙම අවස්ථාවේදී ඔබ ඒ වෙනුවට කළ යුත්තේ:

user=daniel
cat > output.file << EOF
${user}san
EOF
— diogovk
source
6 
a="Hello,"
a=$a" World!"
echo $a

ඔබ නූල් දෙකක් සමපාත කරන්නේ එලෙසයි.

— CodeNinjaPI
source
1
මෙය ක්‍රියාත්මක වන නමුත් විචල්‍ය අන්තර් මැදිහත්වීම ආරක්‍ෂා කර නොමැති නිසා සමහර විට එය අනපේක්ෂිත ප්‍රති results ල ලබා දෙනු ඇත. මේ අනුව, සියලු භාවිත අවස්ථා සඳහා ඔබට මෙම පෝරමය මත විශ්වාසය තැබිය නොහැක.
— ඇන්තනි රට්ලෙජ්
5

එය " World"මුල් නූලට එකතු කිරීමේ ඔබේ උදාහරණය නම්, එය එසේ විය හැකිය:

#!/bin/bash

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

ප්‍රතිදානය:

Hello World
— අවිධිමත් බව
source
5 
var1='hello'
var2='world'
var3=$var1" "$var2 
echo $var3
— හැරී
source
2
එසේම var3=$var1\ $var2එකම බලපෑමක් ඇත
— XavierStuvw
5

කාර්ය සාධනය පිළිබඳ හ o ක් ඇති නමුත් දත්ත ඉදිරිපත් නොකෙරේ. සරල පරීක්ෂණයක් යෝජනා කිරීමට මට ඉඩ දෙන්න.

(සටහන: dateමැකෝස් මත නැනෝ තත්පර ලබා නොදේ, එබැවින් මෙය ලිනක්ස් මත කළ යුතුය.)

මම අන්තර්ගතය සමඟ GitHub හි append_test.sh නිර්මාණය කර ඇත:

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

දෝෂ වලින් පෙනී යන්නේ එය බිඳ වැටීමට පෙර මගේ බෑෂ් 335.54432 MB දක්වා ඉහළ ගොස් ඇති බවයි . ඔබ වෙනස් විය හැකි කේතය වඩා කැටිති ප්රස්තාරය සහ අසාර්ථකත්වය ස්ථානය ලබා ගැනීමට නියත appending කිරීම දත්ත දෙගුණ සිට. නමුත් මම හිතන්නේ මෙය ඔබ සැලකිලිමත්ද යන්න තීරණය කිරීමට ප්‍රමාණවත් තොරතුරු ලබා දිය යුතුය. පුද්ගලිකව, 100 MB ට වඩා අඩු නැත. ඔබගේ සැතපුම් ගණන වෙනස් විය හැකිය.

— බ un නෝ බ්‍රොනොස්කි
source
සිත්ගන්නාසුළුයි! සලකා බලන්න: join <(LANG=C bash -c 'a="a" c=1 last=${EPOCHREALTIME//.};while :;do a+=$a;now=${EPOCHREALTIME//.};echo $((c++)) ${#a} $((now-last));last=$now;done') <(LANG=C bash -c 'a="a" c=1 last=${EPOCHREALTIME//.};while :;do a=$a$a;now=${EPOCHREALTIME//.};echo $((c++)) ${#a} $((now-last));last=$now;done')|sed -ue '1icnt strlen a+=$a a=$a$a' -e 's/^\([0-9]\+\) \([0-9]\+\) \([0-9]\+\) \2/\1 \2 \3/' | xargs printf "%4s %11s %9s %9s\n"(host
— ලදායී
5

මට ලැයිස්තුවකින් නූලක් සෑදීමට අවශ්‍ය විය. ඒ සඳහා පිළිතුරක් සොයාගත නොහැකි වූ නිසා මම එය මෙහි පළ කරමි. මෙන්න මම කළ දේ:

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

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

echo ${string}

ඉන්පසු මට පහත ප්‍රතිදානය ලැබේ:

1 2 3 4 5
— simibac
source
4

විශේෂ ක්රියාකරු තිබියදීත් +=, සංයුක්ත කිරීම සඳහා, යාමට සරල ක්රමයක් තිබේ:

foo='Hello'
foo=$foo' World'
echo $foo

ඇතුළත විචල්‍යයන් අර්ථ නිරූපණය කිරීම සඳහා ද්විත්ව උපුටා දැක්වීම් අමතර ගණනය කිරීමේ කාලයක් ගතවේ. හැකි නම් එය වළක්වා ගන්න.

— ටයිස්
source
3

මෙය ක්‍රියාත්මක නොවන බව සලකන්න

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

$ foo අතහැර දමා ඔබ සමඟ යන විට:

PREFIX_WORLD

නමුත් මෙය ක්‍රියාත්මක වනු ඇත:

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

නිවැරදි ප්‍රතිදානය සමඟ ඔබව තබන්න:

PREFIX_HELLO_WORLD

— ඩී.එස්
source
8
මෙය සිදු වන්නේ අවධාරනය වන්නේ විචල්‍ය නම් වල වලංගු අක්‍ෂරයයි, එබැවින් bash foo_ විචල්යයක් ලෙස දකී. නිශ්චිත var නාම මායිම් ගැන කීමට අවශ්‍ය වූ විට, කැරලි වරහන් භාවිතා කළ හැකිය: PREFIX _ {o foo} _ $ bar
— Nik O'Lai
2

AWK හරහා එක මෙන්න :

$ foo="Hello"
$ foo=$(awk -v var=$foo 'BEGIN{print var" World"}')
$ echo $foo
Hello World
— අවිනාශ් රාජ්
source
1
හොඳයි, නමුත් මම හිතන්නේ මට පයිතන් භාවිතා කිරීමෙන් වඩාත් නිරවද්‍යතාව ලබා ගත හැකිය!
— ටෙක්නෝ
1

පහසු වූ විට මම එය කරන්නේ: පේළිගත කිරීමේ විධානයක් භාවිතා කරන්න!

echo "The current time is `date`"
echo "Current User: `echo $USER`"
— මාටි
source
1
1 වන රේඛාව මත, ඔබ අතහැර හැකි දෙබලක : භාවිතා date "+The current time is %a %b %d %Y +%T"කරනවා වෙනුවට, echo ...$(date). මෑත බැෂ් යටතේ, ඔබට ලිවිය හැකිය : printf "The current time is %(%a %b %d %Y +%T)T\n" -1.
— එෆ්. හවුරි
1

මගේ මතය අනුව, නූල් දෙකක් සංයුක්ත කිරීමට ඇති සරලම ක්‍රමය නම් එය ඔබ වෙනුවෙන් කරන ශ්‍රිතයක් ලිවීමයි, ඉන්පසු එම ශ්‍රිතය භාවිතා කරන්න.

function concat ()
{
    prefix=$1
    suffix=$2

    echo "${prefix}${suffix}"
}

foo="Super"
bar="man"

concat $foo $bar   # Superman

alien=$(concat $foo $bar)

echo $alien        # Superman
— ඇන්තනි රට්ලෙජ්
source
-1

මම ඉක්මන් කාර්යයක් කිරීමට කැමතියි.

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

echo $(combo 'foo''bar')

බළලෙකුගේ සමට තවත් ක්‍රමයක්. කාර්යයන් සමඟ මෙම කාලය: ඩී

— කොමාටෝස්ට්
source
ශ්‍රිතයක් ඇමතීම, එයද උප කුලකයක, සරල කොන්ක්‍රීට් සඳහා අධික ලෙස මරා දැමීමකි.
— codeforester
-1

මම තවමත් PHP ගැන නොදනිමි, නමුත් මෙය ක්‍රියා කරන්නේ ලිනක්ස් බෑෂ් හි ය. ඔබට එය විචල්‍යයකට බලපෑම් කිරීමට අවශ්‍ය නැතිනම්, ඔබට මෙය උත්සාහ කළ හැකිය:

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

>Hello World!

ඔබට 'හෙලෝ' හෝ '!' වෙනුවට වෙනත් විචල්‍යයක් තැබිය හැකිය. ඔබට තවත් නූල් එකට සම්බන්ධ කළ හැකිය.

— අයිමන් බූබ්ලේ
source
2
සරල සංක්ෂිප්තයක් කිරීම සඳහා උපසිරැසියක් භාවිතා කිරීම මිල අධිකය!
— codeforester
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.