Comment découper un espace à partir d'une variable Bash?

J'ai un script shell avec ce code:

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

Mais le code conditionnel s'exécute toujours, car hg stimprime toujours au moins un caractère de nouvelle ligne.

• Existe-t-il un moyen simple de supprimer les espaces $var(comme trim()en PHP )?

ou

• Existe-t-il un moyen standard de traiter ce problème?

Je pourrais utiliser sed ou AWK , mais j'aimerais penser qu'il existe une solution plus élégante à ce problème.

Définissons une variable contenant des espaces de début, de fin et intermédiaires:

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

Comment supprimer tous les espaces (indiqués par [: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

Comment supprimer uniquement les espaces principaux:

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

Comment supprimer uniquement les espaces de fin:

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

Comment supprimer les espaces de début et de fin - enchaînez les 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

Alternativement, si votre bash le prend en charge, vous pouvez le remplacer echo -e "${FOO}" | sed ...par sed ... <<<${FOO}, comme ceci (pour les espaces de fin):

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

Une réponse simple est:

echo "   lol  " | xargs

Xargs fera le réglage pour vous. C'est une commande / programme, pas de paramètres, renvoie la chaîne coupée, aussi simple que ça!

Remarque: cela ne supprime pas tous les espaces internes et "foo bar"reste donc le même; cela ne devient PAS "foobar". Cependant, plusieurs espaces seront condensés en espaces uniques, ainsi "foo bar"le deviendra "foo bar". De plus, il ne supprime pas les caractères de fin de ligne.

Il existe une solution qui n'utilise que des Bash intégrés appelés caractères génériques :

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

Voici le même enveloppé dans une fonction:

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

Vous passez la chaîne à couper sous forme de guillemets. par exemple:

trim "   abc   "

Une bonne chose à propos de cette solution est qu'elle fonctionnera avec n'importe quel shell compatible POSIX.

Référence

• Supprimer les espaces de début et de fin d'une variable Bash ( source d'origine )

Bash a une fonctionnalité appelée expansion de paramètres , qui, entre autres, permet le remplacement de chaînes basé sur des soi-disant modèles (les modèles ressemblent à des expressions régulières, mais il existe des différences et des limitations fondamentales). [ligne originale de flussence: Bash a des expressions régulières, mais elles sont bien cachées:]

Ce qui suit montre comment supprimer tout l'espace blanc (même de l'intérieur) d'une valeur variable.

$ 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

Afin de supprimer tous les espaces du début et de la fin d'une chaîne (y compris les caractères de fin de ligne):

echo $variable | xargs echo -n

Cela supprimera également les espaces en double:

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

Produit: 'cette chaîne a beaucoup d'espaces'

Supprimer un espace de tête et un espace de fin

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Par exemple:

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

Production:

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

Supprimez tous les espaces avant et arrière

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Par exemple:

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

Production:

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

De la section Bash Guide sur le globbing

Pour utiliser un extglob dans une extension de paramètre

 #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  

Voici la même fonctionnalité enveloppée dans une fonction (REMARQUE: besoin de citer la chaîne d'entrée passée à la fonction):

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

Usage:

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

Si nous modifions la fonction à exécuter dans un sous-shell, nous n'avons pas à nous soucier d'examiner l'option de shell actuelle pour extglob, nous pouvons simplement la définir sans affecter le shell actuel. Cela simplifie énormément la fonction. Je mets aussi à jour les paramètres de position "en place" donc je n'ai même pas besoin d'une variable locale

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

donc:

$ 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

Vous pouvez couper simplement avec echo:

foo=" qsdqsd qsdqs q qs   "

# Not trimmed
echo \'$foo\'

# Trim
foo=`echo $foo`

# Trimmed
echo \'$foo\'

Je l'ai toujours fait avec sed

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

S'il existe une solution plus élégante, j'espère que quelqu'un l'affichera.

Vous pouvez supprimer les sauts de ligne avec tr:

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

Avec les fonctionnalités étendues de correspondance de motifs de Bash activées ( shopt -s extglob), vous pouvez utiliser ceci:

{trimmed##*( )}

pour supprimer une quantité arbitraire d'espaces de tête.

# 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

Il y a beaucoup de réponses, mais je crois toujours que mon script qui vient d'être écrit mérite d'être mentionné parce que:

• il a été testé avec succès dans le shell bash / dash / busybox
• il est extrêmement petit
• il ne dépend pas de commandes externes et n'a pas besoin de bifurquer (-> utilisation rapide et faible des ressources)
• cela fonctionne comme prévu:
  • il dépouille tout espaces et les tabulations du début et de la fin, mais pas plus
  • important: il ne supprime rien du milieu de la chaîne (de nombreuses autres réponses le font), même les nouvelles lignes resteront
  • spécial: le "$*"joint plusieurs arguments en utilisant un seul espace. si vous voulez couper et sortir uniquement le premier argument, utilisez"$1" plutôt
  • si n'a aucun problème avec les modèles de noms de fichiers correspondants, etc.

Le scénario:

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

Usage:

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

Production:

>here     is
    something<

Vous pouvez utiliser la vieille école tr. Par exemple, cela renvoie le nombre de fichiers modifiés dans un référentiel git, espaces blancs supprimés.

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

Cela a fonctionné pour moi:

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>

Pour mettre cela sur moins de lignes pour le même résultat:

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

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

OU

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

OU

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

OU

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

OU

S'appuyer sur l'expr soulution de moskit ...

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

OU

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

J'ai vu des scripts utiliser simplement l'affectation de variables pour faire le travail:

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

Les espaces sont automatiquement fusionnés et rognés. Il faut faire attention aux métacaractères du shell (risque d'injection potentiel).

Je recommanderais également toujours de remplacer les variables par des guillemets doubles dans les conditions de la coque:

if [ -n "$var" ]; then

car quelque chose comme un -o ou un autre contenu dans la variable pourrait modifier vos arguments de test.

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

J'utiliserais simplement sed:

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

a) Exemple d'utilisation sur une chaîne à ligne unique

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

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

Production:

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

b) Exemple d'utilisation sur une chaîne multiligne

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

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

Production:

GIVEN STRING: |    wordAA
   >wordB<
wordC    |

TRIMMED STRING: |wordAA
   >wordB<
wordC|

c) Remarque finale:
Si vous n'aimez pas utiliser une fonction, pour une chaîne à une seule ligne, vous pouvez simplement utiliser une commande "plus facile à retenir" comme:

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

Exemple:

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

Production:

wordA wordB wordC

L'utilisation de ce qui précède sur les chaînes multi-lignes fonctionnera également , mais veuillez noter que cela réduira également tout espace multiple interne à la fin / en tête, comme GuruM l'a remarqué dans les commentaires.

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

Production:

wordAA
>four spaces before<
>one space before<

Donc, si cela vous dérange de garder ces espaces, veuillez utiliser la fonction au début de ma réponse!

d) EXPLICATION de la syntaxe sed "find and replace" sur les chaînes multilignes utilisées à l'intérieur de la fonction 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
}'

Voici une fonction trim () qui coupe et normalise les espaces blancs

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

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

Et une autre variante qui utilise des expressions régulières.

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

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

Utilisez AWK:

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

Les affectations ignorent les espaces blancs de début et de fin et, en tant que telles, peuvent être utilisées pour couper:

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

Cela ne pose pas de problème avec les globes indésirables, également, l'espace blanc intérieur n'est pas modifié (en supposant que $IFS est défini par défaut, ce qui est ' \t\n').

Il lit jusqu'à la première nouvelle ligne (et ne l'inclut pas) ou la fin de la chaîne, selon la première éventualité, et supprime tout mélange d'espaces et de \tcaractères de début et de fin . Si vous souhaitez conserver plusieurs lignes (et également supprimer les sauts de ligne de début et de fin), utilisez read -r -d '' var << eofplutôt; notez cependant que si votre entrée contient \neof, elle sera coupée juste avant. ( D' autres formes d'espace blanc, à savoir \r, \fet \v, sont ne pas supprimées, même si vous les ajoutez à $ IFS.)

read -r var << eof
$var
eof

Pour supprimer les espaces et les tabulations de gauche à premier mot, entrez:

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

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

Cela supprimera tous les espaces blancs de votre chaîne,

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

/remplace la première occurrence et //toutes les occurrences d'espaces dans la chaîne. C'est-à-dire que tous les espaces blancs sont remplacés par - rien

C'est la méthode la plus simple que j'ai vue. Il utilise uniquement Bash, ce ne sont que quelques lignes, l'expression rationnelle est simple et correspond à toutes les formes d'espaces:

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

Voici un exemple de script pour le tester:

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 a une fonction strip() qui fonctionne de manière identique à PHP trim(), donc nous pouvons simplement faire un peu de Python en ligne pour en faire un utilitaire facilement compréhensible:

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

Cela supprimera les espaces de début et de fin (y compris les retours à la ligne).

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

J'ai trouvé que j'avais besoin d'ajouter du code à partir d'une sdiffsortie en désordre pour le nettoyer:

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'

Cela supprime les espaces de fin et autres caractères invisibles.

Suppression d'espaces dans un espace:

(text) | fmt -su