SSD Nodes Learn Hosting plans →
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-10-30

Bash command substitution: $() மற்றும் backticks வேறுபாடு

Bash-ல் $() மற்றும் backticks பயன்பாட்டின் முக்கிய வேறுபாடுகளை அறியுங்கள். Subshell-ல் cd மற்றும் மாறிகள் ஏன் செயல்படுவதில்லை மற்றும் nested command சிக்கல்களைத் தவிர்க்கும் முறைகள்.

Verified Every command ran end-to-end on a fresh Ubuntu 24.04 server, August 4, 2026.

Bash command substitution எதைச் செய்கிறது

Bash command substitution என்பது $(command)-ஐ, அந்த command standard output-ல் அச்சிட்ட உரையைக் கொண்டு மாற்றுகிறது. Backticks-ஐப் பயன்படுத்தும் பழைய முறையும் இதே வேலையைத்தான் செய்கிறது. பயனர்களுக்கு ஆச்சரியத்தை ஏற்படுத்தும் அனைத்து விஷயங்களும் இரண்டு உண்மைகளிலிருந்து வருகின்றன: அந்த command subshell எனப்படும் தனி process-ல் இயங்குகிறது, மேலும் அதன் output-ன் இறுதியில் உள்ள ஒவ்வொரு newline-ம் நீக்கப்படுகிறது.

mkdir -p /tmp/subst-demo
cd /tmp/subst-demo
printf 'alpha\nbeta\ngamma\n' > three.txt
count=$(wc -l < three.txt)
echo "$count"
3

இதுதான் இந்த அம்சத்தின் முழுமையான செயல்பாடு. wc -l என்பது 3-ஐ ஒரு newline-உடன் அச்சிட்டது, அந்த newline நீக்கப்பட்டு, count-ல் நீங்கள் விரும்பிய அந்த ஒரு character மட்டும் சேமிக்கப்படுகிறது. wc -l < three.txt ஒரு வெறும் எண்ணை மட்டும் அச்சிடுகிறது என்பதைக் கவனிக்கவும், ஏனெனில் standard input-ஐ வாசிக்கும் GNU wc-க்கு அச்சிடுவதற்கு filename எதுவும் இல்லை. அதற்குப் பதிலாக wc -l three.txt என்று எழுதினால், நீங்கள் 3 three.txt-ஐப் பெறுவீர்கள்; இது ஒரு மாறுபட்ட string ஆகும், மேலும் இது பிற்காலத்தில் கணக்கீடுகள் (arithmetic) தோல்வியடைவதற்கு ஒரு பொதுவான காரணமாகிறது.

இந்த வழிகாட்டியின் மீதமுள்ள பகுதி, யாரும் எதிர்பாராத செயல்பாடுகளைப் பற்றியது. ஏனெனில், subshell என்பது ஒரு தனி process, மேலும் ஒரு தனி process-ஆல் நீங்கள் தட்டச்சு செய்யும் shell-ஐ மாற்ற முடியாது.

$() பயன்படுத்துங்கள், backticks பயன்படுத்துவதை நிறுத்துங்கள்

இரண்டு வடிவங்களும் செல்லுபடியாகும். $() என்பது POSIX தரநிலையில் உள்ளது, எனவே dash, ash மற்றும் busybox sh ஆகிய அனைத்தும் இதை ஆதரிக்கின்றன. backticks பயன்படுத்துவதற்கு எந்தவொரு போர்ட்டபிலிட்டி (portability) காரணமும் இல்லை, ஆனால் அதைப் பயன்படுத்தக்கூடாது என்பதற்கு இரண்டு உறுதியான காரணங்கள் உள்ளன.

Backticks-ஐ ஒன்றிற்குள் ஒன்றாக (nest) பயன்படுத்த முடியாது

echo "$(echo "$(echo hi)")"
echo "`echo `echo hi``"
hi
echo hi

இரண்டாவது வரி echo hi என்ற வார்த்தைகளை அப்படியே அச்சிட்டது. ஷெல் (shell) அடுத்ததாக வரும் backtick-ஐத் தேடுகிறது, எனவே நீங்கள் உள்ளிட்ட இரண்டாவது backtick முதல் backtick-ஐ மூடிவிட்டது. உண்மையில் இயக்கப்பட்ட கட்டளை echo ஆகும், இதற்கு எந்த வாதங்களும் (arguments) இல்லை. இது ஒரு காலியான வரியை அச்சிட்டது, அதன் newline நீக்கப்பட்டது. echo hi என்ற வார்த்தைகள் சாதாரண உரையாக விடப்பட்டன, மேலும் இறுதி backtick ஜோடி ஒரு காலியான கட்டளையை இயக்கியது.

Backticks-ஐ ஒன்றிற்குள் ஒன்றாகப் பயன்படுத்த, ஒவ்வொரு உட்புற backtick-ஐயும் escape செய்ய வேண்டும்:

echo "`echo \`echo hi\``"
hi

ஒவ்வொரு கூடுதல் நிலையும் escape செய்வதை இருமடங்காக்குகிறது. $()-க்கு இது எதவும் தேவையில்லை, ஏனெனில் பார்சர் (parser) ஒரு டெலிமீட்டர் (delimiter) எழுத்தைத் தேடுவதற்குப் பதிலாக அடைப்புக்குறிகளை (parentheses) பொருத்துகிறது.

கட்டளை இயங்குவதற்கு முன்பே Backticks உங்கள் backslashes-ஐ மாற்றுகிறது

echo "$(echo 'a\\b')"
echo "`echo 'a\\b'`"
a\\b
a\b

ஒரே உட்புற கட்டளை வெவ்வேறு வெளியீடுகளை உருவாக்கியது. Backticks-க்குள், உட்புற உரை பகுப்பாய்வு செய்யப்படுவதற்கு முன்பே ஷெல் ஒரு அடுக்கு backslash-ஐ நீக்குகிறது, எனவே ஒற்றை மேற்கோள்கள் (single quotes) எதையும் பாதுகாக்கவில்லை. $()-க்குள், அடைப்புக்குறிகளுக்கு இடையே உள்ள உரை ஒரு சாதாரண ஸ்கிரிப்டாக பகுப்பாய்வு செய்யப்படுகிறது, எனவே ஒற்றை மேற்கோள்கள் நீங்கள் எதிர்பார்ப்பது போலவே செயல்படுகின்றன. இது sed மற்றும் awk ஒன்-லைனர்களில் (one-liners) பெரும் சிக்கலை ஏற்படுத்துகிறது, அங்கு ஒரு விடுபட்ட backslash ஒரு வேலை செய்யும் பேட்டர்னை (pattern) அமைதியாக மாற்றுகிறது.

$()-க்குள் மேற்கோள் காட்டுதல் (quoting) புதியதாகத் தொடங்குகிறது, அதாவது நீங்கள் இரட்டை மேற்கோள்களை (double quotes) escape செய்யாமலேயே ஒன்றிற்குள் ஒன்றாகப் பயன்படுத்தலாம்:

path=/etc/nginx/nginx.conf
echo "$(dirname "$path")"
/etc/nginx

Backtick சமமான கட்டளைக்கு $path-ஐச் சுற்றி \" தேவைப்படுகிறது. ஒவ்வொரு escape-ம் ஒரு தவறு நடப்பதற்கான வாய்ப்பாகும்.

$() உள்ளே இருக்கும் cd ஏன் உங்கள் shell-ஐ மாற்றுவதில்லை

ஏனெனில் $(...) ஒரு புதிய process-ஐ உருவாக்குகிறது (fork). அந்த subshell உங்கள் variables மற்றும் working directory-ன் நகலைப் பெறுகிறது. அது அதன் நகலை மாற்றுகிறது, எதையாவது அச்சிடுகிறது, பிறகு வெளியேறுகிறது (exit). அந்த நகல் அதனுடன் அழிந்துவிடுகிறது.

cd /tmp/subst-demo
pwd
target=$(cd /etc && pwd)
echo "$target"
pwd
/tmp/subst-demo
/etc
/tmp/subst-demo

எதுவும் தோல்வியடையவில்லை. cd சரியாக வேலை செய்தது, மேலும் subshell-க்குள் இருந்த pwd உண்மையில் /etc-ஐ அச்சிட்டது. அந்த மாற்றம் மீண்டும் உங்கள் shell-க்கு வருவதற்கு எந்த வழியும் இல்லை, ஏனெனில் ஒரு subshell அதன் parent-க்கு வழங்கும் ஒரே விஷயங்கள் அதன் standard output மற்றும் exit status மட்டுமே.

Variable assignments-ம் இதேபோல்தான் செயல்படுகின்றன:

count=0
msg=$(count=99; echo "inside: $count")
echo "$msg"
echo "outside: $count"
inside: 99
outside: 0

இந்த bug-ன் ஒரு பதிப்பை மக்கள் அடிக்கடி சந்திக்கிறார்கள், அது substitution-ஐ விட pipeline-ஐ உள்ளடக்கியது. இதற்கும் அதே விதிதான் பொருந்தும்:

n=0
cat three.txt | while read -r line; do n=$((n+1)); done
echo "$n"
0

Pipeline-ன் ஒவ்வொரு நிலையும் அதன் சொந்த subshell-ல் இயங்குகிறது, எனவே while loop என்பது n-ன் ஒரு நகலை மட்டுமே அதிகரித்தது, பிறகு அது முடிந்துவிட்டது. Pipe-க்கு பதிலாக redirect-ஐப் பயன்படுத்தினால், அந்த loop உங்கள் shell-லேயே இயங்கும்:

n=0
while read -r line; do n=$((n+1)); done < three.txt
echo "$n"
3

Bash, pipeline-ன் கடைசி நிலையை தற்போதைய shell-லேயே shopt -s lastpipe மூலம் இயக்க முடியும், ஆனால் job control ஆஃப் செய்யப்பட்டிருக்கும்போது மட்டுமே இது சாத்தியம். Interactive shell-ல் job control இயல்பாகவே ஆன் செய்யப்பட்டிருக்கும். எனவே, redirect-ஐப் பயன்படுத்தவும்.

$() உள்ளே இருக்கும் interactive கட்டளைகளின் prompt எங்கே போனது?

ஒரு command substitution, standard output-ஐ ஒரு pipe-க்கு திருப்பிவிடும், ஆனால் standard input-ஐ மாற்றாது. ஒரு நிரல் தனது கேள்வியை standard output-ல் அச்சிட்டுவிட்டு, பதிலுக்காகக் காத்திருந்தால், அந்த கேள்வி பயனருக்குத் தெரியாது, ஆனால் நிரல் காத்திருக்கும். இதனால் terminal உறைந்து போனது போலத் தோன்றும்.

ask() { printf 'Username: '; read -r u; printf '%s\n' "$u"; }
ask
Username: deploy
deploy

முதல் வரியில் உள்ள deploy என்பது நீங்கள் தட்டச்சு செய்தது. இப்போது அதே function-ஐ ஒரு substitution-க்குள் இயக்கவும்:

v=$(ask)
deploy

நீங்கள் தட்டச்சு செய்யும் எழுத்துக்கள் மட்டுமே தெரியும், இவை நிரலால் அச்சிடப்படாமல், terminal driver-ஆல் எதிரொலிக்கப்படுகின்றன. Prompt வேறெங்கோ சென்றுவிட்டது:

echo "$v"
Username: deploy

இப்போது prompt அந்த variable-க்குள், பதிலுடன் இணைந்துவிட்டது. ஏனெனில் $() என்பது function standard output-ல் எழுதிய அனைத்தையும் பிடித்துக்கொண்டது. standard input தொடப்படாததால், உங்கள் தட்டச்சு read-ஐ அடைந்தது. "எனது script உறைந்து விடுகிறது, எதையும் அச்சிடவில்லை" என்று வரும் bug report-களின் அடையாளம் இதுதான்.

சில கருவிகள் prompt-களை standard error-க்கு அல்லது நேரடியாக /dev/tty-க்கு எழுதும், அப்போதுதான் அவை அழியாமல் இருக்கும். பல கருவிகள் அவ்வாறு செய்வதில்லை. ஒரு function-ஐ substitution-க்குள் வைத்திருக்க வேண்டியிருந்தால், அதன் prompt-ஐ நீங்களே standard error-க்கு அனுப்பவும்:

ask() { printf 'Username: ' >&2; read -r u; printf '%s\n' "$u"; }
v=$(ask)
echo "$v"
Username: deploy
deploy

Standard error பிடிக்கப்படாது, எனவே prompt உங்கள் terminal-ஐ அடையும், பதில் மட்டுமே v-க்குள் சேரும்.

$() உள்ளே ls ஏன் வித்தியாசமாகத் தெரிகிறது?

ஏனெனில் ls ஆனது file descriptor 1-ல் isatty-ஐ அழைக்கிறது, மேலும் அந்தப் பதிலைப் பொறுத்து அதன் வெளியீட்டு வடிவத்தை மாற்றுகிறது. கட்டளை வரியில் (prompt) அந்த descriptor உங்கள் terminal-ஆக இருப்பதால், ls கோப்புப் பெயர்களை வரிசையாகக் columnas-ல் பரப்புகிறது. substitution-க்குள் அது ஒரு pipe என்பதால், ls ஒரு வரிக்கு ஒரு பெயர் என்ற முறையில் மாற்றிக்கொள்கிறது.

mkdir -p /tmp/tty-demo
cd /tmp/tty-demo
touch alpha beta delta gamma
echo "$(ls)"
alpha
beta
delta
gamma

இதே சோதனையானது grep --color=auto-ல் வண்ணங்களையும் (colour), git-ல் pager-ஐயும் முடக்குகிறது. இது ஒரு வசதியாகும். இதன் பொருள், ஒரு script-ஆனது தானாகவே நிலையான, கணினி வாசிக்கக்கூடிய (machine-readable) வெளியீட்டைப் பெறுகிறது; இதற்காக நீங்கள் தனியாகக் கேட்க வேண்டியதில்லை.

இது pipelines குறித்து மக்கள் கேட்கும் ஒரு கேள்விக்கும் பதிலளிக்கிறது. கட்டளை வரியில் ls | sort மற்றும் $(ls | sort) ஆகிய இரண்டும் ஒரே வெளியீட்டைத் தருகின்றன, ஏனெனில் ls-ன் வெளியீட்டில் இரண்டு சந்தர்ப்பங்களிலும் ஒரு pipe இருந்தது. substitution-க்குள் மாறுவது pipeline-ன் கடைசி நிலை மட்டுமே. sort ஒருபோதும் terminal-ஐச் சரிபார்ப்பதில்லை, எனவே அதன் வெளியீடு மாறுவதில்லை. ஒரு pipeline-ன் இறுதியில் terminal-ஐ உணரும் (terminal-aware) கட்டளையை வைத்தால் அது மாறும்; இதனால்தான் நீங்கள் நேரடியாகச் சோதித்த ஒரு pipeline, அதை $()-க்குள் வைக்கும்போது வித்தியாசமாகச் செயல்படுகிறது.

இதிலிருந்து ஒரு எச்சரிக்கை: ls-ன் வெளியீடு வசதியாகத் தெரிந்தாலும், அதை ஒரு script-ல் parse செய்யாதீர்கள். கோப்புப் பெயர்களில் இடைவெளிகளும் (spaces) புதிய வரிகளும் (newlines) இருக்கலாம். அதற்குப் பதிலாக glob-ஐப் பயன்படுத்துங்கள், அல்லது read -d '' உடன் find -print0-ஐப் பயன்படுத்துங்கள்.

அமைதியாக மறையும் trailing newlines

Command substitution, வெளியீட்டின் இறுதியில் உள்ள அனைத்து புதிய வரிகளையும் (newlines) நீக்கிவிடும். கடைசி ஒன்றை மட்டும் அல்ல, அனைத்தையும் நீக்கும்.

cd /tmp/subst-demo
printf 'hello\n\n\n' > blanks.txt
wc -c < blanks.txt
v=$(cat blanks.txt)
printf '%s' "$v" | wc -c
8
5

இந்தக் கோப்பில் hello மற்றும் மூன்று புதிய வரிகள் உள்ளன, எனவே இது 8 bytes அளவு கொண்டது. இந்த variable-ல் hello மட்டுமே உள்ளது, எனவே இது 5 bytes அளவு கொண்டது. மூன்று bytes எந்த எச்சரிக்கையும் இன்றி மறைந்துவிட்டன.

இந்த நீக்கம் திட்டமிட்டே செய்யப்படுகிறது, இது பொதுவாக பயனுள்ளது. இதனால்தான் stamp=$(date -u +%Y%m%dT%H%M%SZ), ஒரு வரியை உடைக்காமல் பயன்படுத்தக்கூடிய filename fragment-ஐ உருவாக்குகிறது. இதனாலேயே இந்த pattern ஒரு scheduled restic backup script போன்ற இடங்களில் பாதுகாப்பானதாக உள்ளது:

stamp=$(date -u +%Y%m%dT%H%M%SZ)
printf 'backup-%s.tar.gz\n' "$stamp"
backup-20260804T031500Z.tar.gz

உங்கள் timestamp மாறுபடலாம். கோப்பின் பெயர் ஒரே வரியில் இருப்பதுதான் முக்கியம்.

இதன் குறைபாடு என்னவென்றால், ஒரு கோப்பின் துல்லியமான bytes-ஐ நகர்த்த உங்களால் $()-ஐப் பயன்படுத்த முடியாது. உங்களுக்கு trailing newlines தேவைப்பட்டால், substitution-க்குள் ஒரு sentinel character-ஐச் சேர்த்துவிட்டு, பிறகு அதை நீக்கிவிடலாம்:

v=$(cat blanks.txt; printf x)
v=${v%x}
printf '%s' "$v" | wc -c
8

x புதிய வரிகளுக்குப் பின் அமர்வதால், நீக்குவதற்கு trailing newlines எதுவும் இருக்காது. அதன் பிறகு ${v%x} அந்த sentinel-ஐ நீக்கிவிட்டு, அசல் bytes-ஐ அப்படியே விட்டுவிடும்.

தொடர்புடைய இரண்டு விவரங்கள். ஒரு முழு கோப்பை வாசிப்பதற்கு, v=$(<blanks.txt), cat-ஐ இயக்காமலேயே அதே வேலையைச் செய்கிறது, ஏனெனில் bash கோப்பைத் தானே திறக்கிறது. இதுவும் trailing newlines-ஐ அதேபோலவே நீக்கும். மேலும், here-strings எதிர் திசையில் செயல்பட்டு, நீங்கள் குறிப்பிடாத ஒரு புதிய வரியைச் சேர்க்கும்:

wc -c <<< 'abc'
4

முடிவை மேற்கோள் குறிகளுக்குள் (quote) இடவும், இல்லையெனில் bash அதை பிரித்து glob செய்யும்

மேற்கோள் காட்டப்படாத substitution, word splitting மற்றும் pathname expansion ஆகியவற்றுக்கு உட்படுத்தப்படும். மேற்கோள் காட்டப்பட்டால், இவை இரண்டுமே நடக்காது.

printf 'a b\tc\nd\n' > words.txt
echo $(cat words.txt)
echo "$(cat words.txt)"
a b c d
a b	c
d

மேற்கோள் காட்டப்படாதபோது, IFS-ல் உள்ள எழுத்துகளை வைத்து bash வெளியீட்டைப் பிரிக்கும்; இயல்பாக இவை space, tab மற்றும் newline ஆகும். பின்னர் echo அந்த நான்கு துண்டுகளையும் ஒற்றை space மூலம் இணைக்கும். மேற்கோள் காட்டப்பட்டால், tab மற்றும் உள்ளமைக்கப்பட்ட newline மாறாமல், உரை ஒரே சொல்லாகக் கிடைக்கும்.

Globbing என்பது இதில் ஆபத்தான பாதியாகும்:

mkdir -p /tmp/glob-demo
cd /tmp/glob-demo
touch one.txt two.txt
printf '*\n' > pattern.txt
p=$(cat pattern.txt)
echo $p
echo "$p"
one.txt pattern.txt two.txt
*

Assignment-ல் word splitting அல்லது globbing நடக்காது என்பதால், அந்த assignment பாதுகாப்பானது. பாதிப்பு echo $p-ல் தான் ஏற்படுகிறது; அங்கு * தற்போதைய கோப்பகத்தில் (current directory) விரிவாக்கப்படுகிறது (expand). ஒரு config கோப்பிலிருந்து pattern-ஐப் படிக்கும் script, மேற்கோள் குறிகளைத் தவிர்க்கும்போது, அது காணும் அனைத்து கோப்புகளிலும் தேவையற்ற செயல்களைச் செய்யும். ஒவ்வொரு expansion-ஐயும் மேற்கோள் குறிகளுக்குள் இடுங்கள், இந்த வகை பிழைகள் முழுமையாக நீங்கிவிடும். உங்களுக்குத் தேவைப்படும்போது மட்டுமே மேற்கோள் குறிகளைத் தவிர்க்கவும், ஆனால் அது அரிதானது.

local x=$(cmd) எப்போதும் ஏன் 0-ஐத் திருப்பி அளிக்கிறது?

ஏனெனில் local என்பது ஒரு கட்டளை (command), மேலும் $? என்பது அதற்குள் இருந்த substitution-ன் நிலையை அல்ல, மாறாக local-ன் நிலையைத்தான் தெரிவிக்கிறது.

check_bad() { local out=$(false); echo "status: $?"; }
check_bad

local x=$(false)
echo $?

status: 0

false 1-ஐத் திருப்பி அளித்து வெளியேறியது, local மாறியை (variable) அறிவிப்பதில் வெற்றி பெற்றது, எனவே அந்த 1 நிராகரிக்கப்பட்டது. declare, export, typeset மற்றும் readonly ஆகிய அனைத்தும் இதே விதமாகவே செயல்படுகின்றன. set -e-ம் இதைத் தடுக்காது, ஏனெனில் shell-ன் பார்வையில் எந்தத் தவறும் நடக்கவில்லை.

அறிவிப்பையும் (declaration) மதிப்பளிப்பையும் (assignment) தனித்தனியாகப் பிரிக்கவும்:

check_good() { local out; out=$(false); echo "status: $?"; }
check_good

local x
x=$(false)

status: 1

மேல் மட்டத்தில் (top level) செய்யப்படும் ஒரு சாதாரண மதிப்பளிப்பு, அதன் கடைசி command substitution-ன் நிலையை ஏற்கனவே தெரிவித்துவிடும்:

out=$(exit 3)
echo $?

x=$(false)
echo $?

3

இது systemd service மற்றும் timer-ன் கீழ் இயங்கும் health check-களில் மிக முக்கியமானது. ஏனெனில், மறைக்கப்பட்ட exit code-ஆல், அந்தப் பணி நடக்காமலேயே, ஒவ்வொரு முறையும் unit வெற்றி பெற்றதாகவே காட்டும்.

உங்களுக்கு உண்மையில் தேவைப்படும் in-shell மாற்றுகள்

பெரும்பாலானோர் $(...)-ஐ நாடுகிறார்கள், ஏனெனில் அவர்களுக்கு தரவு ஒரு variable-ல் தேவைப்படுகிறது. பெரும்பாலும் அவர்களுக்குத் தேவைப்படுவது capture அல்ல, input ஆகும். இந்த நான்கு வடிவங்களும் உங்கள் தற்போதைய shell-ல் state-ஐ அப்படியே வைத்திருக்கும்.

loop-ல் ஒரு redirect

cd /tmp/subst-demo
while read -r line; do printf 'got: %s\n' "$line"; done < three.txt
got: alpha
got: beta
got: gamma

input-க்காக எந்த process-ம் உருவாக்கப்படுவதில்லை, எனவே loop body எதை அமைத்தாலும் அது loop முடிந்த பிறகும் நீடிக்கும்.

Process substitution

while read -r line; do printf 'got: %s\n' "$line"; done < <(sort -r three.txt)
got: gamma
got: beta
got: alpha

<(command) உங்களுக்கு ஒரு path-ஐ வழங்குகிறது, இது /dev/fd/63 போன்றது, இது command-ன் output-ஐ வாசிக்கும். அந்த command அதன் சொந்த process-ல் இயங்கும். while loop அவ்வாறு இயங்காது, அதுவே இதன் முக்கிய நோக்கமாகும். < <(-ல் உள்ள இடைவெளி (space) அவசியம்: <<( என்பது here-document-ன் தொடக்கமாகக் கருதப்படும், அது parse ஆகாது. Process substitution என்பது bash-ன் ஒரு அம்சம், எனவே Ubuntu அல்லது Debian-ல் #!/bin/sh கொண்ட script dash-ன் கீழ் இயங்கும் மற்றும் அதில் தோல்வியடையும். #!/bin/bash-ஐப் பயன்படுத்தவும்.

Here-strings

read -r first rest <<< 'alpha beta gamma'
echo "$first"
echo "$rest"
alpha
beta gamma

<<< ஒரு string-ஐ command-ன் standard input-க்கு வழங்குகிறது. read உங்கள் shell-ல் இயங்குகிறது, எனவே இரண்டு variable-களும் நீங்கள் பயன்படுத்தக்கூடிய இடத்தில் அமைக்கப்படுகின்றன. read -r a b <<< "$(some-command)" என்பது ஒரு வரி output-லிருந்து இரண்டு புலங்களை (fields) எடுப்பதற்கான சாதாரண வழியாகும்.

முழு கோப்புகளுக்கான mapfile

mapfile -t lines < three.txt
echo "${#lines[@]}"
echo "${lines[1]}"
3
beta

mapfile, இது readarray என்றும் அழைக்கப்படுகிறது, ஒரு கோப்பை தற்போதைய shell-ல் உள்ள array-க்குள் வாசிக்கும். -t ஒவ்வொரு element-ன் இறுதியிலும் உள்ள newline-ஐ நீக்கும். mapfile-க்கு bash 4 அல்லது அதற்குப் பிந்தைய பதிப்பு தேவை. Ubuntu 24.04-ல் bash 5.2 மற்றும் Ubuntu 26.04-ல் bash 5.3 உள்ளன, எனவே இது தற்போதைய எந்த server image-லும் கிடைக்கும்.

ஸ்கிரிப்டை commit செய்வதற்கு முந்தைய சரிபார்ப்புப் பட்டியல்

  • $(command)-ஐ எழுதவும், மேலும் நீங்கள் குறிப்பாகப் பிரித்தெடுக்க விரும்பினால் ஒழிய அதை "$(command)" என மேற்கோள் காட்டவும்.
  • trailing newlines நீக்கப்பட்டுவிட்டதாகக் கருதவும். உங்களுக்கு அவை மீண்டும் தேவைப்பட்டால், ஒரு sentinel character-ஐச் சேர்க்கவும்.
  • substitutions-ல் interactive commands-ஐத் தவிர்க்கவும், அல்லது அவற்றின் prompts-ஐ standard error-க்கு அனுப்பவும்.
  • out=$(command)-ன் exit status முக்கியமானது எனில், local out-ஐத் தனி வரியில் எழுதவும்.
  • input-லிருந்து variables-ஐ அமைக்க, pipe-க்கு பதிலாக redirect அல்லது process substitution-ஐப் பயன்படுத்தவும்.

மக்கள் புதிய VPS-ஐ அமைக்கும்போது எழுதும் முதல் சிறிய ஸ்கிரிப்டுகளில் இந்த வடிவங்கள் வெளிப்படுகின்றன, மேலும் தோல்விகள் அமைதியாகவே இருக்கும். ஒரு கோப்பின் பெயருக்குள் prompt-ஐப் பதிவு செய்யும் backup ஸ்கிரிப்ட் அல்லது exit code-ஐ மறைக்கும் health check போன்றவை, தொடர்ந்து வெற்றியை மட்டுமே காட்டும். நீங்கள் ஒரே ஸ்கிரிப்டை பல server-களில் இயக்கும்போது இதன் பாதிப்பு அதிகரிக்கிறது, ஏனெனில் நீங்கள் படிக்காத output, இப்போது இருபது இயந்திரங்களில் நீங்கள் படிக்காத output-ஆக மாறுகிறது.

FAQ

$() உள்ளே cd செய்தால், தற்போதைய directory ஏன் மாறுவதில்லை?

$(...) தனது command-ஐ subshell-ல் இயக்குகிறது. அது உங்கள் working directory மற்றும் variables-ன் நகலை வைத்திருக்கும் தனி process ஆகும். cd அந்த நகலை மாற்றுகிறது. பின்னர் process முடிவடையும் போது, அந்த நகல் நீக்கப்படுகிறது. Subshell தனது standard output மற்றும் exit status-ஐ மட்டுமே திருப்பி அனுப்ப முடியும். ஆகவே directory மாற்றம் parent shell-ஐ அடைய எந்த வழிமுறையும் இல்லை. Directory-யைத் தானாகப் பெற விரும்பினால், அதை target=$(cd /etc && pwd) மூலம் capture செய்து "$target"-ஐ பயன்படுத்தவும். உங்கள் shell நகர வேண்டும் என்றால், substitution இல்லாமல் cd-ஐ நேரடியாக இயக்கவும்.

bash-ல் $() மற்றும் backticks இடையே என்ன வேறுபாடு?

எளிய commands-க்கு அவை ஒரே result-ஐத் தரும். ஆனால் முக்கியமான 2 வேறுபாடுகள் உள்ளன. $() நேரடியாக nest செய்யலாம், ஏனெனில் parser parentheses-ஐ பொருத்துகிறது. ஆனால் backticks-ல் ஒவ்வொரு nesting level-க்கும் escaped backtick தேவைப்படும். Inner command parse செய்யப்படுவதற்கு முன் backticks ஒரு அடுக்கு backslash escaping-ஐ நீக்குகின்றன. எனவே ` echo 'a\\b' prints a\b while $(echo 'a\\b') prints a\\b. $() is in POSIX and works in dash and busybox sh` செயல்படும். ஆகவே backticks-ஐப் பயன்படுத்துவதற்கு portability அடிப்படையிலான காரணம் இல்லை.

ஒரு command கேள்வி கேட்கும்போது, prompt இல்லாமல் எனது script ஏன் முடங்குகிறது?

Command substitution standard output-ஐ pipe-க்கு redirect செய்கிறது. ஆனால் standard input உங்கள் terminal-உடன் இணைந்தே இருக்கும். Prompt-ஐ standard output-ல் எழுதும் program-ன் prompt variable-க்குள் capture செய்யப்படும். அதே நேரத்தில், அதன் பின்னால் உள்ள read உங்களுக்காகக் காத்திருக்கும். Terminal driver echo செய்யும் நீங்கள் type செய்யும் characters மட்டுமே terminal-ல் தெரியும். கேள்வியை substitution-க்கு வெளியே நகர்த்தவும். அல்லது prompt capture ஆகாமல் இருக்க, printf 'Username: ' >&2 மூலம் அதை standard error-க்கு எழுதச் செய்யவும்.

எனது variable-ன் இறுதியில் இருந்த blank lines ஏன் மறைந்துவிட்டன?

Command substitution கடைசி newline மட்டும் அல்லாமல், இறுதியில் வரும் ஒவ்வொரு newline-ஐயும் நீக்குகிறது. printf 'hello\n\n\n' > f; v=$(cat f) மூலம் v ஐந்து bytes-ஐ வைத்திருக்கும்; ஆனால் file-ல் எட்டு bytes இருக்கும். அவற்றைத் தக்கவைக்க, substitution-ன் உள்ளே ஒரு sentinel-ஐச் சேர்க்கவும். பின்னர் v=$(cat f; printf x)-ஐத் தொடர்ந்து v=${v%x} மூலம் அதை நீக்கவும். Newlines-க்கு பின்னர் sentinel இருப்பதால், bash நீக்குவதற்கு இறுதியில் எதுவும் இருக்காது.

local out=$(cmd) எப்போதும் success-ஐ ஏன் report செய்கிறது?

local தனித்த command ஆகும். அந்த line-க்கு பின்னர் வரும் $?, variable-ஐ declare செய்வதில் local வெற்றி பெற்றதா என்பதை report செய்கிறது. Substitution-ன் exit status பயன்படுத்தப்பட்ட பின்னர் discard செய்யப்படுகிறது. இதன் பொருள் set -e script-ஐ நிறுத்தாது என்பதும் ஆகும். declare, export, typeset மற்றும் readonly ஆகியவையும் இதேபோல் செயல்படும். local out-ஐ ஒரு line-ல் எழுதவும். out=$(cmd)-ஐ அடுத்த line-ல் எழுதவும். பின்னர் $? உண்மையான status-ஐ report செய்யும்.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?

#bash#shell-scripting#linux#subshell#coreutils