Comment puis-je utiliser de la Chaîne de découpage des indices dans Swift 4?

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

let newStr = str[..<index]

Il en est de même pour partielle gamme de opérateurs, il suffit de laisser l'autre côté vide:

let newStr = str[index...]

Gardez à l'esprit que ces opérateurs de plages de retour d'un Substring. Si vous souhaitez convertir une chaîne de caractères, utilisez String's la fonction d'initialisation:

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

Vous pouvez lire plus au sujet de la nouvelle sous-chaînes ici.

Swift 4

D'utilisation

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

La conversion de votre code Swift 4 peut également être fait 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 avoir une nouvelle chaîne:

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

Swift5

(Java de la méthode sous-chaîne):

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

Utilisation:

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

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

Propriété uppercasedFirstCharacterNew montre comment utiliser la Chaîne de découpage indice 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"

La création d'une sous-Chaîne (préfixe et suffixe) de Chaîne à l'aide de 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)")
}

De 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 les 2 indices , utilisez :

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

Lors de la programmation, j'ai souvent des chaînes de caractères avec tout simplement A-Za-z et 0-9. Pas besoin de difficile de l'Indice actions. Cette extension est basée sur la plaine de la vieille gauche /milieu /droite fonctions.

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

C'est ma solution, pas d'avertissement, pas d'erreurs, 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)])

Espère que cela 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(","))