स्विफ्ट में यादृच्छिक अल्फ़ान्यूमेरिक स्ट्रिंग उत्पन्न करें

208

मैं स्विफ्ट में एक यादृच्छिक अल्फ़ान्यूमेरिक स्ट्रिंग कैसे उत्पन्न कर सकता हूं?

string  swift 
— विष्णु
स्रोत

जवाबों:

355

स्विफ्ट 4.2 अपडेट

स्विफ्ट 4.2 ने यादृच्छिक मूल्यों और तत्वों से निपटने में बड़े सुधार पेश किए। आप यहां उन सुधारों के बारे में अधिक पढ़ सकते हैं । इस विधि को कुछ पंक्तियों में घटाया गया है:

func randomString(length: Int) -> String {
  let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
  return String((0..<length).map{ _ in letters.randomElement()! })
}

स्विफ्ट 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
}

मूल उत्तर:

func randomStringWithLength (len : Int) -> NSString {

    let letters : NSString = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

    var randomString : NSMutableString = NSMutableString(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
}
— iAhmed
स्रोत
1
क्या कोई तरीका है जिससे मैं उपरोक्त को संशोधित कर सकता हूं ताकि यह सुनिश्चित हो सके कि उत्पन्न अल्फ़ान्यूमेरिक स्ट्रिंग केवल 6 या 8 वर्ण लंबा है?
— ksa_coder
4
randomString (लंबाई: 6) या randomString (लंबाई: 8)
— सिमोन एच
58

यहां स्विफ्टियर सिंटैक्स में रेडी-टू-यूज समाधान दिया गया है । आप इसे कॉपी और पेस्ट कर सकते हैं:

func randomAlphaNumericString(length: Int) -> String {
    let allowedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    let allowedCharsCount = UInt32(allowedChars.characters.count)
    var randomString = ""

    for _ in 0..<length {
        let randomNum = Int(arc4random_uniform(allowedCharsCount))
        let randomIndex = allowedChars.index(allowedChars.startIndex, offsetBy: randomNum)
        let newCharacter = allowedChars[randomIndex]
        randomString += String(newCharacter)
    }

    return randomString
}

यदि आप एक ऐसी फ्रेमवर्क पसंद करते हैं जिसमें कुछ अधिक उपयोगी विशेषताएं हैं, तो मेरी परियोजना HandySwift की जांच करने के लिए स्वतंत्र महसूस करें । इसमें यादृच्छिक अल्फ़ान्यूमेरिक स्ट्रिंग्स के लिए एक सुंदर समाधान भी शामिल है :

String(randomWithLength: 8, allowedCharactersType: .alphaNumeric) // => "2TgM5sUG"
— Jeehut
स्रोत
49

आप इसे निम्नलिखित तरीके से भी उपयोग कर सकते हैं:

extension String {

    static func random(length: Int = 20) -> String {

        let base = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        var randomString: String = ""

        for _ in 0..<length {

            let randomValue = arc4random_uniform(UInt32(base.characters.count))
            randomString += "\(base[base.startIndex.advancedBy(Int(randomValue))])"
        }

        return randomString
    }
}

सरल उपयोग:

let randomString = String.random()

स्विफ्ट 3 सिंटेक्स:

extension String {

    static func random(length: Int = 20) -> String {
        let base = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        var randomString: String = ""

        for _ in 0..<length {
            let randomValue = arc4random_uniform(UInt32(base.characters.count))
            randomString += "\(base[base.index(base.startIndex, offsetBy: Int(randomValue))])"
        }
        return randomString
    }
}

स्विफ्ट 4 सिंटेक्स:

extension String {

    static func random(length: Int = 20) -> String {
        let base = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        var randomString: String = ""

        for _ in 0..<length {
            let randomValue = arc4random_uniform(UInt32(base.count))
            randomString += "\(base[base.index(base.startIndex, offsetBy: Int(randomValue))])"
        }
        return randomString
    }
}
— बार्टोलोमिएज सेमेकोज़ी
स्रोत
29

स्विफ्ट:

let randomString = NSUUID().uuidString
— कहा च
स्रोत
UUID ()। UuidString अब
— मार्क
2
UUID कभी-कभी एक ही तार देता है!
— बुरक Bur
2
यूयूआईडी के विभिन्न प्रकार हैं, उनमें से कुछ समय-आधारित हैं। स्विफ्ट फाउंडेशन में इस्तेमाल किया जाने वाला वी 4, यादृच्छिक है । बहुत कम मौका है (जैसे, अविश्वसनीय रूप से बहुत कम है कि एक ही यूयूआईडी दो बार उत्पन्न हो जाएगा।
— रॉबिन डॉटरेटी
11

अद्यतन 2019।

असामान्य मामले में है कि

प्रदर्शन मायने रखता है।

यहाँ एक अत्यंत स्पष्ट कार्य है जो कैश करता है :

func randomNameString(length: Int = 7)->String{
    
    enum s {
        static let c = Array("abcdefghjklmnpqrstuvwxyz12345789")
        static let k = UInt32(c.count)
    }
    
    var result = [Character](repeating: "-", count: length)
    
    for i in 0..<length {
        let r = Int(arc4random_uniform(s.k))
        result[i] = s.c[r]
    }
    
    return String(result)
}

यह तब होता है जब आपके पास एक निश्चित, ज्ञात वर्ण सेट होता है।

आसान टिप:

ध्यान दें कि "abcdefghjklmnpqrstuvwxyz12345789" 'खराब' वर्णों से बचा जाता है

कोई 0, ओ, ओ, आई, आदि नहीं है ... चरित्र मनुष्य अक्सर भ्रमित करते हैं।

यह अक्सर बुकिंग कोड और समान कोड के लिए किया जाता है जो मानव ग्राहक उपयोग करेंगे।

— fattie
स्रोत
1
के लिए Upvoting repeating:count:।
— कूर
10

सरल और तेज - UUID ()। uuidString

// UUID से निर्मित स्ट्रिंग लौटाता है, जैसे "E621E1F8-C36C-495A-93FC-0C247A3E6E5F"

सार्वजनिक संस्करण uuidString: स्ट्रिंग {get}

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

स्विफ्ट 3.0

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

संपादित करें

कृपया भ्रमित नहीं के साथ UIDevice.current.identifierForVendor?.uuidStringयादृच्छिक मान नहीं देंगे यह।

— मोहम्मद जलील नजीर
स्रोत
10

४.२ स्विफ्ट के साथ आपका सबसे अच्छा शर्त है कि आप अपने इच्छित पात्रों के साथ एक स्ट्रिंग बनाएं और फिर प्रत्येक चरित्र को चुनने के लिए यादृच्छिक उपयोग करें :

let length = 32
let characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
let randomCharacters = (0..<length).map{_ in characters.randomElement()!}
let randomString = String(randomCharacters)

मैं यहाँ इन परिवर्तनों के बारे में अधिक जानकारी देता हूँ ।

— leogdion
स्रोत
3
नक्शे के बजाय आप कॉम्पेक्ट मैप का उपयोग कर सकते हैं और फिर इसकी कोई आवश्यकता नहीं है! ऑपरेटर। ;)
— क्रिस्टप्स ग्रिनबर्ग्स
1
अरे @KristapsGrinbergs! मेरा विचार यह था कि कॉम्पेक्ट मैप का उपयोग करने से बेहतर प्रदर्शन करना होगा।
— leogdion
6

स्विफ्ट 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 randomString(length: Int) -> String {
    let charactersString = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    let charactersArray : [Character] = Array(charactersString.characters)

    var string = ""
    for _ in 0..<length {
        string.append(charactersArray[Int(arc4random()) % charactersArray.count])
    }

    return string
}

मूल रूप से इस विधि को कॉल करें जो फ़ंक्शन को सौंपे गए पूर्णांक की एक यादृच्छिक स्ट्रिंग उत्पन्न करेगा। संभव वर्णों को बदलने के लिए बस अक्षर स्ट्रिंग को संपादित करें। यूनिकोड वर्णों का भी समर्थन करता है।

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

— अर्नेस्ट कनिंघम
स्रोत
2
कुछ दुर्भाग्यपूर्ण कारण से इस संस्करण कभी-कभी एक देता हैEXC_BAD_INSTRUCTION
— जो
हे जो, क्या आपके पास कोई डेमो कोड है जो इस त्रुटि को पुन: उत्पन्न कर सकता है?
— अर्नेस्ट कनिंघम
मुझे देखने दो मैं क्या कर सकता हूँ; मैं इसे केवल आईबी एक्शन आउटलेट के रूप में कह रहा था let random = randomString(16)। EXC केवल एक वास्तविक डिवाइस पर था और मैंने इसे एक सिम्युलेटर में नहीं देखा था और यह डिवाइस पर रुक-रुक कर चल रहा था।
— जो
1
इस SO प्रश्न को इस कारण से देखें कि यह 32-बिट उपकरणों पर आधा समय क्यों क्रैश करता है: stackoverflow.com/questions/25274265/…
— julien_c
महत्वपूर्ण: random % count करता है नहीं (हमेशा) एक समान वितरण पैदा करते हैं। यदि यह आपके लिए प्रासंगिक है, तो उपयोग करने वाले अन्य उत्तरों को देखें arc4random_uniform()।
— राफेल
6

उन लोगों के लिए जो वर्णों के पूरे सेट को टाइप नहीं करना चाहते:

func randomAlphanumericString(length: Int) -> String  {
    enum Statics {
        static let scalars = [UnicodeScalar("a").value...UnicodeScalar("z").value,
                              UnicodeScalar("A").value...UnicodeScalar("Z").value,
                              UnicodeScalar("0").value...UnicodeScalar("9").value].joined()

        static let characters = scalars.map { Character(UnicodeScalar($0)!) }
    }

    let result = (0..<length).map { _ in Statics.characters.randomElement()! }
    return String(result)
}
— FAL
स्रोत
5

स्विफ्ट 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 वारियर
स्रोत
1
क्या आपने उस कोड की कोशिश की? क्या आपने देखा कि लौटी स्ट्रिंग लंबाई गलत है, और केवल अंक हैं? पर एक नज़र डालें stackoverflow.com/q/39566062/1187415 , जो एक ही समस्या है।
— मार्टिन आर
@MartinR कि बाहर इशारा करने के लिए धन्यवाद। मैंने अपना जवाब अपडेट किया है
— S1LENT WARRIOR
5

एक शुद्ध स्विफ्ट Stringकिसी से यादृच्छिक CharacterSet।

उपयोग: CharacterSet.alphanumerics.randomString(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) -> String {
        let charArray = characters()
        let charArrayCount = UInt32(charArray.count)
        var randomString = ""
        for _ in 0 ..< length {
            randomString += String(charArray[Int(arc4random_uniform(charArrayCount))])
        }
        return randomString
    }
}

characters()समारोह है मेरी सबसे तेजी से जाना जाता कार्यान्वयन ।

— कोयूर
स्रोत
3 
func randomString(length: Int) -> String {
    // 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..<length {
        let index = letters.startIndex.advancedBy(Int(arc4random_uniform(n)))
        out.append(letters[index])
    }
    return out
}
— डैनियल हॉवर्ड
स्रोत
3

प्रश्न का मेरा और भी अधिक स्विफ्ट-इयर कार्यान्वयन:

func randomAlphanumericString(length: Int) -> String {

    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".characters
    let lettersLength = UInt32(letters.count)

    let randomCharacters = (0..<length).map { i -> String in
        let offset = Int(arc4random_uniform(lettersLength))
        let c = letters[letters.startIndex.advancedBy(offset)]
        return String(c)
    }

    return randomCharacters.joinWithSeparator("")
}
— Lachezar
स्रोत
3

लूप मुक्त, हालांकि यह 43 वर्णों तक सीमित है। यदि आपको अधिक आवश्यकता है, तो इसे संशोधित किया जा सकता है। UUID के उपयोग से इस दृष्टिकोण के दो फायदे हैं:

  1. निचले केस पत्रों का उपयोग करके ग्रेटर एन्ट्रॉपी, जैसा कि UUID()केवल ऊपरी मामले पत्र उत्पन्न करता है
  2. A UUIDअधिकतम 36 वर्णों (4 हाइफ़न सहित) पर है, लेकिन केवल 32 वर्ण लंबे बिना। क्या आपको लंबे समय तक कुछ चाहिए, या इसमें शामिल हाइफ़न नहीं चाहिए, base64EncodedStringहैंडल का उपयोग

साथ ही, यह फ़ंक्शन UIntऋणात्मक संख्याओं से बचने के लिए उपयोग करता है ।

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

आउटपुट की जांच करने के लिए इसे लूप में कॉल करना:

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

जो पैदा करता है:

Nzk3NjgzMTdBQ0FBNDFCNzk2MDRENzZF
MUI5RURDQzE1RTdCNDA3RDg2MTI4QkQx
M0I3MjJBRjVFRTYyNDFCNkI5OUM1RUVC
RDA1RDZGQ0IzQjI1NDdGREI3NDgxM0Mx
NjcyNUQyOThCNzhCNEVFQTk1RTQ3NTIy
MDkwRTQ0RjFENUFGNEFDOTgyQTUxODI0
RDU2OTNBOUJGMDE4NDhEODlCNEQ1NjZG
RjM2MTUxRjM4RkY3NDU2OUFDOTI0Nzkz
QzUwOTE1N0U1RDVENDE4OEE5NTM2Rjcy
Nzk4QkMxNUJEMjYwNDJDQjhBQkY5QkY5
ODhFNjU0MDVEMUI2NEI5QUIyNjNCNkVF
— CodeBender
स्रोत
3

स्विफ्ट 5.0

// Generating Random String
func randomString(length: Int) -> String {
    let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    return String((0..<length).map{ _ in letters.randomElement()! })
}
// Calling to string
label.text = randomString(length: 3)
— श्रीकांत जी
स्रोत
2

के लिए प्रतिक्रियाओं के साथ समस्या "मैं यादृच्छिक तार की जरूरत है" सवाल (जो भी भाषा में) हर समाधान की एक त्रुटिपूर्ण प्राथमिक विनिर्देशन का उपयोग करता व्यावहारिक रूप है स्ट्रिंग की लंबाई । प्रश्न स्वयं ही शायद ही कभी प्रकट करते हैं कि यादृच्छिक तार की आवश्यकता क्यों है, लेकिन मैं आपको चुनौती देता हूं कि आपको शायद ही कभी लंबाई के यादृच्छिक तारों की आवश्यकता होगी, 8. 8. आपको जिस चीज की आवश्यकता है वह कुछ अद्वितीय तार की संख्या है , उदाहरण के लिए, किसी उद्देश्य के लिए पहचानकर्ता के रूप में उपयोग करने के लिए।

कड़ाई से अद्वितीय स्ट्रिंग्स प्राप्त करने के दो प्रमुख तरीके हैं: नियतात्मक रूप से (जो यादृच्छिक नहीं है) और स्टोर / तुलना (जो कि शानदार है)। हम क्या करें? हम भूत छोड़ देते हैं। हम इसके बजाय संभाव्य विशिष्टता के साथ जाते हैं । यही है, हम स्वीकार करते हैं कि कुछ (हालांकि छोटा) जोखिम है कि हमारे तार अद्वितीय नहीं होंगे। यह वह जगह है जहाँ टकराव की संभावना और एन्ट्रॉपी को समझना मददगार होता है।

इसलिए मैं पुनरावृत्ति की आवश्यकता को फिर से दोहराऊंगा क्योंकि दोहराने के एक छोटे जोखिम के साथ तार की कुछ संख्या की आवश्यकता होती है। एक ठोस उदाहरण के रूप में, मान लें कि आप 5 मिलियन आईडी की क्षमता उत्पन्न करना चाहते हैं। आप प्रत्येक नए स्ट्रिंग को स्टोर और तुलना नहीं करना चाहते हैं, और आप चाहते हैं कि वे यादृच्छिक हो, इसलिए आप दोहराने के कुछ जोखिम को स्वीकार करते हैं। उदाहरण के लिए, मान लें कि एक ट्रिलियन रिपीट के 1 से कम जोखिम है। तो आपको किस लंबाई की स्ट्रिंग की आवश्यकता है? ठीक है, यह प्रश्न अस्वाभाविक है क्योंकि यह इस्तेमाल किए गए पात्रों पर निर्भर करता है। लेकिन इससे भी महत्वपूर्ण बात यह है कि यह गुमराह है। आपको जिस चीज की आवश्यकता है, वह स्ट्रिंग्स के एन्ट्रॉपी का एक विनिर्देश है, न कि उनकी लंबाई। एन्ट्रापी सीधे कुछ संख्याओं में दोहराने की संभावना से संबंधित हो सकती है। स्ट्रिंग की लंबाई नहीं हो सकती।

और यह वह जगह है जहाँ EntropyString जैसी लाइब्रेरी मदद कर सकती है। रैंडम आईडी उत्पन्न करने के लिए, जिसमें 5 मिलियन स्ट्रिंग्स में दोहराने के ट्रिलियन संभावना में 1 से कम है EntropyString:

import EntropyString

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

"Rrrj6pN4d6GBrFLH4"

EntropyStringडिफ़ॉल्ट रूप से 32 वर्णों के साथ सेट वर्ण का उपयोग करता है। अन्य पूर्वनिर्धारित वर्ण सेट हैं, और आप अपने स्वयं के पात्रों को भी निर्दिष्ट कर सकते हैं। उदाहरण के लिए, उपरोक्त एंट्री के साथ आईडी का सृजन करना लेकिन हेक्स वर्णों का उपयोग करना:

import EntropyString

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

"135fe71aec7a80c02dce5"

उपयोग किए गए वर्ण सेट में वर्णों की कुल संख्या के अंतर के कारण स्ट्रिंग की लंबाई में अंतर पर ध्यान दें। संभावित तारों की निर्दिष्ट संख्या में दोहराने का जोखिम समान है। स्ट्रिंग की लंबाई नहीं है। और सबसे अच्छा, दोहराने का जोखिम और तारों की संभावित संख्या स्पष्ट है। स्ट्रिंग की लंबाई के साथ कोई अनुमान नहीं है।

— डिंगो आकाश
स्रोत
2

यदि आपकी यादृच्छिक स्ट्रिंग सुरक्षित-यादृच्छिक होनी चाहिए, तो इसका उपयोग करें:

import Foundation
import Security

// ...

private static func createAlphaNumericRandomString(length: Int) -> String? {
    // create random numbers from 0 to 63
    // use random numbers as index for accessing characters from the symbols string
    // this limit is chosen because it is close to the number of possible symbols A-Z, a-z, 0-9
    // so the error rate for invalid indices is low
    let randomNumberModulo: UInt8 = 64

    // indices greater than the length of the symbols string are invalid
    // invalid indices are skipped
    let symbols = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"

    var alphaNumericRandomString = ""

    let maximumIndex = symbols.count - 1

    while alphaNumericRandomString.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 string length, then skip
        guard randomIndex <= maximumIndex else { continue }

        let symbolIndex = symbols.index(symbols.startIndex, offsetBy: Int(randomIndex))
        alphaNumericRandomString.append(symbols[symbolIndex])
    }

    return alphaNumericRandomString
}
— schirrmacher
स्रोत
1

यदि आपको सिर्फ एक विशिष्ट पहचानकर्ता की आवश्यकता है, तो आप UUID().uuidStringअपने उद्देश्यों की सेवा कर सकते हैं।

— Man1
स्रोत
1

स्विफ्ट के लिए अद्यतन 4. वर्ग विस्तार पर एक आलसी संग्रहित चर का उपयोग करें। यह केवल एक बार गणना की जाती है।

extension String {

    static var chars: [Character] = {
        return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".map({$0})
    }()

    static func random(length: Int) -> String {
        var partial: [Character] = []

        for _ in 0..<length {
            let rand = Int(arc4random_uniform(UInt32(chars.count)))
            partial.append(chars[rand])
        }

        return String(partial)
    }
}

String.random(length: 10) //STQp9JQxoq
— कविन पी।
स्रोत
1

स्विफ्ट 4

Apple अनुशंसा के रूप में बेहतर प्रदर्शन के लिए RandomNumberGenerator का उपयोग करना

उपयोग: String.random(20) परिणाम:CifkNZ9wy9jBOT0KJtV4

extension String{
   static func random(length:Int)->String{
        let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        var randomString = ""

        while randomString.utf8.count < length{
            let randomLetter = letters.randomElement()
            randomString += randomLetter?.description ?? ""
        }
        return randomString
    }
}
— jad
स्रोत
0

यह स्विफ्ट -ेस्ट समाधान है जिसके साथ मैं आ सकता हूं। स्विफ्ट 3.0

extension String {
    static func random(length: Int) -> String {
        let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        let randomLength = UInt32(letters.characters.count)

        let randomString: String = (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
    } 
}
— bojan4
स्रोत
-1 
func randomUIDString(_ wlength: Int) -> String {

    let letters : NSString = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    var randomString = ""

    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
}
— Stema
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.