Как обрезать пробелы из переменной Bash?
У меня есть сценарий оболочки с этим кодом:
var=`hg st -R "$path"`
if [ -n "$var" ]; then
echo $var
fi
Но условный код всегда выполняется, потому что hg st
всегда печатает хотя бы один символ новой строки.
- Есть ли простой способ убрать пробелы из
$var
(лайкtrim()
в PHP)?
или же
- Есть ли стандартный способ решения этой проблемы?
Я мог бы использовать sed или AWK, но я хотел бы думать, что есть более элегантное решение этой проблемы.
52 ответа
Простой ответ:
echo " lol " | xargs
Xargs сделает обрезку для вас. Это одна команда / программа, без параметров, которая возвращает обрезанную строку, просто!
Примечание: это не удаляет внутренние пробелы, поэтому "foo bar"
остается такой же. НЕ становится "foobar"
,
Давайте определим переменную, содержащую начальные, конечные и промежуточные пробелы:
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})"
Существует решение, которое использует только встроенные модули 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-совместимой оболочкой.
Ссылка
Чтобы удалить все пробелы в начале и конце строки (включая символы конца строки):
echo $variable | xargs echo -n
Это также удалит дубликаты пробелов:
echo " this string has a lot of spaces " | xargs echo -n
Производит: "в этой строке много пробелов"
В 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
Удалите один ведущий и один завершающий пробел
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 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
Вы можете обрезать просто с 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/ *$//'`
Если есть более элегантное решение, надеюсь, кто-нибудь опубликует его.
С включенными расширенными функциями сравнения шаблонов в Bash (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
Вы можете удалить переводы строк с tr
:
var=`hg st -R "$path" | tr -d '\n'`
if [ -n $var ]; then
echo $var
done
Есть много ответов, но я все еще верю, что мой только что написанный сценарий стоит упомянуть, потому что:
- он был успешно протестирован в оболочке bash/dash/busybox
- это очень мало
- он не зависит от внешних команд и не нуждается в форке (-> быстрое и низкое использование ресурсов)
- работает как положено:
- он удаляет все пробелы и табуляцию от начала и до конца, но не более
- важно: он ничего не удаляет из середины строки (многие другие ответы делают), даже переводы строки останутся
- особенный:
"$*"
объединяет несколько аргументов, используя один пробел. если вы хотите обрезать и вывести только первый аргумент, используйте"$1"
вместо - если нет проблем с сопоставлением шаблонов имен файлов и т. д.
Сценарий:
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<
Вот что я сделал и разработал идеально и очень просто:
the_string=" test"
the_string=`echo $the_string`
echo "$the_string"
Вывод:
test
Это сработало для меня:
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")")"
}
Чисто в BASH есть несколько разных вариантов:
line=${line##+( )} # strip leading whitespace; no quote expansion!
line=${line%%+( )} # strip trailing whitespace; no quote expansion!
line=${line// /} # strip all whitespace
line=${line//[[:space:]]/} # strip all whitespace
line=${line//[[:blank:]]/} # strip all blank space
Первые два требуют
extglob
быть установлен/включен априори:
shopt -s extglob # bash only
ПРИМЕЧАНИЕ: раскрытие переменной внутри кавычек разбивает два верхних примера!
Поведение сопоставления шаблонов выражений скобок POSIX подробно описано здесь . Если вы используете более современную/поддающуюся взлому оболочку, такую как Fish, есть встроенные функции для обрезки строк.
Вы можете использовать старую школу tr
, Например, это возвращает количество измененных файлов в репозитории git, пробелы удалены.
MYVAR=`git ls-files -m|wc -l|tr -d ' '`
Это удалит все пробелы из вашей строки,
VAR2="${VAR2//[[:space:]]/}"
/
заменяет первое вхождение и //
все вхождения пробелов в строке. Т.е. заменяются все пробелы - ничего
Я бы просто использовал 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|
в) Заключительная записка:
Если вам не нравится использовать функцию, для однострочной строки вы можете просто использовать команду "легче запомнить", например:
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 "найти и заменить" в многострочных строках, используемых внутри функции 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
}'
Я видел сценарии, которые просто используют переменные для выполнения работы:
$ xyz=`echo -e 'foo \n bar'`
$ echo $xyz
foo bar
Пробелы автоматически объединяются и обрезаются. Нужно быть осторожным с метасимволами оболочки (потенциальный риск инъекции).
Я бы также рекомендовал всегда подставлять переменные в кавычки в условных выражениях оболочки:
if [ -n "$var" ]; then
поскольку что-то вроде -o или другого содержимого в переменной может изменить ваши тестовые аргументы.
Назначения игнорируют начальные и конечные пробелы и как таковые могут быть использованы для обрезки:
$ var=`echo ' hello'`; echo $var
hello
Простой ответ:
sed 's/^\s*\|\s*$//g'
Пример:
$ before=$( echo -e " \t a b \t ")
$ echo "(${before})"
( a b )
$ after=$( echo "${before}" | sed 's/^\s*\|\s*$//g' )
$ echo "(${after})"
(a b)
Чтобы удалить пробелы и табуляции слева направо, введите:
echo " This is a test" | sed "s/^[ \t]*//"
ht tp://cyberciti.biz/tips/delete-leading-spaces-from-front-of-each-word.html
Вот функция 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'
Это самый простой метод, который я видел. Он использует только 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."
Это не имеет проблемы с нежелательным сглаживанием, кроме того, внутреннее пространство остается неизменным (при условии, что $IFS
установлен по умолчанию, который ' \t\n'
).
Он читает до первой новой строки (и не включает ее) или до конца строки, в зависимости от того, что наступит раньше, и удаляет любое сочетание начального и конечного пробелов и \t
персонажи. Если вы хотите сохранить несколько строк (а также убрать начальные и конечные строки), используйте read -r -d '' var << eof
вместо; обратите внимание, однако, что если ваш вклад содержит \neof
, он будет отрезан как раз перед этим. (Другие формы пустого пространства, а именно \r
, \f
, а также \v
, не удаляются, даже если вы добавите их в $IFS.)
read -r var << eof
$var
eof