编辑:为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)

我使用了下面的代码:

var k: Int = random() % 10;

对于0到n-1之间的随机整数，使用arc4random_uniform(n)。

let diceRoll = Int(arc4random_uniform(6) + 1)

将结果转换为Int，这样你就不必显式地将你的vars类型为UInt32(这看起来不像swifty)。

更新日期: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)

斯威夫特4.2

Swift 4.2在标准库中包含了一个原生的、功能相当全的随机数API。(Swift Evolution提案SE-0202)

let intBetween0to9 = Int.random(in: 0...9) 
let doubleBetween0to1 = Double.random(in: 0...1)

所有的数字类型都有静态随机数(in:)，它接受范围并返回给定范围内的随机数

在Swift 4.2中，您可以通过调用random()方法在任何您想要的数字类型上生成随机数，提供您想要使用的范围。例如，这会生成一个范围为1到9的随机数，两边都包括在内

let randInt = Int.random(in: 1..<10)

其他类型也一样

let randFloat = Float.random(in: 1..<20)
let randDouble = Double.random(in: 1...30)
let randCGFloat = CGFloat.random(in: 1...40)