Swift Language
列挙型
サーチ…
備考
構造体やクラスとは異なり、列挙型は値型であり、渡されたときに参照される代わりにコピーされます。
列挙型の詳細については、Swiftプログラミング言語を参照してください。
基本的な列挙
enumは関連する値のセットを提供します：
enum Direction {
case up
case down
case left
case right
}
enum Direction { case up, down, left, right }
Enum値は完全修飾名で使用できますが、推論できる場合は型名を省略できます。
let dir = Direction.up
let dir: Direction = Direction.up
let dir: Direction = .up
// func move(dir: Direction)...
move(Direction.up)
move(.up)
obj.dir = Direction.up
obj.dir = .up
enum値を比較/抽出する最も基本的な方法は、 switch文を使用するswitchです。
switch dir {
case .up:
// handle the up case
case .down:
// handle the down case
case .left:
// handle the left case
case .right:
// handle the right case
}
単純な列挙型は自動的にHashable 、 Equatable 、および文字列変換を行います：
if dir == .down { ... }
let dirs: Set<Direction> = [.right, .left]
print(Direction.up) // prints "up"
debugPrint(Direction.up) // prints "Direction.up"
関連付けられた値を持つ列挙型
列挙型のケースには、1つ以上のペイロード （ 関連する値 ）を含めることができます。
enum Action {
case jump
case kick
case move(distance: Float) // The "move" case has an associated distance
}
列挙型の値をインスタンス化するときは、ペイロードを指定する必要があります。
performAction(.jump)
performAction(.kick)
performAction(.move(distance: 3.3))
performAction(.move(distance: 0.5))
switch文は関連する値を抽出できます：
switch action {
case .jump:
...
case .kick:
...
case .move(let distance): // or case let .move(distance):
print("Moving: \(distance)")
}
単一ケース抽出を使用して行うことができるif case ：
if case .move(let distance) = action {
print("Moving: \(distance)")
}
guard case構文は、後で使用するために使用できます。
guard case .move(let distance) = action else {
print("Action is not move")
return
}
関連付けられた値を持つEquatable 、デフォルトではEquatableはありません。 ==演算子の実装は手動で行う必要があります。
extension Action: Equatable { }
func ==(lhs: Action, rhs: Action) -> Bool {
switch lhs {
case .jump: if case .jump = rhs { return true }
case .kick: if case .kick = rhs { return true }
case .move(let lhsDistance): if case .move (let rhsDistance) = rhs { return lhsDistance == rhsDistance }
}
return false
}
間接ペイロード
通常、列挙型は再帰的ではありません（無限の記憶域が必要なため）。
enum Tree<T> {
case leaf(T)
case branch(Tree<T>, Tree<T>) // error: recursive enum 'Tree<T>' is not marked 'indirect'
}
indirectキーワードは、インライン格納するのではなく、間接参照のレイヤーを使用してペイロードを格納します。 1つのケースでこのキーワードを使用することができます：
enum Tree<T> {
case leaf(T)
indirect case branch(Tree<T>, Tree<T>)
}
let tree = Tree.branch(.leaf(1), .branch(.leaf(2), .leaf(3)))
indirectも列挙型全体で動作し、必要に応じて間接的に行います。
indirect enum Tree<T> {
case leaf(T)
case branch(Tree<T>, Tree<T>)
}
生とハッシュの値
ペイロードを持たない列挙型は、任意のリテラル型の生の値を持つことができます：
enum Rotation: Int {
case up = 0
case left = 90
case upsideDown = 180
case right = 270
}
特定の型を持たない列挙型は、rawValueプロパティを公開しません
enum Rotation {
case up
case right
case down
case left
}
let foo = Rotation.up
foo.rawValue //error
整数の生の値は0から始まり単調増加すると仮定されます。
enum MetasyntacticVariable: Int {
case foo // rawValue is automatically 0
case bar // rawValue is automatically 1
case baz = 7
case quux // rawValue is automatically 8
}
文字列の生の値は自動的に合成できます：
enum MarsMoon: String {
case phobos // rawValue is automatically "phobos"
case deimos // rawValue is automatically "deimos"
}
raw値enumは自動的にRawRepresentableに準拠します 。 .rawValue列挙値の対応する生の値を取得できます。
func rotate(rotation: Rotation) {
let degrees = rotation.rawValue
...
}
また、 init?(rawValue:)を使用して生の値から列挙型を作成することもできます：
let rotation = Rotation(rawValue: 0) // returns Rotation.Up
let otherRotation = Rotation(rawValue: 45) // returns nil (there is no Rotation with rawValue 45)
if let moon = MarsMoon(rawValue: str) {
print("Mars has a moon named \(str)")
} else {
print("Mars doesn't have a moon named \(str)")
}
特定の列挙型のハッシュ値を取得したい場合は、そのハッシュ値にアクセスできます。ハッシュ値は列挙型のインデックスをゼロから始まります。
let quux = MetasyntacticVariable(rawValue: 8)// rawValue is 8
quux?.hashValue //hashValue is 3
イニシャライザ
Enumには、デフォルトのinit?(rawValue:)よりも便利なカスタムinitメソッドがあります。 Enumは値も格納できます。これは、初期化された場所に値を格納し、後でその値を取得する場合に便利です。
enum CompassDirection {
case north(Int)
case south(Int)
case east(Int)
case west(Int)
init?(degrees: Int) {
switch degrees {
case 0...45:
self = .north(degrees)
case 46...135:
self = .east(degrees)
case 136...225:
self = .south(degrees)
case 226...315:
self = .west(degrees)
case 316...360:
self = .north(degrees)
default:
return nil
}
}
var value: Int = {
switch self {
case north(let degrees):
return degrees
case south(let degrees):
return degrees
case east(let degrees):
return degrees
case west(let degrees):
return degrees
}
}
}
この初期化子を使用して、これを行うことができます：
var direction = CompassDirection(degrees: 0) // Returns CompassDirection.north
direction = CompassDirection(degrees: 90) // Returns CompassDirection.east
print(direction.value) //prints 90
direction = CompassDirection(degrees: 500) // Returns nil
列挙型はクラスや構造体と多くの機能を共有します
Swiftの列挙型は、 Cなどの他の言語の対応者よりもはるかに強力です。それらは、 初期化子 、 計算されたプロパティ 、 インスタンスメソッド 、 プロトコルの適合性 、 拡張などのクラスや構造体と多くの機能を共有します。
protocol ChangesDirection {
mutating func changeDirection()
}
enum Direction {
// enumeration cases
case up, down, left, right
// initialise the enum instance with a case
// that's in the opposite direction to another
init(oppositeTo otherDirection: Direction) {
self = otherDirection.opposite
}
// computed property that returns the opposite direction
var opposite: Direction {
switch self {
case .up:
return .down
case .down:
return .up
case .left:
return .right
case .right:
return .left
}
}
}
// extension to Direction that adds conformance to the ChangesDirection protocol
extension Direction: ChangesDirection {
mutating func changeDirection() {
self = .left
}
}
var dir = Direction(oppositeTo: .down) // Direction.up
dir.changeDirection() // Direction.left
let opposite = dir.opposite // Direction.right
入れ子になった列挙
列挙型を他の列の中に入れ子にすることができます。これにより、階層型列挙型をより整理して構造化することができます。
enum Orchestra {
enum Strings {
case violin
case viola
case cello
case doubleBasse
}
enum Keyboards {
case piano
case celesta
case harp
}
enum Woodwinds {
case flute
case oboe
case clarinet
case bassoon
case contrabassoon
}
}
そして、あなたはそれを次のように使うことができます：
let instrment1 = Orchestra.Strings.viola
let instrment2 = Orchestra.Keyboards.piano