在Apple关于与C API交互的文档中，它们描述了将NS_ENUM标记的C样式枚举作为Swift枚举导入的方式。这是有道理的，因为Swift中的枚举很容易作为enum值类型提供，所以很容易看到如何创建我们自己的。
更进一步说，这是关于NS_OPTIONS标记的C风格选项：
Swift还导入标有
NS_OPTIONS宏的选项。选项的行为与导入的枚举类似，而选项也可以支持一些按位操作，例如&，|和~。在Objective-C中，您表示一个空的选项集，其常量为零（0）。在Swift中，使用nil表示没有任何选项。
鉴于Swift中没有options值类型，我们如何创建一个C-Style选项变量来使用？
几乎与Swift 2.0完全相同。 OptionSetType已重命名为OptionSet，枚举按约定写成小写。
struct MyOptions : OptionSet {
let rawValue: Int
static let firstOption = MyOptions(rawValue: 1 << 0)
static let secondOption = MyOptions(rawValue: 1 << 1)
static let thirdOption = MyOptions(rawValue: 1 << 2)
}
Swift 3建议使用空数组文字，而不是提供none选项：
let noOptions: MyOptions = []
其他用途：
let singleOption = MyOptions.firstOption
let multipleOptions: MyOptions = [.firstOption, .secondOption]
if multipleOptions.contains(.secondOption) {
print("multipleOptions has SecondOption")
}
let allOptions = MyOptions(rawValue: 7)
if allOptions.contains(.thirdOption) {
print("allOptions has ThirdOption")
}
在Swift 2.0中，协议扩展负责处理这些的大多数样板，现在它们作为符合OptionSetType的结构导入。 （RawOptionSetType已经从Swift 2 beta 2中消失了。）声明要简单得多：
struct MyOptions : OptionSetType {
let rawValue: Int
static let None = MyOptions(rawValue: 0)
static let FirstOption = MyOptions(rawValue: 1 << 0)
static let SecondOption = MyOptions(rawValue: 1 << 1)
static let ThirdOption = MyOptions(rawValue: 1 << 2)
}
现在我们可以使用基于集合的语义与MyOptions：
let singleOption = MyOptions.FirstOption
let multipleOptions: MyOptions = [.FirstOption, .SecondOption]
if multipleOptions.contains(.SecondOption) {
print("multipleOptions has SecondOption")
}
let allOptions = MyOptions(rawValue: 7)
if allOptions.contains(.ThirdOption) {
print("allOptions has ThirdOption")
}
看看Swift导入的Objective-C选项（例如UIViewAutoresizing），我们可以看到选项被声明为符合协议struct的RawOptionSetType，后者又符合_RawOptionSetType，Equatable，RawRepresentable，BitwiseOperationsType和NilLiteralConvertible 。我们可以像这样创建自己的：
struct MyOptions : RawOptionSetType {
typealias RawValue = UInt
private var value: UInt = 0
init(_ value: UInt) { self.value = value }
init(rawValue value: UInt) { self.value = value }
init(nilLiteral: ()) { self.value = 0 }
static var allZeros: MyOptions { return self(0) }
static func fromMask(raw: UInt) -> MyOptions { return self(raw) }
var rawValue: UInt { return self.value }
static var None: MyOptions { return self(0) }
static var FirstOption: MyOptions { return self(1 << 0) }
static var SecondOption: MyOptions { return self(1 << 1) }
static var ThirdOption: MyOptions { return self(1 << 2) }
}
现在我们可以处理这个新的选项集MyOptions，就像在Apple的文档中描述的那样：你可以使用类似enum的语法：
let opt1 = MyOptions.FirstOption
let opt2: MyOptions = .SecondOption
let opt3 = MyOptions(4)
它的行为也像我们期望的行为选择：
let singleOption = MyOptions.FirstOption
let multipleOptions: MyOptions = singleOption | .SecondOption
if multipleOptions & .SecondOption != nil { // see note
println("multipleOptions has SecondOption")
}
let allOptions = MyOptions.fromMask(7) // aka .fromMask(0b111)
if allOptions & .ThirdOption != nil {
println("allOptions has ThirdOption")
}
我已经建立了一个没有找到/替换的generator to create a Swift option set。
最新：Swift 1.1 beta 3的修改。
没有人提到它 - 我在经过一些修补之后对它有点失误 - 但是Swift Set似乎工作得相当好。
如果我们想（可能是维恩图？）关于实际表示的位掩码，它可能是空集。
当然，在从第一原理处理问题时，我们失去了按位运算符的便利性，但获得了强大的基于集合的方法，从而提高了可读性。
这是我的修修补举：
enum Toppings : String {
// Just strings 'cause there's no other way to get the raw name that I know of...
// Could be 1 << x too...
case Tomato = "tomato"
case Salami = "salami"
case Cheese = "cheese"
case Chicken = "chicken"
case Beef = "beef"
case Anchovies = "anchovies"
static let AllOptions: Set<Toppings> = [.Tomato, .Salami, .Cheese, .Chicken, .Anchovies, .Beef]
}
func checkPizza(toppings: Set<Toppings>) {
if toppings.contains(.Cheese) {
print("Possible dairy allergies?")
}
let meats: Set<Toppings> = [.Beef, .Chicken, .Salami]
if toppings.isDisjointWith(meats) {
print("Vego-safe!")
}
if toppings.intersect(meats).count > 1 {
print("Limit one meat, or 50¢ extra charge!")
}
if toppings == [Toppings.Cheese] {
print("A bit boring?")
}
}
checkPizza([.Tomato, .Cheese, .Chicken, .Beef])
checkPizza([.Cheese])
我发现这很好，因为我觉得它来自问题的第一原理方法 - 很像Swift - 而不是试图适应C风格的解决方案。
还希望听到一些Obj-C用例会挑战这种不同的范例，其中整数原始值仍然显示出优点。
为了避免硬编码位位置，这在使用(1 << 0)，(1 << 1)，(1 << 15)等甚至更糟的1，2，16384等或一些十六进制变体时是不可避免的，人们可以先定义enum中的位，然后让我们说enum做位序计算：
// Bits
enum Options : UInt {
case firstOption
case secondOption
case thirdOption
}
// Byte
struct MyOptions : OptionSet {
let rawValue: UInt
static let firstOption = MyOptions(rawValue: 1 << Options.firstOption.rawValue)
static let secondOption = MyOptions(rawValue: 1 << Options.secondOption.rawValue)
static let thirdOption = MyOptions(rawValue: 1 << Options.thirdOption.rawValue)
}
我使用以下内容我需要我可以得到的两个值，rawValue用于索引数组和value for flags。
enum MyEnum: Int {
case one
case two
case four
case eight
var value: UInt8 {
return UInt8(1 << self.rawValue)
}
}
let flags: UInt8 = MyEnum.one.value ^ MyEnum.eight.value
(flags & MyEnum.eight.value) > 0 // true
(flags & MyEnum.four.value) > 0 // false
(flags & MyEnum.two.value) > 0 // false
(flags & MyEnum.one.value) > 0 // true
MyEnum.eight.rawValue // 3
MyEnum.four.rawValue // 2
如果需要更多，只需添加计算属性。
enum MyEnum: Int {
case one
case two
case four
case eight
var value: UInt8 {
return UInt8(1 << self.rawValue)
}
var string: String {
switch self {
case .one:
return "one"
case .two:
return "two"
case .four:
return "four"
case .eight:
return "eight"
}
}
}
re：使用带有多个选项的选项集创建沙盒和书签
let options:NSURL.BookmarkCreationOptions = [.withSecurityScope,.securityScopeAllowOnlyReadAccess]
let temp = try link.bookmarkData(options: options, includingResourceValuesForKeys: nil, relativeTo: nil)
需要组合创作选项的解决方案，当并非所有选项都是互斥的时候很有用。
Nate's answer很好，但我会把它DIY，如下：
struct MyOptions : OptionSetType {
let rawValue: Int
static let None = Element(rawValue: 0)
static let FirstOption = Element(rawValue: 1 << 0)
static let SecondOption = Element(rawValue: 1 << 1)
static let ThirdOption = Element(rawValue: 1 << 2)
}
使用选项集类型，在swift 3中使用OptionSet
struct ShippingOptions: OptionSet {
let rawValue: Int
static let nextDay = ShippingOptions(rawValue: 1 << 0)
static let secondDay = ShippingOptions(rawValue: 1 << 1)
static let priority = ShippingOptions(rawValue: 1 << 2)
static let standard = ShippingOptions(rawValue: 1 << 3)
static let express: ShippingOptions = [.nextDay, .secondDay]
static let all: ShippingOptions = [.express, .priority, .standard]
}
Xcode 6.1 Beta 2对RawOptionSetTypeprotocol进行了一些更改（请参阅此Airspeedvelocity blog entry和Apple release notes）。
基于Nate Cooks的例子，这里有一个更新的解决方案。您可以像这样定义自己的选项集：
struct MyOptions : RawOptionSetType, BooleanType {
private var value: UInt
init(_ rawValue: UInt) { self.value = rawValue }
// MARK: _RawOptionSetType
init(rawValue: UInt) { self.value = rawValue }
// MARK: NilLiteralConvertible
init(nilLiteral: ()) { self.value = 0}
// MARK: RawRepresentable
var rawValue: UInt { return self.value }
// MARK: BooleanType
var boolValue: Bool { return self.value != 0 }
// MARK: BitwiseOperationsType
static var allZeros: MyOptions { return self(0) }
// MARK: User defined bit values
static var None: MyOptions { return self(0) }
static var FirstOption: MyOptions { return self(1 << 0) }
static var SecondOption: MyOptions { return self(1 << 1) }
static var ThirdOption: MyOptions { return self(1 << 2) }
static var All: MyOptions { return self(0b111) }
}
然后可以像这样使用它来定义变量：
let opt1 = MyOptions.FirstOption
let opt2:MyOptions = .SecondOption
let opt3 = MyOptions(4)
像这样测试位：
let singleOption = MyOptions.FirstOption
let multipleOptions: MyOptions = singleOption | .SecondOption
if multipleOptions & .SecondOption {
println("multipleOptions has SecondOption")
}
let allOptions = MyOptions.All
if allOptions & .ThirdOption {
println("allOptions has ThirdOption")
}
文档中的Swift 2.0示例：
struct PackagingOptions : OptionSetType {
let rawValue: Int
init(rawValue: Int) { self.rawValue = rawValue }
static let Box = PackagingOptions(rawValue: 1)
static let Carton = PackagingOptions(rawValue: 2)
static let Bag = PackagingOptions(rawValue: 4)
static let Satchel = PackagingOptions(rawValue: 8)
static let BoxOrBag: PackagingOptions = [Box, Bag]
static let BoxOrCartonOrBag: PackagingOptions = [Box, Carton, Bag]
}
你可以找到它here
在Swift 2中（目前作为Xcode 7测试版的一部分测试版），NS_OPTIONS风格的类型被导入为新的OptionSetType类型的子类型。由于新的Protocol Extensions功能和OptionSetType在标准库中的实现方式，您可以声明自己的类型来扩展OptionsSetType并获得导入NS_OPTIONS样式类型的所有相同的函数和方法。
但是这些函数不再基于按位算术运算符。在C中使用一组非排他性布尔选项需要在字段中屏蔽和修整位是一个实现细节。实际上，一组选项是一组......一组独特的项目。所以OptionsSetType从SetAlgebraType协议中获取所有方法，例如从数组文字语法创建，像contains这样的查询，用intersection屏蔽等等。（不再需要记住哪个有趣的字符用于哪个成员资格测试！）
//Swift 2.0
//create
struct Direction : OptionSetType {
let rawValue: Int
static let None = Direction(rawValue: 0)
static let Top = Direction(rawValue: 1 << 0)
static let Bottom = Direction(rawValue: 1 << 1)
static let Left = Direction(rawValue: 1 << 2)
static let Right = Direction(rawValue: 1 << 3)
}
//declare
var direction: Direction = Direction.None
//using
direction.insert(Direction.Right)
//check
if direction.contains(.Right) {
//`enter code here`
}
如果您不需要与Objective-C进行互操作，只需要在Swift中使用位掩码的表面语义，我就编写了一个名为BitwiseOptions的简单“库”，它可以使用常规的Swift枚举来实现，例如：
enum Animal: BitwiseOptionsType {
case Chicken
case Cow
case Goat
static let allOptions = [.Chicken, .Cow, .Goat]
}
var animals = Animal.Chicken | Animal.Goat
animals ^= .Goat
if animals & .Chicken == .Chicken {
println("Chick-Fil-A!")
}
等等。这里没有翻转实际位。这些是对不透明值的设置操作。你可以找到要点here。
如果我们需要的唯一功能是将选项与|组合在一起，并检查组合选项是否包含&的特定选项，那么替代Nate Cook的答案可能是：
创建一个选项protocol并重载|和&：
protocol OptionsProtocol {
var value: UInt { get }
init (_ value: UInt)
}
func | <T: OptionsProtocol>(left: T, right: T) -> T {
return T(left.value | right.value)
}
func & <T: OptionsProtocol>(left: T, right: T) -> Bool {
if right.value == 0 {
return left.value == 0
}
else {
return left.value & right.value == right.value
}
}
现在我们可以更简单地创建选项结构：
struct MyOptions: OptionsProtocol {
private(set) var value: UInt
init (_ val: UInt) {value = val}
static var None: MyOptions { return self(0) }
static var One: MyOptions { return self(1 << 0) }
static var Two: MyOptions { return self(1 << 1) }
static var Three: MyOptions { return self(1 << 2) }
}
它们可以如下使用：
func myMethod(#options: MyOptions) {
if options & .One {
// Do something
}
}
myMethod(options: .One | .Three)
只是为其他想知道你是否可以组合复合选项的人发布一个额外的例子。你可以，如果你已经习惯了旧的比特场，它们会像你期望的那样结合起来：
struct State: OptionSetType {
let rawValue: Int
static let A = State(rawValue: 1 << 0)
static let B = State(rawValue: 1 << 1)
static let X = State(rawValue: 1 << 2)
static let AB:State = [.A, .B]
static let ABX:State = [.AB, .X] // Combine compound state with .X
}
let state: State = .ABX
state.contains(.A) // true
state.contains(.AB) // true
它将[.AB, .X]集合成[.A, .B, .X]（至少在语义上）：
print(state) // 0b111 as expected: "State(rawValue: 7)"
print(State.AB) // 0b11 as expected: "State(rawValue: 3)"
正如Rickster已经提到的，你可以在Swift 2.0中使用OptionSetType。导入的NS_OPTIONS类型符合OptionSetType协议，该协议为选项提供了类似集合的接口：
struct CoffeeManipulators : OptionSetType {
let rawValue: Int
static let Milk = CoffeeManipulators(rawValue: 1)
static let Sugar = CoffeeManipulators(rawValue: 2)
static let MilkAndSugar = [Milk, Sugar]
}
它为您提供了这种工作方式：
struct Coffee {
let manipulators:[CoffeeManipulators]
// You can now simply check if an option is used with contains
func hasMilk() -> Bool {
return manipulators.contains(.Milk)
}
func hasManipulators() -> Bool {
return manipulators.count != 0
}
}