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'

장갑판의 배쉬 가이드 섹션에서

매개 변수 확장에서 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

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

많은 답변이 있지만 여전히 다음과 같은 이유로 방금 작성한 스크립트를 언급 할 가치가 있다고 생각합니다.

• 쉘 bash / dash / busybox 쉘에서 성공적으로 테스트되었습니다.
• 매우 작습니다
• 외부 명령에 의존하지 않으며 분기 할 필요가 없습니다 (-> 빠르고 낮은 리소스 사용량)
• 예상대로 작동합니다.
  • 그것은 모든 공간과 탭을 시작과 끝에서 제거하지만 더 이상은 제거하지 않습니다.
  • 중요 : 문자열 중간에서 아무것도 제거하지 않으며 (많은 다른 답변이 수행), 줄 바꿈조차 남아 있습니다.
  • special : "$*"하나의 공백을 사용하여 여러 인수를 조인합니다. 첫 번째 인수 만 자르고 출력하려면 "$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<

old-school을 사용할 수 있습니다 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")"
}

또는

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

스크립트가 변수 할당을 사용하여 작업을 수행하는 것을 보았습니다.

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

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 구문 "find and replace"에 대한 설명 :

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

파이썬은 strip()PHP와 동일하게 작동 하는 기능 을 가지고 trim()있으므로 약간의 인라인 파이썬을 통해 이해하기 쉬운 유틸리티를 만들 수 있습니다.

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