Comment obtenez-vous la longueur d'un String? Par exemple, j'ai une variable définie comme:

var test1: String = "Scott"

Cependant, je n'arrive pas à trouver une méthode de longueur sur la chaîne.

À partir de Swift 4+

C'est juste:

test1.count

pour des raisons.

(Merci à Martin R)

Depuis Swift 2:

Avec Swift 2, Apple a changé les fonctions globales en extensions de protocole, extensions qui correspondent à tout type conforme à un protocole. Ainsi, la nouvelle syntaxe est:

test1.characters.count

(Merci à JohnDifool pour l'avertissement)

À partir de Swift 1

Utilisez la méthode du nombre de caractères:

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

directement depuis le Guide Apple Swift

(notez que pour les versions de Swift antérieures à 1.2, ce serait countElements(unusualMenagerie)plutôt)

pour votre variable, ce serait

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

Ou vous pouvez utiliser test1.utf16count

TLDR:

Pour Swift 2.0 et 3.0, utiliseztest1.characters.count . Mais, il y a quelques choses que vous devez savoir. Alors, lisez la suite.

Compter les caractères dans Swift

Avant Swift 2.0, countétait une fonction globale. Depuis Swift 2.0, il peut être appelé en tant que fonction membre.

test1.characters.count

Il renverra le nombre réel de caractères Unicode dans a String, c'est donc l'alternative la plus correcte dans le sens où, si vous imprimiez la chaîne et comptiez les caractères à la main, vous obtiendriez le même résultat.

Cependant, en raison de la façon dont ils Stringssont implémentés dans Swift, les caractères n'occupent pas toujours la même quantité de mémoire, alors sachez que cela se comporte assez différemment des méthodes de comptage de caractères habituelles dans d'autres langues.

Par exemple, vous pouvez également utiliser test1.utf16.count

Mais, comme il est indiqué ci - dessous, la valeur retournée est pas garanti d'être le même que celui d'appeler countlecharacters .

De la référence de langue:

Les grappes de graphèmes étendues peuvent être composées d'un ou plusieurs scalaires Unicode. Cela signifie que différents caractères et différentes représentations du même caractère peuvent nécessiter différentes quantités de mémoire pour être stockées. Pour cette raison, les caractères dans Swift n'occupent pas chacun la même quantité de mémoire dans la représentation d'une chaîne. Par conséquent, le nombre de caractères d'une chaîne ne peut pas être calculé sans parcourir la chaîne pour déterminer ses limites étendues de grappe de graphèmes. Si vous travaillez avec des valeurs de chaîne particulièrement longues, sachez que la propriété caractères doit itérer sur les scalaires Unicode de la chaîne entière afin de déterminer les caractères de cette chaîne.

Le nombre de caractères renvoyés par la propriété caractères n'est pas toujours le même que la propriété de longueur d'une NSString qui contient les mêmes caractères. La longueur d'une chaîne NSS est basée sur le nombre d'unités de code 16 bits dans la représentation UTF-16 de la chaîne et non sur le nombre de grappes de graphèmes étendus Unicode dans la chaîne.

Un exemple qui illustre parfaitement la situation décrite ci-dessus est celui de la vérification de la longueur d'une chaîne contenant un seul caractère emoji, comme indiqué par n00neimp0rtant dans les commentaires.

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

Mise à jour Swift 1.2: il n'y a plus de countElements pour compter la taille des collections. Utilisez simplement la fonction count comme remplacement: count ("Swift")

Swift 2.0, 3.0 et 3.1:

laissez strLength = string.characters.count

Swift 4.2 (à partir de 4.0): [Documentation Apple - Chaînes]

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

usage

"string".length

Si vous essayez simplement de voir si une chaîne est vide ou non (vérification de la longueur de 0), Swift propose une méthode de test booléenne simple sur String

myString.isEmpty

L'autre côté de cette pièce était des gens qui demandaient dans ObjectiveC comment demander si une chaîne était vide où la réponse devait vérifier une longueur de 0:

NSString est vide

tl; dr Si vous voulez la longueur d'un type String en termes de nombre de caractères lisibles par l'homme, utilisez countElements () . Si vous voulez connaître la longueur en termes de nombre de grappes de graphèmes étendus , utilisez endIndex . Lisez la suite pour plus de détails.

Le type String est implémenté comme une collection ordonnée (c'est-à-dire une séquence) de caractères Unicode, et il est conforme au protocole CollectionType , qui est conforme au protocole _CollectionType , qui est le type d'entrée attendu par countElements () . Par conséquent, countElements () peut être appelé, en passant un type String , et il renverra le nombre de caractères.

Cependant, en se conformant à CollectionType , qui à son tour est conforme à _CollectionType , String implémente également les propriétés calculées startIndex et endIndex , qui représentent en fait la position de l'index avant le premier cluster de caractères et la position de l'index après le dernier cluster de caractères, respectivement . Ainsi, dans la chaîne "ABC", la position de l'index avant A est 0 et après C est 3. Par conséquent, endIndex = 3, qui est également la longueur de la chaîne.

Ainsi, endIndex peut être utilisé pour obtenir la longueur de tout type de chaîne, alors, non?

Eh bien, pas toujours ... Les caractères Unicode sont en fait des grappes de graphèmes étendus , qui sont des séquences d'un ou plusieurs scalaires Unicode combinés pour créer un seul caractère lisible par l'homme.

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

circledStar est un caractère unique composé de U + 2606 (une étoile blanche) et U + 20DD (un cercle englobant combinant). Créons une chaîne à partir de circledStar et comparons les résultats de countElements () et endIndex .

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

Dans Swift 2.0 countne fonctionne plus. Vous pouvez utiliser ceci à la place:

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

Voici quelque chose de plus court et de plus naturel que d'utiliser une fonction globale:

aString.utf16count

Cependant, je ne sais pas s'il est disponible en version bêta 1. Mais c'est définitivement là dans la bêta 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"

Mis à jour pour Xcode 6 beta 4, changez la méthode utf16count -> utf16Count

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

Ou

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

À partir de Swift 1.2 utf16Counta été supprimé. Vous devez maintenant utiliser la count()fonction globale et passer la vue UTF16 de la chaîne. Exemple ci-dessous ...

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

Pour Xcode 7.3 et Swift 2.2.

let str = "🐶"

1. Si vous voulez le nombre de caractères visuels:

   str.characters.count

2. Si vous voulez les "unités de code 16 bits dans la représentation UTF-16 de la chaîne":

   str.utf16.count

La plupart du temps, 1 est ce dont vous avez besoin.

Quand auriez-vous besoin de 2 ? J'ai trouvé un cas d'utilisation pour 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

Si vous utilisez 1 , le résultat est incorrect:

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

Tu pourrais essayer comme ça

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

dans Swift 2.x, voici comment trouver la longueur d'une chaîne

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

renvoie 24

Swift 2.0: Obtenez un décompte: yourString.text.characters.count

Un exemple amusant de la façon dont cela est utile serait d'afficher un compte à rebours de caractères à partir d'un certain nombre (150 par exemple) dans un UITextView:

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

Dans swift4, j'ai toujours utilisé string.countjusqu'à aujourd'hui, j'ai trouvé que

string.endIndex.encodedOffset

est la meilleure substitution car elle est plus rapide - pour 50 000 caractères, la chaîne est environ 6 fois plus rapide que .count. Cela .countdépend de la longueur de la chaîne, mais .endIndex.encodedOffsetpas.

Mais il y a un NON. Ce n'est pas bon pour les cordes avec des emojis, cela donnera un mauvais résultat, donc seul .countest correct.

Dans Swift 4 : si la chaîne ne contient pas de caractères unicode, utilisez ce qui suit

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

Si la chaîne contient des caractères unicode, utilisez ce qui suit:

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

Dans Xcode 6.1.1

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

Je pense que les brainiacs changeront cela sur chaque version mineure.

Obtenez la valeur de chaîne de votre textview ou textfield:

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

Trouvez le nombre de caractères dans la chaîne:

let numberOfChars = textlength.characters.count

Voici ce que j'ai fini par faire

let replacementTextAsDecimal = Double(string)

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

Mise à jour de Swift 4 comparant avec Swift 3

Swift 4 supprime le besoin d'un tableau de caractères sur String. Cela signifie que vous pouvez appeler directement countune chaîne sans obtenir de tableau de caractères au préalable.

"hello".count                  // 5

Alors que dans swift 3, vous devrez obtenir un tableau de caractères, puis compter l'élément dans ce tableau. Notez que cette méthode suivante est toujours disponible dans swift 4.0 car vous pouvez toujours appeler characterspour accéder au tableau de caractères de la chaîne donnée

"hello".characters.count       // 5

Swift 4.0 adopte également Unicode 9 et il peut désormais interpréter les grappes de graphèmes. Par exemple, compter sur un emoji vous donnera 1 tandis que dans swift 3.0, vous pouvez obtenir un nombre supérieur à 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 

N'oubliez pas: l'espace est également compté dans le nombre

Vous pouvez obtenir la longueur simplement en écrivant une extension:

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)

Cela compte les caractères de la chaîne Swift régulière

countElements((newString as String))    

Cela compte les caractères dans une chaîne NSS

La meilleure façon de compter String dans Swift est la suivante:

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

String et NSString sont des ponts gratuits afin que vous puissiez utiliser toutes les méthodes disponibles pour NSString avec swift String

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

test1.characters.count

vous obtiendrez le nombre de lettres / chiffres, etc. dans votre chaîne.

ex:

test1 = "StackOverflow"

print(test1.characters.count)

( imprime " 13 ")

Apple l'a rendu différent des autres langues principales. La méthode actuelle consiste à appeler:

test1.characters.count

Cependant, pour être prudent, lorsque vous dites longueur, vous entendez le nombre de caractères et non le nombre d'octets, car ces deux peuvent être différents lorsque vous utilisez des caractères non ascii.

Par exemple; "你好啊hi".characters.countvous donnera 5 mais ce n'est pas le nombre d'octets. Pour obtenir le nombre réel d'octets, vous devez le faire "你好啊hi".lengthOfBytes(using: String.Encoding.utf8). Cela vous donnera 11.

En ce moment (dans Swift 2.3) si vous utilisez:

myString.characters.count 

la méthode retournera un type "Distance", si vous avez besoin de la méthode pour retourner un entier, vous devez taper cast comme ceci:

var count = myString.characters.count as Int