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




swift4 (12)

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

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

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

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

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


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

स्विफ्ट 4

प्रयोग

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

कोड

import Foundation

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

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

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

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

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

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

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

Swift3 और Swift4 में अपरकेसफ्रीचर सुविधा की संपत्ति का उदाहरण।

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

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"

`var str =" हैलो, खेल का मैदान "

let इंडेक्स = str.firstIndex (का: ",")

 print(String(str[..<indexcut!])) print(String(str[indexcut!...])) ` 

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


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

let newStr = str[..<index]

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

let newStr = str[index...]

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

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

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


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

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(","))

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

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)

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

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)
    }
}

पदार्थ बदलें (स्विफ्ट 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

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

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

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

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

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

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)])

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

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

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

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




swift4