110

मैं एक स्ट्रिंग को दूसरी स्ट्रिंग में बदलने के लिए सबसे अच्छा / सरल तरीका सीखना चाहता हूं लेकिन केवल एक सबसेट के साथ, शुरुआत में शुरू होता है और एक चरित्र के अंतिम सूचकांक में जाता है।

उदाहरण के लिए, "www.stackoverflow.com" को "www.stackoverflow.com" में बदलें। कोड स्निपेट क्या करेगा, और सबसे अधिक स्विफ्ट-जैसा होगा? (मुझे उम्मीद है कि यह एक बहस नहीं लाएगा, लेकिन मैं स्विफ्ट में सबस्ट्रिंग को कैसे संभाल सकता हूं, इस बारे में अच्छा सबक नहीं पा सकता हूं।

ios swift

— जेसन होकर
स्रोत

202

बस पिछड़े तक पहुंच रही है

सबसे अच्छा तरीका संपत्ति और वैश्विक फ़ंक्शन के लिए substringToIndexसंयुक्त का उपयोग करना है।endIndexadvance

var string1 = "www.stackoverflow.com"

var index1 = advance(string1.endIndex, -4)

var substring1 = string1.substringToIndex(index1)

पीछे से शुरू होने वाली स्ट्रिंग की तलाश है

का उपयोग करें rangeOfStringऔर करने के optionsलिए सेट करें.BackwardsSearch

var string2 = "www.stackoverflow.com"

var index2 = string2.rangeOfString(".", options: .BackwardsSearch)?.startIndex

var substring2 = string2.substringToIndex(index2!)

कोई एक्सटेंशन नहीं, शुद्ध मुहावरेदार स्विफ्ट

स्विफ्ट 2.0

advanceअब का एक हिस्सा है Indexऔर कहा जाता है advancedBy। आप इसे पसंद करते हैं:

var string1 = "www.stackoverflow.com"

var index1 = string1.endIndex.advancedBy(-4)

var substring1 = string1.substringToIndex(index1)

स्विफ्ट 3.0

आप कॉल नहीं कर सकते हैं advancedByपर एक Stringहै क्योंकि यह चर आकार तत्व है। आपको उपयोग करना होगा index(_, offsetBy:)।

var string1 = "www.stackoverflow.com"

var index1 = string1.index(string1.endIndex, offsetBy: -4)

var substring1 = string1.substring(to: index1)

बहुत सारी चीजों का नाम बदल दिया गया है। मामले कैमलकेस में लिखे startIndexगए , बन गए lowerBound।

var string2 = "www.stackoverflow.com"

var index2 = string2.range(of: ".", options: .backwards)?.lowerBound

var substring2 = string2.substring(to: index2!)

इसके अलावा, मैं बल प्रयोग की सिफारिश नहीं करेंगे index2। आप वैकल्पिक बंधन का उपयोग कर सकते हैं या map। व्यक्तिगत रूप से, मैं उपयोग करना पसंद करता हूं map:

var substring3 = index2.map(string2.substring(to:))

स्विफ्ट 4

स्विफ्ट 3 संस्करण अभी भी मान्य है लेकिन अब आप अनुक्रमणिका श्रेणियों के साथ सदस्यता का उपयोग कर सकते हैं:

let string1 = "www.stackoverflow.com"

let index1 = string1.index(string1.endIndex, offsetBy: -4)

let substring1 = string1[..<index1]

दूसरा दृष्टिकोण अपरिवर्तित रहता है:

let string2 = "www.stackoverflow.com"

let index2 = string2.range(of: ".", options: .backwards)?.lowerBound

let substring3 = index2.map(string2.substring(to:))

— fpg1503
स्रोत

1

धन्यवाद @ fpg1503 यह उसी तरह का उत्तर है जिसे मैं खोजना चाहता था। अन्य जवाबों ने मुझे भाषा में सिखाया या याद दिलाया, लेकिन यह वह तरीका है जिसका उपयोग मैं अपनी समस्या को हल करने के लिए करूंगा।

— जेसन हॉकर

1

स्विफ्ट 2.0 का उपयोग, string1.endIndex.advancedBy(-4)मेरे लिए काम कर रहा हैadvance

— एलेक्स कोशी

92

क्या गंभीरता से ऐसा करने का कोई तरीका नहीं है?

— devios1

12

@devios सब सच है। मैं ऑब्जेक्टिव-सी की तुलना में स्विफ्ट के लिए आभारी हूं, लेकिन आईएमएचओ को इस असंवेदनशील कोड के लिए जो चिंताएं हैं, वे 99% कोड के लिए अप्रासंगिक हैं और वहां से कोडर हैं। इससे भी बुरी बात यह है कि हम ख़ुद ही ख़राब सुविधा विस्तार लिखना समाप्त कर देंगे। यदि नियमित डेवलपर्स इन उच्च-स्तरीय चिंताओं को नहीं समझ सकते हैं, तो वे उन पैदल यात्रियों की चिंताओं से निपटने के लिए एक ऐड-हॉक एपीआई लिखने में सक्षम हैं जिनके साथ हम सॉफ्टवेयर बनाते हैं। बदलने की प्रवृत्ति NSStringजाहिर तौर पर बहुत खराब है, क्योंकि अंततः हम सभी फाउंडेशन (विरासत) वर्गों से दूर होना चाहते हैं। तो .... और अधिक ranting!

— डैन रोसेनस्टार्क

2

स्विफ्ट 4 में, आप कर सकते हैं string1[..<index1]। की कोई जरूरत नहीं string1.startIndex।

— bauerMusic

26

स्विफ्ट 3, एक्सकोड 8

func lastIndexOfCharacter(_ c: Character) -> Int? {
    return range(of: String(c), options: .backwards)?.lowerBound.encodedOffset
}

के बाद advancedBy(Int)से चला गया है स्विफ्ट 3 का उपयोग Stringविधि है index(String.Index, Int)। Stringसबस्ट्रिंग और दोस्तों के साथ इस एक्सटेंशन को देखें:

public extension String {

    //right is the first encountered string after left
    func between(_ left: String, _ right: String) -> String? {
        guard let leftRange = range(of: left), let rightRange = range(of: right, options: .backwards)
        , leftRange.upperBound <= rightRange.lowerBound
            else { return nil }

        let sub = self.substring(from: leftRange.upperBound)
        let closestToLeftRange = sub.range(of: right)!
        return sub.substring(to: closestToLeftRange.lowerBound)
    }

    var length: Int {
        get {
            return self.characters.count
        }
    }

    func substring(to : Int) -> String {
        let toIndex = self.index(self.startIndex, offsetBy: to)
        return self.substring(to: toIndex)
    }

    func substring(from : Int) -> String {
        let fromIndex = self.index(self.startIndex, offsetBy: from)
        return self.substring(from: fromIndex)
    }

    func substring(_ r: Range<Int>) -> String {
        let fromIndex = self.index(self.startIndex, offsetBy: r.lowerBound)
        let toIndex = self.index(self.startIndex, offsetBy: r.upperBound)
        return self.substring(with: Range<String.Index>(uncheckedBounds: (lower: fromIndex, upper: toIndex)))
    }

    func character(_ at: Int) -> Character {
        return self[self.index(self.startIndex, offsetBy: at)]
    }

    func lastIndexOfCharacter(_ c: Character) -> Int? {
        guard let index = range(of: String(c), options: .backwards)?.lowerBound else
        { return nil }
        return distance(from: startIndex, to: index)
    }
}

स्विफ्ट 4 के लिए अद्यतन विस्तार

public extension String {

    //right is the first encountered string after left
    func between(_ left: String, _ right: String) -> String? {
        guard
            let leftRange = range(of: left), let rightRange = range(of: right, options: .backwards)
            , leftRange.upperBound <= rightRange.lowerBound
            else { return nil }

        let sub = self[leftRange.upperBound...]
        let closestToLeftRange = sub.range(of: right)!            
        return String(sub[..<closestToLeftRange.lowerBound])
    }

    var length: Int {
        get {
            return self.count
        }
    }

    func substring(to : Int) -> String {
        let toIndex = self.index(self.startIndex, offsetBy: to)
        return String(self[...toIndex])
    }

    func substring(from : Int) -> String {
        let fromIndex = self.index(self.startIndex, offsetBy: from)
        return String(self[fromIndex...])
    }

    func substring(_ r: Range<Int>) -> String {
        let fromIndex = self.index(self.startIndex, offsetBy: r.lowerBound)
        let toIndex = self.index(self.startIndex, offsetBy: r.upperBound)
        let indexRange = Range<String.Index>(uncheckedBounds: (lower: fromIndex, upper: toIndex))
        return String(self[indexRange])
    }

    func character(_ at: Int) -> Character {
        return self[self.index(self.startIndex, offsetBy: at)]
    }

    func lastIndexOfCharacter(_ c: Character) -> Int? {
        guard let index = range(of: String(c), options: .backwards)?.lowerBound else
        { return nil }
        return distance(from: startIndex, to: index)
    }
}

उपयोग:

let text = "www.stackoverflow.com"
let at = text.character(3) // .
let range = text.substring(0..<3) // www
let from = text.substring(from: 4) // stackoverflow.com
let to = text.substring(to: 16) // www.stackoverflow
let between = text.between(".", ".") // stackoverflow
let substringToLastIndexOfChar = text.lastIndexOfCharacter(".") // 17

पीएस यह वास्तव में अजीब है कि डेवलपर्स String.Indexसादे के बजाय से निपटने के लिए मजबूर हुए Int। हमें आंतरिक Stringयांत्रिकी के बारे में क्यों परेशान होना चाहिए और न केवल सरल substring()तरीके होने चाहिए?

— serg_zhd
स्रोत

आप उपयोग नहीं करना चाहिए encodedOffsetइस टिप्पणी और सही तरीका जाँच करें कि पूरा करने के लिए stackoverflow.com/questions/34540185/...

— सिंह Dabus

18

मैं इसे एक सबस्क्रिप्ट ( s[start..<end]) का उपयोग करके करूंगा :

स्विफ्ट 3, 4, 5

let s = "www.stackoverflow.com"
let start = s.startIndex
let end = s.index(s.endIndex, offsetBy: -4)
let substring = s[start..<end] // www.stackoverflow

— मरीन Černý
स्रोत

11

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

में स्विफ्ट 4 या बाद (Xcode 10.0+) आप नए उपयोग कर सकते हैं BidirectionalCollection विधि (के lastIndex :)

func lastIndex(of element: Element) -> Int?

let string = "www.stackoverflow.com"
if let lastIndex = string.lastIndex(of: ".") {
    let subString = string[..<lastIndex]  // "www.stackoverflow"
}

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

यह एक शानदार उत्तर है, लेकिन ऐसा लगता है कि स्विफ्ट 2 के साथ, इस संपत्ति को एनएसयूआरएल में स्थानांतरित कर दिया गया है। हो सकता है कि इससे भविष्य में लोगों को पढ़ने में मदद

— मिले

8

यहाँ है कि मैं यह कैसे करते हैं। आप इसे उसी तरह कर सकते हैं, या विचारों के लिए इस कोड का उपयोग कर सकते हैं।

let s = "www.stackoverflow.com"
s.substringWithRange(0..<s.lastIndexOf("."))

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

import Foundation
extension String {

  var length: Int {
    get {
      return countElements(self)
    }
  }

  func indexOf(target: String) -> Int {
    var range = self.rangeOfString(target)
    if let range = range {
      return distance(self.startIndex, range.startIndex)
    } else {
      return -1
    }
  }

  func indexOf(target: String, startIndex: Int) -> Int {
    var startRange = advance(self.startIndex, startIndex)        
    var range = self.rangeOfString(target, options: NSStringCompareOptions.LiteralSearch, range: Range<String.Index>(start: startRange, end: self.endIndex))
    if let range = range {
      return distance(self.startIndex, range.startIndex)
    } else {
      return -1
    }
  }

  func lastIndexOf(target: String) -> Int {
    var index = -1
    var stepIndex = self.indexOf(target)
    while stepIndex > -1 {
      index = stepIndex
      if stepIndex + target.length < self.length {
        stepIndex = indexOf(target, startIndex: stepIndex + target.length)
      } else {
        stepIndex = -1
      }
    }
    return 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)
  }

}

क्रेडिट अल्बर्टोरी / कॉमन स्विफ्ट स्ट्रिंग एक्सटेंशन

आम तौर पर मैं एक्सटेंशन का एक मजबूत प्रस्तावक हूं, खासकर स्ट्रिंग हेरफेर, खोज और स्लाइसिंग जैसी जरूरतों के लिए।

— joelparkerhenderson
स्रोत

2

मुझे लगता है कि ये वास्तव में कुछ हैं Apple को स्विफ्ट में स्ट्रिंग के एपीआई में सुधार करना चाहिए।

— क्षितिज ०47४ sky

2

इस API की तलाश है। Apple स्विफ्ट में बहुत सारे बेसिक API की कमी है। यह एक बहुत ही जटिल भाषा है और पूरी भी नहीं है। स्विफ्ट बकवास है!

— लोक

यहां आपके द्वारा संदर्भित लाइब्रेरी के 3 संस्करण को स्विफ़्ट और अपडेट किया गया है: github.com/iamjono/SwiftString

— RenniePet

5

String बिल्ट सबस्ट्रिंग सुविधा है:

extension String : Sliceable {
    subscript (subRange: Range<String.Index>) -> String { get }
}

यदि आप चाहते हैं कि " एक चरित्र के पहले सूचकांक में जा रहा है ", तो आप बिलिन find()फ़ंक्शन का उपयोग करके सबस्ट्रिंग प्राप्त कर सकते हैं :

var str = "www.stackexchange.com"
str[str.startIndex ..< find(str, ".")!] // -> "www"

अंतिम सूचकांक खोजने के लिए , हम कार्यान्वित कर सकते हैं findLast()।

/// Returns the last index where `value` appears in `domain` or `nil` if
/// `value` is not found.
///
/// Complexity: O(\ `countElements(domain)`\ )
func findLast<C: CollectionType where C.Generator.Element: Equatable>(domain: C, value: C.Generator.Element) -> C.Index? {
    var last:C.Index? = nil
    for i in domain.startIndex..<domain.endIndex {
        if domain[i] == value {
            last = i
        }
    }
    return last
}

let str = "www.stackexchange.com"
let substring = map(findLast(str, ".")) { str[str.startIndex ..< $0] } // as String?
// if "." is found, substring has some, otherwise `nil`

जोड़े गए:

हो सकता है, का BidirectionalIndexTypeविशेष संस्करण findLastतेज़ हो:

func findLast<C: CollectionType where C.Generator.Element: Equatable, C.Index: BidirectionalIndexType>(domain: C, value: C.Generator.Element) -> C.Index? {
    for i in lazy(domain.startIndex ..< domain.endIndex).reverse() {
        if domain[i] == value {
            return i
        }
    }
    return nil
}

— Rintaro
स्रोत

स्ट्रिंग के लिए सबस्क्रिप्ट स्विफ्ट 2.0 में उपलब्ध नहीं है, क्या आप एक प्रतिस्थापन जानते हैं?

— Cory

क्या आप जानते हैं कि मैं स्विफ्ट 4 या बाद में BidirectionalIndexType में सूचकांक को कैसे बाधित कर सकता हूं?

— सिंह डबस

5

आप इन एक्सटेंशन का उपयोग कर सकते हैं:

स्विफ्ट 2.3

 extension String
    {
        func substringFromIndex(index: Int) -> String
        {
            if (index < 0 || index > self.characters.count)
            {
                print("index \(index) out of bounds")
                return ""
            }
            return self.substringFromIndex(self.startIndex.advancedBy(index))
        }

        func substringToIndex(index: Int) -> String
        {
            if (index < 0 || index > self.characters.count)
            {
                print("index \(index) out of bounds")
                return ""
            }
            return self.substringToIndex(self.startIndex.advancedBy(index))
        }

        func substringWithRange(start: Int, end: Int) -> String
        {
            if (start < 0 || start > self.characters.count)
            {
                print("start index \(start) out of bounds")
                return ""
            }
            else if end < 0 || end > self.characters.count
            {
                print("end index \(end) out of bounds")
                return ""
            }
            let range = Range(start: self.startIndex.advancedBy(start), end: self.startIndex.advancedBy(end))
            return self.substringWithRange(range)
        }

        func substringWithRange(start: Int, location: Int) -> String
        {
            if (start < 0 || start > self.characters.count)
            {
                print("start index \(start) out of bounds")
                return ""
            }
            else if location < 0 || start + location > self.characters.count
            {
                print("end index \(start + location) out of bounds")
                return ""
            }
            let range = Range(start: self.startIndex.advancedBy(start), end: self.startIndex.advancedBy(start + location))
            return self.substringWithRange(range)
        }
    }

स्विफ्ट 3

extension String
{   
    func substring(from index: Int) -> String
    {
        if (index < 0 || index > self.characters.count)
        {
            print("index \(index) out of bounds")
            return ""
        }
        return self.substring(from: self.characters.index(self.startIndex, offsetBy: index))
    }

    func substring(to index: Int) -> String
    {
        if (index < 0 || index > self.characters.count)
        {
            print("index \(index) out of bounds")
            return ""
        }
        return self.substring(to: self.characters.index(self.startIndex, offsetBy: index))
    }

    func substring(start: Int, end: Int) -> String
    {
        if (start < 0 || start > self.characters.count)
        {
            print("start index \(start) out of bounds")
            return ""
        }
        else if end < 0 || end > self.characters.count
        {
            print("end index \(end) out of bounds")
            return ""
        }
        let startIndex = self.characters.index(self.startIndex, offsetBy: start)
        let endIndex = self.characters.index(self.startIndex, offsetBy: end)
        let range = startIndex..<endIndex

        return self.substring(with: range)
    }

    func substring(start: Int, location: Int) -> String
    {
        if (start < 0 || start > self.characters.count)
        {
            print("start index \(start) out of bounds")
            return ""
        }
        else if location < 0 || start + location > self.characters.count
        {
            print("end index \(start + location) out of bounds")
            return ""
        }
        let startIndex = self.characters.index(self.startIndex, offsetBy: start)
        let endIndex = self.characters.index(self.startIndex, offsetBy: start + location)
        let range = startIndex..<endIndex

        return self.substring(with: range)
    }
}

उपयोग:

let string = "www.stackoverflow.com"        
let substring = string.substringToIndex(string.characters.count-4)

— ChikabuZ
स्रोत

5

स्विफ्ट 4:

extension String {

    /// the length of the string
    var length: Int {
        return self.characters.count
    }

    /// Get substring, e.g. "ABCDE".substring(index: 2, length: 3) -> "CDE"
    ///
    /// - parameter index:  the start index
    /// - parameter length: the length of the substring
    ///
    /// - returns: the substring
    public func substring(index: Int, length: Int) -> String {
        if self.length <= index {
            return ""
        }
        let leftIndex = self.index(self.startIndex, offsetBy: index)
        if self.length <= index + length {
            return self.substring(from: leftIndex)
        }
        let rightIndex = self.index(self.endIndex, offsetBy: -(self.length - index - length))
        return self.substring(with: leftIndex..<rightIndex)
    }

    /// Get substring, e.g. -> "ABCDE".substring(left: 0, right: 2) -> "ABC"
    ///
    /// - parameter left:  the start index
    /// - parameter right: the end index
    ///
    /// - returns: the substring
    public func substring(left: Int, right: Int) -> String {
        if length <= left {
            return ""
        }
        let leftIndex = self.index(self.startIndex, offsetBy: left)
        if length <= right {
            return self.substring(from: leftIndex)
        }
        else {
            let rightIndex = self.index(self.endIndex, offsetBy: -self.length + right + 1)
            return self.substring(with: leftIndex..<rightIndex)
        }
    }
}

आप इसका परीक्षण इस प्रकार कर सकते हैं:

    print("test: " + String("ABCDE".substring(index: 2, length: 3) == "CDE"))
    print("test: " + String("ABCDE".substring(index: 0, length: 3) == "ABC"))
    print("test: " + String("ABCDE".substring(index: 2, length: 1000) == "CDE"))
    print("test: " + String("ABCDE".substring(left: 0, right: 2) == "ABC"))
    print("test: " + String("ABCDE".substring(left: 1, right: 3) == "BCD"))
    print("test: " + String("ABCDE".substring(left: 3, right: 1000) == "DE"))

चेक https://gitlab.com/seriyvolk83/SwiftEx पुस्तकालय। इसमें ये और अन्य सहायक विधियाँ शामिल हैं।

— अलेक्जेंडर वोल्कोव
स्रोत

4

क्या आप अपने किसी एक वर्ण के अंतिम इंडेक्स से एक स्ट्रिंग का विकल्प प्राप्त करना चाहते हैं? यदि हां, तो आप निम्न स्विफ्ट 2.0+ विधियों में से एक चुन सकते हैं।

जिन तरीकों की आवश्यकता होती है `Foundation`

एक विकल्प प्राप्त करें जिसमें एक वर्ण का अंतिम सूचकांक शामिल है:

import Foundation

let string = "www.stackoverflow.com"
if let rangeOfIndex = string.rangeOfCharacterFromSet(NSCharacterSet(charactersInString: "."), options: .BackwardsSearch) {
    print(string.substringToIndex(rangeOfIndex.endIndex))
}

// prints "www.stackoverflow."

एक विकल्प प्राप्त करें जिसमें किसी वर्ण का अंतिम सूचकांक शामिल नहीं है:

import Foundation

let string = "www.stackoverflow.com"
if let rangeOfIndex = string.rangeOfCharacterFromSet(NSCharacterSet(charactersInString: "."), options: .BackwardsSearch) {
    print(string.substringToIndex(rangeOfIndex.startIndex))
}

// prints "www.stackoverflow"

यदि आपको उन ऑपरेशनों को दोहराने की आवश्यकता है, तो विस्तार Stringएक अच्छा समाधान हो सकता है:

import Foundation

extension String {
    func substringWithLastInstanceOf(character: Character) -> String? {
        if let rangeOfIndex = rangeOfCharacterFromSet(NSCharacterSet(charactersInString: String(character)), options: .BackwardsSearch) {
            return self.substringToIndex(rangeOfIndex.endIndex)
        }
        return nil
    }
    func substringWithoutLastInstanceOf(character: Character) -> String? {
        if let rangeOfIndex = rangeOfCharacterFromSet(NSCharacterSet(charactersInString: String(character)), options: .BackwardsSearch) {
            return self.substringToIndex(rangeOfIndex.startIndex)
        }
        return nil
    }
}

print("www.stackoverflow.com".substringWithLastInstanceOf("."))
print("www.stackoverflow.com".substringWithoutLastInstanceOf("."))

/*
prints:
Optional("www.stackoverflow.")
Optional("www.stackoverflow")
*/

जिन तरीकों की आवश्यकता नहीं है `Foundation`

एक विकल्प प्राप्त करें जिसमें एक वर्ण का अंतिम सूचकांक शामिल है:

let string = "www.stackoverflow.com"
if let reverseIndex = string.characters.reverse().indexOf(".") {
    print(string[string.startIndex ..< reverseIndex.base])
}

// prints "www.stackoverflow."

एक विकल्प प्राप्त करें जिसमें किसी वर्ण का अंतिम सूचकांक शामिल नहीं है:

let string = "www.stackoverflow.com"
if let reverseIndex = string.characters.reverse().indexOf(".") {
    print(string[string.startIndex ..< reverseIndex.base.advancedBy(-1)])
}

// prints "www.stackoverflow"

यदि आपको उन ऑपरेशनों को दोहराने की आवश्यकता है, तो विस्तार Stringएक अच्छा समाधान हो सकता है:

extension String {
    func substringWithLastInstanceOf(character: Character) -> String? {
        if let reverseIndex = characters.reverse().indexOf(".") {
            return self[self.startIndex ..< reverseIndex.base]
        }
        return nil
    }
    func substringWithoutLastInstanceOf(character: Character) -> String? {
        if let reverseIndex = characters.reverse().indexOf(".") {
            return self[self.startIndex ..< reverseIndex.base.advancedBy(-1)]
        }
        return nil
    }
}

print("www.stackoverflow.com".substringWithLastInstanceOf("."))
print("www.stackoverflow.com".substringWithoutLastInstanceOf("."))

/*
prints:
Optional("www.stackoverflow.")
Optional("www.stackoverflow")
*/

— इमानौ पेटिट
स्रोत

4

यदि आप इंडेक्स को जानते हैं तो एक विकल्प प्राप्त करने का एक आसान और छोटा तरीका है:

let s = "www.stackoverflow.com"
let result = String(s.characters.prefix(17)) // "www.stackoverflow"

यदि आपका सूचकांक स्ट्रिंग की लंबाई से अधिक है तो यह एप्लिकेशन को क्रैश नहीं करेगा:

let s = "short"
let result = String(s.characters.prefix(17)) // "short"

दोनों उदाहरण स्विफ्ट 3 तैयार हैं ।

— एंड्री गोर्डीव
स्रोत

4

क्लैटर को जोड़ने वाली एक चीज़ दोहराई जाती है stringVar:

stringVar [ stringVar .index ( stringVar .startIndex, offsetBy: ...)

में स्विफ्ट 4

एक एक्सटेंशन कुछ को कम कर सकता है:

extension String {

    func index(at: Int) -> String.Index {
        return self.index(self.startIndex, offsetBy: at)
    }
}

फिर, उपयोग:

let string = "abcde"

let to = string[..<string.index(at: 3)] // abc
let from = string[string.index(at: 3)...] // de

यह ध्यान दिया जाना चाहिए कि toऔर fromप्रकार Substring(या String.SubSequance) हैं। वे नए तार आवंटित नहीं करते हैं और प्रसंस्करण के लिए अधिक कुशल हैं।

एक Stringप्रकार का वापस पाने के लिए, वापस करने की Substringआवश्यकता है String:

let backToString = String(from)

यह वह जगह है जहां एक तार अंत में आवंटित किया जाता है।

— bauerMusic
स्रोत

3

func substr(myString: String, start: Int, clen: Int)->String

{
  var index2 = string1.startIndex.advancedBy(start)
  var substring2 = string1.substringFromIndex(index2)
  var index1 = substring2.startIndex.advancedBy(clen)
  var substring1 = substring2.substringToIndex(index1)

  return substring1   
}

substr(string1, start: 3, clen: 5)

— प्रोफेसर ओक
स्रोत

3

स्विफ्ट 3

let string = "www.stackoverflow.com"
let first3Characters = String(string.characters.prefix(3)) // www
let lastCharacters = string.characters.dropFirst(4) // stackoverflow.com (it would be a collection)

//or by index 
let indexOfFouthCharacter = olNumber.index(olNumber.startIndex, offsetBy: 4)
let first3Characters = olNumber.substring(to: indexOfFouthCharacter) // www
let lastCharacters = olNumber.substring(from: indexOfFouthCharacter) // .stackoverflow.com

समझने के लिए अच्छा लेख , हमें इसकी आवश्यकता क्यों है

— निक कोव
स्रोत

2

मैंने स्ट्रिंग को दो प्रतिस्थापन तरीकों से बढ़ाया है। आप जैसे / सीमा से या लंबाई से / के साथ सबस्ट्रिंग कॉल कर सकते हैं:

var bcd = "abcdef".substring(1,to:3)
var cde = "abcdef".substring(2,to:-2)
var cde = "abcdef".substring(2,length:3)

extension String {
  public func substring(from:Int = 0, var to:Int = -1) -> String {
    if to < 0 {
        to = self.length + to
    }
    return self.substringWithRange(Range<String.Index>(
        start:self.startIndex.advancedBy(from),
        end:self.startIndex.advancedBy(to+1)))
  }
  public func substring(from:Int = 0, length:Int) -> String {
    return self.substringWithRange(Range<String.Index>(
        start:self.startIndex.advancedBy(from),
        end:self.startIndex.advancedBy(from+length)))
  }
}

— andrewz
स्रोत

self.length अब उपलब्ध नहीं है। आपको इसे एक्सटेंशन में जोड़ने की जरूरत है (एंड्रयूज, कृपया कोड को अपडेट करें; मैं दूसरा जवाब पोस्ट नहीं करना चाहता): सार्वजनिक दुर्गंध की लंबाई () -> Int {वापसी self.lengthOfBytesUsingEncoding (NSUTFFStringEncoding)}

— फिलिप

1

स्विफ्ट 2.0 नीचे कोड XCode 7.2 पर परीक्षण किया गया है। कृपया नीचे दिए गए संलग्न स्क्रीनशॉट को देखें

import UIKit

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        var mainText = "http://stackoverflow.com"

        var range = Range(start: mainText.startIndex.advancedBy(7), end: mainText.startIndex.advancedBy(24))
        var subText = mainText.substringWithRange(range)


        //OR Else use below for LAST INDEX

        range = Range(start: mainText.startIndex.advancedBy(7), end: mainText.endIndex)
        subText = mainText.substringWithRange(range)
    }
}

— चमथ जीवन
स्रोत

1

स्विफ्ट 5 में

ज़रुरत है String.Index इंडेक्स का प्रतिनिधित्व करने के लिए सरल इंट वैल्यू के बजाय ।

यह भी याद रखें, जब हम स्विफ्ट String(मूल्य प्रकार) से सबस्ट्रिंग प्राप्त करने का प्रयास करते हैं , तो हमें वास्तव में Sequenceप्रोटोकॉल के साथ चलना पड़ता है , जो String.SubSequenceटाइप के बजाय Stringटाइप करता है।

Stringसे वापस पाने के लिए String.SubSequence, का उपयोग करेंString(subString)

नीचे के रूप में उदाहरण:

    let string = "https://stackoverflow.com"
    let firstIndex = String.Index(utf16Offset: 0, in: string)
    let lastIndex = String.Index(utf16Offset: 6, in: string)
    let subString = String(string[firstIndex...lastIndex])

— macpandit
स्रोत

0

के लिए स्विफ्ट 2.0 , यह इस तरह है:

var string1 = "www.stackoverflow.com"
var index1 = string1.endIndex.advancedBy(-4)
var substring1 = string1.substringToIndex(index1)

— mike.tihonchik
स्रोत

हो सकता है कि उन्होंने इसे बदल दिया हो, लेकिन यह 'एडवांस्ड' है ('एडवांस्ड' के अंत में 'डी' पर ध्यान दें)

— वेज मार्टिन

0

मैंने स्विफ्ट 2.0 के साथ (और शायद स्विफ्ट 3.0) इसे बनाने के लिए andrewz की पोस्ट को संशोधित किया है। मेरी विनम्र राय में, यह विस्तार समझने में आसान है और अन्य भाषाओं (जैसे PHP) में उपलब्ध है।

extension String {

    func length() -> Int {
        return self.lengthOfBytesUsingEncoding(NSUTF16StringEncoding)
    }
    func substring(from:Int = 0, to:Int = -1) -> String {
       var nto=to
        if nto < 0 {
            nto = self.length() + nto
        }
        return self.substringWithRange(Range<String.Index>(
           start:self.startIndex.advancedBy(from),
           end:self.startIndex.advancedBy(nto+1)))
    }
    func substring(from:Int = 0, length:Int) -> String {
        return self.substringWithRange(Range<String.Index>(
            start:self.startIndex.advancedBy(from),
            end:self.startIndex.advancedBy(from+length)))
    }
}

— फिलिप
स्रोत

0

मैं स्विफ्ट 4 के लिए एक साधारण स्ट्रिंग-एक्सटेंशन भी बनाता हूं:

extension String {
    func subStr(s: Int, l: Int) -> String { //s=start, l=lenth
        let r = Range(NSRange(location: s, length: l))!
        let fromIndex = self.index(self.startIndex, offsetBy: r.lowerBound)
        let toIndex = self.index(self.startIndex, offsetBy: r.upperBound)
        let indexRange = Range<String.Index>(uncheckedBounds: (lower: fromIndex, upper: toIndex))

        return String(self[indexRange])
     }
}

तो आप इसे आसानी से इस तरह से कॉल कर सकते हैं:

"Hallo world".subStr(s: 1, l: 3) //prints --> "all"

— मार्को वेबर
स्रोत

0

इस Int-basedसमाधान की कोशिश करें :

extension String {
    // start and end is included
    func intBasedSubstring(_ start: Int, _ end: Int) -> String {
        let endOffset: Int = -(count - end - 1)
        let startIdx = self.index(startIndex, offsetBy: start)
        let endIdx = self.index(endIndex, offsetBy: endOffset)
        return String(self[startIdx..<endIdx])
    }
}

नोट: यह सिर्फ एक अभ्यास है। यह सीमा की जांच नहीं करता है। अपनी आवश्यकताओं के अनुरूप संशोधित करें।

— steveluoxin
स्रोत

-1

यहां स्विफ्ट में प्रतिस्थापन के लिए एक सरल तरीका है

import UIKit

var str = "Hello, playground" 
var res = NSString(string: str)
print(res.substring(from: 4))
print(res.substring(to: 10))

— ZagorTeNej
स्रोत

ओपी पूछता है "चरित्र के अंतिम सूचकांक से शुरुआत में प्रतिस्थापन कैसे करें" पूर्वनिर्धारित हार्डकोड मूल्यों का उपयोग करके प्रतिस्थापन कैसे प्राप्त करें।

— एरिक आया

यह मूल उदाहरण था: "www.stackoverflow.com" को "www.stackoverflow" में रूपांतरित करें। यदि आप शुरू से अंत तक एक विकल्प चाहते हैं तो कुछ नहीं करना है अर्थात परिणाम इनपुट स्ट्रिंग जैसा है। कृपया उपरोक्त उत्तर की उपयोगिता को बहाल करें।

— ZagorTeNej

स्विफ्ट: कैरेक्टर के आखिरी इंडेक्स से सबस्ट्रिंग कैसे करें