Jak przyciąć białe znaki ze zmiennej Bash?

Mam skrypt powłoki z tym kodem:

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

Ale kod warunkowy zawsze wykonuje się, ponieważ hg stzawsze drukuje co najmniej jeden znak nowej linii.

• Czy istnieje prosty sposób na usunięcie białych znaków $var(jak trim()w PHP )?

lub

• Czy istnieje standardowy sposób radzenia sobie z tym problemem?

Mógłbym użyć sed lub AWK , ale chciałbym pomyśleć, że istnieje bardziej eleganckie rozwiązanie tego problemu.

Zdefiniujmy zmienną zawierającą początkowe, końcowe i pośrednie białe znaki:

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

Jak usunąć wszystkie białe znaki (oznaczone przez [:space:]in 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

Jak usunąć tylko wiodące białe znaki:

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

Jak usunąć tylko końcowe białe znaki:

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

Jak usunąć zarówno początkowe, jak i końcowe spacje - połącz łańcuchy 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

Alternatywnie, jeśli bash obsługuje tę funkcję, można wymienić echo -e "${FOO}" | sed ...ze sed ... <<<${FOO}jak tak (za końcowe białe znaki):

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

Prosta odpowiedź to:

echo "   lol  " | xargs

Xargs wykona dla Ciebie przycinanie. To jedno polecenie / program, bez parametrów, zwraca przycięty ciąg znaków, to proste!

Uwaga: to nie usuwa wszystkich wewnętrznych spacji, więc "foo bar"pozostaje takie samo; NIE staje się "foobar". Jednak wiele spacji zostanie skondensowanych do pojedynczych spacji, więc "foo bar"stanie się "foo bar". Ponadto nie usuwa znaków końca linii.

Istnieje rozwiązanie wykorzystujące tylko wbudowane Bash zwane symbolami wieloznacznymi :

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

Oto to samo zawinięte w funkcję:

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

Podajesz ciąg do przycięcia w formie cytowanej. na przykład:

trim "   abc   "

Zaletą tego rozwiązania jest to, że będzie ono działać z dowolną powłoką zgodną z POSIX.

Odniesienie

• Usuń wiodące i końcowe białe spacje ze zmiennej Bash ( oryginalne źródło )

Bash ma funkcję zwaną rozszerzaniem parametrów , która między innymi umożliwia zamianę ciągów w oparciu o tak zwane wzorce (wzorce przypominają wyrażenia regularne, ale istnieją podstawowe różnice i ograniczenia). [oryginalny wiersz flussence: Bash ma wyrażenia regularne, ale są dobrze ukryte:]

Poniżej pokazano, jak usunąć całą spację (nawet z wnętrza) ze zmiennej wartości.

$ 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

Aby usunąć wszystkie spacje od początku i końca ciągu (w tym znaki końca wiersza):

echo $variable | xargs echo -n

Spowoduje to również usunięcie duplikatów:

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

Tworzy: „ten ciąg ma wiele spacji”

Usuń jedną przestrzeń wiodącą i jedną końcową

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Na przykład:

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

Wynik:

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

Usuń wszystkie wiodące i końcowe spacje

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Na przykład:

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

Wynik:

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

Z sekcji Przewodnik po Bash na temat globowania

Aby użyć extglob w rozszerzeniu parametru

 #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  

Oto ta sama funkcjonalność zawarta w funkcji (UWAGA: Należy zacytować ciąg wejściowy przekazany do funkcji):

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

Stosowanie:

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

Jeśli zmienimy funkcję, aby była wykonywana w podpowłoce, nie musimy się martwić o sprawdzenie bieżącej opcji powłoki dla extglob, możemy po prostu ustawić ją bez wpływu na bieżącą powłokę. Upraszcza to ogromnie tę funkcję. Aktualizuję również parametry pozycyjne „na miejscu”, więc nawet nie potrzebuję zmiennej lokalnej

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

więc:

$ 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

Możesz przycinać po prostu za pomocą echo:

foo=" qsdqsd qsdqs q qs   "

# Not trimmed
echo \'$foo\'

# Trim
foo=`echo $foo`

# Trimmed
echo \'$foo\'

Zawsze robiłem to z sedem

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

Jeśli istnieje bardziej eleganckie rozwiązanie, mam nadzieję, że ktoś je opublikuje.

Możesz usunąć nowe linie za pomocą tr:

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

Po włączeniu funkcji rozszerzonego dopasowania wzorca Bash ( shopt -s extglob) możesz użyć tego:

{trimmed##*( )}

aby usunąć dowolną liczbę wiodących spacji.

# 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

Istnieje wiele odpowiedzi, ale nadal uważam, że mój właśnie napisany skrypt jest wart wspomnienia, ponieważ:

• został pomyślnie przetestowany w powłoce powłoki bash / dash / busybox
• jest bardzo mały
• nie zależy od poleceń zewnętrznych i nie musi rozwidlać (-> szybkie i niskie zużycie zasobów)
• działa zgodnie z oczekiwaniami:
  • usuwa wszystkie spacje i tabulatory od początku i na końcu, ale nie więcej
  • ważne: nie usuwa niczego ze środka ciągu (robi to wiele innych odpowiedzi), nawet nowe wiersze pozostaną
  • special: "$*"łączy wiele argumentów za pomocą jednej spacji. jeśli chcesz przyciąć i wypisać tylko pierwszy argument, użyj "$1"zamiast niego
  • jeśli nie ma żadnych problemów z dopasowaniem wzorców nazw plików itp

Scenariusz:

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

Stosowanie:

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

Wynik:

>here     is
    something<

Możesz użyć starej szkoły tr. Na przykład zwraca liczbę zmodyfikowanych plików w repozytorium git, bez białych znaków.

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

To działało dla mnie:

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>

Aby umieścić to w mniejszej liczbie wierszy dla tego samego wyniku:

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

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

LUB

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

LUB

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

LUB

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

LUB

Opierając się na expr soulution moskita ...

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

LUB

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

Widziałem, że skrypty po prostu wykorzystują zmienne przypisanie do wykonania zadania:

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

Biała spacja jest automatycznie łączona i przycinana. Trzeba uważać na metaznaki powłoki (potencjalne ryzyko wstrzyknięcia).

Poleciłbym również zawsze podwójne cytowanie podstawień zmiennych w warunkach powłoki:

if [ -n "$var" ]; then

ponieważ coś takiego jak -o lub inna treść w zmiennej może zmienić twoje argumenty testowe.

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

Po prostu użyłbym sed:

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

a) Przykład użycia ciągu jednowierszowego

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

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

Wynik:

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

b) Przykład użycia ciągu wieloliniowego

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

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

Wynik:

GIVEN STRING: |    wordAA
   >wordB<
wordC    |

TRIMMED STRING: |wordAA
   >wordB<
wordC|

c) Uwaga końcowa:
jeśli nie chcesz używać funkcji, w przypadku ciągu jednowierszowego możesz po prostu użyć polecenia „łatwiej zapamiętać”, takiego jak:

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

Przykład:

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

Wynik:

wordA wordB wordC

Używanie powyższego w ciągach wielowierszowych również będzie działać , ale pamiętaj, że spowoduje to również odcięcie końcowej / wiodącej wewnętrznej przestrzeni wielokrotnej, jak zauważył GuruM w komentarzach

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

Wynik:

wordAA
>four spaces before<
>one space before<

Więc jeśli masz ochotę zachować te spacje, skorzystaj z funkcji na początku mojej odpowiedzi!

d) OBJAŚNIENIE składni sed „znajdź i zamień” na ciągi wielowierszowe używane wewnątrz wykończenia funkcji:

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

Oto funkcja trim (), która przycina i normalizuje białe znaki

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

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

I inny wariant wykorzystujący wyrażenia regularne.

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

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

Użyj AWK:

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

Przypisania ignorują wiodące i końcowe białe znaki i jako takie mogą być używane do przycinania:

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

Nie ma to problemu z niechcianym globowaniem, ponadto wewnętrzna biała przestrzeń jest niezmodyfikowana (zakładając, że $IFSjest ustawiona na wartość domyślną, która jest' \t\n' ).

Czyta do pierwszej nowej linii (i nie obejmuje jej) lub do końca łańcucha, w zależności od tego, co nastąpi wcześniej, i usuwa wszelką kombinację początkowej i końcowej spacji oraz \tznaków. Jeśli chcesz zachować wiele linii (a także rozdzielić początkowe i końcowe znaki nowej linii), użyj read -r -d '' var << eofzamiast tego; zwróć jednak uwagę, że jeśli twoje dane wejściowe zawierają \neof, zostaną odcięte tuż przed. (Inne formy białych znaków, a mianowicie \r, \fi nie\v są usuwane, nawet jeśli dodasz je do $ IFS.)

read -r var << eof
$var
eof

Aby usunąć spacje i tabulatory od lewej do pierwszej litery, wpisz:

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

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

Spowoduje to usunięcie wszystkich białych znaków z łańcucha,

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

/zastępuje pierwsze wystąpienie i //wszystkie wystąpienia białych znaków w ciągu. To znaczy wszystkie białe spacje zostaną zastąpione przez - nic

To najprostsza metoda, jaką widziałem. Używa tylko Bash, to tylko kilka wierszy, wyrażenie regularne jest proste i pasuje do wszystkich form białych znaków:

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

Oto przykładowy skrypt do przetestowania:

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 ma funkcję, strip()która działa identycznie jak PHP trim(), więc możemy po prostu zrobić trochę wbudowanego Pythona, aby stworzyć łatwo zrozumiałe narzędzie do tego:

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

Spowoduje to przycięcie początkowych i końcowych białych znaków (w tym znaków nowej linii).

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

Odkryłem, że muszę dodać trochę kodu z nieporządnego sdiffwyjścia, aby go wyczyścić:

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'

Usuwa to końcowe spacje i inne niewidzialne znaki.

Usuwanie spacji do jednej spacji:

(text) | fmt -su