Як обрізати пробіл із змінної Bash?

У мене є сценарій оболонки з цим кодом:

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

Але умовний код завжди виконується, тому що hg stзавжди друкується принаймні один символ нового рядка.

• Чи є простий спосіб позбавити пробіл $var(наприклад, trim()у PHP )?

або

• Чи існує стандартний спосіб вирішення цього питання?

Я міг би використовувати sed або AWK , але хотілося б подумати, що існує більш елегантне рішення цієї проблеми.

Давайте визначимо змінну, що містить пробіл проміжного, останнього та проміжного пробілів:

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

Як видалити всі пробіли (позначені [:space:]в 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

Як видалити лише провідні пробіли:

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

Як видалити лише пробіли:

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

Як видалити провідні та кінцеві пробіли - ланцюжок 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

З іншого боку , якщо ваш Баш підтримує його, ви можете замінити echo -e "${FOO}" | sed ...з sed ... <<<${FOO}, наприклад , так (для кінцевих пробілів):

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

Проста відповідь:

echo "   lol  " | xargs

Xargs зробить обрізку за вас. Це одна команда / програма, без параметрів, повертає обрізану рядок, просто так!

Примітка: це не видаляє всі внутрішні простори, тому "foo bar"залишається однаковим; це НЕ стає "foobar". Однак кілька пробілів будуть зведені до одиничних просторів, так "foo bar"і стануть "foo bar". Крім того, він не видаляє символи кінця рядків.

Існує рішення, яке використовує лише вбудовані Bash під назвою макіяж :

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

Ось така ж функція:

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

Ви передаєте рядок, яку слід обрізати в цитованому вигляді. наприклад:

trim "   abc   "

Приємно в цьому рішенні те, що воно буде працювати з будь-якою оболонкою, сумісною з POSIX.

Довідково

• Видаліть проміжні пробіли та пробіли із змінної Bash ( оригінальне джерело )

Bash має функцію під назвою розширення параметрів , яка, крім іншого, дозволяє замінити рядок на основі так званих шаблонів (візерунки нагадують регулярні вирази, але існують принципові відмінності та обмеження). [оригінальний рядок flussence: Bash має регулярні вирази, але вони добре приховані:]

Далі показано, як видалити весь простір (навіть із інтер’єру) зі змінного значення.

$ 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

Для того, щоб видалити всі пробіли з початку та в кінці рядка (включаючи символи кінця рядка):

echo $variable | xargs echo -n

Це також видалить повторювані пробіли:

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

Виробляє: "Цей рядок має багато пробілів"

Проведіть один провідний і один простір

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Наприклад:

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

Вихід:

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

Оберіть всі провідні та кінцеві місця

trim()
{
    local trimmed="$1"

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

    echo "$trimmed"
}

Наприклад:

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

Вихід:

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

З розділу посібника Bash про глобалізацію

Використання extglob у розширенні параметра

 #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  

Ось такий же функціонал, який увімкнений у функцію (ПРИМІТКА. Потрібно навести вхідний рядок, переданий функції):

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

Використання:

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

Якщо ми змінимо функцію для виконання в підшлубку, нам не доведеться турбуватися про розгляд поточної опції оболонки для extglob, ми можемо просто встановити її, не впливаючи на поточну оболонку. Це надзвичайно спрощує функцію. Я також оновлюю позиційні параметри "на місці", тому мені навіть не потрібна локальна змінна

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

тому:

$ 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

Ви можете просто обрізати echo:

foo=" qsdqsd qsdqs q qs   "

# Not trimmed
echo \'$foo\'

# Trim
foo=`echo $foo`

# Trimmed
echo \'$foo\'

Я завжди робив це з sed

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

Якщо є більш елегантне рішення, я сподіваюся, що хтось його викладе.

Ви можете видалити нові рядки за допомогою tr:

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

Якщо увімкнено розширені функції відповідності розширеного шаблону Баша ( shopt -s extglob), ви можете використовувати це:

{trimmed##*( )}

для видалення довільної кількості провідних пробілів.

# 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

Відповідей дуже багато, але я все ж вважаю, що мій щойно написаний сценарій варто згадати, оскільки:

• він був успішно випробуваний у оболонці bash / dash / busybox
• це надзвичайно мало
• це не залежить від зовнішніх команд і не потребує роздрібнення (-> швидке та низьке використання ресурсів)
• він працює як очікувалося:
  • він знімає всі пробіли та вкладки від початку та до кінця, але не більше
  • важливо: він не видаляє нічого з середини рядка (багато інших відповідей), навіть нові рядки залишаться
  • спеціальне: "$*"приєднує кілька аргументів, використовуючи один пробіл. якщо ви хочете обрізати та вивести лише перший аргумент, використовуйте "$1"замість цього
  • якщо немає проблем із узгодженням шаблонів назв файлів тощо

Сценарій:

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

Використання:

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

Вихід:

>here     is
    something<

Можна скористатися старої школою tr. Наприклад, це повертає кількість модифікованих файлів у сховищі git, пробіли позбавлені.

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

Це працювало для мене:

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>

Щоб розмістити це на меншій кількості рядків для того ж результату:

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

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

АБО

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

АБО

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

АБО

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

АБО

Спираючись на експрес-москіт москвіта ...

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

АБО

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

Я бачив, як сценарії просто використовують завдання змінної:

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

Пробіл автоматично з’єднується і обробляється. Потрібно бути обережними щодо метахарактерів оболонки (потенційний ризик ін'єкції).

Я також рекомендую завжди подвійне цитування змінних підстановок в умовних оболонках:

if [ -n "$var" ]; then

оскільки щось на зразок -o чи іншого вмісту в змінній може змінити ваші тестові аргументи.

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

Я просто використовую sed:

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

а) Приклад використання в однорядковому рядку

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

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

Вихід:

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

б) Приклад використання багаторядкової строки

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

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

Вихід:

GIVEN STRING: |    wordAA
   >wordB<
wordC    |

TRIMMED STRING: |wordAA
   >wordB<
wordC|

c) Заключна примітка:
Якщо вам не подобається використовувати функцію, для однорядкового рядка ви можете просто скористатися командою "легше запам'ятати", наприклад:

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

Приклад:

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

Вихід:

wordA wordB wordC

Використання вищезазначеного на багаторядкових рядках також буде добре , але врахуйте, що воно також виріже будь-який задні / провідний внутрішній багатопробільний простір, як GuruM помітив у коментарях

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

Вихід:

wordAA
>four spaces before<
>one space before<

Тож якщо ви проти затримати ці пробіли, будь ласка, скористайтеся функцією на початку моєї відповіді!

г) ПОЯСНЕННЯ синтаксису sed «знайти і замінити» на багаторядкових рядках, що використовуються всередині функції обрізки:

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

Ось функція trim (), яка обрізає та нормалізує пробіл

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

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

І ще один варіант, що використовує регулярні вирази.

#!/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:

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

Призначення ігнорують пробіли проміжних та кінцевих пробілів і як такі можуть використовуватися для обрізки:

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

У цьому немає проблем із небажаним глобулюванням, також внутрішній простір не змінюється (якщо припустити, що $IFSвін встановлений за замовчуванням, який є ' \t\n').

Він читає до першого нового рядка (і не включає його) або до кінця рядка, що залежно від першого, і знімає будь-яку суміш провідного та останнього простору та \tсимволів. Якщо ви хочете зберегти декілька рядків (а також смугу провідних та кінцевих нових рядків), використовуйте read -r -d '' var << eofзамість цього; проте зауважте, що якщо ваш вхід містить \neof, він буде відключений безпосередньо раніше. (Інші форми білого простору, а саме \r, \fі \v, не позбавлені, навіть якщо ви додасте їх до $ IFS.)

read -r var << eof
$var
eof

Щоб видалити пробіли та вкладки зліва до першого слова, введіть:

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

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

Це видалить усі білі простори з вашої рядка,

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

/замінює перше виникнення та //всі виникнення пробілів у рядку. Тобто всі білі проміжки замінюються - нічим

Це найпростіший метод, який я бачив. Він використовує лише Bash, це лише кілька рядків, регулярний регулярний вираз є простим і відповідає всім формам пробілів:

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

Ось зразок сценарію, щоб перевірити його за допомогою:

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 trim(), тому ми можемо просто зробити трохи вбудованого Python, щоб зробити легко зрозумілу утиліту для цього:

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

Це дозволить обрізати пробіли проміжного та нижнього (включаючи нові рядки).

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

Я виявив, що мені потрібно додати якийсь код із безладного sdiffвиводу, щоб очистити його:

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'

Це видаляє пробіли та інші невидимі символи.

Видалення пробілів в один простір:

(text) | fmt -su