在Swift编程语言中获取字符串的第n个字符

Question

如何获取字符串的第n个字符？我尝试了托架([])访问器没有运气.

var string = "Hello, world!"

var firstChar = string[0] // Throws error

错误:'subscript'不可用:不能使用Int下标String,请参阅文档注释以供讨论

Answer 1

注意:请参阅Leo Dabus关于Swift 4正确实施的答案.

斯威夫特4

SubstringSwift 4中引入了这种类型,通过与原始字符串共享存储来使子字符串更快,更高效,这就是下标函数应该返回的内容.

在这里尝试一下

extension String {
  subscript (i: Int) -> Character {
    return self[index(startIndex, offsetBy: i)]
  }
  subscript (bounds: CountableRange<Int>) -> Substring {
    let start = index(startIndex, offsetBy: bounds.lowerBound)
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[start ..< end]
  }
  subscript (bounds: CountableClosedRange<Int>) -> Substring {
    let start = index(startIndex, offsetBy: bounds.lowerBound)
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[start ... end]
  }
  subscript (bounds: CountablePartialRangeFrom<Int>) -> Substring {
    let start = index(startIndex, offsetBy: bounds.lowerBound)
    let end = index(endIndex, offsetBy: -1)
    return self[start ... end]
  }
  subscript (bounds: PartialRangeThrough<Int>) -> Substring {
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[startIndex ... end]
  }
  subscript (bounds: PartialRangeUpTo<Int>) -> Substring {
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[startIndex ..< end]
  }
}
extension Substring {
  subscript (i: Int) -> Character {
    return self[index(startIndex, offsetBy: i)]
  }
  subscript (bounds: CountableRange<Int>) -> Substring {
    let start = index(startIndex, offsetBy: bounds.lowerBound)
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[start ..< end]
  }
  subscript (bounds: CountableClosedRange<Int>) -> Substring {
    let start = index(startIndex, offsetBy: bounds.lowerBound)
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[start ... end]
  }
  subscript (bounds: CountablePartialRangeFrom<Int>) -> Substring {
    let start = index(startIndex, offsetBy: bounds.lowerBound)
    let end = index(endIndex, offsetBy: -1)
    return self[start ... end]
  }
  subscript (bounds: PartialRangeThrough<Int>) -> Substring {
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[startIndex ... end]
  }
  subscript (bounds: PartialRangeUpTo<Int>) -> Substring {
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[startIndex ..< end]
  }
}

要将其转换Substring为a String,您可以简单地执行String(string[0..2]),但只有在计划保留子字符串时才应该这样做.否则,保持它更有效Substring.

如果有人能找到将这两个扩展合并为一个的好方法,那就太好了.我尝试扩展StringProtocol 但没有成功,因为index那里的方法不存在.

 

斯威夫特3:

extension String {
  subscript (i: Int) -> Character {
    return self[index(startIndex, offsetBy: i)]
  }
  subscript (i: Int) -> String {
    return String(self[i] as Character)
  }
  subscript (r: Range<Int>) -> String {
    let start = index(startIndex, offsetBy: r.lowerBound)
    let end = index(startIndex, offsetBy: r.upperBound)
    return self[Range(start ..< end)]
  }
}

 

为什么这不是内置的？

Apple提供以下解释(在此处找到):

使用整数订阅字符串不可用.

" i字符串中的第一个字符" 的概念在不同的库和系统组件中有不同的解释.应根据用例和所涉及的API选择正确的解释,因此String 不能使用整数进行下标.

Swift提供了几种不同的方法来访问存储在字符串中的字符数据.

• String.utf8是字符串中UTF-8代码单元的集合.将字符串转换为UTF-8时使用此API.大多数POSIX API根据UTF-8代码单元处理字符串.

• String.utf16是字符串中的UTF-16代码单元的集合.大多数Cocoa和Cocoa touch API根据UTF-16代码单元处理字符串.例如,NSRange与UTF-16代码单元一起使用NSAttributedString和 NSRegularExpression存储子字符串偏移量和长度的实例 .

• String.unicodeScalars是Unicode标量的集合.在对字符数据执行低级操作时使用此API.

• String.characters 是一组扩展的字形簇,它是用户感知字符的近似值.

请注意,在处理包含人类可读文本的字符串时,应尽可能避免逐个字符的处理.使用高级别语言环境敏感的Unicode算法代替,例如 String.localizedStandardCompare(), String.localizedLowercaseString, String.localizedStandardRangeOfString()等.

Answer 2

Swift 4.2及更早版本

let str = "abcdef"
str[1 ..< 3] // returns "bc"
str[5] // returns "f"
str[80] // returns ""
str.substring(fromIndex: 3) // returns "def"
str.substring(toIndex: str.length - 2) // returns "abcd"

您需要将此String扩展添加到项目中(它已经过全面测试):

extension String {

  var length: Int {
    return count
  }

  subscript (i: Int) -> String {
    return self[i ..< i + 1]
  }

  func substring(fromIndex: Int) -> String {
    return self[min(fromIndex, length) ..< length]
  }

  func substring(toIndex: Int) -> String {
    return self[0 ..< max(0, toIndex)]
  }

  subscript (r: Range<Int>) -> String {
    let range = Range(uncheckedBounds: (lower: max(0, min(length, r.lowerBound)),
                                        upper: min(length, max(0, r.upperBound))))
    let start = index(startIndex, offsetBy: range.lowerBound)
    let end = index(start, offsetBy: range.upperBound - range.lowerBound)
    return String(self[start ..< end])
  }

}

即使Swift总是有解决这个问题的解决方案(没有我在下面提供的String扩展),我仍然强烈建议使用扩展.为什么？因为它从早期版本的Swift中节省了数十小时的痛苦迁移,其中String的语法几乎每个版本都在变化,但我需要做的就是更新扩展的实现,而不是重构整个300k代码生产线.应用程序.做出你的选择.

let str = "Hello, world!"
let index = str.index(str.startIndex, offsetBy: 4)
str[index] // returns Character 'o'

let endIndex = str.index(str.endIndex, offsetBy:-2)
str[index ..< endIndex] // returns String "o, worl"

String(str.suffix(from: index)) // returns String "o, world!"
String(str.prefix(upTo: index)) // returns String "Hell"

Answer 3

我想出了这个整洁的解决方法

var firstChar = Array(string)[0]

Answer 4

没有使用整数的索引,只使用String.Index.主要是线性复杂性.您还可以String.Index使用它们创建范围并获取子字符串.

Swift 3.0

let firstChar = someString[someString.startIndex]
let lastChar = someString[someString.index(before: someString.endIndex)]
let charAtIndex = someString[someString.index(someString.startIndex, offsetBy: 10)]

let range = someString.startIndex..<someString.index(someString.startIndex, offsetBy: 10)
let substring = someString[range]

Swift 2.x

let firstChar = someString[someString.startIndex]
let lastChar = someString[someString.endIndex.predecessor()]
let charAtIndex = someString[someString.startIndex.advanceBy(10)]

let range = someString.startIndex..<someString.startIndex.advanceBy(10)
let subtring = someString[range]

请注意,您不能使用从一个字符串创建的索引(或范围)到另一个字符串

let index10 = someString.startIndex.advanceBy(10)

//will compile
//sometimes it will work but sometimes it will crash or result in undefined behaviour
let charFromAnotherString = anotherString[index10]

Answer 5

Swift 4.1或更高版本

您可以扩展Swift 4的StringProtocol以使下标也可用于子字符串.注意:由于建议SE-0191,__CODE__可以删除扩展约束 :

extension StringProtocol {
    subscript(_ offset: Int)                     -> Element     { self[index(startIndex, offsetBy: offset)] }
    subscript(_ range: Range<Int>)               -> SubSequence { prefix(range.lowerBound+range.count).suffix(range.count) }
    subscript(_ range: ClosedRange<Int>)         -> SubSequence { prefix(range.lowerBound+range.count).suffix(range.count) }
    subscript(_ range: PartialRangeThrough<Int>) -> SubSequence { prefix(range.upperBound.advanced(by: 1)) }
    subscript(_ range: PartialRangeUpTo<Int>)    -> SubSequence { prefix(range.upperBound) }
    subscript(_ range: PartialRangeFrom<Int>)    -> SubSequence { suffix(Swift.max(0, count-range.lowerBound)) }
}

extension LosslessStringConvertible {
    var string: String { .init(self) }
}

extension BidirectionalCollection {
    subscript(safe offset: Int) -> Element? {
        guard !isEmpty, let i = index(startIndex, offsetBy: offset, limitedBy: index(before: endIndex)) else { return nil }
        return self[i]
    }
}

测试

let test = "Hello USA !!! Hello Brazil !!!"
test[safe: 10]   // ""
test[11]   // "!"
test[10...]   // "!!! Hello Brazil !!!"
test[10..<12]   // "!"
test[10...12]   // "!!"
test[...10]   // "Hello USA "
test[..<10]   // "Hello USA "
test.first   // "H"
test.last    // "!"

// Subscripting the Substring
 test[...][...3]  // "Hell"

// Note that they all return a Substring of the original String.
// To create a new String from a substring
test[10...].string  // "!!! Hello Brazil !!!"

Answer 6

斯威夫特4

let str = "My String"

索引处的字符串

let index = str.index(str.startIndex, offsetBy: 3)
String(str[index])    // "S"

子

let startIndex = str.index(str.startIndex, offsetBy: 3)
let endIndex = str.index(str.startIndex, offsetBy: 7)
String(str[startIndex...endIndex])     // "Strin"

前n个字符

let startIndex = str.index(str.startIndex, offsetBy: 3)
String(str[..<startIndex])    // "My "

最后n个字符

let startIndex = str.index(str.startIndex, offsetBy: 3)
String(str[startIndex...])    // "String"

斯威夫特2和3

str = "My String"

**索引处的字符串**

斯威夫特2

let charAtIndex = String(str[str.startIndex.advancedBy(3)])  // charAtIndex = "S"

斯威夫特3

str[str.index(str.startIndex, offsetBy: 3)]

SubString fromIndex toIndex

斯威夫特2

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

斯威夫特3

str[str.index(str.startIndex, offsetBy: 3)...str.index(str.startIndex, offsetBy: 7)]

前n个字符

let first2Chars = String(str.characters.prefix(2)) // first2Chars = "My"

最后n个字符

let last3Chars = String(str.characters.suffix(3)) // last3Chars = "ing"

Answer 7

Swift 2.0从Xcode 7 GM Seed开始

var text = "Hello, world!"

let firstChar = text[text.startIndex.advancedBy(0)] // "H"

对于第n个字符,将0替换为n-1.

编辑:Swift 3.0

text[text.index(text.startIndex, offsetBy: 0)]

nb有更简单的方法来抓取字符串中的某些字符

例如 let firstChar = text.characters.first

Answer 8

如果你看到Cannot subscript a value of type 'String'...使用这个扩展名:

斯威夫特3

extension String {
    subscript (i: Int) -> Character {
        return self[self.characters.index(self.startIndex, offsetBy: i)]
    }

    subscript (i: Int) -> String {
        return String(self[i] as Character)
    }

    subscript (r: Range<Int>) -> String {
        let start = index(startIndex, offsetBy: r.lowerBound)
        let end = index(startIndex, offsetBy: r.upperBound)
        return self[start..<end]
    }

    subscript (r: ClosedRange<Int>) -> String {
        let start = index(startIndex, offsetBy: r.lowerBound)
        let end = index(startIndex, offsetBy: r.upperBound)
        return self[start...end]
    }
}

斯威夫特2.3

extension String {
    subscript(integerIndex: Int) -> Character {
        let index = advance(startIndex, integerIndex)
        return self[index]
    }

    subscript(integerRange: Range<Int>) -> String {
        let start = advance(startIndex, integerRange.startIndex)
        let end = advance(startIndex, integerRange.endIndex)
        let range = start..<end
        return self[range]
    }
}

资料来源:http://oleb.net/blog/2014/07/swift-strings/

Answer 9

斯威夫特 5.3

我认为这是非常优雅的。对此解决方案的“Hacking with Swift”的 Paul Hudson 表示赞赏：

@available (macOS 10.15, * )
extension String {
    subscript(idx: Int) -> String {
        String(self[index(startIndex, offsetBy: idx)])
    }
}

然后要从 String 中取出一个字符，您只需执行以下操作：

var string = "Hello, world!"

var firstChar = string[0] // No error, returns "H" as a String

注意：我只是想补充一下，这将返回String评论中指出的a 。我认为这对于 Swift 用户来说可能是意料之外的，但我经常需要String立即在我的代码中使用a而不是Character类型，所以它确实简化了我的代码，避免了以后从 Character 到 String 的转换。

Answer 10

Swift 2.2解决方案:

以下扩展适用于Xcode 7,这是此解决方案与Swift 2.0语法转换的组合.

extension String {
    subscript(integerIndex: Int) -> Character {
        let index = startIndex.advancedBy(integerIndex)
        return self[index]
    }

    subscript(integerRange: Range<Int>) -> String {
        let start = startIndex.advancedBy(integerRange.startIndex)
        let end = startIndex.advancedBy(integerRange.endIndex)
        let range = start..<end
        return self[range]
    }
}

Answer 11

swift字符串类不提供在特定索引处获取字符的能力,因为它本身支持UTF字符.内存中UTF字符的可变长度使得直接跳转到字符是不可能的.这意味着您每次都必须手动循环遍历字符串.

您可以扩展String以提供一种方法,该方法将循环遍历所需的索引

extension String {
    func characterAtIndex(index: Int) -> Character? {
        var cur = 0
        for char in self {
            if cur == index {
                return char
            }
            cur++
        }
        return nil
    }
}

myString.characterAtIndex(0)!

Answer 12

另外,有一些函数可以直接应用于String的Character-chain表示,如下所示:

var string = "Hello, playground"
let firstCharacter = string.characters.first // returns "H"
let lastCharacter = string.characters.last // returns "d"

结果是Character类型,但您可以将其强制转换为String.

或这个:

let reversedString = String(string.characters.reverse())
// returns "dnuorgyalp ,olleH" 

:-)

Answer 13

斯威夫特4

String(Array(stringToIndex)[index]) 

这可能是一次性解决此问题的最佳方法.您可能希望先将String转换为数组,然后再将结果转换为String.否则,将返回一个Character而不是String.

示例String(Array("HelloThere")[1])将"e"作为String返回.

(Array("HelloThere")[1] 将"e"作为角色返回.

Swift不允许将字符串像数组一样编入索引,但这可以完成工作,蛮力风格.

Answer 14

您可以通过将 String 转换为 Array 并使用下标通过特定索引获取它来做到这一点，如下所示

var str = "Hello"
let s = Array(str)[2]
print(s)

Answer 15

我非常简单的解决方案：

Swift 4.1：

let myString = "Test string"
let index = 0
let firstCharacter = myString[String.Index(encodedOffset: index)]

Swift 5.1：

let firstCharacter = myString[String.Index.init(utf16Offset: index, in: myString)]

Answer 16

我们有下标，这在这里非常有用

但是 String 下标会将参数作为 String.Index 所以大多数人都会在这里感到困惑如何传递 String.Index 来获取如何根据我们的要求形成 String.Index 的详细信息请查看下面的文档Apple 文档

这里我创建了一种扩展方法来获取字符串中的第 n 个字符

extension String {
    subscript(i: Int) -> String {
        return  i < count ? String(self[index(startIndex, offsetBy: i)]) : ""
    }
}

用法

let name = "Narayana Rao Routhu"
print(name[11]) //o
print(name[1]) //a
print(name[0]) //N
print(name[30]) //""

如果您传递超出字符串计数范围的索引，它将返回空字符串

Answer 17

我刚才有同样的问题.只需这样做:

var aString: String = "test"
var aChar:unichar = (aString as NSString).characterAtIndex(0)

Answer 18

迅捷3

您可以使用下标语法在特定的String索引处访问Character。

let greeting = "Guten Tag!"
let index = greeting.index(greeting.startIndex, offsetBy: 7)
greeting[index] // a

访问https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html

或者我们可以在Swift 4中进行字符串扩展

extension String {
    func getCharAtIndex(_ index: Int) -> Character {
        return self[self.index(self.startIndex, offsetBy: index)]
    }
}

用法：

let foo = "ABC123"
foo.getCharAtIndex(2) //C

Answer 19

目前，下标(_:)不可用。我们也做不到这一点

str[0] 

对于字符串。我们必须提供“String.Index”但是，我们如何以这种方式给出我们自己的索引号，我们可以使用，

string[str.index(str.startIndex, offsetBy: 0)]

Answer 20

在 Swift 5 中，无需扩展String：

var str = "ABCDEFGH"
for char in str {
if(char == "C") { }
}

上面的 Swift 代码与该代码相同Java：

int n = 8;
var str = "ABCDEFGH"
for (int i=0; i<n; i++) {
if (str.charAt(i) == 'C') { }
}