如何在Swift中创建范围？

时间：2015-05-07 06:41:30

标签： swift range

在Objective-c中，我们使用NSRange

创建范围 
NSRange range;

那么如何在Swift中创建范围？

10 个答案:

答案 0 :(得分：219)

针对Swift 4进行了更新

Swift范围比NSRange更复杂，并且它们在Swift 3中没有变得更容易。如果您想尝试理解其中某些复杂性背后的原因，请阅读this和this。我将向您展示如何创建它们以及何时可以使用它们。

关闭范围：a...b

此range operator创建一个Swift范围，其中包含元素a 和元素b，即使b是最大可能值一个类型（如Int.max）。有两种不同类型的封闭范围：ClosedRange和CountableClosedRange。

1。 ClosedRange

Swift中所有范围的元素都是可比较的（即，它们符合Comparable协议）。这允许您访问集合范围内的元素。这是一个例子：

let myRange: ClosedRange = 1...3

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

但是，ClosedRange不可数（即，它不符合序列协议）。这意味着您无法使用for循环遍历元素。为此，您需要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])
}

半开放范围：a..<b

此范围运算符包含元素a，但不是元素b。如上所述，有两种不同类型的半开放范围：Range和CountableRange。

1。 Range

与ClosedRange一样，您可以使用Range访问集合的元素。例如：

let myRange: Range = 1..<3

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

但是，再次，你不能迭代Range，因为它只是可比较的，而不是可怕的。

2。 CountableRange

CountableRange允许迭代。 

let myRange: CountableRange = 1..<3

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

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

NSRange

您可以（必须）仍然在Swift中使用NSRange（例如，在制作attributed strings时），因此了解如何制作它会很有帮助。

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

请注意，这是位置和长度，而不是起始索引和结束索引。这里的示例与Swift范围3..<5的含义相似。但是，由于类型不同，它们不可互换。

带字符串的范围

...和..<范围运算符是创建范围的简便方法。例如：

let myRange = 1..<3

创建相同范围的长期方法是

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

您可以看到此处的索引类型为Int。但是，这对String不起作用，因为字符串由字符组成，并非所有字符都是相同的大小。 （阅读this了解更多信息。）例如，表情符号比字母“＃34; b＆＃34;”需要更多的空间。

NSRange问​​题

尝试使用表情符号尝试NSRange和NSString，您就会明白我的意思。头痛。

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"!?

笑脸需要两个UTF-16代码单元才能存储，因此它会产生意外的结果，不包括＆＃34; d＆＃34;。

快速解决方案

因此，使用Swift Strings，您使用的是Range<String.Index>，而不是Range<Int>。字符串索引是根据特定字符串计算的，以便它知道是否有任何表情符号或扩展的字形集群。

实施例

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"

单侧范围：a...和...b以及..<b

在Swift 4中，事情被简化了一点。只要可以推断出范围的起点或终点，就可以将其关闭。

<强>内部

您可以使用单侧整数范围来迭代集合。以下是documentation的一些示例。

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

<强>字符串

这也适用于String范围。如果您在一端制作了str.startIndex或str.endIndex的范围，则可以将其关闭。编译器会推断它。

鉴于

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

let myRange = ..<index    // Hello

您可以使用...

从索引转到str.endIndex 
var str = "Hello, playground"
let index = str.index(str.endIndex, offsetBy: -10)
let myRange = index...        // playground

另见：

备注

  • 您不能在不同的字符串上使用您创建的范围。
  • 正如您所看到的，字符串范围在Swift中很痛苦，但它们确实可以更好地处理表情符号和其他Unicode标量。

进一步研究

答案 1 :(得分：24)

Xcode 8 beta 2•Swift 3 

let myString = "Hello World"
let myRange = myString.startIndex..<myString.index(myString.startIndex, offsetBy: 5)
let mySubString = myString.substring(with: myRange)   // Hello

Xcode 7•Swift 2.0 

let myString = "Hello World"
let myRange = Range<String.Index>(start: myString.startIndex, end: myString.startIndex.advancedBy(5))

let mySubString = myString.substringWithRange(myRange)   // Hello

或只是

let myString = "Hello World"
let myRange = myString.startIndex..<myString.startIndex.advancedBy(5)
let mySubString = myString.substringWithRange(myRange)   // Hello

答案 2 :(得分：3)

  

（1 ..＆LT; 10）

...返回

  

范围= 1 ..＆lt; 10

答案 3 :(得分：2)

像这样使用

var start = str.startIndex // Start at the string's start index
var end = advance(str.startIndex, 5) // Take start index and advance 5 characters forward
var range: Range<String.Index> = Range<String.Index>(start: start,end: end)

let firstFiveDigit =  str.substringWithRange(range)

print(firstFiveDigit)

输出你好

答案 4 :(得分：1)

我发现令人惊讶的是，即使在Swift 4中，仍然没有使用Int表达String范围的简单本机方式。允许您提供Int作为按范围获取子字符串的方法的唯一String方法是prefix和suffix。

手头有一些转换实用程序是很有用的，这样我们就可以在与String对话时像NSRange一样说话了。这是一个实用程序，它获取位置和长度，就像NSRange一样，并返回Range<String.Index>：

func range(_ start:Int, _ length:Int) -> Range<String.Index> {
    let i = self.index(start >= 0 ? self.startIndex : self.endIndex,
        offsetBy: start)
    let j = self.index(i, offsetBy: length)
    return i..<j
}

例如，"hello".range(0,1)"是Range<String.Index>包含"hello"的第一个字符。作为奖励，我允许使用否定位置："hello".range(-1,1)"是Range<String.Index>包含"hello"的最后一个字符。

将Range<String.Index>转换为NSRange也很有用，因为那时你必须与Cocoa交谈（例如，在处理NSAttributedString属性范围时）。 Swift 4提供了一种本地方式：

let nsrange = NSRange(range, in:s) // where s is the string

因此我们可以编写另一个实用程序，直接从String位置和长度转到NSRange：

extension String {
    func nsRange(_ start:Int, _ length:Int) -> NSRange {
        return NSRange(self.range(start,length), in:self)
    }
}

答案 5 :(得分：1)

If anyone want to create NSRange object can create as:

let range: NSRange = NSRange.init(location: 0, length: 5)

this will create range with position 0 and length 5

答案 6 :(得分：0)

你可以这样使用

let nsRange = NSRange(location: someInt, length: someInt)

，如

let myNSString = bigTOTPCode as NSString //12345678
let firstDigit = myNSString.substringWithRange(NSRange(location: 0, length: 1)) //1
let secondDigit = myNSString.substringWithRange(NSRange(location: 1, length: 1)) //2
let thirdDigit = myNSString.substringWithRange(NSRange(location: 2, length: 4)) //3456

答案 7 :(得分：0)

我创建了以下扩展名：

extension String {
    func substring(from from:Int, to:Int) -> String? {
        if from<to && from>=0 && to<self.characters.count {
            let rng = self.startIndex.advancedBy(from)..<self.startIndex.advancedBy(to)
            return self.substringWithRange(rng)
        } else {
            return nil
        }
    }
}

使用示例：

print("abcde".substring(from: 1, to: 10)) //nil
print("abcde".substring(from: 2, to: 4))  //Optional("cd")
print("abcde".substring(from: 1, to: 0))  //nil
print("abcde".substring(from: 1, to: 1))  //nil
print("abcde".substring(from: -1, to: 1)) //nil

答案 8 :(得分：0)

func replace(input: String, start: Int,lenght: Int, newChar: Character) -> String {
var chars = Array(input.characters)

for i in start...lenght {
    guard i < input.characters.count else{
        break
    }
    chars[i] = newChar
}
return String(chars)

}

答案 9 :(得分：0)

我想这样做：

print("Hello"[1...3])
// out: Error

但是不幸的是，我无法编写自己的下标，因为讨厌的人占用了名称空间。

但是我们可以这样做：

print("Hello"[range: 1...3])
// out: ell

只需将其添加到您的项目中即可：

extension String {
    subscript(range: ClosedRange<Int>) -> String {
        get {
            let start = String.Index(utf16Offset: range.lowerBound, in: self)
            let end = String.Index(utf16Offset: range.upperBound, in: self)
            return String(self[start...end])
        }
    }
}
相关问题
最新问题