Dictionary

Overview 概要

A dictionary is a type of hash table, providing fast access to the entries it contains. Each entry in the table is identified using its key, which is a hashable type such as a string or number. You use that key to retrieve the corresponding value, which can be any object. In other languages, similar data types are known as hashes or associated arrays. 辞書はある種のハッシュテーブルであり、それが含んでいる登録項目への高速なアクセスを提供します。そのテーブル（表）の中の登録項目はそれのキーを使って特定され、そのキーはハッシュ化型、例えば文字列や数などです。あなたはこのキーを使ってその対応している値を取り出すことができ、その値はあらゆるオブジェクトであることができます。他の言語では、同じようなデータ型はハッシュまたは連想配列として知られます。

Create a new dictionary by using a dictionary literal. A dictionary literal is a comma-separated list of key-value pairs, in which a colon separates each key from its associated value, surrounded by square brackets. You can assign a dictionary literal to a variable or constant or pass it to a function that expects a dictionary. 新しい辞書を辞書リテラルを使って作成してください。辞書リテラルは、「キーと値」の組（キー値ペア）のコンマ区切りのリストで角括弧で囲まれています、このキー値ペアではコロンが各キーをそれの関連値から切り離します。あなたは、辞書リテラルを変数や定数に代入したり、それを辞書を予期する関数に渡したりできます。

Here’s how you would create a dictionary of HTTP response codes and their related messages: ここにあるのは、あなたがHTTP応答コードとそれらの関連メッセージの辞書を作成する方法です：

var responseMessages = [200: "OK",
                        403: "Access forbidden",
                        404: "File not found",
                        500: "Internal server error"]

The responseMessages variable is inferred to have type [Int: String]. The Key type of the dictionary is Int, and the Value type of the dictionary is String. responseMessages変数は、型[Int: String]を持つと推論されます。辞書のKey型はIntです、そして辞書のValue型はStringです。

To create a dictionary with no key-value pairs, use an empty dictionary literal ([:]). キー値ペアを持たない辞書を作成するには、空の辞書リテラル（[:]）を使ってください。

var emptyDict: [String: String] = [:]

Any type that conforms to the Hashable protocol can be used as a dictionary’s Key type, including all of Swift’s basic types. You can use your own custom types as dictionary keys by making them conform to the Hashable protocol. Swiftの基本的な型のすべてを含めて、Hashableプロトコルに準拠するあらゆる型は、辞書のKey型として使われることができます。あなたは、あなた独自のあつらえの型を辞書のキーとして使うことがそれらをHashableプロトコルに準拠させることによって可能です。

Getting and Setting Dictionary Values 辞書の値の取得と設定

The most common way to access values in a dictionary is to use a key as a subscript. Subscripting with a key takes the following form: 辞書の中の値にアクセスする最も普通の方法は、キーを添え字として使うことです。キーによる添え字は以下の形式をとります：

print(responseMessages[200])
// Prints "Optional("OK")"

Subscripting a dictionary with a key returns an optional value, because a dictionary might not hold a value for the key that you use in the subscript. あるキーで辞書に添え字を使うことは、オプショナル値を返します、なぜなら辞書はあなたが添え字に使ったキーに対して値を保持しないかもしれないからです。

The next example uses key-based subscripting of the responseMessages dictionary with two keys that exist in the dictionary and one that does not. 次の例は、キーに基づく添え字をresponseMessages辞書に使います、ですが２つのキーは辞書に存在し１つはそうでありません。

let httpResponseCodes = [200, 403, 301]
for code in httpResponseCodes {
    if let message = responseMessages[code] {
        print("Response \(code): \(message)")
    } else {
        print("Unknown response \(code)")
    }
}
// Prints "Response 200: OK"
// Prints "Response 403: Access forbidden"
// Prints "Unknown response 301"

You can also update, modify, or remove keys and values from a dictionary using the key-based subscript. To add a new key-value pair, assign a value to a key that isn’t yet a part of the dictionary. あなたはまた、辞書のキーと値の更新、修正、または削除をキー基盤の添え字を使って可能です。新しいキー値ペアを加えるには、ある値を、まだ辞書の一部ではないキーに対して割り当ててください。

responseMessages[301] = "Moved permanently"
print(responseMessages[301])
// Prints "Optional("Moved permanently")"

Update an existing value by assigning a new value to a key that already exists in the dictionary. If you assign nil to an existing key, the key and its associated value are removed. The following example updates the value for the 404 code to be simply “Not found” and removes the key-value pair for the 500 code entirely. すでに辞書に存在するキーに新しい値を割り当てることで、既存の値を更新してください。あなたがnilを既存のキーに割り当てるならば、そのキーとそれの関連値は削除されます。以下の例は、404コードの値を単純に「Not found」に更新して、500コードに対するキー値ペアをすっかり削除します。

responseMessages[404] = "Not found"
responseMessages[500] = nil
print(responseMessages)
// Prints "[301: "Moved permanently", 200: "OK", 403: "Access forbidden", 404: "Not found"]"

In a mutable Dictionary instance, you can modify in place a value that you’ve accessed through a keyed subscript. The code sample below declares a dictionary called interestingNumbers with string keys and values that are integer arrays, then sorts each array in-place in descending order. 可変のDictionaryインスタンスでは、あなたがキーによる添え字を通してアクセスしたある値をその場で修正できます。下のコード見本は、interestingNumbersと呼ばれる辞書を文字列キーと整数配列である値で宣言します、それから各配列をその場で降順にソートします。

var interestingNumbers = ["primes": [2, 3, 5, 7, 11, 13, 17],
                          "triangular": [1, 3, 6, 10, 15, 21, 28],
                          "hexagonal": [1, 6, 15, 28, 45, 66, 91]]
for key in interestingNumbers.keys {
    interestingNumbers[key]?.sort(by: >)
}


print(interestingNumbers["primes"]!)
// Prints "[17, 13, 11, 7, 5, 3, 2]"

Iterating Over the Contents of a Dictionary 辞書の内容すべてにわたって反復していく

Every dictionary is an unordered collection of key-value pairs. You can iterate over a dictionary using a for-in loop, decomposing each key-value pair into the elements of a tuple. すべての辞書は、キー値ペアの順番付けられないコレクションです。あなたは辞書全体にわたって反復適用していくことが、for-inループを使うことで、各キー値ペアをタプルの要素へと分解しながら可能です。

let imagePaths = ["star": "/glyphs/star.png",
                  "portrait": "/images/content/portrait.jpg",
                  "spacer": "/images/shared/spacer.gif"]


for (name, path) in imagePaths {
    print("The path to '\(name)' is '\(path)'.")
}
// Prints "The path to 'star' is '/glyphs/star.png'."
// Prints "The path to 'portrait' is '/images/content/portrait.jpg'."
// Prints "The path to 'spacer' is '/images/shared/spacer.gif'."

The order of key-value pairs in a dictionary is stable between mutations but is otherwise unpredictable. If you need an ordered collection of key-value pairs and don’t need the fast key lookup that Dictionary provides, see the KeyValuePairs type for an alternative. 辞書中のキー値ペアの順番は各変化間は安定しています、しかしそれ以外では予測できません。あなたが順番付けられたキー値ペアのコレクションを必要とするそしてDictionaryが提供する高速な検索を必要としないならば、代わりのものとしてKeyValuePairs型を見てください。

You can search a dictionary’s contents for a particular value using the contains(where:) or firstIndex(where:) methods supplied by default implementation. The following example checks to see if imagePaths contains any paths in the "/glyphs" directory: あなたは、ある特定の値を求めて辞書の持つ内容を検索することが、省略時の実装で提供されるcontains(where:)またはfirstIndex(where:)メソッドを使って可能です。以下の例は、imagePathsが何らかのパスを"/glyphs"ディレクトリの中に含むかどうかを調べるために検査します。

let glyphIndex = imagePaths.firstIndex(where: { $0.value.hasPrefix("/glyphs") })
if let index = glyphIndex {
    print("The '\(imagePaths[index].key)' image is a glyph.")
} else {
    print("No glyphs found!")
}
// Prints "The 'star' image is a glyph.")

Note that in this example, imagePaths is subscripted using a dictionary index. Unlike the key-based subscript, the index-based subscript returns the corresponding key-value pair as a non-optional tuple. この例において、imagePathsが辞書インデックスを使って添え字をすることに注意してください。キー基盤の添え字と違い、インデックス基盤の添え字は該当するキー値ペアを非オプショナルのタプルとして返します。

print(imagePaths[glyphIndex!])
// Prints "(key: "star", value: "/glyphs/star.png")"

A dictionary’s indices stay valid across additions to the dictionary as long as the dictionary has enough capacity to store the added values without allocating more buffer. When a dictionary outgrows its buffer, existing indices may be invalidated without any notification. 辞書のインデックスは、その辞書への追加をまたいで有効なままです、加えられた値をもっとバッファを割り当てることなく格納するために辞書が十分な容量を持つ限りは。辞書がそれのバッファより大きくなる時、既存のインデックスは何の通知もなしに無効にされるでしょう。

When you know how many new values you’re adding to a dictionary, use the init(minimumCapacity:) initializer to allocate the correct amount of buffer. どのくらい多くの新しい値をあなたが辞書に加えることになるかあなたが知っている場合は、init(minimumCapacity:)イニシャライザを使って正確な量のバッファを割り当ててください。

Bridging Between Dictionary and NSDictionary DictionaryとNSDictionaryの間のブリッジ

You can bridge between Dictionary and NSDictionary using the as operator. For bridging to be possible, the Key and Value types of a dictionary must be classes, @objc protocols, or types that bridge to Foundation types. あなたは、DictionaryとNSDictionaryの間をブリッジすることがas演算子を使って行えます。ブリッジが可能にされるには、辞書のKeyとValue型がクラス、@objcプロトコル、またはFoundation型にブリッジする型でなければなりません。

Bridging from Dictionary to NSDictionary always takes O(1) time and space. When the dictionary’s Key and Value types are neither classes nor @objc protocols, any required bridging of elements occurs at the first access of each element. For this reason, the first operation that uses the contents of the dictionary may take O(n). DictionaryからNSDictionaryへのブリッジは、常にO(1)時間と空間をとります。辞書のKeyとValue型がクラスでも@objcプロトコルでもない場合、それら要素のブリッジに必要とされるあらゆることが各要素の最初のアクセスで起こります。この理由のために、辞書の内容を使う最初の演算はO(n)をとるでしょう。

Bridging from NSDictionary to Dictionary first calls the copy(with:) method (- copyWithZone: in Objective-C) on the dictionary to get an immutable copy and then performs additional Swift bookkeeping work that takes O(1) time. For instances of NSDictionary that are already immutable, copy(with:) usually returns the same dictionary in O(1) time; otherwise, the copying performance is unspecified. The instances of NSDictionary and Dictionary share buffer using the same copy-on-write optimization that is used when two instances of Dictionary share buffer. NSDictionaryからDictionaryへのブリッジは、最初にcopy(with:)メソッド（Objective-Cでの- copyWithZone:）をその辞書上で呼び出して可変のコピーを取得して、それからO(1)時間を取る追加的なSwift簿記作業を実行します。すでに可変のNSDictionaryのインスタンスに対しては、copy(with:)は通常同じ辞書をO(1)時間で返します；そうでなければ、このコピー性能は不定です。NSDictionaryとDictionaryインスタンスは、Dictionaryの２つのインスタンスがバッファを共有するとき使われるのと、同じコピーオンライト最適化を使ってバッファを共有します。