स्विफ्ट में एक स्ट्रिंग में एक स्ट्रिंग विभाजित करें?

Question

कहो मेरे यहाँ एक तार है:

var fullName: String = "First Last"

मैं श्वेत स्थान पर स्ट्रिंग बेस को विभाजित करना चाहता हूं और उनके संबंधित चर को मान प्रदान करता हूं

var fullNameArr = // something like: fullName.explode(" ") 

var firstName: String = fullNameArr[0]
var lastName: String? = fullnameArr[1]

इसके अलावा, कभी-कभी उपयोगकर्ताओं के पास अंतिम नाम नहीं हो सकता है।

Comments

नमस्ते, मैं न मेरे मैक की जाँच करने के लिए है। लेकिन आप 'fullName.compordsSeparatedByString (स्ट्रिंग: "")' को कॉपी और पेस्ट करने की कोशिश नहीं कर सकते हैं, स्वतः पूर्णांक का उपयोग करें, ताकि आपको सही फ़ंक्शन मिल सके।

— डेविड गोल्जूसर

आप केवल एक चरित्र से बंटवारे, का उपयोग कर रहे हैं fullName.utf8.split( <utf-8 character code> )और साथ ही काम करता है (की जगह .utf8के साथ .utf16UTF-16 के लिए)। उदाहरण के लिए, बंटवारे +का उपयोग करके किया जा सकता हैfullName.utf8.split(43)

— जोजोड्मो

इसके अलावा, कभी-कभी अंतिम नामों में उनके स्थान होते हैं, जैसे कि "डैफने डु मौरियर" या "चार्ल्स डी लिंट"

— बेरी

मुझे यह अच्छा लगा: सिंगल डेलिमिटर द्वारा एक स्ट्रिंग को विभाजित करना , स्ट्रिंग को कई सीमांकक द्वारा विभाजित करना

— prosti

Answer 1

स्विफ्ट तरीका वैश्विक splitफ़ंक्शन का उपयोग करना है, जैसे:

var fullName = "First Last"
var fullNameArr = split(fullName) {$0 == " "}
var firstName: String = fullNameArr[0]
var lastName: String? = fullNameArr.count > 1 ? fullNameArr[1] : nil

स्विफ्ट 2 के साथ

स्विफ्ट 2 में आंतरिक CharacterView प्रकार की शुरूआत के कारण विभाजन का उपयोग थोड़ा अधिक जटिल हो जाता है। इसका मतलब यह है कि स्ट्रिंग अब SequenceType या CollectionType प्रोटोकॉल को नहीं अपनाता है और आपको .charactersस्ट्रिंग के उदाहरण के CharacterView प्रकार प्रतिनिधित्व तक पहुंचने के लिए संपत्ति का उपयोग करना चाहिए । (नोट: CharacterView SequenceType और CollectionType प्रोटोकॉल को अपनाता है)।

let fullName = "First Last"
let fullNameArr = fullName.characters.split{$0 == " "}.map(String.init)
// or simply:
// let fullNameArr = fullName.characters.split{" "}.map(String.init)

fullNameArr[0] // First
fullNameArr[1] // Last 

Comments

मेरे परीक्षणों में, पुर्ज़े के आकार का बायस्ट्रीमिंग आमतौर पर काफी तेज़ होता है, खासकर जब तारों के साथ काम करना जिसमें कई टुकड़ों में विभाजन की आवश्यकता होती है। लेकिन ओपी द्वारा सूचीबद्ध उदाहरण के लिए, या तो पर्याप्त होना चाहिए।

— केसी पर्किन्स

Xcode के रूप में 6.2b3 विभाजन के रूप में इस्तेमाल किया जा सकता है split("a:b::c:", {$0 == ":"}, maxSplit: Int.max, allowEmptySlices: false)।

— पास्कल

बस याद रखें कि आपको अभी भी पुरानी componentsSeparatedByString()पद्धति का उपयोग करने की आवश्यकता है यदि आपका विभाजक एक एकल चरित्र से अधिक लंबा है। और जैसा कि यह कहना अच्छा होगा let (firstName, lastName) = split(fullName) {$0 == ' '}, यह दुख की बात नहीं है।

— एनआरआईटीएच

@ काशिफ तब आप इस्तेमाल कर सकते थे split("a,b;c,d") {$0 == "," || $0 == ";"}याsplit("a,b;c,d") {contains(",;", $0)}

— एथन

Xcode 7.0 के लिए सही कोड fullNameArr = fullName.characters.split {$ 0 == ""} .map (String.init) है। संपादित करने की कोशिश की, लेकिन यह अस्वीकार कर दिया गया।

— स्केजडाल

Answer 2

बस componentsSeparatedByStringअपने पर कॉल विधिfullName

import Foundation

var fullName: String = "First Last"
let fullNameArr = fullName.componentsSeparatedByString(" ")

var firstName: String = fullNameArr[0]
var lastName: String = fullNameArr[1]

स्विफ्ट 3+ के लिए अपडेट

import Foundation

let fullName    = "First Last"
let fullNameArr = fullName.components(separatedBy: " ")

let name    = fullNameArr[0]
let surname = fullNameArr[1]

Comments

ध्यान दें कि यह वास्तव में एक अंतर्निहित है NSString(आयात करते समय स्विफ्ट स्वचालित रूप से स्वैप हो जाती है Foundation)।

— Can

जो अब स्विफ्ट 1.2 में नहीं है, जिसमें एप्पल अब स्विफ्ट के स्ट्रिंग को एनएसएसटीरिंग में स्वचालित रूप से परिवर्तित नहीं करता है।

— एल्कसो

यह जवाब Xcode 7 बीटा 4 और स्विफ्ट 2.0 में काम करता है। Xcode अब स्विफ्ट स्ट्रिंग ऑब्जेक्ट्स पर बिना NSString को टाइप किए बिना फाउंडेशन के तरीकों को स्वतः पूर्ण करता है, जो कि Xcode 6.4 में स्विफ्ट 1.2 के साथ नहीं है।

— एंड्रयू

यह REPL में काम नहीं किया जब तक मैं फाउंडेशन आयात नहीं किया।

— वेलिज़ार हिस्त्रोव

यह ठीक वैसा ही काम करता है जैसा कि (यानी fullNameArr [String]) Xcode 7.2 में है।

— जॉन कॉक्स

Answer 3

यह करने के लिए सबसे आसान तरीका है घटकों का उपयोग करके

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

import Foundation
let fullName : String = "First Last";
let fullNameArr : [String] = fullName.componentsSeparatedByString(" ")

// And then to access the individual words:

var firstName : String = fullNameArr[0]
var lastName : String = fullNameArr[1]

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

import Foundation

let fullName : String = "First Last"
let fullNameArr : [String] = fullName.components(separatedBy: " ")

// And then to access the individual words:

var firstName : String = fullNameArr[0]
var lastName : String = fullNameArr[1]

Comments

क्या यह कहीं भी प्रलेखित है, मॉरी? क्या होगा अगर मुझे एकल चरित्र के अलावा किसी और चीज़ पर विभाजित करने की आवश्यकता है?

— 18

@NRHH विचार .componentsSeparatedByCharactersInSet(.whitespaceAndNewlineCharacterSet())

— rmp251

@ क्रशालोट के दो कार्य हैं: componentsSeparatedByStringऔरcomponentsSeparatedByCharactersInSet

— rmp251

Answer 4

स्विफ्ट देव। 4.0 (24 मई, 2017)

splitस्विफ्ट 4 ( बीटा ) में एक नया कार्य ।

import Foundation
let sayHello = "Hello Swift 4 2017";
let result = sayHello.split(separator: " ")
print(result)

आउटपुट:

["Hello", "Swift", "4", "2017"]

पहुँच मान:

print(result[0]) // Hello
print(result[1]) // Swift
print(result[2]) // 4
print(result[3]) // 2017

Xcode 8.1 / स्विफ्ट 3.0.1

यहाँ सरणी के साथ कई सीमांकक है।

import Foundation
let mathString: String = "12-37*2/5"
let numbers = mathString.components(separatedBy: ["-", "*", "/"])
print(numbers)

आउटपुट:

["12", "37", "2", "5"]

Comments

import Foundationउस कक्षा में जोड़ना सुनिश्चित करें जिसका आप इसमें उपयोग कर रहे हैं। #SavedYouFiveMinutes

— Adrian

ध्यान (स्विफ्ट 4): यदि आपके पास एक स्ट्रिंग है let a="a,,b,c"और आप उपयोग करते हैं a.split(separator: ",")तो आप ["a", "b", c"]डिफ़ॉल्ट रूप से एक सरणी प्राप्त करते हैं । इसे omittingEmptySubsequences: falseडिफ़ॉल्ट रूप से सत्य का उपयोग करके बदला जा सकता है।

— ओडरवेट

स्विफ्ट 4+ में कोई मल्टी-कैरेक्टर स्प्लिट?

— pkamb

Answer 5

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

यदि आपको किसी व्यक्ति के नाम को ठीक से प्रारूपित करने की आवश्यकता है, तो आप PersonNameCompordsFormatter का उपयोग कर सकते हैं ।

PersonNameCompordsFormatter वर्ग व्यक्ति के नाम के घटकों का स्थानीयकृत प्रतिनिधित्व प्रदान करता है, जैसा कि एक PersonNameCompords ऑब्जेक्ट द्वारा प्रस्तुत किया गया है। उपयोगकर्ता को जानकारी का नाम प्रदर्शित करते समय स्थानीयकृत नाम बनाने के लिए इस वर्ग का उपयोग करें।

---

// iOS (9.0 and later), macOS (10.11 and later), tvOS (9.0 and later), watchOS (2.0 and later)
let nameFormatter = PersonNameComponentsFormatter()

let name =  "Mr. Steven Paul Jobs Jr."
// personNameComponents requires iOS (10.0 and later)
if let nameComps  = nameFormatter.personNameComponents(from: name) {
    nameComps.namePrefix   // Mr.
    nameComps.givenName    // Steven
    nameComps.middleName   // Paul
    nameComps.familyName   // Jobs
    nameComps.nameSuffix   // Jr.

    // It can also be configured to format your names
    // Default (same as medium), short, long or abbreviated

    nameFormatter.style = .default
    nameFormatter.string(from: nameComps)   // "Steven Jobs"

    nameFormatter.style = .short
    nameFormatter.string(from: nameComps)   // "Steven"

    nameFormatter.style = .long
    nameFormatter.string(from: nameComps)   // "Mr. Steven Paul Jobs jr."

    nameFormatter.style = .abbreviated
    nameFormatter.string(from: nameComps)   // SJ

    // It can also be use to return an attributed string using annotatedString method
    nameFormatter.style = .long
    nameFormatter.annotatedString(from: nameComps)   // "Mr. Steven Paul Jobs jr."
}

संपादित करें / अद्यतन:

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

केवल गैर अक्षर वर्णों द्वारा एक स्ट्रिंग को विभाजित करने के लिए हम नई चरित्र संपत्ति का उपयोग कर सकते हैं isLetter:

let fullName = "First Last"

let components = fullName.split{ !$0.isLetter }
print(components)  // "["First", "Last"]\n"

Comments

@DarrellRoot आपको बस सब्सट्रिंग्स को मैप करने की आवश्यकता हैfullName.split { $0.isWhitespace }.map(String.init)

— लियो डबस

मुझे वह नई एपीआई बहुत पसंद है लेकिन यह ध्यान रखें कि वह सबस्ट्रिंग लौटाए। मुझे स्ट्रिंग्स की आवश्यकता थी (और सामान्य रूप से let words = line.split{ $0.isWhitespace }.map{ String($0)} व्हाट्सएप पर विभाजित करना चाहता था) इसलिए मैंने ऐसा किया: धन्यवाद @LeoDabus आपके संस्करण के लिए (मेरी मूल टिप्पणी में कोड गायब था)। इसके अलावा मैं उत्तर के शीर्ष पर स्विफ्ट 5 संस्करण को स्थानांतरित करने का सुझाव देता हूं।

— डेरेल रूट

Answer 6

WMios के उत्तर के विकल्प के रूप में, आप इसका उपयोग भी कर सकते हैं componentsSeparatedByCharactersInSet , जो आपके द्वारा अधिक विभाजक (रिक्त स्थान, अल्पविराम, आदि) के मामले में उपयोगी हो सकता है।

अपने विशिष्ट इनपुट के साथ:

let separators = NSCharacterSet(charactersInString: " ")
var fullName: String = "First Last";
var words = fullName.componentsSeparatedByCharactersInSet(separators)

// words contains ["First", "Last"]

कई विभाजकों का उपयोग करना:

let separators = NSCharacterSet(charactersInString: " ,")
var fullName: String = "Last, First Middle";
var words = fullName.componentsSeparatedByCharactersInSet(separators)

// words contains ["Last", "First", "Middle"]

Comments

मेरे विचार में सबसे अधिक उपयोगी जवाब है, के बाद से आप के साथ तार की जुदाई की अनुमति देना चाहेंगे ,या ;या किसी अन्य विभाजक

— क्रिस

Answer 7

स्विफ्ट 4

let words = "these words will be elements in an array".components(separatedBy: " ")

Answer 8

व्हॉट्सएप का मुद्दा

आमतौर पर, लोग इस समस्या और बुरे समाधानों को बार-बार मजबूत करते हैं। क्या यह कोई स्पेस है? "" और क्या "\ n", "\ t" या कुछ यूनिकोड व्हाट्सएप चरित्र के बारे में जो आपने कभी नहीं देखा है, क्योंकि यह अदृश्य नहीं है। जबकि आप दूर हो सकते हैं

एक कमजोर समाधान

import Foundation
let pieces = "Mary had little lamb".componentsSeparatedByString(" ")

यदि आपको कभी भी वास्तविकता पर अपनी पकड़ को हिलाने की आवश्यकता है तो तार या तिथियों पर एक WWDC वीडियो देखें। संक्षेप में, एप्पल को इस तरह के सांसारिक कार्य को हल करने की अनुमति देना लगभग हमेशा बेहतर होता है।

मजबूत समाधान: NSCharacterSet का उपयोग करें

इसे सही तरीके से करने के लिए, IMHO, का उपयोग करना है NSCharacterSetक्योंकि पहले कहा गया है कि आपका व्हाट्सएप वह नहीं हो सकता है जो आप उम्मीद करते हैं और Apple ने एक व्हाट्सएप चरित्र सेट प्रदान किया है। विभिन्न प्रदान किए गए वर्ण सेटों का पता लगाने के लिए Apple के NSCharacterSet डेवलपर दस्तावेज़ीकरण की जांच करें और उसके बाद ही अपनी आवश्यकताओं को पूरा नहीं करने पर एक नए वर्ण सेट का निर्माण या निर्माण करें।

NSCharacterSet व्हाट्सएप

यूनिकोड जनरल श्रेणी Zs और CHARACTER TABULATION (U + 0009) में एक वर्ण सेट देता है।

let longerString: String = "This is a test of the character set splitting system"
let components = longerString.components(separatedBy: .whitespaces)
print(components)

Comments

माना। "" द्वारा विभाजित किए गए उत्तरों को देखने के बाद मेरे लिए पहली बात यह है: इनपुट पाठ में कई लगातार रिक्त स्थान होते हैं तो क्या होता है? यदि यह टैब है तो क्या होगा? पूर्ण-चौड़ाई (CJK) स्थान? आदि

— निकोलस मारी जूल

Answer 9

में स्विफ्ट 4.2 और Xcode 10

//This is your str
let str = "This is my String" //Here replace with your string

विकल्प 1

let items = str.components(separatedBy: " ")//Here replase space with your value and the result is Array.
//Direct single line of code
//let items = "This is my String".components(separatedBy: " ")
let str1 = items[0]
let str2 = items[1]
let str3 = items[2]
let str4 = items[3]
//OutPut
print(items.count)
print(str1)
print(str2)
print(str3)
print(str4)
print(items.first!)
print(items.last!)

विकल्प 2

let items = str.split(separator: " ")
let str1 = String(items.first!)
let str2 = String(items.last!)
//Output
print(items.count)
print(items)
print(str1)
print(str2)

विकल्प 3

let arr = str.split {$0 == " "}
print(arr)

विकल्प 4

let line = "BLANCHE:   I don't want realism. I want magic!"
print(line.split(separator: " "))
// Prints "["BLANCHE:", "I", "don\'t", "want", "realism.", "I", "want", "magic!"]"

Apple प्रलेखन द्वारा ...।

let line = "BLANCHE:   I don't want realism. I want magic!"
print(line.split(separator: " "))
// Prints "["BLANCHE:", "I", "don\'t", "want", "realism.", "I", "want", "magic!"]"

print(line.split(separator: " ", maxSplits: 1))//This can split your string into 2 parts
// Prints "["BLANCHE:", "  I don\'t want realism. I want magic!"]"

print(line.split(separator: " ", maxSplits: 2))//This can split your string into 3 parts

print(line.split(separator: " ", omittingEmptySubsequences: false))//array contains empty strings where spaces were repeated.
// Prints "["BLANCHE:", "", "", "I", "don\'t", "want", "realism.", "I", "want", "magic!"]"

print(line.split(separator: " ", omittingEmptySubsequences: true))//array not contains empty strings where spaces were repeated.
print(line.split(separator: " ", maxSplits: 4, omittingEmptySubsequences: false))
print(line.split(separator: " ", maxSplits: 3, omittingEmptySubsequences: true))

Answer 10

स्विफ्ट 4 पात्रों को विभाजित करना बहुत आसान बनाता है, बस स्ट्रिंग्स के लिए नए विभाजन फ़ंक्शन का उपयोग करें।

उदाहरण: let s = "hi, hello" let a = s.split(separator: ",") print(a)

अब आपको 'हाय' और 'हैलो' के साथ एक ऐरे मिला है।

Comments

ध्यान दें कि यह स्ट्रिंग की एक सरणी नहीं लौटाता है, लेकिन सबस्ट्रिंग की सरणी जो उपयोग करने के लिए अजीब है।

— लिरिक

Answer 11

5 स्विफ्ट के लिए अद्यतन और सबसे सरल तरीका

let paragraph = "Bob hit a ball, the hit BALL flew far after it was hit. Hello! Hie, How r u?"

let words = paragraph.components(separatedBy: [",", " ", "!",".","?"])

यह प्रिंट,

["बॉब", "हिट", "ए", "बॉल", "", "द", "हिट", "बल्ल", "फ्लाव", "फ़ॉर", "के बाद", "इट", " "," हिट "," "," हैलो "," "," ही "," "," कैसे "," आर "," यू "," "]

हालाँकि, यदि आप खाली स्ट्रिंग को फ़िल्टर करना चाहते हैं,

let words = paragraph.components(separatedBy: [",", " ", "!",".","?"]).filter({!$0.isEmpty})

आउटपुट,

["बॉब", "हिट", "ए", "बॉल", "द", "हिट", "बल्ल", "उड़ गया", "दूर", "के बाद", "यह", "था", " हिट "," हैलो "," ही "," हाउ "," आर "," यू "]

लेकिन यह सुनिश्चित करें कि फाउंडेशन आयात किया जाता है

Answer 12

स्विफ्ट 3

let line = "AAA    BBB\t CCC"
let fields = line.components(separatedBy: .whitespaces).filter {!$0.isEmpty}

• तीन तार देता है AAA, BBBऔरCCC
• खाली खेतों को छानता है
• कई रिक्त स्थान और सारणीकरण वर्ण संभालता है
• आप नई लाइनों को संभालने के लिए चाहते हैं, तो बदलने के .whitespacesसाथ.whitespacesAndNewlines

Answer 13

स्विफ्ट 4, Xcode 10 और iOS 12 अपडेट 100% काम कर रहे हैं

let fullName = "First Last"    
let fullNameArr = fullName.components(separatedBy: " ")
let firstName = fullNameArr[0] //First
let lastName = fullNameArr[1] //Last

देखें एप्पल के प्रलेखन यहाँ अधिक जानकारी के लिए।

Answer 14

Xcode 8.0 / स्विफ्ट 3

let fullName = "First Last"
var fullNameArr = fullName.components(separatedBy: " ")

var firstname = fullNameArr[0] // First
var lastname = fullNameArr[1] // Last

लंबा रास्ता:

var fullName: String = "First Last"
fullName += " " // this will help to see the last word

var newElement = "" //Empty String
var fullNameArr = [String]() //Empty Array

for Character in fullName.characters {
    if Character == " " {
        fullNameArr.append(newElement)
        newElement = ""
    } else {
        newElement += "\(Character)"
    }
}


var firsName = fullNameArr[0] // First
var lastName = fullNameArr[1] // Last

Answer 15

मेरे पास एक परिदृश्य था जहां कई नियंत्रण वर्ण स्ट्रिंग में मौजूद हो सकते हैं जिन्हें मैं विभाजित करना चाहता हूं। इन की एक सरणी बनाए रखने के बजाय, मैंने सिर्फ Apple को उस हिस्से को संभालने दिया।

निम्नलिखित iOS 10 पर स्विफ्ट 3.0.1 के साथ काम करता है:

let myArray = myString.components(separatedBy: .controlCharacters)

Answer 16

मुझे एक दिलचस्प मामला मिला, वह

विधि 1

var data:[String] = split( featureData ) { $0 == "\u{003B}" }

जब मैंने सर्वर से लोड किए गए डेटा से कुछ प्रतीक को विभाजित करने के लिए इस कमांड का उपयोग किया , तो यह सिम्युलेटर में टेस्ट करते समय विभाजित हो सकता है और टेस्ट डिवाइस के साथ सिंक कर सकता है, लेकिन यह प्रकाशित एप्लिकेशन और एड हॉक में विभाजित नहीं होगा

इस त्रुटि को ट्रैक करने के लिए मुझे बहुत समय लगता है, यह कुछ स्विफ्ट संस्करण, या कुछ iOS संस्करण से शापित हो सकता है या न ही

यह HTML कोड के बारे में भी नहीं है, क्योंकि मैं stringByRemovingPercentEncoding की कोशिश करता हूं और यह अभी भी काम नहीं कर रहा है

इसके अलावा 10/10/2015

स्विफ्ट 2.0 में इस विधि को बदल दिया गया है

var data:[String] = featureData.split {$0 == "\u{003B}"}

---

विधि 2

var data:[String] = featureData.componentsSeparatedByString("\u{003B}")

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

---

निष्कर्ष, मैं वास्तव में विधि 2 का उपयोग करने का सुझाव देता हूं

string.componentsSeparatedByString("")

Comments

मैं कहूंगा कि यह "एक उत्तर नहीं" स्थिति के करीब है, इसमें यह मौजूदा उत्तरों पर अधिकतर टिप्पणी है। लेकिन यह कुछ महत्वपूर्ण बात की ओर इशारा कर रहा है।

— रिकस्टर

Answer 17

इन उत्तरों में से अधिकांश मानते हैं कि इनपुट में एक स्थान है - सफेद स्थान नहीं और उस पर एक एकल स्थान। यदि आप सुरक्षित रूप से उस धारणा को बना सकते हैं, तो स्वीकृत उत्तर (बेनेट से) काफी सुरुचिपूर्ण है और यह भी कि मैं जो कर सकता हूं, वह तरीका है।

जब हम उस धारणा को नहीं बना सकते हैं, तो एक और अधिक मजबूत समाधान के लिए निम्नलिखित विवरणों को शामिल करने की आवश्यकता होती है, जो यहां दिए गए अधिकांश उत्तरों पर विचार नहीं करते हैं:

• आवर्ती वर्ण सहित टैब / न्यूलाइन्स / स्पेस (व्हाट्सएप)
• अग्रणी / अनुगामी व्हाट्सएप
• ऐप्पल / लिनक्स ( \n) और विंडोज ( \r\n) न्यूलाइन वर्ण

इन मामलों को कवर करने के लिए यह समाधान regex का उपयोग करके सभी व्हाट्सएप (पुनरावर्ती और Windows newline वर्णों सहित) को एक ही स्थान, ट्रिम्स में परिवर्तित करता है, फिर एक ही स्थान से विभाजित होता है:

स्विफ्ट 3:

let searchInput = "  First \r\n \n \t\t\tMiddle    Last "
let searchTerms = searchInput 
    .replacingOccurrences(
        of: "\\s+",
        with: " ",
        options: .regularExpression
    )
    .trimmingCharacters(in: .whitespaces)
    .components(separatedBy: " ")

// searchTerms == ["First", "Middle", "Last"]

Answer 18

या बंद किए बिना आप स्विफ्ट 2 में ऐसा कर सकते हैं:

let fullName = "First Last"
let fullNameArr = fullName.characters.split(" ")
let firstName = String(fullNameArr[0])

Answer 19

स्विफ्ट 4 में एक स्ट्रिंग को एक सरणी में विभाजित करने के लिए कदम।

1. स्ट्रिंग असाइन करें
2. @ विभाजन पर आधारित है।

नोट: variableName.compords (से अलग हो गया: "विभाजित कीवर्ड")

let fullName: String = "First Last @ triggerd event of the session by session storage @ it can be divided by the event of the trigger."
let fullNameArr = fullName.components(separatedBy: "@")
print("split", fullNameArr)

Answer 20

स्विफ्ट 4

let string = "loremipsum.dolorsant.amet:"

let result = string.components(separatedBy: ".")

print(result[0])
print(result[1])
print(result[2])
print("total: \(result.count)")

उत्पादन

loremipsum
dolorsant
amet:
total: 3

Answer 21

मान लें कि आपके पास "हैलो वर्ल्ड" नामक एक चर है और यदि आप इसे विभाजित करना चाहते हैं और इसे दो अलग-अलग चर में स्टोर कर सकते हैं तो आप इसका उपयोग कर सकते हैं:

var fullText = "Hello World"
let firstWord = fullText.text?.components(separatedBy: " ").first
let lastWord = fullText.text?.components(separatedBy: " ").last

Answer 22

let str = "one two"
let strSplit = str.characters.split(" ").map(String.init) // returns ["one", "two"]

Xcode 7.2 (7C68)

Answer 23

स्विफ्ट 2.2 त्रुटि हैंडलिंग और पूंजीकृत जोड़ा गया:

func setFullName(fullName: String) {
    var fullNameComponents = fullName.componentsSeparatedByString(" ")

    self.fname = fullNameComponents.count > 0 ? fullNameComponents[0]: ""
    self.sname = fullNameComponents.count > 1 ? fullNameComponents[1]: ""

    self.fname = self.fname!.capitalizedString
    self.sname = self.sname!.capitalizedString
}

Answer 24

स्ट्रिंग हैंडलिंग अभी भी स्विफ्ट में एक चुनौती है और यह महत्वपूर्ण रूप से बदलता रहता है, जैसा कि आप अन्य उत्तरों से देख सकते हैं। उम्मीद है कि चीजें शांत हो जाएं और यह सरल हो जाए। यह कई विभाजक पात्रों के साथ स्विफ्ट के वर्तमान 3.0 संस्करण के साथ ऐसा करने का तरीका है।

स्विफ्ट 3:

let chars = CharacterSet(charactersIn: ".,; -")
let split = phrase.components(separatedBy: chars)

// Or if the enums do what you want, these are preferred. 
let chars2 = CharacterSet.alphaNumerics // .whitespaces, .punctuation, .capitalizedLetters etc
let split2 = phrase.components(separatedBy: chars2)

Answer 25

मैं शिथिल विभाजन की तलाश कर रहा था , जैसे कि PHP explodeजहां खाली अनुक्रमों को परिणामस्वरूप सरणी में शामिल किया जाता है, यह मेरे लिए काम करता है:

"First ".split(separator: " ", maxSplits: 1, omittingEmptySubsequences: false)

आउटपुट:

["First", ""]

Answer 26

यह सीधे विभाजन भागों की एक सरणी देता है

var fullNameArr = fullName.components(separatedBy:" ")

तो आप इस तरह का उपयोग कर सकते हैं,

var firstName: String = fullNameArr[0]
var lastName: String? = fullnameArr[1]

Answer 27

केवल splitसही उत्तर है, यहां 2 से अधिक स्थानों के लिए अंतर है।

var temp = "Hello world     ni hao"
let arr  = temp.components(separatedBy: .whitespacesAndNewlines)
// ["Hello", "world", "", "", "", "", "ni", "hao"]
let arr2 = temp.components(separatedBy: " ")
// ["Hello", "world", "", "", "", "", "ni", "hao"]
let arr3 = temp.split(whereSeparator: {$0 == " "})
// ["Hello", "world", "ni", "hao"]

Answer 28

यह बीटा 5 में फिर से बदल गया है। अब यह CollectionType पर एक विधि है

पुराना:

var fullName = "First Last"
var fullNameArr = split(fullName) {$0 == " "}

नया:

var fullName = "First Last"
var fullNameArr = fullName.split {$0 == " "}

सेब रिलीज नोट्स

Answer 29

स्विफ्ट 2 के लिए, XCode 7.1:

let complete_string:String = "Hello world"
let string_arr =  complete_string.characters.split {$0 == " "}.map(String.init)
let hello:String = string_arr[0]
let world:String = string_arr[1]

Answer 30

यहाँ एक एल्गोरिथ्म है जो मैं अभी बना रहा हूँ, जो Stringकिसी भी Characterएरे से अलग हो जाएगा और अगर किसी बचे हुए वर्ण के साथ सबस्टिट्यूट रखने की इच्छा हो तो swallowपैरामीटर सेट कर सकता हैtrue ।

Xcode 7.3 - स्विफ्ट 2.2:

extension String {

    func splitBy(characters: [Character], swallow: Bool = false) -> [String] {

        var substring = ""
        var array = [String]()
        var index = 0

        for character in self.characters {

            if let lastCharacter = substring.characters.last {

                // swallow same characters
                if lastCharacter == character {

                    substring.append(character)

                } else {

                    var shouldSplit = false

                    // check if we need to split already
                    for splitCharacter in characters {
                        // slit if the last character is from split characters or the current one
                        if character == splitCharacter || lastCharacter == splitCharacter {

                            shouldSplit = true
                            break
                        }
                    }

                    if shouldSplit {

                        array.append(substring)
                        substring = String(character)

                    } else /* swallow characters that do not equal any of the split characters */ {

                        substring.append(character)
                    }
                }
            } else /* should be the first iteration */ {

                substring.append(character)
            }

            index += 1

            // add last substring to the array
            if index == self.characters.count {

                array.append(substring)
            }
        }

        return array.filter {

            if swallow {

                return true

            } else {

                for splitCharacter in characters {

                    if $0.characters.contains(splitCharacter) {

                        return false
                    }
                }
                return true
            }
        }
    }
}

उदाहरण:

"test text".splitBy([" "]) // ["test", "text"]
"test++text--".splitBy(["+", "-"], swallow: true) // ["test", "++" "text", "--"]