Как преобразовать строку в нижний регистр в Bash?

Ответы:

2183

Существуют различные способы:

Стандарт POSIX

тр

$ echo "$a" | tr '[:upper:]' '[:lower:]'
hi all

AWK

$ echo "$a" | awk '{print tolower($0)}'
hi all

Non-POSIX

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

Баш 4.0

$ echo "${a,,}"
hi all

СЭД

$ echo "$a" | sed -e 's/\(.*\)/\L\1/'
hi all
# this also works:
$ sed -e 's/\(.*\)/\L\1/' <<< "$a"
hi all

Perl

$ echo "$a" | perl -ne 'print lc'
hi all

удар

lc(){
    case "$1" in
        [A-Z])
        n=$(printf "%d" "'$1")
        n=$((n+32))
        printf \\$(printf "%o" "$n")
        ;;
        *)
        printf "%s" "$1"
        ;;
    esac
}
word="I Love Bash"
for((i=0;i<${#word};i++))
do
    ch="${word:$i:1}"
    lc "$ch"
done

Примечание: YMMV на этом. У меня не работает (GNU bash версии 4.2.46 и 4.0.33 (и такое же поведение 2.05b.0, но nocasematch не реализовано)) даже с использованием shopt -u nocasematch;. Отключение этого nocasematch приводит к тому, что [["fooBaR" == "FOObar"]] совпадает с ОК, но внутри случая странным образом [bz] неправильно сопоставляется [AZ]. Bash сбит с толку двойным негативом («unsetting nocasematch»)! :-)

ghostdog74
источник
9
Я что-то упустил, или ваш последний пример (в Bash) действительно делает что-то совершенно другое? Это работает для "ABX", но если вы вместо этого сделаете word="Hi All"как другие примеры, он вернется ha, а не hi all. Он работает только для заглавных букв и пропускает буквы в нижнем регистре.
Янгостеве
26
Обратите внимание , что только trи awkпримеры указаны в стандарте POSIX.
Ричард Хансен
178
tr '[:upper:]' '[:lower:]'будет использовать текущую локаль для определения эквивалентов в верхнем и нижнем регистре, поэтому она будет работать с локалями, которые используют буквы с диакритическими знаками.
Ричард Хансен
10
Как получить выход в новую переменную? То есть, я хочу, чтобы строка в нижнем регистре была новой переменной?
Адам Паркин
60
@Adam:b="$(echo $a | tr '[A-Z]' '[a-z]')"
Тино
435

В Bash 4:

В нижний регистр

$ 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

В верхний регистр

$ 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

Переключить (не документировано, но возможно настраивается во время компиляции)

$ 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

Использование заглавных букв (недокументированное, но при желании настраивается во время компиляции)

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

Название дела:

$ 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

Чтобы отключить declareатрибут, используйте +. Например, declare +c string. Это влияет на последующие назначения, а не на текущее значение.

В declareопции изменить атрибут переменной, но не содержимое. Переназначения в моих примерах обновляют содержимое, чтобы показать изменения.

Редактировать:

Добавлен «переключать первый символ по слову» ( ${var~}), как предложено ghostdog74 .

Редактировать: Исправлено поведение тильды в соответствии с Bash 4.3.

Приостановлено до дальнейшего уведомления.
источник
5
Довольно странно, операторы «^^» и «,,» не работают с не-ASCII символами, а «~~» работает ... Так string="łódź"; echo ${string~~}что вернет «ŁÓDŹ», но echo ${string^^}вернет «łóDź». Даже в LC_ALL=pl_PL.utf-8. Это использует Bash 4.2.24.
Хьюберт Карио
2
@HubertKario: это странно. То же самое для меня в Bash 4.0.33 с той же строкой в en_US.UTF-8. Это ошибка, и я сообщил об этом.
Приостановлено до дальнейшего уведомления.
1
@HubertKario: попробуй echo "$string" | tr '[:lower:]' '[:upper:]'. Это, вероятно, будет демонстрировать ту же ошибку. Так что проблема, по крайней мере, частично не в Баше.
Приостановлено до дальнейшего уведомления.
1
@DennisWilliamson: Да, я тоже это заметил (см. Комментарий к ответу Шувалова). Я бы просто сказал: «Этот материал предназначен только для ASCII», но тогда работает оператор «~~», поэтому он не похож на код и таблицы перевода, которых там еще нет ...
Юбер Карио
4
@HubertKario: сопровождающий Bash подтвердил ошибку и заявил, что она будет исправлена ​​в следующем выпуске.
Приостановлено до дальнейшего уведомления.
123
echo "Hi All" | tr "[:upper:]" "[:lower:]"
шувалов
источник
4
@RichardHansen: trу меня не работает персонажи не-ACII. У меня есть правильный набор локали и сгенерированные файлы локали. Есть идеи, что я могу делать не так?
Хьюберт Карио
К вашему сведению: это работало на Windows / Msys. Некоторые другие предложения не сделали.
wasatchwizard
3
Зачем [:upper:]нужен?
mgutt
77

tr :

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

AWK :

{ print tolower($0) }

sed :

y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/
Игнасио Васкес-Абрамс
источник
2
+1 a="$(tr [A-Z] [a-z] <<< "$a")"выглядит проще всего для меня. Я все еще новичок ...
Сандипан Нат
2
Я настоятельно рекомендую sedрешение; Я работал в среде, которая по какой-то причине отсутствует, trно я еще не нашел систему без нее sed, плюс большую часть времени я хочу сделать это, я просто сделал что-то еще в sedлюбом случае, так что можно связать команды объединяются в одно (длинное) утверждение.
Харавикк
2
Скобочные выражения должны быть в кавычках. В tr [A-Z] [a-z] A, оболочка может выполнять расширение имени файла, если есть имена файлов, состоящие из одной буквы или установлен нуль-гоб . tr "[A-Z]" "[a-z]" Aбудет вести себя правильно.
Деннис
2
@CamiloMartin - это система BusyBox, где у меня возникла эта проблема, в частности, NAS-устройства Synology, но я столкнулся с ней и в некоторых других системах. В последнее время я делал много межплатформенных сценариев оболочки, и с требованием, чтобы ничего лишнего не устанавливалось, это усложняет задачу! Однако мне еще не приходилось сталкиваться с системой безsed
Харавикк
2
Обратите внимание, что tr [A-Z] [a-z]это неправильно почти во всех локалях. например, в en-USлокали A-Zфактически указан интервал AaBbCcDdEeFfGgHh...XxYyZ.
fuz
44

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

UPPER -> Lower : использовать Python:

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

Или рубин

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

Или Perl (наверное, мой любимый):

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

Или PHP:

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

Или Awk:

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

Или сед:

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

Или Баш 4:

b=${a,,}

Или NodeJS, если он у вас есть (и немного чокнутый ...):

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

Вы также можете использовать dd (но я бы не стал!):

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

понизить -> ВЕРХНЯЯ :

использовать питон:

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

Или рубин

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

Или Perl (наверное, мой любимый):

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

Или PHP:

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

Или Awk:

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

Или сед:

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

Или Баш 4:

b=${a^^}

Или NodeJS, если он у вас есть (и немного чокнутый ...):

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

Вы также можете использоватьdd (но я бы не стал!):

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

Также, когда вы говорите «оболочка», я предполагаю, что вы имеете в виду, bashно если вы можете использовать zshэто так же просто, как

b=$a:l

для нижнего регистра и

b=$a:u

для верхнего регистра.

nettux
источник
@JESii оба работают для меня верхний -> нижний и нижний -> верхний. Я использую sed 4.2.2 и Bash 4.3.42 (1) на 64-битной Debian Stretch.
nettux
1
Привет, @ nettux443 ... Я только что снова попытался выполнить операцию bash, и она все равно не работает с сообщением об ошибке "плохая замена". Я на OSX использую bash Homebrew: GNU bash, версия 4.3.42 (1) -релиз (x86_64-apple-darwin14.5.0)
JESii
5
Не используйте! Все примеры, которые генерируют сценарий, являются чрезвычайно хрупкими; если значение aсодержит одинарную кавычку, у вас есть не только нарушенное поведение, но и серьезная проблема безопасности.
tripleee
Мне больше всего нравится решение sed, так как sed всегда вездесущ.
Dudi Boy
Я предпочитаю использовать решение дд. Обратите внимание, что вам нужно быть пользователем root, чтобы это
заработало
29

В зш:

echo $a:u

Должен любить Zsh!

Скотт Смедли
источник
4
или $ a: l для преобразования в нижний регистр
Скотт Смедли
1
Добавьте еще один случай:echo ${(C)a} #Upcase the first char only
biocyberman
18

Используя GNU sed:

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

Пример:

$ foo="Some STRIng";
$ foo=$(echo "$foo" | sed 's/.*/\L&/')
$ echo "$foo"
some string
devnull
источник
12

Pre Bash 4.0

Bash Нижний регистр строки и присвоение переменной

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

echo "$VARIABLE"
hawkeye126
источник
5
Не нужно echoи труб: использовать$(tr '[:upper:]' '[:lower:]' <<<"$VARIABLE")
Тино
3
@Tino Строка here также не переносима на действительно старые версии Bash; Я считаю, что это было введено в v3.
tripleee
1
@tripleee Вы правы, он был представлен в bash-2.05b - однако это самый старый bash, который я смог найти в своих системах
Tino
11

Для стандартной оболочки (без ошибок) используются только встроенные функции:

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

И для верхнего регистра:

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}"
}
technosaurus
источник
Интересно, не допустили ли вы некоторого башизма в этом сценарии, поскольку он не переносим во FreeBSD sh: $ {1: $ ...}: плохая замена
Дерексон,
2
Верно; подстроки с ${var:1:1}являются Bashism.
tripleee
Этот подход имеет довольно плохие показатели производительности. Смотрите мой ответ для метрик.
Деджей Клейтон,
9

В bash 4 вы можете использовать typeset

Пример:

A="HELLO WORLD"
typeset -l A=$A
c4f4t0r
источник
7

Регулярное выражение

Я хотел бы взять кредит на команду, которой хочу поделиться, но правда в том, что я получил ее для собственного использования на http://commandlinefu.com . Преимущество заключается в том, что если вы cdперейдете в какой-либо каталог в своей собственной домашней папке, то есть рекурсивно измените все файлы и папки на строчные, пожалуйста, используйте их с осторожностью. Это великолепное исправление командной строки, особенно полезное для множества альбомов, которые вы сохранили на своем диске.

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

Вы можете указать каталог вместо точки (.) После поиска, которая обозначает текущий каталог или полный путь.

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

Дерек Шоу
источник
Это не сработало для меня по любой причине, хотя выглядит хорошо. Я сделал это работать в качестве альтернативы: найти. -exec / bin / bash -c 'mv {} `tr [AZ] [az] <<< {}`' \;
Джон Рикс,
Это нужно prenameот perl: dpkg -S "$(readlink -e /usr/bin/rename)"даетperl: /usr/bin/prename
Тино
4

Многие ответы используют внешние программы, которые на самом деле не используются Bash.

Если вы знаете, что у вас будет Bash4, вы должны просто использовать ${VAR,,}нотацию (это легко и круто). Для Bash до 4 (Мой Mac все еще использует Bash 3.2, например). Я использовал исправленную версию ответа @ ghostdog74, чтобы создать более переносимую версию.

Один вы можете позвонить lowercase 'my STRING'и получить строчную версию. Я читал комментарии об установке результата в переменную, но он не очень переносим Bash, поскольку мы не можем возвращать строки. Печать это лучшее решение. Легко захватить с чем-то вроде var="$(lowercase $str)".

Как это работает

Это работает путем получения целочисленного представления ASCII каждого символа с printfи затем adding 32if upper-to->lowerили subtracting 32if lower-to->upper. Затем используйте printfснова, чтобы преобразовать число обратно в символ. От 'A' -to-> 'a'нас есть разница в 32 символа.

Используя, printfчтобы объяснить:

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

97 - 65 = 32

И это рабочая версия с примерами.
Обратите внимание на комментарии в коде, так как они объясняют много вещей:

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

И результаты после запуска этого:

$ ./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!

Это должно работать только для символов ASCII .

Для меня это хорошо, так как я знаю, что передам только символы ASCII.
Я использую это для некоторых вариантов CLI без учета регистра, например.

Гас Невес
источник
4

Конвертирование происходит только для алфавитов. Итак, это должно работать аккуратно.

Я сосредотачиваюсь на преобразовании алфавитов между az из верхнего регистра в нижний регистр. Любые другие символы должны быть просто напечатаны в стандартный вывод ...

Преобразует весь текст в пути / в / файл / имя файла в диапазоне от А до А

Для преобразования нижнего регистра в верхний

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

Для преобразования из верхнего регистра в нижний регистр

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

Например,

имя файла:

my name is xyz

превращается в:

MY NAME IS XYZ

Пример 2:

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

Пример 3:

echo "my name is 123 &&^&& #@$#@%%& kAR2~thik" | tr 'a-z' 'A-Z'
# Output:
# MY NAME IS 123 &&^&& #@0@%%& KAR2~THIK
theBuzzyCoder
источник
3

При использовании v4 это запечено . Если нет, то вот простое, широко применимое решение. Другие ответы (и комментарии) на эту тему были весьма полезны при создании кода ниже.

# 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:] )\'
}

Ноты:

  • Выполнение: a="Hi All"и затем: lcase aсделает то же самое, что и:a=$( echolcase "Hi All" )
  • В функции lcase использование ${!1//\'/"'\''"}вместо ${!1}позволяет этому работать, даже если строка содержит кавычки.
Стивен М. Харрис
источник
3

Для версий Bash более ранних, чем 4.0, эта версия должна быть самой быстрой (так как она не выполняет команды fork / exec ):

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

Ответ технозавра тоже имел потенциал, хотя для меня он действовал правильно.

Orwellophile
источник
Неплохо! Для анализа эффективности этого подхода, пожалуйста, смотрите мой ответ для метрик.
Деджей Клейтон,
3

Несмотря на то, сколько лет этот вопрос и похож на этот ответ технозавра . Мне было трудно найти решение, которое было бы переносимым на большинство платформ (которые я использую), а также на старые версии bash. Я также был разочарован массивами, функциями и использованием распечаток, эхо и временных файлов для получения тривиальных переменных. Это работает очень хорошо для меня, пока я думал, что поделюсь. Мои основные тестовые среды:

  1. GNU bash, версия 4.1.2 (1) -релиз (x86_64-redhat-linux-gnu)
  2. GNU bash, версия 3.2.57 (1) -релиз (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

Простой C-стиль для цикла, чтобы перебрать строки. Для строки ниже, если вы не видели ничего подобного до этого, я узнал об этом . В этом случае строка проверяет, существует ли на входе символ $ {input: $ i: 1} (нижний регистр) и, если это так, заменяет его на заданный символ $ {ucs: $ j: 1} (верхний регистр) и сохраняет его вернуться на вход.

input="${input/${input:$i:1}/${ucs:$j:1}}"
JaredTS486
источник
Это крайне неэффективно, в вашем примере выше 650 циклов и 35 секунд для выполнения 1000 вызовов на моем компьютере. Для альтернативы, которая повторяется всего 11 раз и занимает менее 5 секунд для выполнения 1000 вызовов, см. Мой альтернативный ответ.
Деджей Клэйтон
1
Спасибо, хотя это должно быть очевидно, просто глядя на это. Возможно, ошибки страницы связаны с размером ввода и количеством выполняемых итераций. Тем не менее мне нравится ваше решение.
JaredTS486
3

Это гораздо более быстрый вариант подхода JaredTS486, который использует собственные возможности Bash (включая версии Bash <4.0) для оптимизации его подхода.

Я рассчитал 1000 итераций этого подхода для маленькой строки (25 символов) и большей строки (445 символов) как для преобразования в нижний, так и в верхний регистр. Поскольку тестовые строки преимущественно строчные, преобразования в нижний регистр обычно выполняются быстрее, чем в верхний.

Я сравнил свой подход с несколькими другими ответами на этой странице, которые совместимы с Bash 3.2. Мой подход гораздо более эффективен, чем большинство описанных здесь подходов, и даже быстрее, чем trв нескольких случаях.

Вот временные результаты для 1000 итераций по 25 символов:

  • 0,46 с для моего подхода к нижнему регистру; 0,96 с в верхнем регистре
  • 1.16с для подхода Орвеллофила в нижнем регистре; 1,59 с заглавными буквами
  • 3,67 для trстрочных букв ; 3,81 с заглавными буквами
  • 11.12s для подхода ghostdog74 в нижнем регистре; 31,41 для верхнего регистра
  • 26,25 с для подхода технозавра в нижнем регистре; 26.21 с заглавными буквами
  • 25.06 для подхода JaredTS486 к строчным буквам; 27.04 с заглавными буквами

Результаты синхронизации для 1000 итераций по 445 символов (состоящих из поэмы "Робин" Уиттера Биннера):

  • 2 для моего подхода к строчным буквам; 12с прописными буквами
  • 4S для trстрочных букв; 4с прописными буквами
  • 20-е годы для подхода Орвеллофила в нижнем регистре; 29 с заглавными буквами
  • 75 для подхода ghostdog74 в нижнем регистре; 669 для прописных. Интересно отметить, насколько значительна разница в производительности между тестом с преобладающими совпадениями и тестом с преобладающими промахами
  • 467-е для подхода технозавра к строчным буквам; 449 для прописных
  • 660s для подхода JaredTS486 к нижнему регистру ; 660 для прописных. Интересно отметить, что этот подход генерировал непрерывные сбои страниц (перестановка памяти) в Bash

Решение:

#!/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}"
}

Подход прост: хотя во входной строке есть все оставшиеся заглавные буквы, найдите следующую и замените все вхождения этой буквы ее строчным вариантом. Повторяйте, пока все заглавные буквы не будут заменены.

Некоторые характеристики производительности моего решения:

  1. Используются только встроенные утилиты оболочки, что позволяет избежать накладных расходов на вызов внешних двоичных утилит в новом процессе.
  2. Избегает вложенных оболочек, которые влекут за собой потери производительности
  3. Используются механизмы оболочки, скомпилированные и оптимизированные для производительности, такие как глобальная замена строк внутри переменных, обрезание суффиксов переменных, поиск и сопоставление регулярных выражений. Эти механизмы работают намного быстрее, чем перебирать строки вручную
  4. Зацикливает только то количество раз, которое требуется для преобразования количества уникальных совпадающих символов. Например, преобразование строки, содержащей три разных заглавных символа в строчные, требует всего 3 итерации цикла. Для предварительно сконфигурированного алфавита ASCII максимальное количество итераций цикла составляет 26
  5. UCSи LCSможет быть дополнен дополнительными символами
Дежай Клэйтон
источник
2

Хранить преобразованную строку в переменную. Следующее сработало у меня - $SOURCE_NAMEдо$TARGET_NAME

TARGET_NAME="`echo $SOURCE_NAME | tr '[:upper:]' '[:lower:]'`"
nitinr708
источник
1

Простой способ

echo "Hi all" | awk '{ print tolower($0); }'
Atul23
источник