Генерация случайной буквенно-цифровой строки в какао

145

Я хочу вызвать метод, передать ему длину и сгенерировать случайную буквенно-цифровую строку.

Существуют ли какие-либо служебные библиотеки, которые могут иметь несколько таких функций?

подопечный
источник

Ответы:

312

Вот быстрая и грязная реализация. Не был проверен

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;
}
Джефф Б
источник
1
genRandStringLength должен просто вернуть randomString. Нет причин выделять и инициировать (а не авто-релиз!) Целую новую строку.
Kevingessner
5
Просто собираюсь выпустить это там. Нет смысла использовать NSStringдля, lettersкогда простой charмассив будет работать просто отлично. На самом деле, использование [letters characterAtIndex:(rand() % [letters length])]кажется мне менее лаконичным, чем просто letters[rand() % strlen(letters)]. Базовые классы действительно полезны, но для самых простых вещей они могут помочь запутать наш код, а не улучшить его.
Джонатан Стерлинг
3
вы можете захотеть %Cвместо %c, потому что characterAtIndex:возвращаетunichar
user102008
8
Использование arc4random приведет к смещенному результату, когда длина массива не является степенью двойки. arc4random_uniform исправляет это.
Jlukanta
9
о, компилятор выдаст предупреждение о потере точности, поэтому лучше привести к intarc4random_uniform((int)[letters length])
knshn
103

Не совсем то, что вы просите, но все же полезно:

[[NSProcessInfo processInfo] globallyUniqueString]

Пример вывода:

450FEA63-2286-4B49-8ACC-9822C7D4356B-1376-00000239A4AC4FD5
myeyesareblind
источник
2
Это, безусловно, самый короткий и простой способ решения вопроса.
Адиб
Даже если в нем есть дефисы - если это не проблема, тогда круто!
фатухоку
Лучший ответ на милю
Рамбатино
Идеально подходит для моей необходимости "генерировать случайные буквенно-цифровые строки в какао". Не совсем то, что спрашивает ОП только потому, что он добавляет требование «передать ему длину», которое YAGNI!
jkoreska
5
Это, вероятно, нормально для большинства случаев, но НЕ ИСПОЛЬЗУЙТЕ, если вам нужна случайная строка в целях безопасности. Уникальный! = Случайный. Длина постоянна, диапазон используемых символов ограничен (0-9, AF, - = 17, против 62 для aZ. 0-9). Эта строка уникальна, но предсказуема.
AMCC
67
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];
}
Melvin
источник
13
Вам действительно нужно alphabetкаждый раз запрашивать длину ? Он постоянен и не зависит от цикла.
jv42
1
Протестировано путем генерации 1М паролей по 10 символов каждый, и это прекрасно работает.
NaXir
1
NSArrayкэширует его length, не должно быть узким местом производительности.
Паскаль
Я согласен. Это простой доступ к собственности. Он не считает себя каждый раз, когда ты спрашиваешь.
devios1
45

Конечно, вы можете сделать это короче:

+(NSString*)generateRandomString:(int)num {
    NSMutableString* string = [NSMutableString stringWithCapacity:num];
    for (int i = 0; i < num; i++) {
        [string appendFormat:@"%C", (unichar)('a' + arc4random_uniform(26))];
    }
    return string;
}
Джон Риселвато
источник
2
почему -1? В этом нет ничего плохого. Это как самый маленький и самый оптимизированный из всех ответов.
Джон Риселвато
5
В этом нет ничего плохого. Это хорошее и краткое решение. (Хотелось бы, чтобы SO обеспечил комментарий к отрицательным голосам.)
alvi
Лучшее решение. Единственный комментарий, я бы сделал это статическим методом.
Андрей Чижов
9
Единственным недостатком является то, что это не буквенно-цифровые, а только строчные буквы. ;-)
PrimaryFeather
Я думаю, вам нужно изменить 25 на 26, иначе вы никогда не получите 'z'.
Маркус Адамс
28

Если вы хотите ограничиться только шестнадцатеричными символами, тогда самый простой вариант - сгенерировать UUID:

NSString *uuid = [NSUUID UUID].UUIDString;

Пример вывода: 16E3DF0B-87B3-4162-A1A1-E03DB2F59654.

Если вы хотите меньшую случайную строку, вы можете получить только первые 8 символов.

Это версия 4 UUID , который означает , что первый символ в 3 - й и 4 - й группы , не является случайным (они всегда будут 4и один из 8, 9, Aили B).

Каждый другой символ в строке является полностью случайным, и вы можете генерировать миллионы UUID каждую секунду в течение сотен лет без большого риска того, что один и тот же UUID будет сгенерирован дважды.

Абхи Беккерт
источник
1
Вы можете просто использоватьNSString *uuid = [UUID UUID]
orkoden
@orkoden спасибо, мой код взят из кода iOS 5. Я обновлю свой ответ, чтобы использовать более новый API iOS 6 / OS X 10.8.
Абхи Беккерт,
@AbhiBeckert безопасно ли использовать только первые 8 символов без риска получить те же первые 8 символов?
Вишал Сингх
1
@ VishalSingh да, это безопасно, хотя, очевидно, чем короче вы его делаете, тем выше риск столкновения.
Абхи Бекерт,
3
NSString * uuid = [UUID UUID] .UUIDString; выдаст ошибку «Использование необъявленного идентификатора UUID», поэтому просто небольшое изменение в коде используйте NSString * uuid = [NSUUID UUID] .UUIDString;
Аббас Мулани
24

Категориальная версия ответа Джеффа Б.

NSString + Random.h

#import <Foundation/Foundation.h>

@interface NSString (Random)

+ (NSString *)randomAlphanumericStringWithLength:(NSInteger)length;

@end

NSString + Random.m

#import "NSString+Random.h"

 @implementation NSString (Random)

+ (NSString *)randomAlphanumericStringWithLength:(NSInteger)length
{ 
    NSString *letters = @"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    NSMutableString *randomString = [NSMutableString stringWithCapacity:length];

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

    return randomString;
}

@end
keithyip
источник
1
Это отличный пример того, как использовать категории!
ElmerCat
7

Вы также можете просто сгенерировать UUID. Хотя они не совсем случайны, они сложны и уникальны, что делает их случайными для большинства применений. Сгенерируйте один как строку и затем возьмите диапазон символов, равный переданной длине.

TechZen
источник
Я настоятельно рекомендовал бы против этого для всего, что связано с безопасностью. Псевдослучайность является одной из самых больших хакерских способностей хакеров в проникающих системах, поскольку они обеспечивают предсказуемость. Используйте как можно ближе к реальному-случайному.
Шейн
5

стриж

func randomStringWithLength(length: Int) -> String {
    let alphabet = "-_1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    let upperBound = UInt32(count(alphabet))
    return String((0..<length).map { _ -> Character in
        return alphabet[advance(alphabet.startIndex, Int(arc4random_uniform(upperBound)))]
    })
}
ma11hew28
источник
1
Коротко и сладко. Работал для меня за исключением того, что когда я изменил алфавит, он разбился, потому что длина алфавита жестко запрограммирована. Я заменил 64 на UInt32 (количество (алфавит))
scootermg
ХОРОШО. Я заменил жесткий код 64на компьютерный upperBound. Я вычисляю upperBoundза пределами блока, потому что думаю, что это работает лучше.
ma11hew28
Невозможно вызвать 'count' со списком аргументов дескрипторов типа '(String)' с использованием 'alphabet.characters.count'
Запорожченко Александр
возвратный алфавит [alphabet.startIndex.advancedBy (Int (arc4random_uniform (upperBound)))
Запорожченко Александр
4

Вот другой способ справиться с этим. Вместо использования подготовленной строки символов вы можете приводить между целыми числами и символами и генерировать динамический список символов для выбора. Он довольно скудный и быстрый, но имеет немного больше кода.

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);

Когда я выполняю генерацию случайных символов, я предпочитаю работать непосредственно с целыми числами и приводить их вместо того, чтобы выписывать список символов, из которых я хочу извлечь. Объявление переменных в верхней части делает их более независимыми от системы, но этот код предполагает, что числа будут иметь более низкое значение, чем буквы, и что заглавные буквы будут иметь более низкое значение, чем строчные.

rjferguson
источник
3

Альтернативное решение в Swift

func generateString(len: Int) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    let lettersLength = UInt32(countElements(letters))
    let result = (0..<len).map { _ -> String in
        let idx = Int(arc4random_uniform(lettersLength))
        return String(letters[advance(letters.startIndex, idx)])
    }
    return "".join(result)
}
Gralex
источник
2

В дополнение к хорошему ответу Мелвина, вот функция, которую я сделал ( в SWIFT! ) Для получения случайной строки:

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
}

Вот результат теста от звонка randomStringOfLength(10): uXa0igA8wm

Стан Татарников
источник
2

Создает строчную буквенно-цифровую случайную строку заданной длины:

-(NSString*)randomStringWithLength:(NSUInteger)length
{
    NSMutableString* random = [NSMutableString stringWithCapacity:length];

    for (NSUInteger i=0; i<length; i++)
    {
        char c = '0' + (unichar)arc4random()%36;
        if(c > '9') c += ('a'-'9'-1);
        [random appendFormat:@"%c", c];
    }

    return random;
}
erkanyildiz
источник
2

Модификация нескольких идей здесь и в готовом 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))]
        })
    }
}

Использование:

let myHexString = String.Random()
let myLongHexString = String.Random(length:64)
let myLettersString = String.Random(length:32, alphabet:"ABCDEFGHIJKLMNOPQRSTUVWXYZ")
Векс
источник
1

Если вам нужна случайная строка в юникоде, вы можете создать случайные байты, а затем использовать действительные.

    OSStatus sanityCheck = noErr;
    uint8_t * randomBytes = NULL;
    size_t length = 200; // can of course be variable

    randomBytes = malloc( length * sizeof(uint8_t) );
    memset((void *)randomBytes, 0x0, length);

    sanityCheck = SecRandomCopyBytes(kSecRandomDefault, length, randomBytes);

    if (sanityCheck != noErr) NSLog(@"Error generating random bytes, OSStatus == %ld.", sanityCheck);

    NSData* randomData = [[NSData alloc] initWithBytes:(const void *)randomBytes length: length];
    if (randomBytes) free(randomBytes);

    NSString* dataString = [[NSString alloc] initWithCharacters:[randomData bytes] length:[randomData length]];  // create an NSString from the random bytes
    NSData* tempData = [dataString dataUsingEncoding:NSUTF8StringEncoding allowLossyConversion:YES];             // remove illegal characters from string
    NSString* randomString = [[NSString alloc] initWithData:tempData encoding:NSUTF8StringEncoding];

Преобразование из NSString в NSData и обратно необходимо для получения правильной строки UTF-8. Помните, что длина не обязательно будет длиной строки NSS, созданной в конце.

orkoden
источник
1

Я сделал это, используя простой char[]вместо NSString *алфавита. Я добавил это в категорию NSString.

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;
}
Мистер Т
источник
1
static NSUInteger length = 32;
static NSString *letters = @"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
NSMutableString * randomString = [NSMutableString stringWithCapacity:length];
for (NSInteger i = 0; i < length; ++i) {
    [randomString appendFormat: @"%C", [letters characterAtIndex:(NSUInteger)arc4random_uniform((u_int32_t)[letters length])]];
}
Питер Лапису
источник
1

Метод для вызова:


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

Метод:


- (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;
}

Полученные результаты:


## randomString: file_Msci.pdf ##
## randomString: file_xshG.pdf ##
## randomString: file_abAD.pdf ##
## randomString: file_HVwV.pdf ##
emotality
источник
1

для Swift 3.0

func randomString(_ length: Int) -> String {

    let letters : NSString = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    let len = UInt32(letters.length)

    var randomString = ""

    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
}
S1LENT WARRIOR
источник
0
#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;
}
TtheTank
источник
0

Модификация для ответа keithyip:

+ (NSString *)randomAlphanumericStringWithLength:(NSInteger)length
{
    static NSString * const letters = @"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        srand(time(NULL));
    });

    NSMutableString *randomString = [NSMutableString stringWithCapacity:length];

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

    return randomString;
}
iutinvg
источник