উত্তর:
এখানে একটি দ্রুত এবং নোংরা বাস্তবায়ন। পরীক্ষা করা হয়নি।
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 )।
স্ট্রিংয়ের প্রতিটি অন্যান্য চরিত্র সম্পূর্ণরূপে এলোমেলো এবং আপনি একই সেকেন্ডে দু'বার উত্পন্ন হওয়ার ঝুঁকি ছাড়াই কয়েকশ বছর ধরে প্রতি সেকেন্ডে কয়েক মিলিয়ন ইউইউডি তৈরি করতে পারেন।
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আপনি কেবল একটি ইউইউডি তৈরি করতে পারেন। সত্যিকারের এলোমেলো নয়, এগুলি জটিল এবং অনন্য যা তাদের বেশিরভাগ ব্যবহারের জন্য এলোমেলোভাবে উপস্থিত করে তোলে। স্ট্রিং হিসাবে একটি উত্পন্ন করুন এবং তারপরে পাসের দৈর্ঘ্যের সমান অক্ষরের পরিসর নিন।
দ্রুতগতি
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;
}এখানে কয়েকটি ধারণার পরিবর্তন এবং সম্পাদিত সুইফট ৪.০
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];একটি বৈধ ইউটিএফ -8 স্ট্রিং পেতে এনএসএসটিং থেকে এনএসডিটা এবং পিছনে রূপান্তর প্রয়োজন is সচেতন হন যে দৈর্ঘ্যটি শেষ পর্যন্ত এনএসএসস্ট্রিংয়ের দৈর্ঘ্য হিসাবে তৈরি হবে না।
আমি বর্ণমালার 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 ##সুইফট ৩.০ এর জন্য
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;
}