tipos programacion parametros funciones externos swift swift4

funciones - parametros externos en programacion swift



¿Cómo puedo usar los subíndices de segmentación de cadenas en Swift 4? (18)

Tengo el siguiente código simple escrito en Swift 3:

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

De Xcode 9 beta 5, recibo la siguiente advertencia:

'' substring(to:) '' está en desuso: utilice String subíndice de segmentación de String con un operador ''rango parcial desde''.

¿Cómo se puede usar este subíndice de corte con rango parcial en Swift 4?


Swift 4

Uso

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

Código

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


Swift5

(Método de subcadena de Java):

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, Nick Michaels" print(str.subString(from:7,to:20)) // print Nick Michaels


Crear SubString (prefijo y sufijo) a partir de String usando 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)") }

Salida

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

Si desea generar una subcadena entre 2 índices, use:

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


Algunas extensiones útiles:

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


Convertir subcadena (Swift 3) en segmentación de cadenas (Swift 4)

Ejemplos en 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


Cuando programo, a menudo tengo cadenas con simplemente A-Za-z y 0-9. No es necesario realizar acciones difíciles del índice. Esta extensión se basa en las antiguas funciones simples izquierda / media / derecha.

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


Debe dejar un lado vacío , de ahí el nombre de "rango parcial".

let newStr = str[..<index]

Lo mismo significa rango parcial de operadores, solo deje el otro lado vacío:

let newStr = str[index...]

Tenga en cuenta que estos operadores de rango devuelven una Substring . Si desea convertirlo en una cadena, use String función de inicialización de la String :

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

Puede leer más sobre las nuevas subcadenas here .


Ejemplo de propiedad de conveniencia uppercasedFirstCharacter en Swift3 y Swift4.

La propiedad uppercasedFirstCharacterNew muestra cómo usar el subíndice de segmentación de cadenas en 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"


Espero que esto ayude un poco más: -

var string = "123456789"

Si desea una subcadena después de algún índice en particular.

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

Si desea una subcadena después de eliminar alguna cadena al final.

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

También puede crear índices con el siguiente código: -

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


Espero que sea útil.

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


Esta es mi solución, sin advertencia, sin errores, pero perfecta.

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


He escrito una extensión de cadena para reemplazar ''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]) } }

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

Resultado del ejemplo : "1511508780012"

PD: los opcionales se ven obligados a desenvolverse. Agregue tipo de verificación de seguridad cuando sea necesario.


La conversión de su código a Swift 4 también se puede hacer de esta manera:

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

Puede usar el siguiente código para tener una nueva cadena:

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


Más corto en Swift 4:

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


Puede crear su método de subcadena personalizado usando la extensión a la clase Cadena de la siguiente manera:

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


`var str =" Hola, parque infantil "

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

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

Puede intentarlo de esta manera y obtendrá los resultados adecuados.


con este método puede obtener un rango específico de cadena. Debe pasar el índice de inicio y después de ese número total de caracteres que desea.

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


subcadena (de: índice) Convertido a [índice ...]

Revise la muestra

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