තනි උපුටා ගත් නූල් තුළ තනි උපුටා දැක්වීම් වලින් බේරෙන්නේ කෙසේද

අපි කියමු, ඔබට එවැනි බෑෂ් එකක් තිබේ alias:

alias rxvt='urxvt'

එය හොඳින් ක්‍රියාත්මක වේ.

කෙසේවෙතත්:

alias rxvt='urxvt -fg '#111111' -bg '#111111''

ක්‍රියා නොකරනු ඇත, එසේම නොවනු ඇත:

alias rxvt='urxvt -fg \'#111111\' -bg \'#111111\''

ඉතින්, ඔබ උපුටා දැක්වීම් වලින් ගැලවී ගිය පසු, නූලක් තුළ මිල ගණන් විවෘත කිරීම හා වසා දැමීම ගැලපෙන්නේ කෙසේද?

alias rxvt='urxvt -fg'\''#111111'\'' -bg '\''#111111'\''

ඔබට ඒවා ඒ හා සමානව සම්බන්ධ කිරීමට ඉඩ දෙන්නේ නම් එය එකම නූලක් නියෝජනය කරයි.

ඔබට පිටත තට්ටුවේ තනි උපුටා දැක්වීම් භාවිතා කිරීමට අවශ්‍ය නම්, ඔබට උපුටා දැක්වීම් දෙකම මැලියම් කළ හැකි බව මතක තබා ගන්න. උදාහරණයක්:

 alias rxvt='urxvt -fg '"'"'#111111'"'"' -bg '"'"'#111111'"'"
 #                     ^^^^^       ^^^^^     ^^^^^       ^^^^
 #                     12345       12345     12345       1234

'"'"'අර්ථ නිරූපණය කරන්නේ කෙසේද යන්න පැහැදිලි කිරීම ':

1. ' තනි උපුටා දැක්වීම් භාවිතා කරන පළමු උපුටා දැක්වීම අවසන් කරන්න.
2. " ද්විත්ව උපුටා දැක්වීම් භාවිතා කරමින් දෙවන උපුටා දැක්වීම ආරම්භ කරන්න.
3. ' උපුටා ගත් චරිතය.
4. " ද්විත්ව උපුටා දැක්වීම් භාවිතා කරමින් දෙවන උපුටා දැක්වීම අවසන් කරන්න.
5. ' තනි උපුටා දැක්වීම් භාවිතා කරමින් තෙවන උපුටා දැක්වීම ආරම්භ කරන්න.

(1) සහ (2) අතර හෝ (4) සහ (5) අතර කිසිදු හිස් අවකාශයක් ඔබ ස්ථානගත නොකරන්නේ නම්, කවචය එම නූල එක දිගු වචනයක් ලෙස අර්ථ නිරූපණය කරයි.

මම සෑම විටම කාවැද්දූ තනි උපුටා දැක්වීම් අනුක්‍රමය සමඟ ප්‍රතිස්ථාපනය කරමි: '\''(එනම්: quote backslash quote quote) එය නූල වසා දමයි, පැන ගිය තනි උපුටා දැක්වීමක් එකතු කර නැවත නූල විවෘත කරයි.

මා වෙනුවෙන් මෙය කිරීමට මම බොහෝ විට මගේ පර්ල් ස්ක්‍රිප්ට් වල "උපුටා දැක්වීමේ" ශ්‍රිතයක් අවුස්සමි. පියවර වනුයේ:

s/'/'\\''/g    # Handle each embedded quote
$_ = qq['$_']; # Surround result with single quotes.

මෙය බොහෝ අවස්ථාවන් ගැන සැලකිලිමත් වේ.

ඔබ evalඔබේ ෂෙල්-ස්ක්‍රිප්ට් හඳුන්වා දෙන විට ජීවිතය වඩාත් විනෝදජනක වේ. ඔබ අනිවාර්යයෙන්ම නැවත සියල්ල නැවත උපුටා දැක්විය යුතුය!

උදාහරණයක් ලෙස, ඉහත ප්‍රකාශ අඩංගු කෝටිෆයි නමින් පර්ල් පිටපතක් සාදන්න:

#!/usr/bin/perl -pl
s/'/'\\''/g;
$_ = qq['$_'];

නිවැරදිව උපුටා දක්වන ලද නූලක් ජනනය කිරීමට එය භාවිතා කරන්න:

$ quotify
urxvt -fg '#111111' -bg '#111111'

ප්‍රති result ලය:

'urxvt -fg '\''#111111'\'' -bg '\''#111111'\'''

එය අන්වර්ථ විධානයට පිටපත් කිරීමට / ඇලවීමට හැකිය:

alias rxvt='urxvt -fg '\''#111111'\'' -bg '\''#111111'\'''

(ඔබට විධානය evල් එකකට ඇතුළු කිරීමට අවශ්‍ය නම්, නැවත උපුටා දැක්වීම ක්‍රියාත්මක කරන්න:

 $ quotify
 alias rxvt='urxvt -fg '\''#111111'\'' -bg '\''#111111'\'''

ප්‍රති result ලය:

'alias rxvt='\''urxvt -fg '\''\'\'''\''#111111'\''\'\'''\'' -bg '\''\'\'''\''#111111'\''\'\'''\'''\'''

එය පිටපත් කිරීම / ඇලවීම සඳහා ඇලවිය හැකිය:

eval 'alias rxvt='\''urxvt -fg '\''\'\'''\''#111111'\''\'\'''\'' -bg '\''\'\'''\''#111111'\''\'\'''\'''\'''

Bash 2.04 සින්ටැක්ස් $'string'(සාධාරණ වෙනුවට 'string'; අනතුරු ඇඟවීම: පටලවා නොගන්න $('string')) යනු ANSI C වැනි ගැලවීමේ අනුක්‍රමයන්ට ඉඩ දෙන සහ තනි උපුටා ගත් අනුවාදයක් දක්වා ව්‍යාප්ත කිරීමට ඉඩ දෙන තවත් උපුටා දැක්වීමේ යාන්ත්‍රණයකි .

සරල උදාහරණය:

  $> echo $'aa\'bb'
  aa'bb

  $> alias myvar=$'aa\'bb'
  $> alias myvar
  alias myvar='aa'\''bb'

ඔබේ නඩුවේ:

$> alias rxvt=$'urxvt -fg \'#111111\' -bg \'#111111\''
$> alias rxvt
alias rxvt='urxvt -fg '\''#111111'\'' -bg '\''#111111'\'''

පොදු ගැලවීමේ අනුපිළිවෙල අපේක්ෂිත පරිදි ක්‍රියා කරයි:

\'     single quote
\"     double quote
\\     backslash
\n     new line
\t     horizontal tab
\r     carriage return

පහත දැක්වෙන්නේ man bash(4.4 වෙළුම) වෙතින් පිටපත් + අලවා ඇති අදාළ ලියකියවිලි :

String 'නූල්' ආකෘතියේ වචන විශේෂයෙන් සලකනු ලැබේ. ANSI C ප්‍රමිතියෙන් නියම කර ඇති පරිදි බැක්ස්ලෑෂ්-ගැලවී ගිය අක්ෂර ප්‍රතිස්ථාපනය කරමින් වචනය වචන දක්වා විහිදේ. බැක්ස්ලෑෂ් ගැලවීමේ අනුපිළිවෙල පහත පරිදි විකේතනය කර ඇත:

    \a     alert (bell)
    \b     backspace
    \e
    \E     an escape character
    \f     form feed
    \n     new line
    \r     carriage return
    \t     horizontal tab
    \v     vertical tab
    \\     backslash
    \'     single quote
    \"     double quote
    \?     question mark
    \nnn   the eight-bit character whose value is the octal 
           value nnn (one to three digits)
    \xHH   the eight-bit character whose value is the hexadecimal
           value HH (one or two hex digits)
    \uHHHH the Unicode (ISO/IEC 10646) character whose value is 
           the hexadecimal value HHHH (one to four hex digits)
    \UHHHHHHHH the Unicode (ISO/IEC 10646) character whose value 
               is the hexadecimal value HHHHHHHH (one to eight 
               hex digits)
    \cx    a control-x character

පුළුල් කළ ප්‍රති result ලය තනි උපුටා දැක්වීමක් වන අතර එය ඩොලර් ලකුණ නොතිබුණි.

උපුටා දැක්වීම් සහ පැන යාම බලන්න : වැඩි විස්තර සඳහා ANSI C bash-hackers.org විකියේ නූල් වැනි ය . "Bash Changes" ගොනුවේ ( මෙහි දළ විශ්ලේෂණය ) $'string'උපුටා දැක්වීමේ යාන්ත්‍රණයට අදාළ වෙනස්කම් සහ දෝෂ නිවැරදි කිරීම් සඳහා බොහෝ දේ සඳහන් වන බව සලකන්න .

Unix.stackexchange.com ට අනුව සාමාන්‍ය චරිතයක් ලෙස විශේෂ අක්ෂරයක් භාවිතා කරන්නේ කෙසේද? එය bash, zsh, mksh, ksh93 සහ FreeBSD සහ කාර්යබහුල පෙට්ටියේ sh (සමහර වෙනස්කම් සහිතව) ක්‍රියා කළ යුතුය.

ඔහුගේ බ්ලොග් අඩවියේ (ලින්ක් පීඑල්එස්?) ප්‍රවේශය මට නොපෙනේ, නමුත් gnu යොමු අත්පොතට අනුව :

තනි උපුටා දැක්වීම්වල අක්ෂර ඇතුළත් කිරීම ('' ') උපුටා දැක්වීම් තුළ ඇති එක් එක් අක්ෂරවල වචනාර්ථමය වටිනාකම ආරක්ෂා කරයි. බැක්ස්ලෑෂ් එකකට පෙර වුවද තනි උපුටා දැක්වීම් අතර තනි උපුටා දැක්වීමක් සිදු නොවිය හැකිය.

එබැවින් බාෂ් තේරුම් නොගනී:

alias x='y \'z '

කෙසේ වෙතත්, ඔබ ද්විත්ව උපුටා දැක්වීම් වලින් වට වී ඇත්නම් ඔබට මෙය කළ හැකිය:

alias x="echo \'y "
> x
> 'y

'\''තනි උපුටා දැක්වීමක් සඳහා තනි උපුටා දැක්වීමක් සඳහා භාවිතා කිරීම බාෂ් හි ක්‍රියාත්මක වන බව මට සනාථ කළ හැකි අතර, එය ත්‍රෙඩ් එකේ පෙර සිටම “ඇලවීම” තර්කය මෙන් පැහැදිලි කළ හැකිය. අපට උපුටා ගත් නූලක් ඇතැයි සිතමු: 'A '\''B'\'' C'(මෙහි ඇති සියලුම උපුටා දැක්වීම් තනි උපුටා දැක්වීම් වේ). එය දෝංකාරය සඳහා සම්මත කළහොත්, එය පහත සඳහන් දෑ මුද්‍රණය කරයි : A 'B' C. සෑම '\''පළමු උපුටා දැක්වීමක්ම වත්මන් තනි-උපුටා ගත් නූල වසා දමයි, පහත දැක්වෙන්නේ පෙර \'නූලට තනි උපුටා දැක්වීමක් ( \'උපුටා ගත් නූලක් ආරම්භ නොකර තනි උපුටා දැක්වීමක් කළ හැකි ක්‍රමයකි), සහ අවසාන උපුටා දැක්වීම තවත් තනි-උපුටා ගත් නූලක් විවෘත කරයි.

මෙම අනුවාද දෙකම ක්‍රියාත්මක වන්නේ එක්කෝ ගැලවී ගිය තනි උපුටා දැක්වීමේ අක්‍ෂරය (\ ') භාවිතා කිරීමෙන් හෝ තනි උපුටා දැක්වීමේ අක්‍ෂරය ද්විත්ව උපුටා දැක්වීම් ("'") තුළට ඇතුළත් කිරීමෙන් සමෝච්ඡය සමඟ ය.

ඔහුගේ අවසාන ගැලවීමේ උත්සාහය අවසානයේ අමතර තනි උපුටා දැක්වීමක් (') ඇති බව ප්‍රශ්නයේ කතුවරයා දුටුවේ නැත:

alias rxvt='urxvt -fg'\''#111111'\'' -bg '\''#111111'\''
           │         │┊┊|       │┊┊│     │┊┊│       │┊┊│
           └─STRING──┘┊┊└─STRIN─┘┊┊└─STR─┘┊┊└─STRIN─┘┊┊│
                      ┊┊         ┊┊       ┊┊         ┊┊│
                      ┊┊         ┊┊       ┊┊         ┊┊│
                      └┴─────────┴┴───┰───┴┴─────────┴┘│
                          All escaped single quotes    │
                                                       │
                                                       ?

ASCII / Unicode කලාවේ පෙර ලස්සන කෑල්ලෙන් ඔබට දැකිය හැකි පරිදි, අවසන් වරට පැන ගිය තනි උපුටා දැක්වීම (\ ') පසුව අනවශ්‍ය තනි උපුටා දැක්වීමක් (') අනුගමනය කරයි. නොට්පෑඩ් ++ හි ඇති ආකාරයටම සින්ටැක්ස්-හයිලයිටරයක් ​​භාවිතා කිරීම ඉතා ප්‍රයෝජනවත් වේ.

පහත දැක්වෙන උදාහරණය වැනි තවත් උදාහරණයක් සඳහා මෙය සත්‍ය වේ:

alias rc='sed '"'"':a;N;$!ba;s/\n/, /g'"'"
alias rc='sed '\'':a;N;$!ba;s/\n/, /g'\'

අන්වර්ථ නාමවල මෙම සුන්දර අවස්ථා දෙක ඉතා සංකීර්ණ හා අපැහැදිලි ආකාරයකින් පෙන්නුම් කරන්නේ ගොනුවක් පෙළ ගැසිය හැකි ආකාරයයි. එනම්, පේළි විශාල ප්‍රමාණයක් ඇති ගොනුවකින් ඔබට ලැබෙන්නේ පෙර පේළි වල අන්තර්ගතය අතර කොමාව සහ අවකාශය සහිත එක් පේළියක් පමණි. පෙර අදහස් දැක්වීම අර්ථවත් කිරීම සඳහා, පහත දැක්වෙන්නේ නිදසුනකි:

$ cat Little_Commas.TXT
201737194
201802699
201835214

$ rc Little_Commas.TXT
201737194, 201802699, 201835214

කවචයේ ඇති උපුටා දැක්වීම් වලින් ගැලවීමේ සරල උදාහරණය:

$ echo 'abc'\''abc'
abc'abc
$ echo "abc"\""abc"
abc"abc

එය සිදු කර ඇත්තේ දැනටමත් විවෘත කර ඇති එකක් ( ') අවසන් කිරීමෙන් , පැන ගිය එකක් ( \') තැබීමෙන් පසුව තවත් එකක් ( ') විවෘත කිරීමෙනි . මෙම සින්ටැක්ස් සියලුම විධාන සඳහා ක්‍රියා කරයි. එය 1 වන පිළිතුරට බෙහෙවින් සමාන ප්‍රවේශයකි.

මම විශේෂයෙන් උපුටා දැක්වීමේ ගැටලුව විසඳන්නේ නැත, මන්ද, සමහර විට, විකල්ප ප්‍රවේශයක් සලකා බැලීම සාධාරණ ය.

rxvt() { urxvt -fg "#${1:-000000}" -bg "#${2:-FFFFFF}"; }

ඔබට පසුව ඇමතිය හැක්කේ:

rxvt 123456 654321

උපුටා දැක්වීම් ගැන සැලකිලිමත් නොවී ඔබට දැන් මෙය අන්වර්ථ කළ හැකිය යන අදහස:

alias rxvt='rxvt 123456 654321'

හෝ, #කිසියම් හේතුවක් නිසා ඔබට සියලු ඇමතුම් ඇතුළත් කිරීමට අවශ්‍ය නම් :

rxvt() { urxvt -fg "${1:-#000000}" -bg "${2:-#FFFFFF}"; }

ඔබට පසුව ඇමතිය හැක්කේ:

rxvt '#123456' '#654321'

ඇත්ත වශයෙන්ම, අන්වර්ථයකි:

alias rxvt="rxvt '#123456' '#654321'"

(අපොයි, මම හිතන්නේ මම උපුටා දැක්වීම ආමන්ත්‍රණය කළා :)

තනි උපුටා දැක්වීම් නූල් තුළ තනි උපුටා දැක්වීම් කළ නොහැකි බැවින්, සරලම හා වඩාත්ම කියවිය හැකි විකල්පය වන්නේ හෙරෙඩොක් නූලක් භාවිතා කිරීමයි

command=$(cat <<'COMMAND'
urxvt -fg '#111111' -bg '#111111'
COMMAND
)

alias rxvt=$command

ඉහත කේතයේ දී, HEREDOC catවිධානය වෙත යවනු ලබන අතර , එහි ප්‍රතිදානය විධාන ආදේශන අංකනය හරහා විචල්‍යයකට පවරනු ලැබේ.$(..)

හෙරෙඩොක් වටා තනි උපුටා දැක්වීමක් අවශ්‍ය වන්නේ එය a $()

මම ෂෙල් කේත භාවිතා කරමි .. උදා \x27හෝ \\x22අදාළ වේ. කරදරයක් නැහැ, කවදාවත් ඇත්තටම.

මෙම පිළිතුරු බොහොමයක් ඔබ අසන විශේෂිත නඩුවට පහර දෙයි. අත්තනෝමතික ඔබ උදා, ssh හරහා, ෂෙල් පුළුල් බහු ස්ථර හරහා කාව්යකරණයේ විධාන උපුටා ගැනීමට අවශ්ය අවස්ථාවක උපුටා සඳහා ඉඩ සලසා දෙන මිතුරා සහ මම නිර්මාණය කර ඇති පොදු ප්රවේශය නොමැති su -c, bash -cඑහි මෙහි, ඔබට අවශ්ය ප්රාථමික එක් හරය, ආදී ස්වදේශීය බෑෂ් වලින්:

quote_args() {
    local sq="'"
    local dq='"'
    local space=""
    local arg
    for arg; do
        echo -n "$space'${arg//$sq/$sq$dq$sq$dq$sq}'"
        space=" "
    done
}

මෙය පවසන දෙය හරියටම කරයි: එය එක් එක් තර්කය තනි තනිව උපුටා දක්වයි (බැෂ් ප්‍රසාරණයෙන් පසුව, ඇත්ත වශයෙන්ම):

$ quote_args foo bar
'foo' 'bar'
$ quote_args arg1 'arg2 arg2a' arg3
'arg1' 'arg2 arg2a' 'arg3'
$ quote_args dq'"'
'dq"'
$ quote_args dq'"' sq"'"
'dq"' 'sq'"'"''
$ quote_args "*"
'*'
$ quote_args /b*
'/bin' '/boot'

පුළුල් කිරීමේ එක් ස්ථරයක් සඳහා එය පැහැදිලිව පෙනෙන දේ කරයි:

$ bash -c "$(quote_args echo a'"'b"'"c arg2)"
a"b'c arg2

(ප්‍රති $(quote_args ...)result ලය තනි තර්කයක් බවට පත් කිරීම සඳහා අවට ඇති ද්විත්ව උපුටා දැක්වීම් අවශ්‍ය බව සලකන්න bash -c.) තවද එය පුළුල් කිරීමේ විවිධ ස්ථර හරහා නිසි ලෙස උපුටා දැක්වීමට වඩාත් සාමාන්‍යයෙන් භාවිතා කළ හැකිය:

$ bash -c "$(quote_args bash -c "$(quote_args echo a'"'b"'"c arg2)")"
a"b'c arg2

ඉහත උදාහරණය:

1. shell-quotes එක් එක් තර්කය අභ්‍යන්තරයට quote_argsතනි තනිව උපුටා දක්වන අතර එහි ප්‍රති output ලය වන ප්‍රතිදානය අභ්‍යන්තර ද්විත්ව උපුටා දැක්වීම් සමඟ තනි තර්කයකට ඒකාබද්ධ කරයි.
2. shell-quotes bash, -cසහ 1 වන පියවරෙන් දැනටමත් උපුටා දක්වා ඇති ප්‍රති result ලය, ඉන්පසු ප්‍රති double ලය පිටත ද්විත්ව උපුටා දැක්වීම් සමඟ තනි තර්කයකට ඒකාබද්ධ කරයි.
3. එම අවුල තර්කය ලෙස පිටතින් යවයි bash -c.

එය කෙටියෙන් කිවහොත් අදහසයි. ඔබට මෙය සමඟ තරමක් සංකීර්ණ දේවල් කළ හැකිය, නමුත් ඇගයීමේ අනුපිළිවෙල සහ උපුටා දැක්වීම් උපුටා ගැනීම ගැන ඔබ සැලකිලිමත් විය යුතුය. උදාහරණයක් ලෙස, පහත දැක්වෙන දේ වැරදි දේ කරයි (“වැරදි” යන්නෙහි යම් අර්ථ දැක්වීමක් සඳහා):

$ (cd /tmp; bash -c "$(quote_args cd /; pwd 1>&2)")
/tmp
$ (cd /tmp; bash -c "$(quote_args cd /; [ -e *sbin ] && echo success 1>&2 || echo failure 1>&2)")
failure

පළමු උදාහරණයේදී, bash වහාම පුළුල් quote_args cd /; pwd 1>&2වෙනම විධාන දෙකකට, quote_args cd /හා pwd 1>&2, එම නිසා CWD තවමත් /tmpවූ විට pwdඅණ ක්රියාත්මක කර ඇත. දෙවන උදාහරණයෙන් ග්ලෝබ් කිරීම සඳහා සමාන ගැටළුවක් නිරූපණය වේ. ඇත්ත වශයෙන්ම, සියලු මූලික පුළුල් කිරීම් වලදී එකම මූලික ගැටළුව ඇතිවේ. මෙහි ඇති ගැටළුව නම් විධාන ආදේශනය ක්‍රියාකාරී ඇමතුමක් නොවීමයි: එය වචනාර්ථයෙන් එක් බැෂ් ස්ක්‍රිප්ට් එකක් තක්සේරු කර එහි ප්‍රතිදානය වෙනත් බෑෂ් ස්ක්‍රිප්ටයක කොටසක් ලෙස භාවිතා කරයි.

ඔබ හුදෙක් ෂෙල් ක්‍රියාකරුවන්ගෙන් බේරීමට උත්සාහ කරන්නේ නම්, ඔබ අසමත් වනුයේ එහි bash -cප්‍රති string ලයක් ලෙස ලබා දෙන නූල තනි තනිව උපුටා දක්වන ලද නූල්වල අනුක්‍රමයක් වන අතර එය ක්‍රියාකරුවන් ලෙස අර්ථ නිරූපණය නොකෙරේ. කඩාවැටීමට සම්මත කර ඇත:

$ (cd /tmp; echo "$(quote_args cd /\; pwd 1\>\&2)")
'cd' '/;' 'pwd' '1>&2'
$ (cd /tmp; echo "$(quote_args cd /\; \[ -e \*sbin \] \&\& echo success 1\>\&2 \|\| echo failure 1\>\&2)")
'cd' '/;' '[' '-e' '*sbin' ']' '&&' 'echo' 'success' '1>&2' '||' 'echo' 'failure' '1>&2'

මෙහි ඇති ගැටලුව නම් ඔබ ඕනෑවට වඩා උපුටා දැක්වීමයි. ඔබට අවශ්‍ය වන්නේ ක්‍රියාකරුවන්ට කොටු කිරීම සඳහා ආදානය ලෙස නම් නොකිරීමයි bash -c, එයින් අදහස් කරන්නේ ඔවුන් $(quote_args ...)විධාන ආදේශනයට පිටතින් සිටිය යුතු බවයි .

එහි ප්‍රති sequently ලයක් වශයෙන්, ඔබ කළ යුත්තේ සාමාන්‍ය අර්ථයෙන් විධාන ආදේශන අවස්ථාවේ දී පුළුල් කිරීමට අදහස් නොකරන විධානයන්හි එක් එක් වචනය වෙන වෙනම ෂෙල්-කෝට් කිරීම සහ ෂෙල් ක්‍රියාකරුවන්ට අමතර උපුටා දැක්වීමක් නොකිරීම ය:

$ (cd /tmp; echo "$(quote_args cd /); $(quote_args pwd) 1>&2")
'cd' '/'; 'pwd' 1>&2
$ (cd /tmp; bash -c "$(quote_args cd /); $(quote_args pwd) 1>&2")
/
$ (cd /tmp; echo "$(quote_args cd /); [ -e *$(quote_args sbin) ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")
'cd' '/'; [ -e *'sbin' ] && 'echo' 'success' 1>&2 || 'echo' 'failure' 1>&2
$ (cd /tmp; bash -c "$(quote_args cd /); [ -e *$(quote_args sbin) ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")
success

ඔබ මෙය කළ පසු, අත්තනෝමතික මට්ටමේ ඇගයීම් සඳහා තවදුරටත් උපුටා දැක්වීම සඳහා සම්පූර්ණ නූල සාධාරණ ක්‍රීඩාවකි:

$ bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); $(quote_args pwd) 1>&2")"
/
$ bash -c "$(quote_args bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); $(quote_args pwd) 1>&2")")"
/
$ bash -c "$(quote_args bash -c "$(quote_args bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); $(quote_args pwd) 1>&2")")")"
/
$ bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); [ -e *$(quote_args sbin) ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")"
success
$ bash -c "$(quote_args bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); [ -e *sbin ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")")"
success
$ bash -c "$(quote_args bash -c "$(quote_args bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); [ -e *$(quote_args sbin) ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")")")"
success

ආදිය.

මෙම උදාහරණ වැනි වචන බව ලබා දී overwrought පෙනුණත් success, sbinසහ pwdෂෙල්-උපුටා විය යුතු නැහැ, නමුත් ඔබට හොඳටම විශ්වාසද නෑ හැම දෙයක්ම උපුටා කිරීමට අවශ්ය බව අත්තනෝමතික ආදානය තිර රචනය ලිවීමේදී මතක තබා ගැනීමට වන ප්රධාන කාරණය වන්නේ අයෙක් සොයමින් ' ටී පරිශීලක දී විසි ඇත විට ඔබ දන්නේ නැහැ නිසා, උපුටා දක්වමින් අවශ්ය Robert'; rm -rf /.

ආවරණ යටතේ සිදුවන්නේ කුමක්ද යන්න වඩා හොඳින් අවබෝධ කර ගැනීම සඳහා, ඔබට කුඩා උපකාරක කාර්යයන් දෙකක් සමඟ සෙල්ලම් කළ හැකිය:

debug_args() {
    for (( I=1; $I <= $#; I++ )); do
        echo -n "$I:<${!I}> " 1>&2
    done
    echo 1>&2
}

debug_args_and_run() {
    debug_args "$@"
    "$@"
}

එය එක් එක් තර්කය ක්‍රියාත්මක කිරීමට පෙර විධානයකට ගණනය කරනු ඇත:

$ debug_args_and_run echo a'"'b"'"c arg2
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

$ bash -c "$(quote_args debug_args_and_run echo a'"'b"'"c arg2)"
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

$ bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run echo a'"'b"'"c arg2)")"
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'echo' 'a"b'"'"'c' 'arg2'> 
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

$ bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run echo a'"'b"'"c arg2)")")"
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'bash' '-c' ''"'"'debug_args_and_run'"'"' '"'"'echo'"'"' '"'"'a"b'"'"'"'"'"'"'"'"'c'"'"' '"'"'arg2'"'"''> 
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'echo' 'a"b'"'"'c' 'arg2'> 
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

$ bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run echo a'"'b"'"c arg2)")")")"
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'bash' '-c' ''"'"'debug_args_and_run'"'"' '"'"'bash'"'"' '"'"'-c'"'"' '"'"''"'"'"'"'"'"'"'"'debug_args_and_run'"'"'"'"'"'"'"'"' '"'"'"'"'"'"'"'"'echo'"'"'"'"'"'"'"'"' '"'"'"'"'"'"'"'"'a"b'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'c'"'"'"'"'"'"'"'"' '"'"'"'"'"'"'"'"'arg2'"'"'"'"'"'"'"'"''"'"''> 
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'bash' '-c' ''"'"'debug_args_and_run'"'"' '"'"'echo'"'"' '"'"'a"b'"'"'"'"'"'"'"'"'c'"'"' '"'"'arg2'"'"''> 
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'echo' 'a"b'"'"'c' 'arg2'> 
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

IMHO හි සැබෑ පිළිතුර නම් ඔබට තනි උපුටා දැක්වීම් වලින් තනි උපුටා දැක්වීම් වලින් ගැලවිය නොහැකි බවයි.

එය කළ නොහැකි ය.

අපි උපකල්පනය කරන්නේ නම් අපි භාවිතා කරන්නේ බාෂ් ය.

බාෂ් අත්පොතෙන් ...

Enclosing characters in single quotes preserves the literal value of each
character within the quotes.  A single quote may not occur
between single quotes, even when preceded by a backslash.

ඔබ වෙනත් නූල් ගැලවීමේ යාන්ත්‍රණයක් භාවිතා කළ යුතුය "හෝ \

aliasතනි උපුටා දැක්වීම් භාවිතා කරන ලෙස ඉල්ලා සිටින මැජික් කිසිවක් නැත .

පහත දැක්වෙන කාර්යයන් දෙකම කඩිනමින් ක්‍රියාත්මක වේ.

alias rxvt="urxvt -fg '#111111' -bg '#111111'"
alias rxvt=urxvt\ -fg\ \'#111111\'\ -bg\ \'#111111\'

දෙවැන්න අභ්‍යවකාශ අක්ෂරයෙන් ගැලවීමට \ භාවිතා කිරීමයි.

# 111111 ගැන තනි උපුටා දැක්වීම් අවශ්‍ය වන මැජික් කිසිවක් නොමැත.

පහත දැක්වෙන විකල්පයන් අනෙක් විකල්ප දෙකේම ප්‍රති result ලය ලබා ගනී, rxvt අන්වර්ථය අපේක්ෂිත පරිදි ක්‍රියා කරයි.

alias rxvt='urxvt -fg "#111111" -bg "#111111"'
alias rxvt="urxvt -fg \"#111111\" -bg \"#111111\""

ඔබට කරදරකාරී # කෙලින්ම ගැලවිය හැකිය

alias rxvt="urxvt -fg \#111111 -bg \#111111"

දී ඇති උදාහරණයේ දී, පිටත ගැලවීමේ යාන්ත්‍රණයක් ලෙස තනි උපුටා දැක්වීම් වෙනුවට ද්විත්ව උපුටා දැක්වීම් භාවිතා කර ඇත:

alias rxvt="urxvt -fg '#111111' -bg '#111111'"

ඔබට ස්ථාවර නූලක් විධානයකට යැවීමට අවශ්‍ය බොහෝ අවස්ථාවන් සඳහා මෙම ප්‍රවේශය සුදුසු වේ: ෂෙල් එක මඟින් ද්විත්ව උපුටා ගත් නූලක් හරහා අර්ථ නිරූපණය කරන්නේ කෙසේදැයි පරීක්ෂා කර බලා echoඅවශ්‍ය නම් බැක්ස්ලෑෂ් සමඟ අක්ෂර වලින් ගැලවී යන්න.

උදාහරණයේ දී, නූල් ආරක්ෂා කිරීම සඳහා ද්විත්ව උපුටා දැක්වීම් ප්‍රමාණවත් බව ඔබට පෙනෙනු ඇත:

$ echo "urxvt -fg '#111111' -bg '#111111'"
urxvt -fg '#111111' -bg '#111111'

නිසැකවම, ද්විත්ව උපුටා දැක්වීම් සමඟ සරළව සිටීම පහසු වනු ඇත, නමුත් එහි ඇති අභියෝගය කොහිද? තනි උපුටා දැක්වීම් පමණක් භාවිතා කරමින් පිළිතුර මෙන්න. මම ඒ වෙනුවට විචල්‍යයක් භාවිතා කරමි, aliasඑම නිසා එය ඔප්පු කිරීම සඳහා මුද්‍රණය කිරීම පහසුය, නමුත් එය භාවිතා කිරීමට සමාන aliasවේ.

$ rxvt='urxvt -fg '\''#111111'\'' -bg '\''#111111'\'
$ echo $rxvt
urxvt -fg '#111111' -bg '#111111'

පැහැදිලි කිරීම

ප්රධාන දෙය නම්, ඔබට තනි උපුටා දැක්වීම වසා දමා ඔබට අවශ්ය වාර ගණනක් නැවත විවෘත කළ හැකිය. උදාහරණයක් ලෙස foo='a''b'සමාන වේ foo='ab'. එබැවින් ඔබට තනි උපුටා දැක්වීම වසා දැමිය හැකිය, වචනානුසාරයෙන් තනි උපුටා දැක්වීමක් කරන්න \', ඉන්පසු ඊළඟ තනි උපුටා දැක්වීම නැවත විවෘත කරන්න.

බිඳවැටීමේ රූප සටහන

මෙම රූප සටහන මඟින් වරහන් භාවිතා කරමින් තනි උපුටා දැක්වීම් විවෘත කර වසා ඇති ස්ථානය පෙන්වයි. වරහන් වැනි විය හැකි පරිදි මිල ගණන් "කැදැලි" නොවේ. නිවැරදිව යොදන වර්ණ උද්දීපනය කෙරෙහි ද ඔබට අවධානය යොමු කළ හැකිය. උපුටා ගත් නූල් මෙරූන් වන අතර \'කළු ය.

'urxvt -fg '\''#111111'\'' -bg '\''#111111'\'    # original
[^^^^^^^^^^] ^[^^^^^^^] ^[^^^^^] ^[^^^^^^^] ^    # show open/close quotes
 urxvt -fg   ' #111111  '  -bg   ' #111111  '    # literal characters remaining

(මෙය අත්‍යවශ්‍යයෙන්ම ඒඩ්‍රියන්ගේ පිළිතුරමයි. නමුත් මෙය වඩාත් හොඳින් පැහැදිලි කරන බව මට හැඟේ. එසේම ඔහුගේ පිළිතුරට අවසානයේ දී අතිරික්ත තනි උපුටා දැක්වීම් 2 ක් ඇත.)

ඉහත සඳහන් කළ එක් සත්‍ය පිළිතුර පිළිබඳ විස්තරයක් මෙන්න:

සමහර විට මම rsync over ssh භාවිතයෙන් බාගත කර ගන්නා අතර එහි 'TWICE' සහිත ගොනු නාමයකින් ගැලවීමට සිදුවේ! (OMG!) වරක් bash සඳහා සහ එක් වරක් ssh සඳහා. උද්ධෘත පරිසීමක ප්‍රත්‍යාවර්ත කිරීමේ මූලධර්මයම මෙහි ක්‍රියාත්මක වේ.

උදාහරණයක් ලෙස, අපට ලබා ගැනීමට අවශ්‍ය යැයි කියමු: ලුවී තෙරෝක්ස්ගේ LA කතන්දර ...

1. පළමුව ඔබ ලුවී තෙරෝක්ස් බාෂ් සඳහා තනි උපුටා දැක්වීම් සහ ssh සඳහා ද්විත්ව මිල ගණන් ඇතුළත් කරන්න: '' ලුවී තෙරෝක්ස් ''
2. ද්විත්ව උපුටා දැක්වීමෙන් ගැලවීමට ඔබ තනි උපුටා දැක්වීම් භාවිතා කරයි
3. ප්‍රේරිතයෙන් ගැලවීම සඳහා ද්විත්ව උපුටා දැක්වීම් භාවිතා කරන්න
4. ඉන්පසු ද්විත්ව උපුටා දැක්වීමෙන් ගැලවීමට තනි උපුටා දැක්වීම් භාවිතා කරමින් # 2 නැවත කරන්න.
5. ඉන්පසු LA කතන්දර බැෂ් සඳහා තනි උපුටා දැක්වීම් සහ ssh සඳහා ද්විත්ව මිල ගණන් ඇතුළත් කරන්න: '' LA කතන්දර ''

බලන්න! ඔබ මේ සමඟ සුළඟ:

rsync -ave ssh '"Louis Theroux"''"'"'"'"''"s LA Stories"'

ඒක එක පොඩි එකකට ගොඩක් භයානක වැඩක් - ඒත් ඔයා යන්න

shell_escape () {
    printf '%s' "'${1//\'/\'\\\'\'}'"
}

ක්‍රියාත්මක කිරීමේ පැහැදිලි කිරීම:

• ද්විත්ව උපුටා දැක්වීම් නිසා අපට පහසුවෙන් තනි උපුටා දැක්වීම් ප්‍රතිදානය කර ${...}සින්ටැක්ස් භාවිතා කළ හැකිය

• bash ගේ සෙවීම සහ ප්‍රතිස්ථාපනය පෙනෙන්නේ: ${varname//search/replacement}

• අප වෙනුවට කරන්නේ 'සමග'\''

• '\''එබඳු එකක් සංකේතවත් කරයි ':

  1. ' තනි උපුටා දැක්වීම අවසන් කරයි

  2. \'a සංකේතවත් කරයි '(බැක්ස්ලෑෂ් අවශ්‍ය වන්නේ අප මිල ගණන් ඇතුළත නොමැති නිසාය)

  3. ' නැවත තනි උපුටා දැක්වීමක් ආරම්භ කරයි

  4. සුදු අවකාශයක් නොමැති නූල් බාෂ් ස්වයංක්‍රීයව සංයුක්ත කරයි

• එය තියෙනවා \සෑම පෙර \හා 'ඒ සඳහා යොමුවූ නීති වන නිසා ${...//.../...}.

string="That's "'#@$*&^`(@#'
echo "original: $string"
echo "encoded:  $(shell_escape "$string")"
echo "expanded: $(bash -c "echo $(shell_escape "$string")")"

PS සෑම විටම උපුටා ගත් තනි නූල් වලට සංකේතනය කරන්න, මන්ද ඒවා ද්විත්ව උපුටා ගත් නූල් වලට වඩා සරල ය.

කූඩු උපුටා දැක්වීමේ ස්ථර ගණනාවක ගැටලුව විසඳීමට තවත් ක්‍රමයක්:

ඔබ උත්සාහ කරන්නේ ඉතා කුඩා ඉඩක් තුළට රිංගා ගැනීමට ය, එබැවින් bash ශ්‍රිතයක් භාවිතා කරන්න.

ගැටළුව වන්නේ ඔබ ඕනෑවට වඩා කැදැල්ල ඇති කිරීමට උත්සාහ කරන අතර මූලික අන්වර්ථ තාක්‍ෂණය නවාතැන් ගැනීමට තරම් බලවත් නොවේ. තනි, ද්විත්ව උපුටා දැක්වීම් ආපසු කිනිතුල්ලන් හා පරාමිතීන් තුළ සම්මත කර ඇති මේ සියල්ල සාමාන්‍යයෙන් හසුරුවනු ලබන්නේ අප අපේක්ෂා කරන ආකාරයට ය:

lets_do_some_stuff() {
    tmp=$1                       #keep a passed in parameter.
    run_your_program $@          #use all your passed parameters.
    echo -e '\n-------------'    #use your single quotes.
    echo `date`                  #use your back ticks.
    echo -e "\n-------------"    #use your double quotes.
}
alias foobarbaz=lets_do_some_stuff

එවිට ඔබට ඔබේ $ 1 සහ $ 2 විචල්‍යයන් සහ තනි, ද්විත්ව උපුටා දැක්වීම් සහ පසුපස කිනිතුල්ලන් භාවිතා කළ හැකිය.

මෙම වැඩසටහන මුද්‍රණය කරයි:

el@defiant ~/code $ foobarbaz alien Dyson ring detected @grid 10385
alien Dyson ring detected @grid 10385
-------------
Mon Oct 26 20:30:14 EDT 2015
-------------

ඔබ GNU සමාන්තර ස්ථාපනය කර ඇත්නම් ඔබට එහි අභ්‍යන්තර උපුටා දැක්වීම භාවිතා කළ හැකිය:

$ parallel --shellquote
L's 12" record
<Ctrl-D>
'L'"'"'s 12" record'
$ echo 'L'"'"'s 12" record'
L's 12" record

20190222 අනුවාදයෙන් ඔබට --shellquoteකිහිප වතාවක් පවා කළ හැකිය :

$ parallel --shellquote --shellquote --shellquote
L's 12" record
<Ctrl-D>
'"'"'"'"'"'"'L'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'s 12" record'"'"'"'"'"'"'
$ eval eval echo '"'"'"'"'"'"'L'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'s 12" record'"'"'"'"'"'"'
L's 12" record

එය සියලු ආධාරක කවච වල (පමණක් නොව bash) නූල උපුටා දක්වනු ඇත .

මෙම ශ්‍රිතය:

quote () 
{ 
    local quoted=${1//\'/\'\\\'\'};
    printf "'%s'" "$quoted"
}

'ඇතුළත උපුටා දැක්වීමට ඉඩ දෙයි '. මේ ලෙස භාවිතා කරන්න:

$ quote "urxvt -fg '#111111' -bg '#111111'"
'urxvt -fg '\''#111111'\'' -bg '\''#111111'\'''

තනි උපුටා දැක්වීම් සමඟ ද්විත්ව උපුටා දැක්වීම් මෙන් උපුටා දැක්වීමේ රේඛාව වඩාත් සංකීර්ණ වුවහොත්, විචල්යයක් තුළ උපුටා දැක්වීමට නූල ලබා ගැනීම තරමක් උපක්‍රමශීලී විය හැකිය. එවැනි අවස්ථා පෙන්වන විට, ස්ක්‍රිප්ට් එකක් තුළ උපුටා දැක්වීමට අවශ්‍ය රේඛාව ලියන්න (මේ හා සමාන).

#!/bin/bash

quote ()
{
    local quoted=${1//\'/\'\\\'\'};
    printf "'%s'" "$quoted"
}

while read line; do
    quote "$line"
done <<-\_lines_to_quote_
urxvt -fg '#111111' -bg '#111111'
Louis Theroux's LA Stories
'single quote phrase' "double quote phrase"
_lines_to_quote_

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

'urxvt -fg '\''#111111'\'' -bg '\''#111111'\'''
'Louis Theroux'\''s LA Stories'
''\''single quote phrase'\'' "double quote phrase"'

තනි උපුටා දැක්වීම් තුළ නිවැරදිව උපුටා දක්වන ලද නූල් සියල්ලම.

ඔබ පයිතන් 2 හෝ පයිතන් 3 තුළ ෂෙල් නූල් ජනනය කරන්නේ නම්, පහත දැක්වෙන්නේ තර්ක උපුටා දැක්වීමට ය:

#!/usr/bin/env python

from __future__ import print_function

try:  # py3
    from shlex import quote as shlex_quote
except ImportError:  # py2
    from pipes import quote as shlex_quote

s = """foo ain't "bad" so there!"""

print(s)
print(" ".join([shlex_quote(t) for t in s.split()]))

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

foo ain't "bad" so there!
foo 'ain'"'"'t' '"bad"' so 'there!'

මෙන්න මගේ ශත දෙකයි - යමෙකුට sh-පෝර්ටබල් වීමට අවශ්‍ය නම්, විශේෂිත නොවේ bash(විසඳුම එතරම් කාර්යක්ෂම නොවේ, නමුත් එය බාහිර වැඩසටහනක් ආරම්භ කරන විට - sed):

• මෙය ඔබගේ කොතැනක quote.shහෝ (හෝ යන්තම් quote) තබන්න PATH:

# මෙය සම්මත ආදානය (stdin) සමඟ ක්‍රියා කරයි
quote () {
  echo -n "'";
  sed 's / \ ([' "''] ['' '' '] * \) /' '' '' '\ 1"' '' '/ g';
  echo -n "" "
}

නඩුව "$ 1"
 -) උපුටා ගැනීම ;;
 *) echo "use: cat ... | quote - # Bourne shell සඳහා තනි-උපුටා දැක්වීම් ආදානය" 2> & 1 ;;
esac

උදාහරණයක්:

$ echo -n "G'day, යාළුවා!" | ./quote.sh -
'ජී' '' '' දවස, යාළුවා! '

ඇත්ත වශයෙන්ම, එය ආපසු හරවයි:

$ echo 'G' '' '' 'දවස, යාළුවා!'
G'day, යාළුවා!

පැහැදිලි කිරීම: මූලික වශයෙන් අපට ආදානය උපුටා දැක්වීම් සමඟ සම්බන්ධ කළ යුතු අතර ', පසුව ඕනෑම තනි උපුටා දැක්වීමක් මෙම ක්ෂුද්‍ර රාක්ෂයා සමඟ ප්‍රතිස්ථාපනය කළ යුතුය: '"'"'(ආරම්භක උපුටා ගැනීම යුගලනයකින් අවසන් කරන්න ', සොයාගත් තනි උපුටා දැක්වීම ද්විත්ව උපුටා දැක්වීම් වලින් ඔතා එය බේරෙන්න - "'", සහ අවසානයේදී නව විවෘත තනි උපුටා නිකුත් 'හෝ ව්යාජ-අංකනය: ' + "'" + ' == '"'"')

එය කළ හැකි එක් සම්මත ක්‍රමයක් වනුයේ sedපහත දැක්වෙන ආදේශන විධානය සමඟ භාවිතා කිරීමයි:

s/\(['][']*\)/'"\1"'/g 

එක් කුඩා ගැටළුවක් නම්, එය කවචයේ භාවිතා කිරීමට නම්, මේ සියලු තනි උපුටා දැක්වීම් අක්ෂර වින්‍යාසය තුළම ගැලවිය යුතුය.

sed 's/\(['"'"']['"'"']*\)/'"'"'"\1"'"'"'/g' 

(මෙම ප්‍රති result ලය ගොඩනැගීමට එක් හොඳ ක්‍රමයක් නම් මුල් ප්‍රකාශනය s/\(['][']*\)/'"\1"'/gකයිල් රෝස් හෝ ජෝර්ජ් වී. රීලිගේ පිටපත් වලට පෝෂණය කිරීමයි ).

අවසාන වශයෙන්, ආදානය පැමිණෙනු ඇතැයි අපේක්ෂා කිරීම අර්ථවත් කරයි stdin- විධාන රේඛා තර්ක හරහා එය සම්මත කිරීම දැනටමත් බොහෝ කරදර ඇති විය හැකි බැවින්.

(ඔහ්, අපට කුඩා උපකාර පණිවිඩයක් එක් කිරීමට අවශ්‍ය විය හැකි අතර එමඟින් යමෙකු ./quote.sh --helpඑය කරන්නේ කුමක් දැයි කල්පනා කර බලන විට එය තිර රචනය එල්ලෙන්නේ නැත.)

Ason ජේසන් වෝෆ්ගේ පරිපූර්ණ පිළිතුරට අමතරව, මම අදාළ ගැටලුව විසඳූ ආකාරය පෙන්වීමට අවශ්‍යයි

මගේ නඩුවේදී තනි උපුටා දැක්වීම් කේතනය කිරීම '\''සැමවිටම ප්‍රමාණවත් නොවේ, නිදසුනක් ලෙස තනි උපුටා දැක්වීම් සමඟ නූලක් උපුටා දැක්විය යුතු නම්, නමුත් මුළු උපුටා දැක්වීම් ගණන අමුතු ප්‍රමාණයකට හේතු වේ

#!/bin/bash

# no closing quote
string='alecxs\'solution'

# this works for string
string="alecxs'solution"
string=alecxs\'solution
string='alecxs'\''solution'

නූල් යනු ගොනු නාමයක් යැයි උපකල්පනය කරමු. අපි උපුටා ගත් ගොනු නාම ලැයිස්තුවක් තුළ සුරැකිය යුතුය ( stat -c% N ./*> ලැයිස්තුව වැනි )

echo "'$string'" > "$string"
cat "$string"

නමුත් මෙම ලැයිස්තුව සැකසීම අසාර්ථක වනු ඇත (නූලෙහි කොපමණ මිල ගණන් අඩංගුද යන්න මත පදනම්ව)

while read file
  do
    ls -l "$file"
    eval ls -l "$file"
done < "$string"

workaround: නූල් හැසිරවීම සමඟ මිල ගණන් කේතනය කරන්න

string="${string//$'\047'/\'\$\'\\\\047\'\'}"

# result
echo "$string"

මිල ගණන් සැමවිටම සමතුලිත බැවින් දැන් එය ක්‍රියාත්මක වේ

echo "'$string'" > list
while read file
  do
    ls -l "$file"
    eval ls -l "$file"
done < list

සමාන ගැටලුවකට මුහුණ දෙන විට මෙය උපකාරී වේ යැයි සිතමු

මෙන්න තවත් විසඳුමක්. ඉහත ශ්‍රිතය තනි තර්කයක් ගෙන එය තනි-උපුටා දැක්වීමේ අක්‍ෂරය භාවිතයෙන් උචිත ලෙස උපුටා දක්වනු ඇත.

single_quote() {
  local quoted="'"
  local i=0
  while [ $i -lt ${#1} ]; do
    local ch="${1:i:1}"
    if [[ "$ch" != "'" ]]; then
      quoted="$quoted$ch"
    else
      local single_quotes="'"
      local j=1
      while [ $j -lt ${#1} ] && [[ "${1:i+j:1}" == "'" ]]; do
        single_quotes="$single_quotes'"
        ((j++))
      done
      quoted="$quoted'\"$single_quotes\"'"
      ((i+=j-1))
    fi
    ((i++))
  done
  echo "$quoted'"
}

එබැවින්, ඔබට එය මේ ආකාරයෙන් භාවිතා කළ හැකිය:

single_quote "1 2 '3'"
'1 2 '"'"'3'"'"''

x="this text is quoted: 'hello'"
eval "echo $(single_quote "$x")"
this text is quoted: 'hello'