string - बाश में स्ट्रिंग को कम मामले में कनवर्ट करना




bash shell (12)

नियमित अभिव्यक्ति

मैं उस आदेश के लिए क्रेडिट लेना चाहता हूं जिसे मैं साझा करना चाहता हूं लेकिन सच्चाई यह है कि मैंने इसे अपने इस्तेमाल के लिए http://commandlinefu.com से प्राप्त किया है। इसका लाभ यह है कि यदि आप अपने घर के भीतर किसी भी निर्देशिका में cd करते हैं, तो यह सभी फाइलों और फ़ोल्डर्स को कम मामले में बदल देगा, कृपया सावधानी के साथ उपयोग करें। यह एक शानदार कमांड लाइन फिक्स है और विशेष रूप से आपके ड्राइव पर संग्रहीत एल्बमों के उन लोगों के लिए उपयोगी है।

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

आप वर्तमान निर्देशिका या पूर्ण पथ को इंगित करने वाले खोज के बाद डॉट (।) के स्थान पर एक निर्देशिका निर्दिष्ट कर सकते हैं।

मुझे उम्मीद है कि यह समाधान एक चीज को उपयोगी साबित करता है जो यह आदेश नहीं करता है, अंडरस्कोर के साथ रिक्त स्थान को प्रतिस्थापित करता है - ओह ठीक है।

स्ट्रिंग को कम केस स्ट्रिंग में बदलने के लिए bash में कोई तरीका है?

उदाहरण के लिए, यदि मेरे पास है:

a="Hi all"

मैं इसे यहां परिवर्तित करना चाहता हूं:

"hi all"

tr :

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

AWK :

{ print tolower($0) }

sed :

y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/

Zsh में:

echo $a:u

प्यार zsh होगा!



कनवर्टिंग केस केवल अक्षर के लिए किया जाता है। तो, यह अच्छी तरह से काम करना चाहिए।

मैं ऊपरी मामले से निचले मामले में एजे के बीच अक्षरों को परिवर्तित करने पर ध्यान केंद्रित कर रहा हूं। किसी भी अन्य पात्रों को सिर्फ stdout में मुद्रित किया जाना चाहिए क्योंकि यह है ...

एज़ से लेकर एज़ तक के सभी पथ को पथ / से / फ़ाइल / फ़ाइल नाम में कनवर्ट करता है

निचले मामले को ऊपरी मामले में परिवर्तित करने के लिए

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 &&^&& #@[email protected]%%& KAR2~THIK

केवल बिल्टिन का उपयोग करके मानक खोल (बैशिस के बिना) के लिए:

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

प्री बैश 4.0

बैश एक स्ट्रिंग के मामले को कम करें और चर को असाइन करें

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

echo "$VARIABLE"

बाहरी कार्यक्रमों का उपयोग करने वाले कई उत्तर, जो वास्तव में Bash का उपयोग नहीं कर रहे हैं।

यदि आप जानते हैं कि आपके पास Bash4 उपलब्ध होगा तो आपको वास्तव में केवल ${VAR,,} नोटेशन का उपयोग करना चाहिए (यह आसान और ठंडा है)। 4 से पहले बैश के लिए (मेरा मैक अभी भी उदाहरण के लिए बैश 3.2 का उपयोग करता है)। मैंने अधिक पोर्टेबल संस्करण बनाने के लिए @ ghostdog74 के उत्तर के सही संस्करण का उपयोग किया।

एक आप lowercase 'my STRING' कह सकते हैं और लोअरकेस संस्करण प्राप्त कर सकते हैं। मैंने परिणाम को एक var में सेट करने के बारे में टिप्पणियां पढ़ी हैं, लेकिन यह वास्तव में Bash में पोर्टेबल नहीं है, क्योंकि हम तारों को वापस नहीं कर सकते हैं। इसे प्रिंट करना सबसे अच्छा समाधान है। var="$(lowercase $str)" जैसे कुछ के साथ कैप्चर करना आसान है।

यह कैसे काम करता है

जिस तरह से यह काम करता है वह प्रिंटर के साथ प्रत्येक चार के ASCII पूर्णांक प्रतिनिधित्व प्राप्त कर रहा है और फिर upper-to->lower adding 32 , या lower-to->upper subtracting 32 । फिर संख्या को वापस चार में बदलने के लिए 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="[email protected]"
    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="[email protected]"
    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 "[email protected]" 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 वर्णों के लिए काम करना चाहिए

मेरे लिए यह ठीक है, क्योंकि मुझे पता है कि मैं केवल एएससीआईआईआई अक्षरों को पास कर दूंगा।
उदाहरण के लिए, मैं कुछ केस-असंवेदनशील सीएलआई विकल्पों के लिए इसका उपयोग कर रहा हूं।


बैश 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"

declare विशेषता को बंद करने के लिए, + उपयोग करें। उदाहरण के लिए, declare +c string । यह बाद के असाइनमेंट को प्रभावित करता है और वर्तमान मूल्य नहीं।

declare विकल्प चर के गुण को बदलते हैं, लेकिन सामग्री नहीं। मेरे उदाहरणों में पुन: असाइनमेंट परिवर्तन दिखाने के लिए सामग्री को अद्यतन करते हैं।

संपादित करें:

Ghostdog74 द्वारा सुझाए गए अनुसार "शब्द द्वारा पहला अक्षर टॉगल करें" ( ${var~} ) जोड़ा गया

संपादित करें: बैश 4.3 से मेल खाने के लिए सही टिल्डे व्यवहार।


मुझे पता है कि यह एक पुरानी पोस्ट है लेकिन मैंने यह जवाब किसी अन्य साइट के लिए बनाया है, इसलिए मैंने सोचा कि मैं इसे यहां पोस्ट करूंगा:

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');"`

या Awk:

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

या सेड:

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

या बैश 4:

b=${a,,}

या नोडजेएस अगर आपके पास है (और थोड़ा पागल हैं ...):

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');"`

या Awk:

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

या सेड:

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

या बैश 4:

b=${a^^}

या नोडजेएस अगर आपके पास है (और थोड़ा पागल हैं ...):

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

आप dd भी उपयोग कर सकते हैं (लेकिन मैं नहीं!):

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

इसके अलावा जब आप 'खोल' कहते हैं तो मुझे लगता है कि आप का मतलब है कि bash लेकिन यदि आप zsh उपयोग कर सकते हैं zsh यह उतना आसान है जितना आसान है

b=$a:l

कम मामले के लिए और

b=$a:u

ऊपरी मामले के लिए।


रूपांतरित स्ट्रिंग को एक चर में स्टोर करने के लिए। मेरे लिए काम करने के बाद - $SOURCE_NAME $TARGET_NAME

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

विभिन्न तरीके हैं:

tr

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

AWK

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

बैश 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

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




lowercase