¿Cómo se usa String.substringWithRange? (o, ¿cómo funcionan los rangos en Swift?)

Todavía no he podido descubrir cómo obtener una subcadena de a Stringen Swift:

var str = “Hello, playground”
func test(str: String) -> String {
 return str.substringWithRange( /* What goes here? */ )
}
test (str)

No puedo crear un Rango en Swift. Autocompletar en el área de juegos no es muy útil: esto es lo que sugiere:

return str.substringWithRange(aRange: Range<String.Index>)

No he encontrado nada en la Biblioteca de referencia estándar de Swift que me ayude. Aquí había otra conjetura salvaje:

return str.substringWithRange(Range(0, 1))

Y esto:

let r:Range<String.Index> = Range<String.Index>(start: 0, end: 2)
return str.substringWithRange(r)

He visto otras respuestas ( Búsqueda de índice de caracteres en Swift String ) que parecen sugerir que, dado que Stringes un tipo de puente NSString, los métodos "antiguos" deberían funcionar, pero no está claro cómo, por ejemplo, esto tampoco funciona ( no parece ser una sintaxis válida):

let x = str.substringWithRange(NSMakeRange(0, 3))

Pensamientos?

Puede usar el método substringWithRange. Se necesita un inicio y fin de String.Index.

var str = "Hello, playground"
str.substringWithRange(Range<String.Index>(start: str.startIndex, end: str.endIndex)) //"Hello, playground"

Para cambiar el índice inicial y final, use advancedBy (n).

var str = "Hello, playground"
str.substringWithRange(Range<String.Index>(start: str.startIndex.advancedBy(2), end: str.endIndex.advancedBy(-1))) //"llo, playgroun"

También puede seguir utilizando el método NSString con NSRange, pero debe asegurarse de utilizar un NSString como este:

let myNSString = str as NSString
myNSString.substringWithRange(NSRange(location: 0, length: 3))

Nota: como se menciona en JanX2, este segundo método no es seguro con cadenas unicode.

Swift 2

Sencillo

let str = "My String"
let subStr = str[str.startIndex.advancedBy(3)...str.startIndex.advancedBy(7)]
//"Strin"

Swift 3

let startIndex = str.index(str.startIndex, offsetBy: 3)
let endIndex = str.index(str.startIndex, offsetBy: 7)

str[startIndex...endIndex]       // "Strin"
str.substring(to: startIndex)    // "My "
str.substring(from: startIndex)  // "String"

Swift 4

substring(to:)y substring(from:)están en desuso en Swift 4.

String(str[..<startIndex])    // "My "
String(str[startIndex...])    // "String"
String(str[startIndex...endIndex])    // "Strin"

NOTA: @airspeedswift hace algunos puntos muy perspicaces sobre las compensaciones de este enfoque, particularmente los impactos ocultos en el rendimiento. Las cadenas no son simples bestias, y llegar a un índice particular puede llevar tiempo O (n), lo que significa que un bucle que usa un subíndice puede ser O (n ^ 2). Usted ha sido advertido.

Solo necesita agregar una nueva subscriptfunción que tome un rango y use advancedBy()para caminar hacia donde desee:

import Foundation

extension String {
    subscript (r: Range<Int>) -> String {
        get {
            let startIndex = self.startIndex.advancedBy(r.startIndex)
            let endIndex = startIndex.advancedBy(r.endIndex - r.startIndex)

            return self[Range(start: startIndex, end: endIndex)]
        }
    }
}

var s = "Hello, playground"

println(s[0...5]) // ==> "Hello,"
println(s[0..<5]) // ==> "Hello"

(Esto definitivamente debería ser parte del lenguaje. Por favor engañe rdar: // 17158813 )

Por diversión, también puede agregar un +operador a los índices:

func +<T: ForwardIndex>(var index: T, var count: Int) -> T {
  for (; count > 0; --count) {
    index = index.succ()
  }
  return index
}

s.substringWithRange(s.startIndex+2 .. s.startIndex+5)

(Todavía no sé si este debería ser parte del lenguaje o no).

En el momento en que escribo, ninguna extensión es perfectamente compatible con Swift 4.2 , así que aquí hay una que cubre todas las necesidades que se me ocurren:

extension String {
    func substring(from: Int?, to: Int?) -> String {
        if let start = from {
            guard start < self.count else {
                return ""
            }
        }

        if let end = to {
            guard end >= 0 else {
                return ""
            }
        }

        if let start = from, let end = to {
            guard end - start >= 0 else {
                return ""
            }
        }

        let startIndex: String.Index
        if let start = from, start >= 0 {
            startIndex = self.index(self.startIndex, offsetBy: start)
        } else {
            startIndex = self.startIndex
        }

        let endIndex: String.Index
        if let end = to, end >= 0, end < self.count {
            endIndex = self.index(self.startIndex, offsetBy: end + 1)
        } else {
            endIndex = self.endIndex
        }

        return String(self[startIndex ..< endIndex])
    }

    func substring(from: Int) -> String {
        return self.substring(from: from, to: nil)
    }

    func substring(to: Int) -> String {
        return self.substring(from: nil, to: to)
    }

    func substring(from: Int?, length: Int) -> String {
        guard length > 0 else {
            return ""
        }

        let end: Int
        if let start = from, start > 0 {
            end = start + length - 1
        } else {
            end = length - 1
        }

        return self.substring(from: from, to: end)
    }

    func substring(length: Int, to: Int?) -> String {
        guard let end = to, end > 0, length > 0 else {
            return ""
        }

        let start: Int
        if let end = to, end - length > 0 {
            start = end - length + 1
        } else {
            start = 0
        }

        return self.substring(from: start, to: to)
    }
}

Y luego, puedes usar:

let string = "Hello,World!"

string.substring(from: 1, to: 7)te consigue: ello,Wo

string.substring(to: 7)te consigue: Hello,Wo

string.substring(from: 3)te consigue: lo,World!

string.substring(from: 1, length: 4)te consigue: ello

string.substring(length: 4, to: 7)te consigue: o,Wo

Actualizado substring(from: Int?, length: Int)para admitir a partir de cero.

SWIFT 2.0

sencillo:

let myString = "full text container"
let substring = myString[myString.startIndex..<myString.startIndex.advancedBy(3)] // prints: ful

SWIFT 3.0

let substring = myString[myString.startIndex..<myString.index(myString.startIndex, offsetBy: 3)] // prints: ful

SWIFT 4.0

Las operaciones de subcadena devuelven una instancia del tipo Substring, en lugar de String.

let substring = myString[myString.startIndex..<myString.index(myString.startIndex, offsetBy: 3)] // prints: ful

// Convert the result to a String for long-term storage.
let newString = String(substring)

Es mucho más simple que cualquiera de las respuestas aquí, una vez que encuentre la sintaxis correcta.

Quiero quitarme el [y]

let myString = "[ABCDEFGHI]"
let startIndex = advance(myString.startIndex, 1) //advance as much as you like
let endIndex = advance(myString.endIndex, -1)
let range = startIndex..<endIndex
let myNewString = myString.substringWithRange( range )

el resultado será "ABCDEFGHI", el startIndex y endIndex también podrían usarse

let mySubString = myString.substringFromIndex(startIndex)

¡y así!

PD: Como se indica en los comentarios, ¡hay algunos cambios de sintaxis en swift 2 que viene con xcode 7 y iOS9!

Por favor mira esta página

Por ejemplo, para encontrar el primer nombre (hasta el primer espacio) en mi nombre completo:

let name = "Joris Kluivers"

let start = name.startIndex
let end = find(name, " ")

if end {
    let firstName = name[start..end!]
} else {
    // no space found
}

starty endson de tipo String.Indexaquí y se usan para crear ay se Range<String.Index>usan en el descriptor de acceso de subíndice (si se encuentra un espacio en la cadena original).

Es difícil crear un String.Indexdirectamente desde una posición entera como se usa en la publicación de apertura. Esto se debe a que, en mi nombre, cada carácter tendría el mismo tamaño en bytes. Pero los caracteres que usan acentos especiales en otros idiomas podrían haber usado varios bytes más (dependiendo de la codificación utilizada). Entonces, ¿a qué byte debería referirse el entero?

Es posible crear uno nuevo a String.Indexpartir de uno existente usando los métodos succy predque asegurará que se omita el número correcto de bytes para llegar al siguiente punto de código en la codificación. Sin embargo, en este caso, es más fácil buscar el índice del primer espacio en la cadena para encontrar el índice final.

Como String es un tipo de puente para NSString, los métodos "antiguos" deberían funcionar, pero no está claro cómo, por ejemplo, esto tampoco funciona (no parece ser una sintaxis válida):

 let x = str.substringWithRange(NSMakeRange(0, 3))

Para mí, esa es la parte realmente interesante de tu pregunta. Cadena está puenteado a NSString, por lo que la mayor parte métodos NSString hacen el trabajo directamente en una cadena. Puedes usarlos libremente y sin pensar. Entonces, por ejemplo, esto funciona tal como espera:

// delete all spaces from Swift String stateName
stateName = stateName.stringByReplacingOccurrencesOfString(" ", withString:"")

Pero, como suele suceder, "conseguí que mi mojo funcionara pero simplemente no funciona en ti". Simplemente elegiste uno de los raros casos en los que existe un método Swift paralelo idénticamente llamado , y en un caso como ese, el método Swift eclipsa el método Objective-C. Por lo tanto, cuando dices str.substringWithRange, Swift cree que te refieres al método Swift en lugar del método NSString, y luego te mandan, porque el método Swift espera un Range<String.Index>, y no sabes cómo hacer uno de esos.

La salida fácil es evitar que Swift se eclipse de esta manera, emitiendo explícitamente:

let x = (str as NSString).substringWithRange(NSMakeRange(0, 3))

Tenga en cuenta que aquí no hay trabajo adicional significativo. "Emitir" no significa "convertir"; la Cadena es efectivamente una NSString. Solo le estamos diciendo a Swift cómo mirar esta variable para los propósitos de esta línea de código.

La parte realmente extraña de todo esto es que el método Swift, que causa todos estos problemas, no está documentado. No tengo idea de dónde se define; no está en el encabezado NSString y tampoco está en el encabezado Swift.

En el nuevo uso de Xcode 7.0

//: Playground - noun: a place where people can play

import UIKit

var name = "How do you use String.substringWithRange?"
let range = name.startIndex.advancedBy(0)..<name.startIndex.advancedBy(10)
name.substringWithRange(range)

//OUT:

La respuesta corta es que esto es realmente difícil en Swift en este momento. Mi presentimiento es que todavía hay mucho trabajo por hacer para Apple en métodos convenientes para cosas como esta.

String.substringWithRange()está esperando un Range<String.Index>parámetro, y por lo que puedo decir, no hay un método generador para el String.Indextipo. Usted puede obtener String.Indexlos valores de vuelta de aString.startIndexy aString.endIndexy la llamada .succ()o .pred()sobre ellos, pero eso es una locura.

¿Qué tal una extensión en la clase String que toma buenos Ints viejos ?

extension String {
    subscript (r: Range<Int>) -> String {
        get {
            let subStart = advance(self.startIndex, r.startIndex, self.endIndex)
            let subEnd = advance(subStart, r.endIndex - r.startIndex, self.endIndex)
            return self.substringWithRange(Range(start: subStart, end: subEnd))
        }
    }
    func substring(from: Int) -> String {
        let end = countElements(self)
        return self[from..<end]
    }
    func substring(from: Int, length: Int) -> String {
        let end = from + length
        return self[from..<end]
    }
}

let mobyDick = "Call me Ishmael."
println(mobyDick[8...14])             // Ishmael

let dogString = "This 🐶's name is Patch."
println(dogString[5..<6])               // 🐶
println(dogString[5...5])              // 🐶
println(dogString.substring(5))        // 🐶's name is Patch.
println(dogString.substring(5, length: 1))   // 🐶

Actualización: Swift beta 4 resuelve los siguientes problemas.

Tal como está [en beta 3 y anteriores], incluso las cadenas nativas de Swift tienen algunos problemas con el manejo de caracteres Unicode. El icono de perro anterior funcionó, pero lo siguiente no:

let harderString = "1:1️⃣"
for character in harderString {
    println(character)
}

Salida:

1
:
1
️
⃣

Puedes usar estas extensiones para mejorar substringWithRange

Swift 2.3

extension String
{   
    func substringWithRange(start: Int, end: Int) -> String
    {
        if (start < 0 || start > self.characters.count)
        {
            print("start index \(start) out of bounds")
            return ""
        }
        else if end < 0 || end > self.characters.count
        {
            print("end index \(end) out of bounds")
            return ""
        }
        let range = Range(start: self.startIndex.advancedBy(start), end: self.startIndex.advancedBy(end))
        return self.substringWithRange(range)
    }

    func substringWithRange(start: Int, location: Int) -> String
    {
        if (start < 0 || start > self.characters.count)
        {
            print("start index \(start) out of bounds")
            return ""
        }
        else if location < 0 || start + location > self.characters.count
        {
            print("end index \(start + location) out of bounds")
            return ""
        }
        let range = Range(start: self.startIndex.advancedBy(start), end: self.startIndex.advancedBy(start + location))
        return self.substringWithRange(range)
    }
}

Swift 3

extension String
{
    func substring(start: Int, end: Int) -> String
    {
        if (start < 0 || start > self.characters.count)
        {
            print("start index \(start) out of bounds")
            return ""
        }
        else if end < 0 || end > self.characters.count
        {
            print("end index \(end) out of bounds")
            return ""
        }
        let startIndex = self.characters.index(self.startIndex, offsetBy: start)
        let endIndex = self.characters.index(self.startIndex, offsetBy: end)
        let range = startIndex..<endIndex

        return self.substring(with: range)
    }

    func substring(start: Int, location: Int) -> String
    {
        if (start < 0 || start > self.characters.count)
        {
            print("start index \(start) out of bounds")
            return ""
        }
        else if location < 0 || start + location > self.characters.count
        {
            print("end index \(start + location) out of bounds")
            return ""
        }
        let startIndex = self.characters.index(self.startIndex, offsetBy: start)
        let endIndex = self.characters.index(self.startIndex, offsetBy: start + location)
        let range = startIndex..<endIndex

        return self.substring(with: range)
    }
}

Uso:

let str = "Hello, playground"

let substring1 = str.substringWithRange(0, end: 5) //Hello
let substring2 = str.substringWithRange(7, location: 10) //playground

Código de muestra para obtener subcadenas en Swift 2.0

(i) Subcadena del índice inicial

Entrada:-

var str = "Swift is very powerful language!"
print(str)

str = str.substringToIndex(str.startIndex.advancedBy(5))
print(str)

Salida:-

Swift is very powerful language!
Swift

(ii) Subcadena de un índice particular

Entrada:-

var str = "Swift is very powerful language!"
print(str)

str = str.substringFromIndex(str.startIndex.advancedBy(6)).substringToIndex(str.startIndex.advancedBy(2))
print(str)

Salida:-

Swift is very powerful language!
is

¡Espero que te ayude!

Solución fácil con poco código.

Cree una extensión que incluya subcadenas básicas que tienen casi todos los demás idiomas:

extension String {
    func subString(start: Int, end: Int) -> String {
        let startIndex = self.index(self.startIndex, offsetBy: start)
        let endIndex = self.index(startIndex, offsetBy: end)

        let finalString = self.substring(from: startIndex)
        return finalString.substring(to: endIndex)
    }
}

Simplemente llame a esto con

someString.subString(start: 0, end: 6)

Esto funciona en mi patio de recreo :)

String(seq: Array(str)[2...4])

Actualizado para Xcode 7. Agrega la extensión de cadena:

Utilizar:

var chuck: String = "Hello Chuck Norris"
chuck[6...11] // => Chuck

Implementación:

extension String {

    /**
     Subscript to allow for quick String substrings ["Hello"][0...1] = "He"
     */
    subscript (r: Range<Int>) -> String {
        get {
            let start = self.startIndex.advancedBy(r.startIndex)
            let end = self.startIndex.advancedBy(r.endIndex - 1)
            return self.substringWithRange(start..<end)
        }
    }

}

prueba esto en el patio de recreo

var str:String = "Hello, playground"

let range = Range(start:advance(str.startIndex,1), end: advance(str.startIndex,8))

te dará "ello, p"

Sin embargo, cuando esto se vuelve realmente interesante es que si hace que el último índice sea más grande que la cadena en el patio de recreo, mostrará las cadenas que definió después de str: o

Range () parece ser una función genérica, por lo que necesita saber el tipo con el que está tratando.

También debe darle la cadena real que le interesa en los parques infantiles, ya que parece contener todas las picaduras en una secuencia una tras otra con su nombre de variable después.

Entonces

var str:String = "Hello, playground"

var str2:String = "I'm the next string"

let range = Range(start:advance(str.startIndex,1), end: advance(str.startIndex,49))

da "ello, playground str Im the next string str2 "

funciona incluso si str2 se define con let

:)

Rob Napier ya había dado una respuesta asombrosa usando el subíndice. Pero sentí un inconveniente en eso, ya que no hay verificación para condiciones fuera de límite. Esto puede tender a fallar. Así que modifiqué la extensión y aquí está

extension String {
    subscript (r: Range<Int>) -> String? { //Optional String as return value
        get {
            let stringCount = self.characters.count as Int
            //Check for out of boundary condition
            if (stringCount < r.endIndex) || (stringCount < r.startIndex){
                return nil
            }
            let startIndex = self.startIndex.advancedBy(r.startIndex)

            let endIndex = self.startIndex.advancedBy(r.endIndex - r.startIndex)

            return self[Range(start: startIndex, end: endIndex)]
        }
    }
}

Salida a continuación

var str2 = "Hello, World"

var str3 = str2[0...5]
//Hello,
var str4 = str2[0..<5]
//Hello
var str5 = str2[0..<15]
//nil

Así que sugiero que siempre verifique si se deja

if let string = str[0...5]
{
    //Manipulate your string safely
}

En Swift3

Por ejemplo: una variable "Duke James Thomas", necesitamos obtener "James".

let name = "Duke James Thomas"
let range: Range<String.Index> = name.range(of:"James")!
let lastrange: Range<String.Index> = img.range(of:"Thomas")!
var middlename = name[range.lowerBound..<lstrange.lowerBound]
print (middlename)

Tomando una página de Rob Napier, desarrollé estas extensiones de cadena comunes , dos de las cuales son:

subscript (r: Range<Int>) -> String
{
    get {
        let startIndex = advance(self.startIndex, r.startIndex)
        let endIndex = advance(self.startIndex, r.endIndex - 1)

        return self[Range(start: startIndex, end: endIndex)]
    }
}

func subString(startIndex: Int, length: Int) -> String
{
    var start = advance(self.startIndex, startIndex)
    var end = advance(self.startIndex, startIndex + length)
    return self.substringWithRange(Range<String.Index>(start: start, end: end))
}

Uso:

"Awesome"[3...7] //"some"
"Awesome".subString(3, length: 4) //"some"

Así es como obtienes un rango de una cadena:

var str = "Hello, playground"

let startIndex = advance(str.startIndex, 1)
let endIndex = advance(startIndex, 8)
let range = startIndex..<endIndex
let substr = str[range] //"ello, pl"

El punto clave es que está pasando un rango de valores de tipo String.Index (esto es lo que devuelve el avance) en lugar de enteros.

La razón por la que esto es necesario es que las cadenas en Swift no tienen acceso aleatorio (debido a la longitud variable de los caracteres Unicode básicamente). Tampoco puedes hacer str[1]. String.Index está diseñado para funcionar con su estructura interna.

Sin embargo, puede crear una extensión con un subíndice, que lo hace por usted, por lo que puede pasar un rango de enteros (ver, por ejemplo, la respuesta de Rob Napier ).

Traté de llegar a algo Pythonic.

Todos los subíndices aquí son geniales, pero las veces que realmente necesito algo simple es cuando quiero contar desde atrás, p. Ej. string.endIndex.advancedBy(-1)

Admite nilvalores, tanto para el índice inicial como para el final, donde nilsignificaría un índice en 0 para el inicio, string.characters.countpara el final.

extension String {
    var subString: (Int?) -> (Int?) -> String {
        return { (start) in
            { (end) in
                let startIndex = start ?? 0 < 0 ? self.endIndex.advancedBy(start!) : self.startIndex.advancedBy(start ?? 0)
                let endIndex = end ?? self.characters.count < 0 ? self.endIndex.advancedBy(end!) : self.startIndex.advancedBy(end ?? self.characters.count)

                return startIndex > endIndex ? "" : self.substringWithRange(startIndex ..< endIndex)
            }
        }
    }
}

let dog = "Dog‼🐶"
print(dog.subString(nil)(-1)) // Dog!!

EDITAR

Una solución más elegante:

public extension String {
    struct Substring {
        var start: Int?
        var string: String

        public subscript(end: Int?) -> String {
            let startIndex = start ?? 0 < 0 ? string.endIndex.advancedBy(start!) : string.startIndex.advancedBy(start ?? 0)
            let endIndex = end ?? string.characters.count < 0 ? string.endIndex.advancedBy(end!) : string.startIndex.advancedBy(end ?? string.characters.count)

            return startIndex > endIndex ? "" : string.substringWithRange(startIndex ..< endIndex)
        }
    }

    public subscript(start: Int?) -> Substring {
        return Substring(start: start, string: self)
    }
}

let dog = "Dog‼🐶"
print(dog[nil][-1]) // Dog!!

Primero cree el rango, luego la subcadena. Puede usar la fromIndex..<toIndexsintaxis de esta manera:

let range = fullString.startIndex..<fullString.startIndex.advancedBy(15) // 15 first characters of the string
let substring = fullString.substringWithRange(range)

Aquí hay un ejemplo para obtener solo la identificación de video .ie (6oL687G0Iso) de toda la URL en forma rápida

let str = "https://www.youtube.com/watch?v=6oL687G0Iso&list=PLKmzL8Ib1gsT-5LN3V2h2H14wyBZTyvVL&index=2"
var arrSaprate = str.componentsSeparatedByString("v=")
let start = arrSaprate[1]
let rangeOfID = Range(start: start.startIndex,end:start.startIndex.advancedBy(11))
let substring = start[rangeOfID]
print(substring)

let startIndex = text.startIndex
var range = startIndex.advancedBy(1) ..< text.endIndex.advancedBy(-4)
let substring = text.substringWithRange(range)

Muestra completa que puedes ver aquí

http://www.learnswiftonline.com/reference-guides/string-reference-guide-for-swift/ muestra que esto funciona bien:

var str = "abcd"
str = str.substringToIndex(1)

Bueno, tuve el mismo problema y lo resolví con la función "bridgeToObjectiveC ()":

var helloworld = "Hello World!"
var world = helloworld.bridgeToObjectiveC().substringWithRange(NSMakeRange(6,6))
println("\(world)") // should print World!

Tenga en cuenta que en el ejemplo, substringWithRange junto con NSMakeRange toman la parte de la cadena que comienza en el índice 6 (carácter "W") y termina en el índice 6 + 6 posiciones adelante (carácter "!")

Salud.

Puede usar cualquiera de los métodos de subcadena en una extensión Swift String que escribí https://bit.ly/JString .

var string = "hello"
var sub = string.substringFrom(3) // or string[3...5]
println(sub)// "lo"

Si tiene un NSRangepuente, NSStringfunciona a la perfección. Por ejemplo, estaba haciendo algo de trabajo UITextFieldDelegatey rápidamente quise calcular el nuevo valor de la cadena cuando me preguntó si debería reemplazar el rango.

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {
    let newString = (textField.text as NSString).stringByReplacingCharactersInRange(range, withString: string)
    println("Got new string: ", newString)
}

Extensión simple para String:

extension String {

    func substringToIndex(index: Int) -> String {
        return self[startIndex...startIndex.advancedBy(min(index, characters.count - 1))]
    }
}

Si no le importa el rendimiento ... esta es probablemente la solución más concisa en Swift 4

extension String {
    subscript(range: CountableClosedRange<Int>) -> String {
        return enumerated().filter{$0.offset >= range.first! && $0.offset < range.last!}
            .reduce(""){$0 + String($1.element)}
    }
}

Te permite hacer algo como esto:

let myStr = "abcd"
myStr[0..<2] // produces "ab"