Come posso utilizzare gli indici di slicing delle stringhe in Swift 4?

Ho il seguente codice semplice scritto in Swift 3:

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

Da Xcode 9 beta 5, ottengo il seguente avviso:

substring(to:) ‘ è deprecato: si prega di utilizzare il pedice String slicing con un operatore ‘range from from’.

Come può essere usato questo indice di slicing con intervallo parziale in Swift 4?

Dovresti lasciare un lato vuoto , da qui il nome “intervallo parziale”.

 let newStr = str[.. 

Lo stesso vale per il range parziale degli operatori, lascia vuoto l'altro lato:

 let newStr = str[index...] 

Tieni presente che questi operatori di intervallo restituiscono una Substring . Se vuoi convertirlo in una stringa, usa la funzione di inizializzazione di String :

 let newStr = String(str[.. 

Puoi leggere di più sulle nuove sottostringhe qui .

Converti sottostringa (Swift 3) a String Slicing (Swift 4)

Esempi In Swift 3, 4:

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

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

 let range = firstIndex.. 

Swift 4

uso

 let text = "Hello world" text[...3] // "Hell" text[6.. 

Codice

 import Foundation extension String { subscript(value: NSRange) -> Substring { return self[value.lowerBound..) -> Substring { get { return self[index(at: value.lowerBound)...index(at: value.upperBound)] } } subscript(value: CountableRange) -> Substring { get { return self[index(at: value.lowerBound)..) -> Substring { get { return self[..) -> Substring { get { return self[...index(at: value.upperBound)] } } subscript(value: PartialRangeFrom) -> Substring { get { return self[index(at: value.lowerBound)...] } } func index(at offset: Int) -> String.Index { return index(startIndex, offsetBy: offset) } } 

La conversione del tuo codice in Swift 4 può anche essere fatta in questo modo:

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

Puoi usare il codice qui sotto per avere una nuova stringa:

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

sottostringa (da: indice) convertita in [indice …]

Controllare il campione

 let text = "1234567890" let index = text.index(text.startIndex, offsetBy: 3) text.substring(from: index) // "4567890" [Swift 3] String(text[index...]) // "4567890" [Swift 4] 

Esempio di proprietà di convenienza uppercasedFirstCharacter in Swift3 e Swift4.

Proprietà uppercasedFirstCharacterNew dimostra come utilizzare l’indice di divisione String in 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[.. 

Alcune estensioni utili:

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

Puoi creare il tuo metodo subString personalizzato usando l’estensione alla class String come di seguito:

 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.. 

Creazione di sottostringa (prefisso e suffisso) da String utilizzando Swift 4:

 let str : String = "ilike" for i in 0...str.count { let index = str.index(str.startIndex, offsetBy: i) // String.Index let prefix = str[.. 

Produzione

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

Se vuoi generare una sottostringa tra 2 indici, usa:

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

Più corto in Swift 4:

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

Ho scritto un’estensione di stringa per la sostituzione di ‘String: subString:’

 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[.. 

Utilizzo: "Date(1511508780012+0530)".sliceByString(from: "(", to: "+")

Esempio Risultato : "1511508780012"

PS: gli optionals sono costretti a scartare. Aggiungi il controllo di sicurezza del tipo, laddove necessario.

Durante la programmazione ho spesso stringhe con solo A-Za-z e 0-9. Non c’è bisogno di azioni indice difficili. Questa estensione è basata sulle normali vecchie funzioni sinistra / destra / destra.

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

con questo metodo puoi ottenere uno specifico range di stringhe. Devi passare indice di inizio e dopo quel numero totale di caratteri che vuoi.

 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.. 

Questa è la mia soluzione, nessun avvertimento, nessun errore, ma perfetto

 let redStr: String = String(trimmStr[String.Index.init(encodedOffset: 0).. 

Spero che questo aiuti un po ‘di più: –

 var string = "123456789" 

Se vuoi una sottostringa dopo un indice particolare.

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

Se vuoi una sottostringa dopo aver rimosso una stringa alla fine.

 var indexEnd = string.index(before: string.endIndex) var strIndexEnd = String (string[.. 

puoi anche creare indici con il seguente codice: -

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

Spero che sarebbe utile.

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

Swift4:

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

Uso:

 var str = "Hello, playground" print(str.subString(from:1,to:8))