Arrays 从数组中选择一个随机元素

假设我有一个数组，我想随机选取一个元素

最简单的方法是什么

---

最明显的方法是

数组[随机索引]

。但也许有类似ruby的

数组的东西？或者，如果没有，可以使用扩展创建这样的方法吗？
Swift 4.2及更高版本

推荐的新方法是收集协议上的内置方法：
randomElement（）
。它返回一个可选值，以避免前面假设的空情况

let array = ["Frodo", "Sam", "Wise", "Gamgee"]
print(array.randomElement()!) // Using ! knowing I have array.count > 0

如果不创建数组，并且不保证计数>0，则应执行以下操作：

if let randomElement = array.randomElement() { 
    print(randomElement)
}

Swift 4.1及以下版本

为了回答您的问题，您可以执行以下操作以实现随机阵列选择：

let array = ["Frodo", "sam", "wise", "gamgee"]
let randomIndex = Int(arc4random_uniform(UInt32(array.count)))
print(array[randomIndex])

铸件很难看，但我相信它们是必需的，除非其他人有其他方法。
根据Lucas的说法，您可以创建一个对Array类的扩展，如下所示：

extension Array {
    func randomItem() -> Element? {
        if isEmpty { return nil }
        let index = Int(arc4random_uniform(UInt32(self.count)))
        return self[index]
    }
}

例如：

let myArray = [1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16]
let myItem = myArray.randomItem() // Note: myItem is an Optional<Int>

让myArray=[1,2,3,4,5,6,7,8,10,12,14,16]
让myItem=myArray.randomItem（）//注意：myItem是可选项
您也可以使用Swift内置的random（）函数进行扩展：

extension Array {
    func sample() -> Element {
        let randomIndex = Int(rand()) % count
        return self[randomIndex]
    }
}

let array = [1, 2, 3, 4]

array.sample() // 2
array.sample() // 2
array.sample() // 3
array.sample() // 3

array.sample() // 1
array.sample() // 1
array.sample() // 3
array.sample() // 1

检查空数组的替代功能实现

func randomArrayItem<T>(array: [T]) -> T? {
  if array.isEmpty { return nil }
  let randomIndex = Int(arc4random_uniform(UInt32(array.count)))
  return array[randomIndex]
}

randomArrayItem([1,2,3])

func-randomArrayItem（数组：[T]）->T？{
if array.isEmpty{return nil}
设randomIndex=Int（arc4random_统一（UInt32（array.count）））
返回数组[随机索引]
}
随机排列项（[1,2,3]）
在Swift 2.2中，这可以概括为：

UInt.random
UInt8.random
UInt16.random
UInt32.random
UInt64.random
UIntMax.random

// closed intervals:

(-3...3).random
(Int.min...Int.max).random

// and collections, which return optionals since they can be empty:

(1..<4).sample
[1,2,3].sample
"abc".characters.sample
["a": 1, "b": 2, "c": 3].sample

然后，对于具有
UnsignedIntegerType
边界的
ClosedInterval
s：

extension ClosedInterval where Bound : UnsignedIntegerType {
    var random: Bound {
        guard start > 0 || end < Bound.max else { return Bound.random }
        return start + (Bound.random % (end - start + 1))
    }
}

。。。其中，
unsignedDistanceTo
、
unsignedDistanceFromMin
和
plusMinTMax
助手方法可以实现如下：

extension SignedIntegerType {
    func unsignedDistanceTo(other: Self) -> UIntMax {
        let _self = self.toIntMax()
        let other = other.toIntMax()
        let (start, end) = _self < other ? (_self, other) : (other, _self)
        if start == IntMax.min && end == IntMax.max {
            return UIntMax.max
        }
        if start < 0 && end >= 0 {
            let s = start == IntMax.min ? UIntMax(Int.max) + 1 : UIntMax(-start)
            return s + UIntMax(end)
        }
        return UIntMax(end - start)
    }
    var unsignedDistanceFromMin: UIntMax {
        return IntMax.min.unsignedDistanceTo(self.toIntMax())
    }
}

extension UIntMax {
    var plusMinIntMax: IntMax {
        if self > UIntMax(IntMax.max) { return IntMax(self - UIntMax(IntMax.max) - 1) }
        else { return IntMax.min + IntMax(self) }
    }
}

。。。对于整数
范围
s，可以对其进行一些优化：

import Darwin

func sizeof <T> (_: () -> T) -> Int { // sizeof return type without calling
    return sizeof(T.self)
}

let ARC4Foot: Int = sizeof(arc4random)

extension UnsignedIntegerType {
    static var max: Self { // sadly `max` is not required by the protocol
        return ~0
    }
    static var random: Self {
        let foot = sizeof(Self)
        guard foot > ARC4Foot else {
            return numericCast(arc4random() & numericCast(max))
        }
        var r = UIntMax(arc4random())
        for i in 1..<(foot / ARC4Foot) {
            r |= UIntMax(arc4random()) << UIntMax(8 * ARC4Foot * i)
        }
        return numericCast(r)
    }
}

extension Range where Element : SignedIntegerType {
    var sample: Element? {
        guard startIndex < endIndex else { return nil }
        let i: ClosedInterval = startIndex...endIndex.predecessor()
        return i.random
    }
}

extension Range where Element : UnsignedIntegerType {
    var sample: Element? {
        guard startIndex < endIndex else { return nil }
        let i: ClosedInterval = startIndex...endIndex.predecessor()
        return i.random
    }
}

扩展范围，其中元素：SignedIntegerType{
变量样本：元素{
guard startIndex
以下是其他人的回答，但有Swift 2支持

Swift 1.x
Swift 2.x
例如：

let arr = [2, 3, 5, 7, 9, 11, 13, 17, 19, 23, 29, 31]
let randomSample = arr.sample()

这里有一个数组扩展，带有空数组检查，以提高安全性：

extension Array {
    func sample() -> Element? {
        if self.isEmpty { return nil }
        let randomInt = Int(arc4random_uniform(UInt32(self.count)))
        return self[randomInt]
    }
}

您可以像这样简单地使用它：

let digits = Array(0...9)
digits.sample() // => 6

digits.sample(size: 3) // => [8, 0, 7]


如果您更喜欢同样具有一些更方便功能的框架，请签出。您可以通过迦太基将其添加到您的项目中，然后像上面的示例一样使用它：

import HandySwift    

let digits = Array(0...9)
digits.sample() // => 8

此外，它还包括一次获取多个随机元素的选项：

let digits = Array(0...9)
digits.sample() // => 6

digits.sample(size: 3) // => [8, 0, 7]

我发现使用GameKit的GKDrandomSource.SharedAndom（）最适合我

import GameKit

let array = ["random1", "random2", "random3"]

func getRandomIndex() -> Int {
    let randomNumber = GKRandomSource.sharedRandom().nextIntWithUpperBound(array.count)
    return randomNumber

或者，您可以返回所选随机索引处的对象。确保函数首先返回字符串，然后返回数组的索引

    return array[randomNumber]

简明扼要。
Swift 4版本：

extension Collection where Index == Int {

    /**
     Picks a random element of the collection.

     - returns: A random element of the collection.
     */
    func randomElement() -> Iterator.Element? {
        return isEmpty ? nil : self[Int(arc4random_uniform(UInt32(endIndex)))]
    }

}

另一个Swift 3建议

private extension Array {
    var randomElement: Element {
        let index = Int(arc4random_uniform(UInt32(count)))
        return self[index]
    }
}

斯威夫特3

导入游戏套件

func getRandomMessage() -> String {

    let messages = ["one", "two", "three"]

    let randomNumber = GKRandomSource.sharedRandom().nextInt(upperBound: messages.count)

    return messages[randomNumber].description

}

最新的swift3代码试试看，效果很好

 let imagesArray = ["image1.png","image2.png","image3.png","image4.png"]

        var randomNum: UInt32 = 0
        randomNum = arc4random_uniform(UInt32(imagesArray.count))
        wheelBackgroundImageView.image = UIImage(named: imagesArray[Int(randomNum)])

Swift 3-简单易用

创建数组

var arrayOfColors = [UIColor.red, UIColor.yellow, UIColor.orange, UIColor.green]


创建随机颜色

let randomColor = arc4random() % UInt32(arrayOfColors.count)


将该颜色设置为您的对象

your item = arrayOfColors[Int(randomColor)]


下面是一个来自
SpriteKit
项目的示例，该项目使用随机
字符串更新
SKLabelNode
：

    let array = ["one","two","three","four","five"]

    let randomNumber = arc4random() % UInt32(array.count)

    let labelNode = SKLabelNode(text: array[Int(randomNumber)])

如果您希望能够从阵列中获取多个随机元素，且无重复项，GameplayKit将介绍：

import GameplayKit
let array = ["one", "two", "three", "four"]

let shuffled = GKMersenneTwisterRandomSource.sharedRandom().arrayByShufflingObjects(in: array)

let firstRandom = shuffled[0]
let secondRandom = shuffled[1]

您有两个随机性选项，请参见：

GKARC4RandomSource
类使用的算法与arc4random C函数族中使用的算法类似。（但是，此类的实例独立于对arc4random函数的调用。）

gkrinearcongruentialrandomSource类使用的算法比GKARC4RandomSource类更快，但随机性更小。（具体来说，生成的数字的低位比高位重复的频率更高。）当性能比强大的不可预测性更重要时，使用此源

GKMersenneTwisterRandomSource
类使用的算法比GKARC4RandomSource类慢，但更随机。当使用随机数不显示重复模式和性能不太重要时，请使用此源

我使用Swift 4.2中引入的新功能找到了一种非常不同的方法

/现在在
集合上有一个内置方法：

let foods=[“您尝试过任何不同的方法吗？我会尝试
array[从0到长度-1的随机数]
，但我找不到如何在swift中生成随机int，如果我没有被阻止，我会在堆栈溢出时问它：）我不想用半个解决方案来污染这个问题，因为可能有ruby的
数组。示例
您使用的是arc4random（）就像你在Obj CNo中解释为什么你的问题没有收到与JQuery对应的相同反馈一样。但一般来说，你在发布问题时应该遵循这些指导原则。让问题看起来像是你在向别人寻求帮助之前花了一点力气想出了一个解决方案。当我谷歌“选择随机数”时“，第一页充满了建议arc4random_uniform的答案。另外，RTFD…”阅读f'ing文档。令人惊讶的是，有多少问题可以这样回答。感谢您的友好反馈。是的，我想我应该自己回答这个问题，但这似乎很容易
    let array = ["one","two","three","four","five"]

    let randomNumber = arc4random() % UInt32(array.count)

    let labelNode = SKLabelNode(text: array[Int(randomNumber)])

import GameplayKit
let array = ["one", "two", "three", "four"]

let shuffled = GKMersenneTwisterRandomSource.sharedRandom().arrayByShufflingObjects(in: array)

let firstRandom = shuffled[0]
let secondRandom = shuffled[1]