स्विफ्ट स्ट्रिंग में चरित्र का सूचकांक ढूँढना


203

हार मानने का वक्त है ...

ऑब्जेक्टिव-सी में, मैं कुछ इस तरह का उपयोग कर सकता हूं:

NSString* str = @"abcdefghi";
[str rangeOfString:@"c"].location; // 2

स्विफ्ट में, मुझे कुछ समान दिखाई देता है:

var str = "abcdefghi"
str.rangeOfString("c").startIndex

... लेकिन यह सिर्फ मुझे एक देता है String.Index, जिसे मैं मूल स्ट्रिंग में वापस लाने के लिए उपयोग कर सकता हूं, लेकिन इससे कोई स्थान नहीं निकाल सकता।

एफडब्ल्यूआईडब्ल्यू, जिसमें String.Indexएक निजी आइवर है जिसे कहा जाता है _positionकि इसमें सही मूल्य है। मैं अभी नहीं देखता कि यह कैसे उजागर होता है।

मुझे पता है कि मैं आसानी से खुद को स्ट्रिंग में जोड़ सकता हूं। मुझे इस नए एपीआई में जो कुछ याद आ रहा है, उसके बारे में अधिक उत्सुक हूं।


यहाँ एक GitHub परियोजना है जिसमें स्विफ्ट स्ट्रिंग हेरफेर के लिए बहुत सारे विस्तार विधियाँ हैं: github.com/iamjono/SwiftString
RenniePet

सबसे अच्छा कार्यान्वयन जो मैंने यहां पाया है: stackoverflow.com/a/32306142/4550651
कार्लोस गार्सिया

क्या आपको यूनिकोड कोडपॉइंट्स और एक्सटेंडेड ग्रापेम क्लस्टर के बीच अंतर करने की आवश्यकता है?
बेन लेगिएरो

जवाबों:


248

आप एकमात्र ऐसे व्यक्ति नहीं हैं जो समाधान नहीं ढूंढ सके।

Stringलागू नहीं करता है RandomAccessIndexType। शायद इसलिए कि वे अलग-अलग बाइट लंबाई वाले पात्रों को सक्षम करते हैं। इसलिए हमें वर्णों की संख्या प्राप्त करने के लिए string.characters.count( countया countElementsस्विफ्ट 1.x में) का उपयोग करना होगा। यह भी पदों पर लागू होता है। _positionशायद बाइट्स के कच्चे सरणी में एक सूचकांक है और वे उस बेनकाब करने के लिए नहीं करना चाहती। इसका String.Indexमतलब हमें पात्रों के बीच में बाइट्स तक पहुंचने से बचाने के लिए है।

अर्थ यह है कि किसी भी सूचकांक आपको मिल से बनाया जाना चाहिए कि String.startIndexया String.endIndex( String.Indexऔजार BidirectionalIndexType)। किसी भी अन्य सूचकांकों का उपयोग successorया predecessorतरीकों से बनाया जा सकता है ।

अब हमें सूचकांकों में मदद करने के लिए, तरीकों का एक समूह है (स्विफ्ट 1.x में फ़ंक्शन):

स्विफ्ट 4.x

let text = "abc"
let index2 = text.index(text.startIndex, offsetBy: 2) //will call succ 2 times
let lastChar: Character = text[index2] //now we can index!

let characterIndex2 = text.index(text.startIndex, offsetBy: 2)
let lastChar2 = text[characterIndex2] //will do the same as above

let range: Range<String.Index> = text.range(of: "b")!
let index: Int = text.distance(from: text.startIndex, to: range.lowerBound)

स्विफ्ट 3.0

let text = "abc"
let index2 = text.index(text.startIndex, offsetBy: 2) //will call succ 2 times
let lastChar: Character = text[index2] //now we can index!

let characterIndex2 = text.characters.index(text.characters.startIndex, offsetBy: 2)
let lastChar2 = text.characters[characterIndex2] //will do the same as above

let range: Range<String.Index> = text.range(of: "b")!
let index: Int = text.distance(from: text.startIndex, to: range.lowerBound)

स्विफ्ट 2.x

let text = "abc"
let index2 = text.startIndex.advancedBy(2) //will call succ 2 times
let lastChar: Character = text[index2] //now we can index!
let lastChar2 = text.characters[index2] //will do the same as above

let range: Range<String.Index> = text.rangeOfString("b")!
let index: Int = text.startIndex.distanceTo(range.startIndex) //will call successor/predecessor several times until the indices match

स्विफ्ट 1.x

let text = "abc"
let index2 = advance(text.startIndex, 2) //will call succ 2 times
let lastChar: Character = text[index2] //now we can index!

let range = text.rangeOfString("b")
let index: Int = distance(text.startIndex, range.startIndex) //will call succ/pred several times

साथ काम करना String.Indexबोझिल है लेकिन पूर्णांकों द्वारा अनुक्रमणिका के लिए एक आवरण का उपयोग करना (देखें https://stackoverflow.com/a/25152652/669586 ) खतरनाक है क्योंकि यह वास्तविक अनुक्रमण की अक्षमता को छुपाता है।

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

स्विफ्ट 2.x

let text: String = "abc"
let text2: String = "🎾🏇🏈"

let range = text.rangeOfString("b")!

//can randomly return a bad substring or throw an exception
let substring: String = text2[range]

//the correct solution
let intIndex: Int = text.startIndex.distanceTo(range.startIndex)
let startIndex2 = text2.startIndex.advancedBy(intIndex)
let range2 = startIndex2...startIndex2

let substring: String = text2[range2]

स्विफ्ट 1.x

let text: String = "abc"
let text2: String = "🎾🏇🏈"

let range = text.rangeOfString("b")

//can randomly return nil or a bad substring 
let substring: String = text2[range] 

//the correct solution
let intIndex: Int = distance(text.startIndex, range.startIndex)    
let startIndex2 = advance(text2.startIndex, intIndex)
let range2 = startIndex2...startIndex2

let substring: String = text2[range2]  

1
अजीब लगता है कि यह हो सकता है, यह जवाब लगता है। उम्मीद है कि वे दो रेंज फ़ंक्शंस इसे अंतिम रिलीज़ से कुछ समय पहले प्रलेखन में शामिल करेंगे।
मैट विल्डिंग

किस प्रकार का rangeहैvar range = text.rangeOfString("b")
zaph

5
@Zaph हर Collectionएक है typealias IndexType। सरणियों के लिए, इसे इस रूप में परिभाषित किया गया है Int, जैसा कि Stringइसे परिभाषित किया गया है String.Index। सरणियाँ और स्ट्रिंग्स दोनों भी पर्वतमाला (उप-संस्करण और सबस्ट्रिंग बनाने के लिए) का उपयोग कर सकते हैं। रेंज एक विशेष प्रकार है Range<T>। तार के लिए, यह Range<String.Index>, सरणियों के लिए है Range<Int>
सुल्तान

1
में Swift 2.0, distance(text.startIndex, range.startIndex)बन जाता हैtext.startIndex.distanceTo(range.startIndex)
superarts.org

1
@devios String, बिल्कुल NSStringफाउंडेशन की तरह एक विधि है hasPrefix(_:)
सुल्तान

86

स्विफ्ट 3.0 इसे और अधिक क्रियात्मक बनाता है:

let string = "Hello.World"
let needle: Character = "."
if let idx = string.characters.index(of: needle) {
    let pos = string.characters.distance(from: string.startIndex, to: idx)
    print("Found \(needle) at position \(pos)")
}
else {
    print("Not found")
}

एक्सटेंशन:

extension String {
    public func index(of char: Character) -> Int? {
        if let idx = characters.index(of: char) {
            return characters.distance(from: startIndex, to: idx)
        }
        return nil
    }
}

में स्विफ्ट 2.0 यह आसान हो गया है:

let string = "Hello.World"
let needle: Character = "."
if let idx = string.characters.indexOf(needle) {
    let pos = string.startIndex.distanceTo(idx)
    print("Found \(needle) at position \(pos)")
}
else {
    print("Not found")
}

एक्सटेंशन:

extension String {
    public func indexOfCharacter(char: Character) -> Int? {
        if let idx = self.characters.indexOf(char) {
            return self.startIndex.distanceTo(idx)
        }
        return nil
    }
}

स्विफ्ट 1.x कार्यान्वयन:

शुद्ध स्विफ्ट समाधान के लिए एक का उपयोग कर सकते हैं:

let string = "Hello.World"
let needle: Character = "."
if let idx = find(string, needle) {
    let pos = distance(string.startIndex, idx)
    println("Found \(needle) at position \(pos)")
}
else {
    println("Not found")
}

के विस्तार के रूप में String:

extension String {
    public func indexOfCharacter(char: Character) -> Int? {
        if let idx = find(self, char) {
            return distance(self.startIndex, idx)
        }
        return nil
    }
}

1
पात्रों को पदावनत किया जाता है !!
शिवम पोखरियाल

23
extension String {

    // MARK: - sub String
    func substringToIndex(index:Int) -> String {
        return self.substringToIndex(advance(self.startIndex, index))
    }
    func substringFromIndex(index:Int) -> String {
        return self.substringFromIndex(advance(self.startIndex, index))
    }
    func substringWithRange(range:Range<Int>) -> String {
        let start = advance(self.startIndex, range.startIndex)
        let end = advance(self.startIndex, range.endIndex)
        return self.substringWithRange(start..<end)
    }

    subscript(index:Int) -> Character{
        return self[advance(self.startIndex, index)]
    }
    subscript(range:Range<Int>) -> String {
        let start = advance(self.startIndex, range.startIndex)
            let end = advance(self.startIndex, range.endIndex)
            return self[start..<end]
    }


    // MARK: - replace
    func replaceCharactersInRange(range:Range<Int>, withString: String!) -> String {
        var result:NSMutableString = NSMutableString(string: self)
        result.replaceCharactersInRange(NSRange(range), withString: withString)
        return result
    }
}

7
ऐसा करने के बारे में सोचा, लेकिन मुझे लगता है कि यह एक समस्या है कि यह स्ट्रिंग एक्सेस के शब्दार्थ को छुपाता है। किसी सूची के लिए एपीआई की तरह दिखने वाली लिंक्ड सूची तक पहुँचने के लिए एक एपीआई बनाने की कल्पना करें। लोग भयावह अयोग्य कोड लिखना चाहेंगे।
एरिक इंगहेम

16

मुझे यह समाधान स्विफ्ट 2 के लिए मिला है:

var str = "abcdefghi"
let indexForCharacterInString = str.characters.indexOf("c") //returns 2

जब str = "abcdefgchi" पर सूचकांक क्या होगा
वत्सल शुक्ला

10

स्विफ्ट 5.0

public extension String {  
  func indexInt(of char: Character) -> Int? {
    return firstIndex(of: char)?.utf16Offset(in: self)
  }
}

स्विफ्ट 4.0

public extension String {  
  func indexInt(of char: Character) -> Int? {
    return index(of: char)?.encodedOffset        
  }
}

वापसी सूचकांक (का: तत्व) .map {target.distance (से: startIndex, को: $ 0)}
frogcjn

8

मुझे यकीन नहीं है कि String.Index से स्थिति कैसे निकाली जाए, लेकिन अगर आप कुछ ऑब्जेक्टिव-सी फ्रेमवर्क पर वापस आने को तैयार हैं, तो आप ऑब्जेक्टिव-सी पर पुल कर सकते हैं और इसे उसी तरह से कर सकते हैं जैसे आप करते थे।

"abcdefghi".bridgeToObjectiveC().rangeOfString("c").location

ऐसा लगता है कि कुछ NSString पद्धतियाँ अभी तक स्ट्रिंग में रखी नहीं गई हैं (या शायद नहीं होंगी)। दिमाग में भी आता है।


यह वास्तव में प्रतीत होता है कि संकलक के लिए रिटर्न मान के स्थान की संपत्ति तक पहुंच एक एनएसएसट्रिंग प्रकार का अनुमान लगाने के लिए पर्याप्त है, इसलिए bridgeToObjectiveC()कॉल की आवश्यकता नहीं है। मेरी समस्या केवल तब प्रकट होती है जब rangeOfStringपहले से मौजूद स्विफ्ट स्ट्रिंग पर कॉल किया जाता है। एक एपीआई मुद्दे की तरह लगता है ...
मैट विल्डिंग

वह दिलचस्प है। मुझे नहीं पता था कि यह उन मामलों में था। खैर जब यह पहले से ही एक स्ट्रिंग है तो आप हमेशा पुल का उपयोग कर सकते हैं।
कॉनर

8

यहाँ एक साफ़ स्ट्रिंग एक्सटेंशन है जो प्रश्न का उत्तर देता है:

स्विफ्ट 3:

extension String {
    var length:Int {
        return self.characters.count
    }

    func indexOf(target: String) -> Int? {

        let range = (self as NSString).range(of: target)

        guard range.toRange() != nil else {
            return nil
        }

        return range.location

    }
    func lastIndexOf(target: String) -> Int? {



        let range = (self as NSString).range(of: target, options: NSString.CompareOptions.backwards)

        guard range.toRange() != nil else {
            return nil
        }

        return self.length - range.location - 1

    }
    func contains(s: String) -> Bool {
        return (self.range(of: s) != nil) ? true : false
    }
}

स्विफ्ट 2.2:

extension String {    
    var length:Int {
        return self.characters.count
    }

    func indexOf(target: String) -> Int? {

        let range = (self as NSString).rangeOfString(target)

        guard range.toRange() != nil else {
            return nil
        }

        return range.location

    }
    func lastIndexOf(target: String) -> Int? {



        let range = (self as NSString).rangeOfString(target, options: NSStringCompareOptions.BackwardsSearch)

        guard range.toRange() != nil else {
            return nil
        }

        return self.length - range.location - 1

    }
    func contains(s: String) -> Bool {
        return (self.rangeOfString(s) != nil) ? true : false
    }
}

7

आप इस तरह से एक स्ट्रिंग में एक चरित्र के अनुक्रमित पा सकते हैं,

extension String {

  func indexes(of character: String) -> [Int] {

    precondition(character.count == 1, "Must be single character")

    return self.enumerated().reduce([]) { partial, element  in
      if String(element.element) == character {
        return partial + [element.offset]
      }
      return partial
    }
  }

}

जो [String.Distance] में परिणाम देता है। [इंट], जैसे

"apple".indexes(of: "p") // [1, 2]
"element".indexes(of: "e") // [0, 2, 4]
"swift".indexes(of: "j") // []

5

यदि आप परिचित NSString का उपयोग करना चाहते हैं, तो आप इसे स्पष्ट रूप से घोषित कर सकते हैं:

var someString: NSString = "abcdefghi"

var someRange: NSRange = someString.rangeOfString("c")

मैं अभी तक निश्चित नहीं हूं कि स्विफ्ट में यह कैसे करना है।


1
यह निश्चित रूप से काम करता है, और ऐसा लगता है कि कंपाइलर आपके लिए NSString प्रकारों का सामना करने में काफी आक्रामक है। मैं वास्तव में ऐसा करने के एक शुद्ध स्विफ्ट तरीके की उम्मीद कर रहा था, क्योंकि यह एक सामान्य पर्याप्त उपयोग के मामले जैसा लगता है।
मैट विल्डिंग

हाँ, मैं चारों ओर देख रहा हूँ, लेकिन मैं इसे नहीं देखता। यह संभव है कि वे ओबीजेसी द्वारा समर्थित क्षेत्रों पर ध्यान केंद्रित न करें क्योंकि वे इन अंतरालों को खो सकते हैं w / o बहुत अधिक क्षमताओं को खो दिया है। जरा जोर से सोचिए :)
लोगन

4

आप जानना चाहते हैं स्थिति एक के चरित्र एक के रूप में एक स्ट्रिंग में पूर्णांक मूल्य उपयोग करें:

let loc = newString.range(of: ".").location

स्विफ्ट 5 value of type 'Range<String.Index>?' has no member 'location':।
नेफ जुएल

3

मुझे पता है कि यह पुराना है और एक उत्तर को स्वीकार कर लिया गया है, लेकिन आप कोड का उपयोग करके कोड की कुछ पंक्तियों में स्ट्रिंग का सूचकांक पा सकते हैं:

var str : String = "abcdefghi"
let characterToFind: Character = "c"
let characterIndex = find(str, characterToFind)  //returns 2

स्विफ्ट स्ट्रिंग्स के बारे में कुछ अन्य बेहतरीन जानकारी यहाँ स्ट्रिंग्स इन स्विफ्ट


findस्विफ्ट 3 में उपलब्ध नहीं है
आमिर

2

इसने मेरे लिए काम किया,

var loc = "abcdefghi".rangeOfString("c").location
NSLog("%d", loc);

इसने भी काम किया,

var myRange: NSRange = "abcdefghi".rangeOfString("c")
var loc = myRange.location
NSLog("%d", loc);

ये दोनों किसी भी तरह से एनएसएसट्रिंग के व्यवहार पर कमतर हैं। मेरे खेल के मैदान में, मैं स्ट्रिंग के लिए एक मध्यवर्ती चर का उपयोग कर रहा था। var str = "abcdef"; str.rangeOfString("c").locationString.Index के बारे में एक त्रुटि उठाता है, जिसका नाम स्थान नहीं है ...
मैट विल्डिंग

1
यह सिर्फ इसलिए काम करता है क्योंकि "स्ट्रिंग" NSString है और स्विफ्ट के स्ट्रिंग नहीं है
gderaco

2

ऑब्जेक्टिव-सी में एनएसएसटीरिंग की तुलना में वेरिएबल टाइप स्ट्रिंग इन स्विफ्ट में अलग-अलग कार्य होते हैं। और जैसा कि सुल्तान ने उल्लेख किया है,

स्विफ्ट स्ट्रिंग रैंडमएक्स्टइंडेक्स लागू नहीं करता है

आप जो कर सकते हैं, वह स्ट्रिंग के प्रकार NSString के लिए किया जा सकता है (यह स्विफ्ट में मान्य है)। यह आपको NSString में कार्यों तक पहुंच देगा।

var str = "abcdefghi" as NSString
str.rangeOfString("c").locationx   // returns 2

2

यदि आप इसके बारे में सोचते हैं, तो आपको वास्तव में स्थान के सटीक इंट संस्करण की आवश्यकता नहीं है। रेंज या यहां तक ​​कि String.Index जरूरत पड़ने पर फिर से सबस्ट्रिंग प्राप्त करने के लिए पर्याप्त है:

let myString = "hello"

let rangeOfE = myString.rangeOfString("e")

if let rangeOfE = rangeOfE {
    myString.substringWithRange(rangeOfE) // e
    myString[rangeOfE] // e

    // if you do want to create your own range
    // you can keep the index as a String.Index type
    let index = rangeOfE.startIndex
    myString.substringWithRange(Range<String.Index>(start: index, end: advance(index, 1))) // e

    // if you really really need the 
    // Int version of the index:
    let numericIndex = distance(index, advance(index, 1)) // 1 (type Int)
}

मेरे लिए सबसे अच्छा उत्तर यह है कि func indexOf (लक्ष्य: स्ट्रिंग) -> Int {वापसी (N के रूप में स्वयं) .rangeOfString (लक्ष्य) .location}
YannSteph

2

सबसे सरल तरीका है:

में स्विफ्ट 3 :

 var textViewString:String = "HelloWorld2016"
    guard let index = textViewString.characters.index(of: "W") else { return }
    let mentionPosition = textViewString.distance(from: index, to: textViewString.endIndex)
    print(mentionPosition)

1

स्ट्रिंग NSString के लिए एक पुल प्रकार है, इसलिए जोड़ें

import Cocoa

अपनी स्विफ्ट फ़ाइल में और सभी "पुराने" तरीकों का उपयोग करें।


1

सोचने के संदर्भ में इसे एक आमंत्रण कहा जा सकता है। आपको पता है कि दुनिया फ्लैट के बजाय गोल है। "आपको वास्तव में चरित्र के INDEX को जानने की जरूरत नहीं है कि इसके साथ क्या करना है।" और एक सी प्रोग्रामर के रूप में मैंने पाया कि इसे भी लेना मुश्किल है! आपकी लाइन "इंडेक्स = अक्षर.चट्रैक्टर्स.इंडेक्सऑफ़ (" सी ")!" अपने आप में काफी है। उदाहरण के लिए ग को आप उपयोग कर सकते हैं ... (खेल का मैदान पेस्ट में)

    var letters = "abcdefg"
  //let index = letters.rangeOfString("c")!.startIndex //is the same as
    let index = letters.characters.indexOf("c")!
    range = letters.characters.indexOf("c")!...letters.characters.indexOf("c")!
    letters.removeRange(range)
    letters

हालाँकि, यदि आप एक इंडेक्स चाहते हैं तो आपको एक वास्तविक INDEX वापस करना होगा एक Int नहीं क्योंकि एक Int मान किसी भी व्यावहारिक उपयोग के लिए अतिरिक्त चरणों की आवश्यकता होगी। ये एक्सटेंशन एक इंडेक्स, एक विशिष्ट वर्ण की एक गिनती और एक रेंज जो इस खेल के मैदान के प्लग-इन-सक्षम कोड को प्रदर्शित करते हैं, लौटाते हैं।

extension String
{
    public func firstIndexOfCharacter(aCharacter: Character) -> String.CharacterView.Index? {

        for index in self.characters.indices {
            if self[index] == aCharacter {
                return index
            }

        }
        return nil
    }

    public func returnCountOfThisCharacterInString(aCharacter: Character) -> Int? {

        var count = 0
        for letters in self.characters{

            if aCharacter == letters{

                count++
            }
        }
        return count
    }


    public func rangeToCharacterFromStart(aCharacter: Character) -> Range<Index>? {

        for index in self.characters.indices {
            if self[index] == aCharacter {
                let range = self.startIndex...index
                return range
            }

        }
        return nil
    }

}



var MyLittleString = "MyVery:important String"

var theIndex = MyLittleString.firstIndexOfCharacter(":")

var countOfColons = MyLittleString.returnCountOfThisCharacterInString(":")

var theCharacterAtIndex:Character = MyLittleString[theIndex!]

var theRange = MyLittleString.rangeToCharacterFromStart(":")
MyLittleString.removeRange(theRange!)

1

स्विफ्ट 4 पूर्ण समाधान:

ऑफ़सेटइंडेक्सटेबल कॉलेक्शन (इंट इंडेक्स का उपयोग करके स्ट्रिंग)

https://github.com/frogcjn/OffsetIndexableCollection-String-Int-Indexable-

let a = "01234"

print(a[0]) // 0
print(a[0...4]) // 01234
print(a[...]) // 01234

print(a[..<2]) // 01
print(a[...2]) // 012
print(a[2...]) // 234
print(a[2...3]) // 23
print(a[2...2]) // 2

if let number = a.index(of: "1") {
    print(number) // 1
    print(a[number...]) // 1234
}

if let number = a.index(where: { $0 > "1" }) {
    print(number) // 2
}

1

विस्तार स्ट्रिंग {

//Fucntion to get the index of a particular string
func index(of target: String) -> Int? {
    if let range = self.range(of: target) {
        return characters.distance(from: startIndex, to: range.lowerBound)
    } else {
        return nil
    }
}
//Fucntion to get the last index of occurence of a given string
func lastIndex(of target: String) -> Int? {
    if let range = self.range(of: target, options: .backwards) {
        return characters.distance(from: startIndex, to: range.lowerBound)
    } else {
        return nil
    }
}

}


1

स्विफ्ट 5

प्रतिस्थापन के सूचकांक का पता लगाएं

let str = "abcdecd"
if let range: Range<String.Index> = str.range(of: "cd") {
    let index: Int = str.distance(from: str.startIndex, to: range.lowerBound)
    print("index: ", index) //index: 2
}
else {
    print("substring not found")
}

चरित्र के सूचकांक का पता लगाएं

let str = "abcdecd"
if let firstIndex = str.firstIndex(of: "c") {
    let index: Int = str.distance(from: str.startIndex, to: firstIndex)
    print("index: ", index)   //index: 2
}
else {
    print("symbol not found")
}

0

यदि आप कैरेक्टर या स्ट्रिंग चेकआउट का सूचकांक प्राप्त करने के लिए आसान तरीका खोज रहे हैं तो इस लाइब्रेरी http://www.dollarswift.org/#indexof-char-character-int

आप किसी अन्य स्ट्रिंग के साथ-साथ या रेगेक्स पैटर्न का उपयोग करके एक स्ट्रिंग से इंडेक्सऑफ प्राप्त कर सकते हैं


0

स्विफ्ट 2 के साथ एक स्ट्रिंग में एक विकल्प के सूचकांक प्राप्त करने के लिए:

let text = "abc"
if let range = text.rangeOfString("b") {
   var index: Int = text.startIndex.distanceTo(range.startIndex) 
   ...
}

0

तेजी से 2.0 में

var stringMe="Something In this.World"
var needle="."
if let idx = stringMe.characters.indexOf(needle) {
    let pos=stringMe.substringFromIndex(idx)
    print("Found \(needle) at position \(pos)")
}
else {
    print("Not found")
}

0
let mystring:String = "indeep";
let findCharacter:Character = "d";

if (mystring.characters.contains(findCharacter))
{
    let position = mystring.characters.indexOf(findCharacter);
    NSLog("Position of c is \(mystring.startIndex.distanceTo(position!))")

}
else
{
    NSLog("Position of c is not found");
}

0

मैं निम्नलिखित के साथ खेलता हूं

extension String {
    func allCharactes() -> [Character] {
         var result: [Character] = []
         for c in self.characters {
             result.append(c)
         }
         return 
    }
}

जब तक मैं प्रदान की गई समझ नहीं लेता तब तक यह सिर्फ चरित्र सरणी है

और साथ

let c = Array(str.characters)

यह क्या पूरा करता है? आपका पहला कोड ब्लॉक दूसरे से बेहतर कैसे है?
बेन लेगिएरो

0

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

let index = string.characters.index(of: ".")
let intIndex = string.distance(from: string.startIndex, to: index)


0

एक String.Indexमें बदल जाने के विषय पर Int, यह विस्तार मेरे लिए काम करता है:

public extension Int {
    /// Creates an `Int` from a given index in a given string
    ///
    /// - Parameters:
    ///    - index:  The index to convert to an `Int`
    ///    - string: The string from which `index` came
    init(_ index: String.Index, in string: String) {
        self.init(string.distance(from: string.startIndex, to: index))
    }
}

इस प्रश्न के लिए प्रासंगिक उदाहरण का उपयोग करें:

var testString = "abcdefg"

Int(testString.range(of: "c")!.lowerBound, in: testString)     // 2

testString = "🇨🇦🇺🇸🇩🇪👩‍👩‍👧‍👦\u{1112}\u{1161}\u{11AB}"

Int(testString.range(of: "🇨🇦🇺🇸🇩🇪")!.lowerBound, in: testString) // 0
Int(testString.range(of: "👩‍👩‍👧‍👦")!.lowerBound, in: testString)    // 1
Int(testString.range(of: "한")!.lowerBound, in: testString)    // 5

जरूरी:

जैसा कि आप बता सकते हैं, यह समूहों ने अंगूर के समूहों को बढ़ाया और पात्रों को अलग तरह से जोड़ा String.Index। बेशक, यही कारण है कि हमारे पास है String.Index। आपको यह ध्यान रखना चाहिए कि यह विधि समूहों को एकवचन वर्ण मानती है, जो सही होने के करीब है। यदि आपका लक्ष्य यूनिकोड कोड पॉइंट द्वारा एक स्ट्रिंग को विभाजित करना है, तो यह आपके लिए समाधान नहीं है।


0

में स्विफ्ट 2.0 , निम्नलिखित समारोह एक दिया चरित्र से पहले सबस्ट्रिंग देता है।

func substring(before sub: String) -> String {
    if let range = self.rangeOfString(sub),
        let index: Int = self.startIndex.distanceTo(range.startIndex) {
        return sub_range(0, index)
    }
    return ""
}

0

आप किसी वर्ण की अनुक्रमणिका संख्या को इसके साथ स्ट्रिंग में पा सकते हैं:

var str = "abcdefghi"
if let index = str.firstIndex(of: "c") {
    let distance = str.distance(from: str.startIndex, to: index)
    // distance is 2
}

0

मेरे दृष्टिकोण के अनुसार, तर्क को जानने का बेहतर तरीका नीचे ही है

 let testStr: String = "I love my family if you Love us to tell us I'm with you"
 var newStr = ""
 let char:Character = "i"

 for value in testStr {
      if value == char {
         newStr = newStr + String(value)
   }

}
print(newStr.count)
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.