获取字符串的长度

从 Swift 4+ 开始

只是：

test1.count

原因。

（感谢马丁 R）

从 Swift 2 开始：

在 Swift 2 中，Apple 已将全局函数更改为协议扩展，即匹配任何符合协议的类型的扩展。因此，新语法是：

test1.characters.count

（感谢 JohnDifool 的提醒）

从 Swift 1 开始

使用计数字符方法：

let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
println("unusualMenagerie has \(count(unusualMenagerie)) characters")
// prints "unusualMenagerie has 40 characters"

直接来自 Apple Swift 指南

（注意，对于 1.2 之前的 Swift 版本，这将是 countElements(unusualMenagerie)）

对于您的变量，它将是

length = count(test1) // was countElements in earlier versions of Swift

或者你可以使用 test1.utf16count

---

TLDR：

对于 Swift 2.0 和 3.0， 使用 test1.characters.count。但是，有几件事你应该知道。所以，请继续阅读。

在 Swift 中计算字符

在 Swift 2.0 之前，count 是一个全局函数。从 Swift 2.0 开始，它可以作为成员函数调用。

test1.characters.count

它将返回 String 中的实际 Unicode 字符数，因此从某种意义上说，这是最正确的选择，如果您手动打印字符串并计算字符数，您将得到相同的结果。

但是，由于 Strings 在 Swift 中的实现方式，字符并不总是占用相同数量的内存，因此请注意，它的行为与其他语言中通常的字符计数方法完全不同。

例如，您还可以使用 test1.utf16.count

但是，如下所述，返回的值不能保证与在 characters 上调用 count 的值相同。

从语言参考：

扩展字素簇可以由一个或多个 Unicode 标量组成。这意味着不同的字符——以及同一字符的不同表示——可能需要不同数量的内存来存储。正因为如此，Swift 中的字符不会在字符串表示中占用相同数量的内存。因此，如果不迭代字符串以确定其扩展字素簇边界，就无法计算字符串中的字符数。如果您正在处理特别长的字符串值，请注意 characters 属性必须遍历整个字符串中的 Unicode 标量才能确定该字符串的字符。 characters 属性返回的字符数并不总是与包含相同字符的 NSString 的 length 属性相同。 NSString 的长度基于字符串的 UTF-16 表示中的 16 位代码单元的数量，而不是字符串中的 Unicode 扩展字形簇的数量。

一个完美说明上述情况的例子是检查包含单个表情符号字符的字符串的长度，正如评论中的 n00neimp0rtant 所指出的那样。

var emoji = "👍"
emoji.characters.count             //returns 1
emoji.utf16.count                  //returns 2

---

Swift 1.2 更新：不再有 countElements 用于计算集合的大小。只需使用 count 函数作为替代：count("Swift")

斯威夫特 2.0、3.0 和 3.1：

让 strLength = string.characters.count

Swift 4.2（4.0 以上）：[Apple Documentation - Strings]

让 strLength = string.count

---

斯威夫特 1.1

extension String {
    var length: Int { return countElements(self) }  // 
}

斯威夫特 1.2

extension String {
    var length: Int { return count(self)         }  // 
}

斯威夫特 2.0

extension String {
    var length: Int { return characters.count    }  // 
}

斯威夫特 4.2

extension String {
    var length: Int { return self.count }           
}

let str = "Hello"
let count = str.length    // returns 5 (Int)

---

斯威夫特 4

"string".count

;)

斯威夫特 3

extension String {
    var length: Int {
        return self.characters.count
    }
}

用法

"string".length

---

如果您只是想查看一个字符串是否为空（检查长度是否为 0），Swift 在 String 上提供了一个简单的布尔测试方法

myString.isEmpty

这枚硬币的另一面是人们在 ObjectiveC 中询问如何询问字符串是否为空，而答案是检查长度是否为 0：

NSString is empty

---

斯威夫特 5.1、5

let flag = "🇵🇷"

print(flag.count)
// Prints "1" --  Counts the characters and emoji as length 1

print(flag.unicodeScalars.count)
// Prints "2" --  Counts the unicode lenght ex. "A" is 65

print(flag.utf16.count)
// Prints "4"

print(flag.utf8.count)
// Prints "8"

---

tl;dr 如果您想根据人类可读字符的数量来计算 String 类型的长度，请使用 countElements()。如果您想知道扩展字素簇数的长度，请使用 endIndex。请继续阅读以了解详细信息。

String 类型实现为Unicode 字符的有序集合（即序列），它符合CollectionType 协议，它符合_CollectionType 协议，这是countElements() 所期望的输入类型。因此，可以调用 countElements()，传递一个 String 类型，它会返回字符数。

但是，在符合 CollectionType 又符合 _CollectionType 的同时，String 还实现了 startIndex 和 endIndex 计算属性，它们实际上分别表示索引在第一个字符簇之前的位置和索引在最后一个字符簇之后的位置.所以，在字符串“ABC”中，A之前的索引位置是0，C之后是3。所以endIndex = 3，这也是字符串的长度。

那么，endIndex 可以用来获取任何 String 类型的长度，对吧？

好吧，并非总是如此……Unicode 字符实际上是扩展的字素簇，它们是一个或多个 Unicode 标量的序列，组合起来创建一个人类可读的字符。

let circledStar: Character = "\u{2606}\u{20DD}" // ☆⃝

circledStar 是由 U+2606（白星）和 U+20DD（组合封闭圆）组成的单个字符。让我们从 circledStar 创建一个 String 并比较 countElements() 和 endIndex 的结果。

let circledStarString = "\(circledStar)"
countElements(circledStarString) // 1
circledStarString.endIndex // 2

---

在 Swift 2.0 count 中不再起作用。您可以改用它：

var testString = "Scott"
var length = testString.characters.count

---

这里有一些比使用全局函数更短、更自然的方法：

aString.utf16count

不过，我不知道它是否在 beta 1 中可用。但它肯定存在于 beta 2 中。

---

为 Xcode 6 beta 4 更新，更改方法 utf16count --> utf16Count

 var test1: String = "Scott"
 var length =  test1.utf16Count

或者

 var test1: String = "Scott"
 var length = test1.lengthOfBytesUsingEncoding(NSUTF16StringEncoding)

---

从 Swift 1.2 开始，utf16Count 已被删除。您现在应该使用全局 count() 函数并传递字符串的 UTF16 视图。下面的例子...

let string = "Some string"
count(string.utf16)

---

对于 Xcode 7.3 和 Swift 2.2。

let str = "🐶"

如果您想要可视字符的数量：str.characters.count 如果您想要“字符串的 UTF-16 表示中的 16 位代码单元”：str.utf16.count

大多数时候，1 是您所需要的。

什么时候需要2？我找到了 2 的用例：

let regex = try! NSRegularExpression(pattern:"🐶", 
    options: NSRegularExpressionOptions.UseUnixLineSeparators)
let str = "🐶🐶🐶🐶🐶🐶"
let result = regex.stringByReplacingMatchesInString(str, 
    options: NSMatchingOptions.WithTransparentBounds, 
    range: NSMakeRange(0, str.utf16.count), withTemplate: "dog")
print(result) // dogdogdogdogdogdog

如果使用 1，则结果不正确：

let result = regex.stringByReplacingMatchesInString(str, 
    options: NSMatchingOptions.WithTransparentBounds, 
    range: NSMakeRange(0, str.characters.count), withTemplate: "dog")
print(result) // dogdogdog🐶🐶🐶

---

你可以试试这样

var test1: String = "Scott"
var length =  test1.bridgeToObjectiveC().length

---

在 Swift 2.x 中，以下是如何找到字符串的长度

let findLength = "This is a string of text"
findLength.characters.count

返回 24

---

Swift 2.0：获取计数：yourString.text.characters.count

有趣的例子是在 UITextView 中显示某个数字（例如 150）的字符倒计时：

func textViewDidChange(textView: UITextView) {
    yourStringLabel.text = String(150 - yourStringTextView.text.characters.count)
}

---

在 swift4 中我一直使用 string.count 直到今天我发现

string.endIndex.encodedOffset

是更好的替换，因为它更快 - 对于 50 000 个字符，字符串比 .count 快大约 6 倍。 .count 取决于字符串长度，但 .endIndex.encodedOffset 不。

但是有一个NO。这对带有表情符号的字符串不好，它会给出错误的结果，所以只有 .count 是正确的。

---

在 Swift 4 中：如果字符串不包含 unicode 字符，则使用以下

let str : String = "abcd"
let count = str.count // output 4

如果字符串包含 unicode 字符，则使用以下内容：

let spain = "España"
let count1 = spain.count // output 6
let count2 = spain.utf8.count // output 7

---

在 Xcode 6.1.1 中

extension String {    
    var length : Int { return self.utf16Count  }
}

我认为 Brainiacs 会在每个次要版本上改变这一点。

---

从您的文本视图或文本字段中获取字符串值：

let textlengthstring = (yourtextview?.text)! as String

求字符串中的字符数：

let numberOfChars = textlength.characters.count

---

这是我最终做的

let replacementTextAsDecimal = Double(string)

if string.characters.count > 0 &&
    replacementTextAsDecimal == nil &&
    replacementTextHasDecimalSeparator == nil {
        return false
}

---

Swift 4 更新与 Swift 3 的比较

Swift 4 不再需要 String 上的字符数组。这意味着您可以直接在字符串上调用 count 而无需先获取字符数组。

"hello".count                  // 5

而在 swift 3 中，您将必须获取字符数组，然后计算该数组中的元素。请注意，以下方法在 swift 4.0 中仍然可用，因为您仍然可以调用 characters 来访问给定字符串的字符数组

"hello".characters.count       // 5

Swift 4.0 也采用了 Unicode 9，它现在可以解释字素簇。例如，在 swift 3.0 中，计数一个表情符号会给你 1，你可能会得到大于 1 的计数。

"👍🏽".count // Swift 4.0 prints 1, Swift 3.0 prints 2
"👨‍❤️‍💋‍👨".count // Swift 4.0 prints 1, Swift 3.0 prints 4

---

斯威夫特 4

let str =  "Your name"

str.count 

记住：空格也算在数字里

---

您只需编写扩展名即可获得长度：

extension String {
    // MARK: Use if it's Swift 2
    func stringLength(str: String) -> Int {
        return str.characters.count
    }

    // MARK: Use if it's Swift 3
    func stringLength(_ str: String) -> Int {
        return str.characters.count
    }

    // MARK: Use if it's Swift 4
    func stringLength(_ str: String) -> Int {
        return str.count
    }
}

---

var str = "Hello, playground"
var newString = str as NSString    

countElements(str)

这会计算常规 Swift 字符串中的字符

countElements((newString as String))    

这会计算 NSString 中的字符

---

在 Swift 中计算 String 的最佳方法是：

var str = "Hello World"
var length = count(str.utf16)

---

String 和 NSString 是免费的桥梁，因此您可以通过 swift String 使用 NSString 可用的所有方法

let x = "test" as NSString
let y : NSString = "string 2"
let lenx = x.count
let leny = y.count

---

test1.characters.count

将为您提供字符串中字母/数字等的数量。

前任：

test1 = "StackOverflow"

print(test1.characters.count)

（打印“13”）

---

苹果使它与其他主要语言不同。目前的方法是调用：

test1.characters.count

但是，要小心，当您说长度时，您的意思是字符数而不是字节数，因为当您使用非 ascii 字符时，这两者可能会有所不同。

例如; "你好啊hi".characters.count 会给你 5 但这不是字节数。要获得实际的字节数，您需要执行 "你好啊hi".lengthOfBytes(using: String.Encoding.utf8)。这会给你11。

---

现在（在 Swift 2.3 中）如果你使用：

myString.characters.count 

该方法将返回一个“距离”类型，如果您需要该方法返回一个整数，您应该像这样键入 cast：

var count = myString.characters.count as Int

---