วิธีการตัดช่องว่างจากตัวแปร Bash?

ฉันมีเชลล์สคริปต์ด้วยรหัสนี้:

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

แต่รหัสเงื่อนไขจะดำเนินการhg stเสมอเพราะพิมพ์อักขระบรรทัดใหม่อย่างน้อยหนึ่งตัว

• มีวิธีง่ายๆในการตัดช่องว่างจาก$var(เช่นtrim()ในPHP )?

หรือ

• มีวิธีมาตรฐานในการจัดการกับปัญหานี้หรือไม่?

ฉันสามารถใช้sedหรือAWKได้ แต่ฉันคิดว่ามันมีทางออกที่ดีกว่าสำหรับปัญหานี้

มานิยามตัวแปรที่มีช่องว่างนำหน้าต่อท้ายและช่องว่างกลาง:

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

วิธีลบช่องว่างทั้งหมด (แสดงโดย[: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

วิธีลบช่องว่างนำหน้าและต่อท้าย - เชื่อมโยงseds:

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

หรือถ้า bash ของคุณรองรับคุณสามารถแทนที่echo -e "${FOO}" | sed ...ด้วยsed ... <<<${FOO}เช่น (สำหรับช่องว่างต่อท้าย):

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

คำตอบง่ายๆคือ:

echo "   lol  " | xargs

xargsจะทำการตัดแต่งให้คุณ มันเป็นหนึ่งในคำสั่ง / โปรแกรมไม่มีพารามิเตอร์ส่งคืนสตริงที่ถูกตัดง่าย ๆ !

หมายเหตุ: นี่จะไม่ลบช่องว่างภายในทั้งหมด "foo bar"เหมือนเดิม "foobar"มันไม่ได้กลายเป็น แต่ช่องว่างหลายจะข้นไปที่ช่องว่างเดียวดังนั้นจะกลายเป็น"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 ( ต้นฉบับดั้งเดิม )

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'

จากส่วน Bash Guide บน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";

หากเราเปลี่ยนฟังก์ชั่นให้ทำงานใน subshell เราไม่ต้องกังวลเกี่ยวกับการตรวจสอบตัวเลือกเชลล์ปัจจุบันสำหรับ 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\'

ฉันมักจะทำมันด้วยความใจเย็น

  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 ที่เปิดใช้งาน ( 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

มีคำตอบมากมาย แต่ฉันก็ยังเชื่อว่าสคริปต์ที่เพิ่งเขียนของฉันมีค่าควรถูกกล่าวถึงเพราะ:

• ถูกทดสอบสำเร็จในเชลล์ bash / dash / busybox shell
• มันมีขนาดเล็กมาก
• มันไม่ได้ขึ้นอยู่กับคำสั่งภายนอกและไม่จำเป็นต้องแยก (-> การใช้ทรัพยากรอย่างรวดเร็วและต่ำ)
• มันทำงานได้ตามที่คาดไว้:
  • มันแถบทุกพื้นที่และแท็บจากจุดเริ่มต้นและจุดสิ้นสุด แต่ไม่
  • สำคัญ: มันจะไม่ลบสิ่งใดออกจากกลางสตริง (มีคำตอบอื่น ๆ อีกมากมาย) แม้จะขึ้นบรรทัดใหม่
  • พิเศษ: การ"$*"รวมหลายอาร์กิวเมนต์โดยใช้หนึ่งช่องว่าง หากคุณต้องการตัดและแสดงเฉพาะอาร์กิวเมนต์แรกให้ใช้"$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 ซึ่ง whitespaces ถูกปล้น

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>

หากต้องการวางลงบนบรรทัดที่น้อยกว่าสำหรับผลลัพธ์เดียวกัน:

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")")"
}

ฉันเคยเห็นสคริปต์ใช้การกำหนดตัวแปรเพื่อทำงาน:

$ 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|

b) ตัวอย่างการใช้งานกับสตริงหลายบรรทัด

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|

c) หมายเหตุสุดท้าย:
หากคุณไม่ต้องการใช้ฟังก์ชั่นสำหรับสตริงบรรทัดเดียวคุณสามารถใช้คำสั่ง "ง่ายต่อการจดจำ" เช่น:

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

การใช้สตริงด้านบนแบบหลายบรรทัดด้านบนจะใช้งานได้เช่นกันแต่โปรดทราบว่ามันจะตัดส่วนต่อท้าย / นำหน้าหลาย ๆ ช่องว่างภายในเช่นเดียวกับที่ GuruM สังเกตเห็นในความคิดเห็น

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<

ดังนั้นถ้าคุณตั้งใจจะรักษาช่องว่างเหล่านั้นโปรดใช้ฟังก์ชั่นที่จุดเริ่มต้นของคำตอบของฉัน!

d) คำอธิบายของไวยากรณ์ sed "ค้นหาและแทนที่" บนสตริงหลายบรรทัดที่ใช้ในการตัดแต่งฟังก์ชั่น:

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'

ใช้ AWK:

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

การมอบหมายไม่สนใจช่องว่างนำหน้าและต่อท้ายและสามารถใช้ในการตัด:

$ 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

สิ่งนี้จะลบช่องว่างทั้งหมดออกจากสตริงของคุณ

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

/แทนที่การเกิดขึ้นครั้งแรกและการ//เกิด whitespaces ทั้งหมดในสตริง คือช่องว่างสีขาวทั้งหมดถูกแทนที่ด้วย - ไม่มีอะไร

นี่เป็นวิธีที่ง่ายที่สุดที่ฉันเคยเห็น มันใช้ Bash เพียงไม่กี่บรรทัด regexp นั้นง่ายและตรงกับทุกรูปแบบของช่องว่าง:

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."

Python มีฟังก์ชั่นstrip()ที่ทำงานเหมือนกับ PHP'strim()ดังนั้นเราสามารถทำ Python แบบอินไลน์เพียงเล็กน้อยเพื่อสร้างยูทิลิตี้ที่เข้าใจได้ง่ายสำหรับสิ่งนี้:

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

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

ฉันพบว่าฉันต้องการเพิ่มโค้ดบางอย่างจากsdiffเอาท์พุตยุ่ง ๆเพื่อทำความสะอาด:

sdiff -s column1.txt column2.txt | grep -F '<' | cut -f1 -d"<" > c12diff.txt 
sed -n 1'p' c12diff.txt | sed 's/ *$//g' | tr -d '\n' | tr -d '\t'

สิ่งนี้จะลบช่องว่างต่อท้ายและอักขระที่มองไม่เห็นอื่น ๆ

การลบช่องว่างออกเป็นหนึ่งช่องว่าง:

(text) | fmt -su