Come tagliare gli spazi bianchi da una variabile Bash?

Ho uno script di shell con questo codice:

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

Ma il codice condizionale viene sempre eseguito, perché hg ststampa sempre almeno un carattere di nuova riga.

• C'è un modo semplice per eliminare gli spazi bianchi $var(come trim()in PHP )?

o

• Esiste un modo standard di affrontare questo problema?

Potrei usare sed o AWK , ma mi piacerebbe pensare che ci sia una soluzione più elegante a questo problema.

Definiamo una variabile contenente spazi bianchi iniziali, finali e intermedi:

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

Come rimuovere tutti gli spazi bianchi (indicato da [: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

Come rimuovere solo i principali spazi bianchi:

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

Come rimuovere solo gli spazi vuoti finali:

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

Come rimuovere gli spazi iniziali e finali - concatenare la 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

In alternativa, se bash lo supporta, puoi sostituirlo echo -e "${FOO}" | sed ...con sed ... <<<${FOO}, in questo modo (per gli spazi bianchi finali):

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

Una semplice risposta è:

echo "   lol  " | xargs

Xargs farà il taglio per te. È un comando / programma, nessun parametro, restituisce la stringa tagliata, facile!

Nota: questo non rimuove tutti gli spazi interni, quindi "foo bar"rimane lo stesso; non diventa "foobar". Tuttavia, più spazi saranno condensati in singoli spazi, così "foo bar"diventerà "foo bar". Inoltre, non rimuove i caratteri di fine riga.

Esiste una soluzione che utilizza solo i built-in di Bash chiamati caratteri jolly :

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

Ecco lo stesso avvolto in una funzione:

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

Si passa la stringa da tagliare in forma tra virgolette. per esempio:

trim "   abc   "

Una cosa bella di questa soluzione è che funzionerà con qualsiasi shell conforme a POSIX.

Riferimento

• Rimuovi gli spazi bianchi iniziali e finali da una variabile Bash ( sorgente originale )

Bash ha una funzione chiamata espansione dei parametri , che, tra le altre cose, consente la sostituzione delle stringhe in base ai cosiddetti pattern (i pattern assomigliano alle espressioni regolari, ma ci sono differenze e limitazioni fondamentali). [linea originale di flussence: Bash ha espressioni regolari, ma sono ben nascoste:]

Di seguito viene illustrato come rimuovere tutto lo spazio bianco (anche dall'interno) da un valore variabile.

$ 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

Per rimuovere tutti gli spazi dall'inizio e dalla fine di una stringa (inclusi i caratteri di fine riga):

echo $variable | xargs echo -n

Ciò rimuoverà anche gli spazi duplicati:

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

Produce: "questa stringa ha molti spazi"

Striscia uno spazio iniziale e uno finale

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Per esempio:

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

Produzione:

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

Striscia tutti gli spazi iniziali e finali

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Per esempio:

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

Produzione:

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

Dalla sezione Bash Guide su globbing

Per utilizzare un extglob in un'espansione dei parametri

 #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  

Ecco la stessa funzionalità racchiusa in una funzione (NOTA: è necessario citare la stringa di input passata alla funzione):

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

Uso:

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

Se alteriamo la funzione da eseguire in una subshell, non dobbiamo preoccuparci di esaminare l'opzione di shell corrente per extglob, possiamo semplicemente impostarla senza influire sulla shell corrente. Questo semplifica enormemente la funzione. Inoltre aggiorno i parametri posizionali "sul posto", quindi non ho nemmeno bisogno di una variabile locale

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

così:

$ 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

Puoi tagliare semplicemente con echo:

foo=" qsdqsd qsdqs q qs   "

# Not trimmed
echo \'$foo\'

# Trim
foo=`echo $foo`

# Trimmed
echo \'$foo\'

L'ho sempre fatto con sed

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

Se esiste una soluzione più elegante, spero che qualcuno la pubblichi.

Puoi eliminare le nuove righe con tr:

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

Con le funzionalità di corrispondenza del pattern esteso di Bash abilitate ( shopt -s extglob), puoi usare questo:

{trimmed##*( )}

per rimuovere una quantità arbitraria di spazi iniziali.

# 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

Ci sono molte risposte, ma credo ancora che la mia sceneggiatura appena scritta meriti di essere citata perché:

• è stato testato con successo nella shell shell bash / dash / busybox
• è estremamente piccolo
• non dipende da comandi esterni e non necessita di fork (-> utilizzo rapido e basso delle risorse)
• funziona come previsto:
  • rimuove tutti gli spazi e le schede dall'inizio e dalla fine, ma non di più
  • importante: non rimuove nulla dal centro della stringa (molte altre risposte lo fanno), anche le nuove righe rimarranno
  • speciale: "$*"unisce più argomenti usando uno spazio. se vuoi tagliare e produrre solo il primo argomento, usa "$1"invece
  • se non ha problemi con la corrispondenza dei modelli di nomi di file ecc

Il copione:

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

Uso:

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

Produzione:

>here     is
    something<

Puoi usare la vecchia scuola tr. Ad esempio, questo restituisce il numero di file modificati in un repository git, spazi bianchi eliminati.

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

Questo ha funzionato per me:

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>

Per dirlo su un numero inferiore di righe per lo stesso risultato:

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

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

O

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

O

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

O

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

O

Costruire sull'espressione soul di moskit ...

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

O

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

Ho visto degli script usare solo l'assegnazione delle variabili per fare il lavoro:

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

Lo spazio bianco viene automaticamente coalizzato e tagliato. Bisogna stare attenti ai metacaratteri della shell (potenziale rischio di iniezione).

Vorrei anche raccomandare sempre le doppie sostituzioni di variabili nei condizionali di shell:

if [ -n "$var" ]; then

poiché qualcosa come un -o o altro contenuto nella variabile potrebbe modificare gli argomenti del test.

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

Vorrei semplicemente usare sed:

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

a) Esempio di utilizzo su stringa a riga singola

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

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

Produzione:

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

b) Esempio di utilizzo su stringa multilinea

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

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

Produzione:

GIVEN STRING: |    wordAA
   >wordB<
wordC    |

TRIMMED STRING: |wordAA
   >wordB<
wordC|

c) Nota finale:
se non ti piace usare una funzione, per una stringa a riga singola puoi semplicemente usare un comando "più facile da ricordare" come:

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

Esempio:

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

Produzione:

wordA wordB wordC

L'uso di quanto sopra sulle stringhe multilinea funzionerà anche , ma tieni presente che taglierà anche qualsiasi spazio multiplo interno iniziale / iniziale, come notato da GuruM nei commenti

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

Produzione:

wordAA
>four spaces before<
>one space before<

Quindi, se ti dispiace mantenere quegli spazi, per favore usa la funzione all'inizio della mia risposta!

d) SPIEGAZIONE della sintassi sed "trova e sostituisci" sulle stringhe multilinea utilizzate all'interno del trim della funzione:

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

Ecco una funzione trim () che taglia e normalizza gli spazi bianchi

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

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

E un'altra variante che utilizza espressioni regolari.

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

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

Usa AWK:

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

Le assegnazioni ignorano gli spazi bianchi iniziali e finali e come tali possono essere utilizzate per tagliare:

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

Questo non ha il problema con il globbing indesiderato, inoltre, lo spazio bianco interno non è modificato (supponendo che $IFSsia impostato sul valore predefinito, che è ' \t\n').

Legge fino alla prima riga (e non la include) o alla fine della stringa, a seconda di quale delle due condizioni si verifichi per prima, e toglie qualsiasi mix di spazio e \tcaratteri iniziali e finali . Se si desidera conservare più righe (e anche rimuovere le righe iniziali e finali), utilizzare read -r -d '' var << eofinvece; nota, tuttavia, che se l'input contiene \neof, verrà tagliato appena prima. (Altre forme di spazio bianco, ovvero \r, \fe \v, non vengono rimosse, anche se le aggiungi a $ IFS.)

read -r var << eof
$var
eof

Per rimuovere spazi e tab da sinistra alla prima parola, inserisci:

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

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

Ciò rimuoverà tutti gli spazi bianchi dalla stringa,

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

/sostituisce la prima occorrenza e //tutte le occorrenze di spazi bianchi nella stringa. Cioè tutti gli spazi bianchi vengono sostituiti da - niente

Questo è il metodo più semplice che abbia mai visto. Usa solo Bash, è solo poche righe, la regexp è semplice e si adatta a tutte le forme di spazio bianco:

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

Ecco uno script di esempio con cui testarlo:

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 ha una funzione strip() che funziona in modo identico a PHP trim(), quindi possiamo solo fare un po 'di Python in linea per creare un'utilità facilmente comprensibile per questo:

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

Ciò eliminerà gli spazi bianchi iniziali e finali (comprese le nuove linee).

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

Ho scoperto che dovevo aggiungere del codice da un sdiffoutput disordinato per ripulirlo:

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'

Questo rimuove gli spazi finali e altri personaggi invisibili.

Rimozione di spazi in uno spazio:

(text) | fmt -su