Générer une chaîne alphanumérique aléatoire dans Swift

Comment générer une chaîne alphanumérique aléatoire dans Swift?

func randomSsortingngWithLength (len : Int) -> NSSsortingng { let letters : NSSsortingng = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" var randomSsortingng : NSMutableSsortingng = NSMutableSsortingng(capacity: len) for (var i=0; i < len; i++){ var length = UInt32 (letters.length) var rand = arc4random_uniform(length) randomString.appendFormat("%C", letters.characterAtIndex(Int(rand))) } return randomString } 

Swift 3.0 Update

 func randomSsortingng(length: Int) -> Ssortingng { let letters : NSSsortingng = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" let len = UInt32(letters.length) var randomSsortingng = "" for _ in 0 ..< length { let rand = arc4random_uniform(len) var nextChar = letters.character(at: Int(rand)) randomString += NSString(characters: &nextChar, length: 1) as String } return randomString } 

Voici une solution prête à l’emploi en syntaxe Swift . Vous pouvez simplement copier et coller:

 func randomAlphaNumericSsortingng(length: Int) -> Ssortingng { let allowedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" let allowedCharsCount = UInt32(allowedChars.characters.count) var randomSsortingng = "" for _ in 0.. 

Si vous préférez un framework qui comporte également des fonctionnalités plus pratiques, n'hésitez pas à consulter mon projet HandySwift . Il comprend également une belle solution pour les chaînes alphanumériques aléatoires :

 Ssortingng(randomWithLength: 8, allowedCharactersType: .alphaNumeric) // => "2TgM5sUG" 

Vous pouvez également l’utiliser de la manière suivante:

 extension Ssortingng { static func random(length: Int = 20) -> Ssortingng { let base = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" var randomSsortingng: Ssortingng = "" for _ in 0.. 

Utilisation simple:

 let randomSsortingng = Ssortingng.random() 

Swift 3 Syntaxe:

 extension Ssortingng { static func random(length: Int = 20) -> Ssortingng { let base = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" var randomSsortingng: Ssortingng = "" for _ in 0.. 

Swift 4 Syntaxe:

 extension Ssortingng { static func random(length: Int = 20) -> Ssortingng { let base = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" var randomSsortingng: Ssortingng = "" for _ in 0.. 

Rapide:

 let randomSsortingng = NSUUID().uuidSsortingng 

Version rapide 2.2

 // based on https://gist.github.com/samuel-mellert/20b3c99dec168255a046 // which is based on https://gist.github.com/szhernovoy/276e69eb90a0de84dd90 // Updated to work on Swift 2.2 func randomSsortingng(length: Int) -> Ssortingng { let charactersSsortingng = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" let charactersArray : [Character] = Array(charactersSsortingng.characters) var ssortingng = "" for _ in 0.. 

Appelez cette méthode pour générer une chaîne aléatoire de la longueur de l'entier remis à la fonction. Pour changer les caractères possibles, éditez simplement la chaîne charactersSsortingng. Prend également en charge les caractères Unicode.

https://gist.github.com/gingofthesouth/54bea667b28a815b2fe33a4da986e327

Simple et rapideUUID (). UuidSsortingng

// Retourne une chaîne créée à partir de l’UUID, telle que “E621E1F8-C36C-495A-93FC-0C247A3E6E5F”

public var uuidSsortingng: Ssortingng {get}

https://developer.apple.com/documentation/foundation/uuid

Swift 3.0

 let randomSsortingng = UUID().uuidSsortingng //0548CD07-7E2B-412B-AD69-5B2364644433 print(randomSsortingng.replacingOccurrences(of: "-", with: "")) //0548CD077E2B412BAD695B2364644433 

MODIFIER

S’il vous plaît ne pas confondre avec UIDevice.current.identifierForVendor?.uuidSsortingng il ne donnera pas de valeurs aléatoires.

pour Swift 3.0

 func randomSsortingng(_ length: Int) -> Ssortingng { let letters : NSSsortingng = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" let len = UInt32(letters.length) var randomSsortingng = "" for _ in 0 ..< length { let rand = arc4random_uniform(len) var nextChar = letters.character(at: Int(rand)) randomString += NSString(characters: &nextChar, length: 1) as String } return randomString } 

Avec Swift 4.2, le mieux est de créer une chaîne avec les caractères souhaités, puis d’utiliser randomElement pour sélectionner chaque caractère:

 let length = 32 let characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" let randomCharacters = (0.. 

Je détaille plus sur ces changements ici .

 func randomSsortingng(length: Int) -> Ssortingng { // whatever letters you want to possibly appear in the output (unicode handled properly by Swift) let letters = "abcABC012你好吗😀🐱💥∆𝚹∌⌘" let n = UInt32(letters.characters.count) var out = "" for _ in 0.. 

Ma mise en œuvre encore plus rapide de la question:

 func randomAlphanumericSsortingng(length: Int) -> Ssortingng { let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".characters let lettersLength = UInt32(letters.count) let randomCharacters = (0.. Ssortingng in let offset = Int(arc4random_uniform(lettersLength)) let c = letters[letters.startIndex.advancedBy(offset)] return Ssortingng(c) } return randomCharacters.joinWithSeparator("") } 

Peut sauver quelqu’un en tapant, si vous avez le cas inhabituel que

la performance compte.

Voici une fonction extrêmement simple, claire et autonome qui met en cache,

(Je pense que c’est le genre de chose que vous laisseriez simplement au niveau mondial pour plus de simplicité.)

 func randomNameSsortingng(length: Int = 7)->Ssortingng{ enum s { static let c = Array("abcdefghjklmnpqrstuvwxyz12345789".characters) static let k = UInt32(c.count) } var result = [Character](repeating: "a", count: length) for i in 0.. 

Notez que le point ici est celui d'un jeu de caractères fixe et connu - il est mis en cache.

Si vous avez besoin d'un autre jeu de caractères différent, faites simplement une autre fonction en cache,

 func randomVowelsSsortingng(length: Int = 20)->Ssortingng{ enum s { static let c = Array("AEIOU".characters) ... 

Astuce pratique:

Notez que l'ensemble "abcdefghjklmnpqrstuvwxyz12345789" évite les "mauvais" caractères

Il n'y a pas 0, o, O, i, etc ... les personnages confondent souvent les humains.

Ceci est souvent fait pour les codes de réservation, etc.

Si votre chaîne aléatoire doit être sécurisée, utilisez ceci:

 import Foundation import Security // ... private static func createAlphaNumericRandomSsortingng(length: Int) -> Ssortingng? { // create random numbers from 0 to 63 // use random numbers as index for accessing characters from the symbols ssortingng // this limit is chosen because it is close to the number of possible symbols AZ, az, 0-9 // so the error rate for invalid indices is low let randomNumberModulo: UInt8 = 64 // indices greater than the length of the symbols ssortingng are invalid // invalid indices are skipped let symbols = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" var alphaNumericRandomSsortingng = "" let maximumIndex = symbols.count - 1 while alphaNumericRandomSsortingng.count != length { let bytesCount = 1 var randomByte: UInt8 = 0 guard errSecSuccess == SecRandomCopyBytes(kSecRandomDefault, bytesCount, &randomByte) else { return nil } let randomIndex = randomByte % randomNumberModulo // check if index exceeds symbols ssortingng length, then skip guard randomIndex < = maximumIndex else { continue } let symbolIndex = symbols.index(symbols.startIndex, offsetBy: Int(randomIndex)) alphaNumericRandomString.append(symbols[symbolIndex]) } return alphaNumericRandomString } 

Le problème avec les réponses aux questions “J’ai besoin de chaînes aléatoires” (dans n’importe quel langage) est pratiquement que chaque solution utilise une spécification primaire imparfaite de longueur de chaîne . Les questions elles-mêmes révèlent rarement pourquoi les chaînes aléatoires sont nécessaires, mais je conteste que vous ayez rarement besoin de chaînes de longueur aléatoires, disons 8. Ce dont vous avez invariablement besoin, c’est un certain nombre de chaînes uniques , par exemple.

Il existe deux manières principales d’obtenir des chaînes ssortingctement uniques : de manière déterministe (qui n’est pas aléatoire) et stocker / comparer (ce qui est onéreux). Qu’est-ce qu’on fait? Nous abandonnons le fantôme. Nous allons plutôt avec l’ unicité probabiliste . C’est-à-dire que nous acceptons qu’il y ait un risque (même faible) que nos chaînes ne soient pas uniques. C’est là que la compréhension de la probabilité de collision et de l’ entropie sont utiles.

Je vais donc reformuler le besoin invariable comme un certain nombre de chaînes avec un faible risque de répétition. Comme exemple concret, supposons que vous souhaitiez générer un potentiel de 5 millions d’ID. Vous ne voulez pas stocker et comparer chaque nouvelle chaîne, et vous voulez qu’elles soient aléatoires, vous acceptez donc un certain risque de répétition. Par exemple, supposons un risque de moins de 1 pour cent milliards de chances de répétition. Alors quelle longueur de ficelle avez-vous besoin? Eh bien, cette question est sous-spécifiée car elle dépend des caractères utilisés. Mais plus important encore, il est erroné. Ce dont vous avez besoin, c’est d’une spécification de l’entropie des chaînes, et non de leur longueur. L’entropie peut être directement liée à la probabilité d’une répétition dans un certain nombre de chaînes. La longueur de la chaîne ne peut pas.

Et c’est là qu’une bibliothèque comme EntropySsortingng peut vous aider. Pour générer des identifiants aléatoires dont les chances de répétition sont inférieures à 1 billion sur 5 millions de chaînes à l’aide d’ EntropySsortingng :

 import EntropySsortingng let random = Random() let bits = Entropy.bits(for: 5.0e6, risk: 1.0e12) random.ssortingng(bits: bits) 

“Rrrj6pN4d6GBrFLH4”

EntropySsortingng utilise un jeu de caractères avec 32 caractères par défaut. Il existe d’autres jeux de caractères prédéfinis et vous pouvez également spécifier vos propres personnages. Par exemple, générer des identifiants avec la même entropie que ci-dessus mais en utilisant des caractères hexadécimaux:

 import EntropySsortingng let random = Random(.charSet16) let bits = Entropy.bits(for: 5.0e6, risk: 1.0e12) random.ssortingng(bits: bits) 

“135fe71aec7a80c02dce5”

Notez la différence de longueur de chaîne en raison de la différence entre le nombre total de caractères dans le jeu de caractères utilisé. Le risque de répétition dans le nombre spécifié de chaînes potentielles est le même. Les longueurs de chaîne ne sont pas. Mieux encore, le risque de répétition et le nombre potentiel de chaînes sont explicites. Plus besoin de deviner avec la longueur de la chaîne.

Si vous avez juste besoin d’un identifiant unique, UUID().uuidSsortingng peut vous servir.

C’est la solution la plus rapide que je puisse trouver. Swift 3.0

 extension Ssortingng { static func random(length: Int) -> Ssortingng { let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" let randomLength = UInt32(letters.characters.count) let randomSsortingng: Ssortingng = (0 ..< length).reduce(String()) { accum, _ in let randomOffset = arc4random_uniform(randomLength) let randomIndex = letters.index(letters.startIndex, offsetBy: Int(randomOffset)) return accum.appending(String(letters[randomIndex])) } return randomString } } 

Rapide :

Simplement simplifié pour une manière compréhensible en rapidité.

 func randomSsortingng(_ length: Int) -> Ssortingng { let master = Array("abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ_123456789".characters) //0...62 = 63 var randomSsortingng = "" for _ in 1...length{ let random = arc4random_uniform(UInt32(master.count)) randomSsortingng.append(Ssortingng(master[Int(random)])) } return randomSsortingng } 

Mis à jour pour Swift 4. Utilisez une variable stockée paresseuse sur l’extension de classe. Cela n’est calculé qu’une fois.

 extension Ssortingng { static var chars: [Character] = { return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".map({$0}) }() static func random(length: Int) -> Ssortingng { var partial: [Character] = [] for _ in 0.. 

Sans boucle, bien qu’il soit limité à 43 caractères. Si vous avez besoin de plus, il peut être modifié. Cette approche présente deux avantages par rapport à l’utilisation exclusive d’un UUID:

  1. Entropie supérieure en utilisant des lettres minuscules, car UUID() génère uniquement des lettres majuscules
  2. Un UUID au maximum 36 caractères (y compris les 4 tirets), mais seulement 32 caractères de long sans. Si vous avez besoin de quelque chose de plus long ou si vous ne voulez pas que les tirets base64EncodedSsortingng inclus, l’utilisation de base64EncodedSsortingng gère cela.

En outre, cette fonction utilise un UInt pour éviter les nombres négatifs.

  func generateRandom(size: UInt) -> Ssortingng { let prefixSize = Int(min(size, 43)) let uuidSsortingng = UUID().uuidSsortingng.replacingOccurrences(of: "-", with: "") return Ssortingng(Data(uuidSsortingng.utf8) .base64EncodedSsortingng() .replacingOccurrences(of: "=", with: "") .prefix(prefixSize)) } 

L’appel en boucle pour vérifier la sortie:

 for _ in 0...10 { print(generateRandom(size: 32)) } 

Qui produit:

 Nzk3NjgzMTdBQ0FBNDFCNzk2MDRENzZF MUI5RURDQzE1RTdCNDA3RDg2MTI4QkQx M0I3MjJBRjVFRTYyNDFCNkI5OUM1RUVC RDA1RDZGQ0IzQjI1NDdGREI3NDgxM0Mx NjcyNUQyOThCNzhCNEVFQTk1RTQ3NTIy MDkwRTQ0RjFENUFGNEFDOTgyQTUxODI0 RDU2OTNBOUJGMDE4NDhEODlCNEQ1NjZG RjM2MTUxRjM4RkY3NDU2OUFDOTI0Nzkz QzUwOTE1N0U1RDVENDE4OEE5NTM2Rjcy Nzk4QkMxNUJEMjYwNDJDQjhBQkY5QkY5 ODhFNjU0MDVEMUI2NEI5QUIyNjNCNkVF 

Une Ssortingng aléatoire Swift pure à partir de n’importe quel CharacterSet .

Utilisation: CharacterSet.alphanumerics.randomSsortingng(length: 100)

 extension CharacterSet { /// extracting characters /// https://stackoverflow.com/a/52133647/1033581 public func characters() -> [Character] { return codePoints().compactMap { UnicodeScalar($0) }.map { Character($0) } } public func codePoints() -> [Int] { var result: [Int] = [] var plane = 0 for (i, w) in bitmapRepresentation.enumerated() { let k = i % 8193 if k == 8192 { plane = Int(w) < < 13 continue } let base = (plane + k) << 3 for j in 0 ..< 8 where w & 1 << j != 0 { result.append(base + j) } } return result } /// building random string of desired length /// https://stackoverflow.com/a/42895178/1033581 public func randomString(length: Int) -> Ssortingng { let charArray = characters() let charArrayCount = UInt32(charArray.count) var randomSsortingng = "" for _ in 0 ..< length { randomString += String(charArray[Int(arc4random_uniform(charArrayCount))]) } return randomString } } 

La fonction characters() est mon implémentation la plus rapide connue .

 func randomUIDSsortingng(_ wlength: Int) -> Ssortingng { let letters : NSSsortingng = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" var randomSsortingng = "" for _ in 0 ..< wlength { let length = UInt32 (letters.length) let rand = arc4random_uniform(length) randomString = randomString.appendingFormat("%C", letters.character(at: Int(rand))); } return randomString }