string strings Generieren Sie eine zufällige alphanumerische Zeichenfolge in Swift




swift substring (14)

Wie generiert man eine zufällige alphanumerische Zeichenfolge in Swift?


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
}

Swift 3.0 Update

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

Wenn Ihre zufällige Zeichenfolge sicher und zufällig sein soll, verwenden Sie Folgendes:

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
}

Meine noch schnellere Umsetzung der Frage:

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("")
}

Das Problem mit Antworten auf "Ich brauche zufällige Strings" -Fragen (in welcher Sprache auch immer) ist praktisch jede Lösung verwendet eine fehlerhafte primäre Spezifikation der String-Länge . Die Fragen selbst offenbaren selten, warum die zufälligen Strings benötigt werden, aber ich würde Sie herausfordern, selten zufällige Strings der Länge, sagen Sie 8. Was Sie immer brauchen, ist eine Anzahl von eindeutigen Strings , zum Beispiel als Identifikatoren für einen bestimmten Zweck zu verwenden.

Es gibt zwei Möglichkeiten, strikte eindeutige Strings zu erhalten: deterministisch (was nicht zufällig ist) und speichern / vergleichen (was lästig ist). Was machen wir? Wir geben den Geist auf. Wir gehen stattdessen mit probabilistischer Einzigartigkeit . Das heißt, wir akzeptieren, dass es ein gewisses (wenn auch geringes) Risiko gibt, dass unsere Saiten nicht einzigartig sein werden. Hier hilft das Verständnis von Kollisionswahrscheinlichkeit und entropy .

Ich formuliere also das unveränderliche Bedürfnis als eine Anzahl von Saiten mit einem geringen Wiederholungsrisiko. Als konkretes Beispiel möchten wir sagen, dass Sie ein Potenzial von 5 Millionen IDs generieren möchten. Sie möchten nicht jede neue Zeichenfolge speichern und vergleichen, und Sie möchten, dass sie zufällig sind, so dass Sie ein gewisses Wiederholungsrisiko akzeptieren. Nehmen wir als Beispiel ein Risiko von weniger als 1 in einer Billion Chance auf Wiederholung. Welche Länge der Saite brauchst du? Nun, diese Frage ist unterspezifiziert, da sie von den verwendeten Zeichen abhängt. Aber noch wichtiger ist es fehlgeleitet. Was Sie brauchen, ist eine Spezifikation der Entropie der Strings, nicht ihre Länge. Die Entropie kann direkt mit der Wahrscheinlichkeit einer Wiederholung in einer Anzahl von Strings verbunden sein. Stringlänge kann nicht.

Und hier EntropyString eine Bibliothek wie EntropyString . Um Zufalls-IDs mit weniger als 1 in einer Billion Wiederholungswahrscheinlichkeit in 5 Millionen Strings mithilfe von EntropyString :

import EntropyString

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

"Rrrj6pN4d6GBrFLH4"

EntropyString verwendet standardmäßig einen Zeichensatz mit 32 Zeichen. Es gibt andere vordefinierte Zeichensätze und Sie können auch eigene Zeichen festlegen. Beispiel: Erstellen von IDs mit derselben Entropie wie oben, jedoch mit Hexadezimalzeichen:

import EntropyString

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

"135fe71aec7a80c02dce5"

Beachten Sie den Unterschied in der Zeichenfolgenlänge aufgrund des Unterschieds in der Gesamtzahl der Zeichen im verwendeten Zeichensatz. Das Risiko einer Wiederholung in der angegebenen Anzahl möglicher Zeichenfolgen ist gleich. Die Stringlängen sind nicht. Und das Beste von allem, das Risiko der Wiederholung und die mögliche Anzahl der Strings ist explizit. Kein Raten mehr mit Stringlänge.


Schnelle 2.2 Version

// 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
}

Im Grunde rufen Sie diese Methode auf, die eine zufällige Zeichenfolge die Länge der Ganzzahl generiert, die an die Funktion übergeben wird. Um die möglichen Zeichen zu ändern, editieren Sie einfach die Zeichenkettenfolge. Unterstützt auch Unicode-Zeichen.

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


Schnell:

let randomString = NSUUID().uuidString

Einfach und schnell - UUID (). UuidString

// Gibt eine aus der UUID erstellte Zeichenfolge zurück, z. B. "E621E1F8-C36C-495A-93FC-0C247A3E6E5F"

Öffentliche Variable uuidString: String {get}

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

Schnelles 3.0

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

BEARBEITEN

Bitte verwechseln Sie nicht mit UIDevice.current.identifierForVendor?.uuidString es wird keine zufälligen Werte geben.


für 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
}

Wenn Sie nur eine eindeutige Kennung benötigen, kann UUID().uuidString Ihre Zwecke UUID().uuidString .


Schnell:

Einfach für verständliche Weise in swift vereinfacht.

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

    let master = Array("abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ_123456789".characters) //0...62 = 63
    var randomString = ""

    for _ in 1...length{

        let random = arc4random_uniform(UInt32(master.count))
        randomString.append(String(master[Int(random)]))
    }
    return randomString
}

Eine reine schnelle zufällige CharacterSet aus einem beliebigen CharacterSet .

Verwendung: CharacterSet.alphanumerics.randomString(length: 100)

extension CharacterSet {
    /// extracting characters
    public func allCharacters() -> [Character] {
        var allCharacters = [Character]()
        for plane: UInt8 in 0 ... 16 where hasMember(inPlane: plane) {
            for unicode in UInt32(plane) << 16 ..< UInt32(plane + 1) << 16 {
                if let uniChar = UnicodeScalar(unicode), contains(uniChar) {
                    allCharacters.append(Character(uniChar))
                }
            }
        }
        return allCharacters
    }

    /// building random string of desired length
    public func randomString(length: Int) -> String {
        let charArray = allCharacters()
        let charArrayCount = UInt32(charArray.count)
        var randomString = ""
        for _ in 0 ..< length {
            randomString += String(charArray[Int(arc4random_uniform(charArrayCount))])
        }
        return randomString
    }
}

Die allCharacters() basiert auf der Antwort von Martin R.


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
}

Hier ist eine fertige Lösung in Swiftier-Syntax . Sie können es einfach kopieren und einfügen:

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
}

Wenn Sie ein Framework bevorzugen, das auch einige praktische Funktionen bietet, können Sie mein HandySwift Projekt HandySwift . Es enthält auch eine schöne Lösung für zufällige alphanumerische Zeichenfolgen :

String(randomWithLength: 8, allowedCharactersType: .alphaNumeric) // => "2TgM5sUG"






swift