road - swift vxi




आप String.substringWithRange का उपयोग कैसे करते हैं?(या, रेंज स्विफ्ट में कैसे काम करते हैं?) (20)

मैं अभी तक यह पता लगाने में सक्षम नहीं हूं कि स्विफ्ट में String का सबस्ट्रिंग कैसे प्राप्त करें:

var str = “Hello, playground”
func test(str: String) -> String {
 return str.substringWithRange( /* What goes here? */ )
}
test (str)

मैं स्विफ्ट में एक रेंज बनाने में सक्षम नहीं हूँ। खेल के मैदान में स्वतः पूर्ण नहीं है - यह वही है जो यह सुझाता है:

return str.substringWithRange(aRange: Range<String.Index>)

मुझे स्विफ्ट मानक संदर्भ पुस्तकालय में कुछ भी नहीं मिला है जो मदद करता है। यहां एक और जंगली अनुमान था:

return str.substringWithRange(Range(0, 1))

और इस:

let r:Range<String.Index> = Range<String.Index>(start: 0, end: 2)
return str.substringWithRange(r)

मैंने अन्य उत्तरों ( स्विफ्ट स्ट्रिंग में चरित्र की अनुक्रमणिका ढूंढना ) देखा है जो ऐसा लगता है कि चूंकि String NSString लिए पुल प्रकार है, इसलिए "पुरानी" विधियों को काम करना चाहिए, लेकिन यह स्पष्ट नहीं है कि - उदाहरण के लिए, यह काम नहीं करता है या तो (वैध वाक्यविन्यास प्रतीत नहीं होता है):

let x = str.substringWithRange(NSMakeRange(0, 3))

विचार?


चूंकि स्ट्रिंग एनएसएसटींग के लिए एक पुल प्रकार है, इसलिए "पुरानी" विधियों को काम करना चाहिए, लेकिन यह स्पष्ट नहीं है कि - उदाहरण के लिए, यह या तो काम नहीं करता है (वैध वाक्यविन्यास प्रतीत नहीं होता है):

 let x = str.substringWithRange(NSMakeRange(0, 3))

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

// delete all spaces from Swift String stateName
stateName = stateName.stringByReplacingOccurrencesOfString(" ", withString:"")

लेकिन, जैसा कि अक्सर होता है, "मुझे अपना मोोजो काम मिल गया 'लेकिन यह सिर्फ आप पर काम नहीं करता है।" आप बस दुर्लभ मामलों में से एक चुनने के लिए हुआ जहां समानांतर नामित स्विफ्ट विधि मौजूद है , और इस तरह के मामले में, स्विफ्ट विधि उद्देश्य-सी विधि को ओवरहाइड करता है। इस प्रकार, जब आप str.substringWithRange कहते हैं, स्विफ्ट सोचता है कि आप str.substringWithRange विधि की बजाय स्विफ्ट विधि का मतलब है - और फिर आप को रोक दिया गया है, क्योंकि स्विफ्ट विधि एक Range<String.Index> अपेक्षा करती है, और आपको नहीं पता कि कैसे बनाना है उनमें से एक।

स्विफ्ट को स्पष्ट रूप से कास्टिंग करके स्विफ्ट को इस तरह से ओवरहेड करने से रोकने का आसान तरीका है:

let x = (str as NSString).substringWithRange(NSMakeRange(0, 3))

ध्यान दें कि यहां कोई महत्वपूर्ण अतिरिक्त कार्य शामिल नहीं है। "कास्ट" का मतलब "कन्वर्ट" नहीं है; स्ट्रिंग प्रभावी रूप से एक एनएसएसटींग है। हम केवल स्विफ्ट को बता रहे हैं कि कोड की इस पंक्ति के प्रयोजनों के लिए इस चर को कैसे देखें

इस पूरी बात का वास्तव में अजीब हिस्सा यह है कि स्विफ्ट विधि, जो इस समस्या को जन्म देती है, अनियंत्रित है। मुझे नहीं पता कि यह कहां परिभाषित किया गया है; यह एनएसएसटींग हेडर में नहीं है और यह स्विफ्ट हेडर में भी नहीं है।


स्विफ्ट 2

सरल

let str = "My String"
let subStr = str[str.startIndex.advancedBy(3)...str.startIndex.advancedBy(7)]
//"Strin"

स्विफ्ट 3

let startIndex = str.index(str.startIndex, offsetBy: 3)
let endIndex = str.index(str.startIndex, offsetBy: 7)

str[startIndex...endIndex]       // "Strin"
str.substring(to: startIndex)    // "My "
str.substring(from: startIndex)  // "String"

स्विफ्ट 4

substring(to:) और substring(from:) Swift 4 में बहिष्कृत कर रहे हैं।

String(str[..<startIndex])    // "My "
String(str[startIndex...])    // "String"
String(str[startIndex...endIndex])    // "Strin"

आप substringWithRange विधि का उपयोग कर सकते हैं। यह एक प्रारंभ और अंत स्ट्रिंग। इंडेक्स लेता है।

var str = "Hello, playground"
str.substringWithRange(Range<String.Index>(start: str.startIndex, end: str.endIndex)) //"Hello, playground"

प्रारंभ और अंत सूचकांक को बदलने के लिए, उन्नतबी (एन) का उपयोग करें।

var str = "Hello, playground"
str.substringWithRange(Range<String.Index>(start: str.startIndex.advancedBy(2), end: str.endIndex.advancedBy(-1))) //"llo, playgroun"

आप अभी भी एनएसआरेंज के साथ एनएसएसटींग विधि का उपयोग कर सकते हैं, लेकिन आपको यह सुनिश्चित करना होगा कि आप इस तरह एनएसएसटींग का उपयोग कर रहे हैं:

let myNSString = str as NSString
myNSString.substringWithRange(NSRange(location: 0, length: 3))

नोट: जैसा कि JanX2 ने उल्लेख किया है, यह दूसरी विधि यूनिकोड तारों से सुरक्षित नहीं है।


आप स्विफ्ट स्ट्रिंग एक्सटेंशन में किसी भी सबस्ट्रिंग विधियों का उपयोग कर सकते हैं मैंने https://bit.ly/JString लिखा था।

var string = "hello"
var sub = string.substringFrom(3) // or string[3...5]
println(sub)// "lo"

उदाहरण के लिए मेरे नाम पर पहला नाम (पहली जगह तक) ढूंढने के लिए:

let name = "Joris Kluivers"

let start = name.startIndex
let end = find(name, " ")

if end {
    let firstName = name[start..end!]
} else {
    // no space found
}

start और end प्रकार String.Index के प्रकार हैं और एक Range<String.Index> बनाने के लिए उपयोग किए जाते हैं और सबस्क्रिप्ट Range<String.Index> में उपयोग किया जाता है (यदि मूल स्ट्रिंग में कोई स्थान मिलता है)।

शुरुआती पोस्ट में उपयोग की जाने वाली String.Index को एक पूर्णांक स्थिति से सीधे बनाना मुश्किल है। ऐसा इसलिए है क्योंकि मेरे नाम में प्रत्येक चरित्र बाइट्स में बराबर आकार का होगा। लेकिन अन्य भाषाओं में विशेष उच्चारण का उपयोग करने वाले पात्रों ने कई और बाइट्स का उपयोग किया होगा (उपयोग किए गए एन्कोडिंग के आधार पर)। तो क्या पूर्णांक को पूर्णांक का संदर्भ देना चाहिए?

विधियों succ और pred के तरीकों का उपयोग कर मौजूदा String.Index से एक नया String.Index बनाना संभव है जो सुनिश्चित करेगा कि एन्कोडिंग में अगले कोड बिंदु पर जाने के लिए बाइट्स की सही संख्या को छोड़ दिया जाएगा। हालांकि इस मामले में अंत सूचकांक को खोजने के लिए स्ट्रिंग में पहली जगह के सूचकांक की खोज करना आसान है।


एक बार जब आपको सही वाक्यविन्यास मिल जाए, तो यह किसी भी उत्तर से कहीं अधिक सरल है।

मैं [और] ले जाना चाहता हूँ

let myString = "[ABCDEFGHI]"
let startIndex = advance(myString.startIndex, 1) //advance as much as you like
let endIndex = advance(myString.endIndex, -1)
let range = startIndex..<endIndex
let myNewString = myString.substringWithRange( range )

नतीजा "एबीसीडीएफजीएचआई" शुरू होगा और एंड इंडेक्स का भी इस्तेमाल किया जा सकता है

let mySubString = myString.substringFromIndex(startIndex)

और इसी तरह!

पीएस: जैसा कि टिप्पणियों में संकेत दिया गया है, स्विफ्ट 2 में कुछ वाक्यविन्यास परिवर्तन हैं जो xcode 7 और iOS9 के साथ आता है!

कृपया इस पेज को देखें


खेल के मैदान में इसे आज़माएं

var str:String = "Hello, playground"

let range = Range(start:advance(str.startIndex,1), end: advance(str.startIndex,8))

यह आपको "ello, पी"

हालांकि जहां यह वास्तव में दिलचस्प हो जाता है यह है कि यदि आप खेल के मैदान में स्ट्रिंग की तुलना में अंतिम सूचकांक को बड़ा करते हैं तो यह स्ट्रिंग के बाद परिभाषित किए गए किसी भी तार को दिखाएगा: o

रेंज () एक सामान्य कार्य प्रतीत होता है ताकि इसे उस प्रकार के बारे में जानना आवश्यक हो जिस पर यह काम कर रहा है।

आपको इसे खेल के मैदानों में अपनी रुचि रखने वाली वास्तविक स्ट्रिंग भी देनी होगी क्योंकि ऐसा लगता है कि बाद में उनके परिवर्तनीय नाम के साथ एक अनुक्रम में सभी डंक हैं।

इसलिए

var str:String = "Hello, playground"

var str2:String = "I'm the next string"

let range = Range(start:advance(str.startIndex,1), end: advance(str.startIndex,49))

देता है "ello, playground str मैं अगले string str2 हूँ"

स्ट्रेट को एक चलो के साथ परिभाषित किया गया है भले ही काम करता है

:)


खैर, मेरे पास एक ही समस्या थी और "bridgeToObjectiveC ()" फ़ंक्शन के साथ हल किया गया था:

var helloworld = "Hello World!"
var world = helloworld.bridgeToObjectiveC().substringWithRange(NSMakeRange(6,6))
println("\(world)") // should print World!

कृपया ध्यान दें कि उदाहरण में, NSMakeRange के साथ संयोजन में substringWithRange इंडेक्स 6 (वर्ण "डब्ल्यू") से शुरू होने वाली स्ट्रिंग का हिस्सा लेता है और आगे इंडेक्स 6 + 6 पदों पर परिष्करण (चरित्र "!")

चीयर्स।


नए एक्सकोड 7.0 उपयोग में

//: Playground - noun: a place where people can play

import UIKit

var name = "How do you use String.substringWithRange?"
let range = name.startIndex.advancedBy(0)..<name.startIndex.advancedBy(10)
name.substringWithRange(range)

//OUT:


पहले रेंज, फिर सबस्ट्रिंग बनाएँ। आप fromIndex..<toIndex उपयोग कर सकते हैं fromIndex..<toIndex वाक्यविन्यास इस प्रकार है:

let range = fullString.startIndex..<fullString.startIndex.advancedBy(15) // 15 first characters of the string
let substring = fullString.substringWithRange(range)

यदि आपके पास NSRange , तो NSRange को ब्रिजिंग निर्बाध रूप से काम करता है। उदाहरण के लिए, मैं UITextFieldDelegate साथ कुछ काम कर रहा था और जब मैं यह पूछता हूं कि क्या यह सीमा को प्रतिस्थापित करना चाहिए तो मैं जल्दी से नए स्ट्रिंग मान की गणना करना चाहता था।

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {
    let newString = (textField.text as NSString).stringByReplacingCharactersInRange(range, withString: string)
    println("Got new string: ", newString)
}

यह मेरे खेल के मैदान में काम करता है :)

String(seq: Array(str)[2...4])

रोब नेपियर से एक पृष्ठ लेते हुए, मैंने इन आम स्ट्रिंग एक्सटेंशन विकसित किए, जिनमें से दो हैं:

subscript (r: Range<Int>) -> String
{
    get {
        let startIndex = advance(self.startIndex, r.startIndex)
        let endIndex = advance(self.startIndex, r.endIndex - 1)

        return self[Range(start: startIndex, end: endIndex)]
    }
}

func subString(startIndex: Int, length: Int) -> String
{
    var start = advance(self.startIndex, startIndex)
    var end = advance(self.startIndex, startIndex + length)
    return self.substringWithRange(Range<String.Index>(start: start, end: end))
}

उपयोग:

"Awesome"[3...7] //"some"
"Awesome".subString(3, length: 4) //"some"

संक्षिप्त जवाब यह है कि अभी स्विफ्ट में यह वास्तव में कठिन है। मेरा झुकाव यह है कि इस तरह की चीजों के लिए ऐप्पल को सुविधाजनक तरीकों पर करने के लिए अभी भी काम का एक गुच्छा है।

String.substringWithRange() एक Range<String.Index> पैरामीटर की अपेक्षा कर रहा है, और जहां तक ​​मैं कह सकता हूं कि String.Index प्रकार के लिए जनरेटर विधि नहीं है। आप aString.startIndex मानों को aString.startIndex और aString.endIndex से वापस प्राप्त कर सकते हैं और aString.endIndex .succ() या .pred() को कॉल कर सकते हैं, लेकिन वह पागलपन है।

स्ट्रिंग क्लास पर एक विस्तार के बारे में जो पुराने पुराने Int लेता है?

extension String {
    subscript (r: Range<Int>) -> String {
        get {
            let subStart = advance(self.startIndex, r.startIndex, self.endIndex)
            let subEnd = advance(subStart, r.endIndex - r.startIndex, self.endIndex)
            return self.substringWithRange(Range(start: subStart, end: subEnd))
        }
    }
    func substring(from: Int) -> String {
        let end = countElements(self)
        return self[from..<end]
    }
    func substring(from: Int, length: Int) -> String {
        let end = from + length
        return self[from..<end]
    }
}

let mobyDick = "Call me Ishmael."
println(mobyDick[8...14])             // Ishmael

let dogString = "This 🐶's name is Patch."
println(dogString[5..<6])               // 🐶
println(dogString[5...5])              // 🐶
println(dogString.substring(5))        // 🐶's name is Patch.
println(dogString.substring(5, length: 1))   // 🐶

अद्यतन: स्विफ्ट बीटा 4 नीचे दिए गए मुद्दों को हल करता है!

जैसा कि यह खड़ा है [बीटा 3 और इससे पहले], यहां तक ​​कि स्विफ्ट-देशी तारों में यूनिकोड वर्णों को संभालने के कुछ मुद्दे हैं। ऊपर कुत्ते आइकन काम किया, लेकिन निम्नलिखित नहीं है:

let harderString = "1:1️⃣"
for character in harderString {
    println(character)
}

आउटपुट:

1
:
1
️
⃣

नोट: @airspeedswift इस दृष्टिकोण के व्यापार-बंद पर विशेष रूप से छिपे हुए प्रदर्शन प्रभावों पर कुछ बहुत ही अंतर्दृष्टिपूर्ण बिंदु बनाता है। स्ट्रिंग्स साधारण जानवर नहीं हैं, और किसी विशेष इंडेक्स में आने से ओ (एन) समय लग सकता है, जिसका मतलब है कि एक लूप जो सबस्क्रिप्ट का उपयोग करता है ओ (एन ^ 2) हो सकता है। आपको चेतावनी दी गई है।

आपको केवल एक नया subscript फ़ंक्शन जोड़ने की आवश्यकता है जो एक सीमा लेता है और जहां आप चाहते हैं वहां चलने के लिए advancedBy() का उपयोग करता है:

import Foundation

extension String {
    subscript (r: Range<Int>) -> String {
        get {
            let startIndex = self.startIndex.advancedBy(r.startIndex)
            let endIndex = startIndex.advancedBy(r.endIndex - r.startIndex)

            return self[Range(start: startIndex, end: endIndex)]
        }
    }
}

var s = "Hello, playground"

println(s[0...5]) // ==> "Hello,"
println(s[0..<5]) // ==> "Hello"

(यह निश्चित रूप से भाषा का हिस्सा होना चाहिए। कृपया openradar.appspot.com/radar?id=6373877630369792 )

मस्ती के लिए, आप इंडेक्स पर एक + ऑपरेटर भी जोड़ सकते हैं:

func +<T: ForwardIndex>(var index: T, var count: Int) -> T {
  for (; count > 0; --count) {
    index = index.succ()
  }
  return index
}

s.substringWithRange(s.startIndex+2 .. s.startIndex+5)

(मुझे अभी तक पता नहीं है कि यह एक भाषा का हिस्सा होना चाहिए या नहीं।)


छोटे कोड के साथ आसान समाधान।

एक ऐसा एक्सटेंशन बनाएं जिसमें बुनियादी सबस्ट्रिंगिंग शामिल है जो लगभग सभी अन्य भाषाओं में है:

extension String {
    func subString(start: Int, end: Int) -> String {
        let startIndex = self.index(self.startIndex, offsetBy: start)
        let endIndex = self.index(startIndex, offsetBy: end)

        let finalString = self.substring(from: startIndex)
        return finalString.substring(to: endIndex)
    }
}

बस इसे साथ बुलाओ

someString.subString(start: 0, end: 6)

स्विफ्ट 2.0

सरल:

let myString = "full text container"
let substring = myString[myString.startIndex..<myString.startIndex.advancedBy(3)] // prints: ful

स्विफ्ट 3.0

let substring = myString[myString.startIndex..<myString.index(myString.startIndex, offsetBy: 3)] // prints: ful

स्विफ्ट 4.0

सबस्ट्रिंग ऑपरेशंस स्ट्रिंग के बजाए सबस्ट्रिंग प्रकार का एक उदाहरण देता है।

let substring = myString[myString.startIndex..<myString.index(myString.startIndex, offsetBy: 3)] // prints: ful

// Convert the result to a String for long-term storage.
let newString = String(substring)

स्विफ्ट 2.0 में सबस्ट्रिंग कैसे प्राप्त करें के लिए नमूना कोड

(i) सूचकांक शुरू करने से सबस्ट्रिंग

इनपुट: -

var str = "Swift is very powerful language!"
print(str)

str = str.substringToIndex(str.startIndex.advancedBy(5))
print(str)

आउटपुट: -

Swift is very powerful language!
Swift

(ii) विशेष सूचकांक से सबस्ट्रिंग

इनपुट: -

var str = "Swift is very powerful language!"
print(str)

str = str.substringFromIndex(str.startIndex.advancedBy(6)).substringToIndex(str.startIndex.advancedBy(2))
print(str)

आउटपुट: -

Swift is very powerful language!
is

मुझे आशा है कि यह आपकी मदद करेगा!


यदि आपको प्रदर्शन की परवाह नहीं है ... यह शायद स्विफ्ट 4 में सबसे संक्षिप्त समाधान है

extension String {
    subscript(range: CountableClosedRange<Int>) -> String {
        return enumerated().filter{$0.offset >= range.first! && $0.offset < range.last!}
            .reduce(""){$0 + String($1.element)}
    }
}

यह आपको ऐसा कुछ करने में सक्षम बनाता है:

let myStr = "abcd"
myStr[0..<2] // produces "ab"

सरल विस्तार के लिए String:

extension String {

    func substringToIndex(index: Int) -> String {
        return self[startIndex...startIndex.advancedBy(min(index, characters.count - 1))]
    }
}




swift