स्विफ्ट लागू करें। स्ट्रिंग के पहले अक्षर को .upercaseString

232

मैं एक स्वत: सुधार प्रणाली बनाने की कोशिश कर रहा हूं, और जब कोई उपयोगकर्ता किसी शब्द को बड़े अक्षर के साथ टाइप करता है, तो स्वतः पूर्ण काम नहीं करता है। इसे ठीक करने के लिए, मैंने स्ट्रिंग की एक प्रति टाइप की, आवेदन किया। लिवरकेसस्ट्रिंग, और फिर उनकी तुलना की। यदि स्ट्रिंग वास्तव में गलत है, तो उसे शब्द को सही करना चाहिए। हालाँकि तब जो शब्द टाइप किया गया शब्द है वह सभी लोअरकेस है। इसलिए मुझे केवल प्रथम अक्षर को .uppercaseString लागू करने की आवश्यकता है। मैंने मूल रूप से सोचा था कि मैं उपयोग कर सकता हूं

nameOfString[0]

लेकिन यह स्पष्ट रूप से काम नहीं करता है। मैं स्ट्रिंग के पहले अक्षर को अपरकेस कैसे प्राप्त कर सकता हूं, और फिर पहले अक्षर के साथ पूर्ण स्ट्रिंग को प्रिंट करने में सक्षम हो सकता हूं?

किसी भी मदद के लिए धन्यवाद!

— कोई व्यक्ति
स्रोत

512

जिसमें उत्परिवर्तन और गैर उत्परिवर्तन संस्करण शामिल हैं जो एपीआई दिशानिर्देशों के अनुरूप हैं।

स्विफ्ट 3:

extension String {
    func capitalizingFirstLetter() -> String {
        let first = String(characters.prefix(1)).capitalized
        let other = String(characters.dropFirst())
        return first + other
    }

    mutating func capitalizeFirstLetter() {
        self = self.capitalizingFirstLetter()
    }
}

स्विफ्ट 4:

extension String {
    func capitalizingFirstLetter() -> String {
      return prefix(1).uppercased() + self.lowercased().dropFirst()
    }

    mutating func capitalizeFirstLetter() {
      self = self.capitalizingFirstLetter()
    }
}

— Kirsteins
स्रोत

3

बस एक ध्यान दें कि .capitalizedStringअब Xcode 7 बीटा 4 में काम नहीं करता। स्विफ्ट 2.0 में स्ट्रिंग्स थोड़ा बदल गया है।

— काकुबई

2

@ कर्स्टन: आप सही कह रहे हैं, मेरा बुरा। मैं Foundation भेड़ की मुस्कराहट

— kakubei

3

@ लॉरी लॉरी .uppercaseStringउस के लिए उपयोग करें

— कर्स्टन

2

यह गंभीर रूप से प्रभावी उत्तर मेट है। Xcode 7.1.1 / स्विफ्ट 2.1 के साथ काम कर रहा है .... धन्यवाद :)

— onCompletion

20

अभी इसकी .capitalized। नोट भीcapitalizedStringWith(_ locale:)

— राफेल

152

स्विफ्ट 5.1 या बाद में

extension StringProtocol {
    var firstUppercased: String { prefix(1).uppercased() + dropFirst() }
    var firstCapitalized: String { prefix(1).capitalized + dropFirst() }
}

स्विफ्ट 5

extension StringProtocol {
    var firstUppercased: String { return prefix(1).uppercased() + dropFirst() }
    var firstCapitalized: String { return prefix(1).capitalized + dropFirst() }
}

"Swift".first  // "S"
"Swift".last   // "t"
"hello world!!!".firstUppercased  // "Hello world!!!"

"Ǆ".firstCapitalized   // "ǅ"
"ǅ".firstCapitalized   // "ǅ"
"ǆ".firstCapitalized   // "ǅ"

— लियो डबस
स्रोत

3

अच्छी नौकरी। मैंने पहले लोअरकेस पास करने के लिए खान का संपादन किया और उचित नाम दिया।

— एरिकागू

मुझे स्विफ्ट 2.1.1 समाधान पसंद है, लेकिन जब मैं अपना ऐप चलाता हूं और लीक के लिए जांच करता हूं, तो यह दिखा रहा है कि यह लीक हो रहा है।

— हेनी ली

1

मैंने अभी एक नया प्रोजेक्ट बनाया है और ऐसा लगता है कि यह एक मेमोरी लीक का कारण बनता है जब इसे UITextFieldप्रेक्षक के लिए एक साथ प्रयोग किया जाता है UITextFieldTextDidChangeNotification।

— हेनी ली

@ यह कोड के साथ ही करने के लिए कुछ भी नहीं है। यदि आपको किसी प्रदर्शन / स्मृति समस्या का अनुभव होता है, तो आपको इसे Apple को रिपोर्ट करना चाहिए।

— लियो डबस 19

1

@LeoDabus मुझे लगता है कि यह नीचे है जो कोड के इरादे को अधिक स्पष्ट करता है। खाली स्ट्रिंग शाब्दिक शायद सबसे अच्छा है।

— निकोलस मिआरी

84

स्विफ्ट 3.0

"हैलो वर्ल्ड" के लिए

nameOfString.capitalized

या "हेलो वर्ल्ड" के लिए

nameOfString.uppercased

— Maselko
स्रोत

3

चार्ल्सिज्म ने दो महीने पहले ही स्विफ्ट 3 संस्करण के साथ जवाब दिया है ...

— एरिक आया

11

यह स्ट्रिंग के प्रत्येक शब्द के पहले चरित्र को कैपिटल करेगा और न केवल पहला शब्द।

— बोकाक्सिका

रिटर्न: स्ट्रिंग की एक अपरकेस कॉपी। सार्वजनिक समारोह uppercased () -> स्ट्रिंग स्विफ्ट 3.0 या "नमस्ते दुनिया के लिए" बजाय ऊपर nameOfString.uppercased () की nameOfString.uppercased

— Azharhussain शेख

40

स्विफ्ट 4.0

string.capitalized(with: nil)

या

string.capitalized

हालाँकि यह हर शब्द के पहले अक्षर को बड़ा करता है

Apple का प्रलेखन:

एक कैपिटलाइज़्ड स्ट्रिंग एक स्ट्रिंग है जिसमें प्रत्येक शब्द के पहले अक्षर को उसके संबंधित अपरकेस मान में बदल दिया जाता है, और सभी शेष वर्णों को उनके संबंधित लोअरकेस मानों पर सेट किया जाता है। "शब्द" रिक्त स्थान, टैब या लाइन टर्मिनेटर द्वारा सीमांकित वर्णों का कोई भी क्रम है। कुछ सामान्य शब्द विराम चिह्नों पर विचार नहीं किया जाता है, इसलिए यह संपत्ति आमतौर पर मल्टीवर्ड स्ट्रिंग्स के लिए वांछित परिणाम नहीं दे सकती है। अतिरिक्त जानकारी के लिए getLineStart (_: अंत: contentEnd: for :) विधि देखें।

— सैम के
स्रोत

1

मुझे नहीं पता कि लोग इस उत्तर के लिए ग्रहणशील क्यों नहीं हैं। यदि लोग केवल पहला शब्द पूंजीकृत चाहते हैं तो वे पहले को पकड़ सकते हैं और पूंजीकृत संपत्ति के साथ इसे सबसे आसानी से कैपिटल कर सकते हैं।

— स्कॉट्टीब्लाड्स

1

महत्वपूर्ण रूप से, "कैपिटलाइज़्ड" सभी यूनिकोड वर्णों के लिए सही है, जबकि पहले वर्ण के लिए "अपरकेस" का उपयोग नहीं किया गया है।

— gnasher729

23

extension String {
    func firstCharacterUpperCase() -> String? {
        let lowercaseString = self.lowercaseString

        return lowercaseString.stringByReplacingCharactersInRange(lowercaseString.startIndex...lowercaseString.startIndex, withString: String(lowercaseString[lowercaseString.startIndex]).uppercaseString)
    }
}

let x = "heLLo"
let m = x.firstCharacterUpperCase()

स्विफ्ट 5 के लिए:

extension String {
    func firstCharacterUpperCase() -> String? {
        guard !isEmpty else { return nil }
        let lowerCasedString = self.lowercased()
        return lowerCasedString.replacingCharacters(in: lowerCasedString.startIndex...lowerCasedString.startIndex, with: String(lowerCasedString[lowerCasedString.startIndex]).uppercased())
    }
}

— user2260304
स्रोत

यह सबसे अच्छा उत्तर है IMO - भविष्य के सभी मामलों के लिए इसे सरल रखता है।

— रॉबर्ट

यह जाँचने की आवश्यकता नहीं है कि क्या स्ट्रिंग है isEmptyऔर किसी स्ट्रिंग को आरंभिक रूप से बदलने के लिए। आप बस पहले चरित्र को खोल सकते हैं और अगर यह विफल हो जाता है तो केवल शून्य लौटाएं। इसे सरल बनाया जा सकता है

var firstCharacterUpperCase: String? {         guard let first = first else { return nil }         return lowercased().replacingCharacters(in: startIndex...startIndex, with: first.uppercased())     }

— लियो डबस

17

शब्द के पहले अक्षर के .capitalizedलिए स्विफ्ट में और पूरे शब्द के उपयोग के लिए.uppercased()

— दुर्गेश
स्रोत

10

स्विफ्ट 2.0 (सिंगल लाइन):

String(nameOfString.characters.prefix(1)).uppercaseString + String(nameOfString.characters.dropFirst())

— फिल
स्रोत

1

Upvoted। हालांकि, यह मानता है कि मूल स्ट्रिंग सभी निचले मामले हैं। मैंने .localizedLowercaseStringइसे स्ट्रिंग्स के साथ काम करने के लिए आखिर में जोड़ा जैसे: aNYsTring।

String(nameOfString.characters.prefix(1)).uppercaseString + String(nameOfString.characters.dropFirst()).localizedLowercaseString

— इलोजी

4

स्विफ्ट 3 (xcode 8.3.3)

स्ट्रिंग के सभी पहले वर्णों को बड़ा करें

let str = "your string"
let capStr = str.capitalized

//Your String

सभी वर्णों को बड़ा करना

let str = "your string"
let upStr = str.uppercased()

//YOUR STRING

अपरकेस पहले स्ट्रिंग का केवल चरित्र है

 var str = "your string"
 let capStr = String(str.characters.prefix(1)).uppercased() + String(str.characters.dropFirst())

//Your string

— ऑस्कर कास्टेलन
स्रोत

यह सिर्फ एक स्ट्रिंग के पहले चरित्र को कैपिटल नहीं करेगा

— रुल पैप

4

स्विफ्ट 5 में

https://www.hackingwithswift.com/example-code/strings/how-to-capitalize-the-first-letter-of-a-string

extension String {
    func capitalizingFirstLetter() -> String {
        return prefix(1).capitalized + dropFirst()
    }

    mutating func capitalizeFirstLetter() {
        self = self.capitalizingFirstLetter()
    }
}

अपनी स्ट्रिंग के साथ उपयोग करें

let test = "the rain in Spain"
print(test.capitalizingFirstLetter())

— संजय मिश्रा
स्रोत

3

मुझे क्रिस्तिंस के समाधान के साथ पहले चरित्र को दोहराया जा रहा है। यह दोहरे चरित्र को देखे बिना, पहले वर्ण को बड़ा करेगा:

var s: String = "hello world"
s = prefix(s, 1).capitalizedString + suffix(s, countElements(s) - 1)

मुझे नहीं पता कि यह अधिक या कम कुशल है, मैं सिर्फ इतना जानता हूं कि यह मुझे वांछित परिणाम देता है।

— मार्क फीर्बी
स्रोत

आप परीक्षण कर सकते हैं कि पहले चरित्र को कैपिटलाइज़ करने से वह चरित्र बदल जाता है या नहीं - इसे अपने आप में सहेज कर और फिर नए 'कैपिटलाइज़्ड' स्ट्रिंग के साथ समानता का परीक्षण करते हुए, और यदि वे समान हैं तो आपके पास पहले से ही वही है जो आप चाहते हैं।

— डेविड एच।

आपकी पोस्ट ने इस उत्तर को प्रेरित किया - धन्यवाद !: func capitaizeFirstChar (var s: String) -> स्ट्रिंग {if s.isEmpty == false {let रेंज = s.startIndex ... s.startIndex मूल = s.substringWithRange (श्रेणी) अगर पूंजी लगाई जाए तो = मूल.कैपिटलइंस्टारिंग यदि मूल == पूंजीकृत {रिटर्न s} s.replaceRange (रेंज, साथ: पूंजीकृत)} रिटर्न s}

— डेविड एच

1

स्विफ्ट के नए संस्करणों में, countElementsबस है count।

— जॉर्ज पोलोस

3

स्विफ्ट 3 से आप आसानी से उपयोग कर सकते हैं textField.autocapitalizationType = UITextAutocapitalizationType.sentences

— Yura
स्रोत

3

यहां स्विफ्ट 5 के लिए एक संस्करण है जो पहले पत्र पहले से ही बड़े अक्षरों में होने के कारण यूनिकोड स्केलर गुण एपीआई का उपयोग करता है , या मामले की धारणा नहीं है:

extension String {
  func firstLetterUppercased() -> String {
    guard let first = first, first.isLowercase else { return self }
    return String(first).uppercased() + dropFirst()
  }
}

— एडम तेज
स्रोत

पहले चरित्र के साथ एक स्ट्रिंग को शुरू करने की आवश्यकता नहीं है। return first.uppercased() + dropFirst()या एक लाइनर(first?.uppercased() ?? "") + dropFirst()

— लियो डबस

2

स्ट्रिंग में पहले वर्ण को बड़ा करें

extension String {
    var capitalizeFirst: String {
        if self.characters.count == 0 {
            return self

        return String(self[self.startIndex]).capitalized + String(self.characters.dropFirst())
    }
}

— user3699466
स्रोत

2

स्विफ्ट 3.0 में (यह स्वीकृत उत्तर की तुलना में थोड़ा तेज़ और सुरक्षित है):

extension String {
    func firstCharacterUpperCase() -> String {
        if let firstCharacter = characters.first {
            return replacingCharacters(in: startIndex..<index(after: startIndex), with: String(firstCharacter).uppercased())
        }
        return ""
    }
}

nameOfString.capitalized काम नहीं करेगा , यह वाक्य में प्रत्येक शब्द को कैपिटल करेगा

— pierre23
स्रोत

1

लियोनार्डो सावियो डबस को श्रेय:

मुझे लगता है कि उचित उपयोग करने के लिए अधिकांश मामलों का उपयोग किया जाता है:

import Foundation

extension String {

    var toProper:String {
        var result = lowercaseString
        result.replaceRange(startIndex...startIndex, with: String(self[startIndex]).capitalizedString)
        return result
    }
}

— ericgu
स्रोत

1

मेरा समाधान:

func firstCharacterUppercaseString(string: String) -> String {
    var str = string as NSString
    let firstUppercaseCharacter = str.substringToIndex(1).uppercaseString
    let firstUppercaseCharacterString = str.stringByReplacingCharactersInRange(NSMakeRange(0, 1), withString: firstUppercaseCharacter)
    return firstUppercaseCharacterString
}

— नाज़री व्लिज़्लो
स्रोत

यह शुद्ध शुद्ध है।

— अभिषेक बेदी

1

ऊपर दिए गए उत्तरों को शामिल करते हुए, मैंने एक छोटा सा विस्तार लिखा जो हर शब्द के पहले अक्षर को कैपिटल करता है (क्योंकि यही वह चीज है जिसकी मुझे तलाश थी और लगा कि कोई और इसका इस्तेमाल कर सकता है)।

मैं विनम्रतापूर्वक प्रस्तुत करता हूं:

extension String {
    var wordCaps:String {
        let listOfWords:[String] = self.componentsSeparatedByString(" ")
        var returnString: String = ""
        for word in listOfWords {
            if word != "" {
                var capWord = word.lowercaseString as String
                capWord.replaceRange(startIndex...startIndex, with: String(capWord[capWord.startIndex]).uppercaseString)
                returnString = returnString + capWord + " "
            }
        }
        if returnString.hasSuffix(" ") {
            returnString.removeAtIndex(returnString.endIndex.predecessor())
        }
        return returnString
    }
}

— मैट
स्रोत

1

स्विफ्ट स्ट्रिंग में कैपिटलाइज़्ड स्ट्रिंग नामक एक विधि होती है। यदि आपको इसे स्ट्रिंग के एक सरणी पर लागू करने की आवश्यकता है, तो इस उत्तर को जांचें stackoverflow.com/a/28690655/2303865

— लियो डबस

1

स्विफ्ट 4

func firstCharacterUpperCase() -> String {
        if self.count == 0 { return self }
        return prefix(1).uppercased() + dropFirst().lowercased()
    }

— Gayratjon
स्रोत

0

यहाँ मैंने इसे छोटे चरणों में किया है, यह @Kirsteins के समान है।

func capitalizedPhrase(phrase:String) -> String {
    let firstCharIndex = advance(phrase.startIndex, 1)
    let firstChar = phrase.substringToIndex(firstCharIndex).uppercaseString
    let firstCharRange = phrase.startIndex..<firstCharIndex
    return phrase.stringByReplacingCharactersInRange(firstCharRange, withString: firstChar)
}

— guptron
स्रोत

0

func helperCapitalizeFirstLetter(stringToBeCapd:String)->String{
    let capString = stringToBeCapd.substringFromIndex(stringToBeCapd.startIndex).capitalizedString
    return capString
}

यह भी काम करता है बस अपने स्ट्रिंग को पास करें और एक पूंजीकृत वापस प्राप्त करें।

— डैन लियोनार्ड
स्रोत

0

स्विफ्ट 3 अपडेट

replaceRangeसमारोह अब हैreplaceSubrange

nameOfString.replaceSubrange(nameOfString.startIndex...nameOfString.startIndex, with: String(nameOfString[nameOfString.startIndex]).capitalized)

— ब्रेंड्ट बेली
स्रोत

पूंजीकृतकरण विधि का नाम बदलकर पूंजीकरण कर दिया गया है

— Rool Paap

0

मैं इस संस्करण के लिए आंशिक हूं, जो दूसरे उत्तर से साफ किया गया संस्करण है:

extension String {
  var capitalizedFirst: String {
    let characters = self.characters
    if let first = characters.first {
      return String(first).uppercased() + 
             String(characters.dropFirst())
    }
    return self
  }
}

यह केवल स्वयं का मूल्यांकन करके और अधिक कुशल होने का प्रयास करता है। एक बार स्वयं का पता लगाने के बाद, और फिर उप-स्ट्रिंग्स बनाने के लिए लगातार रूपों का उपयोग करता है।

— पैट्रिक दाढ़ी
स्रोत

0

स्विफ्ट 4 (Xcode 9.1)

extension String {
    var capEachWord: String {
        return self.split(separator: " ").map { word in
            return String([word.startIndex]).uppercased() + word.lowercased().dropFirst()
        }.joined(separator: " ")
    }
}

— डैनियल आर
स्रोत

स्ट्रिंग के पास पहले से ही capitalizedइस उद्देश्य के लिए एक संपत्ति है, जिसका नाम है

— लियो डबस

0

यदि आप स्ट्रिंग के प्रत्येक शब्द को बड़ा करना चाहते हैं, तो आप इस एक्सटेंशन का उपयोग कर सकते हैं

स्विफ्ट 4 एक्सकोड 9.2

extension String {
    var wordUppercased: String {
        var aryOfWord = self.split(separator: " ")
        aryOfWord =  aryOfWord.map({String($0.first!).uppercased() + $0.dropFirst()})
        return aryOfWord.joined(separator: " ")
    }
}

उपयोग किया गया

print("simple text example".wordUppercased) //output:: "Simple Text Example"

— Shilpriya
स्रोत

2

बस का उपयोग करें.capitalized

— kakubei

0

यदि आपकी स्ट्रिंग सभी कैप हैं तो नीचे की विधि काम करेगी

labelTitle.text = remarks?.lowercased().firstUppercased

यह एक्सटेंशन आपकी मदद करेगा

extension StringProtocol {
    var firstUppercased: String {
        guard let first = first else { return "" }
        return String(first).uppercased() + dropFirst()
    }
}

— आशु
स्रोत

1

बस का उपयोग करें.capitalized

— kakubei

@kakubei आप नकारात्मक वोट क्यों करते हैं। यह तरीका सेंटेंस केस के लिए है। पूंजीकृत शब्द पूंजी के हर पहले चरित्र को करेगा। उदाहरण स्ट्रिंग: - (यह एक लड़का है) .capitalized(यह एक लड़का है) वापस आ जाएगा और यह विधि वापस आ जाएगी (यह एक लड़का है) दोनों अलग हैं। (कृपया do + ve वोट दें या नकारात्मक निकालें)

— Ashu

तुम सही हो @ आशू, मेरी माफ़ी। हालाँकि मैं तब तक अपवोट नहीं कर सकता जब तक कि आप उत्तर को संपादित नहीं करते, इसलिए शायद एक छोटा सा सफेद स्थान संपादित करें और मैं इसे बढ़ा दूंगा। दोबारा माफी चाहूंगा।

— kakubei

पहले चरित्र के साथ एक स्ट्रिंग को शुरू करने की आवश्यकता नहीं है। return first.uppercased() + dropFirst()या एक लाइनर वापसी(first?.uppercased() ?? "") + dropFirst()

— लियो डबस

0

इस लाइन को viewDidLoad () विधि में जोड़ें।

 txtFieldName.autocapitalizationType = UITextAutocapitalizationType.words

— Pranit
स्रोत

-1

extension String {
    var lowercased:String {
        var result = Array<Character>(self.characters);
        if let first = result.first { result[0] = Character(String(first).uppercaseString) }
        return String(result)
    }
}

— john07
स्रोत

-1

स्विफ्ट 5 के लिए, आप ऐसा कर सकते हैं:

yourString.firstUppercased

नमूना: "एबीसी" -> "एबीसी"

— हुला
स्रोत

स्विफ्ट

— लियो डबस