Как обрезать пробелы из переменной Bash?

Question

Как обрезать пробелы из переменной Bash?

701

У меня есть оболочка script с этим кодом:

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

Но условный код всегда выполняется, потому что hg st всегда печатает хотя бы один символ новой строки.

Есть ли простой способ удалить пробелы из $var (например, trim() в PHP)?

или

Существует ли стандартный способ решения этой проблемы?

Я мог бы использовать sed или AWK, но я бы хотел подумать, что есть более элегантное решение этой проблемы.

too much php 15 дек. 2008, в 20:14

Источник

3

Связанный, если вы хотите обрезать пространство на целое число и просто получить целое число, оберните с $ (($ var)), и даже можете сделать это, когда внутри двойных кавычек. Это стало важным, когда я использовал оператор даты и с именами файлов.
Volomike 10 дек. 2012, в 14:42
0

«Есть ли стандартный способ решения этой проблемы?» Да, используйте [[вместо [. $ var=$(echo) $ [ -n $var ]; echo $? #undesired test return 0 $ [[ -n $var ]]; echo $? 1
user.friendly 26 апр. 2016, в 16:08
0

Если это поможет, по крайней мере, где я тестирую это на Ubuntu 16.04. Использование следующих совпадений во всех отношениях echo " This is a string of char " | xargs : echo " This is a string of char " | xargs Однако если в тексте есть одна кавычка, вы можете сделать следующее: echo " This i's a string of char " | xargs -0 . Обратите внимание, что я упоминаю последний из xargs (4.6.0)
Luis Alvarado 19 июль 2016, в 16:48
0

Условие не выполняется из-за новой строки, поскольку обратные черты заглатывают последнюю новую строку. Это ничего не напечатает test=`echo`; if [ -n "$test" ]; then echo "Not empty"; fi , однако это будет test=`echo "a"`; if [ -n "$test" ]; then echo "Not empty"; fi - в конце должно быть больше, чем просто перевод строки.
Mecki 19 июнь 2017, в 17:02
0

A = "123 4 5 6"; B = echo $A | sed -r 's/( )+//g' ;
bruziuz 17 июль 2018, в 11:25

Показать ещё 3 комментария

Теги:

string

bash

variables

trim

42 ответа

812

Определить переменную, содержащую начальные, конечные и промежуточные пробелы:

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 s:

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

В качестве альтернативы, если ваш bash поддерживает его, вы можете заменить echo -e "${FOO}" | sed ... на sed ... <<<${FOO}, например (для конечных пробелов):

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

MattyV 12 июль 2010, в 21:33

57

Чтобы обобщить решение для обработки всех форм пробелов, замените символ пробела в командах tr и sed на [[:space:]] . Обратите внимание, что подход sed будет работать только на однострочном вводе. Подходы, которые работают с многострочным вводом, а также используют встроенные функции bash, см. В ответах @bashfu и @GuruM. Обобщенная, встроенная версия решения @Nicholas Sushkin будет выглядеть следующим образом: trimmed=$([[ " test test test " =~ [[:space:]]*([^[:space:]]|[^[:space:]].*[^[:space:]])[[:space:]]* ]]; echo -n "${BASH_REMATCH[1]}")
mklement0 10 июнь 2012, в 14:05
7

Если вы делаете это часто, добавьте alias trim="sed -e 's/^[[:space:]]*//g' -e 's/[[:space:]]*\$//g'" в ~/.profile позволяет использовать echo $SOMEVAR | trim и cat somefile | trim
instanceof me 19 март 2013, в 15:59
0

Я написал решение sed которое использует только одно выражение, а не два: sed -r 's/^\s*(\S+(\s+\S+)*)\s*$/\1/' . Он обрезает начальные и конечные пробелы и фиксирует любые разделенные пробелами последовательности непробельных символов в середине. Наслаждайтесь!
Victor Zamanian 06 фев. 2014, в 17:41
0

@VictorZamanian Ваше решение не работает, если входные данные содержат только пробелы. Решения Sed с двумя шаблонами, предоставленные MattyV и instanceof, прекрасно работают с вводом только пробелов.
Torben 09 апр. 2014, в 07:38
0

@ Торбен Справедливая точка. Я полагаю, что одно выражение можно сделать условным, с | , чтобы сохранить его как одно выражение, а не как несколько.
Victor Zamanian 09 апр. 2014, в 13:59
0

Строка echo -e "${FOO}" | wc -m считает еще один символ, потому что эхо добавляет его. Попробуйте echo -ne "${FOO}" | wc -m и получите правильный счет.
user2350426 19 июль 2015, в 05:58
0

Недостатком этого метода является то, что он использует sed , поведение которого зависит от системы. В частности, sed из Solaris 10 не поддерживает [[:space:]] .
vinc17 26 апр. 2016, в 11:33
0

Я был очень смущен опцией -e команды echo. Я работаю на Mac, и он не распознается. Или, по крайней мере, не задокументировано на странице руководства. FOO=' test test test ' FOO_NO_WHITESPACE=$(echo "${FOO}" | tr -d '[:space:]') отлично работает для меня.
Mig82 13 фев. 2017, в 09:26
0

Спасибо .... tr -d '[: space:]' после grep в безопасности мои дни ....
T-Bee 16 март 2018, в 11:52
0

Обратите внимание, что tr -d "[:space:]" удаляет как горизонтальные, так и вертикальные пробельные символы (= переводы строки). Чтобы удалить только горизонтальные пробельные символы, просто используйте tr -d " " .
scai 13 нояб. 2018, в 07:48

Показать ещё 8 комментариев

671

Простой ответ:

echo "   lol  " | xargs

Xargs выполнит обрезку. Это одна команда/программа, без параметров, возвращает обрезанную строку, просто, как это!

Примечание: это не устраняет внутренние пространства, поэтому "foo bar" остается неизменным. Он не становится "foobar".

makevoid 19 окт. 2012, в 12:15

22

Ницца. Это работает очень хорошо. Я решил xargs echo его в xargs echo только для того, чтобы подробно рассказать о том, что я делаю, но xargs сам по себе будет использовать эхо по умолчанию.
Will 18 фев. 2013, в 18:59
0

На Windows это очень хорошее решение. Я обычно использую двоичные файлы gnu utils без bash (например, cygwin, unxutils, пользовательские сборки, mingw, git для windows, gnuwin32 ...), и поддержка sed и awk не очень согласована между ними.
n611x007 14 окт. 2013, в 15:29
0

Кроме того, sed , awk и bash - инструменты настолько старые, что используют синтаксис, который может показаться «загадочным». Люди , которые часто не использовать их, желая сделать простой манипуляции со строками, будет легко чувствовать себя разбитым ' или " или \ или / или // или ^ или $ , спрашивая себя , какой именно один был? Не могу поверить , что есть нет более простого решения этой простой вещи ... Есть.
n611x007 14 окт. 2013, в 15:44
0

Другая причина использования xargs - зачем вводить зависимость? xargs - это двоичный файл, который можно использовать с другими оболочками (мне даже удалось использовать его с cmd.exe ). Поскольку это довольно просто, это не зависит от какой-либо кривой обучения как инструмента немедленной полезности.
n611x007 14 окт. 2013, в 15:53
0

Используя grep . может дополнительно предотвратить вывод пустых строк.
A-B-B 27 нояб. 2013, в 19:31
19

Хороший трюк, но будьте осторожны, вы можете использовать его для однострочной строки, но - благодаря дизайну xargs - он не просто будет работать с многострочным контентом. Сед твой друг тогда.
Jocelyn delalande 28 нояб. 2013, в 09:57
16

Единственная проблема с xargs состоит в том, что он вводит новую строку, если вы хотите, чтобы новая строка была отключена, я бы порекомендовал sed 's/ *$//' в качестве альтернативы. Вы можете увидеть новую xargs так: echo -n "hey thiss " | xargs | hexdump вы заметите 0a73 a является символом новой строки. Если вы сделаете то же самое с sed : echo -n "hey thiss " | sed 's/ *$//' | hexdump вы увидите 0073 , без новой строки.
user4401178 07 янв. 2015, в 04:30
6

Осторожный; это сломается, если строка в xargs содержит лишние пробелы между ними. Как «это один аргумент». xargs разделит на четыре.
bos 24 янв. 2015, в 23:12
46

Это плохо. 1. Он превратит a<space><space>b в a<space>b . 2. Даже больше: она превратится a"b"c'd'e в abcde . 3. Еще больше: он провалится на a"b и т. Д.
Sasha 11 фев. 2015, в 23:20
0

@makevoid Почему вы удалили (очень важное) предупреждение из этого ответа? Это не меняет поведение xargs ...
Daniel Alder 24 фев. 2015, в 12:27
0

@DanielAlder добавил примечание, я удалил это, потому что это было слишком длинно, примечания должны быть короткими - слишком длинный ответ иногда может считаться неправильным из-за TL; DR :)
makevoid 25 март 2015, в 13:40
3

Я использовал xargs для обрезки простых строк, пока не обнаружил, что он не работает на строках с одинарной кавычкой или несколькими внутренними пробелами (как было предупреждено выше). Я не могу рекомендовать этот метод.
Quinn Comendant 07 май 2015, в 22:40
2

Это очень быстрое решение при обрезке простых строк из одного слова. Я использовал это для удаления вывода строки sqlite, где имя столбца имеет бесполезное заполнение в сценарии.
F-3000 12 апр. 2016, в 04:00
0

Я понимаю недостатки этого, но это здорово, когда вы знаете, что ожидаемый результат будет всего одним значением, например, из wc -l . Я использую это для удаления начальных пробелов (которые, похоже, включены в версию wc macOS): ls .. | wc -l | xargs
nwinkler 27 июнь 2017, в 06:30
1

@AlexanderMills спасибо за искренность .... может быть попробовать с этим? A=$(echo " lol " | xargs); echo $A
makevoid 14 июль 2017, в 16:37

Показать ещё 13 комментариев

264

Существует решение, в котором используются только Bash встроенные подстановочные знаки:

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

Здесь же завернутый в функцию:

trim() {
    local var="$*"
    # remove leading whitespace characters
    var="${var#"${var%%[![:space:]]*}"}"
    # remove trailing whitespace characters
    var="${var%"${var##*[![:space:]]}"}"   
    echo -n "$var"
}

Вы передаете строку, подлежащую обрезке в кавычках. например:

trim "   abc   "

Хорошая вещь об этом решении заключается в том, что он будет работать с любой POSIX-совместимой оболочкой.

Ссылка

Удалить ведущие и конечные пробелы из переменной Bash (original источник)

bashfu 28 июль 2010, в 10:37

0

@luca borrione: local var = "$ 1"
Ярослав Рахматуллин 14 сен. 2012, в 09:16
0

Я попробовал ваше решение, но использование local var = "$ @" сжимает несколько внутренних пробелов в один пробел . Таким образом, строка с несколькими пробелами, например, «a <multi-space> bcd», будет переводиться в «abc d» с одним пробелом. Единственный способ, предложенный @mkelement, - это заключить в кавычки непосредственно входную переменную, то есть обрезать «$ string», в этом случае $ @ в любом случае расширяется до одного параметра.
GuruM 18 сен. 2012, в 14:52
14

Умная! Это мое любимое решение, так как оно использует встроенную функциональность bash. Спасибо за публикацию! @ Сан, это две вложенные строки. Например, s=" 1 2 3 "; echo \""${s%1 2 3 }"\" обрезает все с конца, возвращая ведущий " " . Подстановка 1 2 3 с помощью [![:space:]]* говорит ему «найти первый непробельный символ, затем забить его и все после». Использование %% вместо % делает операцию обрезки с конца жадной. Это вложено в не жадную обрезку с самого начала, так что, по сути, вы обрезаете " " с самого начала. Затем поменяйте местами%, # и * для конечных пробелов. Бам!
Mark G. 12 нояб. 2014, в 17:04
2

Я не нашел никаких нежелательных побочных эффектов, и основной код работает также с другими POSIX-подобными оболочками. Однако в Solaris 10 он не работает с /bin/sh (только с /usr/xpg4/bin/sh , но это не то, что будет использоваться с обычными сценариями sh).
vinc17 26 апр. 2016, в 11:57
0

Хорошо, скажем, что это также нормально для Solaris 10 даже без bash, где можно поставить { a=a; : ${a%b}; } 2> /dev/null || exec /usr/xpg4/bin/sh -- "$0" ${1+"$@"} в начале скрипта для использования совместимой оболочки.
vinc17 26 апр. 2016, в 12:12
9

Намного лучшее решение, чем использование sed, tr и т. Д., Так как это намного быстрее, избегая использования fork (). На Cygwin разница в скорости составляет порядки величины.
Gene Pavlovsky 03 июль 2016, в 09:33
8

@San Сначала я был в тупике, потому что думал, что это регулярные выражения. Они не. Скорее всего , это шаблон синтаксис ( gnu.org/software/bash/manual/html_node/Pattern-Matching.html , wiki.bash-hackers.org/syntax/pattern ) , используемый в Substring удаления ( tldp.org/LDP/abs /html/string-manipulation.html ). Таким образом, ${var%%[![:space:]]*} говорит: «удалить из var его самую длинную подстроку, начинающуюся с непробельного символа». Это означает, что у вас остались только первые пробелы, которые вы впоследствии удалите с помощью ${var#.. Следующая строка (трейлинг) противоположна.
Ohad Schneider 25 янв. 2017, в 18:50
1

В подавляющем большинстве это идеальное решение. Работа с одним или несколькими внешними процессами (например, awk , sed , tr , xargs ) просто для обрезки пробелов из одной строки принципиально безумна, особенно когда большинство оболочек (включая bash) уже предоставляют встроенные средства для поиска строк из коробки. ,
Cecil Curry 14 авг. 2018, в 20:44

Показать ещё 6 комментариев

65

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

Ниже показано, как удалить все белое пространство (даже изнутри) из значения переменной.

$ var='abc def'
$ echo "$var"
abc def
# Note: flussence original expression was "${var/ /}", which only replaced the *first* space char., wherever it appeared.
$ echo -n "${var//[[:space:]]/}"
abcdef

user42092 15 дек. 2008, в 23:13

1

Кажется, он не работает с Cygwin.
Paul Tomblin 15 дек. 2008, в 21:54
2

Или, скорее, это работает для пробелов в середине var, но не когда я пытаюсь закрепить его в конце.
Paul Tomblin 15 дек. 2008, в 21:56
0

Это помогает любому? Из man-страницы: «$ {параметр / шаблон / строка} [...] Если шаблон начинается с%, он должен совпадать в конце расширенного значения параметра.»
user42092 15 дек. 2008, в 22:28
0

@ Неужели они не регулярные выражения, а что-то похожее?
Paul Tomblin 15 дек. 2008, в 22:40
3

Они регулярные выражения, просто странный диалект.
user42092 05 март 2009, в 12:36
0

заменить все совпадения echo $ {var //}
Peter Lindqvist 27 нояб. 2009, в 10:01
11

${var/ /} удаляет первый пробел. ${var// /} удаляет все пробелы. Нет способа обрезать только начальные и конечные пробелы только с помощью этой конструкции.
Gilles 03 июнь 2012, в 19:47
0

@PaulTomblin: руководство по bash называет их шаблонами, и, хотя они имеют некоторые функции с регулярными выражениями, они достаточно отличаются, чтобы не называть их регулярными выражениями, чтобы избежать путаницы.
mklement0 04 июнь 2012, в 13:51
0

Я думаю, что это было то, о чем я говорил - flussence называл их регулярными выражениями, но это не так.
Paul Tomblin 04 июнь 2012, в 13:52
0

Шаблоны Bash не являются регулярными выражениями. Bash поддерживает как синтаксис шаблона Bash, так и подлинные регулярные выражения (например, с помощью встроенного оператора =~ представленного в Bash 3.0.0). Два не имеют ничего общего друг с другом.
Cecil Curry 14 авг. 2018, в 20:53
0

«Шаблоны» Bash - это регулярные выражения , только с синтаксисом, отличным от «регулярных выражений POSIX (расширенных)». Вы правы, говоря, что они несовместимы, и что Bash ожидает их в разных местах (первый в подстановках параметров, второй после оператора =~ ). Что касается их выразительности: с «расширенными операторами сопоставления с образцом» (опция оболочки extglob ) единственными функциями, которые есть в man 7 regex POSIX и в образцах Bash, являются ^ и $ (сравните man bash § «Сопоставление с образцом» с man 7 regex ).
Maëlan 24 март 2019, в 22:44

Показать ещё 9 комментариев

36

Вы можете обрезать только с помощью echo:

foo=" qsdqsd qsdqs q qs   "

# Not trimmed
echo \'$foo\'

# Trim
foo=`echo $foo`

# Trimmed
echo \'$foo\'

VAmp 14 март 2013, в 00:53

0

Это объединяет несколько смежных пространств в одно.
Evgeni Sergeev 16 дек. 2013, в 06:13
5

Вы пробовали, когда foo содержит подстановочный знак? например, foo=" I * have a wild card" ... сюрприз! Более того, это объединяет несколько смежных пространств в одно.
gniourf_gniourf 28 апр. 2014, в 08:47
5

Это отличное решение, если вы: 1. не хотите пробелов на концах 2. хотите, чтобы между каждым словом был только один пробел 3. работаете с контролируемым вводом без подстановочных знаков. По сути, он превращает плохо отформатированный список в хороший.
musicin3d 19 нояб. 2015, в 15:25
0

Хорошее напоминание о подстановочных знаках @gniourf_gniourf +1. Все еще превосходное решение, Вамп. +1 тебе тоже.
Dr Beco 21 март 2016, в 01:05

Показать ещё 2 комментария

36

Удалите один ведущий и один завершающий пробел

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'

Brian Cain 05 нояб. 2009, в 22:20

7

Это обрезает только 1 пробел. Таким образом, эхо приводит к 'hello world ', 'foo bar', 'both sides '
Joe 14 июль 2014, в 15:33
0

@ Джо, я добавил лучший вариант.
wjandrea 09 дек. 2017, в 02:09

31

Чтобы удалить все пробелы с начала и конца строки (включая символы конца строки):

echo $variable | xargs echo -n

Это также удалит повторяющиеся пробелы:

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

Производит: "эта строка имеет много пробелов"

rkachach 04 дек. 2016, в 19:44

0

Как это работает?
Roger 08 март 2017, в 14:37
4

По сути, xargs удаляет все разделители из строки. По умолчанию он использует пробел в качестве разделителя (это можно изменить с помощью параметра -d).
rkachach 08 март 2017, в 15:57
3

Это, безусловно, самое чистое (как короткое, так и читаемое) решение.
Potherca 16 авг. 2017, в 07:59
0

Зачем тебе вообще echo -n ? echo " my string " | xargs имеет тот же вывод.
bfontaine 20 март 2019, в 09:26
0

echo -n также удаляет конец строки
rkachach 20 март 2019, в 09:35

Показать ещё 3 комментария

26

Из раздела Bash Guide по глобализации

Использовать 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

GuruM 20 сен. 2011, в 14:18

2

как вы заметили, trim () удаляет только начальные и конечные пробелы.
GuruM 12 сен. 2012, в 13:03
0

Как уже заметил mkelement, вам нужно передать параметр функции в виде строки в кавычках, т.е. $ (trim "$ string") вместо $ (trim $ string). Я обновил код, чтобы показать правильное использование. Благодарю.
GuruM 18 сен. 2012, в 09:57
0

+1 за заботу, чтобы завершить дела :)
Luca Borrione 18 сен. 2012, в 10:08
0

Ценить это!! :-)
GuruM 18 сен. 2012, в 10:15
0

Как бы мне ни хотелось знать о параметрах оболочки, я не думаю, что конечный результат будет более элегантным, чем простая замена двух шаблонов.
sehe 01 нояб. 2016, в 12:33
0

Обратите внимание, что (с достаточно недавней версией Bash?) Вы можете упростить механизм восстановления опции extglob , используя shopt -p : просто напишите local restore="$(shopt -p extglob)" ; shopt -s extglob в начале вашей функции и eval "$restore" в конце (за исключением того, что eval - это зло…).
Maëlan 24 март 2019, в 22:56

Показать ещё 4 комментария

22

С включенными функциями совместимости с расширенными шаблонами Bash (shopt -s extglob) вы можете использовать это:

{trimmed##*( )}

чтобы удалить произвольное количество начальных пробелов.

Mooshu 10 июнь 2010, в 16:45

0

Потрясающе! Я думаю, что это самое легкое и элегантное решение.
dubiousjim 27 янв. 2011, в 18:50
1

Смотрите пост @ GuruM ниже для аналогичного, но более общего решения, которое (а) имеет дело со всеми формами пустого пространства и (б) также обрабатывает конечные пробелы.
mklement0 03 июнь 2012, в 19:55
0

@mkelement +1 за труд переписать мой фрагмент кода как функцию. Спасибо
GuruM 21 сен. 2012, в 05:20
0

Также работает с OpenBSD по умолчанию / bin / ksh. /bin/sh -o posix тоже работает, но я с подозрением.
Clint Pachl 16 март 2018, в 19:19
0

Здесь не волшебник Баш; что trimmed ? Это встроенная вещь или переменная, которая обрезается?
Abhijit Sarkar 30 март 2018, в 17:51
0

@Abhhijit Sarkar - это последнее
Armali 26 июль 2018, в 08:29

Показать ещё 4 комментария

18

Вы можете удалить символы новой строки с помощью tr:

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

Adam Rosenfield 15 дек. 2008, в 22:47

6

Я не хочу удалять '\ n' из середины строки, только из начала или конца.
too much php 15 дек. 2008, в 21:48

17

# 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

flabdablet 25 янв. 2012, в 10:06

1

Удивительно! Просто и эффективно! Понятно мое любимое решение. Спасибо!
xebeche 02 авг. 2012, в 11:21
1

Что делает ${!1} ? Это не совсем понятно.
Craig McQueen 18 июнь 2014, в 06:22
0

очень гениальный, так как он также чрезвычайно хелпер "one liner", read -rd '' str < <(echo "$str") thx!
Aquarius Power 02 апр. 2015, в 20:53
0

@CraigMcQueen это значение переменной, поскольку read будет хранить в переменной по ее имени $ 1 урезанную версию ее значения $ {! 1}
Aquarius Power 02 апр. 2015, в 20:54
1

Параметр функции trim () является именем переменной: см. Вызов функции trim () внутри test_trim (). В рамках trim (), вызываемой из test_trim (), $ 1 расширяется до foo, а $ {! 1} расширяется до $ foo (то есть до текущего содержимого переменной foo). Найдите в руководстве по bash 'переменная косвенность'.
flabdablet 09 апр. 2015, в 12:54
0

Как насчет этой небольшой модификации, чтобы поддержать обрезку нескольких переменных в одном вызове? trim() { while [[ $# -gt 0 ]]; do read -rd '' $1 <<<"${!1}"; shift; done; }
Gene Pavlovsky 03 июль 2016, в 09:37
1

@AquariusPower для однострочной версии не нужно использовать echo в подоболочке, просто read -rd '' str <<<"$str" подойдет.
flabdablet 03 июль 2016, в 19:08

Показать ещё 5 комментариев

16

Я всегда делал это с sed

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

Если есть более элегантное решение, я надеюсь, что кто-то разместит его.

Paul Tomblin 15 дек. 2008, в 22:00

0

Не могли бы вы объяснить синтаксис для sed ?
farid99 08 июль 2015, в 20:21
2

Регулярное выражение соответствует всем конечным пробелам и заменяет его ничем.
Paul Tomblin 08 июль 2015, в 20:23
3

Как насчет ведущих пробелов?
Elgs Qian Chen 10 фев. 2016, в 06:28
0

Это удаляет все завершающие пробелы sed -e 's/\s*$//' . Объяснение: «s» означает поиск, «\ s» означает все пробелы, «*» означает ноль или много, «$» означает до конца строки, а «//» означает замену всех совпадений пустой строкой ,
Craig 12 апр. 2016, в 12:21

Показать ещё 2 комментария

10

Есть много ответов, но я по-прежнему считаю, что мой просто написанный script стоит упомянуть, потому что:

он был успешно протестирован в оболочках bash/dash/busybox shell
он чрезвычайно мал
он не зависит от внешних команд и не нужен fork (- > быстрый и низкий ресурс)
работает как и ожидалось:
- он удаляет все пробелы и вкладки с начала и конца, но не более
- important: он не удаляет ничего из середины строки (многие другие ответы), даже новые строки будут оставаться
- special: "$*" объединяет несколько аргументов, используя одно пространство. если вы хотите обрезать и выводить только первый аргумент, используйте "$1" вместо
- Если у вас нет проблем с совпадением шаблонов имен файлов и т.д.

script:

trim() {
  local s2 s="$*"
  # note: the brackets in each of the following two lines contain one space
  # and one tab
  until s2="${s#[   ]}"; [ "$s2" = "$s" ]; do s="$s2"; done
  until s2="${s%[   ]}"; [ "$s2" = "$s" ]; do s="$s2"; done
  echo "$s"
}

Использование:

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

Вывод:

>here     is
    something<

Daniel Alder 21 окт. 2015, в 01:13

0

Бах в С это было бы проще реализовать!
Nils 14 окт. 2016, в 10:47
1

хорошо, может быть, не проще, но гораздо меньше "WTF ?!"
Nils 14 окт. 2016, в 10:49
0

Конечно. К сожалению, это не C, и иногда вы хотите избежать вызова внешних инструментов
Daniel Alder 14 окт. 2016, в 11:02
0

Чтобы сделать код более читабельным и совместимым с копированием, вы можете изменить скобки на экранированные символы: [\ \t]
meonlol 21 янв. 2017, в 23:06
0

Escape @meonlol не совместимы с busybox ...
Daniel Alder 25 янв. 2017, в 17:54

Показать ещё 3 комментария

10

Вы можете использовать старую школу tr. Например, это возвращает количество измененных файлов в репозитории git, удаленные пробелы.

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

pojo 27 нояб. 2009, в 09:52

0

Это не удаляет пробелы спереди и сзади - оно удаляет все пробелы из строки.
Nick 06 дек. 2013, в 15:28

8

Это сработало для меня:

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##+( )}%%+( )}

gMale 11 сен. 2014, в 21:06

1

Не работал для меня Первый напечатал не обрезанную строку. Второй бросил плохую замену. Можете ли вы объяснить, что здесь происходит?
musicin3d 19 нояб. 2015, в 15:23
1

@ musicin3d: это сайт, которым я часто пользуюсь, который объясняет, как работает манипулирование переменными в поиске bash для ${var##Pattern} для получения более подробной информации. Также этот сайт объясняет паттерны bash . Таким образом, ## означает удаление данного шаблона спереди, а %% означает удаление данного шаблона сзади. Часть +( ) является шаблоном и означает «одно или несколько вхождений пробела»
gMale 21 нояб. 2015, в 18:13
0

Забавно, это работало в подсказке, но не после переноса в файл скрипта bash.
Dr Beco 21 март 2016, в 01:03
0

странно. Это одна и та же версия Bash в обоих случаях?
gMale 21 март 2016, в 19:11

Показать ещё 2 комментария

7

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

ultr 01 апр. 2013, в 11:35

0

Это не сработает, если между любыми двумя словами будет больше одного пробела. Попробуйте: echo $(echo "1 2 3") (с двумя пробелами между 1, 2 и 3).
joshlf 14 авг. 2013, в 22:26

7

Я видел, что сценарии используют назначение переменной для выполнения задания:

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

Пробел автоматически объединяется и обрезается. Нужно быть осторожным с метасимволами оболочки (потенциальный риск инъекций).

Я бы также рекомендовал всегда заменять двойные кавычки на переменные оболочки:

if [ -n "$var" ]; then

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

MykennaC 15 дек. 2008, в 23:53

3

Использование без кавычек $xyz с echo делает объединение пробелов, а не присваивание переменных. Чтобы сохранить усеченное значение в переменной в вашем примере, вы должны будете использовать xyz=$(echo -n $xyz) . Кроме того, этот подход подвержен потенциально нежелательному расширению пути (globbing).
mklement0 04 июнь 2012, в 04:20
0

это просто неправильно, значение в переменной xyz НЕ обрезается.
caesarsol 10 июнь 2015, в 14:24

6

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

ИЛИ ЖЕ

Опираясь на moskit expr soulution...

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

NOYB 01 май 2017, в 21:23

6

Я бы просто использовал sed:

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

a) Пример использования в строке с одной строкой

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|

b) Пример использования в многострочной строке

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<

Итак, если вы не хотите хранить эти пробелы, используйте функцию в начале моего ответа!

d) ОБЪЯСНЕНИЕ синтаксиса 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
}'

Luca Borrione 27 авг. 2012, в 18:34

0

Примечание: как предложено @mkelement, он не будет работать для многострочных строк, хотя он должен работать для однострочных строк.
GuruM 18 сен. 2012, в 10:18
1

Вы не правы: он работает и на многострочных строках. Просто проверьте это! :)
Luca Borrione 18 сен. 2012, в 12:36
0

+1 за использование - мне было легко протестировать код. Однако код по-прежнему не будет работать для многострочных строк. Если вы внимательно посмотрите на вывод, вы заметите, что все начальные / конечные внутренние пробелы также удаляются, например, пространство перед «многострочным» заменяется «многострочным». Просто попробуйте увеличить количество пробелов в каждой строке.
GuruM 18 сен. 2012, в 14:16
0

Теперь я понимаю, что вы имеете в виду! Спасибо за голову, я отредактировал мой ответ.
Luca Borrione 18 сен. 2012, в 15:04
0

@ "Luca Borrione" - добро пожаловать :-) Не могли бы вы объяснить синтаксис sed, который вы используете в trim ()? Это также может помочь любому пользователю вашего кода настроить его для других целей. Также это может даже помочь найти крайние случаи для регулярного выражения.
GuruM 19 сен. 2012, в 06:22
0

давайте продолжим это обсуждение в чате
GuruM 19 сен. 2012, в 06:26
1

Добавлено объяснение @GuruM :)
Luca Borrione 19 сен. 2012, в 07:43

Показать ещё 5 комментариев

5

Здесь функция 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'

Nicholas Sushkin 08 июнь 2011, в 17:00

0

Первый подход сложен в том, что он не только нормализует внутренние пробелы (заменяет все внутренние промежутки пробелами на один пробел каждый), но также подвергается глобализации (расширение пути), так что, например, символ * во входной строке расширится на все файлы и папки в текущей рабочей папке. Наконец, если для $ IFS установлено значение не по умолчанию, обрезка может не работать (хотя это легко исправить, добавив local IFS=$' \t\n' ). Обрезка ограничена следующими формами пробелов: пробелы, символы \t и \n .
mklement0 04 июнь 2012, в 21:53
1

Второй подход, основанный на регулярных выражениях, хорош и лишен побочных эффектов, но в его нынешнем виде проблематичен: (a) в bash v3.2 + сопоставление по умолчанию НЕ будет работать, потому что регулярное выражение должно быть в кавычках, чтобы работать и (б) само регулярное выражение не обрабатывает случай, когда входная строка представляет собой один непробельный символ, окруженный пробелами. Чтобы устранить эти проблемы, замените строку if на: if [[ "$trimmed" =~ ' '*([^ ]|[^ ].*[^ ])' '* ]] . Наконец, подход касается только пробелов, а не других форм пробелов (см. Мой следующий комментарий).
mklement0 04 июнь 2012, в 21:53
2

Функция, которая использует регулярные выражения, имеет дело только с пробелами, а не с другими формами пробелов, но ее легко обобщить: заменить строку if на: [[ "$trimmed" =~ [[:space:]]*([^[:space:]]|[^[:space:]].*[^[:space:]])[[:space:]]* ]]
mklement0 04 июнь 2012, в 21:54

Показать ещё 1 комментарий

4

У этого нет проблемы с нежелательным globbing, также внутреннее белое пространство немодифицировано (предполагается, что для параметра $IFS установлено значение по умолчанию, которое равно ' \t\n').

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

read -r var << eof
$var
eof

Gregor 03 нояб. 2011, в 00:19

4

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

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

evanx 01 окт. 2010, в 13:06

7

Это не правда. Это «эхо», которое удаляет пробелы, а не назначение. В вашем примере выполните echo "$var" чтобы увидеть значение с пробелами.
Nicholas Sushkin 09 фев. 2012, в 17:41
2

@NicholasSushkin Можно было бы сделать var=$(echo $var) но я не рекомендую это делать. Другие решения, представленные здесь, являются предпочтительными.
xebeche 02 авг. 2012, в 11:08

4

Используйте AWK:

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

ghostdog74 06 нояб. 2009, в 00:46

0

Сладкий, который, кажется, работает (ex :) $stripped_version= echo $ var | awk '{gsub (/ ^ + | + $ /, "")} 1'``
rogerdpack 15 апр. 2010, в 18:29
4

за исключением того, что awk ничего не делает: вывод переменной без кавычек уже удаляет пробелы
glenn jackman 08 июнь 2011, в 10:41

3

Это самый простой метод, который я видел. Он использует только Bash, это всего несколько строк, регулярное выражение простое и соответствует всем формам пробелов:

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

Вот пример script, чтобы проверить его с помощью

test=$(echo -e "\n \t Spaces and tabs and newlines be gone! \t  \n ")

echo "Let see if this works:"
echo
echo "----------"
echo -e "Testing:${test} :Tested"  # Ugh!
echo "----------"
echo
echo "Ugh!  Let 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."

blujay 28 апр. 2014, в 05:36

1

Конечно, предпочтительнее, например (вы, боги!), Обстреливать Python. За исключением того, что я думаю, что проще и более общим правильно обрабатывать строку, содержащую только пробелы. Слегка упрощенным выражением будет: ^[[:space:]]*(.*[^[:space:]])?[[:space:]]*$
Ron Burk 10 апр. 2017, в 21:58

3

Это удалит все пробелы из вашей строки,

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

/ заменяет первое вхождение и // все вхождения пробелов в строке. То есть все белые пробелы заменяются на - ничего

Alpesh Gediya 29 май 2013, в 12:20

3

Чтобы удалить пробелы и вкладки слева направо, введите:

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

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

Steven Penny 06 июль 2012, в 07:37

3

#!/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]
#[]

Razor5900 02 дек. 2011, в 04:18

2

Использование:

trim() {
    local orig="$1"
    local trmd=""
    while true;
    do
        trmd="${orig#[[:space:]]}"
        trmd="${trmd%[[:space:]]}"
        test "$trmd" = "$orig" && break
        orig="$trmd"
    done
    printf -- '%s\n' "$trmd"
}

Он работает со всеми типами пробелов, включая новую строку,
Не нужно изменять shopt.
Он сохраняет внутри пробелов, включая новую строку.

Unit test (для ручного просмотра):

#!/bin/bash

. trim.sh

enum() {
    echo "   a b c"
    echo "a b c   "
    echo "  a b c "
    echo " a b c  "
    echo " a  b c  "
    echo " a  b  c  "
    echo " a      b  c  "
    echo "     a      b  c  "
    echo "     a  b  c  "
    echo " a  b  c      "
    echo " a  b  c      "
    echo " a N b  c  "
    echo "N a N b  c  "
    echo " Na  b  c  "
    echo " a  b  c N "
    echo " a  b  c  N"
}

xcheck() {
    local testln result
    while IFS='' read testln;
    do
        testln=$(tr N '\n' <<<"$testln")
        echo ": ~~~~~~~~~~~~~~~~~~~~~~~~~ :" >&2
        result="$(trim "$testln")"
        echo "testln='$testln'" >&2
        echo "result='$result'" >&2
    done
}

enum | xcheck

Alois Mahdal 12 июль 2015, в 22:41

2

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

brownhead 07 авг. 2014, в 23:38

0

в то время как это работает, вы можете подумать о предложении решения, которое не предполагает запуска полного интерпретатора Python просто для обрезки строки. Это просто расточительно.
pdwalker 03 апр. 2015, в 12:00

2

trim() удаляет пробелы (и вкладки, непечатаемые символы, для простоты я рассматриваю просто пробелы). Моя версия решения:

var="$(hg st -R "$path")" # I often like to enclose shell output in double quotes
var="$(echo "${var}" | sed "s/\(^ *\| *\$\)//g")" # This is my suggestion
if [ -n "$var" ]; then
 echo "[${var}]"
fi

Команда "sed" обрезает только ведущие и завершающие пробелы, но ее можно передать в первую команду, а также:

var="$(hg st -R "$path" | sed "s/\(^ *\| *\$\)//g")"
if [ -n "$var" ]; then
 echo "[${var}]"
fi

Avenger 15 июнь 2012, в 22:46

2

Я обнаружил, что мне нужно добавить код из беспорядочного вывода 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'

Это удаляет конечные пробелы и другие невидимые символы.

user1186515 04 фев. 2012, в 01:08

2

Я создал следующие функции. Я не уверен, насколько переносимым является printf, но красота этого решения заключается в том, что вы можете точно указать, что такое "пробел", добавляя больше кодов символов.

    iswhitespace()
    {
        n=`printf "%d\n" "'$1'"`
        if (( $n != "13" )) && (( $n != "10" )) && (( $n != "32" )) && (( $n != "92" )) && (( $n != "110" )) && (( $n != "114" )); then
            return 0
        fi
        return 1
    }

    trim()
    {
        i=0
        str="$1"
        while (( i < ${#1} ))
        do
            char=${1:$i:1}
            iswhitespace "$char"
            if [ "$?" -eq "0" ]; then
                str="${str:$i}"
                i=${#1}
            fi
            (( i += 1 ))
        done
        i=${#str}
        while (( i > "0" ))
        do
            (( i -= 1 ))
            char=${str:$i:1}
            iswhitespace "$char"
            if [ "$?" -eq "0" ]; then
                (( i += 1 ))
                str="${str:0:$i}"
                i=0
            fi
        done
        echo "$str"
    }

#Call it like so
mystring=`trim "$mystring"`

cmeub 15 нояб. 2010, в 02:47

2

Это уменьшает количество пробелов переднего и конечного

whatever=${whatever%% *}

whatever=${whatever#* }

gretelmk2 11 окт. 2010, в 13:38

7

Ваша вторая команда должна иметь ## не только # . Но на самом деле они не работают; шаблон, который вы даете, соответствует пробелу, за которым следует любая последовательность других символов, а не последовательность из 0 или более пробелов. Это * оболочка * , а не обычное регулярное выражение "0 или более" * .
dubiousjim 27 янв. 2011, в 18:50
1

Это полезно, если вы знаете, что в строке не будет пробелов. Они отлично работают для преобразования " foo " в "foo" . Для " hello world " , не так много.
J.D. 28 фев. 2015, в 16:29
0

t=" "" a "" "; echo "=${t#* }=" output = a = ведущие несколько пробелов не удаляются. t=" "" a "" "; echo "=${t%% *}=" output == конечные пробелы удаляются с содержимым строки. (Двойное цитирование из-за SE.)
catpnosis 24 март 2018, в 16:08

Показать ещё 1 комментарий

1

Использование:

var=`expr "$var" : "^\ *\(.*[^ ]\)\ *$"`

Он удаляет ведущие и конечные пробелы и является самым основным решением, я считаю. Не Bash встроенный, но 'expr' является частью coreutils, поэтому, по крайней мере, не требуются автономные утилиты, такие как sed или AWK.

moskit 06 март 2014, в 22:58

1

var="  a b  "
echo "$(set -f; echo $var)"

>a b

davide 28 фев. 2013, в 01:46

1

Используйте это простое расширение Bash:

$ x=" a z     e r ty "
$ echo "START[${x// /}]END"
START[azerty]END

Gilles Quenot 03 июнь 2012, в 20:18

1

Этот подход (а) также удаляет внутренние пробелы и (б) удаляет только пробелы , а не другие формы пустого пространства.
mklement0 04 июнь 2012, в 14:49
0

@ mklement0 Иногда это именно то, что нужно, хотя! :-)
Ville 19 фев. 2017, в 05:46
1

@Ville: Да, и с помощью моего комментария с разъяснением поведения будущие читатели могут решить, подходит ли им это решение.
mklement0 19 фев. 2017, в 06:08

Показать ещё 1 комментарий

1

Еще одно решение с модульными тестами, которое обрезает $IFS от stdin и работает с любым разделителем ввода (даже $'\0'):

ltrim()
{
    # Left-trim $IFS from stdin as a single line
    # $1: Line separator (default NUL)
    local trimmed
    while IFS= read -r -d "${1-}" -u 9
    do
        if [ -n "${trimmed+defined}" ]
        then
            printf %s "$REPLY"
        else
            printf %s "${REPLY#"${REPLY%%[!$IFS]*}"}"
        fi
        printf "${1-\x00}"
        trimmed=true
    done 9<&0

    if [[ $REPLY ]]
    then
        # No delimiter at last line
        if [ -n "${trimmed+defined}" ]
        then
            printf %s "$REPLY"
        else
            printf %s "${REPLY#"${REPLY%%[!$IFS]*}"}"
        fi
    fi
}

rtrim()
{
    # Right-trim $IFS from stdin as a single line
    # $1: Line separator (default NUL)
    local previous last
    while IFS= read -r -d "${1-}" -u 9
    do
        if [ -n "${previous+defined}" ]
        then
            printf %s "$previous"
            printf "${1-\x00}"
        fi
        previous="$REPLY"
    done 9<&0

    if [[ $REPLY ]]
    then
        # No delimiter at last line
        last="$REPLY"
        printf %s "$previous"
        if [ -n "${previous+defined}" ]
        then
            printf "${1-\x00}"
        fi
    else
        last="$previous"
    fi

    right_whitespace="${last##*[!$IFS]}"
    printf %s "${last%$right_whitespace}"
}

trim()
{
    # Trim $IFS from individual lines
    # $1: Line separator (default NUL)
    ltrim ${1+"$@"} | rtrim ${1+"$@"}
}

l0b0 21 сен. 2011, в 11:04

1

Мне нужно было обрезать пробелы из script, когда переменная IFS была установлена на что-то еще. Опираясь на Perl сделал трюк:

# trim() { echo $1; } # This doesn't seem to work, as it affected by IFS

trim() { echo "$1" | perl -p -e 's/^\s+|\s+$//g'; }

strings="after --> , <-- before,  <-- both -->  "

OLD_IFS=$IFS
IFS=","
for str in ${strings}; do
  str=$(trim "${str}")
  echo "str= '${str}'"
done
IFS=$OLD_IFS

TrinitronX 07 июнь 2011, в 21:28

1

Вы можете легко избежать проблем со значениями $ IFS, отличными от заданных по умолчанию, создав локальную копию (которая выйдет из области видимости после выхода из функции): trim() { local IFS=$' \t\n'; echo $1; }
mklement0 02 июнь 2012, в 03:17

1

Удаление пробелов в одно пространство:

(text) | fmt -su

gardziol 13 июнь 2010, в 10:58

-3

#Execute this script with the string argument passed in double quotes !! 
#var2 gives the string without spaces.
#$1 is the string passed in double quotes
#!/bin/bash
var2=`echo $1 | sed 's/ \+//g'`
echo $var2

a.saurabh 20 март 2013, в 04:59

-4

Пока это не строго Bash, это сделает то, что вы хотите, и многое другое:

php -r '$x = trim("  hi there  "); echo $x;'

Если вы хотите сделать это в нижнем регистре, выполните следующие действия:

php -r '$x = trim("  Hi There  "); $x = strtolower($x) ; echo $x;'

David Newcomb 07 янв. 2013, в 15:45

Ещё вопросы

Связанный, если вы хотите обрезать пространство на целое число и просто получить целое число, оберните с $ (($ var)), и даже можете сделать это, когда внутри двойных кавычек. Это стало важным, когда я использовал оператор даты и с именами файлов.
«Есть ли стандартный способ решения этой проблемы?» Да, используйте [[вместо [. $ var=$(echo) $ [ -n $var ]; echo $? #undesired test return 0 $ [[ -n $var ]]; echo $? 1
Если это поможет, по крайней мере, где я тестирую это на Ubuntu 16.04. Использование следующих совпадений во всех отношениях echo " This is a string of char " | xargs : echo " This is a string of char " | xargs Однако если в тексте есть одна кавычка, вы можете сделать следующее: echo " This i's a string of char " | xargs -0 . Обратите внимание, что я упоминаю последний из xargs (4.6.0)
Условие не выполняется из-за новой строки, поскольку обратные черты заглатывают последнюю новую строку. Это ничего не напечатает test=`echo`; if [ -n "$test" ]; then echo "Not empty"; fi , однако это будет test=`echo "a"`; if [ -n "$test" ]; then echo "Not empty"; fi - в конце должно быть больше, чем просто перевод строки.
Чтобы обобщить решение для обработки всех форм пробелов, замените символ пробела в командах tr и sed на [[:space:]] . Обратите внимание, что подход sed будет работать только на однострочном вводе. Подходы, которые работают с многострочным вводом, а также используют встроенные функции bash, см. В ответах @bashfu и @GuruM. Обобщенная, встроенная версия решения @Nicholas Sushkin будет выглядеть следующим образом: trimmed=$([[ " test test test " =~ [[:space:]]*([^[:space:]]|[^[:space:]].*[^[:space:]])[[:space:]]* ]]; echo -n "${BASH_REMATCH[1]}")
Если вы делаете это часто, добавьте alias trim="sed -e 's/^[[:space:]]*//g' -e 's/[[:space:]]*\$//g'" в ~/.profile позволяет использовать echo $SOMEVAR | trim и cat somefile | trim
Я написал решение sed которое использует только одно выражение, а не два: sed -r 's/^\s*(\S+(\s+\S+)*)\s*$/\1/' . Он обрезает начальные и конечные пробелы и фиксирует любые разделенные пробелами последовательности непробельных символов в середине. Наслаждайтесь!
@VictorZamanian Ваше решение не работает, если входные данные содержат только пробелы. Решения Sed с двумя шаблонами, предоставленные MattyV и instanceof, прекрасно работают с вводом только пробелов.
@ Торбен Справедливая точка. Я полагаю, что одно выражение можно сделать условным, с | , чтобы сохранить его как одно выражение, а не как несколько.
Строка echo -e "${FOO}" | wc -m считает еще один символ, потому что эхо добавляет его. Попробуйте echo -ne "${FOO}" | wc -m и получите правильный счет.
Недостатком этого метода является то, что он использует sed , поведение которого зависит от системы. В частности, sed из Solaris 10 не поддерживает [[:space:]] .
Я был очень смущен опцией -e команды echo. Я работаю на Mac, и он не распознается. Или, по крайней мере, не задокументировано на странице руководства. FOO=' test test test ' FOO_NO_WHITESPACE=$(echo "${FOO}" | tr -d '[:space:]') отлично работает для меня.
Спасибо .... tr -d '[: space:]' после grep в безопасности мои дни ....
Обратите внимание, что tr -d "[:space:]" удаляет как горизонтальные, так и вертикальные пробельные символы (= переводы строки). Чтобы удалить только горизонтальные пробельные символы, просто используйте tr -d " " .
Ницца. Это работает очень хорошо. Я решил xargs echo его в xargs echo только для того, чтобы подробно рассказать о том, что я делаю, но xargs сам по себе будет использовать эхо по умолчанию.
На Windows это очень хорошее решение. Я обычно использую двоичные файлы gnu utils без bash (например, cygwin, unxutils, пользовательские сборки, mingw, git для windows, gnuwin32 ...), и поддержка sed и awk не очень согласована между ними.
Кроме того, sed , awk и bash - инструменты настолько старые, что используют синтаксис, который может показаться «загадочным». Люди , которые часто не использовать их, желая сделать простой манипуляции со строками, будет легко чувствовать себя разбитым ' или " или \ или / или // или ^ или $ , спрашивая себя , какой именно один был? Не могу поверить , что есть нет более простого решения этой простой вещи ... Есть.
Другая причина использования xargs - зачем вводить зависимость? xargs - это двоичный файл, который можно использовать с другими оболочками (мне даже удалось использовать его с cmd.exe ). Поскольку это довольно просто, это не зависит от какой-либо кривой обучения как инструмента немедленной полезности.
Используя grep . может дополнительно предотвратить вывод пустых строк.
Хороший трюк, но будьте осторожны, вы можете использовать его для однострочной строки, но - благодаря дизайну xargs - он не просто будет работать с многострочным контентом. Сед твой друг тогда.
Единственная проблема с xargs состоит в том, что он вводит новую строку, если вы хотите, чтобы новая строка была отключена, я бы порекомендовал sed 's/ *$//' в качестве альтернативы. Вы можете увидеть новую xargs так: echo -n "hey thiss " | xargs | hexdump вы заметите 0a73 a является символом новой строки. Если вы сделаете то же самое с sed : echo -n "hey thiss " | sed 's/ *$//' | hexdump вы увидите 0073 , без новой строки.
Осторожный; это сломается, если строка в xargs содержит лишние пробелы между ними. Как «это один аргумент». xargs разделит на четыре.
Это плохо. 1. Он превратит a<space><space>b в a<space>b . 2. Даже больше: она превратится a"b"c'd'e в abcde . 3. Еще больше: он провалится на a"b и т. Д.
@makevoid Почему вы удалили (очень важное) предупреждение из этого ответа? Это не меняет поведение xargs ...
@DanielAlder добавил примечание, я удалил это, потому что это было слишком длинно, примечания должны быть короткими - слишком длинный ответ иногда может считаться неправильным из-за TL; DR :)
Я использовал xargs для обрезки простых строк, пока не обнаружил, что он не работает на строках с одинарной кавычкой или несколькими внутренними пробелами (как было предупреждено выше). Я не могу рекомендовать этот метод.
Это очень быстрое решение при обрезке простых строк из одного слова. Я использовал это для удаления вывода строки sqlite, где имя столбца имеет бесполезное заполнение в сценарии.
Я понимаю недостатки этого, но это здорово, когда вы знаете, что ожидаемый результат будет всего одним значением, например, из wc -l . Я использую это для удаления начальных пробелов (которые, похоже, включены в версию wc macOS): ls .. | wc -l | xargs
@AlexanderMills спасибо за искренность .... может быть попробовать с этим? A=$(echo " lol " | xargs); echo $A
Я попробовал ваше решение, но использование local var = "$ @" сжимает несколько внутренних пробелов в один пробел . Таким образом, строка с несколькими пробелами, например, «a <multi-space> bcd», будет переводиться в «abc d» с одним пробелом. Единственный способ, предложенный @mkelement, - это заключить в кавычки непосредственно входную переменную, то есть обрезать «$ string», в этом случае $ @ в любом случае расширяется до одного параметра.
Умная! Это мое любимое решение, так как оно использует встроенную функциональность bash. Спасибо за публикацию! @ Сан, это две вложенные строки. Например, s=" 1 2 3 "; echo \""${s%1 2 3 }"\" обрезает все с конца, возвращая ведущий " " . Подстановка 1 2 3 с помощью [![:space:]]* говорит ему «найти первый непробельный символ, затем забить его и все после». Использование %% вместо % делает операцию обрезки с конца жадной. Это вложено в не жадную обрезку с самого начала, так что, по сути, вы обрезаете " " с самого начала. Затем поменяйте местами%, # и * для конечных пробелов. Бам!
Я не нашел никаких нежелательных побочных эффектов, и основной код работает также с другими POSIX-подобными оболочками. Однако в Solaris 10 он не работает с /bin/sh (только с /usr/xpg4/bin/sh , но это не то, что будет использоваться с обычными сценариями sh).
Хорошо, скажем, что это также нормально для Solaris 10 даже без bash, где можно поставить { a=a; : ${a%b}; } 2> /dev/null || exec /usr/xpg4/bin/sh -- "$0" ${1+"$@"} в начале скрипта для использования совместимой оболочки.
Намного лучшее решение, чем использование sed, tr и т. Д., Так как это намного быстрее, избегая использования fork (). На Cygwin разница в скорости составляет порядки величины.
@San Сначала я был в тупике, потому что думал, что это регулярные выражения. Они не. Скорее всего , это шаблон синтаксис ( gnu.org/software/bash/manual/html_node/Pattern-Matching.html , wiki.bash-hackers.org/syntax/pattern ) , используемый в Substring удаления ( tldp.org/LDP/abs /html/string-manipulation.html ). Таким образом, ${var%%[![:space:]]*} говорит: «удалить из var его самую длинную подстроку, начинающуюся с непробельного символа». Это означает, что у вас остались только первые пробелы, которые вы впоследствии удалите с помощью ${var#.. Следующая строка (трейлинг) противоположна.
В подавляющем большинстве это идеальное решение. Работа с одним или несколькими внешними процессами (например, awk , sed , tr , xargs ) просто для обрезки пробелов из одной строки принципиально безумна, особенно когда большинство оболочек (включая bash) уже предоставляют встроенные средства для поиска строк из коробки. ,
Или, скорее, это работает для пробелов в середине var, но не когда я пытаюсь закрепить его в конце.
Это помогает любому? Из man-страницы: «$ {параметр / шаблон / строка} [...] Если шаблон начинается с%, он должен совпадать в конце расширенного значения параметра.»
@ Неужели они не регулярные выражения, а что-то похожее?
Они регулярные выражения, просто странный диалект.
заменить все совпадения echo $ {var //}
${var/ /} удаляет первый пробел. ${var// /} удаляет все пробелы. Нет способа обрезать только начальные и конечные пробелы только с помощью этой конструкции.
@PaulTomblin: руководство по bash называет их шаблонами, и, хотя они имеют некоторые функции с регулярными выражениями, они достаточно отличаются, чтобы не называть их регулярными выражениями, чтобы избежать путаницы.
Я думаю, что это было то, о чем я говорил - flussence называл их регулярными выражениями, но это не так.
Шаблоны Bash не являются регулярными выражениями. Bash поддерживает как синтаксис шаблона Bash, так и подлинные регулярные выражения (например, с помощью встроенного оператора =~ представленного в Bash 3.0.0). Два не имеют ничего общего друг с другом.
«Шаблоны» Bash - это регулярные выражения , только с синтаксисом, отличным от «регулярных выражений POSIX (расширенных)». Вы правы, говоря, что они несовместимы, и что Bash ожидает их в разных местах (первый в подстановках параметров, второй после оператора =~ ). Что касается их выразительности: с «расширенными операторами сопоставления с образцом» (опция оболочки extglob ) единственными функциями, которые есть в man 7 regex POSIX и в образцах Bash, являются ^ и $ (сравните man bash § «Сопоставление с образцом» с man 7 regex ).
Это объединяет несколько смежных пространств в одно.
Вы пробовали, когда foo содержит подстановочный знак? например, foo=" I * have a wild card" ... сюрприз! Более того, это объединяет несколько смежных пространств в одно.
Это отличное решение, если вы: 1. не хотите пробелов на концах 2. хотите, чтобы между каждым словом был только один пробел 3. работаете с контролируемым вводом без подстановочных знаков. По сути, он превращает плохо отформатированный список в хороший.
Хорошее напоминание о подстановочных знаках @gniourf_gniourf +1. Все еще превосходное решение, Вамп. +1 тебе тоже.
Это обрезает только 1 пробел. Таким образом, эхо приводит к 'hello world ', 'foo bar', 'both sides '
По сути, xargs удаляет все разделители из строки. По умолчанию он использует пробел в качестве разделителя (это можно изменить с помощью параметра -d).
Это, безусловно, самое чистое (как короткое, так и читаемое) решение.
Зачем тебе вообще echo -n ? echo " my string " | xargs имеет тот же вывод.
как вы заметили, trim () удаляет только начальные и конечные пробелы.
Как уже заметил mkelement, вам нужно передать параметр функции в виде строки в кавычках, т.е. $ (trim "$ string") вместо $ (trim $ string). Я обновил код, чтобы показать правильное использование. Благодарю.
+1 за заботу, чтобы завершить дела :)
Как бы мне ни хотелось знать о параметрах оболочки, я не думаю, что конечный результат будет более элегантным, чем простая замена двух шаблонов.
Обратите внимание, что (с достаточно недавней версией Bash?) Вы можете упростить механизм восстановления опции extglob , используя shopt -p : просто напишите local restore="$(shopt -p extglob)" ; shopt -s extglob в начале вашей функции и eval "$restore" в конце (за исключением того, что eval - это зло…).
Потрясающе! Я думаю, что это самое легкое и элегантное решение.
Смотрите пост @ GuruM ниже для аналогичного, но более общего решения, которое (а) имеет дело со всеми формами пустого пространства и (б) также обрабатывает конечные пробелы.
@mkelement +1 за труд переписать мой фрагмент кода как функцию. Спасибо
Также работает с OpenBSD по умолчанию / bin / ksh. /bin/sh -o posix тоже работает, но я с подозрением.
Здесь не волшебник Баш; что trimmed ? Это встроенная вещь или переменная, которая обрезается?
Я не хочу удалять '\ n' из середины строки, только из начала или конца.
Удивительно! Просто и эффективно! Понятно мое любимое решение. Спасибо!
Что делает ${!1} ? Это не совсем понятно.
очень гениальный, так как он также чрезвычайно хелпер "one liner", read -rd '' str < <(echo "$str") thx!
@CraigMcQueen это значение переменной, поскольку read будет хранить в переменной по ее имени $ 1 урезанную версию ее значения $ {! 1}
Параметр функции trim () является именем переменной: см. Вызов функции trim () внутри test_trim (). В рамках trim (), вызываемой из test_trim (), $ 1 расширяется до foo, а $ {! 1} расширяется до $ foo (то есть до текущего содержимого переменной foo). Найдите в руководстве по bash 'переменная косвенность'.
Как насчет этой небольшой модификации, чтобы поддержать обрезку нескольких переменных в одном вызове? trim() { while [[ $# -gt 0 ]]; do read -rd '' $1 <<<"${!1}"; shift; done; }
@AquariusPower для однострочной версии не нужно использовать echo в подоболочке, просто read -rd '' str <<<"$str" подойдет.
Не могли бы вы объяснить синтаксис для sed ?
Регулярное выражение соответствует всем конечным пробелам и заменяет его ничем.
Это удаляет все завершающие пробелы sed -e 's/\s*$//' . Объяснение: «s» означает поиск, «\ s» означает все пробелы, «*» означает ноль или много, «$» означает до конца строки, а «//» означает замену всех совпадений пустой строкой ,
Бах в С это было бы проще реализовать!
хорошо, может быть, не проще, но гораздо меньше "WTF ?!"
Конечно. К сожалению, это не C, и иногда вы хотите избежать вызова внешних инструментов
Чтобы сделать код более читабельным и совместимым с копированием, вы можете изменить скобки на экранированные символы: [\ \t]
Это не удаляет пробелы спереди и сзади - оно удаляет все пробелы из строки.
Не работал для меня Первый напечатал не обрезанную строку. Второй бросил плохую замену. Можете ли вы объяснить, что здесь происходит?
@ musicin3d: это сайт, которым я часто пользуюсь, который объясняет, как работает манипулирование переменными в поиске bash для ${var##Pattern} для получения более подробной информации. Также этот сайт объясняет паттерны bash . Таким образом, ## означает удаление данного шаблона спереди, а %% означает удаление данного шаблона сзади. Часть +( ) является шаблоном и означает «одно или несколько вхождений пробела»
Забавно, это работало в подсказке, но не после переноса в файл скрипта bash.
странно. Это одна и та же версия Bash в обоих случаях?
Это не сработает, если между любыми двумя словами будет больше одного пробела. Попробуйте: echo $(echo "1 2 3") (с двумя пробелами между 1, 2 и 3).
Использование без кавычек $xyz с echo делает объединение пробелов, а не присваивание переменных. Чтобы сохранить усеченное значение в переменной в вашем примере, вы должны будете использовать xyz=$(echo -n $xyz) . Кроме того, этот подход подвержен потенциально нежелательному расширению пути (globbing).
это просто неправильно, значение в переменной xyz НЕ обрезается.
Примечание: как предложено @mkelement, он не будет работать для многострочных строк, хотя он должен работать для однострочных строк.
Вы не правы: он работает и на многострочных строках. Просто проверьте это! :)
+1 за использование - мне было легко протестировать код. Однако код по-прежнему не будет работать для многострочных строк. Если вы внимательно посмотрите на вывод, вы заметите, что все начальные / конечные внутренние пробелы также удаляются, например, пространство перед «многострочным» заменяется «многострочным». Просто попробуйте увеличить количество пробелов в каждой строке.
Теперь я понимаю, что вы имеете в виду! Спасибо за голову, я отредактировал мой ответ.
@ "Luca Borrione" - добро пожаловать :-) Не могли бы вы объяснить синтаксис sed, который вы используете в trim ()? Это также может помочь любому пользователю вашего кода настроить его для других целей. Также это может даже помочь найти крайние случаи для регулярного выражения.
давайте продолжим это обсуждение в чате
Первый подход сложен в том, что он не только нормализует внутренние пробелы (заменяет все внутренние промежутки пробелами на один пробел каждый), но также подвергается глобализации (расширение пути), так что, например, символ * во входной строке расширится на все файлы и папки в текущей рабочей папке. Наконец, если для $ IFS установлено значение не по умолчанию, обрезка может не работать (хотя это легко исправить, добавив local IFS=$' \t\n' ). Обрезка ограничена следующими формами пробелов: пробелы, символы \t и \n .
Второй подход, основанный на регулярных выражениях, хорош и лишен побочных эффектов, но в его нынешнем виде проблематичен: (a) в bash v3.2 + сопоставление по умолчанию НЕ будет работать, потому что регулярное выражение должно быть в кавычках, чтобы работать и (б) само регулярное выражение не обрабатывает случай, когда входная строка представляет собой один непробельный символ, окруженный пробелами. Чтобы устранить эти проблемы, замените строку if на: if [[ "$trimmed" =~ ' '*([^ ]|[^ ].*[^ ])' '* ]] . Наконец, подход касается только пробелов, а не других форм пробелов (см. Мой следующий комментарий).
Функция, которая использует регулярные выражения, имеет дело только с пробелами, а не с другими формами пробелов, но ее легко обобщить: заменить строку if на: [[ "$trimmed" =~ [[:space:]]*([^[:space:]]|[^[:space:]].*[^[:space:]])[[:space:]]* ]]
Это не правда. Это «эхо», которое удаляет пробелы, а не назначение. В вашем примере выполните echo "$var" чтобы увидеть значение с пробелами.
@NicholasSushkin Можно было бы сделать var=$(echo $var) но я не рекомендую это делать. Другие решения, представленные здесь, являются предпочтительными.
Сладкий, который, кажется, работает (ex :) $stripped_version= echo $ var | awk '{gsub (/ ^ + | + $ /, "")} 1'``
за исключением того, что awk ничего не делает: вывод переменной без кавычек уже удаляет пробелы
Конечно, предпочтительнее, например (вы, боги!), Обстреливать Python. За исключением того, что я думаю, что проще и более общим правильно обрабатывать строку, содержащую только пробелы. Слегка упрощенным выражением будет: ^[[:space:]]*(.*[^[:space:]])?[[:space:]]*$
в то время как это работает, вы можете подумать о предложении решения, которое не предполагает запуска полного интерпретатора Python просто для обрезки строки. Это просто расточительно.
Ваша вторая команда должна иметь ## не только # . Но на самом деле они не работают; шаблон, который вы даете, соответствует пробелу, за которым следует любая последовательность других символов, а не последовательность из 0 или более пробелов. Это * оболочка * , а не обычное регулярное выражение "0 или более" * .
Это полезно, если вы знаете, что в строке не будет пробелов. Они отлично работают для преобразования " foo " в "foo" . Для " hello world " , не так много.
t=" "" a "" "; echo "=${t#* }=" output = a = ведущие несколько пробелов не удаляются. t=" "" a "" "; echo "=${t%% *}=" output == конечные пробелы удаляются с содержимым строки. (Двойное цитирование из-за SE.)
Этот подход (а) также удаляет внутренние пробелы и (б) удаляет только пробелы , а не другие формы пустого пространства.
@ mklement0 Иногда это именно то, что нужно, хотя! :-)
@Ville: Да, и с помощью моего комментария с разъяснением поведения будущие читатели могут решить, подходит ли им это решение.
Вы можете легко избежать проблем со значениями $ IFS, отличными от заданных по умолчанию, создав локальную копию (которая выйдет из области видимости после выхода из функции): trim() { local IFS=$' \t\n'; echo $1; }

too much php · Accepted Answer · 2017-12-04T18-07-00.000Z

Извините, проблема в другом месте в моем script, и я думал, что var имеет в ней конечную новую строку, но на самом деле это не так. Командная строка замещения завершает новые строки автоматически, как указано здесь: http://tldp.org/LDP/abs/html/commandsub.html.