හැඳින්වීම හෙලෝ! මගේ නම කිරිල් ෆමින්, මම iOS සංවර්ධකයෙක්. අද, මට Swift හි initializers වැනි සරල මාතෘකාවක් හොඳින් පරීක්ෂා කිරීමට අවශ්යයි. එහි සරල බව පෙනෙන්නට තිබුණත්, සමහර විට මෙම මාතෘකාව පිළිබඳ අවබෝධයක් නොමැතිකම නිසා විස්තර සොයා බැලීමකින් තොරව ඉක්මනින් නිවැරදි කිරීමට අවශ්ය කලකිරීමට පත්වන දෝෂ ඇති වේ. සම්පූර්ණ මෙම ලිපියෙන්, අපි ආරම්භකයින්ට අදාළ සියල්ල ආවරණය කරන්නෙමු, ඒවා අතර: අභිරුචි එකක් නිර්වචනය කරන අතරතුර ව්යුහයේ සාමාජික මට්ටමේ ආරම්භකය රඳවා ගන්නේ කෙසේද පන්තිවල සෑම විටම ආරම්භකයක් ලිවීම අවශ්ය නොවන්නේ ඇයි නම් කරන ලද ආරම්භක යන්ත්රයක ඇමතීම සැමවිටම අවශ්ය නොවන්නේ ඇයි? super.init ඇමතීමට පෙර උපපංතියක සියලුම ක්ෂේත්ර පුරවා තිබිය යුත්තේ ඇයි? super.init උපපංතිවල අවම අතිච්ඡාදනයන් සහිත සියලුම මාපිය ආරම්භකකරුවන්ට ප්රවේශ වන්නේ කෙසේද හරියටම ආරම්භකයක් අවශ්ය වූ විට required සැමවිටම පරාමිතීන් නොමැතිව හඳුන්වනු ලබන්නේ ඇයි, නමුත් සහ අභිබවා යන්නේ ඇයි? UIView.init() init(frame:) init(coder:) ...සහ තවත්. නමුත් අපි එය පියවරෙන් පියවර ගනිමු. අන්තර්ගත වගුව මූලික කරුණු ව්යුහයන් සාමාජිකත්ව ආරම්භකය විකල්ප vs var let සාමාජිකත්ව ආරම්භකයක් රඳවා තබා ගැනීම පන්ති නම් කරන ලද ආරම්භකය පහසුව සඳහා ආරම්භකය සුපිරි පන්තියේ පහසුව සඳහා ආරම්භකය රඳවා තබා ගැනීම අතිච්ඡාදන ගණන අවම කිරීම සම්පාදක සහාය ආරම්භකකාරකය: generics, protocols, , required Self() final පරාමිතීන් නොමැතිව UIView() ගෞරවනීය සඳහන් කිරීම් අසාර්ථක ආරම්භය එනම්ස් සාරාංශය අදාළ සබැඳි මූලික කරුණු ඇපල් හි මාර්ගෝපදේශය වන (ආරම්භකයින් සඳහා පුදුම සහගත ලෙස සවිස්තරාත්මක) මෙසේ පවසයි: ස්විෆ්ට් ක්රමලේඛන භාෂාව (6) යනු පන්තියක, ව්යුහයක හෝ ගණන් කිරීමේ අවස්ථාවක් භාවිතය සඳහා සකස් කිරීමේ ක්රියාවලියයි. මෙම ක්රියාවලියට එම අවස්ථාවේ ගබඩා කර ඇති සෑම දේපලක් සඳහාම ආරම්භක අගයක් සැකසීම සහ නව අවස්ථාව භාවිතයට සූදානම් වීමට පෙර අවශ්ය වෙනත් ඕනෑම සැකසුමක් හෝ ආරම්භයක් සිදු කිරීම ඇතුළත් වේ. ආරම්භ කිරීම ඔබ මෙම ආරම්භක ක්රියාවලිය ක්රියාත්මක කරන්නේ නිර්වචනය කිරීමෙනි, ඒවා විශේෂිත වර්ගයක නව අවස්ථාවක් නිර්මාණය කිරීමට කැඳවිය හැකි විශේෂ ක්රම වැනිය. Objective-C initializers මෙන් නොව, Swift initializers අගයක් ආපසු ලබා නොදේ. ඔවුන්ගේ ප්රධාන කාර්යභාරය වන්නේ පළමු වරට භාවිතා කිරීමට පෙර වර්ගයක නව අවස්ථා නිවැරදිව ආරම්භ කර ඇති බව සහතික කිරීමයි. initializers හොඳයි, මම හිතන්නේ මට මෙතනට කිසිවක් එකතු කිරීමට අවශ්ය නැහැ. ව්යුහයන් ව්යුහ ආරම්භකකරුවන් සාකච්ඡා කිරීමෙන් පටන් ගනිමු. උරුමයක් නොමැති නිසා මෙය තරමක් සරල ය, නමුත් ඔබ දැනගත යුතු නීති කිහිපයක් තවමත් තිබේ. සාමාජිකත්ව ආරම්භකය අපි සරල ව්යුහයක් ලියමු: struct BankAccount { let amount: Double let isBlocked: Bool } let bankAccount = BankAccount(amount: 735, isBlocked: Bool) ආරම්භකයක් පැහැදිලිව ප්රකාශ නොකර ව්යුහය ආරම්භ කිරීමට අපට හැකි වූ බව සලකන්න. මෙය සිදුවන්නේ ව්යුහයන්ට සම්පාදකය මඟින් ජනනය කරන ලද ලැබෙන බැවිනි. මෙය ක්රියාත්මක වන්නේ . සාමාජික මට්ටමේ ආරම්භකයක් ව්යුහයන් සඳහා පමණි තේරීමෙන්, එය පෙනෙන්නේ කෙසේදැයි ඔබට දැක ගත හැකිය: Refactor → Generate memberwise initializer init(amount: Double, isBlocked: Bool) { self.amount = amount self.isBlocked = isBlocked } අත්සනින්, සියලු පරාමිතීන් සඳහා අගයන් ලබා දීමට අපොහොසත් වීමෙන් සම්පාදන දෝෂයක් ඇති වන බව පහසුවෙන් දැකගත හැකිය: let bankAccount = BankAccount(amount: 735) // ❌ Missing argument for parameter 'isBlocked' in call කෙසේ වෙතත්, ඔබට අවශ්ය තර්ක ගණන අඩු කිරීමට අවශ්ය නම්, ඔබට අභිරුචි ආරම්භකයක් අර්ථ දැක්විය හැකිය: init(amount: Double, isBlocked: Bool = false) { self.amount = amount isBlocked = isBlocked } let bankAccount = BankAccount(amount: 735) // ✅ පුරවා නොමැති නම්, බැවින්, මෙය සම්පාදන දෝෂයකට හේතු වන බව සලකන්න. isBlocked සියලුම ව්යුහ ගුණාංග ආරම්භකකාරකයක පුරවා ගත යුතු vs විකල්ප, var let ක්ෂේත්රයක් පුරවා ගැනීමට අවශ්ය නොවන එකම අවස්ථාව වන්නේ එය ( ) වන විට පමණි ( ). එවැනි අවස්ථාවන්හිදී, ක්ෂේත්රය පෙරනිමියෙන් වනු ඇත: පැහැදිලිව විකල්ප ? විචල්යයක් var nil struct BankAccount { let amount: Double var isBlocked: Bool? init(amount: Double) { self.amount = amount } } let bankAccount = BankAccount(amount: 735) // ✅ කෙසේ වෙතත්, මෙම අවස්ථාවේදී අපි memberwise initializer භාවිතා කිරීමට උත්සාහ කළහොත්, අපට සම්පාදන දෝෂයක් ලැබෙනු ඇත: let bankAccount = BankAccount( amount: 735, isBlocked: false ) // ❌ Extra argument 'isBlocked' in call සාමාජිකත්ව ආරම්භකයක් රඳවා තබා ගැනීම මෙය සිදුවන්නේ අභිරුචි ආරම්භකයක් ප්රකාශ කිරීමෙන් සාමාජික මට්ටමේ ආරම්භකය ඉවත් වන බැවිනි. එය තවමත් පැහැදිලිව අර්ථ දැක්විය හැකි නමුත් එය ස්වයංක්රීයව ලබා ගත නොහැක. කෙසේ වෙතත්, memberwise initializer රඳවා ගැනීමට කුඩා උපක්රමයක් තිබේ: අභිරුචි initializer ප්රකාශ කරන්න. extension struct BankAccount { let amount: Double var isBlocked: Bool? } extension BankAccount { init(amount: Double) { self.amount = amount } } let barclaysBankAccount = BankAccount(amount: 735) // ✅ let revolutBankAccount = BankAccount(amount: 812, isBlocked: false) // ✅ print(barclaysBankAccount.isBlocked) // nil print(barclaysBankAccount.isBlocked) // false ව්යුහයන් සඳහා සාරාංශය සියලුම ක්ෂේත්ර ආරම්භකකාරකයක පුරවා තිබිය යුතුය. සකසා ඇත විකල්ප var ක්ෂේත්ර පෙරනිමියෙන් nil ව්යුහයන්ට නොමිලේ සාමාජිකත්ව ආරම්භකයක් ලැබේ. අභිරුචි ආරම්භකයක් ප්රකාශ කළහොත් සාමාජික මට්ටමේ ආරම්භකය අතුරුදහන් වේ. ව්යුහයේ සාමාජික මට්ටමේ ආරම්භකය රඳවා ගැනීමට, දිගුවක අභිරුචි එකක් අර්ථ extension පන්ති නම් කරන ලද ආරම්භකය පන්තියක් සඳහා ප්රාථමික ආරම්භකය වේ. එය අරමුණු දෙකක් ඉටු කරයි: නම් කරන ලද ආරම්භකය සියලුම ක්ෂේත්ර පිරී ඇති බව සහතික කරයි. පන්තිය උරුම වී ඇත්නම්, එය සුපිරි පන්තියේ ආරම්භකය ලෙස හැඳින්වේ. class Animal { var name: String init(name: String) { self.name = name } } class Dog: Animal { var breed: String var name: String init(breed: String, name: String) { self.breed = breed super.init(name: name) } } ඇමතීමට . මන්ද, superclass initializer උපපංතිය මගින් අභිබවා ගිය ක්රම කැඳවිය හැකි අතර එමඟින් ජනාකීර්ණ නොවූ උපපංති ගුණාංග වෙත ප්රවේශ විය හැකිය. super.init පෙර සියලුම ක්ෂේත්ර පිරවිය යුතුය class Animal { var age: Int init(age: Int) { self.age = age getInfo() } func getInfo() { print("Age: ", age) } } class Dog: Animal { var breed: String init(breed: String, age: Int) { self.breed = breed // imagine we haven't done this super.init(age: age) } override func getInfo() { print("Age: ", age, ", breed: ", breed) } } මේ අනුව, අපි සකසා නොතිබුනේ නම්, අපට ධාවන කාල දෝෂයක් ඇති වීමට ඉඩ තිබුණි, මන්ද initializer එක පන්තියෙන් overrided ක්රමය කැඳවනු ඇත. මෙම ක්රමය තවමත් ජනනය කර නොමැති දේපල වෙත ප්රවේශ වීමට උත්සාහ කරයි. self.breed = breed Animal Dog getInfo() breed ව්යුහයන් මෙන් නොව, පන්තිවලට ව්යංග සාමාජික මට්ටමේ ආරම්භකයක් නොලැබේ. ආරම්භ නොකළ ගුණාංග තිබේ නම්, සම්පාදන දෝෂයක් ඇතිවේ: class Animal { // ❌ Class 'Animal' has no initializers var age: Int } class Animal { // ✅ var age: Int = 0 } class Animal { // ✅ var age: Int? } class Animal { } // ✅ පහසුව සඳහා ආරම්භකය පන්තිවලට ද තිබිය හැකිය. නම් කරන ලද ආරම්භකයන් මෙන් නොව, ඒවා මුල සිටම වස්තුවක් නිර්මාණය නොකරන නමුත් අනෙකුත් ආරම්භකයන්ගේ තර්කනය නැවත භාවිතා කිරීමෙන් ආරම්භක ක්රියාවලිය සරල කරයි. පහසු ආරම්භකයක් class Rectangle { var width: Double var height: Double init(width: Double, height: Double) { self.width = width self.height = height } convenience init(side: Double) { self.init(width: side, height: side) // uses a designated initializer of self } } Convenience initializers හට designated initializers හෝ වෙනත් convenience initializers ඇමතිය හැක. අවසාන වශයෙන්, designated initializer සැමවිටම කැඳවනු ලැබේ. පහසු ආරම්භක යන්ත්ර සෑම විටම තිරස් අතට යයි (self.init), සහ නම් කරන ලද ආරම්භක යන්ත්ර සිරස් අතට යයි (super.init). සුපිරි පන්තියේ පහසුව සඳහා ආරම්භකය රඳවා තබා ගැනීම උපපංතියක් නව ගුණාංග ප්රකාශ කළ වහාම, සුපිරිපංතියේ සියලුම පහසු ආරම්භක වෙත ප්රවේශය අහිමි වේ. class Animal { var age: Int var name: String init(age: Int, name: String) { self.age = age self.name = name } convenience init(age: Int) { self.init(age: age, name: "Default") } convenience init(name: String) { self.init(age: 0, name: name) } } class Dog: Animal { var breed: String init(age: Int, name: String, breed: String) { self.breed = breed super.init(age: age, name: name) } } let dog = Dog(age: 3) // ❌ Missing arguments for parameters 'breed', 'name' in call අභිබවා යාමෙන් මෙය නිවැරදි කළ හැක. සුපිරි පන්තියේ නම් කරන ලද සියලුම ආරම්භක class Dog: Animal { // ... override init(age: Int, name: String) { self.breed = "Mixed" super.init(age: age, name: name) } } let dog = Dog(age: 3) // ✅ මේ ආකාරයෙන්, ඊළඟ උපපංතියේ පහසු ආරම්භකයක් භාවිතා කිරීමට, ඔබ ආරම්භක අභිබවා යා යුතු බව දැකීම පහසුය. දෙකක් class GuideDog: Dog { var isTrained: Bool override init(age: Int, name: String) { self.isTrained = false super.init(age: age, name: name) } override init(age: Int, name: String, breed: String) { self.isTrained = false super.init(age: age, name: name, breed: breed) } init(age: Int, name: String, breed: String, isTrained: Bool) { self.isTrained = isTrained super.init(age: age, name: name, breed: breed) } } let dog = GuideDog(age: 3) // ✅ අතිච්ඡාදන ගණන අවම කිරීම කෙසේ වෙතත්, භාවිතා කිරීමෙන් මෙය වළක්වා ගත හැකිය. පහසුව සඳහා අතික්රමණය කිරීමේ ආරම්භකයක් class Dog: Animal { var breed: String convenience override init(age: Int, name: String) { self.init(age: age, name: name, breed: "Mixed") // self, not super } init(age: Int, name: String, breed: String) { self.breed = breed super.init(age: age, name: name) } } class GuideDog: Dog { var isTrained: Bool // override init(age: Int, name: String) { // self.isTrained = false // // super.init(age: age, name: name, breed: "Mixed") // } convenience override init(age: Int, name: String, breed: String) { self.init(age: age, name: name, breed: breed, isTrained: false) // self, not super } init(age: Int, name: String, breed: String, isTrained: Bool) { self.isTrained = isTrained super.init(age: age, name: name, breed: breed) } } let dog = GuideDog(age: 3) // ✅ දැන් අපට සෑම උපපංතියකම පැහැදිලිව නිශ්චිත ආරම්භක 2 ක් පමණක් ඇත. වෙනුවට designated init ලෙස හඳුන්වන ආකාරය සැලකිල්ලට ගන්න. convenience override initializers super.init self මෙම උපක්රමය Tjeerd විසින් රචිත හි 5 වන පරිච්ඡේදයේ හොඳින් පැහැදිලි කර ඇත, එය මම බෙහෙවින් නිර්දේශ කරන පොතකි. "Swift in Depth" අතරමැදි සාරාංශය සියලුම ගුණාංග පිරවූ බව සහතික කරන අතර ලෙස හඳුන්වයි. නම් කරන ලද ආරම්භකයක් super.init() නම් කරන ලද ආරම්භකයක් ඇමතීමෙන් ආරම්භ කිරීම සරල කරයි. පහසු ආරම්භකයක් උපපංති නව ගුණාංග ප්රකාශ කළහොත් ලබා ගත නොහැක. පහසුව සඳහා ආරම්භකයක් සුපිරි පන්තියක ප්රතිසාධනය කිරීම සඳහා, එහි නම් කරන ලද සියලුම ආරම්භක යන්ත්ර අභිබවා යා යුතුය. පහසුව සඳහා ආරම්භක යන්ත්රය අතිච්ඡාදනය කිරීම් ගණන අවම කිරීම සඳහා, භාවිතා කළ හැකිය. පහසුව සඳහා අතිච්ඡාදනය කිරීමේ ආරම්භකයක් සම්පාදක සහාය උපපංතියක් නව පරාමිතීන් හඳුන්වා නොදෙන්නේ නම්, එය සුපිරිපංතියේ සියලුම ආරම්භක ස්වයංක්රීයව උරුම කර ගන්නා බව අපි දැනටමත් සාකච්ඡා කර ඇත්තෙමු. class Base { let value: Int init() { value = 0 } init(value: Int) { self.value = value } } class Subclass: Base { } let subclass = Subclass() // ✅ let subclass = Subclass(value: 3) // ✅ කෙසේ වෙතත්, තවත් වැදගත් කරුණක් තිබේ: සුපිරි පන්තියට නම් කරන ලද එක් ආරම්භකයක් පමණක් තිබේ නම් සහ එය පරාමිති රහිත නම් ( තර්ක නොමැතිව), එවිට උප පන්තියේ පැහැදිලිව ප්රකාශ කරන ලද ආරම්භකයින්ට ඇමතීමට . මෙම අවස්ථාවේදී, Swift සම්පාදකය ඇමතුම ලබා ගත හැකි තර්ක නොමැතිව ඇතුල් කරයි. init() super.init() අවශ්ය නොවේ ස්වයංක්රීයව super.init() class Base { init() { } } class Subclass: Base { let secondValue: Int init(secondValue: Int) { self.secondValue = secondValue // ✅ without explicit super.init() } } කේතය සම්පාදනය වන්නේ ව්යංගයෙන් හැඳින්වෙන බැවිනි. පහත උදාහරණ කිහිපයක් සඳහා මෙය ඉතා වැදගත් වේ. super.init() අවශ්යයි උපපංතියකට මූලික පන්තියට සමාන ආරම්භකකාරකයක් තිබිය යුතු සෑම අවස්ථාවකම ආරම්භකකාරකයක් භාවිතා වේ. එය ලෙසද හැඳින්විය යුතුය. ආරම්භකකාරකයක් අවශ්ය වන අවස්ථා සඳහා උදාහරණ පහත දැක්වේ. required super.init() required ජෙනරික්ස් සාමාන්ය වර්ගයකින් ඇමතීමට හැකි වන්නේ එය ලෙස ප්රකාශ කිරීමෙන් පමණි. init required init class Base { } class Subclass: Base { } struct Factory<T: Base> { func initInstance() -> T { // ❌ Constructing an object of class T() // type 'T' with a metatype value } // must use a 'required' initializer } මෙම කේතය සම්පාදනය නොවේ, මන්ද හි උප පන්ති ගැන කිසිවක් නොදන්නා බැවිනි. මෙම විශේෂිත අවස්ථාවේදී, පරාමිතීන් නොමැතිව එකක් තිබුණද, එය නව ක්ෂේත්රයක් හඳුන්වා දුන්නේ නම් සිතන්න: Factory Base Subclass init() class Subclass: Base { let value: Int init(value: Int) { self.value = value } } මෙන්න, එහි තවදුරටත් හිස් නොමැති බැවින්, එය පරිදි ප්රකාශ කළ යුතුය. init required class Base { required init() { } } class Subclass: Base { } struct Factory<T: Base> { static func initInstance() -> T { // ✅ T() } } let subclass = Factory<Subclass>.initInstance() අපි පැහැදිලිව ප්රකාශ නොකළද, සම්පාදකයා එය අප වෙනුවෙන් ජනනය කළ බව සලකන්න. මෙය තුළ සාකච්ඡා කරන ලදී. ස්වයංක්රීයව උරුම වූ අතර එය ලෙස හැඳින්වේ. Subclass required init සම්පාදක සහාය required init super.init() class Subclass: Base { required init() { super.init() } } ප්රොටෝකෝල ප්රොටෝකෝලවල ප්රකාශ කර ඇති සියලුම ආරම්භක විය යුතුය: required protocol Initable { init() } class InitableObject: Initable { init() { // ❌ Initializer requirement 'init()' can only // be satisfied by a 'required' initializer } // in non-final class 'InitableObject' } නැවතත්, මෙය අවශ්ය වන්නේ සම්පාදකයා විසින් උපපංතිය ප්රොටෝකෝල ආරම්භකය ක්රියාත්මක කරන බව සහතික කිරීම සඳහා ය. අප දැනටමත් දන්නා පරිදි, මෙය සැමවිටම සිදු නොවේ - නොවේ නම්, උපපංතිය එය අභිබවා යාමට බැඳී නොමැති අතර තමන්ගේම ආරම්භකය නිර්වචනය කළ හැකිය. init required class IntValue: InitableObject { let value: Int init(value: Int) { self.value = value } } let InitableType: Initable.Type = IntValue.self let initable: Initable = InitableType.init() ඇත්ත වශයෙන්ම, නොවන නිසා පහත කේතය සම්පාදනය නොවේ. Base.init() required class InitableObject: Initable { required init() { } // ✅ } class IntValue: InitableObject { let value: Int required init() { self.value = 0 } init(value: Int) { self.value = value } } ස්වයං() ස්ථිතික ක්රම වලදී ආරම්භකය ඇමතීමේදීද මෙවැනිම තත්වයක් ඇතිවේ. Self() class Base { let value: Int init(value: Int) { self.value = value } static func instantiate() -> Self { Self(value: 3) // ❌ Constructing an object of class type 'Self' } // with a metatype value must use a 'required' initializer } සෑම විටම මෙන්, ගැටළුව පවතින්නේ උරුමය තුළ ය: class Subclass: BaseClass { let anotherValue: Int init(anotherValue: Int) { self.anotherValue = anotherValue } } let subclass = Subclass.instantiate() // ❌ class BaseClass { let value: Int required init(value: Int) { // ✅ self.value = value } static func instantiate() -> Self { Self(value: 3) } } ඉවත් කිරීම: required final හි අරමුණ උපපංතිවල ආරම්භකයක් ක්රියාත්මක කිරීම බලාත්මක කිරීම බැවින්, ස්වාභාවිකවම, මූල පදය භාවිතා කරමින් උරුමය තහනම් කිරීමෙන් ආරම්භකයක් ලෙස සලකුණු කිරීමේ අවශ්යතාවය ඉවත් වේ. required final required protocol Initable { init() } final class InitableObject: Initable { } // ✅ protocol ValueInitable { init(value: Int) } final class ValueInitableObject: ValueInitable { init(value: Int) { } // ✅ } අතරමැදි සාරාංශය උපපංතියක් නව පරාමිතීන් හඳුන්වා නොදෙන්නේ නම්, එය ස්වයංක්රීයව එහි සුපිරිපංතියෙන් සියලුම ආරම්භකයන් උරුම කර ගනී. සුපිරි පන්තියේ පරාමිතීන් නොමැතිව පමණක් තිබේ නම්, එය උප පන්තියේ ආරම්භක යන්ත්රවල ස්වයංක්රීයව හැඳින්වේ. init() ජෙනරික්ස්, ප්රොටෝකෝල සහ වල භාවිතය සඳහා උපපංතිවල එහි පැවැත්ම සහතික කිරීම සඳහා ආරම්භකයක් අවශ්ය වේ. Self() required UIVE() පරාමිතීන් නොමැතිව ආරම්භකය පිළිබඳ කෙටි සඳහනක්, එය ලේඛනවල සොයාගත නොහැකි නමුත් අභිරහස් ලෙස සෑම තැනකම භාවිතා වේ. UIView() හේතුව හට පරාමිතීන් නොමැතිව එකක් ඇති වෙතින් උරුම වීමයි. , මෙම ආරම්භකකාරකය අතුරුමුහුණතෙහි පැහැදිලිව ප්රකාශ කර නැත, නමුත් එය තවමත් පවතී: UIView init() NSObject එබැවින් UIView @available(iOS 2.0, *) @MainActor open class UIView : UIResponder, NSCoding, UIAppearance, UIAppearanceContainer, UIDynamicItem, UITraitEnvironment, UICoordinateSpace, UIFocusItem, UIFocusItemContainer, CALayerDelegate { open class var layerClass: AnyClass { get } public init(frame: CGRect) public init?(coder: NSCoder) open var isUserInteractionEnabled: Bool // no init() කෙසේ වෙතත්, ආවරණය යටතේ, මෙම ආරම්භකකාරකය කේතයෙන් ආරම්භ කළ විට ලෙසද, අතුරුමුහුණත් සාදන්නා හරහා ආරම්භ කළ විට ලෙසද හඳුන්වයි. මෙය සිදුවන්නේ තමන්ගේම ක්රියාත්මක කිරීම සපයන බැවිනි, සහ සඳහා විවිධ ලිපින ආපසු ලබා දෙන බව තහවුරු කළ හැකිය. init(frame:) init(coder:) UIView NSObject.init() method_getImplementation NSObject.init() UIView.init() ගෞරවනීය සඳහන් කිරීම් අසාර්ථක ආරම්භය අසාර්ථක විය හැකි init එකක් යනු විකල්පයක් ආපසු ලබා දෙන එකක් පමණි final class Failable { let positiveValue: Int init?(value: Int) { guard value > 0 else { return nil } positiveValue = value } } එනුම් අමු අගයක් සහිත එනම් වලට නොමිලේ init?(rawValue:) enum Direction: String { case north case west case south case east } let north = Direction(rawValue: "north") ඔබට enums සඳහා අභිරුචි init එකක් ද නිර්මාණය කළ හැකිය. සියලුම enum inits පැවරිය යුතුය. self enum DeviceType { case phone case tablet init(screenWidth: Int) { self = screenWidth > 800 ? .tablet : .phone } } අවසාන සාරාංශය අපි Swift හි initializers වල සියලුම අත්යවශ්ය අංග ආවරණය කර ඇත්තෙමු: ආරම්භකයක, සියලුම ක්ෂේත්ර පුරවා තිබිය යුතුය. විකල්ප ගුණාංග පෙරනිමියෙන් . var nil ව්යුහයන්ට නොමිලේ ලැබේ. සාමාජිකත්ව ආරම්භකයක් අභිරුචි . ආරම්භකයක් අර්ථ දක්වා ඇති විට සාමාජික මට්ටමේ ආරම්භකය අතුරුදහන් වේ සියලුම ක්ෂේත්ර පුරවා ඇති බව සහතික කරන අතර අමතයි. නම් කරන ලද ආරම්භකයක් super.init() නම් කරන ලද ආරම්භකයක් ඇමතීමෙන් ආරම්භ කිරීම සරල කරයි. පහසු ආරම්භකයක් පහසු ආරම්භක යන්ත්ර සෑම විටම යයි ( ), සහ නම් කරන ලද ආරම්භක යන්ත්ර යයි ( ). තිරස් අතට self.init සිරස් අතට super.init උපපංති නව ගුණාංග ප්රකාශ කළහොත් ලබා ගත නොහැක. පහසුව සඳහා ආරම්භකයක් සුපිරි පන්තියක ප්රතිසාධනය කිරීම සඳහා, එහි නම් කරන ලද සියලුම ආරම්භක යන්ත්ර අභිබවා යා යුතුය. පහසුව සඳහා ආරම්භක යන්ත්රය අතිච්ඡාදනය කිරීම් ගණන අවම කිරීම සඳහා, භාවිතා කළ හැකිය. පහසුව සඳහා අතිච්ඡාදනය කිරීමේ ආරම්භකයක් උපපංතියක් නව පරාමිතීන් හඳුන්වා නොදෙන්නේ නම්, එය ස්වයංක්රීයව එහි සුපිරිපංතියෙන් සියලුම ආරම්භකයන් උරුම කර ගනී. සුපිරි පන්තියේ පරාමිතීන් නොමැතිව පමණක් තිබේ නම්, එය ස්වයංක්රීයව උප පන්තියේ ආරම්භක තුළ කැඳවනු ලැබේ. init() ජෙනරික්ස්, ප්රොටෝකෝල සහ වල භාවිතය සඳහා උපපංතිවල එහි පැවැත්ම සහතික කරයි. අවශ්ය ආරම්භකයක්, Self() මඟින් හෝ අමතයි. UIView.init() UIView.init(frame:) UIView.init(coder:) විකල්පයක් ආපසු ලබා දෙයි. අසාර්ථක ආරම්භකයක් අමු අගයක් සහිත එනම් වලට නොමිලේ ලැබේ. init?(rawValue:) සියලුම enum ආරම්භකයින් පැවරිය යුතුය. self මෙම ලිපියෙන් ඔබට ප්රයෝජනවත් යමක් හමු වූ බව මම බලාපොරොත්තු වෙමි. යමක් අපැහැදිලි නම් හෝ ඔබට සාවද්ය බවක් පෙනේ නම්, නොමිලේ පැහැදිලි කිරීමක් සඳහා ටෙලිග්රෑම් හරහා මාව සම්බන්ධ කර ගැනීමට නිදහස් වන්න: . @kfamyn අදාළ සබැඳි ස්විෆ්ට් ක්රමලේඛන භාෂාව (6) / ආරම්භ කිරීම Swift in Depth by Tjeerd in 't Veen විදුලි පණිවුඩය - @kfamyn
