bash - बैश में स्ट्रिंग चर को कैसे जोड़ें




shell syntax (19)

पहले बैश

चूंकि यह प्रश्न विशेष रूप से Bash लिए खड़ा है, इसलिए उत्तर का मेरा पहला भाग यह सही तरीके से करने के विभिन्न तरीकों को प्रस्तुत करेगा:

+= : चर में संलग्न करें

वाक्यविन्यास += विभिन्न तरीकों से उपयोग किया जा सकता है:

स्ट्रिंग var+=... संलग्न करें 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

हम्म .. यह एक बग नहीं है, लेकिन एक सुविधा ... विकसित करने की कोशिश करने के लिए बैश को रोकने के लिए !" , आप यह कर सकते हैं:

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

या हम एक तर्क प्रारूप स्ट्रिंग का उपयोग कर सकते हैं जिसे कई तर्क सबमिट किए जाएंगे ...

ध्यान दें कि हमारा अभी भी एक सरणी है! केवल पहला तत्व बदल गया है!

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

बैश के तहत, जब आप इंडेक्स निर्दिष्ट किए बिना एक चर नाम का उपयोग करते हैं, तो आप हमेशा पहले तत्व को संबोधित करते हैं!

तो हमारे सात फ़ील्ड सरणी को पुनः प्राप्त करने के लिए, हमें केवल 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

नोटा: डबल-कोट्स का उपयोग स्ट्रिंग्स, tabulations और / या newlines स्ट्रिंग्स में हेरफेर करने के लिए उपयोगी हो सकता newlines

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

अब शैल

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

PHP में, तारों को एक साथ समेकित किया जाता है:

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

यहां, $foo "हैलो वर्ल्ड" बन जाता है।

यह बैश में कैसे पूरा किया जाता है?


आप उद्धरण के बिना concatenate कर सकते हैं। यहाँ एक उदाहरण है:

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

यह अंतिम कथन "ओपन सिस्टम" प्रिंट करेगा (उद्धरण के बिना)।

यह एक बैश स्क्रिप्ट का एक उदाहरण है:

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

आप भी यह कर सकते हैं:

$ var="myscript"

$ echo $var

myscript


$ var=${var}.sh

$ echo $var

myscript.sh

उद्धरण चिह्नों के साथ सबसे आसान तरीका:

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

जिस तरह से मैं समस्या हल करता हूं बस है

$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

ध्यान दें कि यह काम नहीं करेगा

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

क्योंकि ऐसा लगता है कि $ foo ड्रॉप और आपको छोड़ देता है:

PREFIX_WORLD

लेकिन यह काम करेगा:

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

और आपको सही आउटपुट के साथ छोड़ देता है:

PREFIX_HELLO_WORLD


प्रदर्शन के बारे में आवाज उठाई गई चिंताएं हैं, लेकिन कोई डेटा पेश नहीं किया जाता है। मुझे एक सरल परीक्षण का सुझाव देते हैं।

(नोट: मैकोज़ पर date नैनोसेकंड की पेशकश नहीं करता है, इसलिए यह लिनक्स पर किया जाना चाहिए।)

मैंने सामग्री के साथ गिटहब पर 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 एमबी तक पहुंच गया था। आप अधिक दानेदार ग्राफ और विफलता बिंदु प्राप्त करने के लिए स्थिर को जोड़ने के लिए डेटा को दोगुना करने से कोड को बदल सकते हैं। लेकिन मुझे लगता है कि यह आपको यह तय करने के लिए पर्याप्त जानकारी देनी चाहिए कि आप परवाह है या नहीं। व्यक्तिगत रूप से, 100 एमबी से नीचे मैं नहीं करता हूं। आपकी माइलेज भिन्न हो सकती है।


फिर भी एक और दृष्टिकोण ...

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

... और अभी तक एक और एक।

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

मैं एक त्वरित काम करने की तरह।

#! /bin/sh -f
function combo() {
    echo [email protected]
}

echo $(combo 'foo''bar')

एक बिल्ली को त्वचा के लिए एक और तरीका है। इस बार कार्यों के साथ: डी


मैं एक सूची से एक स्ट्रिंग बनाना चाहता था। इसके लिए कोई जवाब नहीं मिला, इसलिए मैं इसे यहां पोस्ट करता हूं। मैंने जो किया था यह रहा:

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

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

echo ${string}

और फिर मुझे निम्न आउटपुट मिलता है:

1 2 3 4 5

यदि आप अंडरस्कोर की तरह कुछ जोड़ना चाहते हैं, तो बचें (\)

FILEPATH=/opt/myfile

यह काम नहीं करता है:

echo $FILEPATH_$DATEX

यह ठीक काम करता है:

echo $FILEPATH\\_$DATEX

यदि आप एक स्ट्रिंग को कई लाइनों में विभाजित करने की कोशिश कर रहे हैं, तो आप बैकस्लैश का उपयोग कर सकते हैं:

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

बीच में एक जगह के साथ:

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

यह भी बीच में केवल एक स्थान जोड़ता है:

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

यहां एक संक्षिप्त सारांश दिया गया है कि अधिकांश उत्तर किस बारे में बात कर रहे हैं।

मान लें कि हमारे पास दो चर हैं:

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

कुछ नोट्स:

  • डबल कोट्स में असाइनमेंट के आरएचएस को संलग्न करना आम तौर पर एक अच्छा अभ्यास है, हालांकि यह कई मामलों में काफी वैकल्पिक है
  • += एक प्रदर्शन दृष्टिकोण से बेहतर है यदि छोटे वेतन वृद्धि में विशेष रूप से एक लूप में एक बड़ी स्ट्रिंग का निर्माण किया जा रहा है
  • अपने विस्तार को असंबद्ध करने के लिए वेरिएबल नामों के चारों ओर {} उपयोग करें {} ऊपर की तालिका में पंक्ति 2 में)

यह भी देखें:


यहां तक ​​कि अगर + = ऑपरेटर की अनुमति है, तो इसे 2004 में बैश 3.1 में पेश किया गया है।

पुराने बैश संस्करणों पर इस ऑपरेटर का उपयोग करने वाली कोई भी स्क्रिप्ट "भाग्य नहीं मिली" त्रुटि के साथ विफल हो जाएगी यदि आप भाग्यशाली हैं, या "अप्रत्याशित टोकन के पास वाक्यविन्यास त्रुटि"।

उन लोगों के लिए जो पिछड़े संगतता की परवाह करते हैं, पुराने मानक बैश concatenation विधियों के साथ चिपके हुए, जैसे चुने गए उत्तर में उल्लिखित:

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

सुविधाजनक होने पर मैं इसे इस तरह करता हूं: इनलाइन कमांड का उपयोग करें!

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

AWK माध्यम से यहां एक है:

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

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

उत्पादन होगा

helloohaikthxbye

यह तब उपयोगी होता है जब $blaohai एक चर को ले जाता है त्रुटि नहीं मिली। या यदि आपके पास अपने तारों में रिक्त स्थान या अन्य विशेष वर्ण हैं। "${foo}" आपके द्वारा डाले गए कुछ भी ठीक से बच निकलता है।


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


var1='hello'
var2='world'
var3=$var1" "$var2 
echo $var3




string-concatenation