जवाबों:
यहाँ एक त्वरित और गंदा कार्यान्वयन है। परीक्षण नहीं किया गया है।
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के लिए lettersजब एक साधारण charसरणी ठीक काम करेगा। वास्तव में, का उपयोग [letters characterAtIndex:(rand() % [letters length])]करने के लिए मुझे लगता है कम संक्षिप्त होने की तुलना में सिर्फ letters[rand() % strlen(letters)]। फाउंडेशन कक्षाएं वास्तव में सहायक हैं, लेकिन सबसे सरल चीजों के लिए, वे इसे बढ़ाने के बजाय हमारे कोड को बाधित करने की सेवा कर सकते हैं।
%Cइसके बजाय चाहते हो सकता है %c, क्योंकि characterAtIndex:unichar
arc4random_uniform((int)[letters length])
ठीक वही नहीं जो आप पूछते हैं, लेकिन फिर भी उपयोगी है:
[[NSProcessInfo processInfo] globallyUniqueString]नमूना उत्पादन:
450FEA63-2286-4B49-8ACC-9822C7D4356B-1376-00000239A4AC4FD5NSString *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];
}alphabetहर बार लंबाई की क्वेरी करने की आवश्यकता है ? यह स्थिर है और लूप पर निर्भर नहीं करता है।
NSArrayइसका कैश करता है length, एक प्रदर्शन अड़चन नहीं होनी चाहिए।
निश्चित रूप से आप इसे छोटा कर सकते हैं:
+(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;
}यदि आप अपने आप को केवल हेक्स वर्णों तक सीमित रखने के लिए तैयार हैं, तो सबसे सरल विकल्प एक यूयूआईडी उत्पन्न करना है:
NSString *uuid = [NSUUID UUID].UUIDString;उदाहरण आउटपुट: 16E3DF0B-87B3-4162-A1A1-E03DB2F59654।
यदि आप एक छोटे से यादृच्छिक स्ट्रिंग चाहते हैं तो आप केवल पहले 8 अक्षरों को पकड़ सकते हैं।
यह एक संस्करण 4 UUID जो 3 और 4 समूह में पहले वर्ण का अर्थ बताया गया यादृच्छिक नहीं है (वे हमेशा हो जाएगा 4और में से एक 8, 9, AयाB )।
स्ट्रिंग में प्रत्येक अन्य वर्ण पूरी तरह से यादृच्छिक है और आप सैकड़ों UUIDs को हर साल सैकड़ों वर्षों के लिए उत्पन्न कर सकते हैं, एक ही UUID के दो बार बिना अधिक जोखिम के।
NSString *uuid = [UUID UUID]
जेफ बी के जवाब का एक श्रेणी संस्करण।
NSString + Random.h
#import <Foundation/Foundation.h>
@interface NSString (Random)
+ (NSString *)randomAlphanumericStringWithLength:(NSInteger)length;
@endNSString + 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तुम भी सिर्फ एक UUID उत्पन्न कर सकता है। जबकि वास्तव में यादृच्छिक नहीं, वे जटिल और अद्वितीय हैं जो उन्हें अधिकांश उपयोगों के लिए यादृच्छिक दिखाई देते हैं। एक स्ट्रिंग के रूप में उत्पन्न करें और फिर पारित लंबाई के बराबर वर्णों की एक श्रृंखला लें।
तीव्र
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)))]
})
}64एक गणना के साथ हार्डकोड को बदल दिया upperBound। मैं upperBoundब्लॉक के बाहर गणना करता हूं क्योंकि मुझे लगता है कि बेहतर प्रदर्शन करता है।
यहां इससे निपटने का एक अलग तरीका है। पात्रों की तैयार स्ट्रिंग का उपयोग करने के बजाय, आप पूर्णांकों और पात्रों के बीच कास्ट कर सकते हैं, और चयन करने के लिए वर्णों की एक गतिशील सूची उत्पन्न कर सकते हैं। यह बहुत दुबला और तेज़ है, लेकिन इसमें थोड़ा अधिक कोड है।
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);जब मैं यादृच्छिक चरित्र निर्माण कर रहा होता हूं, तो मैं सीधे पूर्णांक के साथ काम करना पसंद करता हूं और उन पर डाली जाती हूं, बजाय इसके कि मैं उन वर्णों की सूची लिखूं जिनसे मैं आकर्षित करना चाहता हूं। शीर्ष पर चर घोषित करने से यह अधिक प्रणाली को स्वतंत्र बनाता है, लेकिन यह कोड मानता है कि संख्याओं में अक्षरों की तुलना में कम मूल्य होगा, और अपरकेस अक्षरों में लोअरकेस अक्षरों की तुलना में कम मूल्य होगा।
स्विफ्ट में वैकल्पिक समाधान
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)
}मेल्विन द्वारा दिए गए अच्छे उत्तर को जोड़ते हुए, यहां एक समारोह है जो मैंने ( स्विफ्ट में! ) एक यादृच्छिक स्ट्रिंग प्राप्त करने के लिए किया है:
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
लोअरकेस अल्फ़ान्यूमेरिक यादृच्छिक स्ट्रिंग दी गई लंबाई के साथ:
-(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;
}यहाँ कुछ विचारों का संशोधन, और किया गया स्विफ्ट 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")यदि आप एक यादृच्छिक यूनिकोड स्ट्रिंग चाहते हैं, तो आप यादृच्छिक बाइट्स बना सकते हैं और फिर वैध का उपयोग कर सकते हैं।
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 स्ट्रिंग प्राप्त करने के लिए आवश्यक है। ज्ञात हो कि लंबाई जरूरी नहीं कि अंत में बनाई गई NSString की लंबाई हो।
मैंने यह वर्णमाला के char[]बजाय एक सरल का उपयोग करके किया 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;
}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])]];
}कॉल करने की विधि:
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 ##स्विफ्ट 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
}#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:¤tChar 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;
}कीथिप के उत्तर के लिए संशोधन:
+ (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;
}