Como você consegue o comprimento de um String? Por exemplo, eu tenho uma variável definida como:

var test1: String = "Scott"

No entanto, parece que não consigo encontrar um método de comprimento na string.

A partir do Swift 4+

É apenas:

test1.count

por razões.

(Obrigado a Martin R)

A partir do Swift 2:

Com o Swift 2, a Apple mudou as funções globais para extensões de protocolo, extensões que correspondem a qualquer tipo em conformidade com um protocolo. Portanto, a nova sintaxe é:

test1.characters.count

(Obrigado a JohnDifool pelo aviso)

A partir do Swift 1

Use o método de contagem de caracteres:

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

direto do Guia Apple Swift

(observe, para versões do Swift anteriores à 1.2, isso seria o caso countElements(unusualMenagerie))

para sua variável, seria

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

Ou você pode usar test1.utf16count

TLDR:

Para Swift 2.0 e 3.0, use test1.characters.count. Mas, há algumas coisas que você deve saber. Então, continue a ler.

Contando caracteres no Swift

Antes do Swift 2.0, countera uma função global. A partir do Swift 2.0, ele pode ser chamado como uma função de membro.

test1.characters.count

Ele retornará o número real de caracteres Unicode em a String, portanto, é a alternativa mais correta no sentido de que, se você imprimir a string e contar caracteres à mão, obterá o mesmo resultado.

No entanto, devido à maneira como Stringssão implementadas no Swift, os caracteres nem sempre ocupam a mesma quantidade de memória; portanto, lembre-se de que isso se comporta de maneira bem diferente dos métodos comuns de contagem de caracteres em outros idiomas.

Por exemplo, você também pode usar test1.utf16.count

Mas, como observado abaixo, o valor retornado não é garantido para ser o mesmo que o de chamar counton characters.

A partir da referência do idioma:

Clusters de grafema estendidos podem ser compostos de um ou mais escalares Unicode. Isso significa que caracteres diferentes - e diferentes representações do mesmo caractere - podem exigir quantidades diferentes de memória para serem armazenadas. Por esse motivo, os caracteres no Swift não ocupam a mesma quantidade de memória na representação de uma string. Como resultado, o número de caracteres em uma sequência não pode ser calculado sem percorrer a sequência para determinar seus limites estendidos do cluster grafema. Se você estiver trabalhando com valores de cadeia particularmente longos, lembre-se de que a propriedade de caracteres deve iterar sobre os escalares Unicode em toda a cadeia, a fim de determinar os caracteres dessa cadeia.

A contagem dos caracteres retornados pela propriedade caracteres nem sempre é igual à propriedade length de um NSString que contém os mesmos caracteres. O comprimento de um NSString é baseado no número de unidades de código de 16 bits na representação UTF-16 da string e não no número de clusters de grafema estendidos Unicode na string.

Um exemplo que ilustra perfeitamente a situação descrita acima é o de verificar o comprimento de uma sequência que contém um único caractere emoji, conforme apontado por n00neimp0rtant nos comentários.

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

Atualização Swift 1.2: não há mais countElements para contar o tamanho das coleções. Basta usar a função count como um substituto: count ("Swift")

Swift 2.0, 3.0 e 3.1:

deixe strLength = string.characters.count

Swift 4.2 (4.0 em diante): [Apple Documentation - Strings]

deixe strLength = string.count

Swift 1.1

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

Swift 1.2

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

Swift 2.0

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

Swift 4.2

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

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

Swift 4

"string".count

;)

Swift 3

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

uso

"string".length

Se você está apenas tentando ver se uma string está vazia ou não (verificando se o comprimento é 0), o Swift oferece um método de teste booleano simples em String

myString.isEmpty

O outro lado dessa moeda eram pessoas perguntando no ObjectiveC como perguntar se uma string estava vazia, onde a resposta era verificar se o comprimento era 0:

NSString está vazio

tl; dr Se você deseja o comprimento de um tipo String em termos do número de caracteres legíveis por humanos, use countElements () . Se você quiser saber o tamanho em termos do número de clusters de grafema estendidos , use endIndex . Continue lendo para obter detalhes.

O tipo String é implementado como uma coleção ordenada (ou seja, sequência) de caracteres Unicode e está em conformidade com o protocolo CollectionType , que está em conformidade com o protocolo _CollectionType , que é o tipo de entrada esperado por countElements () . Portanto, countElements () pode ser chamado, passando um tipo String e retornará a contagem de caracteres.

No entanto, em conformidade com CollectionType , que por sua vez está em conformidade com _CollectionType , Cordas também implementa as startIndex e endIndex propriedades computadas, o que realmente representam a posição do índice antes de o primeiro conjunto de caracteres, ea posição do índice após o último cluster caráter, respectivamente . Portanto, na cadeia "ABC", a posição do índice antes de A é 0 e depois de C é 3. Portanto, endIndex = 3, que também é o comprimento da cadeia.

Então, endIndex pode ser usado para obter o comprimento de qualquer tipo de String, certo?

Bem, nem sempre ... Os caracteres Unicode são, na verdade , conjuntos de grafemas estendidos , que são sequências de um ou mais escalares Unicode combinados para criar um único caractere legível por humanos.

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

circledStar é um caractere único composto por U + 2606 (uma estrela branca) e U + 20DD (um círculo anexo). Vamos criar uma String a partir de circledStar e comparar os resultados de countElements () e endIndex .

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

No Swift 2.0 countnão funciona mais. Você pode usar isso:

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

Aqui está algo mais curto e mais natural do que usar uma função global:

aString.utf16count

Não sei se está disponível na versão beta 1. Mas está definitivamente lá na versão beta 2.

Swift 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"

Atualizado para o Xcode 6 beta 4, altere o método utf16count -> utf16Count

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

Ou

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

A partir do Swift 1.2 utf16Countfoi removida. Agora você deve usar a count()função global e passar a visualização UTF16 da string. Exemplo abaixo ...

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

Para o Xcode 7.3 e Swift 2.2.

let str = "🐶"

1. Se você deseja o número de caracteres visuais:

   str.characters.count

2. Se você deseja "as unidades de código de 16 bits na representação UTF-16 da string":

   str.utf16.count

Na maioria das vezes, 1 é o que você precisa.

Quando você precisaria de 2 ? Encontrei um caso de uso para 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

Se você usar 1 , o resultado está incorreto:

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

Você poderia tentar assim

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

no Swift 2.x, a seguir, é como encontrar o comprimento de uma string

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

retorna 24

Swift 2.0: obtenha uma contagem: yourString.text.characters.count

Um exemplo divertido de como isso é útil seria mostrar uma contagem regressiva de caracteres de algum número (150 por exemplo) em um UITextView:

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

No swift4 eu sempre usei string.countaté hoje, descobri que

string.endIndex.encodedOffset

é a melhor substituição porque é mais rápida - para 50 000 caracteres, a sequência é cerca de 6 vezes mais rápida que .count. O .countdepende do comprimento da corda, mas .endIndex.encodedOffsetnão o faz.

Mas existe um NÃO. Não é bom para seqüências de caracteres com emojis, ele dará resultado errado, portanto, apenas .countestá correto.

No Swift 4 : se a sequência não contiver caracteres unicode, use o seguinte

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

Se a sequência contiver caracteres unicode, use o seguinte:

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

No Xcode 6.1.1

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

Eu acho que os brainiacs vão mudar isso em todas as versões menores.

Obtenha o valor da sequência de caracteres na sua visualização de texto ou campo de texto:

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

Encontre a contagem dos caracteres na string:

let numberOfChars = textlength.characters.count

Aqui está o que eu acabei fazendo

let replacementTextAsDecimal = Double(string)

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

Atualização do Swift 4 em comparação com o Swift 3

O Swift 4 remove a necessidade de uma matriz de caracteres na String. Isso significa que você pode chamar diretamente countuma sequência sem obter primeiro a matriz de caracteres.

"hello".count                  // 5

Enquanto no swift 3, você precisará obter uma matriz de caracteres e depois contar o elemento nessa matriz. Observe que este método a seguir ainda está disponível no swift 4.0, pois você ainda pode chamar characterspara acessar a matriz de caracteres da sequência especificada

"hello".characters.count       // 5

O Swift 4.0 também adota o Unicode 9 e agora pode interpretar clusters de grafema. Por exemplo, contar com um emoji lhe dará 1 enquanto no swift 3.0, você pode obter contagens maiores que 1.

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

Swift 4

let str =  "Your name"

str.count 

Lembre-se: o espaço também é contado no número

Você pode obter o comprimento simplesmente escrevendo uma extensão:

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)

Isso conta os caracteres em Regular Swift String

countElements((newString as String))    

Isso conta os caracteres em um NSString

A melhor maneira de contar String em Swift é esta:

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

String e NSString são pontes gratuitas para que você possa usar todos os métodos disponíveis para o NSString com String rápida

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

test1.characters.count

você receberá o número de letras / números etc em sua string.

ex:

test1 = "StackOverflow"

print(test1.characters.count)

( imprime " 13 ")

A Apple tornou diferente de outro idioma importante. A maneira atual é chamar:

test1.characters.count

No entanto, para ter cuidado, quando você diz comprimento, significa a contagem de caracteres e não a contagem de bytes, porque esses dois podem ser diferentes quando você usa caracteres não-ascii.

Por exemplo; "你好啊hi".characters.countlhe dará 5, mas essa não é a contagem de bytes. Para obter a contagem real de bytes, você precisa "你好啊hi".lengthOfBytes(using: String.Encoding.utf8). Isso lhe dará 11.

Agora (no Swift 2.3) se você usar:

myString.characters.count 

o método retornará um tipo "Distância", se você precisar retornar um número inteiro, digite cast da seguinte forma:

var count = myString.characters.count as Int