Wie schneide ich Leerzeichen aus einer Bash-Variablen?

Ich habe ein Shell-Skript mit diesem Code:

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

Der bedingte Code wird jedoch immer ausgeführt, da hg stimmer mindestens ein Zeilenumbruchzeichen gedruckt wird.

• Gibt es eine einfache Möglichkeit, Leerzeichen zu entfernen $var(wie trim()in PHP )?

oder

• Gibt es eine Standardmethode für den Umgang mit diesem Problem?

Ich könnte sed oder AWK verwenden , aber ich würde gerne glauben, dass es eine elegantere Lösung für dieses Problem gibt.

Definieren wir eine Variable, die führende, nachfolgende und mittlere Leerzeichen enthält:

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

So entfernen Sie alle Leerzeichen (gekennzeichnet mit [: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

So entfernen Sie nur führende Leerzeichen:

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

So entfernen Sie nur nachgestellte Leerzeichen:

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

So entfernen Sie sowohl führende als auch nachfolgende Leerzeichen - verketten Sie die 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

Alternativ kann , wenn Ihre bash unterstützt wird , können Sie ersetzen echo -e "${FOO}" | sed ...mit sed ... <<<${FOO}, wie so (für nachfolgende Leerzeichen):

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

Eine einfache Antwort lautet:

echo "   lol  " | xargs

Xargs erledigt das Trimmen für Sie. Es ist ein Befehl / Programm, keine Parameter, gibt den zugeschnittenen String zurück, so einfach ist das!

Hinweis: Dadurch werden nicht alle internen Leerzeichen entfernt, sodass sie "foo bar"gleich bleiben. es wird NICHT "foobar". Es werden jedoch mehrere Räume zu einzelnen Räumen zusammengefasst, so "foo bar"dass dies auch der Fall ist "foo bar". Außerdem werden keine Zeilenendezeichen entfernt.

Es gibt eine Lösung, die nur Bash-integrierte Funktionen verwendet, die als Platzhalter bezeichnet werden :

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

Hier ist das gleiche in einer Funktion verpackt:

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

Sie übergeben die zu schneidende Zeichenfolge in Anführungszeichen. z.B:

trim "   abc   "

Das Schöne an dieser Lösung ist, dass sie mit jeder POSIX-kompatiblen Shell funktioniert.

Referenz

• Entfernen Sie führende und nachfolgende Leerzeichen aus einer Bash-Variablen ( Originalquelle ).

Bash verfügt über eine Funktion namens Parametererweiterung , die unter anderem das Ersetzen von Zeichenfolgen anhand sogenannter Muster ermöglicht (Muster ähneln regulären Ausdrücken, es gibt jedoch grundlegende Unterschiede und Einschränkungen). [Flussences ursprüngliche Zeile: Bash hat reguläre Ausdrücke, aber sie sind gut versteckt:]

Im Folgenden wird gezeigt, wie Sie alle Leerzeichen (auch aus dem Innenraum) aus einem variablen Wert entfernen .

$ 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

So entfernen Sie alle Leerzeichen am Anfang und am Ende einer Zeichenfolge (einschließlich Zeichen am Zeilenende):

echo $variable | xargs echo -n

Dadurch werden auch doppelte Leerzeichen entfernt:

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

Produziert: 'Diese Saite hat viele Leerzeichen'

Entfernen Sie ein führendes und ein nachfolgendes Leerzeichen

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Zum Beispiel:

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

Ausgabe:

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

Entfernen Sie alle führenden und nachfolgenden Leerzeichen

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Zum Beispiel:

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

Ausgabe:

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

Aus dem Abschnitt Bash Guide zum Globbing

So verwenden Sie einen Extglob in einer Parametererweiterung

 #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  

Hier ist dieselbe Funktionalität, die in eine Funktion eingeschlossen ist (HINWEIS: Die an die Funktion übergebene Eingabezeichenfolge muss angegeben werden):

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

Verwendungszweck:

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

Wenn wir die Funktion ändern, die in einer Subshell ausgeführt werden soll, müssen wir uns nicht um die Prüfung der aktuellen Shell-Option für extglob kümmern, sondern können sie einfach festlegen, ohne die aktuelle Shell zu beeinflussen. Dies vereinfacht die Funktion enorm. Ich aktualisiere auch die Positionsparameter "an Ort und Stelle", damit ich nicht einmal eine lokale Variable benötige

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

damit:

$ 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

Sie können einfach trimmen mit echo:

foo=" qsdqsd qsdqs q qs   "

# Not trimmed
echo \'$foo\'

# Trim
foo=`echo $foo`

# Trimmed
echo \'$foo\'

Ich habe es immer mit sed gemacht

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

Wenn es eine elegantere Lösung gibt, hoffe ich, dass jemand sie veröffentlicht.

Sie können Zeilenumbrüche löschen mit tr:

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

Wenn die erweiterten Mustervergleichsfunktionen von Bash aktiviert sind ( shopt -s extglob), können Sie Folgendes verwenden:

{trimmed##*( )}

um eine beliebige Anzahl von führenden Leerzeichen zu entfernen.

# 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

Es gibt viele Antworten, aber ich glaube immer noch, dass mein gerade geschriebenes Skript erwähnenswert ist, weil:

• Es wurde erfolgreich in der Shell Bash / Dash / Busybox Shell getestet
• es ist extrem klein
• es hängt nicht von externen Befehlen ab und muss nicht gegabelt werden (-> schnelle und geringe Ressourcennutzung)
• es funktioniert wie erwartet:
  • Es entfernt alle Leerzeichen und Tabulatoren von Anfang und Ende, aber nicht mehr
  • wichtig: Es wird nichts aus der Mitte der Zeichenfolge entfernt (viele andere Antworten tun dies), auch Zeilenumbrüche bleiben erhalten
  • Spezial: Die "$*"Verknüpfung mehrerer Argumente mit einem Leerzeichen. Wenn Sie nur das erste Argument zuschneiden und ausgeben möchten, verwenden Sie "$1"stattdessen
  • Wenn es keine Probleme mit übereinstimmenden Dateinamenmustern usw. gibt

Das Skript:

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

Verwendungszweck:

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

Ausgabe:

>here     is
    something<

Sie können Old-School verwenden tr. Dies gibt beispielsweise die Anzahl der geänderten Dateien in einem Git-Repository zurück, wobei Leerzeichen entfernt wurden.

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

Das hat bei mir funktioniert:

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>

Um das für das gleiche Ergebnis in weniger Zeilen zu setzen:

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

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

ODER

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

ODER

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

ODER

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

ODER

Aufbauend auf Moskits Ausdruck ...

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

ODER

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

Ich habe gesehen, dass Skripte nur die Variablenzuweisung verwenden, um den Job zu erledigen:

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

Leerzeichen werden automatisch zusammengeführt und gekürzt. Man muss auf Schalenmetacharaktere achten (potentielles Injektionsrisiko).

Ich würde auch empfehlen, Variablensubstitutionen in Shell-Bedingungen immer doppelt in Anführungszeichen zu setzen:

if [ -n "$var" ]; then

da so etwas wie ein -o oder ein anderer Inhalt in der Variablen Ihre Testargumente ändern könnte.

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

Ich würde einfach sed verwenden:

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

a) Anwendungsbeispiel für einzeilige Zeichenfolgen

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

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

Ausgabe:

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

b) Anwendungsbeispiel für mehrzeilige Zeichenfolgen

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

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

Ausgabe:

GIVEN STRING: |    wordAA
   >wordB<
wordC    |

TRIMMED STRING: |wordAA
   >wordB<
wordC|

c) Schlussbemerkung:
Wenn Sie keine Funktion verwenden möchten, können Sie für einzeilige Zeichenfolgen einfach einen Befehl verwenden, der leichter zu merken ist:

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

Beispiel:

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

Ausgabe:

wordA wordB wordC

Die Verwendung der obigen Anweisungen für mehrzeilige Zeichenfolgen funktioniert ebenfalls , aber bitte beachten Sie, dass dadurch auch alle nachfolgenden / führenden internen Mehrfachbereiche abgeschnitten werden, wie GuruM in den Kommentaren bemerkt hat

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

Ausgabe:

wordAA
>four spaces before<
>one space before<

Wenn es Ihnen etwas ausmacht, diese Leerzeichen beizubehalten, verwenden Sie bitte die Funktion am Anfang meiner Antwort!

d) ERLÄUTERUNG der sed-Syntax "find and replace" für mehrzeilige Zeichenfolgen, die innerhalb der Funktionsanpassung verwendet werden:

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

Hier ist eine trim () -Funktion, die Leerzeichen trimmt und normalisiert

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

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

Und eine andere Variante, die reguläre Ausdrücke verwendet.

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

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

Verwenden Sie AWK:

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

Zuweisungen ignorieren führende und nachfolgende Leerzeichen und können als solche zum Trimmen verwendet werden:

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

Dies hat nicht das Problem mit unerwünschtem Globbing, außerdem ist der innere Leerraum unverändert (vorausgesetzt, er $IFSist auf den Standardwert eingestellt)' \t\n' ).

Es liest bis zur ersten neuen Zeile (und enthält sie nicht) oder bis zum Ende der Zeichenfolge, je nachdem, was zuerst eintritt, und entfernt jede Mischung aus führenden und nachfolgenden Leerzeichen und \tZeichen. Wenn Sie mehrere Zeilen beibehalten möchten (und auch führende und nachfolgende Zeilenumbrüche entfernen möchten), verwenden Sie read -r -d '' var << eofstattdessen. Beachten Sie jedoch, dass Ihre Eingabe \neofkurz zuvor abgeschnitten wird, wenn sie etwas enthält. (Andere Formen des weißen Raumes, nämlich \r, \fund \vwerden nicht entfernt werden , auch wenn Sie sie zu $ IFS hinzufügen.)

read -r var << eof
$var
eof

Geben Sie Folgendes ein, um Leerzeichen und Tabulatoren vom linken zum ersten Wort zu entfernen:

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

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

Dadurch werden alle Leerzeichen aus Ihrem String entfernt.

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

/Ersetzt das erste Vorkommen und //alle Vorkommen von Leerzeichen in der Zeichenfolge. Dh alle Leerzeichen werden ersetzt durch - nichts

Dies ist die einfachste Methode, die ich je gesehen habe. Es wird nur Bash verwendet, es sind nur wenige Zeilen, der reguläre Ausdruck ist einfach und es entspricht allen Formen von Leerzeichen:

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

Hier ist ein Beispielskript zum Testen:

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 hat eine Funktion strip(), die identisch mit PHPs funktioniert trim(), daher können wir nur ein wenig Inline-Python ausführen, um ein leicht verständliches Dienstprogramm dafür zu erstellen:

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

Dadurch werden führende und nachfolgende Leerzeichen (einschließlich Zeilenumbrüche) gekürzt.

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

Ich stellte fest, dass ich Code aus einer unordentlichen sdiffAusgabe hinzufügen musste, um ihn zu bereinigen:

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'

Dadurch werden die nachgestellten Leerzeichen und andere unsichtbare Zeichen entfernt.

Leerzeichen in ein Leerzeichen entfernen:

(text) | fmt -su