La génération aléatoire d'une chaîne alphanumérique dans le Cacao

Voici un moyen rapide et sale de mise en œuvre. N'a pas été testé.

NSString *letters = @"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

-(NSString *) randomStringWithLength: (int) len {

    NSMutableString *randomString = [NSMutableString stringWithCapacity: len];

    for (int i=0; i<len; i++) {
         [randomString appendFormat: @"%C", [letters characterAtIndex: arc4random_uniform([letters length])]];
    }

    return randomString;
}

NSString *alphabet  = @"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXZY0123456789";
NSMutableString *s = [NSMutableString stringWithCapacity:20];
for (NSUInteger i = 0U; i < 20; i++) {
    u_int32_t r = arc4random() % [alphabet length];
    unichar c = [alphabet characterAtIndex:r];
    [s appendFormat:@"%C", c];
}

Si vous êtes prêt à vous limiter à des caractères hexadécimaux, puis l'option la plus simple est de générer un UUID:

NSString *uuid = [NSUUID UUID].UUIDString;

Exemple de sortie: 16E3DF0B-87B3-4162-A1A1-E03DB2F59654.

Si vous voulez une petite chaîne aléatoire, alors vous pouvez prendre juste les 8 premiers caractères.

C'est une version 4 UUID qui signifie que le premier caractère dans le 3ème et le 4ème groupe n'est pas aléatoire (ils seront toujours 4 et l'un des 8, 9, A ou B).

Tous les autres caractères d'une chaîne est complètement aléatoire et vous pouvez générer des millions de Uuid de chaque seconde pour des centaines d'années sans trop de risque de le même UUID généré deux fois.

Vous pourriez tout aussi bien générer un UUID. Bien que pas vraiment au hasard, ils sont complexes et uniques, ce qui les rend semblent aléatoires pour la plupart des utilisations. Générer un comme une chaîne, puis de prendre une série de caractères égal à la longueur.

Voici une autre façon de l'aborder. Au lieu d'utiliser une chaîne de caractères, vous pouvez convertir entre les entiers et les personnages, et de générer une liste dynamique de caractères à sélectionner. Il est assez léger et rapide, mais a un peu plus de code.

int charNumStart = (int) '0';
int charNumEnd = (int) '9';
int charCapitalStart = (int) 'A';
int charCapitalEnd = (int) 'Z';
int charLowerStart = (int) 'a';
int charLowerEnd = (int) 'z';
int amountOfChars = (charNumEnd - charNumStart) + (charCapitalEnd - charCapitalStart) + (charLowerEnd - charLowerStart); //amount of the characters we want.
int firstGap = charCapitalStart - charNumEnd; //there are gaps of random characters between numbers and uppercase letters, so this allows us to skip those.
int secondGap = charLowerStart - charCapitalEnd; //similar to above, but between uppercase and lowercase letters.
//START generates a log to show us which characters we are considering for our UID.
NSMutableString *chars = [NSMutableString stringWithCapacity:amountOfChars];
for (int i = charNumStart; i <= charLowerEnd; i++) {
if ((i >= charNumStart && i <= charNumEnd) || (i >= charCapitalStart && i <= charCapitalEnd) || (i >= charLowerStart && i <= charLowerEnd)) {
[chars appendFormat:@"\n%c", (char) i];
}
}
NSLog(@"chars: %@", chars);
//END log
//Generate a uid of 20 characters that chooses from our desired range.
int uidLength = 20;
NSMutableString *uid = [NSMutableString stringWithCapacity:uidLength];
for (int i = 0; i < uidLength; i++) {
//Generate a random number within our character range.
int randomNum = arc4random() % amountOfChars;
//Add the lowest value number to line this up with a desirable character.
randomNum += charNumStart;
//if the number is in the letter range, skip over the characters between the numbers and letters.
if (randomNum > charNumEnd) {
randomNum += firstGap;
}
//if the number is in the lowercase letter range, skip over the characters between the uppercase and lowercase letters.
if (randomNum > charCapitalEnd) {
randomNum += secondGap;
}
//append the chosen character.
[uid appendFormat:@"%c", (char) randomNum];
}
NSLog(@"uid: %@", uid);
//Generate a UID that selects any kind of character, including a lot of punctuation. It's a bit easier to do it this way.
int amountOfAnyCharacters = charLowerEnd - charNumStart; //A new range of characters.
NSMutableString *multiCharUid = [NSMutableString stringWithCapacity:uidLength];
for (int i = 0; i < uidLength; i++) {
//Generate a random number within our new character range.
int randomNum = arc4random() % amountOfAnyCharacters;
//Add the lowest value number to line this up with our range of characters.
randomNum += charNumStart;
//append the chosen character.
[multiCharUid appendFormat:@"%c", (char) randomNum];
}
NSLog(@"multiCharUid: %@", multiCharUid);

Quand je fais du caractère aléatoire de la génération, je préfère travailler directement avec des entiers, et les jetèrent dessus, au lieu d'écrire la liste des caractères que je veux en tirer. Déclarer les variables dans le haut, il est plus indépendant du système, mais ce code suppose que les nombres ont une valeur inférieure à celle des lettres, et que les majuscules ont une valeur inférieure à celle des lettres minuscules.

Ajoutant à la bonne réponse donnée par Melvin, voici une fonction que j'ai faite (dans SWIFT!) pour obtenir une chaîne de caractères aléatoires:

func randomStringOfLength(length:Int)->String{
var wantedCharacters:NSString="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXZY0123456789"
var s=NSMutableString(capacity: length)
for (var i:Int = 0; i < length; i++) {
let r:UInt32 = arc4random() % UInt32( wantedCharacters.length)
let c:UniChar = wantedCharacters.characterAtIndex( Int(r) )
s.appendFormat("%C", c)
}
return s
}

Ici est le résultat d'un test à partir de l'appelant randomStringOfLength(10): uXa0igA8wm

Modification de quelques idées ici, et en fait Swift 4.0

extension String
{
subscript (i: Int) -> Character
{
return self[index(startIndex, offsetBy:i)]
}
static func Random(length:Int=32, alphabet:String="ABCDEF0123456789") -> String
{
let upperBound = UInt32(alphabet.count)
return String((0..<length).map { _ -> Character in
return alphabet[Int(arc4random_uniform(upperBound))]
})
}
}

Utilisation:

let myHexString = String.Random()
let myLongHexString = String.Random(length:64)
let myLettersString = String.Random(length:32, alphabet:"ABCDEFGHIJKLMNOPQRSTUVWXYZ")

Je l'ai fait à l'aide d'un simple char[] au lieu d'une NSString * de l'alphabet. J'ai ajouté ceci à un NSString catégorie.

static const char __alphabet[] =
"0123456789"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz";
+ (NSString *)randomString:(int)length
{
NSMutableString *randomString = [NSMutableString stringWithCapacity:length];
u_int32_t alphabetLength = (u_int32_t)strlen(__alphabet);
for (int i = 0; i < length; i++) {
[randomString appendFormat:@"%c", __alphabet[arc4random_uniform(alphabetLength)]];
}
return randomString;
}

Méthode à appeler:

---

NSString *string = [self stringWithRandomSuffixForFile:@"file.pdf" withLength:4]

Méthode:

---

- (NSString *)stringWithRandomSuffixForFile:(NSString *)file withLength:(int)length
{
NSString *alphabet = @"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
NSString *fileExtension = [file pathExtension];
NSString *fileName = [file stringByDeletingPathExtension];
NSMutableString *randomString = [NSMutableString stringWithFormat:@"%@_", fileName];
for (int x = 0; x < length; x++) {
[randomString appendFormat:@"%C", [alphabet characterAtIndex: arc4random_uniform((int)[alphabet length]) % [alphabet length]]];
}
[randomString appendFormat:@".%@", fileExtension];
NSLog(@"## randomString: %@ ##", randomString);
return randomString;
}

Résultats:

---

## randomString: file_Msci.pdf ##
## randomString: file_xshG.pdf ##
## randomString: file_abAD.pdf ##
## randomString: file_HVwV.pdf ##

#define ASCII_START_NUMERS 0x30
#define ASCII_END_NUMERS 0x39
#define ASCII_START_LETTERS_A 0x41
#define ASCII_END_LETTERS_Z 0x5A
#define ASCII_START_LETTERS_a 0x61
#define ASCII_END_LETTERS_z 0x5A
-(NSString *)getRandomString:(int)length {
NSMutableString *result = [[NSMutableString alloc]init];
while (result.length != length) {
NSMutableData* data = [NSMutableData dataWithLength:1];
SecRandomCopyBytes(kSecRandomDefault, 1, [data mutableBytes]);
Byte currentChar = 0;
[data getBytes:&currentChar length:1];
NSString *s = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
if (currentChar > ASCII_START_NUMERS && currentChar < ASCII_END_NUMERS) { //0 to 0
[result appendString:s];
continue;
}
if (currentChar > ASCII_START_LETTERS_A && currentChar < ASCII_END_LETTERS_Z) { //0 to 0
[result appendString:s];
continue;
}
if (currentChar > ASCII_START_LETTERS_a && currentChar < ASCII_END_LETTERS_z) { //0 to 0
[result appendString:s];
continue;
}
}
return result;
}