Como você usa String.substringWithRange? (ou, como funcionam as faixas no Swift?)

Ainda não consegui descobrir como obter uma substring de a Stringno Swift:

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

Não consigo criar um intervalo no Swift. O preenchimento automático no Playground não é muito útil - é o que sugere:

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

Não encontrei nada na Swift Standard Reference Library que ajude. Aqui estava outro palpite:

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

E isto:

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

Eu já vi outras respostas ( Encontrar índice de caracteres no Swift String ) que parecem sugerir que, como Stringé um tipo de ponte NSString, os métodos "antigos" devem funcionar, mas não está claro como - por exemplo, isso também não funciona ( parece não ser uma sintaxe válida):

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

Pensamentos?

Você pode usar o método substringWithRange. É preciso um início e um fim String.Index.

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

Para alterar o índice inicial e 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"

Você também ainda pode usar o método NSString com o NSRange, mas precisa verificar se está usando um NSString como este:

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

Nota: como o JanX2 mencionou, este segundo método não é seguro com strings unicode.

Swift 2

Simples

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:)e substring(from:)estão obsoletos Swift 4.

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

NOTA: O @airspeedswift faz alguns pontos muito esclarecedores sobre as compensações dessa abordagem, particularmente os impactos ocultos no desempenho. Strings não são bestas simples, e chegar a um índice específico pode levar O (n) tempo, o que significa que um loop que usa um subscrito pode ser O (n ^ 2). Você foi avisado.

Você só precisa adicionar uma nova subscriptfunção que tenha um intervalo e use advancedBy()para ir até onde você deseja:

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"

(Definitivamente, isso deve fazer parte do idioma. Dupe rdar: // 17158813 )

Por diversão, você também pode adicionar um +operador aos í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)

(Ainda não sei se este deve fazer parte do idioma ou não.)

No momento em que estou escrevendo, nenhuma extensão é perfeitamente compatível com o Swift 4.2 , então aqui está uma que cobre todas as necessidades em que eu poderia pensar:

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

E então, você pode usar:

let string = "Hello,World!"

string.substring(from: 1, to: 7)recebe você: ello,Wo

string.substring(to: 7)recebe você: Hello,Wo

string.substring(from: 3)recebe você: lo,World!

string.substring(from: 1, length: 4)recebe você: ello

string.substring(length: 4, to: 7)recebe você: o,Wo

Atualizado substring(from: Int?, length: Int)para oferecer suporte a partir do zero.

SWIFT 2.0

simples:

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

As operações de substring retornam uma instância do tipo Substring, em vez 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)

É muito mais simples do que qualquer uma das respostas aqui, depois de encontrar a sintaxe correta.

Eu quero tirar o [e]

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 )

resultado será "ABCDEFGHI", o startIndex e o endIndex também podem ser usados ​​em

let mySubString = myString.substringFromIndex(startIndex)

e assim por diante!

PS: Conforme indicado nas observações, há algumas alterações de sintaxe no swift 2 que vem com o xcode 7 e iOS9!

Por favor, veja esta página

Por exemplo, para encontrar o primeiro nome (até o primeiro espaço) no meu nome completo:

let name = "Joris Kluivers"

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

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

starte endsão do tipo String.Indexaqui e são usadas para criar um Range<String.Index>e usado no acessador subscrito (se um espaço for encontrado na string original).

É difícil criar um String.Indexdiretamente a partir de uma posição inteira, como usado no post de abertura. Isso ocorre porque, em meu nome, cada caractere teria o mesmo tamanho em bytes. Mas caracteres usando acentos especiais em outros idiomas poderiam ter usado mais bytes (dependendo da codificação usada). Então, a que byte o número inteiro deve se referir?

É possível criar um novo a String.Indexpartir de um já existente usando os métodos succe predque garantirão que o número correto de bytes seja pulado para chegar ao próximo ponto de código na codificação. No entanto, nesse caso, é mais fácil procurar o índice do primeiro espaço da string para encontrar o índice final.

Como String é um tipo de ponte para o NSString, os métodos "antigos" devem funcionar, mas não está claro como - por exemplo, isso também não funciona (não parece ser uma sintaxe válida):

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

Para mim, essa é a parte realmente interessante da sua pergunta. Cadeia é ponte para NSString, de modo mais métodos NSString fazer o trabalho diretamente em uma corda. Você pode usá-los livremente e sem pensar. Então, por exemplo, isso funciona exatamente como você espera:

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

Mas, como tantas vezes acontece, "fiz meu trabalho funcionar, mas simplesmente não funciona em você". Por acaso, você escolheu um dos raros casos em que existe um método Swift paralelo chamado de forma idêntica e, em um caso como esse, o método Swift ofusca o método Objective-C. Assim, quando você diz str.substringWithRange, Swift pensa que você quer dizer o método Swift, e não o método NSString - e então você é processado, porque o método Swift espera a Range<String.Index>e você não sabe como criar um deles.

O caminho mais fácil é impedir que o Swift se ofereça dessa maneira, lançando explicitamente:

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

Observe que nenhum trabalho extra significativo está envolvido aqui. "Transmitir" não significa "converter"; a String é efetivamente uma NSString. Estamos apenas dizendo ao Swift como olhar para essa variável para fins dessa linha de código.

A parte realmente estranha dessa coisa toda é que o método Swift, que causa todo esse problema, não é documentado. Não faço ideia de onde está definido; não está no cabeçalho NSString e também não está no cabeçalho Swift.

No novo Xcode 7.0, use

//: 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:

A resposta curta é que isso é realmente difícil no Swift agora. Meu palpite é que ainda há muito trabalho para a Apple fazer em métodos de conveniência para coisas como essa.

String.substringWithRange()está esperando um Range<String.Index>parâmetro e, até onde eu sei, não existe um método gerador para o String.Indextipo Você pode obter String.Indexvalores de volta de aString.startIndexe aString.endIndexe chamada .succ()ou .pred()sobre eles, mas isso é loucura.

Que tal uma extensão na classe String que leva bons velhos Inttempos?

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))   // 🐶

Atualização: Swift beta 4 resolve os problemas abaixo!

Como está no [beta 3 e versões anteriores], até as strings nativas do Swift têm alguns problemas ao lidar com caracteres Unicode. O ícone do cachorro acima funcionou, mas o seguinte não:

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

Resultado:

1
:
1
️
⃣

Você pode usar essas extensões para melhorar 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 exemplo para obter substring no Swift 2.0

(i) Substring do índice inicial

Entrada:-

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

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

Resultado:-

Swift is very powerful language!
Swift

(ii) Substring de um índice específico

Entrada:-

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

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

Resultado:-

Swift is very powerful language!
is

Espero que ajude você!

Solução fácil com pouco código.

Faça uma extensão que inclua subStringing básico que quase todos os outros idiomas tenham:

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

Basta chamar isso com

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

Isso funciona no meu playground :)

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

Atualizado para o Xcode 7. Adiciona extensão String:

Usar:

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

Implementação:

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

}

tente isso no playground

var str:String = "Hello, playground"

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

vai te dar "ello, p"

No entanto, onde isso fica realmente interessante é que, se você tornar o último índice maior que a string no playground, ela mostrará quaisquer strings que você definiu após str: o

Range () parece ser uma função genérica para que ele precise saber o tipo com o qual está lidando.

Você também precisa fornecer a string real de seu interesse nos playgrounds, pois parece conter todas as picadas em uma sequência, uma após a outra, com o nome da variável posteriormente.

assim

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

dá "ello, playground str Sou a próxima string str2 "

funciona mesmo se str2 for definido com um let

:)

Rob Napier já tinha dado uma resposta impressionante usando subscrito. Mas senti uma desvantagem, pois não há verificação de condições fora do limite. Isso pode tender a falhar. Então eu modifiquei a extensão e aqui 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)]
        }
    }
}

Saída abaixo

var str2 = "Hello, World"

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

Então, eu sugiro sempre verificar o if let

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

Na Swift3

Por exemplo: uma variável "Duke James Thomas", precisamos obter "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 uma página de Rob Napier, desenvolvi essas Common String Extensions , duas das quais são:

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"

É assim que você obtém um intervalo de uma string:

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"

O ponto principal é que você está passando um intervalo de valores do tipo String.Index (é isso que o avanço retorna) em vez de números inteiros.

A razão pela qual isso é necessário é que as seqüências de caracteres no Swift não têm acesso aleatório (basicamente devido ao comprimento variável dos caracteres Unicode). Você também não pode fazerstr[1] . String.Index foi projetado para funcionar com sua estrutura interna.

Você pode criar uma extensão com um índice subscrito, que faz isso por você, para que você possa passar um intervalo de números inteiros (veja, por exemplo, a resposta de Rob Napier ).

Eu tentei inventar algo pythonic.

Todos os subscritos aqui são ótimos, mas os momentos em que realmente preciso de algo simples são geralmente quando quero contar de volta, por exemplo string.endIndex.advancedBy(-1)

Ele suporta nilvalores, tanto para o índice inicial quanto para o final, onde nilsignificaria índice em 0 para início e string.characters.countfim.

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

Uma solução mais 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!!

Primeiro crie o intervalo, depois a substring. Você pode usar a fromIndex..<toIndexsintaxe da seguinte maneira:

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

Aqui está um exemplo para obter apenas o ID de vídeo .ie (6oL687G0Iso) de todo o URL rapidamente

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)

Amostra completa você pode ver aqui

http://www.learnswiftonline.com/reference-guides/string-reference-guide-for-swift/ mostra que isso funciona bem:

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

Bem, eu tive o mesmo problema e resolvi com a função "bridgeToObjectiveC ()":

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

Observe que, no exemplo, substringWithRange em conjunto com NSMakeRange ocupa a parte da sequência iniciando no índice 6 (caractere "W") e finalizando nas posições 6 + 6 do índice à frente (caractere "!")

Felicidades.

Você pode usar qualquer um dos métodos de substring em uma extensão Swift String que escrevi https://bit.ly/JString .

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

Se você tiver um NSRange, a ponte NSStringfunciona perfeitamente. Por exemplo, eu estava trabalhando um pouco UITextFieldDelegatee rapidamente quis calcular o novo valor da string quando ele perguntou se deveria substituir o intervalo.

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

Extensão simples para String:

extension String {

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

Se você não se importa com o desempenho ... essa é provavelmente a solução mais concisa no 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)}
    }
}

Ele permite que você faça algo assim:

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