class Country { let name: String le

class Country {
let name: String
let capitalCity: City!
init(name: String, capitalName: String) {
self.name = name
self.capitalCity = City(name: capitalName, country: self)
}
}
City {
name: String
unowned let country: Country
(name: String, country: Country) {
self.name = name
self.country = country
To set up the interdependency between the two classes, the initializer for City takes a Country instance, and stores this instance in its country property. The initializer for City is called from within the initializer for Country. However, the initializer for Country cannot pass self to the City initializer until a new Country instance is fully initialized, as described in Two-Phase Initialization. To cope with this requirement, you declare the capitalCity property of Country as an implicitly unwrapped optional property, indicated by the exclamation mark at the end of its type annotation (City!). This means that the capitalCity property has a default value of nil, like any other optional, but can be accessed without the need to unwrap its value as described in Implicitly Unwrapped Optionals. Because capitalCity has a default nil value, a new Country instance is considered fully initialized as soon as the Country instance sets its name property within its initializer. This means that the Country initializer can start to reference and pass around the implicit self property as soon as the name property is set. The Country initializer can therefore pass self as one of the parameters for the City initializer when the Country initializer is setting its own capitalCity property. All of this means that you can create the Country and City instances in a single statement, without creating a strong reference cycle, and the capitalCity property can be accessed directly, without needing to use an exclamation mark to unwrap its optional value:
var country = Country(name: "Canada", capitalName: "Ottawa")
println("(country.name)'s capital city is called (country.capitalCity.name)")
// prints "Canada's capital city is called Ottawa"
In the example above, the use of an implicitly unwrapped optional means that all of the two-phase class initializer requirements are satisfied. The capitalCity property can be used and accessed like a non-optional value once initialization is complete, while still avoiding a strong reference cycle.

Strong Reference Cycles for Closures

You saw above how a strong reference cycle can be created when two class instance properties hold a strong reference to each other. You also saw how to use weak and unowned references to break these strong reference cycles. A strong reference cycle can also occur if you assign a closure to a property of a class instance, and the body of that closure captures the instance. This capture might occur because the closure’s body accesses a property of the instance, such as self.someProperty, or because the closure calls a method on the instance, such as self.someMethod(). In either case, these accesses cause the closure to “capture” self, creating a strong reference cycle. This strong reference cycle occurs because closures, like classes, are reference types. When you assign a closure to a property, you are assigning a reference to that closure. In essence, it’s the same problem as above—two strong references are keeping each other alive. However, rather than two class instances, this time it’s a class instance and a closure that are keeping each other alive.
Swift provides an elegant solution to this problem, known as a closure capture list. However, before you learn how to break a strong reference cycle with a closure capture list, it is useful to understand how such a cycle can be caused. The example below shows how you can create a strong reference cycle when using a closure that references self. This example defines a class called HTMLElement, which provides a simple model for an individual element within an HTML document:
class HTMLElement {

let name: String
let text: String?

@lazy var asHTML: () -> String = {
if let text = self.text {
return "(text)"
} else {
return ""
}
(name: String, text: String? = nil) {
self.name = name
self.text = text
deinit {
println("(name) is being deinitialized")

The HTMLElement class defines a name property, which indicates the name of the element, such as "p" for a paragraph element, or "br" for a line break element. HTMLElement also defines an optional text property, which you can set to a string that represents the text to be rendered within that HTML element. In addition to these two simple properties, the HTMLElement class defines a lazy property called asHTML. This property references a closure that combines name and text into an HTML string fragment. The asHTML property is of type () -> String, or “a function that takes no parameters, and returns a String value”. By default, the asHTML property is assigned a closure that returns a string representation of an HTML tag. This tag contains the optional text value if it exists, or no text content if text does not exist. For a paragraph element, the closure would return "some text" or "", depending on whether the text property equals "some text" or nil. The asHTML property is named and used somewhat like an instance method. However, because asHTML is a closure property rather than an instance method, you can replace the default value of the asHTML property with a custom closure, if you want to change the HTML rendering for a particular HTML element.

NOTE The asHTML property is declared as a lazy property, because it is only needed if and when the element actually needs to be rendered as a string value for some HTML output target. The fact that asHTML is a lazy property means that you can refer to self within the default closure, because the lazy property will not be accessed until after initialization has been completed and self is known to exist.

The HTMLElement class provides a single initializer, which takes a name argument and (if desired) a text argument to initialize a new element. The class also defines a deinitializer, which prints a message to show when an HTMLElement instance is deallocated.
Here’s how you use the HTMLElement class to create and print a new instance:

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
println(paragraph!.asHTML())
// prints "hello, world"

NOTE The paragraph variable above is defined as an optional HTMLElement, so that it can be set to nil below to demonstrate the presence of a strong reference cycle.

Unfortunately, the HTMLElement class, as written above, creates a strong reference cycle between an HTMLElement instance and the closure used for its default asHTML value. Here’s how the cycle looks:

The instance’s asHTML property holds a strong reference to its closure. However, because the closure refers to self within its body (as a way to reference self.name and self.text), the closure captures self, which means that it holds a strong reference back to the HTMLElement instance. A strong reference cycle is created between the two. (For more information about capturing values in a closure, see Capturing Values.)

NOTE Even though the closure refers to self multiple times, it only captures one strong reference to the HTMLElement instance.

If you set the paragraph variable to nil and break its strong reference to the HTMLElement instance, neither the HTMLElement instance nor its closure are deallocated, because of the strong reference cycle:
paragraph = nil
Note that the message in the HTMLElement deinitializer is not printed, which shows that the HTMLElement instance is not deallocated.

Resolving Strong Reference Cycles for Closures

You resolve a strong reference cycle between a closure and a class instance by defining a capture list as part of the closure’s definition. A capture list defines the rules to use when capturing one or more reference types within the closure’s body. As with strong reference cycles between two class instances, you declare each captured reference to be a weak or unowned reference rather than a strong reference. The appropriate choice of weak or unowned depends on the relationships between the different parts of your code.

NOTE Swift requires you to write self.someProperty or self.someMethod (rather than just someProperty or someMethod) whenever you refer to a member of self within a closure. This helps you remember that it’s possible to capture self by accident.

Defining a Capture List
Each item in a capture list is a pairing of the weak or unowned keyword with a reference to a class instance (such as self or someInstance). These pairings are written within a pair of square braces, separated by commas. Place the capture list before a closure’s parameter list and return type if they are provided:
@lazy var someClosure: (Int, String) -> String = {
[unowned self] (index: Int, stringToProcess: String) -> String in
// closure body goes here
}
If a closure does not specify a parameter list or return type because they can be inferred from context, place the capture list at the very start of the closure, followed by the in keyword:
@lazy var someClosure: () -> String = {
[unowned self] in
// closure body goes here
}
Weak and Unowned References
Define a capture in a closure as an unowned reference when the closure and the instance it captures will always refer to each other, and will always be deallocated at the same time. Conversely, define a capture as a weak reference when the captured reference may become nil at some point in the future. Weak references are always of an optional type, and automatically become nil when the instance they reference is deallocated. This enables you to check for their existence within the closure’s body.

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

คลาส{ประเทศ ให้ชื่อ: สายอักขระ ให้ capitalCity: เมือง เริ่มต้น (ชื่อ: สตริง capitalName: สตริง) { self.name =ชื่อ self.capitalCity =เมือง (ชื่อ: capitalName ประเทศ: ด้วยตนเอง) }} {เมือง ชื่อ: สายอักขระunowned ให้ประเทศ: ประเทศ(ชื่อ: สตริง ประเทศ: ประเทศ) { self.name =ชื่อ self.country =ประเทศการตั้งค่าความเชื่อมโยงกันระหว่าง 2 ชั้น ตัวในเมืองใช้อินสแตนซ์ที่ประเทศ และเก็บอินสแตนซ์นี้ในคุณสมบัติของประเทศ ตัวในเมืองจะเรียกจากภายในตัวที่สำหรับประเทศ อย่างไรก็ตาม ตัวสำหรับประเทศไม่ผ่านตัวเองไปตัวเมืองจนกว่าอินสแตนซ์ประเทศใหม่ทั้งหมดเริ่มต้น ใน Two-Phase เริ่มต้น เพื่อรับมือกับความต้องการนี้ คุณต้องกำหนดคุณสมบัติ capitalCity ของประเทศเป็นคุณสมบัติเสริมนัย unwrapped ระบุ ด้วยเครื่องหมายอัศเจรีย์ที่สุดของคำอธิบายของชนิด (เมือง) หมายความ ว่า คุณสมบัติ capitalCity มีค่าเริ่มต้นของ nil ชอบใด ๆ อื่น ๆ ไม่จำเป็น แต่สามารถเข้าถึงได้โดยไม่ต้องไม่ตัดค่าตามที่อธิบายไว้ในนัย Unwrapped Optionals เนื่องจาก capitalCity มีค่าเริ่มต้นค่า nil อินสแตนซ์ประเทศใหม่จะถือว่าเริ่มต้นทั้งหมดเป็นอินสแตนซ์ประเทศตั้งค่าคุณสมบัติชื่อภายในตัวของมัน ซึ่งหมายความ ว่า ตัวประเทศสามารถเริ่มต้น การอ้างอิงผ่านสถานนัยตัวเองทันทีที่มีการตั้งค่าคุณสมบัติชื่อ ตัวประเทศสามารถจึงส่งตัวเองเป็นพารามิเตอร์ใดพารามิเตอร์หนึ่งในตัวเมืองเมื่อตัวประเทศมีการตั้งค่าคุณสมบัติ capitalCity ของตัวเอง ทั้งหมดนี้หมายความ ว่า คุณสามารถสร้างอินสแตนซ์ของประเทศและเมืองในงบเดี่ยว ไม่ มีการสร้างวงจรอ้างอิงแข็งแรง และคุณสมบัติ capitalCity สามารถเข้าถึงได้โดยตรง ไม่จำเป็นต้องใช้เครื่องหมายอัศเจรีย์เพื่อไม่ตัดค่าของตัวเลือก:ประเทศ var =ประเทศ (ชื่อ: "แคนาดา" capitalName: "ออตตาวา")println (" (country.name) เป็นเมืองหลวงเรียกว่า (country.capitalCity.name)")พิมพ์ "แคนาดาเมืองหลวงคือออตตาวา"ในตัวอย่างข้างต้น การใช้ unwrapped นัยก็ได้หมายความ ว่า ความตัว two-phase คลาสทั้งหมดพอใจ คุณสมบัติ capitalCity สามารถใช้ และเข้าถึงได้เช่นค่าไม่จำเป็นเมื่อเริ่มต้นเสร็จสมบูรณ์ วงจรอ้างอิงแรงขณะรอบอ้างอิงที่แข็งแกร่งสำหรับปิดคุณเห็นข้างบนว่ารอบอ้างอิงที่แข็งแกร่งสามารถสร้างคุณสมบัติอินสแตนซ์คลาส 2 เก็บการอ้างอิงที่แข็งแรงกัน นอกจากนี้คุณยังเห็นวิธีการอ้างอิง unowned และอ่อนแอจะรอบอ้างอิงแรงเหล่านี้ รอบอ้างอิงที่แข็งแรงอาจเกิดขึ้นหากคุณกำหนดปิดการคุณสมบัติของอินสแตนซ์คลาส และรวบรวมเนื้อความของการปิดอินสแตนซ์ จับนี้อาจเกิดขึ้น เพราะร่างกายของปิดการเข้าถึงคุณสมบัติของอินสแตนซ์ เช่น self.someProperty หรือปิดการเรียกวิธีการบนอินสแตนซ์ เช่น self.someMethod() ในกรณีอย่างใดอย่างหนึ่ง หาเหล่านี้ทำให้ปิดการ "จับภาพ" ตัวเอง สร้างวงจรอ้างอิงแรง วงจรอ้างอิงแรงนี้เกิดขึ้นเนื่องจากปิด เช่นชนชั้น มีชนิดการอ้างอิง เมื่อคุณกำหนดปิดการคุณสมบัติ คุณกำลังกำหนดอ้างอิงไปที่ปิด ในสาระสำคัญ เป็นปัญหาเดียวกันกับข้างต้นโดยอ้างอิงแรงทั้งสองมีให้กันชีวิต อย่างไรก็ตาม มากกว่าสองคลาสอินสแตนซ์ เวลานี้จะมีอินสแตนซ์ของคลาและปิดที่จะรักษาแต่มีชีวิตอยู่Swift ให้วิธีแก้ปัญหานี้ เป็นรายการปิดจับภาพสวยงาม อย่างไรก็ตาม ก่อนที่คุณเรียนรู้วิธีการตัดวงจรอ้างอิงแรงกับรายการจับปิด ได้ประโยชน์ที่จะเข้าใจว่าอาจเกิดวงจรดังกล่าว ตัวอย่างด้านล่างแสดงว่าคุณสามารถสร้างการอ้างอิงแรงรอบเมื่อใช้ปิดที่อ้างอิงตัวเอง ตัวอย่างนี้กำหนดคลาสที่เรียกว่า HTMLElement ซึ่งเป็นแบบอย่างสำหรับแต่ละองค์ประกอบภายในเอกสาร HTML:คลาส HTMLElement { ให้ชื่อ: สายอักขระ ให้ข้อความ: สายไหม @lazy var asHTML: () -> สาย ={ หากให้ข้อความ = self.text { กลับ "< (self.name) > (text)" } {อื่น กลับ " < (self.name) / > " }(ชื่อ: สตริง ข้อความ: สายอักขระ? = nil นั่น) { self.name =ชื่อ self.text =ข้อความdeinit { println("(name) เป็นการ deinitialized")คลา HTMLElement กำหนดคุณสมบัติชื่อ ซึ่งบ่งชี้ชื่อขององค์ประกอบ เช่น "p" สำหรับเป็นองค์ประกอบย่อหน้า หรือ "br" สำหรับองค์ประกอบเป็นตัวแบ่งบรรทัด HTMLElement กำหนดลักษณะข้อความที่เลือกได้ ซึ่งคุณสามารถตั้งค่าสายอักขระที่แสดงถึงข้อความจะแสดงภายในองค์ประกอบ HTML ที่ นอกจากคุณสมบัติเรื่องเหล่านี้สอง คลา HTMLElement กำหนดคุณสมบัติขี้เกียจเรียกว่า asHTML นี่อ้างอิงปิดที่รวมชื่อและข้อความในส่วนสายอักขระเป็น HTML คุณสมบัติ asHTML เป็นชนิด() -> สาย หรือ "ฟังก์ชันที่ใช้พารามิเตอร์ไม่ และส่งกลับค่าสายอักขระ" โดยค่าเริ่มต้น asHTML คุณสมบัติถูกกำหนดให้ปิดที่ส่งกลับค่าสายอักขระตัวแทนของแท็ก HTML แท็กนี้ประกอบด้วยค่าข้อความตัวเลือกมีอยู่ หรือไม่ข้อความถ้าข้อความมีอยู่ สำหรับองค์ประกอบย่อหน้า การปิดจะกลับมา"ข้อความบางอย่าง"หรือ"", ขึ้นอยู่กับว่าคุณสมบัติข้อความเท่ากับ"ข้อความ"หรือ nil นั่น คุณสมบัติ asHTML เป็นชื่อ และใช้เหมือนวิธีการอินสแตนซ์ อย่างไรก็ตาม เนื่องจาก asHTML มีคุณสมบัติปิดมากกว่าวิธีการอินสแตนซ์ คุณสามารถแทนค่าเริ่มต้นของคุณสมบัติ asHTML กับปิดเอง ถ้าคุณต้องการเปลี่ยนการแสดงผล HTML สำหรับองค์ประกอบ HTML ที่เฉพาะหมายเหตุประกาศคุณสมบัติ asHTML เป็นคุณสมบัติขี้เกียจ เพราะเท่านั้นการองค์จริงต้องการจะแสดงเป็นค่าสายอักขระสำหรับเป้าหมายของผลลัพธ์ HTML บาง ความจริงว่า asHTML หมายถึงขี้เกียจคุณสมบัติที่คุณสามารถอ้างอิงถึงตนเองในการเริ่มต้นปิด เนื่องจากคุณสมบัติขี้เกียจจะไม่สามารถเข้าถึงจนกว่าหลังจากเสร็จสิ้นการเตรียมใช้งาน และตนเองเป็นที่รู้จักกันอยู่คลา HTMLElement ให้เป็นตัวเดียว ซึ่งใช้อาร์กิวเมนต์ชื่อและ (ถ้าต้องการ) อาร์กิวเมนต์ข้อความเริ่มต้นองค์ประกอบใหม่ ชั้นกำ deinitializer ซึ่งพิมพ์ข้อความที่แสดงเมื่อ deallocated อินสแตนซ์ HTMLElement นี่คือวิธีที่คุณใช้คลาส HTMLElement เพื่อสร้าง และพิมพ์อินสแตนซ์ใหม่:ย่อหน้า var: HTMLElement = HTMLElement(name: "p", text: "hello, world")println(paragraph!. asHTML())พิมพ์"หวัดดีชาวโลก"หมายเหตุตัวแปรย่อหน้าข้างต้นถูกกำหนดเป็น HTMLElement ไม่จำเป็น เพื่อให้สามารถกำหนดไปด้านล่าง nil นั่นแสดงให้เห็นถึงสถานะของรอบอ้างอิงที่แข็งแรงอับ คลา HTMLElement ตามที่เขียนไว้ข้างต้น สร้างวงจรแรงอ้างอิงอินสแตนซ์ HTMLElement และปิดการใช้ค่าเริ่มต้น asHTML นี่คือลักษณะของรอบ:คุณสมบัติของอินสแตนซ์ asHTML เก็บข้อมูลอ้างอิงปิดแข็งแรง อย่างไรก็ตาม เนื่องจากการปิดหมายถึงตนเองภายในร่างกาย (เป็นวิธีการอ้างอิง self.name และ self.text), การปิดจับตนเอง ซึ่งหมายความ ว่า มันมีอ้างอิงกลับไปยังอินสแตนซ์ HTMLElement แข็งแรง มีสร้างวงจรอ้างอิงแรงระหว่างสอง (สำหรับข้อมูลเพิ่มเติมเกี่ยวกับค่าปิดจับภาพ ดูค่าที่จับ)หมายเหตุแม้ว่าปิดอ้างอิงถึงตัวเองหลายครั้ง มันเท่าจับอ้างอิงกับอินสแตนซ์ HTMLElement แข็งแรงถ้าคุณตั้งค่าตัวแปรย่อหน้า nil นั่น และทำลายอ้างอิงอินสแตนซ์ HTMLElement ความแข็งแรง ไม่มีอินสแตนซ์ HTMLElement หรือปิดมันจะ deallocated เนื่องจากวงจรอ้างอิงแรง:ย่อหน้า = nil นั่นโปรดสังเกตว่า ข้อความใน HTMLElement deinitializer ไม่พิมพ์ แสดงว่า อินสแตนซ์ HTMLElement จะไม่ deallocatedแก้ไขรอบอ้างอิงที่แข็งแกร่งสำหรับปิดคุณแก้ไขวงจรอ้างอิงแรงระหว่างการปิดอินสแตนซ์ของคลาส โดยกำหนดรายการจับเป็นส่วนหนึ่งของคำจำกัดความของการปิด รายการจับกำหนดกฎเพื่อใช้ในการจับภาพอย่าง น้อยหนึ่งชนิดการอ้างอิงภายในเนื้อหาของการปิด เช่นเดียวกับวงจรอ้างอิงแรงระหว่างสองอินสแตนซ์คลาส คุณประกาศจับอ้างอิงต้อง การอ้างอิงอ่อน หรือ unowned แทนการอ้างอิงที่แข็งแรง อ่อนแอ หรือ unowned เลือกที่เหมาะสมขึ้นอยู่กับความสัมพันธ์ระหว่างส่วนต่าง ๆ ของโค้ดของคุณหมายเหตุ Swift ต้องเขียน self.someProperty หรือ self.someMethod (มากกว่าเพียงแค่ someProperty หรือ someMethod) เมื่อใดก็ตามที่คุณอ้างถึงสมาชิกของตนเองภายในปิด นี้ช่วยให้คุณจำไว้ว่า จะสามารถจับภาพด้วยตนเอง โดยบังเอิญกำหนดรายการจับสินค้าแต่ละรายการในรายการจับเป็นการจับคู่ของ unowned หรืออ่อนแอมีการอ้างอิงอินสแตนซ์ของคลาส (เช่นตนเองหรือ someInstance) Pairings เหล่านี้จะถูกเขียนในคู่ของวงเล็บสี่เหลี่ยม จุลภาค ทำรายการจับก่อนรายการพารามิเตอร์ของปิด และกลับชนิดถ้ามี:@lazy var someClosure: (Int สตริง) -> สาย ={ [unowned ตนเอง] (ดัชนี: Int, stringToProcess: สตริง) -> สายใน ร่างกายปิดนี่}ถ้าไม่ปิดการระบุพารามิเตอร์ หรือชนิดการส่งคืนเนื่องจากพวกเขาสามารถสรุปได้จากบริบท ทำรายการจับที่ปิด ตามคำสำคัญในเริ่มมาก:@lazy var someClosure: () -> สาย ={ [unowned ตนเอง] ใน ร่างกายปิดนี่}อ้างอิง Unowned และอ่อนแอกำหนดจับในแบบปิดเป็นการอ้างอิง unowned เมื่อการปิดอินสแตนซ์ที่จะจับจะเสมอถึงกัน และจะถูก deallocated ในเวลาเดียวกัน ในทางกลับกัน กำหนดจับอ้างอิงอ่อนเมื่ออ้างอิงจับอาจเป็น nil ในบางจุดในอนาคต อ้างอิงที่อ่อนแอมักเลือกชนิด และโดยอัตโนมัติกลายเป็น nil เมื่อ deallocated อินสแตนซ์ที่จะอ้างอิง นี้ช่วยให้คุณสามารถตรวจสอบการมีที่อยู่ภายในร่างกายการปิด

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

ระดับประเทศ {
ขอให้ชื่อ: String
ให้ capitalCity: เมือง!
init (ชื่อ: สตริง capitalName: String) {
self.name = ชื่อ
self.capitalCity = ซิตี้ (ชื่อ: capitalName ประเทศ: ตัวเอง)
}
}
{เมือง
ชื่อ: String
ไม่มีเจ้าของ ปล่อยให้ประเทศ: ประเทศ
(ชื่อ: String ประเทศ: ประเทศ) {
self.name = ชื่อ
self.country ประเทศ =
การตั้งค่า interdependency ระหว่างสองชั้น, initializer ซิตี้ใช้เวลาเช่นประเทศและร้านค้าเช่นนี้ในประเทศของตน คุณสมบัติ การเริ่มต้นสำหรับเมืองที่เรียกว่าจากภายใน initializer สำหรับประเทศ แต่การเริ่มต้นสำหรับประเทศไม่สามารถผ่านตัวเองไปจนถึงเมือง initializer เช่นประเทศใหม่จะเริ่มต้นได้อย่างเต็มที่ตามที่อธิบายไว้ในขั้นตอนที่สองเริ่มต้น เพื่อรับมือกับความต้องการนี้คุณประกาศทรัพย์สิน capitalCity ของประเทศเป็นสถานที่ให้บริการที่เป็นตัวเลือกที่อยากได้โดยปริยายระบุด้วยเครื่องหมายอัศเจรีย์ในตอนท้ายของบันทึกย่อชนิด (เมือง) ซึ่งหมายความว่าทรัพย์สิน capitalCity มีค่าเริ่มต้นของศูนย์เช่นตัวเลือกอื่น ๆ แต่สามารถเข้าถึงได้โดยไม่จำเป็นต้องแกะค่าของมันตามที่อธิบายไว้ในปริยายแกะ Optionals เพราะ capitalCity มีค่าเป็นศูนย์เริ่มต้นใหม่เช่นประเทศถือว่าเริ่มต้นได้อย่างเต็มที่โดยเร็วเช่นประเทศตั้งชื่อสถานที่ให้บริการภายใน initializer ของ ซึ่งหมายความว่าประเทศ initializer สามารถเริ่มต้นที่จะอ้างอิงและผ่านรอบสถานที่ให้บริการตัวเองโดยปริยายทันทีที่ชื่อของสถานที่มีการตั้งค่า ประเทศ initializer จึงสามารถส่งผ่านตัวเองเป็นหนึ่งในพารามิเตอร์สำหรับการเริ่มต้นซิตี้เมื่อประเทศ initializer คือการตั้งค่าสถานที่ให้บริการ capitalCity ของตัวเอง ทั้งหมดนี้หมายความว่าคุณสามารถสร้างประเทศและกรณีเมืองในคำสั่งเดียวโดยไม่ต้องสร้างวงจรการอ้างอิงที่แข็งแกร่งและทรัพย์สิน capitalCity สามารถเข้าถึงได้โดยตรงโดยไม่จำเป็นต้องใช้เครื่องหมายอัศเจรีย์จะแกะตัวเลือกที่คุ้มค่า:
ประเทศ var = ประเทศ (ชื่อ "แคนาดา" capitalName "ออตตาวา")
println (" (country.name) 's เมืองหลวงเรียกว่า (country.capitalCity.name)")
// พิมพ์ "เมืองหลวงของแคนาดาออตตาวาเรียกว่า"
ในตัวอย่างข้างต้นการใช้งานของตัวเลือกที่อยากได้โดยปริยายหมายความว่าทุกชั้นสองเฟสต้องการ initializer มีความพึงพอใจ สถานที่ให้บริการ capitalCity สามารถใช้และเข้าถึงได้เช่นค่าที่ไม่ใช่ตัวเลือกเริ่มต้นที่ครั้งหนึ่งเคยเป็นที่สมบูรณ์ขณะที่ยังคงหลีกเลี่ยงวงจรอ้างอิงที่แข็งแกร่ง. รอบอ้างอิงที่แข็งแกร่งสำหรับการปิดให้คุณเห็นวิธีการดังกล่าวข้างต้นวงจรการอ้างอิงที่แข็งแกร่งสามารถสร้างขึ้นเมื่อสองคุณสมบัติเช่นชั้นถือ การอ้างอิงที่แข็งแกร่งซึ่งกันและกัน นอกจากนี้คุณยังเห็นวิธีการที่จะใช้การอ้างอิงที่อ่อนแอและไม่มีเจ้าของที่จะทำลายวงจรการอ้างอิงที่แข็งแกร่งเหล่านี้ วงจรการอ้างอิงที่แข็งแกร่งนอกจากนี้ยังสามารถเกิดขึ้นได้ถ้าคุณกำหนดปิดต่อทรัพย์สินของเช่นชั้นและร่างกายของการปิดที่จับเช่น การจับภาพนี้อาจเกิดขึ้นเพราะร่างกายของการปิดการเข้าถึงทรัพย์สินของตัวอย่างเช่น self.someProperty หรือเพราะการปิดเรียกวิธีการในกรณีเช่น self.someMethod () ในทั้งสองกรณีการเข้าถึงเหล่านี้ทำให้เกิดการปิดการ "จับภาพ" ตัวเอง, การสร้างวงจรการอ้างอิงที่แข็งแกร่ง วงจรนี้อ้างอิงที่แข็งแกร่งเกิดขึ้นเนื่องจากการปิดเช่นเดียวกับการเรียนประเภทอ้างอิง เมื่อคุณกำหนดปิดทรัพย์สินคุณจะกำหนดปิดการอ้างอิงถึงที่ ในสาระสำคัญมันเป็นปัญหาที่เกิดขึ้นเช่นเดียวกับข้างต้นสองอ้างอิงที่แข็งแกร่งจะทำให้คนอื่น ๆ ยังมีชีวิตอยู่ แต่มากกว่าสองกรณีระดับในครั้งนี้ก็เช่นชั้นและปิดที่จะทำให้คนอื่น ๆ ยังมีชีวิตอยู่. สวิฟท์ให้เป็นโซลูชั่นที่สง่างามที่จะแก้ไขปัญหานี้รู้จักกันในชื่อรายการจับปิด แต่ก่อนที่จะได้เรียนรู้วิธีที่จะทำลายวงจรการอ้างอิงที่แข็งแกร่งที่มีรายชื่อการจับภาพการปิดจะเป็นประโยชน์ที่จะเข้าใจวิธีการเช่นวงจรสามารถเกิด ตัวอย่างด้านล่างแสดงให้เห็นว่าคุณสามารถสร้างวงจรการอ้างอิงที่แข็งแกร่งเมื่อใช้ปิดที่อ้างอิงตัวเอง ตัวอย่างนี้กำหนดระดับที่เรียกว่า HtmlElement ซึ่งมีรูปแบบที่ง่ายสำหรับองค์ประกอบของแต่ละบุคคลภายในเอกสาร HTML: ระดับ HtmlElement { ขอให้ชื่อ: String ให้ข้อความ: String? @lazy var asHTML: () -> String = { ถ้าปล่อยให้ข้อความ = self.text { กลับ "< (self.name)> (ข้อความ) " } อื่น { กลับ "< (self.name) />" } (ชื่อ: สตริงข้อความ: String = ไม่มี) { ตนเอง name = ชื่อself.text = ข้อความdeinit { println (" (ชื่อ) จะถูก deinitialized") ระดับ HtmlElement กำหนดสถานที่ให้บริการชื่อที่ระบุชื่อขององค์ประกอบเช่น "p" สำหรับองค์ประกอบวรรคหรือ " นอน "สำหรับองค์ประกอบเส้นแบ่ง HtmlElement ยังกำหนดคุณสมบัติข้อความตัวเลือกที่คุณสามารถตั้งค่าเพื่อสตริงที่แสดงข้อความที่จะแสดงผลภายในองค์ประกอบ HTML ที่ นอกจากนี้สองคุณสมบัติที่เรียบง่ายคลาส HtmlElement กำหนดสถานที่ให้บริการที่เรียกว่าขี้เกียจ asHTML สถานที่แห่งนี้อ้างอิงปิดที่รวมชื่อและข้อความลงในส่วนสตริง HTML สถานที่ให้บริการ asHTML เป็นประเภท () -> String หรือ "ฟังก์ชั่นที่จะไม่มีพารามิเตอร์และส่งกลับค่าสตริง" โดยค่าเริ่มต้นสถานที่ให้บริการที่ได้รับมอบหมาย asHTML ปิดที่ส่งกลับแสดงสตริงของแท็ก แท็กนี้มีค่าข้อความไม่จำเป็นถ้ามันมีอยู่แล้วหรือเนื้อหาข้อความถ้าข้อความไม่อยู่ สำหรับองค์ประกอบวรรคปิดจะกลับมา "






















ข้อความบางส่วน"หรือ""ขึ้นอยู่กับว่าสถานที่ให้บริการข้อความเท่ากับ" ข้อความ "หรือศูนย์. ทรัพย์สิน asHTML การตั้งชื่อและนำมาใช้บ้างเช่นวิธีการเช่น. แต่เนื่องจาก asHTML เป็นสถานที่ให้บริการปิดมากกว่าวิธีการเช่นคุณสามารถเปลี่ยนค่าเริ่มต้นของ สถานที่ให้บริการกับ asHTML ปิดที่กำหนดเองถ้าคุณต้องการที่จะเปลี่ยนการแสดงผล HTML สำหรับองค์ประกอบ HTML โดยเฉพาะอย่างยิ่ง. หมายเหตุคุณสมบัติ asHTML ถูกประกาศเป็นสถานที่ให้บริการขี้เกียจเพราะมันเป็นสิ่งจำเป็นเฉพาะในกรณีและเมื่อองค์ประกอบจริงจะต้องมีการแสดงผลเป็น ค่าสตริงสำหรับบางเป้าหมายการแสดงผล HTML. ความจริงที่ว่า asHTML เป็นที่พักขี้เกียจหมายความว่าคุณสามารถดูตัวเองที่อยู่ในการปิดเริ่มต้นเพราะขี้เกียจสถานที่ให้บริการจะไม่สามารถเข้าถึงจนกระทั่งหลังจากที่เริ่มต้นได้เสร็จสมบูรณ์แล้วและตนเองเป็นที่รู้จักกันอยู่. ระดับ HtmlElement ให้ initializer เดียวซึ่งใช้อาร์กิวเมนต์ชื่อและ (ถ้าต้องการ) อาร์กิวเมนต์ข้อความที่จะเริ่มต้นองค์ประกอบใหม่. ชั้นนอกจากนี้ยังกำหนด deinitializer ซึ่งแสดงข้อความที่จะแสดงเมื่อเช่น HtmlElement เป็น deallocated. นี่คือวิธีที่คุณใช้ ระดับ HtmlElement ในการสร้างและพิมพ์ตัวอย่างใหม่: var วรรค: HtmlElement? = HtmlElement (ชื่อ "p" ข้อความ "สวัสดีโลก") (! วรรค .asHTML ()) println // พิมพ์ "








สวัสดีโลก" หมายเหตุตัวแปรวรรคข้างต้นถูกกำหนดให้เป็นตัวเลือก HtmlElement เพื่อที่จะสามารถกำหนดให้ศูนย์ด้านล่างเพื่อแสดงให้เห็นถึงการปรากฏตัวของวงจรการอ้างอิงที่แข็งแกร่ง. แต่น่าเสียดายที่ระดับ HtmlElement, ตามที่เขียนไว้ข้างต้นสร้างวงจรการอ้างอิงที่แข็งแกร่งระหว่าง HtmlElement . และการปิดตัวอย่างที่ใช้ในการเริ่มต้นของค่า asHTML นี่คือวิธีการที่มีลักษณะวงจร: สถานที่ให้บริการของ asHTML เช่นถือหุ้นอ้างอิงที่แข็งแกร่งในการปิด แต่เนื่องจากการปิดหมายถึงตัวเองในร่างกายของตน (เป็นวิธีที่จะอ้างอิงและ self.name. self.text) ปิดจับตัวเองซึ่งหมายความว่ามันถืออ้างอิงที่แข็งแกร่งกลับไปเช่น HtmlElement. วงจรการอ้างอิงที่แข็งแกร่งจะถูกสร้างขึ้นระหว่างทั้งสอง. (สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการจับค่าในการปิดให้ดูที่การจับค่า.) หมายเหตุแม้ว่าการปิดหมายถึงตัวเองหลายครั้งก็จับหนึ่งที่แข็งแกร่งในการอ้างอิงเช่น HtmlElement. ถ้าคุณตั้งค่าตัวแปรวรรคศูนย์และทำลายอ้างอิงที่แข็งแกร่งไปเช่น HtmlElement ไม่เช่น HtmlElement หรือปิดจะ deallocated, เพราะวงจรการอ้างอิงที่แข็งแกร่ง: วรรค = ศูนย์ทราบว่าข้อความใน deinitializer HtmlElement ไม่ถูกพิมพ์ซึ่งแสดงให้เห็นว่าเช่น HtmlElement ไม่ได้ deallocated. แก้ไขวงจรอ้างอิงที่แข็งแกร่งสำหรับการปิดให้คุณแก้ปัญหาวงจรการอ้างอิงที่แข็งแกร่งระหว่างการปิดและชั้น ตัวอย่างเช่นโดยการกำหนดรายชื่อการจับภาพเป็นส่วนหนึ่งของความหมายของการปิด รายการจับกำหนดกฎระเบียบที่จะใช้เมื่อการจับภาพอย่างใดอย่างหนึ่งหรือหลายชนิดอ้างอิงภายในร่างกายของปิด เช่นเดียวกับรอบการอ้างอิงที่แข็งแกร่งระหว่างสองกรณีระดับคุณประกาศการอ้างอิงในแต่ละจับจะมีการอ้างอิงอ่อนแอหรือไม่มีเจ้าของมากกว่าการอ้างอิงที่แข็งแกร่ง เลือกที่เหมาะสมของอ่อนแอหรือไม่มีเจ้าของขึ้นอยู่กับความสัมพันธ์ระหว่างส่วนต่างๆของรหัสของคุณ. สวิฟท์หมายเหตุคุณจะต้องเขียน self.someProperty หรือ self.someMethod (มากกว่าแค่ someProperty หรือ SomeMethod) เมื่อใดก็ตามที่คุณอ้างถึงสมาชิกของตัวเองภายใน การปิด นี้จะช่วยให้คุณจำได้ว่ามันเป็นไปได้ที่จะจับตัวเองโดยอุบัติเหตุ. กำหนดรายชื่อจับแต่ละรายการในรายการจับเป็นจับคู่ของคำหลักที่อ่อนแอหรือไม่มีเจ้าของมีการอ้างอิงถึงเช่นชั้น (เช่นตัวเองหรือ someInstance) การจับคู่เหล่านี้ถูกเขียนภายในคู่ของการจัดฟันตารางคั่นด้วยเครื่องหมายจุลภาค วางรายการจับก่อนที่จะปิดรายการพารามิเตอร์ของประเภทและกลับหากพวกเขาจะได้รับบริการ: @lazy var someClosure (Int, String) -> String = { [ตนเองไม่มีเจ้าของ] (ดัชนี: Int, stringToProcess: String) -> String ใน/ ร่างกาย / ปิดไปที่นี่} ถ้าปิดไม่ได้ระบุรายการพารามิเตอร์หรือกลับชนิดเพราะพวกเขาจะสามารถสรุปจากบริบทวางรายการจับภาพในช่วงเริ่มต้นของการปิดมากตามด้วยคำหลัก: @lazy var someClosure ( ) -> String = { [ตนเองไม่มีเจ้าของ] ในร่างกาย // ปิดที่นี่} อ่อนแอและไม่มีเจ้าของอ้างอิงกำหนดในการจับภาพการปิดเป็นข้อมูลอ้างอิงเมื่อไม่มีเจ้าของและปิดเช่นจะจับมักจะอ้างถึงกันและกันและจะเสมอ จะ deallocated ในเวลาเดียวกัน ตรงกันข้ามกำหนดจับเป็นข้อมูลอ้างอิงที่อ่อนแอเมื่ออ้างอิงจับอาจจะกลายเป็นศูนย์ที่จุดในอนาคตบาง การอ้างอิงที่อ่อนแออยู่เสมอของเลือกประเภทและจะกลายเป็นศูนย์เช่นเมื่อพวกเขาอ้างอิงเป็น deallocated ซึ่งจะช่วยให้คุณสามารถตรวจสอบสำหรับการดำรงอยู่ของพวกเขาภายในร่างกายของปิด

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

ระดับประเทศ ขอให้ชื่อสตริง {

ให้ capitalcity : เมือง !
init ( ชื่อ String , String capitalname : ) {

self.capitalcity self.name = = ชื่อเมือง ( ชื่อ : capitalname , ประเทศ : ตัวเอง )
} {

}
เมืองชื่อ : String
unowned ให้ประเทศ : ประเทศ
( ชื่อ String , ประเทศ : ประเทศ ) self.name {

self.country = = ชื่อ ประเทศ
ตั้งค่าการพึ่งพาอาศัยกันระหว่างสองชนชั้นการ initializer เมืองจะเป็นประเทศตัวอย่าง และร้านค้านี้เช่นในประเทศแห่งนี้ การ initializer เมืองเรียกว่าจากภายใน initializer สำหรับประเทศ อย่างไรก็ตาม initializer ประเทศไม่สามารถผ่านตนเองไปเมือง initializer จนอินสแตนซ์ประเทศใหม่อย่างเริ่มต้น ตามที่อธิบายไว้ในการเริ่มต้นสองเฟส ที่จะรับมือกับความต้องการนี้คุณประกาศ capitalcity ทรัพย์สินของประเทศที่เป็นตัวเลือกคุณสมบัติโดยปริยายซึ่งระบุโดยเครื่องหมายอัศเจรีย์ในตอนท้ายของพิมพ์บันทึกย่อ ( เมือง ) นี้หมายความ ว่า capitalcity ทรัพย์สินมีค่าเริ่มต้นของนิล อย่างอื่นก็ได้ แต่สามารถเข้าถึงได้โดยไม่ต้องแกะเป็นค่าตามที่อธิบายไว้ในห่อ optionals โดยปริยาย .เพราะ capitalcity ได้เริ่มต้นที่ศูนย์ค่า อินสแตนซ์ ประเทศใหม่ ถือว่าครบเริ่มต้นทันทีที่ประเทศตัวอย่างชุดของ ชื่อ คุณสมบัติภายในของ initializer . ซึ่งหมายความว่าประเทศ initializer สามารถเริ่มต้นการอ้างอิงและผ่านรอบคุณสมบัติตนเองความนัยทันทีที่ชื่อสถานที่ตั้งประเทศ initializer จึงสามารถผ่านตนเองเป็นหนึ่งในพารามิเตอร์สำหรับเมือง initializer เมื่อประเทศ initializer คือการตั้งค่าคุณสมบัติ capitalcity ของตัวเอง ทั้งหมดนี้หมายความว่าคุณสามารถสร้างประเทศและเมืองอินสแตนซ์ในงบเดี่ยว โดยไม่ต้องสร้างวงจรอ้างอิงที่แข็งแกร่งและ capitalcity คุณสมบัติสามารถเข้าถึงได้โดยตรงโดยไม่ต้องใช้เครื่องหมายอัศเจรีย์แกะค่า ตัวเลือก :
var = ประเทศ ( ชื่อประเทศ " แคนาดา " capitalname " ออตตาวา " ) ( " (
println ประเทศ ชื่อของเมืองหลวงคือชื่อ ( ชื่อ capitalcity ประเทศ ) " พิมพ์ "
/ / เมืองหลวงของ ออตตาวาแคนาดาเรียกว่า "
ในตัวอย่างข้างต้นใช้เป็นห่อเลือกโดยปริยายหมายความว่าแห่งการเรียน initializer ความต้องการจะพอใจ การ capitalcity คุณสมบัติสามารถใช้และเข้าถึงได้ อย่างไม่เลือก ค่าเริ่มต้นคือเมื่อเสร็จสมบูรณ์ในขณะที่ยังคงหลีกเลี่ยงวงจรอ้างอิงแข็งแรง

แข็งแรงอ้างอิงรอบี่

คุณเห็นข้างต้นว่าวงจรอ้างอิงที่แข็งแกร่งสามารถสร้างขึ้นเมื่อสองห้องตัวอย่างสมบัติถือแข็งแรงอ้างอิงกับแต่ละอื่น ๆ คุณยังเห็นวิธีการใช้อ่อนแอและ unowned อ้างอิงแบ่งเหล่านี้แข็งแรงอ้างอิงรอบ วงจรอ้างอิงที่แข็งแกร่งยังสามารถเกิดขึ้นถ้าคุณกำหนดปิดคุณสมบัติของคลาสอินสแตนซ์ และร่างกายที่ปิดตัว เป็นต้นจับนี้อาจเกิดขึ้นเนื่องจากร่างกายของการปิดการเข้าถึงคุณสมบัติของอินสแตนซ์ เช่น self.someproperty หรือเพราะการเรียกวิธีการบนอินสแตนซ์เช่นตนเอง somemethod() . ในทั้งสองกรณีเหล่านี้เข้าถึงสาเหตุการปิด " จับ " ด้วยตนเอง การสร้างวงจรอ้างอิงที่แข็งแกร่ง นี้เกิดขึ้นเพราะแรงอ้างอิงวงจรปิด เหมือนชั้นเป็นประเภทอ้างอิงเมื่อคุณกำหนดปิดคุณสมบัติ คุณจะให้อ้างอิงที่ปิด สรุปแล้ว มันเป็นปัญหาเดียวกับข้างบนอ้างอิงสองแรงจะรักษากันมีชีวิตอยู่ แต่มากกว่าสองคลาสอินสแตนซ์ ที่เวลานี้มันเป็นคลาสอินสแตนซ์และปิดที่รักษากันมีชีวิตอยู่
Swift ให้เป็นโซลูชั่นที่เป็นหรูหราสำหรับปัญหานี้ เรียกว่าปิดจับภาพรายการอย่างไรก็ตาม ก่อนที่คุณจะเรียนรู้วิธีที่จะทำลายวงจรอ้างอิงที่แข็งแกร่งด้วยการจับรายชื่อ เป็นประโยชน์ในการเข้าใจวิธีการเช่นวงจรสามารถทำให้ . ตัวอย่างด้านล่างแสดงวิธีที่คุณสามารถสร้างวงจรอ้างอิงแข็งแรงเมื่อใช้ปิดที่การอ้างอิงตนเอง ตัวอย่างนี้กำหนดเป็นระดับที่เรียกว่า htmlelement ซึ่งมีรูปแบบที่เรียบง่ายสำหรับแต่ละองค์ประกอบภายในเอกสาร HTML :
ชื่อชั้น htmlelement {


ขอให้สตริงข้อความ : เชือก

@ ขี้เกียจ var ashtml : ( ) -- > สตริง = {
ถ้าข้อความ = self.text {
กลับมา " < ( ตนเอง ชื่อ ) > ( ข้อความ ) < / ( ตนเอง ชื่อ ) "
} {
กลับมาอีก " < ( ตนเอง ชื่อ ) / > "
}
( ชื่อสตริงข้อความ : เชือก = 0 ) {

self.text self.name = ชื่อ = ข้อความ

println deinit { " ( ชื่อ ) จะถูก deinitialized " )

เรียน htmlelement กำหนดชื่อทรัพย์สินซึ่งบ่งชี้ว่า ชื่อของธาตุ เช่น " P " วรรคองค์ประกอบหรือ " แก้ไข " เพื่อแบ่งบรรทัดองค์ประกอบ htmlelement ยังกำหนดคุณสมบัติข้อความตัวเลือกที่คุณสามารถตั้งค่าสตริงที่แสดงถึงข้อความที่จะแสดงผลใน HTML ที่องค์ประกอบ นอกจากคุณสมบัติเหล่านี้ง่าย สอง ชั้น htmlelement เริ่มขี้เกียจคุณสมบัติที่เรียกว่า ashtml .คุณสมบัตินี้อ้างอิงการรวมชื่อและข้อความลงใน HTML เป็นข้อความอะไรบางอย่าง การ ashtml คุณสมบัติของชนิด ( ) - > สตริงหรือ " ฟังก์ชั่นที่ใช้พารามิเตอร์และส่งกลับค่าสตริง " โดยค่าเริ่มต้น ashtml ทรัพย์สินได้รับการปิดที่ส่งกลับสตริงที่เป็นตัวแทนของ HTML แท็ก แท็กนี้ประกอบด้วยค่าข้อความตัวเลือก ถ้ามันมีอยู่จริงหรือ ไม่มีข้อความ ถ้าข้อความที่ไม่มีอยู่จริง สำหรับย่อหน้าองค์ประกอบปิดจะต้องกลับมา " < p > บางข้อความ < / p > " หรือ " < p / > " ขึ้นอยู่กับว่าข้อความคุณสมบัติเท่ากับ " ข้อความ " บางอย่าง หรือนิล การ ashtml คุณสมบัติชื่อและใช้ค่อนข้างชอบ เช่น วิธี อย่างไรก็ตาม เนื่องจากมีการปิด ashtml ที่ดินมากกว่า เช่น วิธีการคุณสามารถแทนที่ค่าเริ่มต้นของ ashtml คุณสมบัติด้วยการปิดเอง ถ้าคุณต้องการที่จะเปลี่ยนการแสดงผล HTML สำหรับเฉพาะ HTML องค์ประกอบ

หมายเหตุ ashtml คุณสมบัติประกาศให้เป็นสมบัติขี้เกียจเพราะมันเป็นเพียงที่จำเป็นและถ้าธาตุจริงๆ แล้วต้องแสดงเป็นค่าสตริงสำหรับ HTML ผลผลิตเป้าหมาย