actualizado para a Swift 4

Intervalos Fechados: a...b

Este operador de gama cria um intervalo Swift que inclui ambos os elementos a e elemento b, mesmo que b seja o valor máximo possível para um tipo (como Int.max). Existem dois tipos diferentes de intervalos fechados: ClosedRange e CountableClosedRange.

1. ClosedRange

OS Elementos de todas as gamas da Swift são comparáveis (isto é, estão em conformidade com o protocolo comparável). Isso permite que você acesse os elementos na gama a partir de uma coleção. Aqui está um exemplo:

let myRange: ClosedRange = 1...3

let myArray = ["a", "b", "c", "d", "e"]
myArray[myRange] // ["b", "c", "d"]

No entanto, um ClosedRange não é contável (ou seja, não está em conformidade com o protocolo Sequencial). Isso significa que tu ... não se pode iterar sobre os elementos com um laço for. Para isso precisas do CountableClosedRange.

2. CountableClosedRange

let myRange: CountableClosedRange = 1...3

let myArray = ["a", "b", "c", "d", "e"]
myArray[myRange] // ["b", "c", "d"]

for index in myRange {
    print(myArray[index])
}

Intervalos Semi-Abertos: a..<b

Este operador de gama inclui o elemento a mas Não elemento b. Como acima, existem dois tipos diferentes de intervalos semi-abertos: Range e CountableRange.

1. Range

Como em ClosedRange, Você pode acessar o elementos de uma colecção com um Range. Exemplo:

let myRange: Range = 1..<3

let myArray = ["a", "b", "c", "d", "e"]
myArray[myRange] // ["b", "c"]

2. CountableRange

A CountableRange permite a iteração.

let myRange: CountableRange = 1..<3

let myArray = ["a", "b", "c", "d", "e"]
myArray[myRange] // ["b", "c"]

for index in myRange {
    print(myArray[index])
}

NSRange

Você pode (deve) ainda usar NSRange às vezes no Swift (ao fazercadeias atribuídas , por exemplo), por isso é útil saber como fazer uma.

let myNSRange = NSRange(location: 3, length: 2)

Note que esta é a localização e Comprimento , Não iniciar o índice e terminar o índice. O exemplo aqui é semelhante em significado para a faixa Swift 3..<5. Contudo, uma vez que os tipos são diferentes, não são permutáveis.

Intervalos com cordas

Os operadores de gama ... e ..< são uma forma abreviada de criar intervalos. Por exemplo:

let myRange = 1..<3

let myRange = CountableRange<Int>(uncheckedBounds: (lower: 1, upper: 3)) // 1..<3

Você pode ver que o tipo de índice aqui é Int. Isso não funciona para String, no entanto, porque as cordas são feito de caracteres e nem todos os caracteres são do mesmo tamanho. (Leia isto para mais informações.) Um emoji como, por exemplo, ocupa mais espaço do que a letra "b".

Problema com NSRange

let myNSRange = NSRange(location: 1, length: 3)

let myNSString: NSString = "abcde"
myNSString.substring(with: myNSRange) // "bcd"

let myNSString2: NSString = "acde"
myNSString2.substring(with: myNSRange) // "c"    Where is the "d"!?

A cara sorridente leva duas unidades de código UTF-16 para armazenar, por isso dá o resultado inesperado de não incluir o "d".

Swift Solução

Por causa disto, com cordas rápidas você usa Range<String.Index>, Não Range<Int>. O Índice de String é calculado com base em uma string particular para que ele saiba se há algum emoji ou grapheme estendido.

Exemplo

var myString = "abcde"
let start = myString.index(myString.startIndex, offsetBy: 1)
let end = myString.index(myString.startIndex, offsetBy: 4)
let myRange = start..<end
myString[myRange] // "bcd"

myString = "acde"
let start2 = myString.index(myString.startIndex, offsetBy: 1)
let end2 = myString.index(myString.startIndex, offsetBy: 4)
let myRange2 = start2..<end2
myString[myRange2] // "cd"

Gamas unilaterais: a... e ...be ..<b

Int

Pode usar intervalos inteiros de um lado para iterar as colecções. Aqui estão alguns exemplos da documentação .

// iterate from index 2 to the end of the array
for name in names[2...] {
    print(name)
}

// iterate from the beginning of the array to index 2
for name in names[...2] {
    print(name)
}

// iterate from the beginning of the array up to but not including index 2
for name in names[..<2] {
    print(name)
}

// the range from negative infinity to 5. You can't iterate forward
// over this because the starting point in unknown.
let range = ...5
range.contains(7)   // false
range.contains(4)   // true
range.contains(-1)  // true

// You can iterate over this but it will be an infinate loop 
// so you have to break out at some point.
let range = 5...

Texto

Isto também funciona com intervalos de cordas. Se você está fazendo um intervalo com str.startIndex ou str.endIndex em uma extremidade, você pode deixá-lo fora. O compilador vai Inferi-lo.

Administrado

var str = "Hello, playground"
let index = str.index(str.startIndex, offsetBy: 5)

let myRange = ..<index    // Hello

Podes ir do Índice para o str.endIndex usando ...

var str = "Hello, playground"
let index = str.index(str.endIndex, offsetBy: -10)
let myRange = index...        // playground

Ver além disso:

• como está o String?Trabalho de indexação no Swift
• como funciona o sub-texto em Swift

Notas

• você não pode usar um intervalo que você criou com um string em um string diferente.
Como podem ver, as cadeias de caracteres são uma dor no Swift, mas fazem com que seja possível lidar melhor com emoji e outros scalars Unicode.

Outro Estudo

• texto Exemplos de gama
• documentação do operador da Gama
• documentação de Textos e caracteres