Guides and Sample Code

Developer

The Swift Programming Language (Swift 4.1)

iBooks
On This Page

Classes and Structures
クラスと構造体

Classes and structures are general-purpose, flexible constructs that become the building blocks of your program’s code. You define properties and methods to add functionality to your classes and structures by using exactly the same syntax as for constants, variables, and functions.
クラスおよび構造体は、あなたのプログラムのコードの建築ブロックになる、万能で、柔軟な構造物です。あなたは、機能性をあなたのクラスおよび構造体に加えるためにプロパティとメソッドを定義します、それには、定数、変数、そして関数に対するのとまったく同じ構文を使います。

Unlike other programming languages, Swift does not require you to create separate interface and implementation files for custom classes and structures. In Swift, you define a class or a structure in a single file, and the external interface to that class or structure is automatically made available for other code to use.
他のプログラミング言語と違って、スウィフトはあなたにカスタム・クラスおよび構造体のために別々のインタフェースおよび実装ファイルを作成することを要求しません。スウィフトでは、あなたは一つのファイルにおいてクラスまたは構造体を定義します、そして、そのクラスまたは構造体への外部インタフェースは自動的に他のコードが使うことが可能にされます。

Comparing Classes and Structures
クラスと構造体を比較する

Classes and structures in Swift have many things in common. Both can:
スウィフトでのクラスと構造体は、多くのものを共通して持ちます。両方とも以下のことができます:

  • Define properties to store values
    値を格納するために、プロパティを定義します

  • Define methods to provide functionality
    機能性を提供するために、メソッドを定義します

  • Define subscripts to provide access to their values using subscript syntax
    添え字構文を使用してそれらの値の利用することを提供するために、添え字を定義します

  • Define initializers to set up their initial state
    それらの初期状態を設定するために、イニシャライザを定義します

  • Be extended to expand their functionality beyond a default implementation
    それらの機能性を元の実装を越えて広げるために、拡張されます

  • Conform to protocols to provide standard functionality of a certain kind
    特定の種類の標準の機能性を提供するために、プロトコルに準拠します

For more information, see Properties, Methods, Subscripts, Initialization, Extensions, and Protocols.
詳細は、プロパティメソッド添え字初期化拡張、そしてプロトコルを見てください。

Classes have additional capabilities that structures do not:
クラスは、構造体がそうしない追加の能力を持ちます:

  • Inheritance enables one class to inherit the characteristics of another.
    継承は、あるクラスが他のものの特徴を受け継ぐのを可能にします。

  • Type casting enables you to check and interpret the type of a class instance at runtime.
    型キャストは、あなたにクラスインスタンスの型を実行時に調べて解釈することを可能にします。

  • Deinitializers enable an instance of a class to free up any resources it has assigned.
    デイニシャライザは、クラスのインスタンスにそれが代入したどんなリソースでも解放するのを可能にします。

  • Reference counting allows more than one reference to a class instance.
    参照カウントは、あるクラスインスタンスに対する1つ以上の参照を許します。

For more information, see Inheritance, Type Casting, Deinitialization, and Automatic Reference Counting.
詳細は、継承型キャストデイニシャライズ、そして自動参照カウントを見てください。

Definition Syntax
定義構文

Classes and structures have a similar definition syntax. You introduce classes with the class keyword and structures with the struct keyword. Both place their entire definition within a pair of braces:
クラスと構造体は、類似した定義構文を持ちます。あなたは、classキーワードでクラスを、そしてstructキーワードで構造体を始めます。両方とも、それらの全ての定義を一対の波括弧の範囲内に置きます:

  1. class SomeClass {
  2. // class definition goes here (クラス定義が、ここにきます)
  3. }
  4. struct SomeStructure {
  5. // structure definition goes here (構造体定義が、ここにきます)
  6. }

Here’s an example of a structure definition and a class definition:
構造体定義とクラス定義の例は、ここにあります:

  1. struct Resolution {
  2. var width = 0
  3. var height = 0
  4. }
  5. class VideoMode {
  6. var resolution = Resolution()
  7. var interlaced = false
  8. var frameRate = 0.0
  9. var name: String?
  10. }

The example above defines a new structure called Resolution, to describe a pixel-based display resolution. This structure has two stored properties called width and height. Stored properties are constants or variables that are bundled up and stored as part of the class or structure. These two properties are inferred to be of type Int by setting them to an initial integer value of 0.
上の例は、ピクセルに基づくディスプレイ解像度を記述するために、Resolutionと呼ばれる新しい構造体を定義します。この構造体は、2つの格納プロパティ、widthheightと呼ばれるものを持ちます。格納プロパティは、クラスまたは構造体の一部としてまとめられて格納される定数または変数です。これらの2つのプロパティは、それらを最初の整数値0に設定することによって型Intであると推論されます。

The example above also defines a new class called VideoMode, to describe a specific video mode for video display. This class has four variable stored properties. The first, resolution, is initialized with a new Resolution structure instance, which infers a property type of Resolution. For the other three properties, new VideoMode instances will be initialized with an interlaced setting of false (meaning “noninterlaced video”), a playback frame rate of 0.0, and an optional String value called name. The name property is automatically given a default value of nil, or “no name value”, because it is of an optional type.
上の例は、また、ビデオ・ディスプレイのために特定のビデオ・モードを記述するために、VideoModeと呼ばれる新しいクラスを定義します。このクラスは、4つの変数の格納プロパティを持ちます。一番目、resolutionは、新しいResolution構造体インスタンスで初期化されます、そしてそれは、Resolutionのプロパティ型を暗に意味します。他の3つのプロパティのために、新しいVideoModeインスタンスは、falseに設定されるinterlaced(「ノンインタレース・ビデオ」を意味します)、0.0の再生フレームレート、nameというオプショナルのString値で初期化されます。nameプロパティは省略時の値のnil、つまり「name値なし」を自動的に与えられます、なぜならそれがオプショナル型であるからです。

Class and Structure Instances
クラスと構造体のインスタンス

The Resolution structure definition and the VideoMode class definition only describe what a Resolution or VideoMode will look like. They themselves do not describe a specific resolution or video mode. To do that, you need to create an instance of the structure or class.
Resolution構造体定義とVideoModeクラス定義は、ResolutionまたはVideoModeがどのようなものかについて記述するだけです。それらはそれら自体で、特定の解像度またはビデオ・モードを記述しません。それをするために、あなたは構造体またはクラスのインスタンスをつくる必要があります。

The syntax for creating instances is very similar for both structures and classes:
インスタンスをつくるための構文は、構造体とクラスの両方で非常に類似しています:

  1. let someResolution = Resolution()
  2. let someVideoMode = VideoMode()

Structures and classes both use initializer syntax for new instances. The simplest form of initializer syntax uses the type name of the class or structure followed by empty parentheses, such as Resolution() or VideoMode(). This creates a new instance of the class or structure, with any properties initialized to their default values. Class and structure initialization is described in more detail in Initialization.
構造体とクラスは両方とも、新しいインスタンスのためにイニシャライザ構文を使います。イニシャライザ構文の最も単純な形式は、クラスまたは構造体の型名を使用して、それに空の丸括弧を続けます、例えばResolution()またはVideoMode()のように。これは、クラスまたは構造体の新しいインスタンスをつくり、どんなプロパティでもそれらの省略時の値に初期化されます。クラスと構造体の初期化は、更に詳細に初期化で記述されます。

Accessing Properties
プロパティにアクセスする

You can access the properties of an instance using dot syntax. In dot syntax, you write the property name immediately after the instance name, separated by a period (.), without any spaces:
あなたは、ドット構文を使ってインスタンスのプロパティにアクセスすることができます。ドット構文において、あなたはプロパティ名をインスタンス名の直後に、終止符(.)で区切り、どんな空白もなしで、書きます:

  1. print("The width of someResolution is \(someResolution.width)")
  2. // Prints "The width of someResolution is 0" (「someResolutionの幅は0です」を出力します)

In this example, someResolution.width refers to the width property of someResolution, and returns its default initial value of 0.
この例では、someResolution.widthsomeResolutionwidthプロパティに言及して、その省略時の初期値の0を返します。

You can drill down into sub-properties, such as the width property in the resolution property of a VideoMode:
あなたは、下位プロパティへと掘り下っていくことができます、例えば、あるVideoModeresolutionプロパティの中のwidthプロパティ:

  1. print("The width of someVideoMode is \(someVideoMode.resolution.width)")
  2. // Prints "The width of someVideoMode is 0" (「someVideoModeの幅は0です」を出力します)

You can also use dot syntax to assign a new value to a variable property:
あなたは、また、新しい値を変数プロパティに代入するためにドット構文を使うことができます:

  1. someVideoMode.resolution.width = 1280
  2. print("The width of someVideoMode is now \(someVideoMode.resolution.width)")
  3. // Prints "The width of someVideoMode is now 1280" (「someVideoModeの幅は、現在は1280です」を出力します)

Memberwise Initializers for Structure Types
構造体型のためのメンバー関連イニシャライザ

All structures have an automatically-generated memberwise initializer, which you can use to initialize the member properties of new structure instances. Initial values for the properties of the new instance can be passed to the memberwise initializer by name:
全ての構造体は自動的に生成されるメンバー関連イニシャライザを持ちます、それはあなたが新しい構造体インスタンスのメンバープロパティを初期化するために使うことが可能です。新しいインスタンスのプロパティのための最初の値は、名前によってメンバー関連イニシャライザに渡されることができます:

  1. let vga = Resolution(width: 640, height: 480)

Unlike structures, class instances do not receive a default memberwise initializer. Initializers are described in more detail in Initialization.
構造体と違って、クラスインスタンスは、自動生成のメンバー関連イニシャライザを授けられません。イニシャライザは、更に詳細に初期化で記述されます。

Structures and Enumerations Are Value Types
構造体と列挙は値型です

A value type is a type whose value is copied when it is assigned to a variable or constant, or when it is passed to a function.
値型は、それが変数または定数に代入される時に、あるいは、それが関数に渡されるときに、値がコピーされる型です。

You’ve actually been using value types extensively throughout the previous chapters. In fact, all of the basic types in Swift—integers, floating-point numbers, Booleans, strings, arrays and dictionaries—are value types, and are implemented as structures behind the scenes.
あなたは、実際に前の章を通して広く値型を使っていました。実際、スウィフトにおける基本の型の全て ― 整数、浮動小数点数、ブール、文字列、配列および辞書 ― は、値型であり、そして舞台裏では構造体として実装されます。

All structures and enumerations are value types in Swift. This means that any structure and enumeration instances you create—and any value types they have as properties—are always copied when they are passed around in your code.
全ての構造体と列挙は、スウィフトでは値型です。これは、あなたがつくるあらゆる構造体や列挙のインスタンス ― そして、それらがプロパティとして持つあらゆる値型 ― は、あなたのコードの中であちこち渡される時に常にコピーされることを意味します。

Consider this example, which uses the Resolution structure from the previous example:
この例を考慮してください、それは、前の例からResolution構造体を使用します:

  1. let hd = Resolution(width: 1920, height: 1080)
  2. var cinema = hd

This example declares a constant called hd and sets it to a Resolution instance initialized with the width and height of full HD video (1920 pixels wide by 1080 pixels high).
この例は、hdと呼ばれる定数を宣言して、それをフルHDビデオの幅と高さ(1920ピクセル幅の広さで1080ピクセルの高さがある)で初期化されるResolutionインスタンスに設定します。

It then declares a variable called cinema and sets it to the current value of hd. Because Resolution is a structure, a copy of the existing instance is made, and this new copy is assigned to cinema. Even though hd and cinema now have the same width and height, they are two completely different instances behind the scenes.
それは、それからcinemaと呼ばれる変数を宣言して、それをhdの現在の値に設定します。Resolutionが構造体であるので、既存のインスタンスのコピーが作成されます、そして、この新しいコピーはcinemaに代入されます。たとえhdcinemaが現在同じ幅と高さを持つとしても、それらは舞台裏では2つの完全に異なるインスタンスです。

Next, the width property of cinema is amended to be the width of the slightly-wider 2K standard used for digital cinema projection (2048 pixels wide and 1080 pixels high):
次に、cinemawidthプロパティは、デジタル映画館投影のために使われるわずかにより広い2Kの標準の幅(2048ピクセル幅の広さで1080ピクセルの高さがある)になるように改められます:

  1. cinema.width = 2048

Checking the width property of cinema shows that it has indeed changed to be 2048:
cinemawidthプロパティをチェックすると、2048になるように変えられたことを示します:

  1. print("cinema is now \(cinema.width) pixels wide")
  2. // Prints "cinema is now 2048 pixels wide" (「cinemaは、現在2048のピクセルの幅です」を出力します)

However, the width property of the original hd instance still has the old value of 1920:
しかし、最初のhdインスタンスのwidthプロパティは、まだ1920の古い値を持ちます:

  1. print("hd is still \(hd.width) pixels wide")
  2. // Prints "hd is still 1920 pixels wide" (「hdは、依然として1920のピクセルの幅です」を出力します)

When cinema was given the current value of hd, the values stored in hd were copied into the new cinema instance. The end result is two completely separate instances, which just happened to contain the same numeric values. Because they are separate instances, setting the width of cinema to 2048 doesn’t affect the width stored in hd.
cinemahdの現在の値を与えられたとき、hdに格納されるは新しいcinemaインスタンスにコピーされました。最終的な結果は2つの完全に別々のインスタンスです、そしてそれらは、たまたま同じ数値を含むということです。それらが別々のインスタンスであるので、cinemaの幅を2048に設定することはhdに格納される幅に影響を及ぼしません。

The same behavior applies to enumerations:
同じ挙動は、列挙にもあてはまります:

  1. enum CompassPoint {
  2. case north, south, east, west
  3. }
  4. var currentDirection = CompassPoint.west
  5. let rememberedDirection = currentDirection
  6. currentDirection = .east
  7. if rememberedDirection == .west {
  8. print("The remembered direction is still .west")
  9. }
  10. // Prints "The remembered direction is still .west" (「記憶されている方位は、依然として.westです」を出力します)

When rememberedDirection is assigned the value of currentDirection, it is actually set to a copy of that value. Changing the value of currentDirection thereafter does not affect the copy of the original value that was stored in rememberedDirection.
rememberedDirectioncurrentDirectionの値を代入されるとき、それは実際にはその値のコピーに設定されます。それ以降にcurrentDirectionの値を変えることは、本来の値のコピーに、rememberedDirectionに格納されたものに影響を及ぼしません。

Classes Are Reference Types
クラスは、参照型です

Unlike value types, reference types are not copied when they are assigned to a variable or constant, or when they are passed to a function. Rather than a copy, a reference to the same existing instance is used instead.
値型とは異なり、参照型は、それが変数や定数に代入される時に、あるいはそれが関数に渡される時に、コピーされません。コピーではなく、既存の同じインスタンスに対する参照が代わりに使われます。

Here’s an example, using the VideoMode class defined above:
上で定義されるVideoModeクラスを使用している例がここにあります:

  1. let tenEighty = VideoMode()
  2. tenEighty.resolution = hd
  3. tenEighty.interlaced = true
  4. tenEighty.name = "1080i"
  5. tenEighty.frameRate = 25.0

This example declares a new constant called tenEighty and sets it to refer to a new instance of the VideoMode class. The video mode is assigned a copy of the HD resolution of 1920 by 1080 from before. It is set to be interlaced, and is given a name of "1080i". Finally, it is set to a frame rate of 25.0 frames per second.
この例は、tenEightyと呼ばれる新しい定数を宣言して、それをVideoModeクラスの新しいインスタンスに言及するように設定します。ビデオ・モードは、以前にHD解像度1920×1080のコピーを代入されます。それは、インターレースに設定され、"1080i"の名前を与えられます。最後に、それは1秒につき25.0フレームのフレームレートに設定されます。

Next, tenEighty is assigned to a new constant, called alsoTenEighty, and the frame rate of alsoTenEighty is modified:
次に、tenEightyは、新しい定数、alsoTenEightyと呼ばれるものに代入されます、そしてalsoTenEightyのフレームレートが修正されます:

  1. let alsoTenEighty = tenEighty
  2. alsoTenEighty.frameRate = 30.0

Because classes are reference types, tenEighty and alsoTenEighty actually both refer to the same VideoMode instance. Effectively, they are just two different names for the same single instance.
クラスが参照型であるので、tenEightyalsoTenEightyは両方とも実際に同じVideoModeインスタンスに言及します。事実上、それらは同じ一つのインスタンスに対する単なる2つの異なる名前です。

Checking the frameRate property of tenEighty shows that it correctly reports the new frame rate of 30.0 from the underlying VideoMode instance:
tenEightyframeRateプロパティを調べてみると、それが根底にあるVideoModeインスタンス由来の新しいフレームレートの30.0を正しく報告することがわかります:

  1. print("The frameRate property of tenEighty is now \(tenEighty.frameRate)")
  2. // Prints "The frameRate property of tenEighty is now 30.0" (「tenEightyのframeRateプロパティは、現在は30.0です」を出力します)

Note that tenEighty and alsoTenEighty are declared as constants, rather than variables. However, you can still change tenEighty.frameRate and alsoTenEighty.frameRate because the values of the tenEighty and alsoTenEighty constants themselves do not actually change. tenEighty and alsoTenEighty themselves do not “store” the VideoMode instance—instead, they both refer to a VideoMode instance behind the scenes. It is the frameRate property of the underlying VideoMode that is changed, not the values of the constant references to that VideoMode.
tenEightyalsoTenEightyが、変数ではなく、定数として宣言される点に注意してください。しかし、あなたはそれでもなおtenEighty.frameRatealsoTenEighty.frameRateを変更することができます、なぜならtenEightyおよびalsoTenEighty定数それら自身の値は実のところ変わらないからです。tenEightyおよびalsoTenEightyそれら自身はVideoModeインスタンスを格納しません ― そうではなく、それらは両方とも舞台裏であるVideoModeインスタンスに言及します。それは、根底にあるVideoModeの変更可能なframeRateプロパティです、そのVideoModeに対する参照をもつこれら定数の値ではありません。

Identity Operators
同一性演算子

Because classes are reference types, it is possible for multiple constants and variables to refer to the same single instance of a class behind the scenes. (The same is not true for structures and enumerations, because they are always copied when they are assigned to a constant or variable, or passed to a function.)
クラスが参照型であるので、複数の定数と変数があるクラスの同じ一つのインスタンスに言及することが舞台裏で可能です。(同じことは構造体と列挙にあてはまりません、なぜなら、それらが値型であって、それらが定数または変数に代入されるか関数に渡される時に、常にコピーされるからです)。

It can sometimes be useful to find out if two constants or variables refer to exactly the same instance of a class. To enable this, Swift provides two identity operators:
2つの定数または変数が正確にあるクラスの同じインスタンスに言及するかどうかについて、知ることは時々役に立つことがありえます。これを可能にするために、スウィフトは2つの同一性演算子を提供します:

  • Identical to (===)
    同一である(===

  • Not identical to (!==)
    同一でない(!==

Use these operators to check whether two constants or variables refer to the same single instance:
2つの定数または変数が同じ一つのインスタンスに言及するかどうか調べるためにこれらの演算子を使用してください:

  1. if tenEighty === alsoTenEighty {
  2. print("tenEighty and alsoTenEighty refer to the same VideoMode instance.")
  3. }
  4. // Prints "tenEighty and alsoTenEighty refer to the same VideoMode instance." (「tenEightyとalsoTenEightyは、同じVideoModeインスタンスに言及します。」を出力します)

Note that “identical to” (represented by three equals signs, or ===) does not mean the same thing as “equal to” (represented by two equals signs, or ==):
「同一である」(3つの等号、つまり===によって表されるもの)は「同等である」(2つの等号、つまり==によって表されるもの)と同じことを意味しないことに注意してください:

  • “Identical to” means that two constants or variables of class type refer to exactly the same class instance.
    「同一」は、クラス型の2つの定数または変数が、正確に同じクラスインスタンスに言及することを意味します。

  • “Equal to” means that two instances are considered “equal” or “equivalent” in value, for some appropriate meaning of “equal”, as defined by the type’s designer.
    「同等」は、2つのインスタンスが、値で「等しい」あるいは「相当する」と、ある適切な「等しい」の意味で、型の設計者によって定義されたとおりに、考慮されることを意味します。

When you define your own custom classes and structures, it is your responsibility to decide what qualifies as two instances being “equal”. The process of defining your own implementations of the “equal to” and “not equal to” operators is described in Equivalence Operators.
あなたが独自の特注のクラスと構造体を定義するとき、2つのインスタンスが「等しい」とする基準は何かを決めるのはなたの責任です。「同等」および「不等」演算子のあなた独自の実施を定義する過程は、同等演算子で記述されます。

Pointers
ポインター

If you have experience with C, C++, or Objective-C, you may know that these languages use pointers to refer to addresses in memory. A Swift constant or variable that refers to an instance of some reference type is similar to a pointer in C, but is not a direct pointer to an address in memory, and does not require you to write an asterisk (*) to indicate that you are creating a reference. Instead, these references are defined like any other constant or variable in Swift.
あなたがC、C++、またはObjective-Cで経験を持つならば、あなたはこれらの言語がメモリのアドレスに言及するためにポインターを使用するということを知っているかもしれません。ある参照型のインスタンスに言及するスウィフト定数または変数はCの中のポインターに似ています、しかしメモリ中のアドレスへの直接のポインターでなくて、あなたに参照をつくっていることを示すために星印(*)を書くことを要求しません。その代わりに、これらの参照は、スウィフトにおけるあらゆる他の定数または変数と同じように定義されます。

Choosing Between Classes and Structures
クラスと構造体のどちらかを選ぶ

You can use both classes and structures to define custom data types to use as the building blocks of your program’s code.
あなたは、あなたのプログラムのコードの建築ブロックとして使う特別あつらえのデータ型を定義するために、クラスと構造体のどちらでも使用することができます。

However, structure instances are always passed by value, and class instances are always passed by reference. This means that they are suited to different kinds of tasks. As you consider the data constructs and functionality that you need for a project, decide whether each data construct should be defined as a class or as a structure.
しかし、構造体インスタンスは常にによって渡されます、そして、クラスインスタンスは常に参照によって渡されます。これは、それらが異なる種類の作業に適していることを意味します。あなたがプロジェクトのために必要とするデータ構造と機能性を考慮するので、各データ構造物がクラスとしてまたは構造体として定義されなければならないか決めてください。

As a general guideline, consider creating a structure when one or more of these conditions apply:
一般的な指針として、これらの状況のうちの1つ以上があてはまるとき、構造体を作成することを考えてください:

  • The structure’s primary purpose is to encapsulate a few relatively simple data values.
    その構造体の主要な目的は、比較的単純な2、3のデータ値をカプセル化することである。

  • It is reasonable to expect that the encapsulated values will be copied rather than referenced when you assign or pass around an instance of that structure.
    あなたがその構造体のインスタンスをあちこち代入したり、渡したりするとき、カプセル化された値が参照をつけられるのではなくコピーされるのが当然だと思うことが道筋が立っている。

  • Any properties stored by the structure are themselves value types, which would also be expected to be copied rather than referenced.
    構造体で格納されるどんなプロパティでもそれら自身値型であり、それはまた参照をつけられるのではなくコピーされることを期待される。

  • The structure does not need to inherit properties or behavior from another existing type.
    その構造体が、既存の別の型からプロパティまたは挙動を受け継ぐ必要がない。

Examples of good candidates for structures include:
構造体の良い候補者の例には、次のようなものがあります:

  • The size of a geometric shape, perhaps encapsulating a width property and a height property, both of type Double.
    幾何学図形のサイズ、おそらくはwidthプロパティとheightプロパティ(両方ともDouble型)をカプセル化する。

  • A way to refer to ranges within a series, perhaps encapsulating a start property and a length property, both of type Int.
    ある連続の中に納まるいくつかの範囲を参照する一つの方法、おそらくはstartプロパティとlengthプロパティ(両方とも型Int)をカプセル化する。

  • A point in a 3D coordinate system, perhaps encapsulating x, y and z properties, each of type Double.
    3D座標系でのポイント、おそらくはxy、そしてzプロパティ(各々Double型)をカプセル化する。

In all other cases, define a class, and create instances of that class to be managed and passed by reference. In practice, this means that most custom data constructs should be classes, not structures.
全ての他の場合には、クラスを定義してください、そしてそのクラスのインスタンスをつくって、参照で管理されて渡されるようにしてください。実際問題として、これは、ほとんどのあつらえのデータ構造はクラスでなければならないことを意味します、構造体ではなく。

Assignment and Copy Behavior for Strings, Arrays, and Dictionaries
文字列、配列、そして辞書のための代入とコピー挙動

In Swift, many basic data types such as String, Array, and Dictionary are implemented as structures. This means that data such as strings, arrays, and dictionaries are copied when they are assigned to a new constant or variable, or when they are passed to a function or method.
スウィフトでは、多くの基本的なデータ型、StringArray、およびDictionaryなどが、構造体として実装されます。これは、文字列、配列、および辞書などのデータが、それらが新しい定数や変数に代入される時に、またはそれらが関数やメソッドに渡される時に、コピーされることを意味します。

This behavior is different from Foundation: NSString, NSArray, and NSDictionary are implemented as classes, not structures. Strings, arrays, and dictionaries in Foundation are always assigned and passed around as a reference to an existing instance, rather than as a copy.
この挙動は、Foundationとは異なります:NSStringNSArray、そしてNSDictionaryは、構造体ではなくクラスとして実装されます。Foundationでの文字列、配列、そして辞書は、常にコピーとしてでなく既存のインスタンスへの参照として代入されてあちこちに渡されます。