从Swift 4.2开始

有一组新的api:

let randomIntFrom0To10 = Int.random(in: 0 ..< 10)
let randomDouble = Double.random(in: 1 ... 10)

所有数字类型现在都有random(in:)方法，该方法接受range。 它返回一个在该范围内均匀分布的数字。

博士TL;

那么，“好”的旧方法有什么错呢?

你必须使用导入的C api(它们在不同平台之间是不同的)。 而且……

如果我告诉你随机并不是那么随机呢?

如果您使用arc4random()(计算余数)，如arc4random() % aNumber，结果不是均匀分布在0和aNumber之间。有一个问题叫做模偏倚。

模的偏见

通常，该函数生成一个0到MAX之间的随机数(取决于类型等)。举个简单的例子，假设最大的数字是7，你关心的是一个范围为0 ..< 2(或者间隔[0,3)，如果你喜欢的话)。

单个数字的概率为:

0: 3/8 = 37.5% 1: 3/8 = 37.5% 2: 2/8 = 25%

换句话说，你更有可能得到0或1而不是2。 当然，请记住，这是非常简化的，MAX数字要高得多，使其更加“公平”。

Swift 4.2中的SE-0202 -随机统一解决了这个问题

编辑:为Swift 3.0更新

arc4random在Swift中工作得很好，但基本函数仅限于32位整数类型(Int在iPhone 5S和现代mac上是64位)。下面是一个泛型函数，用于表示可以用整型字面值表示的类型的随机数:

public func arc4random<T: ExpressibleByIntegerLiteral>(_ type: T.Type) -> T {
    var r: T = 0
    arc4random_buf(&r, MemoryLayout<T>.size)
    return r
}

我们可以使用这个新的泛型函数扩展UInt64，增加边界参数并减少模偏置。(这是从arc4random.c直接引用的)

public extension UInt64 {
    public static func random(lower: UInt64 = min, upper: UInt64 = max) -> UInt64 {
        var m: UInt64
        let u = upper - lower
        var r = arc4random(UInt64.self)

        if u > UInt64(Int64.max) {
            m = 1 + ~u
        } else {
            m = ((max - (u * 2)) + 1) % u
        }

        while r < m {
            r = arc4random(UInt64.self)
        }

        return (r % u) + lower
    }
}

这样我们就可以将Int64扩展为相同的参数，处理溢出:

public extension Int64 {
    public static func random(lower: Int64 = min, upper: Int64 = max) -> Int64 {
        let (s, overflow) = Int64.subtractWithOverflow(upper, lower)
        let u = overflow ? UInt64.max - UInt64(~s) : UInt64(s)
        let r = UInt64.random(upper: u)

        if r > UInt64(Int64.max)  {
            return Int64(r - (UInt64(~lower) + 1))
        } else {
            return Int64(r) + lower
        }
    }
}

为了让家庭更完整……

private let _wordSize = __WORDSIZE

public extension UInt32 {
    public static func random(lower: UInt32 = min, upper: UInt32 = max) -> UInt32 {
        return arc4random_uniform(upper - lower) + lower
    }
}

public extension Int32 {
    public static func random(lower: Int32 = min, upper: Int32 = max) -> Int32 {
        let r = arc4random_uniform(UInt32(Int64(upper) - Int64(lower)))
        return Int32(Int64(r) + Int64(lower))
    }
}

public extension UInt {
    public static func random(lower: UInt = min, upper: UInt = max) -> UInt {
        switch (_wordSize) {
            case 32: return UInt(UInt32.random(UInt32(lower), upper: UInt32(upper)))
            case 64: return UInt(UInt64.random(UInt64(lower), upper: UInt64(upper)))
            default: return lower
        }
    }
}

public extension Int {
    public static func random(lower: Int = min, upper: Int = max) -> Int {
        switch (_wordSize) {
            case 32: return Int(Int32.random(Int32(lower), upper: Int32(upper)))
            case 64: return Int(Int64.random(Int64(lower), upper: Int64(upper)))
            default: return lower
        }
    }
}

在所有这些之后，我们终于可以做这样的事情:

let diceRoll = UInt64.random(lower: 1, upper: 7)

Swift 4.2编辑

从Swift 4.2开始，你可以使用Swift自己的本地函数，而不是使用导入的C函数arc4random_uniform()。

// Generates integers starting with 0 up to, and including, 10
Int.random(in: 0 ... 10)

你也可以使用random(in:)来获取其他原始值的随机值;比如Int型，Double型，Float型，甚至Bool型。

Swift版本< 4.2

该方法将在给定的最小值和最大值之间生成一个随机Int值

func randomInt(min: Int, max: Int) -> Int {
    return min + Int(arc4random_uniform(UInt32(max - min + 1)))
}

我想补充现有的答案，在Swift书中的随机数生成器的例子是一个线性同余生成器(LCG)，这是一个非常有限的一个，不应该除了必须平凡的例子，其中随机性的质量根本不重要。LCG永远不应该用于加密目的。

Arc4random()要好得多，可以用于大多数目的，但不应该用于加密目的。

如果您想要保证加密安全的内容，请使用SecCopyRandomBytes()。请注意，如果您将随机数生成器构建到某个东西中，其他人可能最终(错误地)将其用于加密目的(例如密码、密钥或盐生成)，那么无论如何您都应该考虑使用SecCopyRandomBytes()，即使您的需要并不完全需要这样做。

更新日期:2022年6月9日。

斯威夫特5.7

假设我们有一个数组:

let numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

对于iOS和macOS，你可以在Xcode的框架GameKit中使用系统范围内的随机源代码。在这里你可以找到GKRandomSource类及其sharerandom()类方法:

import GameKit

private func randomNumberGenerator() -> Int {
    let rand = GKRandomSource.sharedRandom().nextInt(upperBound: numbers.count)
    return numbers[rand]
}

randomNumberGenerator()

你也可以使用randomElement()方法返回一个集合的随机元素:

let randomNumber = numbers.randomElement()!
print(randomNumber)

或者使用arc4random_uniform()。注意，该方法返回UInt32类型。

let generator = Int(arc4random_uniform(11))
print(generator)

当然，我们也可以使用makeIterator()方法，该方法返回集合元素上的迭代器。

let iterator: Int = (1...10).makeIterator().shuffled().first!
print(iterator)

你在这里看到的最后一个例子通过静态func random(in range: ClosedRange<Int>) -> Int在指定范围内返回一个随机值。

let randomizer = Int.random(in: 1...10)
print(randomizer)

伪随机双位数生成器drand48()返回0.0到1.0之间的值。

import Foundation

let randomInt = Int(drand48() * 10)

细节

xCode 9.1, Swift 4

面向数学的解(1)

import Foundation

class Random {

    subscript<T>(_ min: T, _ max: T) -> T where T : BinaryInteger {
        get {
            return rand(min-1, max+1)
        }
    }
}

let rand = Random()

func rand<T>(_ min: T, _ max: T) -> T where T : BinaryInteger {
    let _min = min + 1
    let difference = max - _min
    return T(arc4random_uniform(UInt32(difference))) + _min
}

溶液使用方法(1)

let x = rand(-5, 5)       // x = [-4, -3, -2, -1, 0, 1, 2, 3, 4]
let x = rand[0, 10]       // x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

面向程序员的解决方案(2)

不要忘记在这里添加面向数学的解决方案(1)代码

import Foundation

extension CountableRange where Bound : BinaryInteger {

    var random: Bound {
        return rand(lowerBound-1, upperBound)
    }
}

extension CountableClosedRange where Bound : BinaryInteger {

    var random: Bound {
        return rand[lowerBound, upperBound]
    }
}

溶液使用方法(2)

let x = (-8..<2).random           // x = [-8, -7, -6, -5, -4, -3, -2, -1, 0, 1]
let x = (0..<10).random           // x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
let x = (-10 ... -2).random       // x = [-10, -9, -8, -7, -6, -5, -4, -3, -2]

完整的样品

不要忘记在这里添加溶液(1)和溶液(2)的代码

private func generateRandNums(closure:()->(Int)) {

    var allNums = Set<Int>()
    for _ in 0..<100 {
        allNums.insert(closure())
    }
    print(allNums.sorted{ $0 < $1 })
}

generateRandNums {
    (-8..<2).random
}

generateRandNums {
    (0..<10).random
}

generateRandNums {
    (-10 ... -2).random
}

generateRandNums {
    rand(-5, 5)
}
generateRandNums {
    rand[0, 10]
}

样品结果