Swift Language
तार और चरित्र

वाक्य - विन्यास

• String.characters // स्ट्रिंग में वर्णों की एक सरणी देता है
• String.characters.count // वर्णों की संख्या लौटाता है
• String.utf8 // A String.UTF8View, स्ट्रिंग में UTF-8 वर्ण बिंदु देता है
• String.utf16 // A String.UTF16View, String में UTF-16 वर्ण बिंदु देता है
• String.unicodeScalars // A String.UnicodeScalarView, स्ट्रिंग में UTF-32 वर्ण बिंदु लौटाता है
• String.isEmpty // यदि स्ट्रिंग में कोई पाठ नहीं है, तो वापस लौटाता है
• String.hasPrefix (स्ट्रिंग) // स्ट्रिंग सही है यदि स्ट्रिंग तर्क के साथ उपसर्ग है
• String.hasSuffix (String) // रिटर्न सही है यदि स्ट्रिंग तर्क के साथ प्रत्यय है
• String.startIndex // वह इंडेक्स देता है जो स्ट्रिंग के पहले कैरेक्टर से मेल खाता है
• String.endIndex // वह इंडेक्स देता है जो स्ट्रिंग के अंतिम वर्ण के बाद स्पॉट से मेल खाता है
• String.compords (सेपरेट किया गया: String) // दिए गए सेपरेटर स्ट्रिंग द्वारा अलग किए गए सब्सट्रिंग्स युक्त सरणी देता है
• String.append (चरित्र) // String में अक्षर (तर्क के रूप में दिए गए) जोड़ता है

टिप्पणियों

स्ट्रिंग और चरित्र साहित्य

स्विफ्ट में स्ट्रिंग शाब्दिक को दोहरे उद्धरण चिह्नों के साथ सीमांकित किया गया है ( " ):

let greeting = "Hello!"  // greeting's type is String

वर्णों को स्ट्रिंग शाब्दिकों से आरम्भ किया जा सकता है, जब तक कि शाब्दिक में केवल एक अंगूर समूह होता है:

let chr: Character = "H" // valid
let chr2: Character = "😊" // valid
let chr3: Character = "abc" // invalid - multiple grapheme clusters

स्ट्रिंग इंटरपोलेशन

स्ट्रिंग इंटरपोलेशन एक स्ट्रिंग शाब्दिक में सीधे अभिव्यक्ति को इंजेक्ट करने की अनुमति देता है। यह सभी प्रकार के मूल्यों के साथ किया जा सकता है, जिसमें तार, पूर्णांक, फ्लोटिंग पॉइंट संख्या और अधिक शामिल हैं।

वाक्यविन्यास एक बैकस्लैश है जिसके बाद कोष्ठक में मान: \(value) लपेटते हैं। फ़ंक्शन कॉल सहित, कोष्ठक में कोई भी मान्य अभिव्यक्ति दिखाई दे सकती है।

let number = 5
let interpolatedNumber = "\(number)"  // string is "5"
let fortyTwo = "\(6 * 7)"             // string is "42"

let example = "This post has \(number) view\(number == 1 ? "" : "s")"
// It will output "This post has 5 views" for the above example.
// If the variable number had the value 1, it would output "This post has 1 view" instead.

कस्टम प्रकारों के लिए, स्ट्रिंग प्रक्षेप का डिफ़ॉल्ट व्यवहार यह है कि "\(myobj)" String(myobj) बराबर है, print(myobj) द्वारा उपयोग किया गया समान प्रतिनिधित्व। आप अपने प्रकार के लिए CustomStringConvertible प्रोटोकॉल को लागू करके इस व्यवहार को अनुकूलित कर सकते हैं।

विशेष वर्ण

कुछ वर्णों को स्ट्रिंग लिटरल्स में उनका उपयोग करने के लिए एक विशेष एस्केप सीक्वेंस की आवश्यकता होती है:

उदाहरण:

let message = "Then he said, \"I \u{1F496} you!\""

print(message) // Then he said, "I 💖 you!"

संगति तार

एक नया तार पैदा करने के लिए + ऑपरेटर के साथ तार समेटें:

let name = "John"
let surname = "Appleseed"
let fullName = name + " " + surname  // fullName is "John Appleseed"

+= कंपाउंड असाइनमेंट ऑपरेटर का उपयोग करके या किसी विधि का उपयोग करके एक म्यूटेबल स्ट्रिंग में जोड़ें:

let str2 = "there"
var instruction = "look over"
instruction += " " + str2  // instruction is now "look over there"

var instruction = "look over"
instruction.append(" " + str2)  // instruction is now "look over there"

एक एकल स्ट्रिंग के लिए एक एकल वर्ण जोड़ें:

var greeting: String = "Hello"
let exclamationMark: Character = "!"
greeting.append(exclamationMark) 
// produces a modified String (greeting) = "Hello!"

एक उत्परिवर्ती स्ट्रिंग में कई वर्णों को जोड़ें

var alphabet:String = "my ABCs: "
alphabet.append(contentsOf: (0x61...0x7A).map(UnicodeScalar.init)
                                         .map(Character.init) )
// produces a modified string (alphabet) = "my ABCs: abcdefghijklmnopqrstuvwxyz"

joinWithSeparator(_:) : का उपयोग करके एक नया स्ट्रिंग बनाने के लिए तार के अनुक्रम में शामिल हों:

let words = ["apple", "orange", "banana"]
let str = words.joinWithSeparator(" & ")

print(str)   // "apple & orange & banana"

परीक्षण करें और स्ट्रिंग्स की तुलना करें

जांचें कि क्या कोई स्ट्रिंग खाली है:

if str.isEmpty {
    // do something if the string is empty
}

// If the string is empty, replace it with a fallback:
let result = str.isEmpty ? "fallback string" : str

जांचें कि क्या दो तार बराबर हैं ( यूनिकोड विहित समतुल्यता के अर्थ में):

"abc" == "def"          // false
"abc" == "ABC"          // false
"abc" == "abc"          // true

// "LATIN SMALL LETTER A WITH ACUTE" == "LATIN SMALL LETTER A" + "COMBINING ACUTE ACCENT"
"\u{e1}" == "a\u{301}"  // true

जांचें कि क्या एक स्ट्रिंग दूसरे स्ट्रिंग के साथ शुरू / समाप्त होती है:

"fortitude".hasPrefix("fort")      // true
"Swift Language".hasSuffix("age")  // true

स्ट्रिंग एन्कोडिंग और अपघटन

एक स्विफ्ट स्ट्रिंग यूनिकोड कोड बिंदुओं से बना है। इसे कई अलग-अलग तरीकों से विघटित और एन्कोड किया जा सकता है।

let str = "ที่👌①!"

Decomposing स्ट्रिंग्स

एक स्ट्रिंग के characters यूनिकोड विस्तारित अंगूर समूह हैं :

Array(str.characters)  // ["ที่", "👌", "①", "!"]

unicodeScalars यूनिकोड हैं कोड अंक कि एक स्ट्रिंग बना है (ध्यान दें कि ที่ एक ग्रफीम क्लस्टर है, लेकिन 3 कोड अंक - 3607, 3637, 3656 - तो परिणामी सरणी की लंबाई के साथ के रूप में ही नहीं है characters ):

str.unicodeScalars.map{ $0.value }  // [3607, 3637, 3656, 128076, 9312, 33]

आप UTF-8 ( UInt8 s का एक क्रम) या UTF-16 ( UInt16 s का एक क्रम) के रूप में स्ट्रिंग को एन्कोड और विघटित कर सकते हैं:

Array(str.utf8)   // [224, 184, 151, 224, 184, 181, 224, 185, 136, 240, 159, 145, 140, 226, 145, 160, 33]
Array(str.utf16)  // [3607, 3637, 3656, 55357, 56396, 9312, 33]

स्ट्रिंग लंबाई और Iteration

एक स्ट्रिंग के characters , unicodeScalars , utf8 और utf16 सभी संग्रह s हैं, इसलिए आप उनकी count प्राप्त कर सकते हैं और उन पर पुनरावृति कर सकते हैं:

// NOTE: These operations are NOT necessarily fast/cheap! 

str.characters.count     // 4
str.unicodeScalars.count // 6
str.utf8.count           // 17
str.utf16.count          // 7

for c in str.characters { // ...
for u in str.unicodeScalars { // ...
for byte in str.utf8 { // ...
for byte in str.utf16 { // ...

यूनिकोड

मान सेट करना

सीधे यूनिकोड का उपयोग करना

var str: String = "I want to visit 北京, Москва, मुंबई, القاهرة, and 서울시. 😊"
var character: Character = "🌍"

हेक्साडेसिमल मूल्यों का उपयोग करना

var str: String = "\u{61}\u{5927}\u{1F34E}\u{3C0}" // a大🍎π
var character: Character = "\u{65}\u{301}" // é = "e" + accent mark

ध्यान दें कि स्विफ्ट Character कई यूनिकोड कोड बिंदुओं से बना हो सकता है, लेकिन एक एकल वर्ण प्रतीत होता है। इसे एक्सटेंडेड ग्रेफेम क्लस्टर कहा जाता है।

रूपांतरण

स्ट्रिंग -> हेक्स

// Accesses views of different Unicode encodings of `str`
str.utf8
str.utf16
str.unicodeScalars // UTF-32

हेक्स -> स्ट्रिंग

let value0: UInt8 = 0x61
let value1: UInt16 = 0x5927
let value2: UInt32 = 0x1F34E

let string0 = String(UnicodeScalar(value0)) // a
let string1 = String(UnicodeScalar(value1)) // 大
let string2 = String(UnicodeScalar(value2)) // 🍎

// convert hex array to String
let myHexArray = [0x43, 0x61, 0x74, 0x203C, 0x1F431] // an Int array
var myString = ""
for hexValue in myHexArray {
    myString.append(UnicodeScalar(hexValue))
}
print(myString) // Cat‼🐱

ध्यान दें कि UTF-8 और UTF-16 के लिए रूपांतरण हमेशा इतना आसान नहीं होता है क्योंकि इमोजी जैसी चीजों को एकल UTF-16 मान के साथ एन्कोड नहीं किया जा सकता है। यह एक सरोगेट जोड़ी लेता है।

स्ट्रिंग्स उलट

let aString = "This is a test string."

// first, reverse the String's characters 
let reversedCharacters = aString.characters.reverse()

// then convert back to a String with the String() initializer
let reversedString = String(reversedCharacters)

print(reversedString) // ".gnirts tset a si sihT"

let reversedCharacters = aString.characters.reversed()
let reversedString = String(reversedCharacters)

अपरकेस और लोअरकेस स्ट्रिंग्स

एक स्ट्रिंग अपरकेस या लोअरकेस में सभी वर्ण बनाने के लिए:

let text = "AaBbCc"
let uppercase = text.uppercaseString // "AABBCC"
let lowercase = text.lowercaseString // "aabbcc"

let text = "AaBbCc"
let uppercase = text.uppercased() // "AABBCC"
let lowercase = text.lowercased() // "aabbcc"

जाँच करें कि क्या स्ट्रिंग में एक निर्धारित सेट से वर्ण हैं

पत्र

let letters = CharacterSet.letters

let phrase = "Test case"
let range = phrase.rangeOfCharacter(from: letters)

// range will be nil if no letters is found
if let test = range {
   print("letters found")
}
else {
   print("letters not found")
}

let letters = NSCharacterSet.letterCharacterSet()

let phrase = "Test case"
let range = phrase.rangeOfCharacterFromSet(letters)

// range will be nil if no letters is found
if let test = range {
   print("letters found")
}
else {
  print("letters not found")
}

नई CharacterSet संरचना जो ऑब्जेक्टिव-सी NSCharacterSet क्लास के लिए भी ब्रिज की गई है, कई पूर्वनिर्धारित सेटों को परिभाषित करती है:

• decimalDigits
• capitalizedLetters
• alphanumerics
• controlCharacters
• illegalCharacters
• और अधिक आप NSCharacterSet संदर्भ में पा सकते हैं।

आप अपने स्वयं के पात्रों को भी परिभाषित कर सकते हैं:

let phrase = "Test case"
let charset = CharacterSet(charactersIn: "t")

if let _ = phrase.rangeOfCharacter(from: charset, options: .caseInsensitive) {
   print("yes") 
}
else {
   print("no")
}

let charset = NSCharacterSet(charactersInString: "t")

if let _ = phrase.rangeOfCharacterFromSet(charset, options: .CaseInsensitiveSearch, range: nil) {
   print("yes")
}
else {
    print("no")
}

आप रेंज भी शामिल कर सकते हैं:

let phrase = "Test case"
let charset = CharacterSet(charactersIn: "t")

if let _ = phrase.rangeOfCharacter(from: charset, options: .caseInsensitive, range: phrase.startIndex..<phrase.endIndex)) {
   print("yes") 
}
else {
   print("no")
}

एक स्ट्रिंग में एक चरित्र की घटनाओं की गणना

एक String और एक Character को देखते हुए

let text = "Hello World"
let char: Character = "o"

हम String का उपयोग करते समय Character प्रकट होने की संख्या की गणना कर सकते हैं

let sensitiveCount = text.characters.filter { $0 == char }.count // case-sensitive
let insensitiveCount = text.lowercaseString.characters.filter { $0 == Character(String(char).lowercaseString) } // case-insensitive

सेट में परिभाषित स्ट्रिंग से वर्ण निकालें

func removeCharactersNotInSetFromText(text: String, set: Set<Character>) -> String {
   return String(text.characters.filter { set.contains( $0) })
}

let text = "Swift 3.0 Come Out"
var chars = Set([Character]("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLKMNOPQRSTUVWXYZ".characters))
let newText = removeCharactersNotInSetFromText(text, set: chars) // "SwiftComeOut"

func removeCharactersNotInSetFromText(text: String, set: Set<Character>) -> String {
  return String(text.characters.filter { set.contains( $0) })
}

let text = "Swift 3.0 Come Out"
var chars = Set([Character]("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLKMNOPQRSTUVWXYZ".characters))
let newText = removeCharactersNotInSetFromText(text: text, set: chars)

स्वरूपण स्ट्रिंग्स

अग्रणी शून्य

let number: Int = 7
let str1 = String(format: "%03d", number) // 007
let str2 = String(format: "%05d", number) // 00007

दशमलव के बाद की संख्या

let number: Float = 3.14159
let str1 = String(format: "%.2f", number) // 3.14
let str2 = String(format: "%.4f", number) // 3.1416 (rounded)

हेक्साडेसिमल को दशमलव

let number: Int = 13627
let str1 = String(format: "%2X", number) // 353B
let str2 = String(format: "%2x", number) // 353b (notice the lowercase b)

वैकल्पिक रूप से एक विशेष इनिशियलाइज़र का उपयोग कर सकता है जो ऐसा ही करता है:

let number: Int = 13627
let str1 = String(number, radix: 16, uppercase: true) //353B
let str2 = String(number, radix: 16) // 353b

मनमाने ढंग से मूलांक के साथ एक संख्या में दशमलव

let number: Int = 13627
let str1 = String(number, radix: 36) // aij

मूलांक [2, 36] में Int है।

एक संख्या प्रकार के लिए स्विफ्ट स्ट्रिंग परिवर्तित करना

Int("123") // Returns 123 of Int type
Int("abcd") // Returns nil
Int("10") // Returns 10 of Int type
Int("10", radix: 2) // Returns 2 of Int type
Double("1.5") // Returns 1.5 of Double type
Double("abcd") // Returns nil

ध्यान दें कि ऐसा करने से एक Optional मूल्य प्राप्त होता है, जिसका उपयोग किए जाने से पहले तदनुसार अपरिवर्तित होना चाहिए।

स्ट्रिंग Iteration

let string = "My fantastic string"
var index = string.startIndex

while index != string.endIndex {
    print(string[index])
    index = index.successor()
}

let string = "My fantastic string"
var currentIndex = string.startIndex

while currentIndex != string.endIndex {
    print(string[currentIndex])
    currentIndex = string.index(after: currentIndex)
}

और, उदाहरण के लिए, यदि आप दूसरे रास्ते पर जाना चाहते हैं:

var index:String.Index? = string.endIndex.predecessor()

while index != nil {
    print(string[index!])
    if index != string.startIndex {
        index = index.predecessor()
    }
    else {
        index = nil
    }
}

var currentIndex: String.Index? = string.index(before: string.endIndex)

while currentIndex != nil {
    print(string[currentIndex!])
    if currentIndex != string.startIndex {
        currentIndex = string.index(before: currentIndex!)
    }
    else {
        currentIndex = nil
    }
}

नोट, Index एक ऑब्जेक्ट प्रकार है, और Int नहीं। आप स्ट्रिंग के एक चरित्र का उपयोग इस प्रकार नहीं कर सकते हैं:

let string = "My string"
string[2] // can't do this
string.characters[2] // and also can't do this

लेकिन आप इस प्रकार एक विशिष्ट सूचकांक प्राप्त कर सकते हैं:

index = string.startIndex.advanceBy(2)

currentIndex = string.index(string.startIndex, offsetBy: 2)

और इस तरह पीछे जा सकते हैं:

index = string.endIndex.advancedBy(-2)

currentIndex = string.index(string.endIndex, offsetBy: -2)

यदि आप स्ट्रिंग की सीमा को पार कर सकते हैं, या आप एक सीमा निर्दिष्ट करना चाहते हैं जिसका आप उपयोग कर सकते हैं:

index = string.startIndex.advanceBy(20, limit: string.endIndex)

currentIndex = string.index(string.startIndex, offsetBy: 20, limitedBy: string.endIndex)

वैकल्पिक रूप से एक स्ट्रिंग में वर्णों के माध्यम से बस पुनरावृति हो सकती है, लेकिन यह संदर्भ के आधार पर कम उपयोगी हो सकता है:

for c in string.characters {
    print(c)
}

व्हाइटस्पेस और न्यूलाइन को अग्रणी और पीछे हटा दें

let someString = "  Swift Language  \n"
let trimmedString = someString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet())
// "Swift Language"

let trimmedWhiteSpace = someString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())
// "Swift Language  \n"

let trimmedNewLine = someString.stringByTrimmingCharactersInSet(NSCharacterSet.newlineCharacterSet())
// "  Swift Language  "

let someString = "  Swift Language  \n"

let trimmedString = someString.trimmingCharacters(in: .whitespacesAndNewlines)
// "Swift Language"

let trimmedWhiteSpace = someString.trimmingCharacters(in: .whitespaces)
// "Swift Language  \n"

let trimmedNewLine = someString.trimmingCharacters(in: .newlines)
// "  Swift Language  "

नोट: ये सभी तरीके Foundation । import Foundation उपयोग करें यदि फाउंडेशन पहले से ही अन्य पुस्तकालयों जैसे कोको या यूकीट के माध्यम से आयात नहीं किया गया है।

डेटा और NSData से स्ट्रिंग को कनवर्ट करें

स्ट्रिंग को डेटा / NSData से परिवर्तित करने के लिए हमें एक विशिष्ट एन्कोडिंग के साथ इस स्ट्रिंग को एनकोड करना होगा। सबसे प्रसिद्ध UTF-8 जो यूनिकोड वर्णों का 8-बिट प्रतिनिधित्व है, जो एएससीआईआई-आधारित प्रणालियों द्वारा प्रसारण या भंडारण के लिए उपयुक्त है। यहाँ सभी उपलब्ध String Encodings की एक सूची है

Data / NSData लिए String

let data = string.data(using: .utf8)

let data = string.dataUsingEncoding(NSUTF8StringEncoding)

String लिए Data / NSData

let string = String(data: data, encoding: .utf8)

let string = String(data: data, encoding: NSUTF8StringEncoding)

एक स्ट्रिंग को एक ऐरे में विभाजित करना

स्विफ्ट में आप एक स्ट्रिंग को आसानी से एक निश्चित वर्ण में खिसकाकर एक सरणी में अलग कर सकते हैं:

let startDate = "23:51"

let startDateAsArray = startDate.components(separatedBy: ":") // ["23", "51"]`

let startDate = "23:51"

let startArray = startDate.componentsSeparatedByString(":") // ["23", "51"]`

या जब विभाजक मौजूद नहीं है:

let myText = "MyText"

let myTextArray = myText.components(separatedBy: " ") // myTextArray is ["MyText"]

let myText = "MyText"

let myTextArray = myText.componentsSeparatedByString(" ") // myTextArray is ["MyText"]