Làm thế nào để cắt khoảng trắng từ một biến Bash?

Tôi có một kịch bản shell với mã này:

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

Nhưng mã điều kiện luôn luôn thực thi, bởi vì hg stluôn in ít nhất một ký tự dòng mới.

• Có cách nào đơn giản để loại bỏ khoảng trắng từ $var(như trim()trong PHP ) không?

hoặc là

• Có một cách tiêu chuẩn để đối phó với vấn đề này?

Tôi có thể sử dụng sed hoặc AWK , nhưng tôi muốn nghĩ rằng có một giải pháp thanh lịch hơn cho vấn đề này.

Hãy xác định một biến chứa khoảng trắng hàng đầu, dấu và trung gian:

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

Cách xóa tất cả khoảng trắng (ký hiệu là [:space:]trong 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

Cách xóa chỉ khoảng trắng hàng đầu:

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

Cách xóa chỉ khoảng trắng theo sau:

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

Cách xóa cả dấu cách hàng đầu và dấu cách - xâu chuỗi 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

Ngoài ra, nếu bash của bạn hỗ trợ nó, bạn có thể thay thế echo -e "${FOO}" | sed ...bằng sed ... <<<${FOO}, như vậy (đối với khoảng trắng theo sau):

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

Một câu trả lời đơn giản là:

echo "   lol  " | xargs

Xargs sẽ làm việc cắt tỉa cho bạn. Đó là một lệnh / chương trình, không có tham số, trả về chuỗi được cắt xén, dễ dàng như vậy!

Lưu ý: điều này không loại bỏ tất cả các không gian nội bộ để "foo bar"giữ nguyên; nó KHÔNG trở thành "foobar". Tuy nhiên, nhiều không gian sẽ được cô đọng thành các không gian duy nhất, do đó "foo bar"sẽ trở thành "foo bar". Ngoài ra, nó không loại bỏ cuối dòng ký tự.

Có một giải pháp chỉ sử dụng Bash dựng sẵn được gọi là ký tự đại diện :

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

Đây là cùng một gói trong một chức năng:

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

Bạn vượt qua chuỗi được cắt ở dạng trích dẫn. ví dụ:

trim "   abc   "

Một điều tuyệt vời về giải pháp này là nó sẽ hoạt động với mọi vỏ tương thích POSIX.

Tài liệu tham khảo

• Xóa khoảng trắng hàng đầu & dấu kiểm khỏi biến Bash ( nguồn gốc )

Bash có một tính năng gọi là mở rộng tham số , trong số những thứ khác, cho phép thay thế chuỗi dựa trên các mẫu được gọi là (các mẫu giống với các biểu thức thông thường, nhưng có những khác biệt và hạn chế cơ bản). [dòng gốc của flussence: Bash có các biểu thức chính quy, nhưng chúng được giấu kỹ:]

Dưới đây trình bày cách loại bỏ tất cả khoảng trắng (thậm chí từ bên trong) khỏi giá trị biến.

$ 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

Để xóa tất cả các khoảng trắng từ đầu và cuối chuỗi (bao gồm cả các ký tự cuối dòng):

echo $variable | xargs echo -n

Điều này cũng sẽ loại bỏ các không gian trùng lặp:

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

Sản xuất: 'chuỗi này có nhiều khoảng trắng'

Tách một không gian hàng đầu và một dấu

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Ví dụ:

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

Đầu ra:

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

Tách tất cả các không gian hàng đầu và dấu

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Ví dụ:

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

Đầu ra:

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

Từ phần Bash Guide trên globalbing

Để sử dụng một extglob trong một mở rộng tham số

 #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  

Đây là chức năng tương tự được bao bọc trong một chức năng (LƯU Ý: Cần trích dẫn chuỗi đầu vào được truyền cho chức năng):

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

Sử dụng:

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

Nếu chúng ta thay đổi hàm để thực thi trong một lớp con, chúng ta không phải lo lắng về việc kiểm tra tùy chọn shell hiện tại cho extglob, chúng ta chỉ có thể đặt nó mà không ảnh hưởng đến shell hiện tại. Điều này đơn giản hóa các chức năng rất nhiều. Tôi cũng cập nhật các tham số vị trí "tại chỗ" vì vậy tôi thậm chí không cần một biến cục bộ

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

vì thế:

$ 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

Bạn có thể cắt đơn giản với echo:

foo=" qsdqsd qsdqs q qs   "

# Not trimmed
echo \'$foo\'

# Trim
foo=`echo $foo`

# Trimmed
echo \'$foo\'

Tôi đã luôn luôn làm nó với sed

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

Nếu có một giải pháp thanh lịch hơn, tôi hy vọng ai đó đăng nó.

Bạn có thể xóa các dòng mới với tr:

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

Với các tính năng khớp mẫu mở rộng của Bash được bật ( shopt -s extglob), bạn có thể sử dụng tính năng này:

{trimmed##*( )}

để loại bỏ một lượng không gian hàng đầu tùy ý.

# 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

Có rất nhiều câu trả lời, nhưng tôi vẫn tin rằng kịch bản vừa viết của mình đáng được nhắc đến vì:

• nó đã được thử nghiệm thành công trong shell bash / dash / busybox shell
• nó rất nhỏ
• nó không phụ thuộc vào các lệnh bên ngoài và không cần rẽ nhánh (-> sử dụng tài nguyên nhanh và thấp)
• nó hoạt động như mong đợi:
  • nó loại bỏ tất cả các khoảng trắng và tab từ đầu đến cuối, nhưng không nhiều hơn
  • quan trọng: nó không xóa bất cứ điều gì từ giữa chuỗi (nhiều câu trả lời khác làm), thậm chí các dòng mới sẽ vẫn còn
  • đặc biệt: "$*"tham gia nhiều đối số bằng một khoảng trắng. nếu bạn muốn cắt và chỉ xuất ra đối số đầu tiên, "$1"thay vào đó hãy sử dụng
  • nếu không có bất kỳ vấn đề nào với các mẫu tên tệp phù hợp, v.v.

Kịch bản:

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

Sử dụng:

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

Đầu ra:

>here     is
    something<

Bạn có thể sử dụng trường học cũ tr. Ví dụ, cái này trả về số lượng tệp đã sửa đổi trong kho git, khoảng trắng bị tước.

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

Điều này làm việc cho tôi:

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>

Để đặt nó trên ít dòng hơn cho cùng một kết quả:

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

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

HOẶC LÀ

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

HOẶC LÀ

# 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]}"
}

HOẶC LÀ

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

HOẶC LÀ

Xây dựng dựa trên linh hồn expr ...

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

HOẶC LÀ

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

Tôi đã thấy các tập lệnh chỉ sử dụng phép gán biến để thực hiện công việc:

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

Khoảng trắng được tự động kết hợp và cắt xén. Người ta phải cẩn thận với các siêu ký tự vỏ (nguy cơ tiêm tiềm năng).

Tôi cũng khuyên bạn nên luôn luôn trích dẫn thay thế hai lần trong điều kiện shell:

if [ -n "$var" ]; then

vì một cái gì đó như -o hoặc nội dung khác trong biến có thể sửa đổi các đối số thử nghiệm của bạn.

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

Tôi chỉ đơn giản là sử dụng sed:

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

a) Ví dụ về cách sử dụng trên chuỗi đơn

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

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

Đầu ra:

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

b) Ví dụ về cách sử dụng trên chuỗi nhiều dòng

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

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

Đầu ra:

GIVEN STRING: |    wordAA
   >wordB<
wordC    |

TRIMMED STRING: |wordAA
   >wordB<
wordC|

c) Lưu ý cuối cùng:
Nếu bạn không muốn sử dụng hàm, đối với chuỗi dòng đơn, bạn chỉ cần sử dụng lệnh "dễ nhớ hơn" như:

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

Thí dụ:

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

Đầu ra:

wordA wordB wordC

Sử dụng ở trên trên các chuỗi nhiều dòng cũng sẽ hoạt động , nhưng xin lưu ý rằng nó cũng sẽ cắt bất kỳ không gian nội bộ kéo dài / hàng đầu nào, như GurM nhận thấy trong các bình luận

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

Đầu ra:

wordAA
>four spaces before<
>one space before<

Vì vậy, nếu bạn có ý định giữ những khoảng trống đó, vui lòng sử dụng chức năng ở đầu câu trả lời của tôi!

d) GIẢI THÍCH cú pháp sed "tìm và thay thế" trên các chuỗi nhiều dòng được sử dụng bên trong hàm trim:

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

Đây là hàm trim () cắt và chuẩn hóa khoảng trắng

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

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

Và một biến thể khác sử dụng biểu thức thông thường.

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

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

Sử dụng AWK:

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

Bài tập bỏ qua khoảng trắng hàng đầu và dấu và như vậy có thể được sử dụng để cắt:

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

Điều này không có vấn đề với việc tạo khối không mong muốn, ngoài ra, không gian trắng bên trong không được sửa đổi (giả sử $IFSđược đặt thành mặc định, đó là ' \t\n').

Nó đọc đến dòng mới đầu tiên (và không bao gồm nó) hoặc phần cuối của chuỗi, tùy theo điều kiện nào đến trước và loại bỏ mọi kết hợp giữa không gian và \tký tự hàng đầu và dấu . Nếu bạn muốn duy trì nhiều dòng (và cả dải dòng mới và hàng đầu), read -r -d '' var << eofthay vào đó , hãy sử dụng ; tuy nhiên, lưu ý rằng nếu đầu vào của bạn có chứa \neof, nó sẽ bị cắt ngay trước đó. (Các dạng khác của khoảng trắng, cụ thể là \r, \fvà \v, không bị tước, ngay cả khi bạn thêm chúng vào $ IFS.)

read -r var << eof
$var
eof

Để xóa khoảng trắng và tab từ trái sang từ đầu tiên, hãy nhập:

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

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

Điều này sẽ xóa tất cả các khoảng trắng khỏi Chuỗi của bạn,

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

/thay thế lần xuất hiện đầu tiên và //tất cả sự xuất hiện của khoảng trắng trong chuỗi. Tức là tất cả các khoảng trắng được thay thế bởi - không có gì

Đây là phương pháp đơn giản nhất tôi từng thấy. Nó chỉ sử dụng Bash, nó chỉ có một vài dòng, biểu thức chính là đơn giản và phù hợp với tất cả các dạng khoảng trắng:

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

Đây là một kịch bản mẫu để kiểm tra nó với:

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 có một chức năng strip()hoạt động giống hệt với PHP trim(), vì vậy chúng ta chỉ cần thực hiện một Python nhỏ nội tuyến để tạo ra một tiện ích dễ hiểu cho việc này:

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

Điều này sẽ cắt khoảng trắng hàng đầu và dấu (bao gồm cả dòng mới).

$ 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]
#[]

Tôi thấy rằng tôi cần thêm một số mã từ một sdiffđầu ra lộn xộn để dọn sạch nó:

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'

Điều này loại bỏ các dấu cách và các ký tự vô hình khác.

Xóa không gian thành một không gian:

(text) | fmt -su