Obtenir la longueur d'une chaîne
Comment obtenez-vous la longueur d'une 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)
À partir de Swift 2:
Avec Swift 2, Apple a modifié les fonctions globales en extensions de protocole, extensions correspondant à tout type conforme à un protocole. La nouvelle syntaxe est donc la suivante:
test1.characters.count
(Merci à JohnDifool pour le heads-up)
À partir de Swift 1
Utilisez la méthode de nombre de caractères:
let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
println("unusualMenagerie has \(count(unusualMenagerie)) characters")
// prints "unusualMenagerie has 40 characters"
directement du Guide Apple Swift
(notez que pour les versions de Swift antérieures à 1.2, ce serait plutôt countElements(unusualMenagerie))
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, utilisez test1.characters.count. Mais, il y a quelques choses que vous devriez 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 une String. C'est donc l'alternative la plus correcte en ce sens que si vous imprimez la chaîne et comptez les caractères à la main, vous obtiendrez le même résultat.
Cependant, en raison de la manière dont Strings est implémenté dans Swift, les caractères n'occupent pas toujours la même quantité de mémoire. Sachez donc que cela se comporte très différemment des méthodes de décompte des caractères habituelles dans d'autres langues.
Par exemple, vous pouvez également utiliser test1.utf16.count
Toutefois, comme indiqué ci-dessous, la valeur renvoyée n'est pas garantie comme celle de l'appel count sur characters.
De la référence de langue:
Les grappes de graphèmes étendus peuvent être composées d'un ou plusieurs Unicode scalaires. Cela signifie que différents personnages, et différents représentations du même caractère - peuvent nécessiter différentes quantités de mémoire à stocker. Pour cette raison, les personnages de Swift ne prennent pas chacun même quantité de mémoire dans la représentation d’une chaîne. Comme un 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 son extension graphème limites de cluster. Si vous travaillez avec une durée particulièrement longue valeurs de chaîne, sachez que la propriété characters doit parcourir plus de les scalaires Unicode dans la chaîne entière afin de déterminer le caractères pour cette chaîne.
Le nombre de caractères renvoyés par la propriété characters n’est pas toujours identique à la propriété length d'un NSString qui contient les mêmes personnages. La longueur d'un NSString est basée sur le nombre 16 bits dans la représentation UTF-16 de la chaîne et non 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’ya plus de compte élément pour compter la taille des collections. Il suffit d'utiliser la fonction de comptage en remplacement: count ("Swift")
Swift 2.0, 3.0 et 3.1:
let strLength = string.characters.count </ strike>
Swift 4.2 (à partir de la version 4.0): [Apple Documentation - Strings]
laisser strLength = string.count
let str = "Hello"
let count = str.length // returns 5 (Int)
extension String {
var length: Int { return countElements(self) } // Swift 1.1
}
extension String {
var length: Int { return count(self) } // Swift 1.2
}
extension String {
var length: Int { return characters.count } // Swift 2.0
}
extension String {
var length: Int { return self.count } // Swift 4.2
}
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 0), Swift propose une méthode de test booléen simple sur String
myString.isEmpty
L’autre côté de cette pièce était des gens qui demandaient à ObjectiveC comment demander si une chaîne était vide alors que la réponse était de vérifier une longueur de 0:
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 souhaitez connaître la longueur en termes de nombre de extended grapheme clusters, utilisez endIndex . Lisez la suite pour plus de détails.
Le type String est implémenté en tant que collection ordonnée (séquence) de caractères Unicode et 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 String type, qui retournera le nombre de caractères.
Cependant, conformément à CollectionType , qui à son tour est conforme à _CollectionType , String implémente également les propriétés startIndex et endIndex calculées, qui représentent en réalité la position l'index avant le premier groupe de caractères et la position de l'index après le dernier groupe 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 correspond également à la longueur de la chaîne.
Donc, endIndex peut être utilisé pour obtenir la longueur de tout type String, alors, non?
Pas toujours ... Les caractères Unicode sont en fait des étendus grappes de graphèmes, 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 (étoile blanche) et de U + 20DD (cercle de combinaison). Créons un String from circledStar et comparons les résultats de countElements () et endIndex .
let circledStarString = "\(circledStar)"
countElements(circledStarString) // 1
circledStarString.endIndex // 2
Dans Swift 2.0, count ne fonctionne plus. Vous pouvez utiliser ceci à la place:
var testString = "Scott"
var length = testString.characters.count
Voici quelque chose de plus court et plus naturel que d'utiliser une fonction globale:
aString.utf16count
Je ne sais pas s'il est disponible en version bêta 1, cependant. Mais c'est vraiment là en beta 2.
Mise à jour pour Xcode 6 beta 4, modification de 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, utf16Count a été supprimé. Vous devez maintenant utiliser la fonction globale count() 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 // 1
2) Si vous voulez le 16-bit code units within the string’s UTF-16 representation:
str.utf16.count // 2
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 l’utilité de cette méthode serait d’afficher un compte à rebours de caractères parmi un certain nombre (150 par exemple) dans une UITextView:
func textViewDidChange(textView: UITextView) {
yourStringLabel.text = String(150 - yourStringTextView.text.characters.count)
}
Swift 4.2
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"
Dans Swift4 j'ai toujours utilisé string.count jusqu'à aujourd'hui, j'ai trouvé que
string.endIndex.encodedOffset
est la meilleure substitution car elle est plus rapide - pour une chaîne de 50 000 caractères, environ 6 fois plus vite que .count Le .count dépend de la longueur de la chaîne, mais pas .endIndex.encodedOffset.
Mais il y a un NON. Ce n'est pas bon pour les chaînes avec emojis, cela donnera un résultat faux, donc seul .count est 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
Voici ce que j'ai fini par faire
let replacementTextAsDecimal = Double(string)
if string.characters.count > 0 &&
replacementTextAsDecimal == nil &&
replacementTextHasDecimalSeparator == nil {
return false
}
Obtenir une valeur de chaîne depuis 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
Dans Xcode 6.1.1
extension String {
var length : Int { return self.utf16Count }
}
Je pense que les cerveaux vont changer cela sur chaque version mineure.
Swift 4
let str = "Your name"
str.count
Rappelez-vous: 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
}
}
Apple l'a rendu différent des autres langues principales. Le moyen actuel est d'appeler:
test1.characters.count
Cependant, soyez prudent, lorsque vous indiquez longueur, vous entendez le nombre de caractères et non le nombre d'octets, car ils peuvent être différents lorsque vous utilisez des caractères non-ascii.
Par exemple; "你好啊hi".characters.count vous en donnera 5 mais ce n'est pas le nombre d'octets . Pour obtenir le nombre réel d'octets, vous devez utiliser "你好啊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 renvoyer un entier, vous devez taper cast comme ceci:
var count = myString.characters.count as Int
mes deux cents pour Swift 3/4
Si vous avez besoin de compiler sous condition
#if Swift(>=4.0)
let len = text.count
#else
let len = text.characters.count
#endif
La meilleure façon de compter String dans Swift est la suivante:
var str = "Hello World"
var length = count(str.utf16)
Mise à jour de Swift 4 en comparant avec Swift 3
Swift 4 supprime la nécessité d'un tableau de caractères sur String. Cela signifie que vous pouvez appeler directement count sur une chaîne sans obtenir d’abord un tableau de caractères.
"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 characters pour 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 peut désormais interpréter les grappes de graphèmes. Par exemple, compter sur un emoji vous donnera 1, alors 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
var str = "Hello, playground"
var newString = str as NSString
countElements(str)
Ceci compte les personnages dans la chaîne Swift régulière
countElements((newString as String))
Ceci compte les caractères dans un NSString
String et NSString sont des ponts gratuits qui vous permettent d’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)
( empreintes "13")
// String literal
let s = "Hello world"
// Get the length of the string
let length = s.characters.count
print(length)
Solution universelle Swift 4 et 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)
}
}
Vous pouvez utiliser str.utf8.count et str.utf16.count qui, je pense, sont la meilleure solution
Utilisation de Xcode 6.4 , Swift 1.2 et 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
Vous pouvez ajouter cette fonction à votre extension
extension NSString {
func charLength() -> Int {
return count(self as String)
}
}
Les chaînes Swift 5.0 peuvent être traitées comme un tableau de caractères individuels. Ainsi, pour renvoyer la longueur d'une chaîne, vous pouvez utiliser yourString.count pour compter le nombre d'éléments dans le tableau de caractères.
si tu veux compter n'importe quelle longueur de corde
Essayez ce moyen très simple:
Pour Swift:
var test1: String = "Scott"
La ligne de code ci-dessous doit compter la longueur de la chaîne:
test1.count
ou tu peux essayer ça aussi:
test1.characters.count
Puisse cela vous aider.
Je vous remercie.
Dans Swift 4.1 et Xcode 9.4.1
Obtenir de la longueur dans Objective C et Swift est différent. Dans Obj-c, nous utilisons length property, mais dans Swift, nous utilisons count property
Exemple :
//In Swift
let stringLenght = "This is my String"
print(stringLenght.count)
//In Objective C
NSString * stringLenght = @"This is my String";
NSLog(@"%lu", stringLenght.length);
test1.endIndex donne le même résultat que test1.characters.count sur Swift 3
Dans Swift 4.2 et Xcode 10.1
Dans Swift, les chaînes peuvent être traitées comme un tableau de caractères individuels. Ainsi, chaque caractère d'une chaîne est comme un élément d'un tableau. Pour obtenir la longueur d'une chaîne, utilisez yourStringName.count property.
Dans Swift
La propriété yourStringName.characters.count est déconseillée. Utilisez donc directement la propriété 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
Si Objectif C
NSString *myString = @"Hello World";
NSLog(@"%lu", [myString length]); // 11