web-dev-qa-db-fra.com

Comment utiliser les indices de découpage en chaîne dans Swift 4?

J'ai le code simple suivant écrit dans Swift 3:

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

À partir de Xcode 9 beta 5, je reçois l'avertissement suivant:

'substring(to:)' est obsolète: veuillez utiliser String indice de tranchage avec un opérateur 'plage partielle à partir de'.

Comment cet indice slicing de plage partielle de peut-il être utilisé dans Swift 4?

swiftswift4
239
Kobe

Vous devriez laisser un côté vide, d'où le nom "plage partielle".

let newStr = str[..<index]

Il en va de même pour partial range from opérateurs, laissez simplement l'autre côté vide:

let newStr = str[index...]

N'oubliez pas que ces opérateurs de plage renvoient un Substring. Si vous voulez le convertir en chaîne, utilisez la fonction d'initialisation de String:

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

Vous pouvez en savoir plus sur les nouvelles sous-chaînes ici .

306
Tamás Sengel

Conversion de sous-chaîne (Swift 3) en Tranche de chaîne (Swift 4)

Exemples dans Swift 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
204
Mohammad Sadegh Panadgoo

Swift 4

Usage

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

Code

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

La conversion de votre code en Swift 4 peut également être effectuée de cette façon: 

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

Vous pouvez utiliser le code ci-dessous pour créer une nouvelle chaîne:

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

Plus court dans Swift 4:

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

sous-chaîne (from: index)converti en[index ...]

Vérifiez l'échantillon

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

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

Quelques extensions utiles:

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

Exemple de propriété de uppercasedFirstCharacter commodité dans Swift3 et Swift4.

La propriété uppercasedFirstCharacterNew montre comment utiliser l'indice de découpage en chaîne dans 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"
6
Vlad

Vous pouvez créer votre méthode de sous-chaîne personnalisée en utilisant l'extension to class String comme ci-dessous:

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

Création de sous-chaînes (préfixes et suffixes) à partir de String avec 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[..<index] // String.SubSequence
    let suffix = str[index...] // String.SubSequence
    print("prefix \(prefix), suffix : \(suffix)")
}

Sortie

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

Si vous souhaitez générer une sous-chaîne entre 2 index, utilisez:

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

J'ai écrit une extension de chaîne pour remplacer "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[..<range!.lowerBound])
    }

}

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

Exemple de résultat : "1511508780012"

PS: Les optionnels sont obligés de se défaire. Veuillez ajouter un contrôle de sécurité de type si nécessaire.

4
byJeevan

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

Usage:

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

avec cette méthode, vous pouvez obtenir une plage spécifique de chaîne. Vous devez transmettre l'index de départ et le nombre total de caractères que vous souhaitez.

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])
    }
}
3
jayesh kanzariya

Lors de la programmation, j'ai souvent des chaînes avec les lettres simples A-Za-z et 0-9. Pas besoin d'actions d'index difficiles. Cette extension est basée sur les anciennes fonctions plain left/mid/right.

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

Ceci est ma solution, aucun avertissement, aucune erreur, mais parfait

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)])
2
Victor John

J'espère que ce serait 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(","))
0
Anand Verma

`var str =" Bonjour, terrain de jeu "

let indexcut = str.firstIndex (of: ",")

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

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

Vous pouvez essayer de cette façon et vous obtiendrez de bons résultats

0
user1828845

J'espère que cela aidera un peu plus: -

var string = "123456789"

Si vous voulez une sous-chaîne après un index particulier.

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

Si vous voulez une sous-chaîne après avoir enlevé une chaîne à la fin.

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

vous pouvez également créer des index avec le code suivant: -

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