मैं स्विफ्ट 4 में स्ट्रिंग स्लिंगिंग सदस्यता का उपयोग कैसे कर सकता हूं?

Question

मेरे पास स्विफ्ट 3 में लिखा गया सरल कोड है:

let str = "Hello, playground"
let index = str.index(of: ",")!
let newStr = str.substring(to: index)

Xcode 9 बीटा 5 से, मुझे निम्नलिखित चेतावनी मिलती है:

' substring(to:)' पदावनत किया जाता है: कृपया String'ऑपरेटर से आंशिक सीमा' के साथ स्लाइसिंग सबस्क्रिप्ट का उपयोग करें ।

स्विफ्ट 4 में आंशिक स्लाइस के साथ इस स्लाइसिंग सबस्क्रिप्ट का उपयोग कैसे किया जा सकता है?

Comments

var str = "हेलो, प्लेग्राउंड" let indexcut = str.firstIndex (of: ",") प्रिंट (स्ट्रिंग (str [.. <indexcut!])) प्रिंट (String (str [indexcut! ...]))

— user1828845

Answer 1

आपको एक तरफ को खाली छोड़ देना चाहिए , इसलिए नाम "आंशिक सीमा"।

let newStr = str[..<index]

वही ऑपरेटरों से आंशिक सीमा के लिए खड़ा है , बस दूसरी तरफ खाली छोड़ दें:

let newStr = str[index...]

ध्यान रखें कि ये रेंज ऑपरेटर ए वापस करते हैं Substring। यदि आप इसे एक स्ट्रिंग में बदलना चाहते हैं, तो Stringइनिशियलाइज़ेशन फंक्शन का उपयोग करें :

let newStr = String(str[..<index])

आप यहां नए सबस्ट्रिंग के बारे में अधिक पढ़ सकते हैं ।

Comments

str[..<index]एक रिटर्न Substring। यदि आप चाहते हैं newStrएक होने के लिए Stringआपके पास लेखन के लिए है:let newStr = "\(str[..<index])"

— लिंडेमन

एक लोन के साथ स्ट्रिंग प्रक्षेप का उपयोग करना Substringशायद थोड़ा भ्रामक है, क्योंकि आप वास्तव में जो हासिल करने की कोशिश कर रहे हैं वह है Stringइनिशियलाइज़ेशन let newStr = String(str[..<index]):।

— गैरी

कोड जहाँ मेरे 'सूचकांक' मूल्य केवल था एक पूर्णांक एक त्रुटि संदेश पैदावार अपडेट कर रहा है, Cannot subscript a value of type 'String' with an index of type 'PartialRangeUpTo<Int>'। वहां किस प्रकार के मूल्यों का उपयोग किया जाना है?

— ConfusionTowers

@ConfusionTowers, स्विफ्ट स्ट्रिंग इंडेक्स पूर्णांक नहीं हैं , और यह संस्करण 4 के साथ नहीं बदला है। आपको शायद str[..<str.index(str.startIndex, offsetBy: 8)]या ऐसा कुछ चाहिए होगा । इस बात का ध्यान रखें कि फंक्शन में str.indexएक लीनियर-टाइम ऑपरेशन है offsetBy।

— zneak

@zneak आप शायद चाहते हैंstr.prefix(8)

— टिम

Answer 2

पदार्थ बदलें (स्विफ्ट 3) स्ट्रिंग स्ट्रिंग (स्विफ्ट 4) में बदलें

स्विफ्ट 3, 4 में उदाहरण:

let newStr = str.substring(to: index) // Swift 3
let newStr = String(str[..<index]) // Swift 4

---

let newStr = str.substring(from: index) // Swift 3
let newStr = String(str[index...]) // Swift 4 

---

let range = firstIndex..<secondIndex // If you have a range
let newStr = = str.substring(with: range) // Swift 3
let newStr = String(str[range])  // Swift 4

Comments

परफेक्टो, और 3 और 4 उदाहरणों को साथ-साथ देने के लिए धन्यवाद, मेरे प्रोजेक्ट के तरीके को अपडेट करना आसान बनाता है!

— एथन पार्कर

Answer 3

स्विफ्ट 5, 4

प्रयोग

let text = "Hello world"
text[0] // H
text[...3] // "Hell"
text[6..<text.count] // world
text[NSRange(location: 6, length: 3)] // wor

कोड

import Foundation

public extension String {
  subscript(value: Int) -> Character {
    self[index(at: value)]
  }
}

public extension String {
  subscript(value: NSRange) -> Substring {
    self[value.lowerBound..<value.upperBound]
  }
}

public extension String {
  subscript(value: CountableClosedRange<Int>) -> Substring {
    self[index(at: value.lowerBound)...index(at: value.upperBound)]
  }

  subscript(value: CountableRange<Int>) -> Substring {
    self[index(at: value.lowerBound)..<index(at: value.upperBound)]
  }

  subscript(value: PartialRangeUpTo<Int>) -> Substring {
    self[..<index(at: value.upperBound)]
  }

  subscript(value: PartialRangeThrough<Int>) -> Substring {
    self[...index(at: value.upperBound)]
  }

  subscript(value: PartialRangeFrom<Int>) -> Substring {
    self[index(at: value.lowerBound)...]
  }
}

private extension String {
  func index(at offset: Int) -> String.Index {
    index(startIndex, offsetBy: offset)
  }
}

Comments

यह कार्यक्षमता डिफ़ॉल्ट स्विफ्ट व्यवहार होना चाहिए।

— लामिस

निश्चित रूप से यह स्विफ्ट लिब में PR: D

— OhadM

यह स्विफ्ट के बदसूरत हिस्से का एक फिक्स है।

— दिमित्री

@ किसी को भी यह पसंद नहीं आया, क्योंकि इस उत्तर में -2 है। : डी

— डिंपियाक्स

यह एक बुरा उत्तर है क्योंकि सबस्क्रिप्ट ऑपरेटर इंडेक्स-फंक्शन की O (n) जटिलता को छुपाता है। एक अच्छा प्रोग्रामिंग एपीआई केवल फास्ट लुकअप को दर्शाने के लिए सबस्क्रिप्ट का उपयोग करता है।

— ragnarius

Answer 4

स्विफ्ट 4/5 में छोटा:

var string = "123456"
string = String(string.prefix(3)) //"123"
string = String(string.suffix(3)) //"456"

Answer 5

स्विफ्ट 4 में आपके कोड का रूपांतरण इस तरह भी किया जा सकता है:

let str = "Hello, playground"
let index = str.index(of: ",")!
let substr = str.prefix(upTo: index)

आप एक नई स्ट्रिंग के लिए नीचे दिए गए कोड का उपयोग कर सकते हैं:

let newString = String(str.prefix(upTo: index))

Answer 6

प्रतिस्थापन (से: सूचकांक) [सूचकांक ...] में परिवर्तित

नमूने की जाँच करें

let text = "1234567890"
let index = text.index(text.startIndex, offsetBy: 3)

text.substring(from: index) // "4567890"   [Swift 3]
String(text[index...])      // "4567890"   [Swift 4]

Comments

अक्षर स्विफ्ट 4 में चित्रित किए गए हैं, मुझे लगता है कि आपको स्विफ्ट 4 के लिए सूचकांक प्राप्त करने के लिए उदाहरण बदलना होगा

— अबूआर्क

इससे मुझे मदद मिली। tnx

— user1105951

Answer 7

Swift5

(जावा के विकल्प विधि):

extension String {
    func subString(from: Int, to: Int) -> String {
       let startIndex = self.index(self.startIndex, offsetBy: from)
       let endIndex = self.index(self.startIndex, offsetBy: to)
       return String(self[startIndex...endIndex])
    }
}

उपयोग:

var str = "Hello, Nick Michaels"
print(str.subString(from:7,to:20))
// print Nick Michaels

Comments

फिर भी स्विफ्ट 5. में काम करता है मैं एक जावा शैली-स्ट्रिंग के लिए (देख रहा था fromकरने के लिए to-1, उदाहरण के लिए "Hello".substring(1,4)रिटर्न "ell")। एक छोटे संशोधन ( startIndex..<endIndex) के साथ यह अब तक का सबसे अच्छा समाधान है जो कोड की कुछ पंक्तियों के साथ ठीक यही करता है।

— 14

Answer 8

कुछ उपयोगी एक्सटेंशन:

extension String {
    func substring(from: Int, to: Int) -> String {
        let start = index(startIndex, offsetBy: from)
        let end = index(start, offsetBy: to - from)
        return String(self[start ..< end])
    }

    func substring(range: NSRange) -> String {
        return substring(from: range.lowerBound, to: range.upperBound)
    }
}

Comments

दिलचस्प है, मैं भी यही सोच रहा था। स्ट्रिंग (लाइन ["http: //" .endIndex ...]) स्पष्ट प्रतिस्थापन की तुलना में स्पष्ट है? line.substring (से: "http: //" .endIndex) हो सकता है जब तक कि उन्हें अद्भुत स्ट्रिंग हैंडलिंग का घोषित लक्ष्य नहीं मिलता है, तब तक उन्हें सबस्ट्रिंग को चित्रित नहीं करना चाहिए।

— possen

Answer 9

uppercasedFirstCharacterस्विफ्ट 3 और स्विफ्ट 4 में सुविधा संपत्ति का उदाहरण ।

संपत्ति uppercasedFirstCharacterNewदर्शाती है कि Swift4 में स्ट्रिंग स्लाइसिंग सबस्क्रिप्ट का उपयोग कैसे करें।

extension String {

   public var uppercasedFirstCharacterOld: String {
      if characters.count > 0 {
         let splitIndex = index(after: startIndex)
         let firstCharacter = substring(to: splitIndex).uppercased()
         let sentence = substring(from: splitIndex)
         return firstCharacter + sentence
      } else {
         return self
      }
   }

   public var uppercasedFirstCharacterNew: String {
      if characters.count > 0 {
         let splitIndex = index(after: startIndex)
         let firstCharacter = self[..<splitIndex].uppercased()
         let sentence = self[splitIndex...]
         return firstCharacter + sentence
      } else {
         return self
      }
   }
}

let lorem = "lorem".uppercasedFirstCharacterOld
print(lorem) // Prints "Lorem"

let ipsum = "ipsum".uppercasedFirstCharacterNew
print(ipsum) // Prints "Ipsum"

Comments

यदि आप सबस्ट्रिंग का मतलब है (साथ: रेंज) -> स्वयं [रेंज]

— आर्सेन वर्टबरोनोव

Answer 10

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

extension String {
    func subString(startIndex: Int, endIndex: Int) -> String {
        let end = (endIndex - self.count) + 1
        let indexStartOfText = self.index(self.startIndex, offsetBy: startIndex)
        let indexEndOfText = self.index(self.endIndex, offsetBy: end)
        let substring = self[indexStartOfText..<indexEndOfText]
        return String(substring)
    }
}

Comments

यदि यह एक एंडइंडेक्स में लेने जा रहा है, तो इसे सीमा से बाहर भी संभालने में सक्षम होना चाहिए।

— जय

Answer 11

स्विफ्ट 4 का उपयोग करते हुए स्ट्रिंग से सबस्ट्रिंग (उपसर्ग और प्रत्यय) बनाना:

let str : String = "ilike"
for i in 0...str.count {
    let index = str.index(str.startIndex, offsetBy: i) // String.Index
    let prefix = str[..<index] // String.SubSequence
    let suffix = str[index...] // String.SubSequence
    print("prefix \(prefix), suffix : \(suffix)")
}

उत्पादन

prefix , suffix : ilike
prefix i, suffix : like
prefix il, suffix : ike
prefix ili, suffix : ke
prefix ilik, suffix : e
prefix ilike, suffix : 

यदि आप 2 सूचकांकों के बीच एक विकल्प उत्पन्न करना चाहते हैं, तो उपयोग करें:

let substring1 = string[startIndex...endIndex] // including endIndex
let subString2 = string[startIndex..<endIndex] // excluding endIndex

Comments

चलो उपसर्ग = str [... <इंडेक्स>] के बजाय str [.. <इंडेक्स>] सिंगल डॉट गायब है।

— अबूआर्क

@AbuTaareq, आप किसके बारे में बात कर रहे हैं? Prefix = str [.. <इंडेक्स] को दें, यह एकदम सही है। (उपसर्ग स्ट्रिंग)। अधिक संदर्भ प्राप्त करने के लिए खेल मैदान में प्रयास करें।

— आशीस लाह

Answer 12

मैंने 'स्ट्रिंग: सबस्ट्रिंग:' के प्रतिस्थापन के लिए एक स्ट्रिंग एक्सटेंशन लिखा है

extension String {

    func sliceByCharacter(from: Character, to: Character) -> String? {
        let fromIndex = self.index(self.index(of: from)!, offsetBy: 1)
        let toIndex = self.index(self.index(of: to)!, offsetBy: -1)
        return String(self[fromIndex...toIndex])
    }

    func sliceByString(from:String, to:String) -> String? {
        //From - startIndex
        var range = self.range(of: from)
        let subString = String(self[range!.upperBound...])

        //To - endIndex
        range = subString.range(of: to)
        return String(subString[..<range!.lowerBound])
    }

}

उपयोग: "Date(1511508780012+0530)".sliceByString(from: "(", to: "+")

उदाहरण परिणाम : "1511508780012"

पुनश्च: वैकल्पिकों को खाली करने के लिए मजबूर किया जाता है। कृपया जहाँ भी आवश्यक हो टाइप सुरक्षा की जाँच करें।

Comments

सावधानी: वैकल्पिकों को मजबूर करने के लिए मजबूर किया जाता है। यदि आवश्यक हो तो कृपया टाइप सुरक्षा जांच जोड़ें।

— बाईजीवन

Answer 13

जब प्रोग्रामिंग मैं अक्सर सादे A-Za-z और 0-9 के साथ तार होता है। सूचकांक की कठिन क्रियाओं की आवश्यकता नहीं। यह विस्तार सादे पुराने बाएं / मध्य / दाएं कार्यों पर आधारित है।

extension String {

    // LEFT
    // Returns the specified number of chars from the left of the string
    // let str = "Hello"
    // print(str.left(3))         // Hel
    func left(_ to: Int) -> String {
        return "\(self[..<self.index(startIndex, offsetBy: to)])"
    }

    // RIGHT
    // Returns the specified number of chars from the right of the string
    // let str = "Hello"
    // print(str.left(3))         // llo
    func right(_ from: Int) -> String {
        return "\(self[self.index(startIndex, offsetBy: self.length-from)...])"
    }

    // MID
    // Returns the specified number of chars from the startpoint of the string
    // let str = "Hello"
    // print(str.left(2,amount: 2))         // ll
    func mid(_ from: Int, amount: Int) -> String {
        let x = "\(self[self.index(startIndex, offsetBy: from)...])"
        return x.left(amount)
    }
}

Comments

महान विचार!! दुख की बात है कि स्विफ्ट-फीचर्स को अमूर्त करने की जरूरत है क्योंकि वे लगातार बदल रहे हैं कि चीजें कैसे काम करती हैं। लगता है वे चाहते हैं कि हम सभी उत्पादकता के बजाय निर्माणों पर ध्यान केंद्रित करें। वैसे भी, मैंने आपके ठीक कोड में कुछ मामूली अपडेट किए: pastebin.com/ManWmNnW

— Fredrik Johansson

Answer 14

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

extension String{
    func substring(fromIndex : Int,count : Int) -> String{
        let startIndex = self.index(self.startIndex, offsetBy: fromIndex)
        let endIndex = self.index(self.startIndex, offsetBy: fromIndex + count)
        let range = startIndex..<endIndex
        return String(self[range])
    }
}

Answer 15

यह मेरा समाधान है, कोई चेतावनी नहीं, कोई त्रुटि नहीं, लेकिन सही है

let redStr: String = String(trimmStr[String.Index.init(encodedOffset: 0)..<String.Index.init(encodedOffset: 2)])
let greenStr: String = String(trimmStr[String.Index.init(encodedOffset: 3)..<String.Index.init(encodedOffset: 4)])
let blueStr: String = String(trimmStr[String.Index.init(encodedOffset: 5)..<String.Index.init(encodedOffset: 6)])

Comments

के उपयोग encodedOffsetहै हानिकारक माना जाएगा और पदावनत ।

— मार्टिन आर

Answer 16

उम्मीद है कि इससे थोड़ी मदद मिलेगी: -

var string = "123456789"

यदि आप किसी विशेष सूचकांक के बाद एक विकल्प चाहते हैं।

var indexStart  =  string.index(after: string.startIndex )// you can use any index in place of startIndex
var strIndexStart   = String (string[indexStart...])//23456789

यदि आप अंत में कुछ स्ट्रिंग को हटाने के बाद एक विकल्प चाहते हैं।

var indexEnd  =  string.index(before: string.endIndex)
var strIndexEnd   = String (string[..<indexEnd])//12345678

आप निम्न कोड के साथ अनुक्रमित भी बना सकते हैं: -

var  indexWithOffset =  string.index(string.startIndex, offsetBy: 4)

Answer 17

आशा है कि यह मददगार होगा।

extension String {
    func getSubString(_ char: Character) -> String {
        var subString = ""
        for eachChar in self {
            if eachChar == char {
                return subString
            } else {
                subString += String(eachChar)
            }
        }
        return subString
    }
}


let str: String = "Hello, playground"
print(str.getSubString(","))

Answer 18

var str = "Hello, playground"
let indexcut = str.firstIndex(of: ",")
print(String(str[..<indexcut!]))
print(String(str[indexcut!...]))

आप इस तरह से कोशिश कर सकते हैं और उचित परिणाम प्राप्त करेंगे।