[英]How to generate a random number in Swift?
我实现了 Swift 这本书提供了一个随机数生成器的实现。 复制和粘贴此实现的最佳做法是什么? 或者有没有我们现在可以使用的库?
斯威夫特 4.2+
Xcode 10 附带的 Swift 4.2 为许多数据类型引入了新的易于使用的随机函数。 您可以对数字类型调用random()
方法。
let randomInt = Int.random(in: 0..<6)
let randomDouble = Double.random(in: 2.71828...3.14159)
let randomBool = Bool.random()
将arc4random_uniform(n)
用于 0 到 n-1 之间的随机整数。
let diceRoll = Int(arc4random_uniform(6) + 1)
将结果转换为 Int,这样您就不必将您的变量显式键入为UInt32
(这似乎不是 Swifty)。
arc4random
在 Swift 中运行良好,但基本函数仅限于 32 位整数类型(在 iPhone 5S 和现代 Mac 上Int
是 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。
斯威夫特版本 < 4.2
此方法将在给定的最小值和最大值之间生成一个随机Int
值
func randomInt(min: Int, max: Int) -> Int {
return min + Int(arc4random_uniform(UInt32(max - min + 1)))
}
我使用了这段代码:
var k: Int = random() % 10;
从 iOS 9 开始,您可以使用新的 GameplayKit 类以多种方式生成随机数。
您有四种源类型可供选择:一般随机源(未命名,由系统选择它的功能)、线性同余、ARC4 和 Mersenne Twister。 这些可以生成随机整数、浮点数和布尔值。
在最简单的层面上,您可以从系统的内置随机源生成一个随机数,如下所示:
GKRandomSource.sharedRandom().nextInt()
这会生成一个介于 -2,147,483,648 和 2,147,483,647 之间的数字。 如果你想要一个介于 0 和上限(不包括)之间的数字,你可以使用:
GKRandomSource.sharedRandom().nextIntWithUpperBound(6)
GameplayKit 内置了一些方便的构造函数来处理骰子。 例如,您可以像这样滚动一个六面骰子:
let d6 = GKRandomDistribution.d6()
d6.nextInt()
另外,您可以使用 GKShuffledDistribution 之类的东西来塑造随机分布。 这需要更多解释,但如果您有兴趣,可以阅读我的 GameplayKit 随机数教程。
你可以像在 C 中那样做:
let randomNumber = arc4random()
randomNumber
被推断为UInt32
类型(一个 32 位无符号整数)
arc4random_uniform()
用法:
arc4random_uniform(someNumber: UInt32) -> UInt32
这为您提供了0
到someNumber - 1
范围内的随机整数。
UInt32
的最大值为 4,294,967,295(即2^32 - 1
)。
例子:
硬币翻转
let flip = arc4random_uniform(2) // 0 or 1
掷骰子
let roll = arc4random_uniform(6) + 1 // 1...6
十月的随机一天
let day = arc4random_uniform(31) + 1 // 1...31
1990年代的随机年份
let year = 1990 + arc4random_uniform(10)
一般形式:
let number = min + arc4random_uniform(max - min + 1)
其中number
、 max
和min
是UInt32
。
arc4random()
您还可以使用arc4random()
获得一个随机数,它会产生一个介于 0 和 2^32-1 之间的UInt32
。 因此,要获得0
和x-1
之间的随机数,您可以将其除以x
并取余数。 或者换句话说,使用余数运算符 (%) :
let number = arc4random() % 5 // 0...4
但是,这会产生轻微的模数偏差(另请参见此处和此处),因此建议使用arc4random_uniform()
。
与Int
相互转换
通常可以这样做以便在Int
和UInt32
之间来回转换:
let number: Int = 10
let random = Int(arc4random_uniform(UInt32(number)))
但是,问题在于Int
在 32 位系统上的范围为-2,147,483,648...2,147,483,647
,在 64 位系统上的范围为-9,223,372,036,854,775,808...9,223,372,036,854,775,807
。 将此与0...4,294,967,295
的UInt32
范围进行比较。 UInt32
的U
表示unsigned 。
考虑以下错误:
UInt32(-1) // negative numbers cause integer overflow error
UInt32(4294967296) // numbers greater than 4,294,967,295 cause integer overflow error
因此,您只需要确保您的输入参数在UInt32
范围内,并且您也不需要超出该范围的输出。
10 (0-9) 之间的随机数示例;
import UIKit
let randomNumber = Int(arc4random_uniform(10))
非常简单的代码 - 简单而简短。
我已经能够使用rand()
来获得一个随机的 CInt。 您可以使用以下方法使其成为 Int :
let myVar: Int = Int(rand())
您可以使用您最喜欢的 C 随机函数,并在需要时将值转换为 Int。
@jstn 的回答很好,但有点冗长。 Swift 被称为面向协议的语言,因此我们可以通过添加协议扩展的默认实现来实现相同的结果,而无需为整数系列中的每个类实现样板代码。
public extension ExpressibleByIntegerLiteral {
public static func arc4random() -> Self {
var r: Self = 0
arc4random_buf(&r, MemoryLayout<Self>.size)
return r
}
}
现在我们可以这样做:
let i = Int.arc4random()
let j = UInt32.arc4random()
并且所有其他整数类都可以。
在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)
更新日期:2022 年 6 月 9 日。
假设我们有一个数组:
let numbers: [Int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
对于 iOS 和 macOS,您可以在 Xcode 的框架GameKit
中使用系统范围的随机源。 在这里您可以找到GKRandomSource
类及其sharedRandom()
类方法:
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)
您在此处看到的最后一个示例在static 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)
这是一个做得很好的库https://github.com/thellimist/SwiftRandom
public extension Int {
/// SwiftRandom extension
public static func random(lower: Int = 0, _ upper: Int = 100) -> Int {
return lower + Int(arc4random_uniform(UInt32(upper - lower + 1)))
}
}
public extension Double {
/// SwiftRandom extension
public static func random(lower: Double = 0, _ upper: Double = 100) -> Double {
return (Double(arc4random()) / 0xFFFFFFFF) * (upper - lower) + lower
}
}
public extension Float {
/// SwiftRandom extension
public static func random(lower: Float = 0, _ upper: Float = 100) -> Float {
return (Float(arc4random()) / 0xFFFFFFFF) * (upper - lower) + lower
}
}
public extension CGFloat {
/// SwiftRandom extension
public static func random(lower: CGFloat = 0, _ upper: CGFloat = 1) -> CGFloat {
return CGFloat(Float(arc4random()) / Float(UINT32_MAX)) * (upper - lower) + lower
}
}
有一组新的 API:
let randomIntFrom0To10 = Int.random(in: 0 ..< 10)
let randomDouble = Double.random(in: 1 ... 10)
所有数字类型现在都有接受range
的random(in:)
方法。
它返回一个均匀分布在该范围内的数字。
TL;博士
您必须使用导入的C API (它们在平台之间有所不同) 。
而且……
如果我告诉你随机不是那么随机怎么办?
如果您使用arc4random()
(计算余数) ,如arc4random() % aNumber
,则结果不会在0
和aNumber
之间均匀分布。 有一个叫做模偏差的问题。
模偏置
通常,该函数会生成一个介于0
和MAX之间的随机数(取决于类型等) 。 举一个简单、快速的例子,假设最大数是7
,并且您关心0 ..< 2
(或区间 [0, 3) 如果您愿意的话)范围内的随机数。
个别数字的概率是:
换句话说,你更有可能最终得到0或1而不是2 。 当然,请记住,这是非常简化的,并且MAX数字要高得多,使其更加“公平”。
SE-0202 - Swift 4.2中的随机统一解决了这个问题
let MAX : UInt32 = 9
let MIN : UInt32 = 1
func randomNumber()
{
var random_number = Int(arc4random_uniform(MAX) + MIN)
print ("random = ", random_number);
}
var randomNumber = Int(arc4random_uniform(UInt32(5)))
这里 5 将确保从零到四生成随机数。 您可以相应地设置该值。
我想在现有答案中补充一点,Swift 书中的随机数生成器示例是线性同余生成器(LCG),它是一个严重受限的示例,除了必须琐碎的示例之外不应如此,其中随机性的质量不一点都不重要。 并且LCG 永远不应该用于加密目的。
arc4random()
要好得多,可以用于大多数目的,但同样不应用于加密目的。
如果您想要保证加密安全的东西,请使用SecCopyRandomBytes()
。 请注意,如果您将随机数生成器构建到某个东西中,其他人可能最终(错误)将其用于加密目的(例如密码、密钥或盐生成),那么您应该考虑使用SecCopyRandomBytes()
无论如何,即使您的需要并不完全需要。
在某些版本的 Xcode 中没有 arc4Random_uniform() (在 7.1 中它运行但不会自动完成)。 您可以改为这样做。
生成一个 0-5 的随机数。 第一的
import GameplayKit
然后
let diceRoll = GKRandomSource.sharedRandom().nextIntWithUpperBound(6)
斯威夫特 4.2
再见,导入 Foundation C 库arc4random_uniform()
// 1
let digit = Int.random(in: 0..<10)
// 2
if let anotherDigit = (0..<10).randomElement() {
print(anotherDigit)
} else {
print("Empty range.")
}
// 3
let double = Double.random(in: 0..<1)
let float = Float.random(in: 0..<1)
let cgFloat = CGFloat.random(in: 0..<1)
let bool = Bool.random()
以下代码将生成 0 到 255 之间的安全随机数:
extension UInt8 {
public static var random: UInt8 {
var number: UInt8 = 0
_ = SecRandomCopyBytes(kSecRandomDefault, 1, &number)
return number
}
}
你这样称呼它:
print(UInt8.random)
对于更大的数字,它变得更加复杂。
这是我能想到的最好的:
extension UInt16 {
public static var random: UInt16 {
let count = Int(UInt8.random % 2) + 1
var numbers = [UInt8](repeating: 0, count: 2)
_ = SecRandomCopyBytes(kSecRandomDefault, count, &numbers)
return numbers.reversed().reduce(0) { $0 << 8 + UInt16($1) }
}
}
extension UInt32 {
public static var random: UInt32 {
let count = Int(UInt8.random % 4) + 1
var numbers = [UInt8](repeating: 0, count: 4)
_ = SecRandomCopyBytes(kSecRandomDefault, count, &numbers)
return numbers.reversed().reduce(0) { $0 << 8 + UInt32($1) }
}
}
这些方法使用一个额外的随机数来确定将使用多少UInt8
来创建随机数。 最后一行将[UInt8]
转换为UInt16
或UInt32
。
我不知道最后两个是否仍然算作真正随机的,但您可以根据自己的喜好对其进行调整:)
斯威夫特 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:) ,它接受范围并返回给定范围内的随机数
您可以像这样使用GeneratorOf
:
var fibs = ArraySlice([1, 1])
var fibGenerator = GeneratorOf{
_ -> Int? in
fibs.append(fibs.reduce(0, combine:+))
return fibs.removeAtIndex(0)
}
println(fibGenerator.next())
println(fibGenerator.next())
println(fibGenerator.next())
println(fibGenerator.next())
println(fibGenerator.next())
println(fibGenerator.next())
我使用此代码生成一个随机数:
//
// FactModel.swift
// Collection
//
// Created by Ahmadreza Shamimi on 6/11/16.
// Copyright © 2016 Ahmadreza Shamimi. All rights reserved.
//
import GameKit
struct FactModel {
let fun = ["I love swift","My name is Ahmadreza","I love coding" ,"I love PHP","My name is ALireza","I love Coding too"]
func getRandomNumber() -> String {
let randomNumber = GKRandomSource.sharedRandom().nextIntWithUpperBound(fun.count)
return fun[randomNumber]
}
}
xCode 9.1,斯威夫特 4
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
}
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]
不要忘记在此处添加面向数学的解决方案 (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]
}
}
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]
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.