SubscriptsClasses, structures, and

Subscripts
Classes, structures, and enumerations can define subscripts, which are shortcuts for
accessing the member elements of a collection, list, or sequence. You use subscripts to
set and retrieve values by index without needing separate methods for setting and
retrieval. For example, you access elements in an Array instance as someArray[index] and
elements in a Dictionary instance as someDictionary[key].
You can define multiple subscripts for a single type, and the appropriate subscript
overload to use is selected based on the type of index value you pass to the subscript.
Subscripts are not limited to a single dimension, and you can define subscripts with
multiple input parameters to suit your custom type’s needs.
Subscript Syntax
Subscripts enable you to query instances of a type by writing one or more values in
square brackets after the instance name. Their syntax is similar to both instance method
syntax and computed property syntax. You write subscript definitions with the subscript
keyword, and specify one or more input parameters and a return type, in the same way
as instance methods. Unlike instance methods, subscripts can be read-write or read-only.
This behavior is communicated by a getter and setter in the same way as for computed
properties:
subscript(index: Int) -> Int {
get {
// return an appropriate subscript value here
}
set(newValue) {
// perform a suitable setting action here
}
}
The type of newValue is the same as the return value of the subscript. As with computed
properties, you can choose not to specify the setter’s (newValue) parameter. A default
parameter called newValue is provided to your setter if you do not provide one yourself.
As with read-only computed properties, you can drop the get keyword for read-only
subscripts:
subscript(index: Int) -> Int {
// return an appropriate subscript value here
}
Here’s an example of a read-only subscript implementation, which defines a TimesTable
structure to represent an n-times-table of integers:
struct TimesTable {
let multiplier: Int
subscript(index: Int) -> Int {
return multiplier * index
}
}
let threeTimesTable = TimesTable(multiplier: 3)
println("six times three is (threeTimesTable[6])")
// prints "six times three is 18"
In this example, a new instance of TimesTable is created to represent the three-times-table.
This is indicated by passing a value of 3 to the structure’s initializer as the value to use for
the instance’s multiplier parameter.
You can query the threeTimesTable instance by calling its subscript, as shown in the call to
threeTimesTable[6]. This requests the sixth entry in the three-times-table, which returns a
value of 18, or 3 times 6.
NOTE
An n-times-table is based on a fixed mathematical rule. It is not appropriate to set
threeTimesTable[someIndex] to a new value, and so the subscript for TimesTable is defined as a read-only
subscript.
Subscript Usage
The exact meaning of “subscript” depends on the context in which it is used. Subscripts
are typically used as a shortcut for accessing the member elements in a collection, list, or
sequence. You are free to implement subscripts in the most appropriate way for your
particular class or structure’s functionality.
For example, Swift’s Dictionary type implements a subscript to set and retrieve the values
stored in a Dictionary instance. You can set a value in a dictionary by providing a key of the
dictionary’s key type within subscript braces, and assigning a value of the dictionary’s
value type to the subscript:
var numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
numberOfLegs["bird"] = 2
The example above defines a variable called numberOfLegs and initializes it with a dictionary
literal containing three key-value pairs. The type of the numberOfLegs dictionary is inferred
to be Dictionary. After creating the dictionary, this example uses subscript
assignment to add a String key of "bird" and an Int value of 2 to the dictionary.
For more information about Dictionary subscripting, see Accessing and Modifying a
Dictionary.
NOTE
Swift’s Dictionary type implements its key-value subscripting as a subscript that takes and receives an optional
type. For the numberOfLegs dictionary above, the key-value subscript takes and returns a value of type Int?,
or “optional int”. The Dictionary type uses an optional subscript type to model the fact that not every key will
have a value, and to give a way to delete a value for a key by assigning a nil value for that key.
Subscript Options
Subscripts can take any number of input parameters, and these input parameters can be
of any type. Subscripts can also return any type. Subscripts can use variable parameters
and variadic parameters, but cannot use in-out parameters or provide default parameter
values.
A class or structure can provide as many subscript implementations as it needs, and the
appropriate subscript to be used will be inferred based on the types of the value or values
that are contained within the subscript braces at the point that the subscript is used. This
definition of multiple subscripts is known as subscript overloading.
While it is most common for a subscript to take a single parameter, you can also define a
subscript with multiple parameters if it is appropriate for your type. The following
example defines a Matrix structure, which represents a two-dimensional matrix of Double
values. The Matrix structure’s subscript takes two integer parameters:
struct Matrix {
let rows: Int, columns: Int
var grid: Double[]
init(rows: Int, columns: Int) {
self.rows = rows
self.columns = columns
grid = Array(count: rows * columns, repeatedValue: 0.0)
}
func indexIsValidForRow(row: Int, column: Int) -> Bool {
return row >= 0 && row < rows && column >= 0 && column < columns
ubscript(row: Int, column: Int) -> Double {
get {
assert(indexIsValidForRow(row, column: column), "Index out of range")
return grid[(row * columns) + column]
}
set {
assert(indexIsValidForRow(row, column: column), "Index out of range")
grid[(row * columns) + column] = newValue
}
Matrix provides an initializer that takes two parameters called rows and columns, and creates
an array that is large enough to store rows * columns values of type Double. Each position in
the matrix is given an initial value of 0.0. To achieve this, the array’s size, and an initial
cell value of 0.0, are passed to an array initializer that creates and initializes a new array
of the correct size. This initializer is described in more detail in Creating and Initializing
an Array.
You can construct a new Matrix instance by passing an appropriate row and column count
to its initializer:
var matrix = Matrix(rows: 2, columns: 2)
The preceding example creates a new Matrix instance with two rows and two columns. The
grid array for this Matrix instance is effectively a flattened version of the matrix, as read
from top left to bottom right:
Values in the matrix can be set by passing row and column values into the subscript,
separated by a comma:
matrix[0, 1] = 1.5
matrix[1, 0] = 3.2
These two statements call the subscript’s setter to set a value of 1.5 in the top right
position of the matrix (where row is 0 and column is 1), and 3.2 in the bottom left position
(where row is 1 and column is 0):
The Matrix subscript’s getter and setter both contain an assertion to check that the
subscript’s row and column values are valid. To assist with these assertions, Matrix includes a
convenience method called indexIsValid, which checks whether the requested row or column is
outside the bounds of the matrix:
func indexIsValidForRow(row: Int, column: Int) -> Bool {
return row >= 0 && row < rows && column >= 0 && column < columns
}
An assertion is triggered if you try to access a subscript that is outside of the matrix
bounds:
let someValue = matrix[2, 2]
// this triggers an assert, because [2, 2] is outside of the matrix bounds

ผลลัพธ์ (ไทย) 1:

ตัวห้อยเรียน โครงสร้าง และระบุหมายเลขที่สามารถกำหนดตัวห้อย ซึ่งเป็นทางลัดสำหรับเข้าถึงองค์ประกอบหนึ่งของคอลเลกชัน รายการ หรือลำดับ คุณใช้ตัวห้อยไปตั้งค่า และเรียกค่าดัชนีโดยไม่จำเป็นวิธีการแยกต่างหากสำหรับการตั้งค่า และเรียก ตัวอย่าง คุณเข้าถึงองค์ประกอบในอินสแตนซ์เรย์เป็น someArray [ดัชนี] และองค์ประกอบในพจนานุกรมตัวอย่างเป็น someDictionary [คีย์]คุณสามารถกำหนดตัวห้อยหลายชนิดเดียว และตัวห้อยที่เหมาะสมโอเวอร์โหลดจะใช้ไว้ตามชนิดของค่าดัชนีที่คุณส่งไปตัวห้อยตัวห้อยไม่จำกัดขนาดเดียว และคุณสามารถกำหนดตัวห้อยด้วยหลายพารามิเตอร์ป้อนเข้าเพื่อให้เหมาะกับความต้องการของชนิดของคุณเองไวยากรณ์ตัวห้อยตัวห้อยช่วยให้คุณสามารถสอบถามการอินสแตนซ์ของชนิด โดยการเขียนอย่าง น้อยหนึ่งค่าในวงเล็บสี่เหลี่ยมหลังชื่ออินสแตนซ์ ไวยากรณ์จะคล้ายกับวิธีการอินสแตนซ์ทั้งสองไวยากรณ์และไวยากรณ์คำนวณคุณสมบัติ คุณเขียนคำนิยามตัวห้อย ด้วยตัวห้อยคำสำคัญ และระบุอย่าง น้อยหนึ่งพารามิเตอร์ที่ป้อนเข้าและชนิดการส่งคืนสินค้า วิธีการเดียวกันเป็นวิธีการอินสแตนซ์ ซึ่งแตกต่างจากวิธีการอินสแตนซ์ ตัวห้อยสามารถอ่านเขียน หรืออ่านติดต่อสื่อสาร โดยมีการทำงานนี้ และตัวเซ็ตเดียวเป็นการคำนวณคุณสมบัติ:subscript(index: Int) -> Int { {ได้รับ ส่งกลับค่าที่เหมาะสมในตัวห้อยที่นี่ } set(newValue) { ดำเนินการตั้งค่าที่เหมาะสมที่นี่ }}ชนิดของ newValue จะเหมือนกับค่าที่ส่งคืนของตัวห้อย ตามด้วยคำนวณคุณสมบัติ คุณสามารถเลือกไม่ระบุที่ตัวเซ็ตของ (newValue) พารามิเตอร์ได้ ค่าเริ่มต้นพารามิเตอร์ที่เรียกว่า newValue ที่ให้แก่ตัวเซ็ตของคุณถ้าคุณไม่ให้ด้วยตนเองตามอ่านคำนวณคุณสมบัติ คุณสามารถปล่อยสำคัญรับสำหรับอ่านอย่างเดียวตัวห้อย:subscript(index: Int) -> Int { ส่งกลับค่าที่เหมาะสมในตัวห้อยที่นี่}นี่คือตัวอย่างการอ่านตัวห้อยดำเนินการ ซึ่งกำหนดเป็น TimesTableโครงสร้างถึง n-เท่าตารางที่มีจำนวนเต็ม:struct TimesTable { ให้คูณ: Int subscript(index: Int) -> Int { กลับตัวคูณ * ดัชนี }}ให้ threeTimesTable = TimesTable(multiplier: 3)println ("หกครั้งสามคือ (threeTimesTable[6])")พิมพ์ "หกครั้งสามเป็น 18"ในตัวอย่างนี้ มีสร้างอินสแตนซ์ใหม่ของ TimesTable ถึงสามเวลาตารางนี้แสดง โดยช่วยให้ค่า 3 ตัวของโครงสร้างเป็นค่าที่จะใช้สำหรับอินสแตนซ์ตัวคูณพารามิเตอร์คุณสามารถสอบถามอินสแตนซ์ threeTimesTable โดยการเรียกตัวห้อยของ ดังที่แสดงในการเรียกthreeTimesTable [6] นี้ขอรายการเดียวในสามเวลาตาราง ซึ่งส่งกลับค่าการมูลค่า 18 หรือ 6 ครั้งที่ 3หมายเหตุN-เท่าตารางที่ยึดตามกฎคณิตศาสตร์ถาวร ไม่เหมาะสมกับการตั้งค่าthreeTimesTable [someIndex] ค่าใหม่ และเพื่อ ให้ตัวห้อยสำหรับ TimesTable ถูกกำหนดเป็นแบบอ่านอย่างเดียวตัวห้อยการใช้ตัวห้อยความหมายของ "ตัวห้อย" แน่นอนขึ้นอยู่กับบริบทที่ใช้ ตัวห้อยจะใช้เป็นทางลัดสำหรับการเข้าถึงองค์ประกอบของสมาชิกในกลุ่ม รายการ หรือลำดับนั้น คุณมีอิสระในการใช้ตัวห้อยในลักษณะที่เหมาะสมที่สุดสำหรับคุณคลาสเฉพาะหรือโครงสร้างของฟังก์ชันตัวอย่าง Swift พจนานุกรมชนิดใช้ตัวห้อยเพื่อตั้งค่า และเรียกค่าเก็บไว้ในอินสแตนซ์ที่พจนานุกรม คุณสามารถตั้งค่าในพจนานุกรม โดยการให้ความสำคัญของการชนิดหลักของพจนานุกรมภายในวงเล็บตัวห้อย และการกำหนดค่าของการชนิดค่าตัวห้อย:var numberOfLegs = ["แมงมุม": 8 "มด": 6 "แมว": 4]numberOfLegs ["นก"] = 2ตัวอย่างข้างต้นกำหนดตัวแปรที่เรียกว่า numberOfLegs และเริ่มต้น ด้วยพจนานุกรมตัวที่ประกอบด้วยสามคู่ค่าคีย์ สรุปชนิดของพจนานุกรม numberOfLegsเป็น พจนานุกรม. หลังจากสร้างพจนานุกรม ตัวอย่างนี้ใช้ตัวห้อยกำหนดให้เพิ่มคีย์สายของ "นก" และค่า Int 2 ในพจนานุกรมสำหรับข้อมูลเพิ่มเติมเกี่ยวกับ subscripting พจนานุกรม ดู Accessing Modifying เป็นพจนานุกรมหมายเหตุSubscripting ของค่าคีย์เป็นตัวห้อยที่ใช้ และได้รับการเลือกใช้ชนิดของ Swift พจนานุกรมชนิดของ สำหรับ numberOfLegs พจนานุกรมข้าง ตัวห้อยคีย์ค่าใช้ และส่งกลับค่าชนิด Int ?,หรือ "เลือก int" ชนิดพจนานุกรมใช้ชนิดตัวห้อยได้เลือกแบบจะไม่ครบทุกแป้นมีค่า และให้วิธีการลบค่าสำหรับคีย์การกำหนดค่าคีย์ที่ nilตัวห้อยตัวตัวห้อยสามารถใช้จำนวนพารามิเตอร์ป้อนเข้า และพารามิเตอร์เหล่านี้สามารถชนิดใดก็ ตัวห้อยสามารถส่งคืนชนิดใดก็ ตัวห้อยสามารถใช้พารามิเตอร์ตัวแปรและ พารามิเตอร์ variadic แต่ไม่สามารถใช้พารามิเตอร์ในเช็ค หรือให้พารามิเตอร์เริ่มต้นค่าชั้นหรือโครงสร้างที่สามารถให้ใช้งานตัวห้อยมากเท่าที่จำเป็น และตัวห้อยที่เหมาะสมที่จะใช้จะสรุปตามชนิดของค่าหรือค่าที่อยู่ในวงเล็บตัวห้อยที่จุดที่ตัวห้อยที่ใช้ นี้คำจำกัดความของตัวห้อยหลายเรียกว่าตัวห้อยมากเกินไปในขณะที่พบมากที่สุดสำหรับตัวห้อยใช้พารามิเตอร์เดียว คุณยังสามารถกำหนดความตัวห้อย มีหลายพารามิเตอร์ถ้าเหมาะสมกับชนิดของคุณ ต่อไปนี้ตัวอย่างกำหนดโครงสร้างเมตริกซ์ ซึ่งแสดงเมตริกซ์สองของสองค่า เมตริกซ์ของโครงสร้างตัวห้อยจะเต็มสองพารามิเตอร์:struct {เมตริกซ์ ให้แถว: Int คอลัมน์: Int ตาราง var: คู่] เริ่มต้น (แถว: Int คอลัมน์: Int) { self.rows =แถว self.columns =คอลัมน์ ตาราง =เรย์ (จำนวน: แถว * คอลัมน์ repeatedValue: 0.0) } func indexIsValidForRow (แถว: Int คอลัมน์: Int) -> Bool { กลับแถว > = 0 & & แถว < แถว & & คอลัมน์ > = 0 & & คอลัมน์ < คอลัมน์ubscript (แถว: Int คอลัมน์: Int) -> {คู่ {ได้รับ ยืนยันรูป (indexIsValidForRow (แถว คอลัมน์: คอลัมน์), "ดัชนีออกจากช่วง") กลับเส้น [(row * columns) + คอลัมน์] } {ชุด ยืนยันรูป (indexIsValidForRow (แถว คอลัมน์: คอลัมน์), "ดัชนีออกจากช่วง") ตาราง [(row * columns) + คอลัมน์] = newValue }เมตริกซ์แสดงตัวที่สองพารามิเตอร์เรียกแถวและคอลัมน์ และสร้างอาร์เรย์ที่มีขนาดใหญ่พอที่จะเก็บแถว * ค่าคอลัมน์ของชนิดเดี่ยว แต่ละตำแหน่งในเมตริกซ์จะกำหนดค่าเริ่มต้นของ 0.0 เพื่อให้บรรลุนี้ อาร์เรย์ของ ขนาด และ อันแรกเซลล์ค่า 0.0 ส่งผ่านไปที่ตัวอาร์เรย์ที่สร้าง และเริ่มต้นแถวใหม่ขนาดถูกต้อง ตัวนี้จะอธิบายในรายละเอียดเพิ่มเติมในการสร้างและการ Initializingอาร์เรย์คุณสามารถสร้างอินสแตนซ์เมตริกซ์ใหม่ โดยผ่านการสมแถวและจำนวนคอลัมน์ต้องการตัว:เมตริกซ์ var =เมตริกซ์ (แถว: 2 คอลัมน์: 2)ตัวอย่างก่อนหน้านี้สร้างอินสแตนซ์เมตริกซ์ใหม่ มีสองแถวและคอลัมน์ที่สอง ที่อ่านเรย์ตารางสำหรับนี้อินสแตนซ์เป็นอย่างมีประสิทธิภาพรุ่นล...เมตริกซ์ เมตริกซ์จากบนซ้ายลงล่างขวา:สามารถตั้งค่าในเมตริกซ์ โดยส่งค่าที่แถวและคอลัมน์เป็นตัวห้อยคั่น ด้วยเครื่องหมายจุลภาค:เมตริกซ์ [0, 1] = 1.5เมตริกซ์ [1, 0] = 3.2ตัวห้อยตัวเซ็ตการตั้งค่า 1.5 ด้านบนขวาเรียกคำสั่งเหล่านี้สองตำแหน่งของเมทริกซ์ (ที่ 0 คือแถว และคอลัมน์คือ 1), และ 3.2 ในตำแหน่งซ้ายล่าง(แถว 1 และคอลัมน์เป็น 0):ในเมตริกซ์ของมีและตัวเซ็ตทั้งการยืนยันการตรวจสอบว่าประกอบด้วยการค่าตัวห้อยของแถวและคอลัมน์ไม่ถูกต้อง ช่วย ด้วย assertions เหล่านี้ มีเมตริกซ์การวิธีสะดวกที่เรียกว่า indexIsValid การร้องขอแถวหรือคอลัมน์ว่านอกขอบเขตของเมทริกซ์:func indexIsValidForRow (แถว: Int คอลัมน์: Int) -> Bool { กลับแถว > = 0 & & แถว < แถว & & คอลัมน์ > = 0 & & คอลัมน์ < คอลัมน์}การยืนยันจะถูกทริกเกอร์ถ้าคุณพยายามเข้าถึงตัวห้อยที่อยู่นอกเมตริกซ์ขอบเขต:ให้ someValue =เมตริกซ์ [2, 2]นี้ทริกเกอร์การ assert เพราะ [2, 2] อยู่นอกขอบเขตของเมตริกซ์

ผลลัพธ์ (ไทย) 2:

ห้อย
เรียนโครงสร้างและ enumerations สามารถกำหนดห้อยซึ่งเป็นทางลัดสำหรับ
การเข้าถึงองค์ประกอบสมาชิกคนหนึ่งของคอลเลกชันรายการหรือลำดับ คุณสามารถใช้ห้อยที่จะ
ตั้งค่าและเรียกค่าดัชนีโดยไม่จำเป็นต้องใช้วิธีแยกต่างหากสำหรับการตั้งค่าและ
การดึง ตัวอย่างเช่นคุณสามารถเข้าถึงองค์ประกอบในตัวอย่างอาร์เรย์เป็น someArray [index] และ
องค์ประกอบในพจนานุกรมเช่นเป็น someDictionary [สำคัญ].
คุณสามารถกำหนดห้อยหลายชนิดเดียวและห้อยที่เหมาะสม
กับการใช้งานเกินจะถูกเลือกขึ้นอยู่กับชนิด ของค่าดัชนีที่คุณส่งผ่านไปยังห้อย.
ห้อยไม่ จำกัด เพียงมิติเดียวและคุณสามารถกำหนดห้อยกับ
ป้อนพารามิเตอร์หลายเพื่อให้เหมาะกับความต้องการประเภทที่กำหนดเองของคุณ.
ห้อยไวยากรณ์
ห้อยช่วยให้คุณสามารถสอบถามกรณีของชนิดโดยการเขียนหนึ่งหรือมากกว่า ค่าใน
วงเล็บหลังชื่อเช่น ไวยากรณ์ของพวกเขามีความคล้ายคลึงกับทั้งสองวิธีการเช่น
ไวยากรณ์และไวยากรณ์อสังหาริมทรัพย์คำนวณ คุณเขียนคำจำกัดความห้อยกับห้อย
คำและระบุหนึ่งหรือมากกว่าหนึ่งป้อนพารามิเตอร์และประเภทผลตอบแทนในลักษณะเดียว
กับวิธีการเช่น . ซึ่งแตกต่างจากวิธีการเช่นห้อยสามารถอ่านเขียนหรืออ่านอย่างเดียว
ลักษณะการทำงานนี้มีการสื่อสารโดยทะเยอทะยานและหมาในลักษณะเดียวกับการคำนวณ
คุณสมบัติ:
ห้อย (ดัชนี: Int) -> Int {
{ได้รับ
กลับ // เหมาะสม ค่าห้อยที่นี่
}
ชุด (newValue) {
// ดำเนินการดำเนินการตั้งค่าที่เหมาะสมที่นี่
}
}
ประเภทของ newValue เป็นเช่นเดียวกับค่าตอบแทนจากตัวห้อย เช่นเดียวกับการคำนวณ
คุณสมบัติคุณสามารถเลือกที่จะไม่ระบุตัวตั้งค่าของ (newValue) พารามิเตอร์ เริ่มต้น
ที่เรียกว่าพารามิเตอร์ newValue ให้กับหมาของคุณถ้าคุณไม่ให้หนึ่งตัวเอง.
เช่นเดียวกับการอ่านอย่างเดียวคุณสมบัติคำนวณคุณสามารถวางคำหลักที่ได้รับสำหรับอ่านอย่างเดียว
ห้อย:
ห้อย (ดัชนี: Int) -> Int {
// กลับค่าห้อยที่เหมาะสมที่นี่
}
นี่คือตัวอย่างของการอ่านอย่างเดียวการดำเนินห้อยซึ่งกำหนด Timestable
โครงสร้างเพื่อเป็นตัวแทนของ n-ครั้งตารางของจำนวนเต็ม:
struct Timestable {
ให้คูณ: Int
ห้อย (ดัชนี: Int) -> Int {
กลับมาคูณดัชนี *
}
}
ให้ threeTimesTable = Timestable (คูณ: 3)
println ("หกครั้งสามเป็น (threeTimesTable [6])")
// พิมพ์ "หกครั้งสามคือ 18"
ในตัวอย่างนี้ตัวอย่างใหม่ของ Timestable ถูกสร้างขึ้นเพื่อเป็นตัวแทนของสามครั้งตาราง.
นี้จะแสดงโดยผ่านค่าของ 3 ถึงการเริ่มต้นของโครงสร้างเป็นค่าที่จะใช้สำหรับ
พารามิเตอร์คูณตัวอย่างของ.
คุณสามารถค้นหาเช่น threeTimesTable โดยการเรียกห้อยตามที่แสดงใน การเรียกร้องให้
threeTimesTable [6] นี้ขอรายการที่หกในสามครั้งตารางซึ่งผลตอบแทน
ค่าของ 18 หรือ 3 ครั้ง 6.
หมายเหตุ
n ครั้งตารางจะขึ้นอยู่กับกฎทางคณิตศาสตร์คงที่ มันไม่เหมาะสมที่จะตั้ง
threeTimesTable [someIndex] เพื่อค่าใหม่และอื่น ๆ สำหรับห้อย Timestable ถูกกำหนดให้เป็นแบบอ่านอย่างเดียว
ห้อย.
ห้อยการใช้
ความหมายที่แท้จริงของ "ห้อย" ขึ้นอยู่กับบริบทที่มันถูกนำมาใช้ ห้อย
มักจะใช้เป็นทางลัดในการเข้าถึงองค์ประกอบสมาชิกในการเก็บรวบรวมรายการหรือ
ลำดับ คุณมีอิสระที่จะใช้ห้อยในทางที่เหมาะสมที่สุดสำหรับคุณ
โดยเฉพาะอย่างยิ่งการทำงานระดับหรือโครงสร้างของ.
ตัวอย่างเช่นพิมพ์พจนานุกรมวิฟท์ดำเนินห้อยตั้งและเรียกค่า
ที่เก็บไว้ในพจนานุกรมเช่น คุณสามารถตั้งค่าในพจนานุกรมโดยการให้ที่สำคัญของ
ชนิดที่สำคัญพจนานุกรมภายในวงเล็บห้อยและการกำหนดค่าของพจนานุกรมของ
ประเภทค่าที่จะห้อย:
var numberOfLegs = ["แมงมุม": 8 "มด": 6, "แมว": 4]
numberOfLegs ["นก"] = 2
ตัวอย่างข้างต้นกำหนดตัวแปรที่เรียกว่า numberOfLegs และเริ่มต้นด้วยพจนานุกรม
อักษรที่มีสามคู่ค่าคีย์ ประเภทของพจนานุกรม numberOfLegs เหมาเอา
ว่าจะเป็นพจนานุกรม. หลังจากที่สร้างพจนานุกรมตัวอย่างนี้ใช้ห้อย
มอบหมายให้เพิ่มคีย์ String ของ "นก" และค่า Int 2 ถึงพจนานุกรม.
สำหรับข้อมูลเพิ่มเติมเกี่ยว subscripting พจนานุกรมดูการเขและแก้ไข
พจนานุกรม.
หมายเหตุ
ประเภทพจนานุกรมวิฟท์ดำเนินการที่สำคัญของ subscripting -value ห้อยที่ใช้และได้รับตัวเลือก
ชนิด สำหรับ numberOfLegs พจนานุกรมข้างต้นห้อยค่าคีย์จะใช้เวลาและการส่งกลับค่าของ Int ชนิด ?,
หรือ "ตัวเลือก int" ประเภทพจนานุกรมใช้ชนิดห้อยตัวเลือกในการจำลองความจริงที่ว่าไม่สำคัญทุกคนจะ
มีค่าและเพื่อให้วิธีการลบค่าสำหรับคีย์โดยการกำหนดค่าศูนย์สำหรับคีย์ที่.
ตัวเลือกห้อย
ห้อยสามารถใช้ตัวเลขใด ๆ ป้อนพารามิเตอร์และป้อนพารามิเตอร์เหล่านี้อาจจะเป็น
ประเภทใด ห้อยยังสามารถกลับชนิดใด ๆ ห้อยสามารถใช้พารามิเตอร์ตัวแปร
และพารามิเตอร์ variadic แต่ไม่สามารถใช้พารามิเตอร์ในออกหรือให้พารามิเตอร์เริ่มต้น
ค่า.
ชั้นหรือโครงสร้างสามารถให้การใช้งานห้อยมากที่สุดเท่าที่มันต้องการและ
ห้อยเหมาะสมที่จะนำมาใช้จะได้รับการสรุปตามประเภท ของมูลค่าหรือค่า
ที่มีอยู่ภายในวงเล็บห้อยที่จุดที่ห้อยถูกนำมาใช้ นี้
ความหมายของหลายห้อยเป็นที่รู้จักกันมากไปห้อย.
ในขณะที่มันเป็นเรื่องธรรมดามากที่สุดสำหรับห้อยที่จะใช้พารามิเตอร์เดียวคุณยังสามารถกำหนด
ห้อยกับพารามิเตอร์หลายถ้ามันเป็นที่เหมาะสมสำหรับประเภทของคุณ ต่อไปนี้
ตัวอย่างเช่นกำหนดโครงสร้างเมทริกซ์ซึ่งหมายถึงเมทริกซ์สองมิติคู่
ค่า ห้อยโครงสร้างเมทริกซ์ใช้เวลาสองพารามิเตอร์จำนวนเต็ม:
Matrix struct {
ปล่อยแถว: Int คอลัมน์: Int
ตาราง var: คู่ []
init (แถว: Int คอลัมน์: Int) {
self.rows แถว =
คอลัมน์ = self.columns
ตาราง = อาร์เรย์ (นับแถวคอลัมน์ * repeatedValue: 0.0)
}
func indexIsValidForRow (แถว: Int คอลัมน์: Int) -> Bool {
กลับมาแถว> = 0 && แถว <แถว && คอลัมน์> = 0 && คอลัมน์ <คอลัมน์
ubscript (แถว: Int คอลัมน์: Int) -> คู่ {
{ได้รับ
ยืนยัน (indexIsValidForRow (แถวคอลัมน์: คอลัมน์), "ดัชนีอยู่ในช่วง")
ตารางผลตอบแทน [(แถว * คอลัมน์) + คอลัมน์]
}
ชุด {
ยืนยัน (indexIsValidForRow (แถวคอลัมน์ : คอลัมน์), "ดัชนีอยู่ในช่วง")
ตาราง [(แถว * คอลัมน์) + คอลัมน์] = newValue
}
เมทริกซ์มีการเริ่มต้นที่จะใช้เวลาสองพารามิเตอร์ที่เรียกว่าแถวและคอลัมน์และสร้าง
อาร์เรย์ที่มีขนาดใหญ่พอที่จะเก็บแถวคอลัมน์ * ค่าประเภทคู่ แต่ละตำแหน่งใน
เมทริกซ์จะได้รับค่าเริ่มต้นของ 0.0 เพื่อให้บรรลุนี้ขนาดของอาเรย์และเริ่มต้น
ค่าในเซลล์ของ 0.0 จะถูกส่งผ่านไปยังการเริ่มต้นที่จะสร้างอาร์เรย์และเริ่มต้นอาร์เรย์ใหม่
ของขนาดที่ถูกต้อง การเริ่มต้นนี้จะอธิบายในรายละเอียดเพิ่มเติมในการสร้างและการเริ่มต้น
อาร์เรย์.
คุณสามารถสร้างอินสแตนซ์เมทริกซ์ใหม่โดยผ่านแถวที่เหมาะสมและคอลัมน์นับ
เพื่อการเริ่มต้นของมัน
เมทริกซ์ var = เมทริกซ์ (แถว: 2 คอลัมน์: 2)
ตัวอย่างก่อนหน้านี้สร้าง เช่น Matrix ใหม่ที่มีสองแถวและคอลัมน์ที่สอง
อาร์เรย์ตารางเช่น Matrix นี้ได้อย่างมีประสิทธิภาพรุ่นแบนของเมทริกซ์เป็นอ่าน
จากซ้ายไปขวาด้านล่าง:
ค่าในเมทริกซ์สามารถตั้งค่าได้โดยผ่านแถวและค่าของคอลัมน์เป็นห้อย,
คั่นด้วยเครื่องหมายจุลภาค:
เมทริกซ์ [0 1] = 1.5
เมทริกซ์ [1, 0] = 3.2
ทั้งสองงบเรียกหมาห้อยในการตั้งค่าของ 1.5 ที่ด้านขวาบน
ตำแหน่งของเมทริกซ์ (ที่แถวเป็น 0 และคอลัมน์ 1) และ 3.2 ในด้านล่าง ตำแหน่งซ้าย
(แถวที่ 1 และ 0 คอลัมน์):
ทะเยอทะยานห้อยเมทริกซ์และ Setter ทั้งสองมีการยืนยันที่จะตรวจสอบว่า
แถวของห้อยและค่าของคอลัมน์ที่ถูกต้อง เพื่อช่วยในการยืนยันเหล่านี้เมทริกซ์รวมถึง
วิธีการที่เรียกว่าสะดวกสบาย indexIsValid ซึ่งตรวจสอบว่าแถวที่ร้องขอหรือคอลัมน์เป็น
นอกขอบเขตของเมทริกซ์:
func indexIsValidForRow (แถว: Int คอลัมน์: Int) -> Bool {
กลับมาแถว> = 0 && แถว <แถว && คอลัมน์> = 0 && คอลัมน์ <คอลัมน์
}
ยืนยันจะถูกเรียกว่าถ้าคุณพยายามที่จะเข้าถึงห้อยที่อยู่นอกของเมทริกซ์
ขอบเขต:
ให้ someValue เมทริกซ์ = [2, 2]
// นี้ก่อให้เกิดการยืนยันเพราะ [2, 2] อยู่นอกขอบเขตเมทริกซ์

ผลลัพธ์ (ไทย) 3:

subscripts
ชั้น โครงสร้าง และสามารถกำหนด subscripts เครื่อง ซึ่งเป็นทางลัดสำหรับ
เข้าถึงสมาชิกองค์ประกอบของคอลเลกชันรายชื่อหรือลำดับ คุณใช้ subscripts

ชุดและดึงค่าดัชนี โดยไม่ต้องมีวิธีการแยกต่างหากสำหรับการตั้งค่าและ
คำค้น ตัวอย่างเช่นคุณสามารถเข้าถึงองค์ประกอบในอาร์เรย์ ตัวอย่าง เช่น ดัชนี somearray [
]องค์ประกอบในพจนานุกรมอินสแตนซ์เป็นกุญแจ ] somedictionary [ .
คุณสามารถกำหนดหลาย subscripts เป็นชนิดเดียว และเกินอยู่
ที่เหมาะสมเพื่อใช้เลือกตามชนิดของค่าดัชนีคุณส่งผ่านไปยังตัวห้อย .
subscripts ไม่จํากัดเพียงมิติเดียว และคุณสามารถกำหนดพารามิเตอร์การป้อนข้อมูลด้วย
subscripts หลายเพื่อให้เหมาะกับความต้องการของคุณเองประเภทของไวยากรณ์
.
ดรรชนีล่างsubscripts ช่วยให้คุณสามารถค้นหาอินสแตนซ์ของหนึ่งหรือมากกว่าหนึ่งชนิด โดยการเขียนค่า
ตารางวงเล็บหลังชื่ออินสแตนซ์ ไวยากรณ์ของพวกเขาจะคล้ายกับตัวอย่างวิธีการคำนวณทั้งสอง
ไวยากรณ์และไวยากรณ์คุณสมบัติ คุณเขียนอยู่คำนิยามกับตัวห้อย
คำหลักและระบุหนึ่งหรือมากกว่าหนึ่งพารามิเตอร์การป้อนข้อมูลและพิมพ์กลับใน
เช่นเดียวกับวิธีการอินสแตนซ์ ซึ่งแตกต่างจากวิธีการอินสแตนซ์subscripts สามารถอ่านเขียนได้ หรืออ่านอย่างเดียว พฤติกรรมนี้เป็นการสื่อสารโดยเก็ต setter และในลักษณะเดียวกันสำหรับการคำนวณคุณสมบัติ :

ตัวห้อย ( ดัชนี : 1 ) - > int {
รับ {
/ / กลับที่เหมาะสมอยู่ค่า

( newvalue ที่นี่ } ) {
/ / ดำเนินการที่เหมาะสม การตั้งค่าการกระทำที่นี่


} } ประเภทของ newvalue เป็นเช่นเดียวกับคืนค่าของอยู่ . เช่นเดียวกับการคำนวณ
คุณสมบัติคุณสามารถเลือกที่จะไม่ระบุเป็น setter ( newvalue ) พารามิเตอร์ การเริ่มต้นพารามิเตอร์ที่เรียกว่า
newvalue ให้ตั้งค่าของคุณถ้าคุณไม่ได้หนึ่งให้ตัวเอง กับอ่านอย่างเดียว
คำนวณคุณสมบัติ คุณสามารถวางได้รับคำหลักสำหรับ subscripts อ่านอย่างเดียว
:
ตัวห้อย ( ดัชนี : 1 ) - > int {
/ / ส่งกลับค่าที่เหมาะสมอยู่ที่นี่
}
นี่คือตัวอย่างของการใช้ตัวห้อยอ่านได้อย่างเดียวเท่านั้นซึ่งได้กำหนดโครงสร้างของ timestable

n-times-table จำนวนเต็ม : ซอฟต์แวร์ timestable {
ให้คูณ int
ตัวห้อย ( ดัชนี : 1 ) - > int {

}
กลับไปตัวคูณดัชนี * }
ให้ threetimestable = timestable ( คูณ 3 )
println ( " 6 ครั้ง 3 ( threetimestable [ 6 ] ) " )
/ / พิมพ์ครั้งที่ 3 " 6 18 "
ในตัวอย่างนี้ตัวอย่างใหม่ของ timestable ถูกสร้างขึ้นเพื่อแสดงถึงสามครั้งตาราง .
นี้แสดงโดยผ่านค่าของ 3 initializer ของโครงสร้างที่เป็นค่า เพื่อใช้สำหรับเป็นอินสแตนซ์

คูณพารามิเตอร์ คุณสามารถค้นหาอินสแตนซ์ threetimestable เรียกของมันอยู่ ดังปรากฏในโทร
threetimestable [ 6 ] นี้ขอให้รายการที่หกใน 3 ครั้งซึ่งส่งกลับ
โต๊ะมูลค่า 18 , หรือ 3 ครั้ง 6 .

มีหมายเหตุ n-times-table ขึ้นอยู่กับคงที่ทางคณิตศาสตร์กฎ มันไม่เหมาะที่จะตั้ง
threetimestable [ someindex ] ค่าใหม่ และดังนั้น ตัวห้อยสำหรับ timestable ถูกกําหนดให้เป็นตัวห้อยอ่านอย่างเดียว
.

ใช้ตัวห้อยความหมายที่แน่นอนของ " ห้อย " ขึ้นอยู่กับบริบทที่จะใช้ subscripts
โดยทั่วไปจะใช้เป็นทางลัดในการเข้าถึงสมาชิกองค์ประกอบคอลเลกชัน รายการหรือ
ลำดับ คุณมีอิสระที่จะใช้ subscripts ในทางที่เหมาะสมที่สุดสำหรับการเรียนหรือการทํางานโครงสร้างเฉพาะ
.
ตัวอย่างรวดเร็วของประเภทพจนานุกรมใช้อยู่ตั้งค่าและเรียกค่า
เก็บไว้ในพจนานุกรมเช่นคุณสามารถตั้งค่าในพจนานุกรม โดยให้หลักของ
พจนานุกรมพิมพ์คีย์อยู่ภายในวงเล็บและการกําหนดมูลค่าของค่า
พจนานุกรมชนิดที่อยู่ :
var numberoflegs = [ " แมงมุม " 8 " มด " 6 " แมว " :
numberoflegs [ 5 ] " นก " ] = 2
ตัวอย่างข้างต้นกำหนดตัวแปรและเรียก numberoflegs initializes กับพจนานุกรม
ที่แท้จริงประกอบด้วยสามค่าคีย์คู่ประเภทของ numberoflegs พจนานุกรมเป็นพจนานุกรมได้
< สตริง , int > หลังจากสร้างพจนานุกรม ตัวอย่างนี้ใช้งานอยู่
เพิ่มคีย์ข้อความของ " นก " และเป็น int ค่าของ 2 ในพจนานุกรม
สำหรับข้อมูลเพิ่มเติมเกี่ยวกับพจนานุกรม subscripting เห็นการเข้าถึงและปรับเปลี่ยนข้อความ


พจนานุกรมรวดเร็วพิมพ์พจนานุกรมใช้คีย์ของมูลค่า subscripting เป็นตัวห้อยที่ใช้เวลาและได้รับประเภทที่เลือก

สำหรับ numberoflegs พจนานุกรมข้างต้น ตกลงค่าคีย์ใช้เวลาและจะคืนค่าของชนิด int ?
" int " , หรือตัวเลือก ประเภทพจนานุกรมใช้ตัวห้อยเลือกแบบชนิดที่ว่าไม่ทุกคีย์
มีมูลค่าและเพื่อให้วิธีการลบค่าสำหรับคีย์ โดยให้ศูนย์ค่ากุญแจ อยู่

subscripts ตัวเลือกสามารถใช้หมายเลขใด ๆของพารามิเตอร์การป้อนข้อมูลและพารามิเตอร์การป้อนข้อมูลเหล่านี้สามารถ
ประเภทใด subscripts สามารถส่งคืนชนิดใด subscripts สามารถใช้ตัวแปรพารามิเตอร์
และพารามิเตอร์ variadic แต่ไม่สามารถใช้ในพารามิเตอร์หรือให้

พารามิเตอร์ค่าเริ่มต้น .ชั้นหรือโครงสร้างสามารถให้ใช้งานอยู่มากมายตามความต้องการ และเหมาะสมที่จะใช้
สดๆจะได้ตามประเภทของค่าหรือค่า
ที่มีอยู่ภายในการจัดฟัน อยู่ในจุดที่ตกลงใช้ คำนิยามของหลาย subscripts นี้

เรียกว่าตัวห้อยเกินพิกัดในขณะที่มันเป็นเรื่องธรรมดามากที่สุดสำหรับตัวห้อยใช้พารามิเตอร์เดียว คุณยังสามารถกำหนด
ตัวห้อยด้วยพารามิเตอร์หลาย ถ้ามันเป็นที่เหมาะสมสำหรับชนิดของคุณ ตัวอย่างต่อไปนี้
กำหนดโครงสร้างเมทริกซ์ซึ่งเป็นเมทริกซ์สองมิติของคู่
ค่า ตัวห้อยเมทริกซ์โครงสร้างของคนสองคนที่เป็นพารามิเตอร์ :

ปล่อยแถวของเมทริกซ์ซอฟต์แวร์ { : คอลัมน์ int , int
var ตาราง :คู่ [ ]
init ( แถว : int , int คอลัมน์ : ) {
self.rows = =

self.columns แถวคอลัมน์ตาราง = array ( นับ : แถว * คอลัมน์ repeatedvalue : 0.0 )
}
func indexisvalidforrow ( แถว : int , int คอลัมน์ : ) - > บูล {
กลับแถว > = 0 &&แถว < แถว&&คอลัมน์ > = 0 &&คอลัมน์คอลัมน์ <
ubscript ( แถว : int , int คอลัมน์ : ) - > คู่ { {

ได้ยืนยัน indexisvalidforrow ( แถว , คอลัมน์ : คอลัมน์ ) " ดัชนีในช่วง " )
[ ตารางผลตอบแทน ( แถวคอลัมน์ * ) คอลัมน์ ]
} {

ชุดใหม่ ( indexisvalidforrow ( แถว , คอลัมน์ : คอลัมน์ ) " ดัชนีในช่วง " )
( แถวคอลัมน์ตาราง [ คอลัมน์ ] = * ) newvalue
}
Matrix ให้ initializer ซึ่งใช้เวลาสองพารามิเตอร์ที่เรียกว่าแถวและคอลัมน์และสร้าง
อาร์เรย์ที่มีขนาดใหญ่พอที่จะเก็บแถว * คอลัมน์ค่าของประเภทคู่ แต่ละตำแหน่งใน
Matrix ได้รับค่าเริ่มต้นของ 0.0เพื่อให้บรรลุนี้ ขนาดของอาร์เรย์และเริ่มต้น
เซลล์ค่า 0.0 จะถูกส่งผ่านไปยังดอกไม้ที่สร้างและ initializes เป็น
เรย์ใหม่ของขนาดที่ถูกต้อง initializer นี้จะอธิบายในรายละเอียดเพิ่มเติมในการสร้าง และการเริ่มต้นของอาร์เรย์
.
คุณสามารถสร้างอินสแตนซ์เมทริกซ์ใหม่โดยผ่านแถวและคอลัมน์ที่เหมาะสมของ initializer นับ

= : var เมทริกซ์เมทริกซ์ ( แถว 2 คอลัมน์ :2 )
ก่อนหน้านี้ตัวอย่างสร้างอินสแตนซ์เมทริกซ์ใหม่ 2 แถว และคอลัมน์
เรย์สำหรับตารางเมทริกซ์นี้อินสแตนซ์ได้อย่างมีประสิทธิภาพบี้รุ่นของเมทริกซ์เป็นอ่าน
จากด้านบนจากซ้ายไปขวาด้านล่าง :
ค่าใน matrix สามารถตั้งค่าได้โดยผ่านแถวและคอลัมน์เป็นค่าอยู่
, คั่นด้วยเครื่องหมายจุลภาค :
เมทริกซ์ [ 0 , 1 ] = 1.5
เมทริกซ์ [ 1 0 ] =
.ทั้งสองข้อของผู้เรียกอยู่ตั้งมูลค่า 1.5 ในด้านบนขวา
ตำแหน่งของเมทริกซ์ ( ที่แถวและคอลัมน์จะเป็น 0 , 1 ) และ 3.2 ในด้านล่างซ้ายตำแหน่ง
( ที่แถว 1 คอลัมน์เป็น 0 ) :
เมทริกซ์ตัวห้อยเป็น setter และทั้งสองมีเก็ตเตอร์ การตรวจสอบว่าแถวพยาบาลตัวห้อยและค่าคอลัมน์ที่ถูกต้อง เพื่อให้ความช่วยเหลือกับ assertions เหล่านี้รวมถึง
เมทริกซ์วิธีสะดวกเรียก indexisvalid ซึ่งจะตรวจสอบว่าขอแถวหรือคอลัมน์คือ
อยู่นอกขอบเขตของเมทริกซ์ :
func indexisvalidforrow ( แถว : int , int คอลัมน์ : ) - > บูล {
กลับแถว > = 0 &&แถว < แถว&&คอลัมน์ > = 0 &&คอลัมน์คอลัมน์ <
}
มีการทริกเกอร์ ถ้าคุณพยายามที่จะเข้าถึงข้อมูลอยู่ที่ด้านนอกของเมทริกซ์

ให้ขอบเขต : somevalue = เมทริกซ์ [ 2 ]
2/ / นี่เรียกการยืนยันเพราะ [ 1 , 2 ] นอกขอบเขตเมทริกซ์