从 Swift 4+ 开始

它只是：

test1.count

出于原因。

（感谢 Martin 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

你可以像这样试试

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

顶级域名：

对于 Swift 2.0 和 3.0，请使用 .但是，您应该知道一些事情。所以，请继续阅读。test1.characters.count

在 Swift 中计算字符数

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

test1.characters.count

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

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

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

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

从语言参考：

扩展字素簇可以由一个或多个 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

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

aString.utf16count

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

针对 Xcode 6 beta 4 进行了更新，更改了方法 utf16count --> utf16Count

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

或

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

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

myString.isEmpty

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

NSString 为空

tl;dr 如果您想要 String 类型的长度与人类可读字符的数量有关，请使用 countElements（）。如果您想知道扩展字素簇数的长度，请使用 endIndex。请继续阅读了解详情。

String 类型是作为 Unicode 字符的有序集合（即序列）实现的，它符合 CollectionType 协议，该协议符合 _CollectionType协议，该协议是 countElements（） 预期的输入类型。因此，可以调用 countElements（），传递 String 类型，它将返回字符数。

但是，为了符合 CollectionType（而 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

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

countElements(str)

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

countElements((newString as String))    

这将计算 NSString 中的字符数

斯威夫特 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)

如果你正在寻找一种更简洁的方式来获取字符串的长度，请查看这个库，它有一堆对 Swift 内置类的扩展 http://www.dollarswift.org/#length

使用这个库，你可以"Some Str".length

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

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

在 Xcode 6.1.1 中

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

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

在 Swift 中计算字符串的最佳方法是：

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

Swift 1.2 更新：不再有用于计算集合大小的 countElements。只需使用 count 函数作为替代品：count（“Swift”）

Swift 2.0、3.0 和 3.1：

let strLength = 字符串.字符.计数

Swift 4.2（4.0 及更高版本）：[Apple 文档 - 字符串]

let strLength = 字符串.计数

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

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

String 和 NSString 是免费桥接，因此您可以将 NSString 可用的所有方法与 swift String 一起使用

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

使用 Xcode 6.4、Swift 1.2 和 iOS 8.4：

    //: Playground - noun: a place where people can play

    import UIKit

    var str = "  He\u{2606}  "
    count(str) // 7

    let length = count(str.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet())) as Int // 3
    println(length == 3) // true

您可以将此函数添加到您的扩展中

extension NSString { 
    func charLength() -> Int {
        return count(self as String)
    }
}

斯威夫特 2.0： 获取计数：yourString.text.characters.count

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

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

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

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

返回 24

您可以使用 SwiftString （https://github.com/amayne/SwiftString） 来执行此操作。

"string".length // 6

免责声明：我写了这个扩展

test1.characters.count

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

前任：

test1 = "StackOverflow"

print(test1.characters.count)

(指纹“13")

您可以使用，我认为哪个是最好的解决方案str.utf8.countstr.utf16.count

适用于 Xcode 7.3 和 Swift 2.2。

let str = "🐶"

1. 如果需要可视字符的数量：

   str.characters.count
   

2. 如果您想要“字符串的 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🐶🐶🐶

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

test1.characters.count

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

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

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

myString.characters.count 

该方法将返回一个“Distance”类型，如果你需要该方法返回一个 Integer，你应该像这样键入 cast：

var count = myString.characters.count as Int

从 textview 或 textfield 获取字符串值：

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

查找字符串中字符的计数：

let numberOfChars = textlength.characters.count

斯威夫特 4

"string".count

;)

斯威夫特 3

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

用法

"string".length

这是我最终所做的

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，它现在可以解释字素簇。例如，指望一个表情符号会给你 1，而在 swift 3.0 中，你可能会得到大于 1 的计数。

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

斯威夫特 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"

我的 Swift 3/4 两美分

如果需要有条件地编译

    #if swift(>=4.0)
            let len = text.count
        #else
            let len = text.characters.count
        #endif

test1.endIndex给出与 Swift 3 相同的结果test1.characters.count

通用 Swift 4 和 3 解决方案

/**
 * Since swift 4 There is also native count, But it doesn't return Int
 * NOTE: was: var count:Int { return self.characters.count }
 * EXAMPLE: "abc👌".count//Output: 4
 */
extension String{
    var count:Int {
        return self.distance(from: self.startIndex, to: self.endIndex)
    }
}

斯威夫特 4

let str =  "Your name"

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

你可以通过编写一个扩展来获得长度：

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

在 Swift 4.1 和 Xcode 9.4.1 中

在 Objective c 和 Swift 中获取长度是不同的。在 Obj-c 中，我们使用 length 属性，但在 Swift 中，我们使用 count 属性

例：

//In Swift
let stringLenght = "This is my String"
print(stringLenght.count)

//In Objective c
NSString * stringLenght = @"This is my String";
NSLog(@"%lu", stringLenght.length);

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

string.endIndex.encodedOffset

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

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

在 Swift 4.2 和 Xcode 10.1 中

在 Swift 中，字符串可以被视为单个字符的数组。因此，字符串中的每个字符都像数组中的一个元素。若要获取字符串的长度，请使用 yourStringName.count 属性。

在 Swift 中

yourStringName.characters.count属性。所以直接使用属性。strLength.count

let strLength = "This is my string"
print(strLength.count)
//print(strLength.characters.count) //Error: 'characters' is deprecated: Please use String or Substring directly

如果目标 C

NSString *myString = @"Hello World";
NSLog(@"%lu", [myString length]); // 11

Swift 5.0 字符串可以被视为单个字符的数组。因此，要返回字符串的长度，您可以使用 yourString.count 来计算字符数组中的项目数。