බාෂ් හි නූලක් කුඩා අකුරක් බවට පරිවර්තනය කරන්නේ කෙසේද?

ඇතුළට ක්‍රමයක් තියෙනවද? bash නූලක් කුඩා අකුරු බවට පරිවර්තනය කිරීමට?

උදාහරණයක් ලෙස, මට තිබේ නම්:

a="Hi all"

මට එය පරිවර්තනය කිරීමට අවශ්‍යයි:

"hi all"

විවිධ ක්‍රම:

POSIX ප්‍රමිතිය

tr

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

AWK

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

POSIX නොවන

ඔබට පහත උදාහරණ සමඟ අතේ ගෙන යා හැකි ගැටළු වලට මුහුණ දිය හැකිය:

බෑෂ් 4.0

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

sed

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

පර්ල්

$ 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] විසින් වැරදියට ගැලපේ. ද්විත්ව negative ණ ("සැකසීමේ නොකාස්මැච්") මගින් බාෂ් ව්‍යාකූල වේ! :-)

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විකල්ප එකේම ආරෝපණය, නමුත් අන්තර්ගතය වෙනස් කරන්න. මගේ උදාහරණවල නැවත පැවරීම් වෙනස්කම් පෙන්වීමට අන්තර්ගතය යාවත්කාලීන කරයි.

සංස්කරණය කරන්න:

Ghostdog74${var~} විසින් යෝජනා කර ඇති පරිදි "පළමු අක්‍ෂරය වචනයෙන් ටොගල් කරන්න" ( ) එකතු කරන ලදි .

සංස්කරණය කරන්න: බාෂ් 4.3 ට ගැලපෙන පරිදි නිවැරදි ටිල්ඩ් හැසිරීම.

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

tr :

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

AWK :

{ print tolower($0) }

sed :

y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/

මෙය පැරණි පෝස්ට් එකක් බව මම දනිමි, නමුත් මම මෙම පිළිතුර වෙනත් වෙබ් අඩවියකට ඉදිරිපත් කළෙමි, එබැවින් මම එය මෙහි පළ කිරීමට සිතුවෙමි:

UPPER -> පහළ : පයිතන් භාවිතා කරන්න:

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

හෝ රූබි:

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

හෝ පර්ල් (බොහෝ විට මගේ ප්‍රියතම):

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

හෝ PHP:

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

හෝ අවුල්:

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

හෝ සෙඩ්:

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

හෝ Bash 4:

b=${a,,}

හෝ ඔබට එය තිබේ නම් NodeJS (සහ ටිකක් ගෙඩි වේ ...):

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

ඔබට ද භාවිතා කළ හැකිය dd(නමුත් මම එසේ නොකරමි!):

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

පහළ -> UPPER :

පයිතන් භාවිතා කරන්න:

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

හෝ රූබි:

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

හෝ පර්ල් (බොහෝ විට මගේ ප්‍රියතම):

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

හෝ PHP:

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

හෝ අවුල්:

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

හෝ සෙඩ්:

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

හෝ Bash 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

ඉහළ නඩුව සඳහා.

Zsh හි:

echo $a:u

Zsh ආදරෙයි!

GNU භාවිතා කිරීම sed:

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

උදාහරණයක්:

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

පෙර බෑෂ් 4.0

Bash නූලක නඩුව අඩු කර විචල්‍යයට පවරන්න

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

echo "$VARIABLE"

බිල්ඩින් පමණක් භාවිතා කරමින් සම්මත කවචයක් සඳහා (බාෂිස්ම් නොමැතිව):

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

Bash 4 හි ඔබට යතුරු ලියනය භාවිතා කළ හැකිය

උදාහරණයක්:

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

ඔබට මෙය උත්සාහ කළ හැකිය

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/

සාමාන්ය ලෙස

මම බෙදා ගැනීමට බලාපොරොත්තු වන විධානය සඳහා ගෞරවය ලබා ගැනීමට මම කැමැත්තෙමි, නමුත් සත්‍යය එය මාගේ ප්‍රයෝජනය සඳහා http://commandlinefu.com වෙතින් ලබාගෙන ඇත. cdඔබේ නිවසේ ෆෝල්ඩරය තුළ ඇති ඕනෑම නාමාවලියකට ඔබ ගියහොත් එය සියලු ලිපිගොනු සහ ෆෝල්ඩර කුඩා අකුරුවලට වෙනස් කරයි. කරුණාකර ප්‍රවේශමෙන් භාවිතා කරන්න. එය දීප්තිමත් විධාන රේඛා විසඳුමක් වන අතර ඔබ ඔබේ ධාවකයේ ගබඩා කර ඇති ඇල්බම රාශියකට විශේෂයෙන් ප්‍රයෝජනවත් වේ.

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

වත්මන් නාමාවලිය හෝ සම්පූර්ණ මාර්ගය දැක්වෙන සොයාගැනීමෙන් පසුව ඔබට තිත (.) වෙනුවට නාමාවලියක් නියම කළ හැකිය.

මෙම විසඳුම ප්‍රයෝජනවත් බව ඔප්පු වනු ඇතැයි මම විශ්වාස කරමි, මෙම විධානය මඟින් සිදු නොකරන එක් දෙයක් අවකාශය අවතක්සේරු කිරීම වෙනුවට ආදේශ කිරීමකි.

බාහිර වැඩසටහන් භාවිතා කරමින් බොහෝ පිළිතුරු, එය ඇත්ත වශයෙන්ම භාවිතා නොකරයි Bash.

ඔබට Bash4 ලබා ගත හැකි බව ඔබ දන්නේ නම්, ඔබ සැබවින්ම ${VAR,,}අංකනය භාවිතා කළ යුතුය (එය පහසු සහ සිසිල් ය). 4 ට පෙර Bash සඳහා (උදාහරණයක් ලෙස මගේ මැක් තවමත් Bash 3.2 භාවිතා කරයි). වඩා අතේ ගෙන යා හැකි අනුවාදයක් නිර්මාණය කිරීම සඳහා මම නිවැරදි කරන ලද @ ghostdog74 පිළිතුර භාවිතා කළෙමි.

ඔබට ඇමතුමක් lowercase 'my STRING'ලබා දී කුඩා අකුරු ලබා ගත හැකිය . ප්‍රති result ලය var ට සැකසීම ගැන මම අදහස් කියෙව්වා, නමුත් එය ඇත්ත වශයෙන්ම අතේ ගෙන යා නොහැකි Bashනිසා අපට නූල් ආපසු ලබා දිය නොහැක. එය මුද්‍රණය කිරීම හොඳම විසඳුමයි. වැනි දෙයක් සමඟ අල්ලා ගැනීම පහසුය var="$(lowercase $str)".

මෙය ක්‍රියාත්මක වන ආකාරය

මෙය ක්‍රියාත්මක වන ආකාරය වන්නේ එක් එක් වර්‍ගයේ ASCII නිඛිල නිරූපණය ලබාගෙන printfපසුව adding 32නම් upper-to->lowerහෝ subtracting 32තිබේ නම් lower-to->upper. printfඅංකය නැවත වර්‍ගයක් බවට පරිවර්තනය කිරීමට නැවත භාවිතා කරන්න . සිට 'A' -to-> 'a'අප chars 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

මෙය ක්‍රියාත්මක කිරීමෙන් පසු ප්‍රති results ල:

$ ./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 විකල්ප සඳහා ය.

පරිවර්තන නඩුව සිදු කරනු ලබන්නේ හෝඩිය සඳහා පමණි. එබැවින් මෙය පිළිවෙලට ක්‍රියාත්මක විය යුතුය.

මම අවධානය යොමු කරන්නේ අක්ෂර අතර අක්ෂර අක්ෂර ඉහළ අකුරේ සිට කුඩා අකුරට පරිවර්තනය කිරීම සඳහා ය. වෙනත් ඕනෑම අක්ෂරයක් stdout හි මුද්‍රණය කළ යුතුය.

Az පරාසය තුළ ඇති සියලුම පා / යන් / ගොනුව / ගොනු නාමය 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

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" )
• ලේස් ශ්‍රිතයේ දී, ${!1//\'/"'\''"}ඒ වෙනුවට භාවිතා කිරීමෙන් ${!1}නූල් උපුටා දැක්වීම් ඇති විට පවා මෙය ක්‍රියාත්මක වේ.

4.0 ට පෙර Bash අනුවාද සඳහා, මෙම අනුවාදය වේගවත් විය යුතුය (එය කිසිදු විධානයක් දෙබලක / ක්‍රියාත්මක නොකරන බැවින් ):

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

ටෙක්නෝසෝරස්ගේ පිළිතුරට ද විභවයක් ඇත, එය මට නිසි ලෙස ක්‍රියාත්මක වුවද.

මෙම ප්‍රශ්නය කොතරම් පැරණි වුවත්, ටෙක්නෝසෝරස්ගේ මෙම පිළිතුරට සමාන ය . බොහෝ වේදිකා හරහා (මම භාවිතා කරන) මෙන්ම පැරණි අනුවාදයන් හරහා ගෙන යා හැකි විසඳුමක් සොයා ගැනීමට මට අපහසු විය. සුළු විචල්‍යයන් ලබා ගැනීම සඳහා අරා, කාර්යයන් සහ මුද්‍රණ, දෝංකාරය සහ තාවකාලික ලිපිගොනු භාවිතා කිරීම පිළිබඳව ද මම කලකිරීමට පත්ව සිටිමි. මෙය මට ඉතා හොඳින් ක්‍රියාත්මක වන අතර මෙතෙක් මා සිතුවේ මම බෙදා ගනීවි කියාය. මගේ ප්‍රධාන පරීක්ෂණ පරිසරයන්:

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

නූල් හරහා නැවත ගමන් කිරීම සඳහා ලූප සඳහා සරල සී-විලාසිතාව . පහත පේළිය සඳහා ඔබ මීට පෙර මෙවැනි දෙයක් දැක නොමැති නම් මම මෙය ඉගෙන ගත් ස්ථානයයි . මෙම අවස්ථාවෙහිදී පේළිය {{ආදානය: $ i: 1} (කුඩා අකුර) ආදානයේ තිබේදැයි පරික්ෂා කරයි. නැවත ආදානයට.

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

මෙය ජරෙඩ් ටීඑස් 486 හි ප්‍රවේශයේ වඩා වේගවත් විචලනයකි, එය ඔහුගේ ප්‍රවේශය ප්‍රශස්ත කිරීම සඳහා ස්වදේශීය බාෂ් හැකියාවන් (බෑෂ් අනුවාද <4.0 ද ඇතුළුව) භාවිතා කරයි.

කුඩා අකුරු (අකුරු 25) සහ විශාල නූලක් (අක්ෂර 445) සඳහා කුඩා හා ලොකු අකුරු පරිවර්තනය සඳහා මම මෙම ප්‍රවේශයේ පුනරාවර්තන 1,000 ක් කාලය ගත කර ඇත්තෙමි. පරීක්ෂණ නූල් ප්‍රධාන වශයෙන් කුඩා අකුරු බැවින් කුඩා අකුරුවලට පරිවර්තනය සාමාන්‍යයෙන් ලොකු අකුරට වඩා වේගවත් වේ.

මම මගේ ප්‍රවේශය මෙම පිටුවේ ඇති තවත් පිළිතුරු කිහිපයක් සමඟ සංසන්දනය කර ඇති අතර එය Bash 3.2 සමඟ අනුකූල වේ. මගේ ප්‍රවේශය මෙහි ලේඛනගත කර ඇති බොහෝ ප්‍රවේශයන්ට වඩා බෙහෙවින් ක්‍රියාකාරී වන අතර එය trඅවස්ථා කිහිපයකට වඩා වේගවත් ය .

අක්ෂර 25 ක පුනරාවර්තන 1,000 ක් සඳහා කාල ප්‍රති results ල මෙන්න:

• සිම්පල් සඳහා මගේ ප්‍රවේශය සඳහා 0.46s; ලොකු අකුරු සඳහා 0.96s
• සිම්පල් සඳහා ඕවල්ලොෆිල්ගේ ප්‍රවේශය සඳහා 1.16s ; ලොකු අකුරු සඳහා 1.59s
• trසිම්පල් කිරීමට 3.67s ; ලොකු අකුරු සඳහා 3.81s
• සිම්පල් සඳහා හොස්ට්ඩෝග් 74 හි ප්‍රවේශය සඳහා 11.12s ; ලොකු අකුරු සඳහා 31.41s
• සිම්පල් සඳහා ටෙක්නෝසෝරස් ප්‍රවේශය සඳහා 26.25s ; ලොකු අකුරු සඳහා 26.21s
• සිම්පල් සඳහා ජරෙඩ්ටීඑස් 486 හි ප්‍රවේශය සඳහා 25.06s ; ලොකු අකුර සඳහා 27.04s

අක්ෂර 445 ක පුනරාවර්තන 1,000 ක් සඳහා කාල ප්‍රති results ල (විටර් බිනර් විසින් රචිත "ද රොබින්" කාව්‍යයෙන් සමන්විත වේ):

• සිම්පල් සඳහා මගේ ප්‍රවේශය සඳහා 2s; ලොකු අකුරු සඳහා 12s
• trසිම්පල් කිරීමට 4s ; ලොකු අකුරු සඳහා 4s
• සිම්පල් සඳහා ඕවල්ලොෆිල්ගේ ප්‍රවේශය සඳහා 20s ; ලොකු අකුරු සඳහා 29s
• සිම්පල් සඳහා හොස්ට්ඩෝග් 74 හි ප්‍රවේශය සඳහා 75s ; ලොකු අකුරු සඳහා 669s. ප්‍රධාන තරඟ සමඟ එදිරිව එදිරිව එදිරිව
• කුඩා අකුරු සඳහා ටෙක්නෝසෝරස්ගේ ප්‍රවේශය සඳහා 467s ; ලොකු අකුර සඳහා 449s
• සිම්පල් සඳහා ජරෙඩ්ටීඑස් 486 හි ප්‍රවේශය සඳහා 660s ; ලොකු අකුරු සඳහා 660s. මෙම ප්‍රවේශය 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අමතර අක්ෂර සමඟ වැඩි කළ හැකිය

පරිවර්තනය කරන ලද නූල විචල්යයක් ලෙස ගබඩා කිරීම. පහත දැක්වෙන්නේ මා වෙනුවෙන් වැඩ $SOURCE_NAMEකිරීමයි$TARGET_NAME

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

සරල ක්‍රමය

echo "Hi all" | awk '{ print tolower($0); }'