Ottieni la lunghezza di una stringa

Come si ottiene la lunghezza di una String ? Ad esempio, ho una variabile definita come:

 var test1: String = "Scott" 

Tuttavia, non riesco a trovare un metodo di lunghezza sulla stringa.

A partire da Swift 4

È appena:

 test1.count 

per ragioni.

(Grazie a Martin R)

A partire da Swift 2:

Con Swift 2, Apple ha cambiato le funzioni globali in estensioni di protocollo, estensioni che corrispondono a qualsiasi tipo conforms a un protocollo. Quindi la nuova syntax è:

 test1.characters.count 

(Grazie a JohnDifool per l’heads up)

A partire da Swift 1

Usa il metodo dei caratteri di conteggio:

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

direttamente dalla Apple Swift Guide

(nota, per le versioni di Swift precedenti alla 1.2, questo sarebbe countElements(unusualMenagerie) )

per la tua variabile, sarebbe

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

Oppure puoi utilizzare test1.utf16count

TLDR:

Per Swift 2.0 e 3.0, utilizzare test1.characters.count . Ma ci sono alcune cose che dovresti sapere. Quindi, continua a leggere.

Conteggio dei personaggi in Swift

Prima di Swift 2.0, count era una funzione globale. A partire da Swift 2.0, può essere chiamato come funzione membro.

 test1.characters.count 

Restituirà il numero effettivo di caratteri Unicode in una String , quindi è l’alternativa più corretta nel senso che, se si stampasse la stringa e si contassero i caratteri a mano, si otterrebbe lo stesso risultato.

Tuttavia, a causa del modo in cui le Strings vengono implementate in Swift, i caratteri non occupano sempre la stessa quantità di memoria, quindi tieni presente che questo comportamento si comporta in modo diverso rispetto ai soliti metodi di conteggio dei caratteri in altre lingue.

Ad esempio, puoi anche utilizzare test1.utf16.count

Ma, come indicato di seguito, il valore restituito non è garantito per essere uguale a quello del count delle chiamate sui characters .

Dalla lingua di riferimento:

I graft grapheme estesi possono essere composti da uno o più scalari Unicode. Ciò significa che caratteri diversi e rappresentazioni diverse dello stesso carattere possono richiedere diverse quantità di memoria da memorizzare. Per questo motivo, i personaggi di Swift non occupano la stessa quantità di memoria all’interno della rappresentazione di una stringa. Di conseguenza, il numero di caratteri in una stringa non può essere calcolato senza iterare attraverso la stringa per determinarne i limiti del cluster grafo esteso. Se stai lavorando con valori di stringa particolarmente lunghi, tieni presente che la proprietà dei caratteri deve iterare sugli scalari Unicode nell’intera stringa per determinare i caratteri per quella stringa.

Il conteggio dei caratteri restituiti dalla proprietà caratteri non è sempre uguale alla proprietà length di una NSString che contiene gli stessi caratteri. La lunghezza di una NSString si basa sul numero di unità di codice a 16 bit all’interno della rappresentazione UTF-16 della stringa e non sul numero di cluster grapheme estesi Unicode all’interno della stringa.

Un esempio che illustra perfettamente la situazione descritta sopra è quello di verificare la lunghezza di una stringa contenente un singolo carattere emoji, come sottolineato da n00neimp0rtant nei commenti.

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

Aggiornamento Swift 1.2: non ci sono più countElements per il conteggio delle dimensioni delle raccolte. Usa semplicemente la funzione di conteggio come ricambio: count (“Swift”)

Swift 2.0, 3.0 e 3.1:

let strLength = string.characters.count

Swift 4.0: [Apple Documentation – Stringhe]

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

Swift 4

"string".count

😉

Swift 3

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

uso

"string".length

Se stai solo cercando di vedere se una stringa è vuota o no (controllando la lunghezza di 0), Swift offre un semplice metodo di test booleano su String

 myString.isEmpty 

L’altro lato di questa moneta era la gente che chiedeva in ObjectiveC come chiedere se una stringa era vuota dove la risposta era di controllare una lunghezza di 0:

NSString è vuoto

tl; dr Se si desidera la lunghezza di un tipo di stringa in termini di numero di caratteri leggibili dall’uomo, utilizzare countElements () . Se vuoi conoscere la lunghezza in termini di numero di grafi estesi grapheme , usa endIndex . Continua a leggere per i dettagli.

Il tipo String viene implementato come una raccolta ordinata (ad esempio, sequenza) di caratteri Unicode ed è conforms al protocollo CollectionType , che è conforms al protocollo _CollectionType , che è il tipo di input previsto da countElements () . Pertanto, countElements () può essere chiamato, passando un tipo String , e restituirà il conteggio dei caratteri.

Tuttavia, in conformità a CollectionType , che a sua volta si conforma a _CollectionType , String implementa anche le proprietà calcolate startIndex e endIndex , che rappresentano effettivamente la posizione dell’indice prima del primo cluster di caratteri e la posizione dell’indice dopo l’ultimo cluster di caratteri, rispettivamente . Quindi, nella stringa “ABC”, la posizione dell’indice prima di A è 0 e dopo C è 3. Pertanto, endIndex = 3, che è anche la lunghezza della stringa.

Quindi, endIndex può essere utilizzato per ottenere la lunghezza di qualsiasi tipo di stringa, quindi, giusto?

Beh, non sempre … I caratteri Unicode sono in realtà grappoli grapheme estesi , che sono sequenze di uno o più scalari Unicode combinati per creare un singolo carattere leggibile dall’uomo.

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

circledStar è un singolo carattere composto da U + 2606 (una stella bianca) e U + 20DD (un cerchio che racchiude un cerchio). Creiamo una stringa da circledStar e confrontiamo i risultati di countElements () e endIndex .

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

Ecco qualcosa di più breve e più naturale rispetto all’utilizzo di una funzione globale:

 aString.utf16count 

Non so se è disponibile in beta 1, però. Ma è sicuramente lì nella beta 2.

count Swift 2.0 non funziona più. Puoi usare questo invece:

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

Aggiornato per Xcode 6 beta 4, cambia metodo utf16count -> utf16Count

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

O

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

A partire da Swift 1.2 utf16Count è stato rimosso. Ora dovresti usare la funzione count() globale e passare la vista UTF16 della stringa. Esempio sotto …

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

Per XCode 7.3 e Swift 2.2.

 let str = "🐶" 

1) Se vuoi il numero di caratteri visivi:

 str.characters.count // 1 

2) Se si desidera che le 16-bit code units within the string's UTF-16 representation :

 str.utf16.count // 2 



La maggior parte delle volte, 1) è ciò di cui hai bisogno.

Quando avresti bisogno di 2)? Ho trovato un caso d’uso per 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 si utilizza 1), il risultato non è corretto:

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

Potresti provare in questo modo

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

in Swift 2.x il seguente è come trovare la lunghezza di una stringa

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

restituisce 24

Swift 2.0: ottieni un conteggio: yourString.text.characters.count

Un divertente esempio di come è utile sarebbe mostrare un conto alla rovescia di un carattere da un numero (150 per esempio) in un UITextView:

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

Swift 4.0

 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" 

In Xcode 6.1.1

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

Penso che i brainiac lo cambieranno su ogni versione minore.

Ottieni il valore di stringa dalla tua textview o textfield:

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

Trova il conteggio dei caratteri nella stringa:

 let numberOfChars = textlength.characters.count 

In Swift 4 : se la stringa non contiene caratteri unicode, utilizzare quanto segue

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

Se la stringa contiene caratteri Unicode, utilizzare quanto segue:

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

Puoi ottenere la lunghezza semplicemente scrivendo un’estensione:

 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) 

Conta i personaggi in Regular Swift String

 countElements((newString as String)) 

Conta i personaggi in una NSString

Il modo migliore per contare le stringhe in Swift è questo:

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

String e NSString sono pedaggi gratuiti, quindi puoi utilizzare tutti i metodi disponibili per NSString con String rapido

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

otterrà il numero di lettere / numeri ecc. nella stringa.

ex:

 test1 = "StackOverflow" print(test1.characters.count) 

( stampa13 “)

Apple lo ha reso diverso dalle altre lingue principali. Il modo attuale è chiamare:

test1.characters.count

Tuttavia, per fare attenzione, quando si dice lunghezza si intende il conteggio dei caratteri non il conteggio dei byte, perché questi due possono essere diversi quando si usano caratteri non ascii.

Per esempio; "你好啊hi".characters.count ti darà 5 ma questo non è il numero dei byte. Per ottenere il conteggio reale dei byte, è necessario eseguire "你好啊hi".lengthOfBytes(using: String.Encoding.utf8) . Questo ti darà 11.

In questo momento (in Swift 2.3) se usi:

 myString.characters.count 

il metodo restituirà un tipo “Distanza”, se hai bisogno del metodo per restituire un intero devi digitare cast così:

 var count = myString.characters.count as Int 

Ecco cosa ho finito per fare

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

Aggiornamento Swift 4 a confronto con swift 3

Swift 4 rimuove la necessità di un array di caratteri su String. Ciò significa che è ansible chiamare direttamente il count su una stringa senza prima ottenere l’array di caratteri.

 "hello".count // 5 

Mentre in swift 3 dovrai ottenere array di caratteri e poi contare l’elemento in quell’array. Si noti che questo metodo seguente è ancora disponibile in swift 4.0 poiché è ancora ansible chiamare characters per accedere alla matrice di caratteri della stringa data

 "hello".characters.count // 5 

Swift 4.0 adotta anche Unicode 9 e ora può interpretare grapheme cluster. Ad esempio, il conteggio su un’emoji ti darà 1 mentre in swift 3.0, potresti ottenere un numero maggiore di 1.

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

i miei due centesimi per 3/4 veloci

Se è necessario compilare condizionatamente

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

Swift 4

 let str = "Your name" str.count 

Ricorda: lo spazio è anche conteggiato nel numero