Bagaimana cara memotong spasi dari variabel Bash?

Saya memiliki skrip shell dengan kode ini:

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

Tetapi kode kondisional selalu dijalankan, karena hg stselalu mencetak setidaknya satu karakter baris baru.

• Apakah ada cara sederhana untuk menghapus spasi $var(seperti trim()dalam PHP )?

atau

• Apakah ada cara standar untuk menangani masalah ini?

Saya bisa menggunakan sed atau AWK , tetapi saya ingin berpikir ada solusi yang lebih elegan untuk masalah ini.

Mari kita definisikan variabel yang berisi spasi spasi awal, jejak, dan menengah:

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

Cara menghapus semua spasi putih (dilambangkan dengan [:space:]dalam 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

Cara menghapus spasi putih saja:

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

Cara menghapus trailing space saja:

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

Cara menghapus spasi depan dan akhir - rangkai sed:

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

Atau, jika bash Anda mendukungnya, Anda dapat menggantinya echo -e "${FOO}" | sed ...dengan sed ... <<<${FOO}, seperti: (untuk mengekstrak spasi putih):

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

Jawaban sederhana adalah:

echo "   lol  " | xargs

Xargs akan melakukan pemotongan untuk Anda. Ini satu perintah / program, tanpa parameter, mengembalikan string yang dipangkas, semudah itu!

Catatan: ini tidak menghapus semua ruang internal jadi "foo bar"tetap sama; TIDAK menjadi "foobar". Namun, beberapa ruang akan diringkas menjadi satu ruang, jadi "foo bar"akan menjadi "foo bar". Selain itu tidak menghapus karakter garis akhir.

Ada solusi yang hanya menggunakan Bash built-in yang disebut wildcard :

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

Inilah yang sama terbungkus dalam suatu fungsi:

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

Anda melewatkan string yang akan dipotong dalam bentuk yang dikutip. misalnya:

trim "   abc   "

Satu hal yang menyenangkan tentang solusi ini adalah ia akan bekerja dengan semua shell yang sesuai dengan POSIX.

Referensi

• Hapus spasi spasi awalan & akhir dari variabel Bash ( sumber asli )

Bash memiliki fitur yang disebut ekspansi parameter , yang, antara lain, memungkinkan penggantian string berdasarkan apa yang disebut pola (pola menyerupai ekspresi reguler, tetapi ada perbedaan dan batasan mendasar). [Baris asli flussence: Bash memiliki ekspresi reguler, tetapi mereka tersembunyi dengan baik:]

Berikut ini menunjukkan cara menghapus semua ruang putih (bahkan dari interior) dari nilai variabel.

$ 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

Untuk menghapus semua spasi dari awal dan akhir string (termasuk karakter akhir baris):

echo $variable | xargs echo -n

Ini juga akan menghapus ruang duplikat:

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

Menghasilkan: 'string ini memiliki banyak ruang'

Strip satu memimpin dan satu spasi tambahan

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Sebagai contoh:

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

Keluaran:

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

Lepaskan semua ruang depan dan belakang

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Sebagai contoh:

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

Keluaran:

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

Dari bagian Bash Guide tentang globbing

Untuk menggunakan extglob dalam ekspansi parameter

 #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  

Berikut fungsi yang sama yang dibungkus dalam suatu fungsi (CATATAN: Perlu mengutip string input yang diteruskan ke fungsi):

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

Pemakaian:

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

Jika kita mengubah fungsi untuk dieksekusi dalam subkulit, kita tidak perlu khawatir tentang memeriksa opsi shell saat ini untuk extglob, kita bisa mengaturnya tanpa mempengaruhi shell saat ini. Ini sangat menyederhanakan fungsi. Saya juga memperbarui parameter posisi "di tempat" jadi saya bahkan tidak perlu variabel lokal

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

begitu:

$ 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

Anda dapat memotongnya hanya dengan echo:

foo=" qsdqsd qsdqs q qs   "

# Not trimmed
echo \'$foo\'

# Trim
foo=`echo $foo`

# Trimmed
echo \'$foo\'

Saya selalu melakukannya dengan sed

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

Jika ada solusi yang lebih elegan, saya harap seseorang mempostingnya.

Anda dapat menghapus baris baru dengan tr:

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

Dengan fitur pencocokan pola diperpanjang Bash diaktifkan ( shopt -s extglob), Anda dapat menggunakan ini:

{trimmed##*( )}

untuk menghapus jumlah ruang utama yang sewenang-wenang.

# 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

Ada banyak jawaban, tetapi saya masih percaya naskah saya yang baru saja ditulis layak disebutkan karena:

• itu berhasil diuji di shell bash / dash / busybox shell
• ini sangat kecil
• itu tidak tergantung pada perintah eksternal dan tidak perlu melakukan fork (-> penggunaan sumber daya yang cepat dan rendah)
• ini berfungsi seperti yang diharapkan:
  • itu menghapus semua spasi dan tab dari awal dan akhir, tetapi tidak lebih
  • Penting: itu tidak menghapus apa pun dari tengah-tengah string (banyak jawaban lain lakukan), bahkan baris baru akan tetap
  • spesial: "$*"gabungan beberapa argumen menggunakan satu spasi. jika Anda ingin memotong & hanya menampilkan argumen pertama, gunakan "$1"saja
  • jika tidak memiliki masalah dengan pola nama file yang cocok dll

Naskah:

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

Pemakaian:

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

Keluaran:

>here     is
    something<

Anda bisa menggunakan old-school tr. Sebagai contoh, ini mengembalikan jumlah file yang dimodifikasi dalam repositori git, spasi putih dilucuti.

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

Ini bekerja untuk saya:

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>

Untuk membuatnya lebih sedikit pada baris untuk hasil yang sama:

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

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

ATAU

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

ATAU

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

ATAU

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

ATAU

Membangun di atas soulution exp ...

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

ATAU

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

Saya telah melihat skrip hanya menggunakan tugas variabel untuk melakukan pekerjaan:

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

Ruang kosong secara otomatis digabungkan dan dipangkas. Kita harus berhati-hati terhadap metakarakter shell (risiko injeksi potensial).

Saya juga merekomendasikan untuk selalu memberikan dua kali penggantian variabel dalam kondisi shell:

if [ -n "$var" ]; then

karena sesuatu seperti -o atau konten lain dalam variabel dapat mengubah argumen pengujian Anda.

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

Saya hanya akan menggunakan sed:

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

a) Contoh penggunaan pada string baris tunggal

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

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

Keluaran:

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

b) Contoh penggunaan pada string multi-line

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

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

Keluaran:

GIVEN STRING: |    wordAA
   >wordB<
wordC    |

TRIMMED STRING: |wordAA
   >wordB<
wordC|

c) Catatan akhir:
Jika Anda tidak suka menggunakan fungsi, untuk string baris tunggal Anda cukup menggunakan perintah "lebih mudah diingat" seperti:

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

Contoh:

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

Keluaran:

wordA wordB wordC

Menggunakan hal di atas pada string multi-line akan berfungsi juga , tetapi harap dicatat bahwa itu akan memotong semua ruang trailing / leading internal juga, seperti yang GuruM perhatikan dalam komentar

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

Keluaran:

wordAA
>four spaces before<
>one space before<

Jadi, jika Anda berkeinginan untuk menjaga jarak tersebut, silakan gunakan fungsi ini di awal jawaban saya!

d) PENJELASAN sintaks sed "find and replace" pada string multi-line yang digunakan di dalam fungsi 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
}'

Inilah fungsi trim () yang memotong dan menormalkan spasi putih

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

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

Dan varian lain yang menggunakan ekspresi reguler.

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

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

Gunakan AWK:

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

Tugas mengabaikan spasi putih terkemuka dan tertinggal dan karenanya dapat digunakan untuk memotong:

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

Ini tidak memiliki masalah dengan globbing yang tidak diinginkan, juga, ruang putih interior tidak dimodifikasi (dengan asumsi yang $IFSdiatur ke default, yaitu ' \t\n').

Itu membaca hingga baris baru pertama (dan tidak termasuk itu) atau akhir string, mana yang lebih dulu, dan menghapus setiap campuran ruang dan \tkarakter memimpin dan tertinggal . Jika Anda ingin mempertahankan beberapa baris (dan juga menghapus dan memimpin baris baru), gunakan read -r -d '' var << eofsebaliknya; Perhatikan, bagaimanapun, bahwa jika input Anda mengandung \neof, itu akan dipotong sebelum. (Bentuk ruang putih lainnya, yaitu \r,, \fdan \v, tidak dilucuti, bahkan jika Anda menambahkannya ke $ IFS.)

read -r var << eof
$var
eof

Untuk menghapus spasi dan tab dari kiri ke kata pertama, masukkan:

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

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

Ini akan menghapus semua spasi putih dari String Anda,

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

/menggantikan kemunculan pertama dan //semua kemunculan spasi putih dalam string. Yaitu semua ruang putih bisa diganti dengan - tidak ada

Ini adalah metode paling sederhana yang pernah saya lihat. Hanya menggunakan Bash, hanya beberapa baris, regexp sederhana, dan cocok dengan semua bentuk spasi putih:

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

Berikut ini contoh skrip untuk mengujinya:

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 memiliki fungsi strip()yang identik dengan PHP trim(), jadi kita bisa melakukan sedikit inline Python untuk membuat utilitas yang mudah dimengerti untuk ini:

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

Ini akan memangkas spasi putih depan dan akhir (termasuk baris baru).

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

Saya menemukan bahwa saya perlu menambahkan beberapa kode dari sdiffkeluaran yang berantakan untuk membersihkannya:

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'

Ini menghilangkan spasi tambahan dan karakter tak terlihat lainnya.

Menghapus spasi ke satu ruang:

(text) | fmt -su