Advanced Operators¶ 先進の演算子¶

Bitwise Operators¶ ビット単位演算子¶

Bitwise operators enable you to manipulate the individual raw data bits within a data structure. They’re often used in low-level programming, such as graphics programming and device driver creation. Bitwise operators can also be useful when you work with raw data from external sources, such as encoding and decoding data for communication over a custom protocol. ビット単位演算子は、あなたにあるデータ構造内の個々の生のデータ・ビットを操作することを可能にします。それらが、低階層のプログラミング、例えばグラフィックス・プログラミングやデバイスドライバー作成において、しばしば使われます。ビット単位演算子はまた、あなたが外部のソースからの生のデータを扱うとき、役に立つことがありえます、例えば、あつらえのプロトコルを越えて通信するためのデータの符号化や復号など。

Swift supports all of the bitwise operators found in C, as described below. スウィフトは、下記のように、Cで見つけられるビット単位演算子の全てをサポートします。

Bitwise NOT Operator¶ ビット単位の論理否定演算子¶

The bitwise NOT operator (~) inverts all bits in a number: ビット単位の論理否定演算子（~）は、ある数の中の全てのビットを逆にします：

The bitwise NOT operator is a prefix operator, and appears immediately before the value it operates on, without any white space: ビット単位の論理否定演算子は、接頭辞演算子で、少しの空白なしで、それが作用する値の直前に現れまます：

1. let initialBits: UInt8 = 0b00001111
2. let invertedBits = ~initialBits // equals 11110000（11110000に等しい）

UInt8 integers have eight bits and can store any value between 0 and 255. This example initializes a UInt8 integer with the binary value 00001111, which has its first four bits set to 0, and its second four bits set to 1. This is equivalent to a decimal value of 15. UInt8整数は、８ビットを持ち、0と255の間でのどんな値でも格納することができます。この例は、UInt8整数を２進数の値00001111で初期化します、それは、その最初の４つのビットを0に設定して、次の４つのビットを1に設定します。これは、10進の値の15に等しいです。

The bitwise NOT operator is then used to create a new constant called invertedBits, which is equal to initialBits, but with all of the bits inverted. Zeros become ones, and ones become zeros. The value of invertedBits is 11110000, which is equal to an unsigned decimal value of 240. ビット単位の論理否定演算子は、それからinvertedBitsと呼ばれる新しい定数をつくるために使われます、それは、initialBitsと等しいです、しかし全てのビットは逆にされます。ゼロは１になります、そして１はゼロになります。invertedBitsの値は11110000です、それは、符号なし10進の値の240と等しいです。

Bitwise AND Operator¶ ビット単位の論理積演算子¶

The bitwise AND operator (&) combines the bits of two numbers. It returns a new number whose bits are set to 1 only if the bits were equal to 1 in both input numbers: ビット単位の論理積演算子（&）は、２つの数のビットを結合します。それはある新しい数を返します、それのビットは両方の入力数においてビットが1と等しかった場合にだけ1に設定されます：

In the example below, the values of firstSixBits and lastSixBits both have four middle bits equal to 1. The bitwise AND operator combines them to make the number 00111100, which is equal to an unsigned decimal value of 60: 下記の例で、firstSixBitsとlastSixBitsの値は、1と等しい４つの中間のビットを両方とも持ちます。ビット単位の論理積演算子は、それらを結合して、数00111100をつくります、それは、符号なしの10進数の60と等しいです：

1. let firstSixBits: UInt8 = 0b11111100
2. let lastSixBits: UInt8 = 0b00111111
3. let middleFourBits = firstSixBits & lastSixBits // equals 00111100（00111100に等しい）

Bitwise OR Operator¶ ビット単位の論理和演算子¶

The bitwise OR operator (|) compares the bits of two numbers. The operator returns a new number whose bits are set to 1 if the bits are equal to 1 in either input number: ビット単位の論理和演算子（|）は、２つの数のビットを比較します。この演算子は、どちらかの入力数においてビットが1と等しいならばビットが1に設定される、ある新しい数を返します：

In the example below, the values of someBits and moreBits have different bits set to 1. The bitwise OR operator combines them to make the number 11111110, which equals an unsigned decimal of 254: 下記の例で、someBitsとmoreBitsの値は、1に設定される異なるビットを持ちます。ビット単位の論理和演算子は、それらを結合して、数11111110を作ります、それは、符号なしの10進数の254と等しいです：

1. let someBits: UInt8 = 0b10110010
2. let moreBits: UInt8 = 0b01011110
3. let combinedbits = someBits | moreBits // equals 11111110（11111110に等しい）

Bitwise XOR Operator¶ ビット単位の排他的論理和演算子¶

The bitwise XOR operator, or “exclusive OR operator” (^), compares the bits of two numbers. The operator returns a new number whose bits are set to 1 where the input bits are different and are set to 0 where the input bits are the same: ビット単位の排他的論理和（XOR）演算子、あるいは「排他的論理和演算子」（^）は、２つの数のビットを比較します。この演算子は、入力ビットそれらが異なっている所で1に設定され、入力ビットそれらが同じである所で0に設定される、ある新しい数を返します：

In the example below, the values of firstBits and otherBits each have a bit set to 1 in a location that the other does not. The bitwise XOR operator sets both of these bits to 1 in its output value. All of the other bits in firstBits and otherBits match and are set to 0 in the output value: 下記の例で、firstBitsとotherBitsそれぞれの値は、他のものがそうでない場所で、ビットを1に設定されます。ビット単位の排他的論理和演算子は、これらのビットの両方ともその出力値において1に設定します。firstBitsとotherBitsでの他の全てのビットは一致していて、出力値において0に設定されます：

1. let firstBits: UInt8 = 0b00010100
2. let otherBits: UInt8 = 0b00000101
3. let outputBits = firstBits ^ otherBits // equals 00010001（00010001に等しい）

Bitwise Left and Right Shift Operators¶ ビット単位の左および右シフト演算子¶

The bitwise left shift operator (<<) and bitwise right shift operator (>>) move all bits in a number to the left or the right by a certain number of places, according to the rules defined below. ビット単位の左シフト演算子（<<）とビット単位の右シフト演算子（>>）は、下で定義される規則に従ってある数の中の全てのビットを左または右に特定の桁数だけ移動します（シフト：移す、ずらす）。

Bitwise left and right shifts have the effect of multiplying or dividing an integer by a factor of two. Shifting an integer’s bits to the left by one position doubles its value, whereas shifting it to the right by one position halves its value. ビット単位の左または右シフトは、２の因数によって、ある整数を掛けるまたは割る効果を持ちます。整数のビットを位置１つだけ左へ移すことはその値を２倍にします、一方それを位置１つだけ右へ移すことはその値を半分にします。

Shifting Behavior for Unsigned Integers¶ 符号なし整数のためのシフト挙動¶

The bit-shifting behavior for unsigned integers is as follows: 符号なし整数のためのビットシフト挙動は、次の通りです：

1. Existing bits are moved to the left or right by the requested number of places. 既存のビットは、左または右へ要請された桁数だけ動かされます。
2. Any bits that are moved beyond the bounds of the integer’s storage are discarded. 整数の格納量の境界を越えて動かされるあらゆるビットは、捨てられます。
3. Zeros are inserted in the spaces left behind after the original bits are moved to the left or right. 元のビットが左または右へ移動した後に残される空きに、ゼロが差し込まれます。

This approach is known as a logical shift. このやり方は、論理シフトとして知られています。

The illustration below shows the results of 11111111 << 1 (which is 11111111 shifted to the left by 1 place), and 11111111 >> 1 (which is 11111111 shifted to the right by 1 place). Blue numbers are shifted, gray numbers are discarded, and orange zeros are inserted: 下のイラストは、11111111 << 1（それは、1桁だけ左へシフトされる11111111です）、そして11111111 >> 1（それは、1桁だけ右へシフトされる11111111です）の結果を示します。青色の数はシフトされます、灰色の数は捨てられます、そしてオレンジ色のゼロが差し込まれます：

Here’s how bit shifting looks in Swift code: ビットシフトがスウィフトコードにおいてどのように見えるかは、ここにあります：

1. let shiftBits: UInt8 = 4 // 00000100 in binary（２進数での00000100）
2. shiftBits << 1 // 00001000
3. shiftBits << 2 // 00010000
4. shiftBits << 5 // 10000000
5. shiftBits << 6 // 00000000
6. shiftBits >> 2 // 00000001

You can use bit shifting to encode and decode values within other data types: あなたは、他のデータ型内の値を符号化したり復号するために、ビットシフトを使うことができます：

1. let pink: UInt32 = 0xCC6699
2. let redComponent = (pink & 0xFF0000) >> 16 // redComponent is 0xCC, or 204（redComponent は 0xCC または 204 です）
3. let greenComponent = (pink & 0x00FF00) >> 8 // greenComponent is 0x66, or 102（greenComponent は 0x66 または 102 です）
4. let blueComponent = pink & 0x0000FF // blueComponent is 0x99, or 153（blueComponent は 0x99 または 153 です）

This example uses a UInt32 constant called pink to store a Cascading Style Sheets color value for the color pink. The CSS color value #CC6699 is written as 0xCC6699 in Swift’s hexadecimal number representation. This color is then decomposed into its red (CC), green (66), and blue (99) components by the bitwise AND operator (&) and the bitwise right shift operator (>>). この例は、ピンク色のカスケーディング・スタイル・シートの色値を保存するために、pinkと呼ばれるUInt32定数を使います。CSS色値#CC6699は、スウィフトの16進数表現では0xCC6699のように書かれます。この色はそれから、ビット単位の論理積演算子（&）とビット単位の右シフト演算子（>>）によって、それの赤（CC）、緑（66）、そして青（99）の構成要素に分解されます。

The red component is obtained by performing a bitwise AND between the numbers 0xCC6699 and 0xFF0000. The zeros in 0xFF0000 effectively “mask” the second and third bytes of 0xCC6699, causing the 6699 to be ignored and leaving 0xCC0000 as the result. 赤の構成要素は、数0xCC6699と0xFF0000との間のビット単位の論理積を実行することによって得られます。0xFF0000のゼロは、0xCC6699の２番目と３番目のバイトを効果的に「マスク」します（隠して消します）、そして6699が無視されるようになって、結果として0xCC0000が残ります。

This number is then shifted 16 places to the right (>> 16). Each pair of characters in a hexadecimal number uses 8 bits, so a move 16 places to the right will convert 0xCC0000 into 0x0000CC. This is the same as 0xCC, which has a decimal value of 204. この数は、それから右に16桁シフトされます（>> 16）。16進数の中の文字の各ペアは８ビットを使うので、右への16桁の移動は0xCC0000を0x0000CCへと変えます。これは0xCCと同じものです、それは、10進の値の204を持ちます。

Similarly, the green component is obtained by performing a bitwise AND between the numbers 0xCC6699 and 0x00FF00, which gives an output value of 0x006600. This output value is then shifted eight places to the right, giving a value of 0x66, which has a decimal value of 102. 同じように、緑の構成要素は数0xCC6699と0x00FF00との間のビット単位の論理積を実行することによって得られます、それは、0x006600の出力値を与えます。この出力値は、それから８桁右にシフトされて、0x66の値を与えます、それは10進の値の102を持ちます。

Finally, the blue component is obtained by performing a bitwise AND between the numbers 0xCC6699 and 0x0000FF, which gives an output value of 0x000099. Because 0x000099 already equals 0x99, which has a decimal value of 153, this value is used without shifting it to the right, 最後に、青の構成要素は数0xCC6699と0x0000FFとの間のビット単位の論理積を実行することによって得られます、それは、0x000099の出力値を与えます。0x000099はもう既に0x99と等しいので、それは10進数の153を持ちます、この値はそれを右へとシフトすることなく使用されます。

Shifting Behavior for Signed Integers¶ 符号つき整数のためのシフト挙動¶

The shifting behavior is more complex for signed integers than for unsigned integers, because of the way signed integers are represented in binary. (The examples below are based on 8-bit signed integers for simplicity, but the same principles apply for signed integers of any size.) シフト挙動は、符号つき整数では符号なし整数よりももっと複雑です、なぜなら、符号つき整数が２進数において表される方法のためです。（下の例は、単純さのために8ビット符号つき整数に基づきます、しかし同じ原理はあらゆるサイズの符号つき整数に当てはまります）。

Signed integers use their first bit (known as the sign bit) to indicate whether the integer is positive or negative. A sign bit of 0 means positive, and a sign bit of 1 means negative. 符号つき整数は、それらの最初のビット（符号ビットとして知られるもの）を使って、その整数が正であるか負であるかを示します。0の符号ビットは正を意味します、そして、1の符号ビットは負であることを意味します。

The remaining bits (known as the value bits) store the actual value. Positive numbers are stored in exactly the same way as for unsigned integers, counting upwards from 0. Here’s how the bits inside an Int8 look for the number 4: 残っているビット（値ビットとして知られるもの）は、実際の値を格納します。正の数は符号なし整数と正確に同じ方法で格納されて、0から上方へ数えます。Int8内のビットが数4に対してどのように見えるかは、ここにあります：

The sign bit is 0 (meaning “positive”), and the seven value bits are just the number 4, written in binary notation. 符号ビットは0です（「正」を意味します）、そして７つの値ビットはちょうど、２進数表記法で書かれる数4です。

Negative numbers, however, are stored differently. They’re stored by subtracting their absolute value from 2 to the power of n, where n is the number of value bits. An eight-bit number has seven value bits, so this means 2 to the power of 7, or 128. 負の数は、しかし異なって格納されます。それらは、2のn乗からそれらの絶対値を減ずることによって格納されます、そこで、nは値ビットの数です。８ビットの数は７つの値ビットを持ちますので、これは2の7乗、つまり128を意味します。

Here’s how the bits inside an Int8 look for the number -4: Int8内のビットが数-4に対してどのように見えるかは、ここにあります：

This time, the sign bit is 1 (meaning “negative”), and the seven value bits have a binary value of 124 (which is 128 - 4): 今度は、符号ビットは1です（「負」を意味します）、そして、７つの値ビットは２進数の値の124を持ちます（それは、128 - 4です）：

This encoding for negative numbers is known as a two’s complement representation. It may seem an unusual way to represent negative numbers, but it has several advantages. この負数のための符号化は、２の補数表現として知られています。それは負数を表す普通でない方法のようかもしれません、しかしそれはいくつかの利点を持ちます。

First, you can add -1 to -4, simply by performing a standard binary addition of all eight bits (including the sign bit), and discarding anything that doesn’t fit in the eight bits once you’re done: 第１に、あなたは-1を-4に加えることが、単純に８つのビット全て（符号ビットを含む）の通常のバイナリの加算を実行して、あなたがそうしたならばその８ビットに収まらない何でも捨てることによって行えます：

Second, the two’s complement representation also lets you shift the bits of negative numbers to the left and right like positive numbers, and still end up doubling them for every shift you make to the left, or halving them for every shift you make to the right. To achieve this, an extra rule is used when signed integers are shifted to the right: When you shift signed integers to the right, apply the same rules as for unsigned integers, but fill any empty bits on the left with the sign bit, rather than with a zero. 第２に、２の補数表現はまた、あなたに負数のビットを左や右に正の数のようにシフトさせます、そして依然としてあなたが左へとするシフトは全てそれを２倍にすることで、またあなたが右へとするシフトは全てそれを半分にすることで終わります。これを達成するために、符号つき整数が右へシフトされるとき、特別な規則が使われます：あなたが符号つき整数を右にシフトする時は、符号なし整数と同じ規則を適用してください、しかし、その左のあらゆる空のビットを、ゼロではなく符号ビットで満たしてください。

This action ensures that signed integers have the same sign after they’re shifted to the right, and is known as an arithmetic shift. この動作は、符号つき整数が、それが右へシフトされた後に同じサインを持つことを確実にします、そして算術シフトとして知られています。

Because of the special way that positive and negative numbers are stored, shifting either of them to the right moves them closer to zero. Keeping the sign bit the same during this shift means that negative integers remain negative as their value moves closer to zero. 正および負の数が格納される特別な方法のため、それらのどちらでも右へシフトすることは、それらをゼロの近くに動かします。このシフトの間に符号ビットを同じに保つことは、それの値がゼロの近くに動くとき、負整数が負のままであることを意味します。

Overflow Operators¶ オーバフロー演算子¶

If you try to insert a number into an integer constant or variable that can’t hold that value, by default Swift reports an error rather than allowing an invalid value to be created. This behavior gives extra safety when you work with numbers that are too large or too small. あなたがある数をその値を持つことができない整数の定数や変数の中へ入れようとするならば、初期状態では、スウィフトは無効な値がつくられるようにするのではなく、エラーを報告します。この挙動は、あまりに大きいかあまりに小さい数をあなたが扱うとき、追加の安全を与えます。

For example, the Int16 integer type can hold any signed integer between -32768 and 32767. Trying to set an Int16 constant or variable to a number outside of this range causes an error: 例えば、Int16整数型は、-32768と32767の間のどんな符号つき整数でも持つことができます。Int16定数または変数をこの範囲の外側の数に設定する試みは、エラーを引き起こします：

Providing error handling when values get too large or too small gives you much more flexibility when coding for boundary value conditions. 値があまりに大きいかあまりに小さくなる時にエラー処理を提供することは、境界値条件のためのコードを書くとき、あなたにずっと多くの柔軟性を与えます。

However, when you specifically want an overflow condition to truncate the number of available bits, you can opt in to this behavior rather than triggering an error. Swift provides three arithmetic overflow operators that opt in to the overflow behavior for integer calculations. These operators all begin with an ampersand (&): しかし、あなたがに利用できるビットの数を切り詰めるために特にオーバフロー条件を望むとき、あなたはエラーを引き起こすのではなくこの挙動を選ぶことができます。スウィフトは、整数計算のためにオーバフロー挙動を選択する３つの算術オーバフロー演算子を提供します。これらの演算子は、全てアンパサンド（&）で始まります：

• Overflow addition (&+) オーバフロー加算（&+）
• Overflow subtraction (&-) オーバフロー減算（&-）
• Overflow multiplication (&*) オーバフロー乗算（&*）

Value Overflow¶ 値オーバフロー¶

Numbers can overflow in both the positive and negative direction. 数は正と負の向きの両方においてオーバフローすることができます。

Here’s an example of what happens when an unsigned integer is allowed to overflow in the positive direction, using the overflow addition operator (&+): ここに、オーバフロー加算演算子（&+）を使用して、正の向きにおいて符号なし整数がオーバフローを許されるとき何が起こるかの例があります：

1. var unsignedOverflow = UInt8.max
2. // unsignedOverflow equals 255, which is the maximum value a UInt8 can hold（unsignedOverflowは255に等しく、それはUInt８が持つことができる最大限の値です）
3. unsignedOverflow = unsignedOverflow &+ 1
4. // unsignedOverflow is now equal to 0（unsignedOverflowは、現在0と等しいです）

The variable unsignedOverflow is initialized with the maximum value a UInt8 can hold (255, or 11111111 in binary). It’s then incremented by 1 using the overflow addition operator (&+). This pushes its binary representation just over the size that a UInt8 can hold, causing it to overflow beyond its bounds, as shown in the diagram below. The value that remains within the bounds of the UInt8 after the overflow addition is 00000000, or zero. 変数unsignedOverflowは、UInt8が持つことができる最大限の値で初期化されます（255、または２進数での11111111）。それは、それからオーバフロー加算演算子（&+）を使って1だけ増やされます。これは、そのバイナリの表現をちょうどUInt8が持つことができる大きさ以上に押し広げて、それを、下の図で示すように、その境界を越えてあふれさせます。オーバフロー加算の後でUInt8の領域内に残る値は、00000000、またはゼロです。

Something similar happens when an unsigned integer is allowed to overflow in the negative direction. Here’s an example using the overflow subtraction operator (&-): 符号なし整数が負の向きにおいてオーバフローを認められるときに同じようなことが起こります。ここにオーバフロー減算演算子（&-）を使った例があります：

1. var unsignedOverflow = UInt8.min
2. // unsignedOverflow equals 0, which is the minimum value a UInt8 can hold（unsignedOverflowは0と等しく、それはUInt8が持つことができる最小限の値です）
3. unsignedOverflow = unsignedOverflow &- 1
4. // unsignedOverflow is now equal to 255（unsignedOverflowは、現在255と等しいです）

The minimum value that a UInt8 can hold is zero, or 00000000 in binary. If you subtract 1 from 00000000 using the overflow subtraction operator (&-), the number will overflow and wrap around to 11111111, or 255 in decimal. UInt8が持つことができる最小限の値は、０、または２進数では00000000です。あなたがオーバフロー減算演算子（&-）を使用して00000000から1を減ずるならば、その数はあふれ出てぐるっと送り込まれて11111111、10進での255になります。

Overflow also occurs for signed integers. All addition and subtraction for signed integers is performed in bitwise fashion, with the sign bit included as part of the numbers being added or subtracted, as described in Bitwise Left and Right Shift Operators. オーバフローはまた、符号つき整数に対しても起こります。符号つき整数に対する全ての加算と減算は、ビット単位の左および右シフト演算子で記述されるように、加算または減算される数の一部として含めらる符号ビットとともに、ビット単位流儀で実行されます。

1. var signedOverflow = Int8.min
2. // signedOverflow equals -128, which is the minimum value an Int8 can hold（signedOverflowは-128と等しく、それはInt8が持つことができる最小限の値です）
3. signedOverflow = signedOverflow &- 1
4. // signedOverflow is now equal to 127（signedOverflowは、現在127と等しいです）

The minimum value that an Int8 can hold is -128, or 10000000 in binary. Subtracting 1 from this binary number with the overflow operator gives a binary value of 01111111, which toggles the sign bit and gives positive 127, the maximum positive value that an Int8 can hold. Int8が持つことができる最小限の数は、-128、または２進数での10000000です。この２進数からオーバフロー演算子を使って1を減ずることは、２進数の01111111を与えます、それは符号ビットを切り替えて正の127、Int8が持つことができる最大限の正の値、を与えます。

For both signed and unsigned integers, overflow in the positive direction wraps around from the maximum valid integer value back to the minimum, and overflow in the negative direction wraps around from the minimum value to the maximum. 符号つきおよび符号なし整数の両方に対して、正の方向でのオーバフローは最大限の有効な整数値から逆に最小限へとぐるっと送り込まれ、負の方向でのオーバフローは最小限の値から最大限へとぐるっと送り込まれます。

Precedence and Associativity¶ 優先順位と結合性¶

Operator precedence gives some operators higher priority than others; these operators are applied first. 演算子優先順位は、ある演算子に他のものよりも高い優先権を与えます；これらの演算子は最初に適用されます。

Operator associativity defines how operators of the same precedence are grouped together—either grouped from the left, or grouped from the right. Think of it as meaning “they associate with the expression to their left,” or “they associate with the expression to their right.” 演算子結合性は、同じ優先順位の演算子がまとめられる方法を定義します ― 左からまとめられるか右からまとめられるかのどちらか。それは「それらは、式をそれらの左と結びつける」あるいは「それらは、式をそれらの右と結びつける」を意味すると考えてください。

It’s important to consider each operator’s precedence and associativity when working out the order in which a compound expression will be calculated. For example, operator precedence explains why the following expression equals 17. 複合の式が計算される順番を解決するとき、各演算子の優先順位と結合性を考慮することは、重要です。例えば、演算子優先順位は、なぜ以下の式が17に等しいのかを説明します。

If you read strictly from left to right, you might expect the expression to be calculated as follows: あなたが厳密に左から右に読んだならば、あなたはこの式を以下のように計算されることを期待するでしょう：

• 2 plus 3 equals 5 2足す3は5に等しい
• 5 remainder 4 equals 1 5割る4の余りは1に等しい
• 1 times 5 equals 5 1掛ける5は5に等しい

However, the actual answer is 17, not 5. Higher-precedence operators are evaluated before lower-precedence ones. In Swift, as in C, the remainder operator (%) and the multiplication operator (*) have a higher precedence than the addition operator (+). As a result, they’re both evaluated before the addition is considered. しかしながら、実際の答えは17です、5ではなく。より高い優先順位の演算子は、より低い優先順位のもの前に評価されます。スウィフトでは、Cでのように、剰余演算子（%）と乗算演算子（*）は、加算演算子（+）より高い優先順位を持ちます。結果として、それらは両方とも、加算が考慮される前に評価されます。

However, remainder and multiplication have the same precedence as each other. To work out the exact evaluation order to use, you also need to consider their associativity. Remainder and multiplication both associate with the expression to their left. Think of this as adding implicit parentheses around these parts of the expression, starting from their left: しかしながら、剰余と乗算は、互いに同じ優先順位を持ちます。使用する的確な評価順序を解き明かすには、あなたはまたそれらの結合性を考慮する必要があります。剰余と乗算は、両方とも式をそれらの左と結びつけます。これを、これらの式部分のまわりに、暗黙の括弧をそれらの左から開始して加えることと考えてみてください：

(3 % 4) is 3, so this is equivalent to: (3 % 4)は3なので、これは以下に等しいです：

(3 * 5) is 15, so this is equivalent to: (3 * 5)は15なので、これは以下に等しいです：

This calculation yields the final answer of 17. この計算は、最終的な答えの17を生みます。

For information about the operators provided by the Swift standard library, including a complete list of the operator precedence groups and associativity settings, see Operator Declarations. スウィフト標準ライブラリによって提供される演算子についての情報として、演算子優先順位と結合性の設定の完全なリストを含めて、さまざまな演算子宣言を見てください。

Operator Methods¶ 演算子メソッド¶

Classes and structures can provide their own implementations of existing operators. This is known as overloading the existing operators. クラスと構造体は、既存の演算子のそれら独自の実装を提供することができます。既存の演算子のオーバーロードとしてこれは知られています。

The example below shows how to implement the arithmetic addition operator (+) for a custom structure. The arithmetic addition operator is a binary operator because it operates on two targets and it’s an infix operator because it appears between those two targets. 下の例は、あつらえの構造体のために算術加算演算子（+）を実装する方法を示します。算術加算演算子は、それが２つの目標に作用するので二項演算子です、そして、それがそれらの２つの目標の間に現れるので接中辞演算子です。

The example defines a Vector2D structure for a two-dimensional position vector (x, y), followed by a definition of an operator method to add together instances of the Vector2D structure: 例は、２次元の位置ベクトル(x, y)のためのVector2D構造体を定義します。そして、Vector2D構造体のインスタンスそれらを１つに加えるための演算子メソッドの定義が続きます：

The operator method is defined as a type method on Vector2D, with a method name that matches the operator to be overloaded (+). Because addition isn’t part of the essential behavior for a vector, the type method is defined in an extension of Vector2D rather than in the main structure declaration of Vector2D. Because the arithmetic addition operator is a binary operator, this operator method takes two input parameters of type Vector2D and returns a single output value, also of type Vector2D. この演算子メソッドは、Vector2D上で型メソッドとして定義され、オーバーロードされる演算子と一致するメソッド名を持ちます（+）。加算はベクトルの欠くことのできない挙動の部分ではないので、この型メソッドはVector2Dの拡張において定義されます、Vector2Dの主構造定義においてではなく。算術加算演算子は二項演算子なので、この演算子メソッドはVector2D型の２つの入力パラメーターを取り、同じくVector2D型のただ１つの出力値を返します。

In this implementation, the input parameters are named left and right to represent the Vector2D instances that will be on the left side and right side of the + operator. The method returns a new Vector2D instance, whose x and y properties are initialized with the sum of the x and y properties from the two Vector2D instances that are added together. この実装において、入力パラメータは、leftとrightという名前をつけられ、+演算子の左側と右側にあるVector2Dインスタンスを表します。メソッドは、新しいVector2Dインスタンスを返します、それはxとyプロパティが一緒に加えられる２つのVector2Dインスタンスからのxとyプロパティの合計で初期化されるものです。

The type method can be used as an infix operator between existing Vector2D instances: この型メソッドは既存のVector2Dインスタンスの間で接中辞演算子として使われることができます：

This example adds together the vectors (3.0, 1.0) and (2.0, 4.0) to make the vector (5.0, 5.0), as illustrated below. この例は、下で図示されるように、ベクトル(3.0, 1.0)と(2.0, 4.0)を加えて一緒にして、ベクトル(5.0, 5.0)を作ります。

Custom Operators¶ あつらえの演算子¶

You can declare and implement your own custom operators in addition to the standard operators provided by Swift. For a list of characters that can be used to define custom operators, see Operators. あなたは、スウィフトによって提供される標準の演算子に加えて、あなた独自のあつらえの演算子を宣言して実装することができます。あつらえの演算子を定義するために使用できる文字のリストとして、演算子を見てください。

New operators are declared at a global level using the operator keyword, and are marked with the prefix, infix or postfix modifiers: 新しい演算子はoperatorキーワードを使ってグローバル水準で宣言されます、そしてprefix、infixまたはpostfix修飾子で印されます：

The example above defines a new prefix operator called +++. This operator doesn’t have an existing meaning in Swift, and so it’s given its own custom meaning below in the specific context of working with Vector2D instances. For the purposes of this example, +++ is treated as a new “prefix doubling” operator. It doubles the x and y values of a Vector2D instance, by adding the vector to itself with the addition assignment operator defined earlier. To implement the +++ operator, you add a type method called +++ to Vector2D as follows: 上の例は、+++と呼ばれる新しい接頭辞演算子を定義します。この演算子は、スウィフトにおいて既存の意味を持ちません、なので、それはVector2Dインスタンスを扱う特定の文脈の下で、独自のあつらえの意味を与えられます。この例の目的のために、+++は新しい「接頭辞倍加」演算子とみなされます。それはVector2Dインスタンスのxとy値を、そのベクトルをそれ自体へと以前に定義される加算代入演算子を使って加えることによって２倍にします。+++演算子を実装するには、あなたは+++と呼ばれる型メソッドを次のようにVector2Dに加えます：

Result Builders¶ リザルトビルダー¶

A result builder is a type you define that adds syntax for creating nested data, like a list or tree, in a natural, declarative way. The code that uses the result builder can include ordinary Swift syntax, like if and for, to handle conditional or repeated pieces of data. リザルトビルダーはあなたが定義する型です、それは入れ子にされたデータ、たとえばリストやツリーなどを自然な、宣言的な方法で作成するための構文を加えます。リザルトビルダーを使うコードは、通常のスウィフト構文、たとえばifおよびforなどを含むことで、条件付きでまたは繰り返してデータの断片を取り扱えます。

The code below defines a few types for drawing on a single line using stars and text. 下のコードは、単一の行上で星とテキストを使って描画するためにいくつかの型を定義します。

The Drawable protocol defines the requirement for something that can be drawn, like a line or shape: The type must implement a draw() method. The Line structure represents a single-line drawing, and it serves the top-level container for most drawings. To draw a Line, the structure calls draw() on each of the line’s components, and then concatenates the resulting strings into a single string. The Text structure wraps a string to make it part of a drawing. The AllCaps structure wraps and modifies another drawing, converting any text in the drawing to uppercase. Drawableプロトコルは、描画されることが可能な何らかのもの、ある行または形状などに対する要件を定義します：その型はdraw()メソッドを実装しなければいけません。Line構造体は、ある単一行の描画を表します、そしてそれはほとんどの描画に対するトップレベルコンテナとして利用できます。Lineを描画するために、構造体はdraw()をその行のもつ構成要素のそれぞれで呼び出します、そしてそれから結果文字列それらを単一の文字列へと連結します。Text構造体は、文字列をラップしてそれを描画の一部とします。AllCaps構造体は、別の描画をラップおよび修正して、あらゆるテキストをその描画においてアッパーケースに変換します。

It’s possible to make a drawing with these types by calling their initializers: ある描画を３つの型でそれらのイニシャライザを呼び出すことによって作ることは可能です：

This code works, but it’s a little awkward. The deeply nested parentheses after AllCaps are hard to read. The fallback logic to use “World” when name is nil has to be done inline using the ?? operator, which would be difficult with anything more complex. If you needed to include switches or for loops to build up part of the drawing, there’s no way to do that. A result builder lets you rewrite code like this so that it looks like normal Swift code. このコードは働きます、しかしそれは少々ぎこちないものです。AllCapsの後ろで深く入れ子にされた丸括弧は読みやすいとは言えません。nameがnilの時に“World” を使う代替論理は、??演算子を使用してインラインにされる必要があり、それはより複雑なものでは難しいでしょう。あなたがスイッチ条件分岐またはforループを含めることで描画の一部を作り上げる必要があるとしても、それをする方法はありません。リザルトビルダーは、あなたにこのようなコードを、それが通常のスウィフトコードのように見えるように書き直させます。

To define a result builder, you write the @resultBuilder attribute on a type declaration. For example, this code defines a result builder called DrawingBuilder, which lets you use a declarative syntax to describe a drawing: リザルトビルダーを定義するには、あなたは@resultBuilder属性を型宣言上で書きます。例えば、このコードはDrawingBuilderと呼ばれるリザルトビルダーを定義します、それはあなたに宣言的な構文を使って描画を記述させます：

The DrawingBuilder structure defines three methods that implement parts of the result builder syntax. The buildBlock(_:) method adds support for writing a series of lines in a block of code. It combines the components in that block into a Line. The buildEither(first:) and buildEither(second:) methods add support for if-else. DrawingBuilderは３つのメソッドを定義します、それらはリザルトビルダー構文の各部分を実装します。buildBlock(_:)メソッドは、あるコードのブロックの中の一連の行を記述することに対するサポートを加えます。それは、そのブロックの中の構成要素それらをひとつのLineへと結合します。buildEither(first:)とbuildEither(second:)メソッドは、if-elseに対するサポートを加えます。

You can apply the @DrawingBuilder attribute to a function’s parameter, which turns a closure passed to the function into the value that the result builder creates from that closure. For example: あなたは、@DrawingBuilder属性を関数のもつパラメータに対して適用できます、それはその関数に渡されたクロージャを、リザルトビルダーがそのクロージャから作成する値へと変えます。例えば：

The makeGreeting(for:) function takes a name parameter and uses it to draw a personalized greeting. The draw(_:) and caps(_:) functions both take a single closure as their argument, which is marked with the @DrawingBuilder attribute. When you call those functions, you use the special syntax that DrawingBuilder defines. Swift transforms that declarative description of a drawing into a series of calls to the methods on DrawingBuilder to build up the value that’s passed as the function argument. For example, Swift transforms the call to caps(_:) in that example into code like the following: makeGreeting(for:)関数は、nameパラメータを取り、そしてそれを使って各個人向け挨拶を引き出します。draw(_:)とcaps(_:)関数は、両方ともある単一のクロージャをそれらの引数として取ります、それは@DrawingBuilder属性で印されます。あなたがそれらの関数を呼び出す場合、あなたはDrawingBuilderが定義する特別な構文を使います。スウィフトは、ある描画の宣言的な記述をDrawingBuilder上のメソッドへの一連の呼び出しに変換することで、関数引数として渡される値を作り上げます。例えば、スウィフトはその例におけるcaps(_:)呼び出しを以下のようなコードに変換します：

Swift transforms the if-else block into calls to the buildEither(first:) and buildEither(second:) methods. Although you don’t call these methods in your own code, showing the result of the transformation makes it easier to see how Swift transforms your code when you use the DrawingBuilder syntax. スウィフトは、if-elseブロックをbuildEither(first:)とbuildEither(second:)メソッドへの呼び出しへと変換します。あなたがそれらのメソッドをあなた自身のコードにおいて呼び出さないとはいえ、変換の結果を見せることは、どのようにスウィフトがあなたのコードをあなたがDrawingBuilder構文を使う時に変換するかを理解しやすくします。

To add support for writing for loops in the special drawing syntax, add a buildArray(_:) method. forループを書くサポートをこの特別な描画構文に加えるには、buildArray(_:)メソッドを加えてください。

In the code above, the for loop creates an array of drawings, and the buildArray(_:) method turns that array into a Line. 上のコードにおいて、forループは描画それらからなるある配列を作成します、そしてbuildArray(_:)メソッドはその配列をLineへと変えます。

For a complete list of how Swift transforms builder syntax into calls to the builder type’s methods, see resultBuilder. どのようにスウィフトがビルダー構文をビルダー型のもつメソッドそれらへと変換するかの完全な一覧として、resultBuilderを見てください。