Boşluk Bash değişkeninden nasıl kesilir?

Bu kod ile bir kabuk komut dosyası var:

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

Ancak koşullu kod her zaman yürütülür, çünkü hg sther zaman en az bir yeni satır karakteri yazdırır.

• Dan boşluk şerit basit bir yol var mı $var(gibi trim()içinde PHP )?

veya

• Bu sorunla başa çıkmanın standart bir yolu var mı?

Sed veya AWK kullanabilirdim , ancak bu soruna daha zarif bir çözüm olduğunu düşünmek istiyorum.

Öncü, sondaki ve ara boşluk içeren bir değişken tanımlayalım:

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

Nasıl (ile gösterilir tüm boşlukları silebilirsiniz [:space:]içinde 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

Yalnızca önde gelen boşluk nasıl kaldırılır:

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

Yalnızca sondaki boşluk nasıl kaldırılır:

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

Hem önde gelen hem de arkadaki boşluklar nasıl kaldırılır - zincirleri 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

Senin bash destekliyorsa Alternatif olarak, yerine echo -e "${FOO}" | sed ...ile sed ... <<<${FOO}şöyle (sonlarındaki boşluk için),:

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

Basit bir cevap:

echo "   lol  " | xargs

Xargs sizin için düzeltme yapacak. Bu bir komut / program, parametre yok, kesilmiş dizeyi döndürür, bu kadar kolay!

Not: Bu, tüm dahili alanları kaldırmaz, bu nedenle "foo bar"aynı kalır; bu OLMAYACAK "foobar". Bununla birlikte, birden çok boşluk tek boşluklara yoğunlaştırılacak, böylece "foo bar"olacak "foo bar". Ayrıca satır sonu karakterlerini kaldırmaz.

Sadece joker olarak adlandırılan Bash yerleşiklerini kullanan bir çözüm var :

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

İşte bir fonksiyonda sarılı olan:

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

Kesilecek dizeyi tırnak biçiminde iletirsiniz. Örneğin:

trim "   abc   "

Bu çözümle ilgili güzel bir şey, herhangi bir POSIX uyumlu kabukla çalışmasıdır.

Referans

• Bash değişkeninden önde gelen ve sondaki boşlukları kaldırın ( orijinal kaynak )

Bash, parametre genişletme adı verilen bir özelliğe sahiptir, bu özellik , diğer şeylerin yanı sıra, sözde desenlere dayalı dizginin değiştirilmesine izin verir (desenler düzenli ifadelere benzer, ancak temel farklılıklar ve sınırlamalar vardır). [flussence'ın orijinal satırı: Bash'in düzenli ifadeleri var, ancak iyi gizlenmişler:]

Aşağıda, tüm beyaz alanların (iç kısımdan bile) değişken bir değerden nasıl kaldırılacağı gösterilmektedir .

$ 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

Bir dizenin başından ve sonundan tüm satırları kaldırmak için (satır sonu karakterleri dahil):

echo $variable | xargs echo -n

Bu, yinelenen boşlukları da kaldıracaktır:

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

Üretiyor: 'bu dizgede çok fazla alan var'

Bir öncü ve bir arka boşluk bırakın

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Örneğin:

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

Çıktı:

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

Tüm önde gelen ve arkadaki alanları soyun

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Örneğin:

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

Çıktı:

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

Globbing ile ilgili Bash Guide bölümünden

Parametre genişletmesinde bir extglob kullanmak için

 #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  

İşte bir işlevin içine sarılmış aynı işlevsellik (NOT: İşleve geçirilen girdi dizesini alıntılamak gerekir):

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

Kullanımı:

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

Bir alt kabukta yürütülecek işlevi değiştirirsek, extglob için geçerli kabuk seçeneğini inceleme konusunda endişelenmemize gerek kalmaz, sadece geçerli kabuğu etkilemeden ayarlayabiliriz. Bu, işlevi muazzam bir şekilde basitleştirir. Ayrıca "yerinde" konum parametrelerini de güncelliyorum, bu yüzden yerel bir değişkene bile ihtiyacım yok

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

yani:

$ 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

Basitçe aşağıdakilerle kırpabilirsiniz echo:

foo=" qsdqsd qsdqs q qs   "

# Not trimmed
echo \'$foo\'

# Trim
foo=`echo $foo`

# Trimmed
echo \'$foo\'

Her zaman sed ile yaptım

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

Daha zarif bir çözüm varsa, umarım birisi gönderir.

Yeni satırları aşağıdakilerle silebilirsiniz tr:

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

Bash'ın genişletilmiş desen eşleme özellikleri etkinken ( shopt -s extglob) şunları kullanabilirsiniz:

{trimmed##*( )}

gelişigüzel miktarda önde gelen boşlukları kaldırmak için.

# 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

Çok fazla cevap var, ama hala yazdığım senaryodan bahsetmeye değer olduğuna inanıyorum çünkü:

• başarıyla bash / dash / busybox kabuğunda test edildi
• son derece küçük
• harici komutlara bağlı değildir ve çatallanmaya gerek yoktur (-> hızlı ve düşük kaynak kullanımı)
• beklendiği gibi çalışır:
  • o şeritler tüm başı ve sonu boşlukları ve sekmeleri değil, daha
  • önemli: dizenin ortasından hiçbir şey kaldırmaz (diğer birçok yanıt yapar), hatta yeni satırlar kalır
  • special: "$*"bir boşluk kullanarak birden çok argümanı birleştirir. yalnızca ilk bağımsız değişkeni kırpmak ve çıktısını almak istiyorsanız "$1"bunun yerine
  • dosya adı desenlerini eşleştirme konusunda herhangi bir sorun yoksa vb.

Senaryo:

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

Kullanımı:

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

Çıktı:

>here     is
    something<

Eski okulu kullanabilirsiniz tr. Örneğin, bir boşluk deposundaki değiştirilmiş dosyaların sayısını döndürür.

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

Bu benim için çalıştı:

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>

Aynı sonuç için daha az satıra koymak için:

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

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

VEYA

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

VEYA

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

VEYA

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

VEYA

Moskit'in ifade ruhu üzerine inşa ...

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

VEYA

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

Ben komut dosyaları sadece iş yapmak için değişken atama kullanın gördüm:

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

Boşluk otomatik olarak birleştirilir ve kırpılır. Kabuk metakarakterlerine dikkat edilmelidir (potansiyel enjeksiyon riski).

Ayrıca, kabuk koşullarında her zaman çift tırnaklı değişken ikamelerini tavsiye ederim:

if [ -n "$var" ]; then

çünkü değişkente -o veya başka bir içerik test argümanlarınızı değiştirebilir.

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

Ben sadece sed kullanırdım:

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

a) Tek satırlı dize kullanım örneği

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

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

Çıktı:

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

b) Çok satırlı dizede kullanım örneği

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

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

Çıktı:

GIVEN STRING: |    wordAA
   >wordB<
wordC    |

TRIMMED STRING: |wordAA
   >wordB<
wordC|

c) Son not:
Bir işlev kullanmak istemiyorsanız, tek satırlık dize için aşağıdaki gibi "hatırlaması daha kolay" komutunu kullanabilirsiniz:

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

Misal:

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

Çıktı:

wordA wordB wordC

Yukarıdakileri çok satırlı dizelerde kullanmak da işe yarayacaktır , ancak GuruM'nin yorumlarda fark ettiği gibi, arkadaki / önde gelen dahili çoklu alanı da keseceğini lütfen unutmayın.

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

Çıktı:

wordAA
>four spaces before<
>one space before<

Bu boşlukları saklamayı düşünürseniz, lütfen cevabımın başındaki fonksiyonu kullanın!

d) sed sözdiziminin fonksiyon triminde kullanılan çok satırlı dizelerde "bul ve değiştir" açıklaması:

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

Boşluğu kesen ve normalleştiren bir trim () işlevi

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

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

Ve düzenli ifadeler kullanan başka bir varyant.

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

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

AWK kullan:

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

Atamalar, öndeki ve sondaki boşlukları yok sayar ve bu nedenle kırpmak için kullanılabilir:

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

Bu, istenmeyen globbing ile ilgili bir sorun oluşturmaz, ayrıca, iç beyaz boşluk değiştirilmez (varsayılan $IFSolarak ayarlandığı varsayılarak,' \t\n' ).

Hangisi önce gelirse, ilk satırsonuna (ve onu içermez) veya dizenin sonuna kadar okur ve önde gelen ve sondaki boşluk ve \tkarakterlerin karışımını kaldırır . Birden fazla satırı korumak istiyorsanız (ve ayrıca satır başı ve son satır satırlarını sıyırmak istiyorsanız) read -r -d '' var << eofbunun yerine; Ancak, girdiniz içeriyorsa \neof, daha önce kesileceğini unutmayın. (Yani boşluk, diğer şekilleri \r, \fve \v, olan değil sen $ IFS eklemek bile soyulmuş.)

read -r var << eof
$var
eof

Soldan ilk kelimeye kadar olan boşlukları ve sekmeleri kaldırmak için şunu girin:

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

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

Bu, tüm beyaz alanları Dizenizden kaldıracak,

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

///dizede ilk ve beyaz boşlukların tümünün yerini alır . Yani tüm beyaz alanların yerini alıyor - hiçbir şey

Bu gördüğüm en basit yöntem. Sadece Bash kullanır, sadece birkaç satırdır, normal ifade basittir ve tüm boşluk alanlarıyla eşleşir:

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

İşte sınamak için örnek bir komut dosyası:

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, strip()PHP'lerle aynı şekilde çalışan bir işleve sahiptir trim(), bu yüzden bunun için kolayca anlaşılabilir bir yardımcı program yapmak için biraz satır içi Python yapabiliriz:

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

Bu, önde gelen ve sondaki boşlukları (yeni satırlar dahil) keser.

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

sdiffTemizlemek için dağınık bir çıktı bazı kod eklemek için gerekli bulundu :

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'

Bu, sondaki boşlukları ve diğer görünmez karakterleri kaldırır.

Bir boşluğa boşluk kaldırma:

(text) | fmt -su