- ข้อความ
- ประวัติศาสตร์
ExtensionsExtensions add new functi
Extensions
Extensions add new functionality to an existing class, structure, or enumeration type. This includes the ability to extend types for which you do not have access to the original source code (known as retroactive modeling). Extensions are similar to categories in Objective-C. (Unlike Objective-C categories, Swift extensions do not have names.) Extensions in Swift can:
Add computed properties and computed static properties Define instance methods and type methods Provide new initializers Define subscripts Define and use new nested types Make an existing type conform to a protocol
NOTE If you define an extension to add new functionality to an existing type, the new functionality will be available on all existing instances of that type, even if they were created before the extension was defined.
Extension Syntax
Declare extensions with the extension keyword:
extension SomeType {
// new functionality to add to SomeType goes here
}
An extension can extend an existing type to make it adopt one or more protocols. Where this is the case, the protocol names are written in exactly the same way as for a class or structure:
extension SomeType: SomeProtocol, AnotherProtocol {
// implementation of protocol requirements goes here
}
Adding protocol conformance in this way is described in Adding Protocol Conformance with an Extension.
Computed Properties
Extensions can add computed instance properties and computed type properties to existing types. This example adds five computed instance properties to Swift’s built-in Double type, to provide basic support for working with distance units:
extension Double {
var km: Double { return self * 1_000.0 }
var m: Double { return self }
var cm: Double { return self / 100.0 }
var mm: Double { return self / 1_000.0 }
var ft: Double { return self / 3.28084 }
}
let oneInch = 25.4.mm
println("One inch is (oneInch) meters")
rints "One inch is 0.0254 meters"
threeFeet = 3.ft
("Three feet is (threeFeet) meters")
rints "Three feet is 0.914399970739201 meters"
These computed properties express that a Double value should be considered as a certain unit of length. Although they are implemented as computed properties, the names of these properties can be appended to a floating-point literal value with dot syntax, as a way to use that literal value to perform distance conversions. In this example, a Double value of 1.0 is considered to represent “one meter”. This is why the m computed property returns self—the expression 1.m is considered to calculate a Double value of 1.0. Other units require some conversion to be expressed as a value measured in meters. One
kilometer is the same as 1,000 meters, so the km computed property multiplies the value by 1_000.00 to convert into a number expressed in meters. Similarly, there are 3.28024 feet in a meter, and so the ft computed property divides the underlying Double value by 3.28024, to convert it from feet to meters. These properties are read-only computed properties, and so they are expressed without the get keyword, for brevity. Their return value is of type Double, and can be used within mathematical calculations wherever a Double is accepted:
let aMarathon = 42.km + 195.m
println("A marathon is (aMarathon) meters long")
// prints "A marathon is 42195.0 meters long"
NOTE Extensions can add new computed properties, but they cannot add stored properties, or add property observers to existing properties.
Initializers
Extensions can add new initializers to existing types. This enables you to extend other types to accept your own custom types as initializer parameters, or to provide additional initialization options that were not included as part of the type’s original implementation. Extensions can add new convenience initializers to a class, but they cannot add new designated initializers or deinitializers to a class. Designated initializers and deinitializers must always be provided by the original class implementation.
NOTE If you use an extension to add an initializer to a value type that provides default values for all of its stored properties and does not define any custom initializers, you can call the default initializer and memberwise initializer for that value type from within your extension’s initializer. This would not be the case if you had written the initializer as part of the value type’s original implementation, as described in Initializer Delegation for Value Types.
The example below defines a custom Rect structure to represent a geometric rectangle. The example also defines two supporting structures called Size and Point, both of which provide default values of 0.0 for all of their properties:
struct Size {
var width = 0.0, height = 0.0
}
struct Point {
var x = 0.0, y = 0.0
}
struct Rect {
var origin = Point()
var size = Size()
Because the Rect structure provides default values for all of its properties, it receives a default initializer and a memberwise initializer automatically, as described in Default Initializers. These initializers can be used to create new Rect instances:
let defaultRect = Rect()
let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0),
size: Size(width: 5.0, height: 5.0))
You can extend the Rect structure to provide an additional initializer that takes a specific center point and size:
extension Rect {
init(center: Point, size: Size) {
let originX = center.x - (size.width / 2)
let originY = center.y - (size.height / 2)
self.init(origin: Point(x: originX, y: originY), size: size)
}
}
This new initializer starts by calculating an appropriate origin point based on the provided center point and size value. The initializer then calls the structure’s automatic memberwise initializer init(origin:size:), which stores the new origin and size values in the appropriate properties:
let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
size: Size(width: 3.0, height: 3.0))
// centerRect's origin is (2.5, 2.5) and its size is (3.0, 3.0)
NOTE If you provide a new initializer with an extension, you are still responsible for making sure that each instance is fully initialized once the initializer completes.
Methods
Extensions can add new instance methods and type methods to existing types. The following example adds a new instance method called repetitions to the Int type:
extension Int {
func repetitions(task: () -> ()) {
for i in 0..self {
task()
}
}
}
The repetitions method takes a single argument of type () -> (), which indicates a function that has no parameters and does not return a value. After defining this extension, you can call the repetitions method on any integer number to perform a task that many number of times:
3.repetitions({
println("Hello!")
})
// Hello!
// Hello!
// Hello!
Use trailing closure syntax to make the call more succinct:
3.repetitions {
println("Goodbye!")
}
// Goodbye!
// Goodbye!
// Goodbye!
Mutating Instance Methods
Instance methods added with an extension can also modify (or mutate) the instance itself. Structure and enumeration methods that modify self or its properties must mark the instance method as mutating, just like mutating methods from an original implementation. The example below adds a new mutating method called square to Swift’s Int type, which squares the original value:
extension Int {
mutating func square() {
self = self * self
}
}
var someInt = 3
someInt.square()
// someInt is now 9
Subscripts
Extensions can add new subscripts to an existing type. This example adds an integer subscript to Swift’s built-in Int type. This subscript [n] returns the decimal digit n places in from the right of the number:
123456789[0] returns 9
…and so on:
extension Int {
subscript(digitIndex: Int) -> Int {
var decimalBase = 1
for _ in 1...digitIndex {
decimalBase *= 10
}
return (self / decimalBase) % 10
}
}
6381295[0]
eturns 5
6381295[1]
eturns 9
6381295[2]
eturns 2
6381295[8]
eturns 7
If the Int value does not have enough digits for the requested index, the subscript implementation returns 0, as if the number had been padded with zeroes to the left:
746381295[9]
// returns 0, as if you had requested:
0746381295[9]
Nested Types
Extensions can add new nested types to existing classes, structures and enumerations:
123456789[1] returns 8
extension Character {
enum Kind {
case Vowel, Consonant, Other
}
var kind: Kind {
switch String(self).lowercaseString {
case "a", "e", "i", "o", "u":
return .Vowel
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
"n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
return .Consonant
default:
return .Other
}
This example adds a new nested enumeration to Character. This enumeration, called Kind, expresses the kind of letter that a particular character represents. Specifically, it expresses whether the character is a vowel or a consonant in a standard Latin script (without taking into account accents or regional variations), or whether it is another kind of character. This example also adds a new computed instance property to Character, called kind, which returns the appropriate Kind enumeration member for that character. The nested enumeration can now be used with Character values:
func printLetterKinds(word: String) {
println("'(word)' is made up of the following kinds of letters:")
for character in word {
switch character.kind {
case .Vowel:
print("vowel ")
case .Consonant:
print("consonant ")
case .Other:
print("other ")
}
print("
")
tLetterKinds("Hello")
Hello' is made up of the following kinds of letters:
consonant vowel consonant consonant vowel
This function, printLetterKinds, takes an input String value and iterates over its characters. For each character, it considers the kind computed property for tha
Extensions add new functionality to an existing class, structure, or enumeration type. This includes the ability to extend types for which you do not have access to the original source code (known as retroactive modeling). Extensions are similar to categories in Objective-C. (Unlike Objective-C categories, Swift extensions do not have names.) Extensions in Swift can:
Add computed properties and computed static properties Define instance methods and type methods Provide new initializers Define subscripts Define and use new nested types Make an existing type conform to a protocol
NOTE If you define an extension to add new functionality to an existing type, the new functionality will be available on all existing instances of that type, even if they were created before the extension was defined.
Extension Syntax
Declare extensions with the extension keyword:
extension SomeType {
// new functionality to add to SomeType goes here
}
An extension can extend an existing type to make it adopt one or more protocols. Where this is the case, the protocol names are written in exactly the same way as for a class or structure:
extension SomeType: SomeProtocol, AnotherProtocol {
// implementation of protocol requirements goes here
}
Adding protocol conformance in this way is described in Adding Protocol Conformance with an Extension.
Computed Properties
Extensions can add computed instance properties and computed type properties to existing types. This example adds five computed instance properties to Swift’s built-in Double type, to provide basic support for working with distance units:
extension Double {
var km: Double { return self * 1_000.0 }
var m: Double { return self }
var cm: Double { return self / 100.0 }
var mm: Double { return self / 1_000.0 }
var ft: Double { return self / 3.28084 }
}
let oneInch = 25.4.mm
println("One inch is (oneInch) meters")
rints "One inch is 0.0254 meters"
threeFeet = 3.ft
("Three feet is (threeFeet) meters")
rints "Three feet is 0.914399970739201 meters"
These computed properties express that a Double value should be considered as a certain unit of length. Although they are implemented as computed properties, the names of these properties can be appended to a floating-point literal value with dot syntax, as a way to use that literal value to perform distance conversions. In this example, a Double value of 1.0 is considered to represent “one meter”. This is why the m computed property returns self—the expression 1.m is considered to calculate a Double value of 1.0. Other units require some conversion to be expressed as a value measured in meters. One
kilometer is the same as 1,000 meters, so the km computed property multiplies the value by 1_000.00 to convert into a number expressed in meters. Similarly, there are 3.28024 feet in a meter, and so the ft computed property divides the underlying Double value by 3.28024, to convert it from feet to meters. These properties are read-only computed properties, and so they are expressed without the get keyword, for brevity. Their return value is of type Double, and can be used within mathematical calculations wherever a Double is accepted:
let aMarathon = 42.km + 195.m
println("A marathon is (aMarathon) meters long")
// prints "A marathon is 42195.0 meters long"
NOTE Extensions can add new computed properties, but they cannot add stored properties, or add property observers to existing properties.
Initializers
Extensions can add new initializers to existing types. This enables you to extend other types to accept your own custom types as initializer parameters, or to provide additional initialization options that were not included as part of the type’s original implementation. Extensions can add new convenience initializers to a class, but they cannot add new designated initializers or deinitializers to a class. Designated initializers and deinitializers must always be provided by the original class implementation.
NOTE If you use an extension to add an initializer to a value type that provides default values for all of its stored properties and does not define any custom initializers, you can call the default initializer and memberwise initializer for that value type from within your extension’s initializer. This would not be the case if you had written the initializer as part of the value type’s original implementation, as described in Initializer Delegation for Value Types.
The example below defines a custom Rect structure to represent a geometric rectangle. The example also defines two supporting structures called Size and Point, both of which provide default values of 0.0 for all of their properties:
struct Size {
var width = 0.0, height = 0.0
}
struct Point {
var x = 0.0, y = 0.0
}
struct Rect {
var origin = Point()
var size = Size()
Because the Rect structure provides default values for all of its properties, it receives a default initializer and a memberwise initializer automatically, as described in Default Initializers. These initializers can be used to create new Rect instances:
let defaultRect = Rect()
let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0),
size: Size(width: 5.0, height: 5.0))
You can extend the Rect structure to provide an additional initializer that takes a specific center point and size:
extension Rect {
init(center: Point, size: Size) {
let originX = center.x - (size.width / 2)
let originY = center.y - (size.height / 2)
self.init(origin: Point(x: originX, y: originY), size: size)
}
}
This new initializer starts by calculating an appropriate origin point based on the provided center point and size value. The initializer then calls the structure’s automatic memberwise initializer init(origin:size:), which stores the new origin and size values in the appropriate properties:
let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
size: Size(width: 3.0, height: 3.0))
// centerRect's origin is (2.5, 2.5) and its size is (3.0, 3.0)
NOTE If you provide a new initializer with an extension, you are still responsible for making sure that each instance is fully initialized once the initializer completes.
Methods
Extensions can add new instance methods and type methods to existing types. The following example adds a new instance method called repetitions to the Int type:
extension Int {
func repetitions(task: () -> ()) {
for i in 0..self {
task()
}
}
}
The repetitions method takes a single argument of type () -> (), which indicates a function that has no parameters and does not return a value. After defining this extension, you can call the repetitions method on any integer number to perform a task that many number of times:
3.repetitions({
println("Hello!")
})
// Hello!
// Hello!
// Hello!
Use trailing closure syntax to make the call more succinct:
3.repetitions {
println("Goodbye!")
}
// Goodbye!
// Goodbye!
// Goodbye!
Mutating Instance Methods
Instance methods added with an extension can also modify (or mutate) the instance itself. Structure and enumeration methods that modify self or its properties must mark the instance method as mutating, just like mutating methods from an original implementation. The example below adds a new mutating method called square to Swift’s Int type, which squares the original value:
extension Int {
mutating func square() {
self = self * self
}
}
var someInt = 3
someInt.square()
// someInt is now 9
Subscripts
Extensions can add new subscripts to an existing type. This example adds an integer subscript to Swift’s built-in Int type. This subscript [n] returns the decimal digit n places in from the right of the number:
123456789[0] returns 9
…and so on:
extension Int {
subscript(digitIndex: Int) -> Int {
var decimalBase = 1
for _ in 1...digitIndex {
decimalBase *= 10
}
return (self / decimalBase) % 10
}
}
6381295[0]
eturns 5
6381295[1]
eturns 9
6381295[2]
eturns 2
6381295[8]
eturns 7
If the Int value does not have enough digits for the requested index, the subscript implementation returns 0, as if the number had been padded with zeroes to the left:
746381295[9]
// returns 0, as if you had requested:
0746381295[9]
Nested Types
Extensions can add new nested types to existing classes, structures and enumerations:
123456789[1] returns 8
extension Character {
enum Kind {
case Vowel, Consonant, Other
}
var kind: Kind {
switch String(self).lowercaseString {
case "a", "e", "i", "o", "u":
return .Vowel
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
"n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
return .Consonant
default:
return .Other
}
This example adds a new nested enumeration to Character. This enumeration, called Kind, expresses the kind of letter that a particular character represents. Specifically, it expresses whether the character is a vowel or a consonant in a standard Latin script (without taking into account accents or regional variations), or whether it is another kind of character. This example also adds a new computed instance property to Character, called kind, which returns the appropriate Kind enumeration member for that character. The nested enumeration can now be used with Character values:
func printLetterKinds(word: String) {
println("'(word)' is made up of the following kinds of letters:")
for character in word {
switch character.kind {
case .Vowel:
print("vowel ")
case .Consonant:
print("consonant ")
case .Other:
print("other ")
}
print("
")
tLetterKinds("Hello")
Hello' is made up of the following kinds of letters:
consonant vowel consonant consonant vowel
This function, printLetterKinds, takes an input String value and iterates over its characters. For each character, it considers the kind computed property for tha
0/5000
ส่วนขยายส่วนขยายเพิ่มฟังก์ชันใหม่ให้อยู่ชั้น โครงสร้าง การแจงนับชนิด ซึ่งรวมถึงความสามารถในการขยายชนิดที่คุณสามารถเข้าถึงรหัสต้นฉบับเดิมที่ (เรียกว่าโมเดลระหว่าง) ส่วนขยายจะคล้ายกับประเภทใน C. วัตถุประสงค์ (ต่างจากประเภทวัตถุประสงค์ C, Swift ส่วนขยายไม่มีชื่อ) ส่วนขยายใน Swift:เพิ่มคุณสมบัติคำนวณและคำนวณคงคุณสมบัติกำหนดวิธีการอินสแตนซ์ และพิมพ์วิธีแสดงใหม่ initializers กำหนดตัวห้อยกำหนด และใช้ชนิดซ้อนกันใหม่ให้เป็นชนิดที่มีอยู่สอดคล้องกับโพรโทคอลหมายเหตุถ้าคุณกำหนดส่วนขยายเพื่อเพิ่มฟังก์ชันใหม่เป็นชนิดที่มีอยู่ ฟังก์ชันใหม่จะพร้อมใช้ในอินสแตนซ์ที่มีอยู่ทั้งหมดของชนิด แม้ว่าพวกเขาสร้างขึ้นก่อนส่วนขยายถูกกำหนดไวยากรณ์ของส่วนขยายประกาศขยายกับคำขยาย:นามสกุล SomeType { ฟังก์ชันใหม่เพื่อเพิ่ม SomeType ที่นี่}ส่วนขยายสามารถขยายเป็นชนิดที่มีอยู่เพื่อให้นำมาใช้อย่าง น้อยหนึ่งโพรโทคอล เป็นเช่นนี้ ชื่อโพรโทคอลจะเขียนในแบบเดียวกับชั้นหรือโครงสร้าง:ต่อ SomeType: SomeProtocol, AnotherProtocol {ดำเนินการตามข้อกำหนดโพรโทคอลนี่}เพิ่มโพรโทคอความสอดคล้องกันในลักษณะนี้ถูกอธิบายเพิ่มโพรโทคอความสอดคล้องกันกับนามสกุลคุณสมบัติที่มีการคำนวณนามสกุลสามารถเพิ่มอินสแตนซ์ที่มีการคำนวณคุณสมบัติและคุณสมบัติคำนวณชนิดชนิดที่มีอยู่ ตัวอย่างนี้เพิ่ม 5 คำนวณคุณสมบัติของอินสแตนซ์ของ Swift มีคู่ชนิด เพื่อให้การสนับสนุนพื้นฐานสำหรับการทำงานกับระยะ:นามสกุล{คู่ var km: คู่ {ส่งคืนด้วยตนเอง * 1_000.0 } m: var คู่ {คืนตนเอง} ซม. var: คู่ {ส่งคืนด้วยตนเอง / 100.0 } มม. var: คู่ {ส่งคืนด้วยตนเอง / 1_000.0 } ฟุต var: คู่ {ส่งคืนด้วยตนเอง / 3.28084 }}ให้ oneInch = 25.4.mmprintln ("นิ้วหนึ่งเป็น (oneInch) เมตร")พิมพ์ "นิ้วหนึ่งเป็น 0.0254 เมตร"threeFeet =ฟุต 3("สามฟุตเป็นเมตร (threeFeet)")พิมพ์ "สามฟุตเป็นเมตร 0.914399970739201"เหล่านี้คำนวณคุณสมบัติแสดงว่าค่าคู่ควรเป็นหน่วยความยาว แม้ว่าจะมีใช้เป็นการคำนวณคุณสมบัติ ชื่อของคุณสมบัติเหล่านี้สามารถผนวกไปยังค่าสัญพจน์ทศนิยมจุดไวยากรณ์ เป็นวิธีการใช้ค่าสัญพจน์การแปลงระยะทาง ตัวอย่างนี้ พิจารณาค่าคู่ 1.0 ถึง "หนึ่งเมตร" นี่คือเหตุผลที่ m การคำนวณคุณสมบัติส่งกลับค่าตัวเอง — นิพจน์ 1.m ถือเป็นค่าคู่ของ 1.0 หน่วยอื่น ๆ ต้องใช้การแปลงบางแสดงเป็นค่าวัดเป็นเมตร หนึ่งกิโลเมตรเป็นเหมือนกับ 1000 เมตร ดังนั้น km การคำนวณคุณสมบัติคูณค่า โดย 1_000.00 แปลงเป็นตัวเลขที่แสดงในเมตร ในทำนองเดียวกัน มีเท้า 3.28024 ในเครื่องวัด และเพื่อคำนวณ ft คุณสมบัติแบ่งค่าคู่ต้น โดย 3.28024 การแปลงจากฟุตเป็นเมตร คุณสมบัติเหล่านี้มีคุณสมบัติคำนวณแบบอ่านอย่างเดียว และดังนั้น พวกเขาจะแสดง โดยคำสำคัญได้ กระชับ ค่าที่ส่งคืนของพวกเขาเป็นคู่ และสามารถใช้ในการคำนวณทางคณิตศาสตร์ทุกคู่เป็นที่ยอมรับ:ให้ aMarathon = 195.m + 42. kmprintln ("แบบมาราธอนคือ (aMarathon) เมตร")พิมพ์ "มาราธอนเป็น 42195.0 เมตร"หมายเหตุนามสกุลสามารถเพิ่มคุณสมบัติใหม่คำนวณ แต่พวกเขาไม่สามารถเพิ่มคุณสมบัติเก็บไว้ หรือผู้สังเกตการณ์คุณสมบัติเพิ่มคุณสมบัติที่มีอยู่Initializersนามสกุลสามารถเพิ่ม initializers ใหม่ชนิดที่มีอยู่ นี้ช่วยให้คุณสามารถขยายชนิดอื่น ๆ ให้ยอมรับชนิดกำหนดเองของคุณเองเป็นพารามิเตอร์ตัว หรือให้เพิ่มเติมเริ่มต้นตัวเลือกที่ไม่รวมเป็นส่วนหนึ่งของงานต้นฉบับของชนิด ส่วนขยายสามารถเพิ่มใหม่ผ่อน initializers คลา แต่พวกเขาไม่สามารถเพิ่ม initializers กำหนดใหม่หรือ deinitializers เป็น กำหนด initializers และ deinitializers ต้องเสมอให้ใช้คลาสเดิมหมายเหตุถ้าคุณใช้ส่วนขยายเพื่อเพิ่มตัวเป็นชนิดค่าที่ค่าเริ่มต้นสำหรับคุณสมบัติเก็บไว้ทั้งหมด และกำหนด initializers ใด ๆ เอง คุณสามารถเรียกตัวเริ่มและตัว memberwise สำหรับชนิดค่าจากภายในตัวของส่วนขยายของคุณ นี้จะไม่เป็นกรณีคุณได้เขียนตัวที่เป็นส่วนหนึ่งของงานต้นฉบับของชนิดค่า ตามที่อธิบายไว้ในการมอบหมายตัวเริ่มต้นสำหรับชนิดของค่าตัวอย่างด้านล่างกำหนดโครงสร้าง Rect เองถึงสี่เหลี่ยมเรขาคณิต ตัวอย่างกำหนดสองสนับสนุนโครงสร้างขนาดและจุด ซึ่งทั้งสองให้ค่าเริ่มต้นของ 0.0 ของคุณสมบัติ:struct {ขนาด ความกว้างของ var = 0.0 ความสูง = 0.0}struct {จุด var x = 0.0, y = 0.0}struct Rect { จุดเริ่มต้นของ var = Point() ขนาด var = Size()เนื่องจากโครงสร้าง Rect ให้ค่าเริ่มต้นสำหรับคุณสมบัติทั้งหมด ได้รับเป็นตัวเริ่มและตัว memberwise โดยอัตโนมัติ ตามที่อธิบายไว้ใน Initializers Initializers เหล่านี้สามารถใช้เพื่อสร้างอินสแตนซ์ใหม่ Rect:ให้ defaultRect = Rect()ให้ memberwiseRect = Rect (ต้นกำเนิด: จุด (x: 2.0, y: 2.0), ขนาด: ขนาด (ความกว้าง: ความสูง 5.0 : 5.0))คุณสามารถขยายโครงสร้าง Rect เพื่อให้เป็นตัวเพิ่มเติมที่ศูนย์เฉพาะจุดและขนาด:นามสกุล Rect { เริ่มต้น (ศูนย์: จุด ขนาด: ขนาด) { ให้ originX = center.x - (size.width / 2) ให้ originY = center.y - (size.height / 2) self.init (ต้นกำเนิด: จุด (x: originX, y: originY), ขนาด: ขนาด) }}ตัวใหม่นี้เริ่มจากการคำนวณเป็นจุดกำเนิดที่เหมาะสมตามศูนย์ให้มาจุดและขนาดค่า ตัวที่แล้วเรียกของโครงสร้างตัวอัตโนมัติ memberwise init(origin:size:) ที่เก็บค่าของจุดเริ่มต้นและขนาดที่ใหม่ในคุณสมบัติที่เหมาะสม:ให้ centerRect = Rect (ศูนย์: จุด (x: 4.0, y: 4.0), ขนาด: ขนาด (ความกว้าง: ความสูง 3.0 : 3.0))เป็นจุดเริ่มต้นของ centerRect (2.5, 2.5) และขนาด (3.0, 3.0)หมายเหตุถ้าคุณมีตัวใหม่ส่วนขยาย คุณจะยังคงรับผิดชอบในการตรวจสอบว่า แต่ละอินสแตนซ์ได้ทั้งหมดเริ่มต้นเมื่อเสร็จสิ้นการตัววิธีการส่วนขยายสามารถเพิ่มวิธีการอินสแตนซ์ใหม่ และพิมพ์วิธีการชนิดที่มีอยู่ การเพิ่มวิธีการอินสแตนซ์ใหม่เรียกว่าการทำซ้ำชนิด Int:นามสกุล Int { func repetitions(task: () -> {()) หาใน 0..self { task() } }}ใช้วิธีทำซ้ำอาร์กิวเมนต์หนึ่งของชนิด() -> (), ซึ่งบ่งชี้ว่า ฟังก์ชันที่คืนค่า และพารามิเตอร์ไม่ หลังจากกำหนดส่วนขยายนี้ คุณสามารถเรียกวิธีการทำซ้ำบนจำนวนเต็มใดก็จะทำงานให้จำนวนครั้ง:3.repetitions({ println("Hello!") })สวัสดี!สวัสดี!สวัสดี!ใช้ไวยากรณ์ปิดต่อท้ายจะทำการโทรที่รวบรัดมากขึ้น:3.ทำซ้ำ{ println("Goodbye!")}ลาก่อนลาก่อนลาก่อนMutating วิธีการอินสแตนซ์วิธีการอินสแตนซ์เพิ่ม ด้วยส่วนขยายสามารถยังแก้ไข (หรือผ่าเหล่า) อินสแตนซ์ของตัวเอง วิธีการแจงนับและโครงสร้างที่ปรับเปลี่ยนตัวเองหรือคุณสมบัติต้องทำเครื่องหมายวิธีการอินสแตนซ์เป็น mutating เช่น mutating วิธีการจากการปฏิบัติเดิม ตัวอย่างด้านล่างเพิ่มวิธีการ mutating ใหม่ที่เรียกว่าสี่เหลี่ยมของ Swift Int ชนิด ที่สี่เหลี่ยมค่าต้นฉบับ:นามสกุล Int { mutating func square() { ตนเอง =ตัวเอง * ด้วยตนเอง }}var someInt = 3someInt.square()someInt เป็น 9ตัวห้อยนามสกุลสามารถเพิ่มตัวห้อยใหม่เป็นชนิดที่มีอยู่ ตัวอย่างนี้เพิ่มตัวห้อยเป็นเลขจำนวนเต็มชนิด Int มี Swift ตัวห้อยนี้ [n] ส่งกลับตัวเลขทศนิยม n ตำแหน่งในจากด้านขวาของหมายเลข:9 คืน 123456789 [0]... และเรื่อย ๆ:นามสกุล Int { subscript(digitIndex: Int) -> Int { var decimalBase = 1 นาน 1... digitIndex { decimalBase * = 10 } กลับ (ตนเอง / decimalBase) % 10 }}6381295 [0]eturns 56381295 [1]eturns 96381295 [2]eturns 26381295 [8]eturns 7ถ้าค่า Int ไม่มีหลักเพียงพอสำหรับดัชนีร้องขอ ใช้ตัวห้อยส่งกลับ 0 เช่นถ้าหมายเลขมีการเบาะกับศูนย์ไปทางซ้าย:746381295 [9]ส่งกลับค่า 0 เป็นถ้าคุณได้ร้องขอ:0746381295 [9]ชนิดซ้อนกันนามสกุลสามารถเพิ่มชนิดใหม่ซ้อนอยู่ชั้น โครงสร้าง และระบุหมายเลข:8 คืน 123456789 [1]นามสกุล{อักขระ enum {ประเภท กรณีสระ พยัญชนะ อื่น ๆ } var ชนิด: {ประเภท สลับสาย (ตนเอง) {.lowercaseString กรณี "a", "e" "เรา" "o", "u": กลับ สระ กรณี "b", "c", "d", "f", "g", "h" "เจ" "k", "l", "m""n", "p" "คิว" "r", "s", "t", "v", "w", "x", "y", "z": กลับ พยัญชนะเริ่มต้น: กลับ อื่น ๆ }ตัวอย่างนี้เพิ่มการแจงนับซ้อนใหม่ลงอักขระ การแจงนับนี้ เรียกว่าชนิด แสดงชนิดของตัวอักษรที่ใช้แสดงแทนอักขระหนึ่ง ๆ โดยเฉพาะ ก็แสดงว่าตัวละครเป็นสระหรือพยัญชนะในสคริปต์ละตินพิมพ์ใหญ่มาตรฐาน (โดยไม่พิจารณาบัญชีเน้นหรือรูปแบบภูมิภาค), หรือไม่ว่าจะเป็นอักขระชนิดอื่น ตัวอย่างนี้ยังเพิ่มคุณสมบัติใหม่ที่มีการคำนวณอย่างลงอักขระ ชนิด ซึ่งส่งกลับสมาชิกแจงนับชนิดที่เหมาะสมสำหรับอักขระที่ เรียกว่า การแจงนับซ้อนกันสามารถใช้ได้กับอักขระค่าตอนนี้:func printLetterKinds(word: String) { println("'(word)' ขึ้นเป็นชนิดของตัวอักษรต่อไปนี้: ") สำหรับอักขระในคำ{ สลับ character.kind { กรณี สระ: พิมพ์ ("สระ") กรณี พยัญชนะ: พิมพ์ ("พยัญชนะ") กรณี อื่น ๆ: พิมพ์ ("อื่นๆ") }print("
")tLetterKinds("Hello")สวัสดี ' ของชนิดของตัวอักษรต่อไปนี้:สระพยัญชนะพยัญชนะพยัญชนะสระฟังก์ชันนี้ printLetterKinds ใช้ค่าสตริงที่ป้อนข้อมูล และคำนวณซ้ำช่วงของอักขระ สำหรับแต่ละอักขระ พิจารณาคุณสมบัติที่มีการคำนวณประเภทสำหรับท่า
")tLetterKinds("Hello")สวัสดี ' ของชนิดของตัวอักษรต่อไปนี้:สระพยัญชนะพยัญชนะพยัญชนะสระฟังก์ชันนี้ printLetterKinds ใช้ค่าสตริงที่ป้อนข้อมูล และคำนวณซ้ำช่วงของอักขระ สำหรับแต่ละอักขระ พิจารณาคุณสมบัติที่มีการคำนวณประเภทสำหรับท่า
การแปล กรุณารอสักครู่..
ส่วนขยาย
ส่วนขยายเพิ่มฟังก์ชันการทำงานใหม่ที่จะมีอยู่ในระดับโครงสร้างหรือประเภทการแจงนับ ซึ่งรวมถึงความสามารถในการขยายประเภทที่คุณไม่ได้มีการเข้าถึงแหล่งรหัสเดิม (เรียกว่าการสร้างแบบจำลองย้อนหลัง) ส่วนต่อขยายที่มีความคล้ายคลึงกับประเภทในวัตถุประสงค์ -C (ซึ่งแตกต่างจากวัตถุประสงค์ -C ประเภทนามสกุลสวิฟท์ไม่ได้มีชื่อ.) ส่วนขยายในสวิฟท์สามารถ: เพิ่มคุณสมบัติการคำนวณและการคำนวณคุณสมบัติคงที่กำหนดวิธีการและวิธีการเช่นประเภทใหม่ให้ initializers กำหนดห้อยกำหนดและใช้ชนิดที่ซ้อนกันใหม่ให้ชนิดที่มีอยู่ให้สอดคล้องกับ โปรโตคอลหมายเหตุหากคุณกำหนดขยายเพิ่มฟังก์ชันการทำงานใหม่ในการพิมพ์ที่มีอยู่การทำงานใหม่จะสามารถใช้ได้ในกรณีที่มีอยู่ทั้งหมดของประเภทนั้นถึงแม้ว่าพวกเขาถูกสร้างขึ้นก่อนที่จะขยายกำหนด. ขยายไวยากรณ์ประกาศนามสกุลกับคำขยาย : ขยาย SomeType { // ฟังก์ชันการทำงานใหม่ที่จะเพิ่ม SomeType ที่นี่} ขยายสามารถขยายประเภทมีอยู่เพื่อให้นำมาใช้โปรโตคอลหนึ่งหรือมากกว่า ในกรณีที่เป็นกรณีนี้ชื่อโปรโตคอลที่เขียนในตรงทางเช่นเดียวกับชั้นหรือโครงสร้าง: ขยาย SomeType: SomeProtocol, AnotherProtocol { // ดำเนินการตามข้อกำหนดโปรโตคอลที่นี่} เพิ่มโปรโตคอลสอดคล้องในลักษณะนี้อธิบายไว้ในพิธีสารเพิ่ม สอดคล้องกับการขยาย. คุณสมบัติของคอมพิวเตอร์ส่วนขยายสามารถเพิ่มคุณสมบัติเช่นการคำนวณและคุณสมบัติประเภทคำนวณประเภทที่มีอยู่ ตัวอย่างนี้เพิ่มห้าคุณสมบัติเช่นการคำนวณสวิฟท์ในตัวประเภทคู่จะให้การสนับสนุนขั้นพื้นฐานสำหรับการทำงานร่วมกับหน่วยระยะทาง: ขยายคู่ { var กม.: Double {กลับตัวเอง * 1_000.0} var เมตร: Double {} กลับตนเองvar ซม. : Double {กลับตนเอง / 100.0} var มม: Double {ผลตอบแทนตัวเอง / 1_000.0} var ฟุต: Double {กลับตนเอง / 3.28084} } ให้ oneInch = 25.4.mm println ("หนึ่งนิ้ว (oneInch) เมตร") rints "หนึ่งนิ้ว 0.0254 เมตร" threeFeet = 3.ft ("สามฟุตคือ (threeFeet) เมตร") rints "สามฟุต .914399970739201 เมตร" คุณสมบัติเหล่านี้แสดงคำนวณว่าค่าคู่ควรได้รับการพิจารณาเป็นหน่วยหนึ่งของความยาว . แม้ว่าพวกเขาจะนำมาใช้เป็นคุณสมบัติคำนวณชื่อของคุณสมบัติเหล่านี้สามารถผนวกเข้ากับจุดลอยมูลค่าที่แท้จริงกับไวยากรณ์จุดเป็นวิธีการใช้ว่ามูลค่าที่แท้จริงเพื่อดำเนินการแปลงระยะทาง ในตัวอย่างนี้คู่มูลค่า 1.0 ถือว่าเป็นตัวแทนของ "หนึ่งเมตร" นี่คือเหตุผลที่สถานที่ให้บริการมวณผลตอบแทนที่ตัวเอง 1.m แสดงออกมีการพิจารณาในการคำนวณค่าคู่ 1.0 หน่วยงานอื่น ๆ จำเป็นต้องมีการแปลงบางอย่างที่จะแสดงเป็นค่าที่วัดเป็นเมตร หนึ่งกิโลเมตรเป็นเช่นเดียวกับ 1,000 เมตรดังนั้นกมคำนวณทรัพย์สินคูณค่าโดย 1_000.00 แปลงเป็นตัวเลขที่แสดงออกในเมตร ในทำนองเดียวกันมี 3.28024 ฟุตเมตรและฟุตคำนวณแบ่งทรัพย์สินมูลค่าพื้นฐานโดยคู่ 3.28024 การแปลงจากเท้าเมตร คุณสมบัติเหล่านี้จะถูกอ่านอย่างเดียวคุณสมบัติคำนวณและเพื่อพวกเขาจะแสดงคำหลักโดยไม่ต้องได้รับสำหรับระยะเวลาสั้น ๆ ค่าตอบแทนของพวกเขาเป็นประเภทคู่และสามารถนำมาใช้ในการคำนวณทางคณิตศาสตร์ที่ใดก็ตามที่คู่เป็นที่ยอมรับ: ให้ aMarathon = 42.km + 195.m println ("มาราธอนคือ (aMarathon) เมตรยาว") // พิมพ์ " การวิ่งมาราธอนเป็น 42,195.0 เมตรยาว " ส่วนขยายหมายเหตุสามารถเพิ่มคุณสมบัติการคำนวณใหม่ แต่พวกเขาไม่สามารถเพิ่มคุณสมบัติเก็บไว้หรือเพิ่มสถานที่ให้บริการผู้สังเกตการณ์คุณสมบัติที่มีอยู่. Initializers สามารถเพิ่มขยาย initializers ใหม่ประเภทที่มีอยู่ ซึ่งจะช่วยให้คุณสามารถขยายประเภทอื่น ๆ ที่จะยอมรับประเภทที่กำหนดเองของคุณเองเป็นพารามิเตอร์ initializer หรือเพื่อให้ตัวเลือกเริ่มต้นเพิ่มเติมที่ไม่ได้ถูกรวมเป็นส่วนหนึ่งของการดำเนินงานเดิมของประเภท ส่วนต่อขยายที่สามารถเพิ่มความสะดวกสบาย initializers ใหม่ในชั้นเรียน แต่พวกเขาไม่สามารถเพิ่ม initializers กำหนดใหม่หรือ deinitializers ในชั้นเรียน ได้รับการออกแบบและ initializers deinitializers จะต้องให้เสมอโดยการดำเนินการระดับเดิม. หมายเหตุถ้าคุณใช้ส่วนขยายที่จะเพิ่มการเริ่มต้นที่จะพิมพ์ค่าที่ให้ค่าเริ่มต้นสำหรับคุณสมบัติทั้งหมดที่เก็บไว้และไม่ได้กำหนด initializers กำหนดเองใด ๆ คุณสามารถเรียก เริ่มต้นการเริ่มต้นและการเริ่มต้น memberwise สำหรับประเภทค่าที่จากภายใน initializer นามสกุลของคุณ นี้จะไม่เป็นกรณีที่ถ้าคุณได้เขียน initializer เป็นส่วนหนึ่งของการดำเนินงานเดิมของประเภทค่าตามที่อธิบายไว้ในคณะผู้แทน Initializer สำหรับประเภทค่า. ตัวอย่างด้านล่างกำหนดโครงสร้าง Rect ที่กำหนดเองที่จะเป็นตัวแทนสี่เหลี่ยมเรขาคณิต ตัวอย่างที่สองนอกจากนี้ยังกำหนดโครงสร้างการสนับสนุนที่เรียกว่าขนาดและจุดซึ่งทั้งสองให้ค่าเริ่มต้นของ 0.0 สำหรับทุกคุณสมบัติของพวกเขาขนาด struct { var = ความกว้าง 0.0 สูง = 0.0 } จุด struct { var x = 0.0, y = 0.0 } Rect struct { var กำเนิด = Point () ขนาด var = ขนาด () เนื่องจากโครงสร้าง Rect ให้ค่าเริ่มต้นทั้งหมดของคุณสมบัติของมันได้รับการเริ่มต้นค่าเริ่มต้นและ initializer memberwise โดยอัตโนมัติตามที่อธิบายไว้ในการเริ่มต้น Initializers initializers เหล่านี้สามารถใช้ในการสร้างอินสแตนซ์ Rect ใหม่ให้ defaultRect = Rect () ให้ memberwiseRect = Rect (แหล่งที่มา: จุด (x: 2.0, y: 2.0) ขนาด: ขนาด (กว้าง: 5.0 สูง 5.0)) คุณสามารถ ขยายโครงสร้าง Rect เพื่อให้ initializer เพิ่มเติมที่จะเป็นจุดศูนย์ที่เฉพาะเจาะจงและขนาดขยาย Rect { init (กลาง: จุดขนาด: ขนาด) { ให้ originX = center.x - (size.width / 2) ให้ศูนย์ originY = .y - (size.height / 2) self.init (แหล่งที่มา: จุด (x: originX, y: originY) ขนาด: ขนาด) } } initializer ใหม่นี้จะเริ่มต้นโดยการคำนวณจุดกำเนิดที่เหมาะสมขึ้นอยู่กับจุดกึ่งกลางให้และ ค่าขนาด initializer แล้วเรียก memberwise อัตโนมัติโครงสร้าง initializer init (แหล่งที่มา: ขนาด :) ที่เก็บที่มาใหม่และค่าขนาดในคุณสมบัติที่เหมาะสม: ให้ centerRect = Rect (กลาง: จุด (x: 4.0, y: 4.0) ขนาด: ขนาด (กว้าง 3.0 สูง 3.0)) // กำเนิด centerRect คือ (2.5, 2.5) และขนาดของมันคือ (3.0, 3.0) หมายเหตุถ้าคุณให้การเริ่มต้นใหม่ที่มีนามสกุลคุณยังคงรับผิดชอบในการทำให้แน่ใจว่าแต่ละ เช่นจะเริ่มต้นได้อย่างเต็มที่ครั้งเดียว initializer เสร็จสมบูรณ์. วิธีการสามารถเพิ่มขยายตัวอย่างวิธีการใหม่และวิธีการประเภทประเภทที่มีอยู่ ตัวอย่างต่อไปนี้เพิ่มวิธีการเช่นใหม่ที่เรียกว่าการเกิดซ้ำประเภท Int: Int ขยาย { ซ้ำบำบัด (งาน: () -> ()) { สำหรับฉันใน 0..self { งาน () } } } วิธีการใช้ซ้ำ อาร์กิวเมนต์เดียวประเภท () -> () ซึ่งบ่งชี้ว่าฟังก์ชั่นที่มีพารามิเตอร์และไม่คืนค่า หลังจากการกำหนดส่วนขยายนี้คุณสามารถเรียกวิธีการซ้ำกับจำนวนจำนวนเต็มใด ๆ ที่จะดำเนินการงานที่จำนวนหลายครั้ง: 3.repetitions ({ println ("Hello!") }) // Hello! // Hello! // สวัสดี ! ใช้ไวยากรณ์ปิดท้ายโทรรวบรัดเพิ่มเติมได้ที่: 3.repetitions { println ("ลาก่อน!") } // ลาก่อน! // ลาก่อน! // ลาก่อน! กรรมวิธีตัวอย่างวิธีการวิธีการเพิ่มอินสแตนซ์ที่มีนามสกุลยังสามารถปรับเปลี่ยน (หรือ กลายพันธุ์) เช่นตัวเอง โครงสร้างและวิธีการแจงนับที่ปรับเปลี่ยนตนเองหรือคุณสมบัติของมันจะต้องทำเครื่องหมายวิธีการเช่นเป็นกรรมวิธีเช่นเดียวกับวิธีการจากกรรมวิธีการดำเนินงานเดิม ตัวอย่างด้านล่างเพิ่ม mutating วิธีใหม่ที่เรียกว่าตารางประเภท Int สวิฟท์ซึ่งสี่เหลี่ยมค่าเดิม: Int ขยาย { กรรมวิธีบำบัดตาราง () { ตัวเองตัวเอง = * ตนเอง} } var someInt = 3 someInt.square () // someInt คือ ตอนนี้ 9 ห้อยสามารถเพิ่มส่วนขยายใหม่ที่จะห้อยประเภทที่มีอยู่ ตัวอย่างนี้เพิ่มห้อยจำนวนเต็มสวิฟท์ในตัวชนิด Int ห้อยนี้ [n] จะแสดงสถานที่ n ทศนิยมหลักมาจากด้านขวาของหมายเลข: 123456789 [0] ผลตอบแทนที่ 9 ... และอื่น ๆ : Int ขยาย { ห้อย (digitIndex: Int) -> Int { var decimalBase = 1 สำหรับ _ ใน 1 ... digitIndex { decimalBase * = 10 } ผลตอบแทน (ตัวเอง / decimalBase) 10% } } 6381295 [0] eturns 5 6381295 [1] eturns 9 6381295 [2] eturns 2 6381295 [8] eturns 7 ถ้าค่า Int ไม่ ไม่ได้มีมากพอสำหรับตัวเลขดัชนีที่ร้องขอการดำเนินห้อยกลับ 0 เช่นถ้าตัวเลขที่ได้รับการเบาะที่มีเลขศูนย์ไปทางซ้าย: 746381295 [9] // กลับ 0 เช่นถ้าคุณได้รับการร้องขอ: 0746381295 [9] ซ้อนประเภทส่วนขยาย สามารถเพิ่มประเภทที่ซ้อนกันใหม่ในการเรียนที่มีอยู่โครงสร้างและ enumerations: 123456789 [1] ผลตอบแทนที่ 8 ขยายตัวละคร { {enum ชนิดกรณีสระพยัญชนะ, อื่น ๆ} var ชนิด: ชนิด { สลับสตริง (ตัวเอง) .lowercaseString { กรณี "" "อี", "ฉัน", "o", "ยู": กลับ .Vowel กรณี "ข", "ค", "D", "F", "g", "เอช", "เจ", "k "," ลิตร "," m ", "n", "พี", "คิว", "อาร์", "S", "ที", "โวลต์", "W", "x", "Y" "Z": กลับ .Consonant ค่าเริ่มต้น: กลับอื่นใน} ตัวอย่างนี้จะเพิ่มการแจงนับที่ซ้อนกันใหม่เพื่อตัวละคร นับนี้เรียกว่าชนิดเป็นการแสดงออกถึงชนิดของตัวอักษรที่แสดงให้เห็นถึงตัวละครโดยเฉพาะอย่างยิ่ง โดยเฉพาะมันเป็นการแสดงออกถึงตัวละครไม่ว่าจะเป็นสระหรือพยัญชนะในสคริปต์ภาษาละตินมาตรฐาน (โดยไม่คำนึงถึงสำเนียงบัญชีหรือเปลี่ยนแปลงในระดับภูมิภาค) หรือไม่ว่าจะเป็นชนิดของตัวอักษรอีก ตัวอย่างนี้ยังเพิ่มคุณสมบัติเช่นการคำนวณใหม่เพื่อตัวละครที่เรียกว่าชนิดซึ่งผลตอบแทนสมาชิกนับชนิดที่เหมาะสมสำหรับตัวละครที่ แจงนับที่ซ้อนกันในขณะนี้สามารถใช้กับค่าตัวอักษร: บำบัด printLetterKinds (คำ: String) { println (" (คำ) 'ถูกสร้างขึ้นจากชนิดของตัวอักษรต่อไปนี้:") สำหรับตัวละครในคำ { {character.kind สวิทช์กรณี .Vowel: การพิมพ์ ("สระ") กรณี .Consonant: การพิมพ์ ("พยัญชนะ") กรณีอื่นใน: การพิมพ์ ("อื่น ๆ ") } พิมพ์ (" n") tLetterKinds ("สวัสดี") สวัสดี 'ถูกสร้างขึ้นจาก ชนิดของตัวอักษรต่อไปนี้: พยัญชนะสระพยัญชนะสระพยัญชนะฟังก์ชั่นนี้ printLetterKinds ใช้การป้อนค่าสายอักขระและ iterates มากกว่าตัวละคร สำหรับตัวละครแต่ละตัวจะมีการพิจารณาสถานที่ให้บริการสำหรับการคำนวณชนิด tha
ส่วนขยายเพิ่มฟังก์ชันการทำงานใหม่ที่จะมีอยู่ในระดับโครงสร้างหรือประเภทการแจงนับ ซึ่งรวมถึงความสามารถในการขยายประเภทที่คุณไม่ได้มีการเข้าถึงแหล่งรหัสเดิม (เรียกว่าการสร้างแบบจำลองย้อนหลัง) ส่วนต่อขยายที่มีความคล้ายคลึงกับประเภทในวัตถุประสงค์ -C (ซึ่งแตกต่างจากวัตถุประสงค์ -C ประเภทนามสกุลสวิฟท์ไม่ได้มีชื่อ.) ส่วนขยายในสวิฟท์สามารถ: เพิ่มคุณสมบัติการคำนวณและการคำนวณคุณสมบัติคงที่กำหนดวิธีการและวิธีการเช่นประเภทใหม่ให้ initializers กำหนดห้อยกำหนดและใช้ชนิดที่ซ้อนกันใหม่ให้ชนิดที่มีอยู่ให้สอดคล้องกับ โปรโตคอลหมายเหตุหากคุณกำหนดขยายเพิ่มฟังก์ชันการทำงานใหม่ในการพิมพ์ที่มีอยู่การทำงานใหม่จะสามารถใช้ได้ในกรณีที่มีอยู่ทั้งหมดของประเภทนั้นถึงแม้ว่าพวกเขาถูกสร้างขึ้นก่อนที่จะขยายกำหนด. ขยายไวยากรณ์ประกาศนามสกุลกับคำขยาย : ขยาย SomeType { // ฟังก์ชันการทำงานใหม่ที่จะเพิ่ม SomeType ที่นี่} ขยายสามารถขยายประเภทมีอยู่เพื่อให้นำมาใช้โปรโตคอลหนึ่งหรือมากกว่า ในกรณีที่เป็นกรณีนี้ชื่อโปรโตคอลที่เขียนในตรงทางเช่นเดียวกับชั้นหรือโครงสร้าง: ขยาย SomeType: SomeProtocol, AnotherProtocol { // ดำเนินการตามข้อกำหนดโปรโตคอลที่นี่} เพิ่มโปรโตคอลสอดคล้องในลักษณะนี้อธิบายไว้ในพิธีสารเพิ่ม สอดคล้องกับการขยาย. คุณสมบัติของคอมพิวเตอร์ส่วนขยายสามารถเพิ่มคุณสมบัติเช่นการคำนวณและคุณสมบัติประเภทคำนวณประเภทที่มีอยู่ ตัวอย่างนี้เพิ่มห้าคุณสมบัติเช่นการคำนวณสวิฟท์ในตัวประเภทคู่จะให้การสนับสนุนขั้นพื้นฐานสำหรับการทำงานร่วมกับหน่วยระยะทาง: ขยายคู่ { var กม.: Double {กลับตัวเอง * 1_000.0} var เมตร: Double {} กลับตนเองvar ซม. : Double {กลับตนเอง / 100.0} var มม: Double {ผลตอบแทนตัวเอง / 1_000.0} var ฟุต: Double {กลับตนเอง / 3.28084} } ให้ oneInch = 25.4.mm println ("หนึ่งนิ้ว (oneInch) เมตร") rints "หนึ่งนิ้ว 0.0254 เมตร" threeFeet = 3.ft ("สามฟุตคือ (threeFeet) เมตร") rints "สามฟุต .914399970739201 เมตร" คุณสมบัติเหล่านี้แสดงคำนวณว่าค่าคู่ควรได้รับการพิจารณาเป็นหน่วยหนึ่งของความยาว . แม้ว่าพวกเขาจะนำมาใช้เป็นคุณสมบัติคำนวณชื่อของคุณสมบัติเหล่านี้สามารถผนวกเข้ากับจุดลอยมูลค่าที่แท้จริงกับไวยากรณ์จุดเป็นวิธีการใช้ว่ามูลค่าที่แท้จริงเพื่อดำเนินการแปลงระยะทาง ในตัวอย่างนี้คู่มูลค่า 1.0 ถือว่าเป็นตัวแทนของ "หนึ่งเมตร" นี่คือเหตุผลที่สถานที่ให้บริการมวณผลตอบแทนที่ตัวเอง 1.m แสดงออกมีการพิจารณาในการคำนวณค่าคู่ 1.0 หน่วยงานอื่น ๆ จำเป็นต้องมีการแปลงบางอย่างที่จะแสดงเป็นค่าที่วัดเป็นเมตร หนึ่งกิโลเมตรเป็นเช่นเดียวกับ 1,000 เมตรดังนั้นกมคำนวณทรัพย์สินคูณค่าโดย 1_000.00 แปลงเป็นตัวเลขที่แสดงออกในเมตร ในทำนองเดียวกันมี 3.28024 ฟุตเมตรและฟุตคำนวณแบ่งทรัพย์สินมูลค่าพื้นฐานโดยคู่ 3.28024 การแปลงจากเท้าเมตร คุณสมบัติเหล่านี้จะถูกอ่านอย่างเดียวคุณสมบัติคำนวณและเพื่อพวกเขาจะแสดงคำหลักโดยไม่ต้องได้รับสำหรับระยะเวลาสั้น ๆ ค่าตอบแทนของพวกเขาเป็นประเภทคู่และสามารถนำมาใช้ในการคำนวณทางคณิตศาสตร์ที่ใดก็ตามที่คู่เป็นที่ยอมรับ: ให้ aMarathon = 42.km + 195.m println ("มาราธอนคือ (aMarathon) เมตรยาว") // พิมพ์ " การวิ่งมาราธอนเป็น 42,195.0 เมตรยาว " ส่วนขยายหมายเหตุสามารถเพิ่มคุณสมบัติการคำนวณใหม่ แต่พวกเขาไม่สามารถเพิ่มคุณสมบัติเก็บไว้หรือเพิ่มสถานที่ให้บริการผู้สังเกตการณ์คุณสมบัติที่มีอยู่. Initializers สามารถเพิ่มขยาย initializers ใหม่ประเภทที่มีอยู่ ซึ่งจะช่วยให้คุณสามารถขยายประเภทอื่น ๆ ที่จะยอมรับประเภทที่กำหนดเองของคุณเองเป็นพารามิเตอร์ initializer หรือเพื่อให้ตัวเลือกเริ่มต้นเพิ่มเติมที่ไม่ได้ถูกรวมเป็นส่วนหนึ่งของการดำเนินงานเดิมของประเภท ส่วนต่อขยายที่สามารถเพิ่มความสะดวกสบาย initializers ใหม่ในชั้นเรียน แต่พวกเขาไม่สามารถเพิ่ม initializers กำหนดใหม่หรือ deinitializers ในชั้นเรียน ได้รับการออกแบบและ initializers deinitializers จะต้องให้เสมอโดยการดำเนินการระดับเดิม. หมายเหตุถ้าคุณใช้ส่วนขยายที่จะเพิ่มการเริ่มต้นที่จะพิมพ์ค่าที่ให้ค่าเริ่มต้นสำหรับคุณสมบัติทั้งหมดที่เก็บไว้และไม่ได้กำหนด initializers กำหนดเองใด ๆ คุณสามารถเรียก เริ่มต้นการเริ่มต้นและการเริ่มต้น memberwise สำหรับประเภทค่าที่จากภายใน initializer นามสกุลของคุณ นี้จะไม่เป็นกรณีที่ถ้าคุณได้เขียน initializer เป็นส่วนหนึ่งของการดำเนินงานเดิมของประเภทค่าตามที่อธิบายไว้ในคณะผู้แทน Initializer สำหรับประเภทค่า. ตัวอย่างด้านล่างกำหนดโครงสร้าง Rect ที่กำหนดเองที่จะเป็นตัวแทนสี่เหลี่ยมเรขาคณิต ตัวอย่างที่สองนอกจากนี้ยังกำหนดโครงสร้างการสนับสนุนที่เรียกว่าขนาดและจุดซึ่งทั้งสองให้ค่าเริ่มต้นของ 0.0 สำหรับทุกคุณสมบัติของพวกเขาขนาด struct { var = ความกว้าง 0.0 สูง = 0.0 } จุด struct { var x = 0.0, y = 0.0 } Rect struct { var กำเนิด = Point () ขนาด var = ขนาด () เนื่องจากโครงสร้าง Rect ให้ค่าเริ่มต้นทั้งหมดของคุณสมบัติของมันได้รับการเริ่มต้นค่าเริ่มต้นและ initializer memberwise โดยอัตโนมัติตามที่อธิบายไว้ในการเริ่มต้น Initializers initializers เหล่านี้สามารถใช้ในการสร้างอินสแตนซ์ Rect ใหม่ให้ defaultRect = Rect () ให้ memberwiseRect = Rect (แหล่งที่มา: จุด (x: 2.0, y: 2.0) ขนาด: ขนาด (กว้าง: 5.0 สูง 5.0)) คุณสามารถ ขยายโครงสร้าง Rect เพื่อให้ initializer เพิ่มเติมที่จะเป็นจุดศูนย์ที่เฉพาะเจาะจงและขนาดขยาย Rect { init (กลาง: จุดขนาด: ขนาด) { ให้ originX = center.x - (size.width / 2) ให้ศูนย์ originY = .y - (size.height / 2) self.init (แหล่งที่มา: จุด (x: originX, y: originY) ขนาด: ขนาด) } } initializer ใหม่นี้จะเริ่มต้นโดยการคำนวณจุดกำเนิดที่เหมาะสมขึ้นอยู่กับจุดกึ่งกลางให้และ ค่าขนาด initializer แล้วเรียก memberwise อัตโนมัติโครงสร้าง initializer init (แหล่งที่มา: ขนาด :) ที่เก็บที่มาใหม่และค่าขนาดในคุณสมบัติที่เหมาะสม: ให้ centerRect = Rect (กลาง: จุด (x: 4.0, y: 4.0) ขนาด: ขนาด (กว้าง 3.0 สูง 3.0)) // กำเนิด centerRect คือ (2.5, 2.5) และขนาดของมันคือ (3.0, 3.0) หมายเหตุถ้าคุณให้การเริ่มต้นใหม่ที่มีนามสกุลคุณยังคงรับผิดชอบในการทำให้แน่ใจว่าแต่ละ เช่นจะเริ่มต้นได้อย่างเต็มที่ครั้งเดียว initializer เสร็จสมบูรณ์. วิธีการสามารถเพิ่มขยายตัวอย่างวิธีการใหม่และวิธีการประเภทประเภทที่มีอยู่ ตัวอย่างต่อไปนี้เพิ่มวิธีการเช่นใหม่ที่เรียกว่าการเกิดซ้ำประเภท Int: Int ขยาย { ซ้ำบำบัด (งาน: () -> ()) { สำหรับฉันใน 0..self { งาน () } } } วิธีการใช้ซ้ำ อาร์กิวเมนต์เดียวประเภท () -> () ซึ่งบ่งชี้ว่าฟังก์ชั่นที่มีพารามิเตอร์และไม่คืนค่า หลังจากการกำหนดส่วนขยายนี้คุณสามารถเรียกวิธีการซ้ำกับจำนวนจำนวนเต็มใด ๆ ที่จะดำเนินการงานที่จำนวนหลายครั้ง: 3.repetitions ({ println ("Hello!") }) // Hello! // Hello! // สวัสดี ! ใช้ไวยากรณ์ปิดท้ายโทรรวบรัดเพิ่มเติมได้ที่: 3.repetitions { println ("ลาก่อน!") } // ลาก่อน! // ลาก่อน! // ลาก่อน! กรรมวิธีตัวอย่างวิธีการวิธีการเพิ่มอินสแตนซ์ที่มีนามสกุลยังสามารถปรับเปลี่ยน (หรือ กลายพันธุ์) เช่นตัวเอง โครงสร้างและวิธีการแจงนับที่ปรับเปลี่ยนตนเองหรือคุณสมบัติของมันจะต้องทำเครื่องหมายวิธีการเช่นเป็นกรรมวิธีเช่นเดียวกับวิธีการจากกรรมวิธีการดำเนินงานเดิม ตัวอย่างด้านล่างเพิ่ม mutating วิธีใหม่ที่เรียกว่าตารางประเภท Int สวิฟท์ซึ่งสี่เหลี่ยมค่าเดิม: Int ขยาย { กรรมวิธีบำบัดตาราง () { ตัวเองตัวเอง = * ตนเอง} } var someInt = 3 someInt.square () // someInt คือ ตอนนี้ 9 ห้อยสามารถเพิ่มส่วนขยายใหม่ที่จะห้อยประเภทที่มีอยู่ ตัวอย่างนี้เพิ่มห้อยจำนวนเต็มสวิฟท์ในตัวชนิด Int ห้อยนี้ [n] จะแสดงสถานที่ n ทศนิยมหลักมาจากด้านขวาของหมายเลข: 123456789 [0] ผลตอบแทนที่ 9 ... และอื่น ๆ : Int ขยาย { ห้อย (digitIndex: Int) -> Int { var decimalBase = 1 สำหรับ _ ใน 1 ... digitIndex { decimalBase * = 10 } ผลตอบแทน (ตัวเอง / decimalBase) 10% } } 6381295 [0] eturns 5 6381295 [1] eturns 9 6381295 [2] eturns 2 6381295 [8] eturns 7 ถ้าค่า Int ไม่ ไม่ได้มีมากพอสำหรับตัวเลขดัชนีที่ร้องขอการดำเนินห้อยกลับ 0 เช่นถ้าตัวเลขที่ได้รับการเบาะที่มีเลขศูนย์ไปทางซ้าย: 746381295 [9] // กลับ 0 เช่นถ้าคุณได้รับการร้องขอ: 0746381295 [9] ซ้อนประเภทส่วนขยาย สามารถเพิ่มประเภทที่ซ้อนกันใหม่ในการเรียนที่มีอยู่โครงสร้างและ enumerations: 123456789 [1] ผลตอบแทนที่ 8 ขยายตัวละคร { {enum ชนิดกรณีสระพยัญชนะ, อื่น ๆ} var ชนิด: ชนิด { สลับสตริง (ตัวเอง) .lowercaseString { กรณี "" "อี", "ฉัน", "o", "ยู": กลับ .Vowel กรณี "ข", "ค", "D", "F", "g", "เอช", "เจ", "k "," ลิตร "," m ", "n", "พี", "คิว", "อาร์", "S", "ที", "โวลต์", "W", "x", "Y" "Z": กลับ .Consonant ค่าเริ่มต้น: กลับอื่นใน} ตัวอย่างนี้จะเพิ่มการแจงนับที่ซ้อนกันใหม่เพื่อตัวละคร นับนี้เรียกว่าชนิดเป็นการแสดงออกถึงชนิดของตัวอักษรที่แสดงให้เห็นถึงตัวละครโดยเฉพาะอย่างยิ่ง โดยเฉพาะมันเป็นการแสดงออกถึงตัวละครไม่ว่าจะเป็นสระหรือพยัญชนะในสคริปต์ภาษาละตินมาตรฐาน (โดยไม่คำนึงถึงสำเนียงบัญชีหรือเปลี่ยนแปลงในระดับภูมิภาค) หรือไม่ว่าจะเป็นชนิดของตัวอักษรอีก ตัวอย่างนี้ยังเพิ่มคุณสมบัติเช่นการคำนวณใหม่เพื่อตัวละครที่เรียกว่าชนิดซึ่งผลตอบแทนสมาชิกนับชนิดที่เหมาะสมสำหรับตัวละครที่ แจงนับที่ซ้อนกันในขณะนี้สามารถใช้กับค่าตัวอักษร: บำบัด printLetterKinds (คำ: String) { println (" (คำ) 'ถูกสร้างขึ้นจากชนิดของตัวอักษรต่อไปนี้:") สำหรับตัวละครในคำ { {character.kind สวิทช์กรณี .Vowel: การพิมพ์ ("สระ") กรณี .Consonant: การพิมพ์ ("พยัญชนะ") กรณีอื่นใน: การพิมพ์ ("อื่น ๆ ") } พิมพ์ (" n") tLetterKinds ("สวัสดี") สวัสดี 'ถูกสร้างขึ้นจาก ชนิดของตัวอักษรต่อไปนี้: พยัญชนะสระพยัญชนะสระพยัญชนะฟังก์ชั่นนี้ printLetterKinds ใช้การป้อนค่าสายอักขระและ iterates มากกว่าตัวละคร สำหรับตัวละครแต่ละตัวจะมีการพิจารณาสถานที่ให้บริการสำหรับการคำนวณชนิด tha
การแปล กรุณารอสักครู่..
ส่วนขยายส่วนขยายเพิ่ม
ใหม่ฟังก์ชันที่มีอยู่ในระดับโครงสร้าง หรือ การ พิมพ์ ซึ่งรวมถึงความสามารถในการขยายประเภทที่คุณไม่ได้มีการเข้าถึงรหัสแหล่งที่มาต้นฉบับ ( ที่รู้จักกันเป็นแบบย้อนหลัง ) ส่วนขยายจะคล้ายกับประเภท objective-c. ( ซึ่งแตกต่างจากประเภท Lua ส่วนขยายอย่างรวดเร็ว ไม่ได้ชื่อ นามสกุลใน Swift )
สามารถ :เพิ่มคุณสมบัติและคำนวณแบบคำนวณคุณสมบัติกำหนดตัวอย่างวิธีการและชนิดวิธีให้ใหม่ initializers กำหนด subscripts กำหนดและใช้ใหม่ชนิดที่มีอยู่ในประเภทซ้อนกันให้สอดคล้องกับโปรโตคอล
หมายเหตุถ้าคุณกำหนดส่วนขยายเพื่อเพิ่มฟังก์ชันการทำงานที่มีอยู่ในประเภทการทํางานใหม่จะสามารถใช้ได้ในทั้งหมดที่มีอยู่ กรณีของประเภทที่แม้ว่าพวกเขาจะถูกสร้างขึ้นก่อนที่จะขยายกำหนด .
ขยายไวยากรณ์
ประกาศนามสกุลกับการขยายการส่งเสริม sometype {
/ / ฟังก์ชันการทำงานใหม่เพื่อเพิ่ม sometype อยู่ตรงนี้
}
ส่วนขยายสามารถขยายประเภทที่มีอยู่ให้ใช้หนึ่งหรือหลายโปรโตคอล ที่เป็นกรณีนี้ ซึ่งชื่อที่เขียนในแบบเดียวกับที่ สำหรับชั้นเรียนหรือโครงสร้าง :
ส่งเสริม sometype : someprotocol anotherprotocol { ,
/ / การใช้โปรโตคอลความต้องการอยู่ตรงนี้
}
เพิ่มโปรโตคอลดังกล่าวในวิธีนี้จะอธิบายในการเพิ่มขั้นตอนสอดคล้องกับนามสกุล นามสกุลสามารถเพิ่มคุณสมบัติ
คำนวณคำนวณคำนวณคุณสมบัติและคุณสมบัติเช่นประเภทประเภทที่มีอยู่ตัวอย่างนี้เพิ่มห้าคำนวณตัวอย่างคุณสมบัติอย่างรวดเร็วของในตัวคู่ชนิด เพื่อให้การสนับสนุนขั้นพื้นฐานสำหรับการทำงานกับหน่วยระยะทาง :
) { var km : คู่คู่
{ }
กลับตนเอง * 1_000.0 var m : { } สองคืนด้วยตนเอง
var ซม. คู่กลับด้วยตนเอง /
4 } { var mm : คู่ { กลับตนเอง / 1_000.0 }
{ var ฟุตสองคืนด้วยตนเอง / 3.28084 }
}
ให้ oneinch = 25.4 mm
.println ( " หนึ่งนิ้ว N ( oneinch ) เมตร " )
rints " หนึ่งนิ้ว 0.0254 เมตร "
( threefeet = 3 ฟุต 3 ฟุต N ( threefeet ) เมตร " )
rints " สามฟุต 0.914399970739201 เมตร "
เหล่านี้คำนวณคุณสมบัติการแสดงที่มีค่าคู่ควรพิจารณาเป็น หน่วยหนึ่งของความยาว ถึงแม้ว่าพวกเขาจะใช้เป็นข้อมูลคุณสมบัติชื่อของ คุณสมบัติเหล่านี้สามารถผนวกกับมูลค่าที่แท้จริงจุด - จุดไวยากรณ์เป็นวิธีที่จะใช้อักษรค่าแสดงการแปลงระยะทาง ในตัวอย่างนี้ , ค่าคู่ 1.0 ถือว่าเป็นตัวแทนของ " หนึ่งเมตร " นี่คือเหตุผลที่ M คำนวณการคืนทรัพย์สินตนเองนิพจน์ 1 เมตร ถือว่าเพื่อคำนวณมูลค่าสองเท่าของ 1.0หน่วยอื่น ๆต้องมีการแปลง จะแสดงเป็นค่าวัดเมตร หนึ่ง
กิโลเมตรก็เหมือนกับ 1 , 000 เมตรดังนั้น km คำนวณคุณสมบัติคูณค่า โดย 1_000.00 แปลงเป็นตัวเลขแสดงในเมตร ในทำนองเดียวกันมี 3.28024 ฟุตเมตรและฟุตคำนวณคุณสมบัติพื้นฐานสองค่า โดยแบ่ง 3.28024 เพื่อแปลงจากฟุตเพื่อเมตรคุณสมบัติเหล่านี้จะถูกคำนวณคุณสมบัติอ่านอย่างเดียว และดังนั้นพวกเขาจะแสดงโดยไม่ได้รับคำหลัก , การใช้คำที่สั้นกระชับ กลับค่าของพวกเขาเป็นประเภทคู่ และสามารถใช้ในการคำนวณทางคณิตศาสตร์ทุกคู่ได้รับการยอมรับ :
ให้ amarathon = 42.km 195 . m
println ( " มาราธอน ( amarathon ) เมตรยาว " )
/ / พิมพ์ " มาราธอน 42195.0 เมตรยาว "
หมายเหตุ สามารถเพิ่มส่วนขยายใหม่คำนวณคุณสมบัติ แต่พวกเขาไม่สามารถเพิ่มเก็บสมบัติ หรือเพิ่มผู้สังเกตการณ์ทรัพย์สินสมบัติที่มีอยู่ initializers
นามสกุลสามารถเพิ่ม initializers ใหม่ประเภทที่มีอยู่ นี้ช่วยให้คุณสามารถขยายประเภทอื่น ๆที่จะยอมรับเป็นพารามิเตอร์ initializer ประเภทของคุณเอง ,หรือจะให้เพิ่มเติมเริ่มต้นตัวเลือกที่ไม่ได้ถูกรวมเป็นส่วนหนึ่งของชนิดเดิมที่ใช้ ส่วนขยายที่สามารถเพิ่ม initializers ความสะดวกใหม่ที่จะเรียน แต่พวกเขาไม่สามารถเพิ่มใหม่เขต initializers หรือ deinitializers เพื่อชั้น เขต initializers และ deinitializers เสมอต้องให้โดยการใช้ระดับเดิม .
ใหม่ฟังก์ชันที่มีอยู่ในระดับโครงสร้าง หรือ การ พิมพ์ ซึ่งรวมถึงความสามารถในการขยายประเภทที่คุณไม่ได้มีการเข้าถึงรหัสแหล่งที่มาต้นฉบับ ( ที่รู้จักกันเป็นแบบย้อนหลัง ) ส่วนขยายจะคล้ายกับประเภท objective-c. ( ซึ่งแตกต่างจากประเภท Lua ส่วนขยายอย่างรวดเร็ว ไม่ได้ชื่อ นามสกุลใน Swift )
สามารถ :เพิ่มคุณสมบัติและคำนวณแบบคำนวณคุณสมบัติกำหนดตัวอย่างวิธีการและชนิดวิธีให้ใหม่ initializers กำหนด subscripts กำหนดและใช้ใหม่ชนิดที่มีอยู่ในประเภทซ้อนกันให้สอดคล้องกับโปรโตคอล
หมายเหตุถ้าคุณกำหนดส่วนขยายเพื่อเพิ่มฟังก์ชันการทำงานที่มีอยู่ในประเภทการทํางานใหม่จะสามารถใช้ได้ในทั้งหมดที่มีอยู่ กรณีของประเภทที่แม้ว่าพวกเขาจะถูกสร้างขึ้นก่อนที่จะขยายกำหนด .
ขยายไวยากรณ์
ประกาศนามสกุลกับการขยายการส่งเสริม sometype {
/ / ฟังก์ชันการทำงานใหม่เพื่อเพิ่ม sometype อยู่ตรงนี้
}
ส่วนขยายสามารถขยายประเภทที่มีอยู่ให้ใช้หนึ่งหรือหลายโปรโตคอล ที่เป็นกรณีนี้ ซึ่งชื่อที่เขียนในแบบเดียวกับที่ สำหรับชั้นเรียนหรือโครงสร้าง :
ส่งเสริม sometype : someprotocol anotherprotocol { ,
/ / การใช้โปรโตคอลความต้องการอยู่ตรงนี้
}
เพิ่มโปรโตคอลดังกล่าวในวิธีนี้จะอธิบายในการเพิ่มขั้นตอนสอดคล้องกับนามสกุล นามสกุลสามารถเพิ่มคุณสมบัติ
คำนวณคำนวณคำนวณคุณสมบัติและคุณสมบัติเช่นประเภทประเภทที่มีอยู่ตัวอย่างนี้เพิ่มห้าคำนวณตัวอย่างคุณสมบัติอย่างรวดเร็วของในตัวคู่ชนิด เพื่อให้การสนับสนุนขั้นพื้นฐานสำหรับการทำงานกับหน่วยระยะทาง :
) { var km : คู่คู่
{ }
กลับตนเอง * 1_000.0 var m : { } สองคืนด้วยตนเอง
var ซม. คู่กลับด้วยตนเอง /
4 } { var mm : คู่ { กลับตนเอง / 1_000.0 }
{ var ฟุตสองคืนด้วยตนเอง / 3.28084 }
}
ให้ oneinch = 25.4 mm
.println ( " หนึ่งนิ้ว N ( oneinch ) เมตร " )
rints " หนึ่งนิ้ว 0.0254 เมตร "
( threefeet = 3 ฟุต 3 ฟุต N ( threefeet ) เมตร " )
rints " สามฟุต 0.914399970739201 เมตร "
เหล่านี้คำนวณคุณสมบัติการแสดงที่มีค่าคู่ควรพิจารณาเป็น หน่วยหนึ่งของความยาว ถึงแม้ว่าพวกเขาจะใช้เป็นข้อมูลคุณสมบัติชื่อของ คุณสมบัติเหล่านี้สามารถผนวกกับมูลค่าที่แท้จริงจุด - จุดไวยากรณ์เป็นวิธีที่จะใช้อักษรค่าแสดงการแปลงระยะทาง ในตัวอย่างนี้ , ค่าคู่ 1.0 ถือว่าเป็นตัวแทนของ " หนึ่งเมตร " นี่คือเหตุผลที่ M คำนวณการคืนทรัพย์สินตนเองนิพจน์ 1 เมตร ถือว่าเพื่อคำนวณมูลค่าสองเท่าของ 1.0หน่วยอื่น ๆต้องมีการแปลง จะแสดงเป็นค่าวัดเมตร หนึ่ง
กิโลเมตรก็เหมือนกับ 1 , 000 เมตรดังนั้น km คำนวณคุณสมบัติคูณค่า โดย 1_000.00 แปลงเป็นตัวเลขแสดงในเมตร ในทำนองเดียวกันมี 3.28024 ฟุตเมตรและฟุตคำนวณคุณสมบัติพื้นฐานสองค่า โดยแบ่ง 3.28024 เพื่อแปลงจากฟุตเพื่อเมตรคุณสมบัติเหล่านี้จะถูกคำนวณคุณสมบัติอ่านอย่างเดียว และดังนั้นพวกเขาจะแสดงโดยไม่ได้รับคำหลัก , การใช้คำที่สั้นกระชับ กลับค่าของพวกเขาเป็นประเภทคู่ และสามารถใช้ในการคำนวณทางคณิตศาสตร์ทุกคู่ได้รับการยอมรับ :
ให้ amarathon = 42.km 195 . m
println ( " มาราธอน ( amarathon ) เมตรยาว " )
/ / พิมพ์ " มาราธอน 42195.0 เมตรยาว "
หมายเหตุ สามารถเพิ่มส่วนขยายใหม่คำนวณคุณสมบัติ แต่พวกเขาไม่สามารถเพิ่มเก็บสมบัติ หรือเพิ่มผู้สังเกตการณ์ทรัพย์สินสมบัติที่มีอยู่ initializers
นามสกุลสามารถเพิ่ม initializers ใหม่ประเภทที่มีอยู่ นี้ช่วยให้คุณสามารถขยายประเภทอื่น ๆที่จะยอมรับเป็นพารามิเตอร์ initializer ประเภทของคุณเอง ,หรือจะให้เพิ่มเติมเริ่มต้นตัวเลือกที่ไม่ได้ถูกรวมเป็นส่วนหนึ่งของชนิดเดิมที่ใช้ ส่วนขยายที่สามารถเพิ่ม initializers ความสะดวกใหม่ที่จะเรียน แต่พวกเขาไม่สามารถเพิ่มใหม่เขต initializers หรือ deinitializers เพื่อชั้น เขต initializers และ deinitializers เสมอต้องให้โดยการใช้ระดับเดิม .
การแปล กรุณารอสักครู่..
ภาษาอื่น ๆ
การสนับสนุนเครื่องมือแปลภาษา: กรีก, กันนาดา, กาลิเชียน, คลิงออน, คอร์สิกา, คาซัค, คาตาลัน, คินยารวันดา, คีร์กิซ, คุชราต, จอร์เจีย, จีน, จีนดั้งเดิม, ชวา, ชิเชวา, ซามัว, ซีบัวโน, ซุนดา, ซูลู, ญี่ปุ่น, ดัตช์, ตรวจหาภาษา, ตุรกี, ทมิฬ, ทาจิก, ทาทาร์, นอร์เวย์, บอสเนีย, บัลแกเรีย, บาสก์, ปัญจาป, ฝรั่งเศส, พาชตู, ฟริเชียน, ฟินแลนด์, ฟิลิปปินส์, ภาษาอินโดนีเซี, มองโกเลีย, มัลทีส, มาซีโดเนีย, มาราฐี, มาลากาซี, มาลายาลัม, มาเลย์, ม้ง, ยิดดิช, ยูเครน, รัสเซีย, ละติน, ลักเซมเบิร์ก, ลัตเวีย, ลาว, ลิทัวเนีย, สวาฮิลี, สวีเดน, สิงหล, สินธี, สเปน, สโลวัก, สโลวีเนีย, อังกฤษ, อัมฮาริก, อาร์เซอร์ไบจัน, อาร์เมเนีย, อาหรับ, อิกโบ, อิตาลี, อุยกูร์, อุสเบกิสถาน, อูรดู, ฮังการี, ฮัวซา, ฮาวาย, ฮินดี, ฮีบรู, เกลิกสกอต, เกาหลี, เขมร, เคิร์ด, เช็ก, เซอร์เบียน, เซโซโท, เดนมาร์ก, เตลูกู, เติร์กเมน, เนปาล, เบงกอล, เบลารุส, เปอร์เซีย, เมารี, เมียนมา (พม่า), เยอรมัน, เวลส์, เวียดนาม, เอสเปอแรนโต, เอสโทเนีย, เฮติครีโอล, แอฟริกา, แอลเบเนีย, โคซา, โครเอเชีย, โชนา, โซมาลี, โปรตุเกส, โปแลนด์, โยรูบา, โรมาเนีย, โอเดีย (โอริยา), ไทย, ไอซ์แลนด์, ไอร์แลนด์, การแปลภาษา.
- ฉันเรียนทุกอย่างที่เกี่ยวกับภาษาไทย ฉันเ
- ส้มตำแตงกวากุ้งสด
- 밥을 먹고싶어!
- 3.1สถานที่ตั้งสถานีมีความเหมาะสม3.2 จำนว
- จำนวน
- happy Room
- now that you saw it in real time did you
- Nutrient analyses for phosphate, silicat
- การท่องเที่ยวก้อนเมฆ
- ดูแลสุขภาพด้วย
- พื้นที่ ของวัสดุที่รับแรงก็จะมีพื้นที่น้
- among
- Because the ecological goal of stock reb
- คุณตื่นเช้า
- Ichitan ramps up production
- for
- แต่เนื่องจำกควำมแตกต่ำงของผลิตภัณฑ์อยู่ท
- ฉันไม่ถามแล้วค่ะคุณครู
- This car sucks in drifts so you should u
- When D is a constant the equationcan be
- Joy
- This technology was developed by NASA fo
- สี่แสนหนึ่งหมื่นเจ็ดร้อยห้าสิบาท
- ขอโทษที่ฉันพูดเรื่องแบบนี้กับคุณ
