Jak przekonwertować łańcuch znaków na małe litery w Bash?

W Bash 4:

Do małych liter

$ string="A FEW WORDS"
$ echo "${string,}"
a FEW WORDS
$ echo "${string,,}"
a few words
$ echo "${string,,[AEIUO]}"
a FeW WoRDS

$ string="A Few Words"
$ declare -l string
$ string=$string; echo "$string"
a few words

Do wielkich liter

$ string="a few words"
$ echo "${string^}"
A few words
$ echo "${string^^}"
A FEW WORDS
$ echo "${string^^[aeiou]}"
A fEw wOrds

$ string="A Few Words"
$ declare -u string
$ string=$string; echo "$string"
A FEW WORDS

Toggle (nieudokumentowane, ale opcjonalnie konfigurowalne podczas kompilacji)

$ string="A Few Words"
$ echo "${string~~}"
a fEW wORDS
$ string="A FEW WORDS"
$ echo "${string~}"
a FEW WORDS
$ string="a few words"
$ echo "${string~}"
A few words

Capitalize (nieudokumentowane, ale opcjonalnie konfigurowalne podczas kompilacji)

$ string="a few words"
$ declare -c string
$ string=$string
$ echo "$string"
A few words

Tytuł sprawy:

$ string="a few words"
$ string=($string)
$ string="${string[@]^}"
$ echo "$string"
A Few Words

$ declare -c string
$ string=(a few words)
$ echo "${string[@]}"
A Few Words

$ string="a FeW WOrdS"
$ string=${string,,}
$ string=${string~}
$ echo "$string"
A few words

Aby wyłączyć atrybut declare, użyj +. Na przykład declare +c string. Ma to wpływ na kolejne przypisania, a nie na bieżącą wartość.

Opcje declare zmieniają atrybut zmienna, ale nie zawartość. Zmiany w moich przykładach aktualizują zawartość, aby pokazać zmiany.

Edit:

Edit: Poprawiono zachowanie tyldy, aby pasowało do Bash 4.3.

echo "Hi All" | tr "[:upper:]" "[:lower:]"

Tr :

a="$(tr [A-Z] [a-z] <<< "$a")"

AWK :

{ print tolower($0) }

Sed :

y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/

Wiem, że to stary post, ale zrobiłem tę odpowiedź na inną stronę, więc pomyślałem, że wrzucę ją tutaj:

Górny - > dolny : użyj Pythona:

b=`echo "print '$a'.lower()" | python`

Lub Ruby:

b=`echo "print '$a'.downcase" | ruby`

Lub Perl (chyba mój ulubiony):

b=`perl -e "print lc('$a');"`

Lub PHP:

b=`php -r "print strtolower('$a');"`

Lub Awk:

b=`echo "$a" | awk '{ print tolower($1) }'`

Lub Sed:

b=`echo "$a" | sed 's/./\L&/g'`

Lub Bash 4:

b=${a,,}

Lub NodeJS, jeśli go masz (i jesteś trochę szalony...):

b=`echo "console.log('$a'.toLowerCase());" | node`

Można też użyć dd (ale ja nie!):

b=`echo "$a" | dd  conv=lcase 2> /dev/null`

Dolny - > górny :

Użyj Pythona:

b=`echo "print '$a'.upper()" | python`

Lub Ruby:

b=`echo "print '$a'.upcase" | ruby`

Lub Perl (chyba mój ulubiony):

b=`perl -e "print uc('$a');"`

Lub PHP:

b=`php -r "print strtoupper('$a');"`

Lub Awk:

b=`echo "$a" | awk '{ print toupper($1) }'`

Lub Sed:

b=`echo "$a" | sed 's/./\U&/g'`

Lub Bash 4:

b=${a^^}

Lub NodeJS, jeśli go masz (i jesteś trochę szalony...):

b=`echo "console.log('$a'.toUpperCase());" | node`

Możesz też użyć dd (ale ja nie!):

b=`echo "$a" | dd  conv=ucase 2> /dev/null`

Również, kiedy mówisz "shell" zakładam, że masz na myśli bash ale jeśli możesz użyć zsh to jest tak proste, jak

b=$a:l

Dla małych liter i

b=$a:u

Dla wielkich liter.

W zsh:

echo $a:u

Gotta love zsh!

Using GNU sed:

sed 's/.*/\L&/'

Przykład:

$ foo="Some STRIng";
$ foo=$(echo "$foo" | sed 's/.*/\L&/')
$ echo "$foo"
some string

Dla standardowej powłoki (bez bashismów) używającej tylko wbudowanych:

uppers=ABCDEFGHIJKLMNOPQRSTUVWXYZ
lowers=abcdefghijklmnopqrstuvwxyz

lc(){ #usage: lc "SOME STRING" -> "some string"
    i=0
    while ([ $i -lt ${#1} ]) do
        CUR=${1:$i:1}
        case $uppers in
            *$CUR*)CUR=${uppers%$CUR*};OUTPUT="${OUTPUT}${lowers:${#CUR}:1}";;
            *)OUTPUT="${OUTPUT}$CUR";;
        esac
        i=$((i+1))
    done
    echo "${OUTPUT}"
}

I dla wielkich liter:

uc(){ #usage: uc "some string" -> "SOME STRING"
    i=0
    while ([ $i -lt ${#1} ]) do
        CUR=${1:$i:1}
        case $lowers in
            *$CUR*)CUR=${lowers%$CUR*};OUTPUT="${OUTPUT}${uppers:${#CUR}:1}";;
            *)OUTPUT="${OUTPUT}$CUR";;
        esac
        i=$((i+1))
    done
    echo "${OUTPUT}"
}

Pre Bash 4.0

Bash obniża wielkość liter łańcucha i przypisuje do zmiennej

VARIABLE=$(echo "$VARIABLE" | tr '[:upper:]' '[:lower:]') 

echo "$VARIABLE"

Wyrażenie regularne

Chciałbym pochwalić się poleceniem, którym chciałbym się podzielić, ale prawda jest taka, że otrzymałem je na własny użytek od http://commandlinefu.com . ma tę zaletę, że jeśli cd do dowolnego katalogu wewnątrz własnego katalogu domowego, który jest to zmieni wszystkie pliki i foldery na małe litery, należy używać z ostrożnością. Jest to genialna poprawka wiersza poleceń i szczególnie przydatna dla tych wielu albumów, które zapisałeś na swoim jedź.

find . -depth -exec rename 's/(.*)\/([^\/]*)/$1\/\L$2/' {} \;

Możesz określić katalog zamiast kropki (.) po find oznaczającym bieżący katalog lub pełną ścieżkę.

Mam nadzieję, że to rozwiązanie okaże się użyteczne jedyną rzeczą, której to polecenie nie robi, jest zamiana spacji na podkreślniki-no cóż, może innym razem.

W bash 4 możesz użyć typeset

Przykład:

A="HELLO WORLD"
typeset -l A=$A

Możesz spróbować tego

s="Hello World!" 

echo $s  # Hello World!

a=${s,,}
echo $a  # hello world!

b=${s^^}
echo $b  # HELLO WORLD!

Ref: http://wiki.workassis.com/shell-script-convert-text-to-lowercase-and-uppercase/

Jeśli używasz v4, to jest to . Jeśli nie, oto proste, powszechnie stosowane Rozwiązanie. Inne odpowiedzi (i komentarze) w tym wątku były bardzo pomocne w tworzeniu poniższego kodu.

# Like echo, but converts to lowercase
echolcase () {
    tr [:upper:] [:lower:] <<< "${*}"
}

# Takes one arg by reference (var name) and makes it lowercase
lcase () { 
    eval "${1}"=\'$(echo ${!1//\'/"'\''"} | tr [:upper:] [:lower:] )\'
}

uwagi:

• robi: a="Hi All" a następnie: lcase a zrobi to samo co: a=$( echolcase "Hi All" )
• w funkcji lcase użycie ${!1//\'/"'\''"} zamiast ${!1} pozwala to działać nawet wtedy, gdy łańcuch znaków ma cudzysłowy.

Dla wersji Bash wcześniejszych niż 4.0, ta wersja powinna być najszybsza (ponieważ nie fork/exec żadnych poleceń):

function string.monolithic.tolower
{
   local __word=$1
   local __len=${#__word}
   local __char
   local __octal
   local __decimal
   local __result

   for (( i=0; i<__len; i++ ))
   do
      __char=${__word:$i:1}
      case "$__char" in
         [A-Z] )
            printf -v __decimal '%d' "'$__char"
            printf -v __octal '%03o' $(( $__decimal ^ 0x20 ))
            printf -v __char \\$__octal
            ;;
      esac
      __result+="$__char"
   done
   REPLY="$__result"
}

Odpowiedź Technozaura miała też potencjał, chociaż działała prawidłowo dla mee.

Pomimo tego, jak stare jest to pytanie i podobne do tej odpowiedzi przez technosaurus . Miałem trudności ze znalezieniem rozwiązania, które było przenośne na większości platform (których używam), a także starszych wersjach bash. Byłem również sfrustrowany tablicami, funkcjami i używaniem wydruków, echa i plików tymczasowych do pobierania trywialnych zmiennych. To działa bardzo dobrze dla mnie do tej pory myślałem, że podzielę. Moje główne środowiska testowe to:

1. GNU bash, wersja 4.1.2 (1)-release (x86_64-redhat-linux-gnu)
2. GNU bash, wersja 3.2.57(1) - release (sparc-sun-solaris2.10)

lcs="abcdefghijklmnopqrstuvwxyz"
ucs="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
input="Change Me To All Capitals"
for (( i=0; i<"${#input}"; i++ )) ; do :
    for (( j=0; j<"${#lcs}"; j++ )) ; do :
        if [[ "${input:$i:1}" == "${lcs:$j:1}" ]] ; then
            input="${input/${input:$i:1}/${ucs:$j:1}}" 
        fi
    done
done

Prosty C-styl dla pętli do iteracji przez łańcuchy. Dla poniższej linii, jeśli wcześniej czegoś takiego nie widziałeś tutaj nauczyłem się tego . W tym przypadku linia sprawdza, czy znak ${input:$i:1} (małe litery) istnieje w wejściu i jeśli tak, zastępuje go znakiem ${ucs:$j: 1} (wielkie litery) i zapisuje go z powrotem do wejście.

input="${input/${input:$i:1}/${ucs:$j:1}}"

Wiele odpowiedzi za pomocą zewnętrznych programów, które tak naprawdę nie używają Bash.

Jeśli wiesz, że będziesz miał Bash4, naprawdę powinieneś użyć notacji ${VAR,,} (jest to łatwe i fajne). Dla Bash przed 4 (mój Mac nadal używa Bash 3.2 na przykład). Użyłem poprawionej wersji odpowiedzi @ghostdog74, aby stworzyć bardziej przenośną wersję.

Można wywołać lowercase 'my STRING' i uzyskać wersję z małymi literami. Czytam komentarze na temat ustawiania wyniku na var, ale to nie jest naprawdę przenośny w Bash, ponieważ nie możemy zwracać ciągów. Druk jest najlepszym rozwiązaniem. Łatwy do uchwycenia za pomocą czegoś takiego jak var="$(lowercase $str)".

Jak to działa

Sposób, w jaki to działa, polega na pobraniu reprezentacji liczb całkowitych ASCII każdego znaku z printf i adding 32 if upper-to->lower, lub subtracting 32 if lower-to->upper. Następnie ponownie użyj printf, aby przekonwertować liczbę z powrotem na znak. Od 'A' -to-> 'a' mamy różnicę 32 znaków.

Używając printf do wyjaśnić:

$ printf "%d\n" "'a"
97
$ printf "%d\n" "'A"
65

97 - 65 = 32

A to jest wersja robocza z przykładami.
Proszę zwrócić uwagę na komentarze w kodzie, ponieważ wyjaśniają one wiele rzeczy: {]}

#!/bin/bash

# lowerupper.sh

# Prints the lowercase version of a char
lowercaseChar(){
    case "$1" in
        [A-Z])
            n=$(printf "%d" "'$1")
            n=$((n+32))
            printf \\$(printf "%o" "$n")
            ;;
        *)
            printf "%s" "$1"
            ;;
    esac
}

# Prints the lowercase version of a sequence of strings
lowercase() {
    word="$@"
    for((i=0;i<${#word};i++)); do
        ch="${word:$i:1}"
        lowercaseChar "$ch"
    done
}

# Prints the uppercase version of a char
uppercaseChar(){
    case "$1" in
        [a-z])
            n=$(printf "%d" "'$1")
            n=$((n-32))
            printf \\$(printf "%o" "$n")
            ;;
        *)
            printf "%s" "$1"
            ;;
    esac
}

# Prints the uppercase version of a sequence of strings
uppercase() {
    word="$@"
    for((i=0;i<${#word};i++)); do
        ch="${word:$i:1}"
        uppercaseChar "$ch"
    done
}

# The functions will not add a new line, so use echo or
# append it if you want a new line after printing

# Printing stuff directly
lowercase "I AM the Walrus!"$'\n'
uppercase "I AM the Walrus!"$'\n'

echo "----------"

# Printing a var
str="A StRing WITH mixed sTUFF!"
lowercase "$str"$'\n'
uppercase "$str"$'\n'

echo "----------"

# Not quoting the var should also work, 
# since we use "$@" inside the functions
lowercase $str$'\n'
uppercase $str$'\n'

echo "----------"

# Assigning to a var
myLowerVar="$(lowercase $str)"
myUpperVar="$(uppercase $str)"
echo "myLowerVar: $myLowerVar"
echo "myUpperVar: $myUpperVar"

echo "----------"

# You can even do stuff like
if [[ 'option 2' = "$(lowercase 'OPTION 2')" ]]; then
    echo "Fine! All the same!"
else
    echo "Ops! Not the same!"
fi

exit 0

A wyniki po uruchomieniu tego:

$ ./lowerupper.sh 
i am the walrus!
I AM THE WALRUS!
----------
a string with mixed stuff!
A STRING WITH MIXED STUFF!
----------
a string with mixed stuff!
A STRING WITH MIXED STUFF!
----------
myLowerVar: a string with mixed stuff!
myUpperVar: A STRING WITH MIXED STUFF!
----------
Fine! All the same!

Powinno to działać tylko dla znaków ASCII .

Dla mnie jest w porządku, ponieważ Wiem, że będę przekazywać do niego tylko znaki ASCII.
Używam tego do niektórych opcji CLI niewrażliwych na wielkość liter, na przykład.

Konwersja wielkości liter odbywa się tylko dla alfabetów. Więc to powinno działać porządnie.

Skupiam się na konwersji alfabetów między a-z Z wielkich liter na małe litery. Wszelkie inne znaki powinny być po prostu wydrukowane w standardzie stdout...

Konwertuje cały tekst w path / to / file / filename w zakresie a-z na A-z

Do konwersji małych liter na wielkie litery

cat path/to/file/filename | tr 'a-z' 'A-Z'

Do konwersji z wielkich liter na małe litery

cat path/to/file/filename | tr 'A-Z' 'a-z'

Dla przykład,

Nazwa pliku:

my name is xyz

Zostaje zamienione na:

MY NAME IS XYZ

Przykład 2:

echo "my name is 123 karthik" | tr 'a-z' 'A-Z'
# Output:
# MY NAME IS 123 KARTHIK

Przykład 3:

echo "my name is 123 &&^&& #@$#@%%& kAR2~thik" | tr 'a-z' 'A-Z'
# Output:
# MY NAME IS 123 &&^&& #@0@%%& KAR2~THIK

Do przechowywania przekształconego ciągu znaków w zmienną. Following worked for me - $SOURCE_NAME do $TARGET_NAME

TARGET_NAME="`echo $SOURCE_NAME | tr '[:upper:]' '[:lower:]'`"

Jest to znacznie szybsza odmiana podejścia JaredTS486 , która wykorzystuje natywne możliwości Bash (w tym wersje Bash

Zmierzyłem 1000 iteracji tego podejścia dla małego ciągu znaków (25 znaków) i większego ciągu znaków (445 znaków), zarówno dla konwersji małych, jak i dużych. Ponieważ ciągi testowe są przeważnie pisane małymi literami, konwersje na małe są na ogół szybsze niż na wielkie litery.

Porównałem swoje podejście z kilkoma innymi odpowiedziami na tej stronie, które są zgodne z Bash 3.2. Moje podejście jest znacznie bardziej wydajne niż większość opisanych tu podejść, a w kilku przypadkach nawet szybsze niż tr.

Oto wyniki czasowe dla 1000 iteracji po 25 znaków:

• 0.46 s dla mojego podejścia do małych liter; 0.96 s dla wielkich liter
• 1.16 s dla orwellophile ' s approach to lowercase; 1.59 s dla uppercase
• 3.67 s dla tr na małe litery; 3.81 s dla wielkie litery
11.12 s dla podejścia ghostdog74 do małych liter; 31.41 s dla wielkich liter
• 26.25 s dla podejście technozaura do małych liter; 26.21 s dla wielkich liter
• 25,06 s dla jaredts486 ' s approach to lowercase; 27,04 s dla uppercase

• 2s dla mojego podejścia do małych liter; 12s dla wielkich liter
• 4s for tr to lowercase; 4s for uppercase
• 20s dla orwellophile ' s approach to lowercase; 29s dla uppercase
• 75S dla ghostdog74 ' s podejście do małych liter; 669s dla wielkich liter. Warto zauważyć, jak dramatyczna jest różnica między testem z dominującymi meczami a testem z dominującymi chybieniami [18]}
• 467s dla podejście technozaura do małych liter; 449s dla wielkich liter
• 660s for JaredTS486 ' s podejście do małych liter; 660s dla wielkich liter. Warto zauważyć, że takie podejście generowało ciągłe błędy stron (Zamiana pamięci) w Bash

Rozwiązanie:

#!/bin/bash
set -e
set -u

declare LCS="abcdefghijklmnopqrstuvwxyz"
declare UCS="ABCDEFGHIJKLMNOPQRSTUVWXYZ"

function lcase()
{
  local TARGET="${1-}"
  local UCHAR=''
  local UOFFSET=''

  while [[ "${TARGET}" =~ ([A-Z]) ]]
  do
    UCHAR="${BASH_REMATCH[1]}"
    UOFFSET="${UCS%%${UCHAR}*}"
    TARGET="${TARGET//${UCHAR}/${LCS:${#UOFFSET}:1}}"
  done

  echo -n "${TARGET}"
}

function ucase()
{
  local TARGET="${1-}"
  local LCHAR=''
  local LOFFSET=''

  while [[ "${TARGET}" =~ ([a-z]) ]]
  do
    LCHAR="${BASH_REMATCH[1]}"
    LOFFSET="${LCS%%${LCHAR}*}"
    TARGET="${TARGET//${LCHAR}/${UCS:${#LOFFSET}:1}}"
  done

  echo -n "${TARGET}"
}

Podejście jest proste: podczas gdy łańcuch wejściowy zawiera Pozostałe wielkie litery, Znajdź następny i zamień wszystkie wystąpienia tej litery na małe litery. Powtarzaj, aż wszystkie wielkie litery zostaną zastąpione.

Niektóre cechy wydajności mojego rozwiązanie:

1. używa tylko narzędzi wbudowanych w powłokę, co pozwala uniknąć kosztów wywołania zewnętrznych narzędzi binarnych w nowym procesie
2. unika sub-powłoki, które ponoszą kary wydajności
3. używa mechanizmów powłoki, które są kompilowane i optymalizowane pod kątem wydajności, takich jak globalne zastępowanie łańcuchów w zmiennych, przycinanie przyrostków zmiennych oraz wyszukiwanie i dopasowywanie regex. Mechanizmy te są znacznie szybsze niż iteracja Manualna za pomocą łańcuchów
4. pętle tylko liczba razy wymagana przez liczbę unikalnych dopasowanych znaków do konwersji. Na przykład konwersja ciągu zawierającego trzy różne wielkie litery na małe wymaga tylko trzech iteracji pętli. Dla wstępnie skonfigurowanego alfabetu ASCII, Maksymalna liczba iteracji pętli wynosi 26
5. UCS i LCS mogą być rozszerzone o Dodatkowe znaki