Bash විචල්‍යයකින් සුදු අවකාශය කපා ගන්නේ කෙසේද?

මෙම කේතය සමඟ මට ෂෙල් ස්ක්‍රිප්ට් එකක් ඇත:

var=`hg st -R "$path"`
if [ -n "$var" ]; then
    echo $var
fi

නමුත් කොන්දේසි සහිත කේතය සැමවිටම ක්‍රියාත්මක වන්නේ hg stසෑම විටම අවම වශයෙන් එක් නව අක්ෂරයක්වත් මුද්‍රණය කරන බැවිනි .

• $var( PHPtrim() හි මෙන් ) හිස් අවකාශය ඉවත් කිරීමට සරල ක්‍රමයක් තිබේද?

හෝ

• මෙම ගැටළුව සමඟ කටයුතු කිරීමට සම්මත ක්‍රමයක් තිබේද?

මට sed හෝ AWK භාවිතා කළ හැකිය , නමුත් මෙම ගැටලුවට වඩාත් අලංකාර විසඳුමක් ඇතැයි මම සිතීමට කැමැත්තෙමි.

ප්‍රමුඛ, පසුපස හා අතරමැදි සුදු අවකාශය අඩංගු විචල්‍යයක් නිර්වචනය කරමු:

FOO=' test test test '
echo -e "FOO='${FOO}'"
# > FOO=' test test test '
echo -e "length(FOO)==${#FOO}"
# > length(FOO)==16

(නිර්වචනයක් සියලු whitespace ඉවත් කරන්නේ කොහොමද [:space:]දී tr):

FOO=' test test test '
FOO_NO_WHITESPACE="$(echo -e "${FOO}" | tr -d '[:space:]')"
echo -e "FOO_NO_WHITESPACE='${FOO_NO_WHITESPACE}'"
# > FOO_NO_WHITESPACE='testtesttest'
echo -e "length(FOO_NO_WHITESPACE)==${#FOO_NO_WHITESPACE}"
# > length(FOO_NO_WHITESPACE)==12

ප්‍රමුඛ සුදු අවකාශය පමණක් ඉවත් කරන්නේ කෙසේද:

FOO=' test test test '
FOO_NO_LEAD_SPACE="$(echo -e "${FOO}" | sed -e 's/^[[:space:]]*//')"
echo -e "FOO_NO_LEAD_SPACE='${FOO_NO_LEAD_SPACE}'"
# > FOO_NO_LEAD_SPACE='test test test '
echo -e "length(FOO_NO_LEAD_SPACE)==${#FOO_NO_LEAD_SPACE}"
# > length(FOO_NO_LEAD_SPACE)==15

පසුපස හිස් අවකාශය පමණක් ඉවත් කරන්නේ කෙසේද:

FOO=' test test test '
FOO_NO_TRAIL_SPACE="$(echo -e "${FOO}" | sed -e 's/[[:space:]]*$//')"
echo -e "FOO_NO_TRAIL_SPACE='${FOO_NO_TRAIL_SPACE}'"
# > FOO_NO_TRAIL_SPACE=' test test test'
echo -e "length(FOO_NO_TRAIL_SPACE)==${#FOO_NO_TRAIL_SPACE}"
# > length(FOO_NO_TRAIL_SPACE)==15

ප්‍රමුඛ හා පසුපස අවකාශ දෙකම ඉවත් කරන්නේ කෙසේද - දම්වැල sed:

FOO=' test test test '
FOO_NO_EXTERNAL_SPACE="$(echo -e "${FOO}" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')"
echo -e "FOO_NO_EXTERNAL_SPACE='${FOO_NO_EXTERNAL_SPACE}'"
# > FOO_NO_EXTERNAL_SPACE='test test test'
echo -e "length(FOO_NO_EXTERNAL_SPACE)==${#FOO_NO_EXTERNAL_SPACE}"
# > length(FOO_NO_EXTERNAL_SPACE)==14

විකල්පයක් ලෙස, ඔබේ බෑෂ් එයට සහය දක්වන්නේ නම්, ඔබට ඒ echo -e "${FOO}" | sed ...හා sed ... <<<${FOO}සමාන ආදේශ කළ හැකිය (සුදු අවකාශය පසුපස යාම සඳහා):

FOO_NO_TRAIL_SPACE="$(sed -e 's/[[:space:]]*$//' <<<${FOO})"

සරල පිළිතුරක් නම්:

echo "   lol  " | xargs

Xargs ඔබ වෙනුවෙන් කැපීම කරනු ඇත. එය එක් විධානයක් / වැඩසටහනකි, පරාමිතීන් නොමැත, කැපූ නූල නැවත ලබා දෙයි, එය පහසුය!

සටහන: මෙය සියලු අභ්‍යන්තර අවකාශයන් ඉවත් නොකරන බැවින් "foo bar"එක හා සමාන වේ; එය බවට පත් නොවේ "foobar". කෙසේ වෙතත්, බහු අවකාශයන් තනි අවකාශයන්ට ensed නීභවනය වන බැවින් "foo bar"එය බවට පත්වේ "foo bar". ඊට අමතරව එය පේළි අක්ෂරවල අවසානය ඉවත් නොකරයි.

ආදේශකයක් ලෙස හැඳින්වෙන Bash බිල්ට්-ඉන්ස් පමණක් භාවිතා කරන විසඳුමක් තිබේ :

var="    abc    "
# remove leading whitespace characters
var="${var#"${var%%[![:space:]]*}"}"
# remove trailing whitespace characters
var="${var%"${var##*[![:space:]]}"}"   
printf '%s' "===$var==="

ශ්‍රිතයක ඔතා ඇති දේ මෙන්න:

trim() {
    local var="$*"
    # remove leading whitespace characters
    var="${var#"${var%%[![:space:]]*}"}"
    # remove trailing whitespace characters
    var="${var%"${var##*[![:space:]]}"}"   
    printf '%s' "$var"
}

උපුටා ගත් ස්වරූපයෙන් කැපීමට ඔබ නූල පසු කරයි. උදා:

trim "   abc   "

මෙම විසඳුම පිළිබඳ හොඳ දෙයක් නම්, එය ඕනෑම POSIX- අනුකූල කවචයක් සමඟ ක්‍රියා කරනු ඇත.

යොමුව

• ප්‍රමුඛ හා පසුපස සුදු අවකාශය බාෂ් විචල්‍යයකින් ඉවත් කරන්න ( මුල් ප්‍රභවය )

Bash හි පරාමිති ප්‍රසාරණය යනුවෙන් හැඳින්වෙන අංගයක් ඇති අතර, වෙනත් දේ අතර ඊනියා රටා මත පදනම්ව නූල් ප්‍රතිස්ථාපනය කිරීමට ඉඩ ලබා දේ (රටා නිත්‍ය ප්‍රකාශන වලට සමාන ය, නමුත් මූලික වෙනස්කම් හා සීමාවන් ඇත). [flussence හි මුල් පේළිය: Bash හි නිත්‍ය ප්‍රකාශන ඇත, නමුත් ඒවා හොඳින් සැඟවී ඇත:]

පහත දැක්වෙන්නේ විචල්‍ය අගයකින් සියලු සුදු අවකාශය (අභ්‍යන්තරයෙන් පවා) ඉවත් කරන්නේ කෙසේද යන්නයි .

$ var='abc def'
$ echo "$var"
abc def
# Note: flussence's original expression was "${var/ /}", which only replaced the *first* space char., wherever it appeared.
$ echo -n "${var//[[:space:]]/}"
abcdef

නූලක ආරම්භයේ සහ අවසානයේ සිට සියලු අවකාශයන් ඉවත් කිරීම සඳහා (රේඛා අක්ෂරවල අවසානය ඇතුළුව):

echo $variable | xargs echo -n

මෙය අනුපිටපත් අවකාශයන් ද ඉවත් කරයි:

echo "  this string has a lot       of spaces " | xargs echo -n

නිෂ්පාදනය කරයි: 'මෙම නූලට විශාල ඉඩ ප්‍රමාණයක් ඇත'

එක් ප්‍රමුඛ හා පසුපස ස්ථානයක් ඉවත් කරන්න

trim()
{
    local trimmed="$1"

    # Strip leading space.
    trimmed="${trimmed## }"
    # Strip trailing space.
    trimmed="${trimmed%% }"

    echo "$trimmed"
}

උදාහරණයක් වශයෙන්:

test1="$(trim " one leading")"
test2="$(trim "one trailing ")"
test3="$(trim " one leading and one trailing ")"
echo "'$test1', '$test2', '$test3'"

ප්‍රතිදානය:

'one leading', 'one trailing', 'one leading and one trailing'

අහිමි සෑම ප්රධාන හා අවර අවකාශයන්

trim()
{
    local trimmed="$1"

    # Strip leading spaces.
    while [[ $trimmed == ' '* ]]; do
       trimmed="${trimmed## }"
    done
    # Strip trailing spaces.
    while [[ $trimmed == *' ' ]]; do
        trimmed="${trimmed%% }"
    done

    echo "$trimmed"
}

උදාහරණයක් වශයෙන්:

test4="$(trim "  two leading")"
test5="$(trim "two trailing  ")"
test6="$(trim "  two leading and two trailing  ")"
echo "'$test4', '$test5', '$test6'"

ප්‍රතිදානය:

'two leading', 'two trailing', 'two leading and two trailing'

මත බෑෂ් මාර්ගෝපදේශය අංශයෙන් globbing

පරාමිති ප්‍රසාරණයක දී extglob භාවිතා කිරීම

 #Turn on extended globbing  
shopt -s extglob  
 #Trim leading and trailing whitespace from a variable  
x=${x##+([[:space:]])}; x=${x%%+([[:space:]])}  
 #Turn off extended globbing  
shopt -u extglob  

ශ්‍රිතයක් තුළ ඔතා ඇති එකම ක්‍රියාකාරිත්වය මෙන්න (සටහන: ක්‍රියාකාරීත්වයට සම්මත ආදාන වචන උපුටා දැක්වීමට අවශ්‍යය):

trim() {
    # Determine if 'extglob' is currently on.
    local extglobWasOff=1
    shopt extglob >/dev/null && extglobWasOff=0 
    (( extglobWasOff )) && shopt -s extglob # Turn 'extglob' on, if currently turned off.
    # Trim leading and trailing whitespace
    local var=$1
    var=${var##+([[:space:]])}
    var=${var%%+([[:space:]])}
    (( extglobWasOff )) && shopt -u extglob # If 'extglob' was off before, turn it back off.
    echo -n "$var"  # Output trimmed string.
}

භාවිතය:

string="   abc def ghi  ";
#need to quote input-string to preserve internal white-space if any
trimmed=$(trim "$string");  
echo "$trimmed";

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

trim() {
    shopt -s extglob
    set -- "${1##+([[:space:]])}"
    printf "%s" "${1%%+([[:space:]])}" 
}

නිසා:

$ s=$'\t\n \r\tfoo  '
$ shopt -u extglob
$ shopt extglob
extglob         off
$ printf ">%q<\n" "$s" "$(trim "$s")"
>$'\t\n \r\tfoo  '<
>foo<
$ shopt extglob
extglob         off

ඔබට මෙය සරලව කපා ගත හැකිය echo:

foo=" qsdqsd qsdqs q qs   "

# Not trimmed
echo \'$foo\'

# Trim
foo=`echo $foo`

# Trimmed
echo \'$foo\'

මම හැම විටම එය sed සමඟ කර ඇත

  var=`hg st -R "$path" | sed -e 's/  *$//'`

වඩාත් අලංකාර විසඳුමක් තිබේ නම්, කවුරුහරි එය පළ කරනු ඇතැයි මම බලාපොරොත්තු වෙමි.

ඔබට නව රේඛා මකා දැමිය හැක්කේ tr:

var=`hg st -R "$path" | tr -d '\n'`
if [ -n $var ]; then
    echo $var
done

Bash හි දීර් pattern රටා ගැලපුම් අංග සක්‍රිය කර ඇති විට ( shopt -s extglob), ඔබට මෙය භාවිතා කළ හැකිය:

{trimmed##*( )}

අත්තනෝමතික ප්‍රමුඛ අවකාශයන් ඉවත් කිරීමට.

# Trim whitespace from both ends of specified parameter

trim () {
    read -rd '' $1 <<<"${!1}"
}

# Unit test for trim()

test_trim () {
    local foo="$1"
    trim foo
    test "$foo" = "$2"
}

test_trim hey hey &&
test_trim '  hey' hey &&
test_trim 'ho  ' ho &&
test_trim 'hey ho' 'hey ho' &&
test_trim '  hey  ho  ' 'hey  ho' &&
test_trim $'\n\n\t hey\n\t ho \t\n' $'hey\n\t ho' &&
test_trim $'\n' '' &&
test_trim '\n' '\n' &&
echo passed

පිළිතුරු ගොඩක් ඇත, නමුත් මගේ ලිඛිත පිටපත සඳහන් කිරීම වටී යැයි මම තවමත් විශ්වාස කරමි:

• එය ෂෙල් වෙඩි / බාෂ් / කාර්යබහුල පෙට්ටියේ සාර්ථකව අත්හදා බලන ලදී
• එය අතිශයින් කුඩා ය
• එය බාහිර විධාන මත රඳා නොපවතින අතර දෙබලක අවශ්‍ය නොවේ (-> වේගවත් හා අඩු සම්පත් භාවිතය)
• එය අපේක්ෂිත පරිදි ක්‍රියාත්මක වේ:
  • එය ආරම්භයේ සිට අවසානය දක්වා සියලු අවකාශයන් සහ ටැබ් ඉවත් කරයි, නමුත් වැඩි නොවේ
  • වැදගත්: එය නූල් මැදින් කිසිවක් ඉවත් නොකරයි (තවත් බොහෝ පිළිතුරු ඇත), නව රේඛා පවා පවතිනු ඇත
  • විශේෂ: "$*"එක් ඉඩක් භාවිතා කරමින් බහුවිධ තර්ක සමඟ සම්බන්ධ වේ. ඔබට පළමු තර්කය පමණක් කැපීමට හා ප්‍රතිදානය කිරීමට අවශ්‍ය නම් "$1"ඒ වෙනුවට භාවිතා කරන්න
  • ගැලපෙන ලිපිගොනු රටා ආදිය සමඟ කිසිදු ගැටළුවක් නොමැති නම්

පිටපත:

trim() {
  local s2 s="$*"
  until s2="${s#[[:space:]]}"; [ "$s2" = "$s" ]; do s="$s2"; done
  until s2="${s%[[:space:]]}"; [ "$s2" = "$s" ]; do s="$s2"; done
  echo "$s"
}

භාවිතය:

mystring="   here     is
    something    "
mystring=$(trim "$mystring")
echo ">$mystring<"

ප්‍රතිදානය:

>here     is
    something<

ඔබට පැරණි පාසල භාවිතා කළ හැකිය tr. නිදසුනක් ලෙස, මෙය git ගබඩාවක නවීකරණය කරන ලද ගොනු ගණන නැවත ලබා දෙයි.

MYVAR=`git ls-files -m|wc -l|tr -d ' '`

මෙය මට ප්‍රයෝජනවත් විය:

text="   trim my edges    "

trimmed=$text
trimmed=${trimmed##+( )} #Remove longest matching series of spaces from the front
trimmed=${trimmed%%+( )} #Remove longest matching series of spaces from the back

echo "<$trimmed>" #Adding angle braces just to make it easier to confirm that all spaces are removed

#Result
<trim my edges>

එකම ප්‍රති result ලය සඳහා එය අඩු රේඛා මත තැබීමට:

text="    trim my edges    "
trimmed=${${text##+( )}%%+( )}

# Strip leading and trailing white space (new line inclusive).
trim(){
    [[ "$1" =~ [^[:space:]](.*[^[:space:]])? ]]
    printf "%s" "$BASH_REMATCH"
}

හෝ

# Strip leading white space (new line inclusive).
ltrim(){
    [[ "$1" =~ [^[:space:]].* ]]
    printf "%s" "$BASH_REMATCH"
}

# Strip trailing white space (new line inclusive).
rtrim(){
    [[ "$1" =~ .*[^[:space:]] ]]
    printf "%s" "$BASH_REMATCH"
}

# Strip leading and trailing white space (new line inclusive).
trim(){
    printf "%s" "$(rtrim "$(ltrim "$1")")"
}

හෝ

# Strip leading and trailing specified characters.  ex: str=$(trim "$str" $'\n a')
trim(){
    if [ "$2" ]; then
        trim_chrs="$2"
    else
        trim_chrs="[:space:]"
    fi

    [[ "$1" =~ ^["$trim_chrs"]*(.*[^"$trim_chrs"])["$trim_chrs"]*$ ]]
    printf "%s" "${BASH_REMATCH[1]}"
}

හෝ

# Strip leading specified characters.  ex: str=$(ltrim "$str" $'\n a')
ltrim(){
    if [ "$2" ]; then
        trim_chrs="$2"
    else
        trim_chrs="[:space:]"
    fi

    [[ "$1" =~ ^["$trim_chrs"]*(.*[^"$trim_chrs"]) ]]
    printf "%s" "${BASH_REMATCH[1]}"
}

# Strip trailing specified characters.  ex: str=$(rtrim "$str" $'\n a')
rtrim(){
    if [ "$2" ]; then
        trim_chrs="$2"
    else
        trim_chrs="[:space:]"
    fi

    [[ "$1" =~ ^(.*[^"$trim_chrs"])["$trim_chrs"]*$ ]]
    printf "%s" "${BASH_REMATCH[1]}"
}

# Strip leading and trailing specified characters.  ex: str=$(trim "$str" $'\n a')
trim(){
    printf "%s" "$(rtrim "$(ltrim "$1" "$2")" "$2")"
}

හෝ

මදුරුවන්ගේ එක්ස්පර් ආත්මය මත ගොඩනැගීම ...

# Strip leading and trailing white space (new line inclusive).
trim(){
    printf "%s" "`expr "$1" : "^[[:space:]]*\(.*[^[:space:]]\)[[:space:]]*$"`"
}

හෝ

# Strip leading white space (new line inclusive).
ltrim(){
    printf "%s" "`expr "$1" : "^[[:space:]]*\(.*[^[:space:]]\)"`"
}

# Strip trailing white space (new line inclusive).
rtrim(){
    printf "%s" "`expr "$1" : "^\(.*[^[:space:]]\)[[:space:]]*$"`"
}

# Strip leading and trailing white space (new line inclusive).
trim(){
    printf "%s" "$(rtrim "$(ltrim "$1")")"
}

AWK භාවිතා කරන්න:

echo $var | awk '{gsub(/^ +| +$/,"")}1'

කාර්යය කිරීමට ස්ක්‍රිප්ට් විචල්‍ය පැවරුම් භාවිතා කරන බව මම දැක ඇත්තෙමි.

$ xyz=`echo -e 'foo \n bar'`
$ echo $xyz
foo bar

වයිට්ස්පේස් ස්වයංක්‍රීයව එකට එකතු වී කපා දමනු ලැබේ. යමෙකු ෂෙල් මෙටාචරැක්ටර්ස් (විභව එන්නත් කිරීමේ අවදානම) ගැන සැලකිලිමත් විය යුතුය.

ෂෙල් කොන්දේසි වල විචල්‍ය ආදේශක සෑම විටම ද්වි-උපුටා දැක්වීමට මම නිර්දේශ කරමි:

if [ -n "$var" ]; then

-o හෝ විචල්‍යයේ වෙනත් අන්තර්ගතයක් වැනි දෙයක් මඟින් ඔබේ පරීක්ෂණ තර්ක සංශෝධනය කළ හැකි බැවිනි.

var='   a b c   '
trimmed=$(echo $var)

මම සරලවම sed භාවිතා කරමි:

function trim
{
    echo "$1" | sed -n '1h;1!H;${;g;s/^[ \t]*//g;s/[ \t]*$//g;p;}'
}

a) තනි පේළියේ භාවිතා කිරීමේ උදාහරණය

string='    wordA wordB  wordC   wordD    '
trimmed=$( trim "$string" )

echo "GIVEN STRING: |$string|"
echo "TRIMMED STRING: |$trimmed|"

ප්‍රතිදානය:

GIVEN STRING: |    wordA wordB  wordC   wordD    |
TRIMMED STRING: |wordA wordB  wordC   wordD|

ආ) බහු රේඛා නූල් භාවිතා කිරීමේ උදාහරණය

string='    wordA
   >wordB<
wordC    '
trimmed=$( trim "$string" )

echo -e "GIVEN STRING: |$string|\n"
echo "TRIMMED STRING: |$trimmed|"

ප්‍රතිදානය:

GIVEN STRING: |    wordAA
   >wordB<
wordC    |

TRIMMED STRING: |wordAA
   >wordB<
wordC|

ඇ) අවසාන සටහන:
ඔබ ශ්‍රිතයක් භාවිතා කිරීමට අකමැති නම්, තනි පේළියක් සඳහා ඔබට "මතක තබා ගැනීමට පහසු" විධානයක් භාවිතා කළ හැකිය:

echo "$string" | sed -e 's/^[ \t]*//' | sed -e 's/[ \t]*$//'

උදාහරණයක්:

echo "   wordA wordB wordC   " | sed -e 's/^[ \t]*//' | sed -e 's/[ \t]*$//'

ප්‍රතිදානය:

wordA wordB wordC

ඉහත සඳහන් බහු රේඛා නූල් භාවිතා කිරීමද සාර්ථක වනු ඇත , නමුත් කරුණාකර සටහන් කර ඇති පරිදි ගුරුම් විසින් සටහන් කර ඇති පරිදි ඕනෑම පසුගාමී / ප්‍රමුඛ අභ්‍යන්තර බහුවිධ ඉඩක් කපා හරිනු ඇත.

string='    wordAA
    >four spaces before<
 >one space before<    '
echo "$string" | sed -e 's/^[ \t]*//' | sed -e 's/[ \t]*$//'

ප්‍රතිදානය:

wordAA
>four spaces before<
>one space before<

එබැවින් එම අවකාශයන් තබා ගැනීමට ඔබ සිතන්නේ නම්, කරුණාකර මගේ පිළිතුර ආරම්භයේ දී ශ්‍රිතය භාවිතා කරන්න!

)) ටිම් ශ්‍රිතය තුළ භාවිතා වන බහු රේඛා නූල් මත සෙඩ් සින්ටැක්ස් “සොයා ගැනීම සහ ප්‍රතිස්ථාපනය කිරීම” පැහැදිලි කිරීම:

sed -n '
# If the first line, copy the pattern to the hold buffer
1h
# If not the first line, then append the pattern to the hold buffer
1!H
# If the last line then ...
$ {
    # Copy from the hold to the pattern buffer
    g
    # Do the search and replace
    s/^[ \t]*//g
    s/[ \t]*$//g
    # print
    p
}'

සුදු අවකාශය කප්පාදු කර සාමාන්‍යකරණය කරන ට්‍රිම් () ශ්‍රිතයක් මෙන්න

#!/bin/bash
function trim {
    echo $*
}

echo "'$(trim "  one   two    three  ")'"
# 'one two three'

නිත්‍ය ප්‍රකාශන භාවිතා කරන තවත් ප්‍රභේදයකි.

#!/bin/bash
function trim {
    local trimmed="$@"
    if [[ "$trimmed" =~ " *([^ ].*[^ ]) *" ]]
    then 
        trimmed=${BASH_REMATCH[1]}
    fi
    echo "$trimmed"
}

echo "'$(trim "  one   two    three  ")'"
# 'one   two    three'

මෙය ඔබගේ සංගීතයෙන් සියලු සුදු අවකාශයන් ඉවත් කරනු ඇත,

 VAR2="${VAR2//[[:space:]]/}"

/පළමු සිදුවීම සහ //සුදු පැහැති අවකාශයේ සියලු සිදුවීම් ප්‍රතිස්ථාපනය කරයි . එනම් සියලු සුදු අවකාශයන් ප්‍රතිස්ථාපනය වේ - කිසිවක් නැත

පැවරුම් ප්‍රමුඛ හා පසුපස සුදු අවකාශය නොසලකා හරින අතර ඒවා කැපීමට භාවිතා කළ හැකිය:

$ var=`echo '   hello'`; echo $var
hello

මෙය අනවශ්‍ය ග්ලෝබ් කිරීම පිළිබඳ ගැටළුවක් නොවන අතර අභ්‍යන්තර සුදු අවකාශය නවීකරණය නොකෙරේ ( $IFSඑය පෙරනිමියට සකසා ඇතැයි උපකල්පනය කරයි ' \t\n').

එය පළමු නව රේඛාව දක්වා (සහ එය ඇතුළත් නොවේ) හෝ නූල් අවසානය දක්වා කියවන අතර, මුලින්ම එන දෙය, සහ ප්‍රමුඛ හා පසුපස අවකාශය සහ \tඅක්ෂරවල ඕනෑම මිශ්‍රණයක් ඉවත් කරයි. ඔබට බහුවිධ රේඛා සංරක්ෂණය කිරීමට අවශ්‍ය නම් (ඒ වගේම ප්‍රමුඛ පෙළේ සහ පසුපස නව රේඛා ඉවත් කරන්න), read -r -d '' var << eofඒ වෙනුවට භාවිතා කරන්න; කෙසේ වෙතත්, ඔබේ ආදානය අඩංගු \neofවුවහොත් එය මඳක් කපා දමනු ඇති බව සලකන්න. (ඔබ සුදු පැහැති අවකාශයේ වෙනත් ආකාර, එනම් \r, \fසහ \v, ඔබ ඒවා $ IFS වෙත එකතු කළත් ඉවත් නොකෙරේ .)

read -r var << eof
$var
eof

වමේ සිට පළමු වචනය දක්වා අවකාශ සහ ටැබ් ඉවත් කිරීමට, ඇතුළත් කරන්න:

echo "     This is a test" | sed "s/^[ \t]*//"

cyberciti.biz/tips/delete-leading-spaces-from-front-of-each-word.html

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

if [[ "$test" =~ ^[[:space:]]*([^[:space:]].*[^[:space:]])[[:space:]]*$ ]]
then 
    test=${BASH_REMATCH[1]}
fi

මෙය පරීක්ෂා කිරීම සඳහා නියැදි පිටපතක් මෙන්න:

test=$(echo -e "\n \t Spaces and tabs and newlines be gone! \t  \n ")

echo "Let's see if this works:"
echo
echo "----------"
echo -e "Testing:${test} :Tested"  # Ugh!
echo "----------"
echo
echo "Ugh!  Let's fix that..."

if [[ "$test" =~ ^[[:space:]]*([^[:space:]].*[^[:space:]])[[:space:]]*$ ]]
then 
    test=${BASH_REMATCH[1]}
fi

echo
echo "----------"
echo -e "Testing:${test}:Tested"  # "Testing:Spaces and tabs and newlines be gone!"
echo "----------"
echo
echo "Ah, much better."

පයිතන්ට strip()PHP වලට සමානව ක්‍රියා කරන ශ්‍රිතයක් ඇත trim(), එබැවින් අපට මේ සඳහා පහසුවෙන් තේරුම් ගත හැකි උපයෝගීතාවයක් ලබා ගැනීම සඳහා කුඩා පේළි කිහිපයක් කළ හැකිය:

alias trim='python -c "import sys; sys.stdout.write(sys.stdin.read().strip())"'

මෙය ප්‍රමුඛ හා පසුපස සුදු අවකාශය (නව රේඛා ඇතුළුව) කපා දමනු ඇත.

$ x=`echo -e "\n\t   \n" | trim`
$ if [ -z "$x" ]; then echo hi; fi
hi

එක් අවකාශයකට අවකාශය ඉවත් කිරීම:

(text) | fmt -su

මෙය ඉදිරිපස සහ කෙළවරේ බහු අවකාශයන් කපා දමයි

whatever=${whatever%% *}

whatever=${whatever#* }

#!/bin/bash

function trim
{
    typeset trimVar
    eval trimVar="\${$1}"
    read trimVar << EOTtrim
    $trimVar
EOTtrim
    eval $1=\$trimVar
}

# Note that the parameter to the function is the NAME of the variable to trim, 
# not the variable contents.  However, the contents are trimmed.


# Example of use:
while read aLine
do
    trim aline
    echo "[${aline}]"
done < info.txt



# File info.txt contents:
# ------------------------------
# ok  hello there    $
#    another  line   here     $
#and yet another   $
#  only at the front$
#$



# Output:
#[ok  hello there]
#[another  line   here]
#[and yet another]
#[only at the front]
#[]