WWDC 2015 ഡെവലപ്പർ കോൺഫറൻസിൻ്റെ ഉദ്ഘാടന വേളയിൽ, ആപ്പിൾ അതിൻ്റെ പ്രധാന പ്ലാറ്റ്‌ഫോമുകളായ iOS 9, OS X El Capitan എന്നിവയിലേക്ക് അപ്‌ഡേറ്റുകൾ അവതരിപ്പിച്ചു. എന്നാൽ ഡവലപ്പർമാരെ സംബന്ധിച്ചിടത്തോളം, പ്രോഗ്രാമിംഗ് ഭാഷയുടെ രണ്ടാമത്തെ പതിപ്പാണ് ഏറ്റവും പ്രധാനപ്പെട്ട പ്രഖ്യാപനങ്ങളിലൊന്ന്. ഒബ്ജക്റ്റീവ്-സിയുടെ ബുദ്ധിമുട്ടുള്ള പാരമ്പര്യത്തിൽ നിന്ന് മുക്തമായ ഒരു ഭാഷ സൃഷ്ടിക്കാൻ ആപ്പിൾ ശ്രമിച്ചതായി ഉൽപ്പന്ന അവതരണ വേളയിൽ ക്രെയ്ഗ് ഫെഡറിഗി പറഞ്ഞു. നെക്സ്റ്റ് പ്ലാറ്റ്‌ഫോമിലാണ് സ്വിഫ്റ്റ് നിർമ്മിച്ചത്, അത് ഒഎസ് എക്സിനും ഐഒഎസിനും അടിസ്ഥാനമായി.

സ്വിഫ്റ്റ് ശരിക്കും സൗകര്യപ്രദമാണ് ശക്തമായ ഭാഷ, ഇത് ആപ്പിൾ ഇക്കോസിസ്റ്റത്തിൽ ഒബ്ജക്റ്റീവ്-സി മാറ്റിസ്ഥാപിക്കുമെന്ന് മാത്രമല്ല, മുഴുവൻ സി കുടുംബത്തെയും മൊത്തത്തിൽ കയ്യേറ്റം ചെയ്യാനും അവകാശപ്പെടുന്നു. ബ്ലോഗർ ആൻ്റൺ മുഖതേവ്, നിരവധി പ്രോഗ്രാമിംഗ് ഭാഷകൾ പഠിക്കുന്നത്, അഞ്ച് നേട്ടങ്ങൾ ആപ്പിൾ സ്വിഫ്റ്റ്പുതിയ ഉപയോക്താക്കൾക്കായി. എളുപ്പത്തിൽ വായിക്കാവുന്ന വാക്യഘടന, വ്യക്തമായ നിർമ്മിതികൾ, സുരക്ഷ, പരിചയസമ്പന്നരായ സ്വിഫ്റ്റ് പ്രോഗ്രാമർമാരുടെ അഭാവം എന്നിവ ഇതിൽ ഉൾപ്പെടുന്നു.

1. ഇപ്പോഴും പരിചയസമ്പന്നരായ സ്വിഫ്റ്റ് ഡെവലപ്പർമാർ ഇല്ല

എല്ലാവരും, ഒരു അപവാദവുമില്ലാതെ, പഠിക്കുകയും വീണ്ടും പഠിക്കുകയും വേണം. 2015-ൽ നിങ്ങൾ സ്വിഫ്റ്റ് ഏറ്റെടുക്കുകയാണെങ്കിൽ, എത്ര വർഷങ്ങൾക്ക് ശേഷവും നിങ്ങൾ ഏറ്റവും പരിചയസമ്പന്നരായ പ്രോഗ്രാമർമാരേക്കാൾ ഒരു വർഷമെങ്കിലും പിന്നിലായിരിക്കും. പരിചയസമ്പന്നരായ കോഡർമാർക്കുള്ള ഒരേയൊരു നേട്ടം സ്വിഫ്റ്റ് കടമെടുക്കുന്നു എന്നതാണ് മികച്ച ഘടകങ്ങൾമറ്റ് ഭാഷകൾ - അവ അറിയുന്നവർക്ക് അതിൽ പ്രാവീണ്യം നേടുന്നത് എളുപ്പമാണ്.

2. ഇതൊരു യുവ പ്രോഗ്രാമിംഗ് ഭാഷയാണ്

സ്വിഫ്റ്റിൻ്റെ പുതിയ പതിപ്പുകൾ വാക്യഘടനയിലും ഡാറ്റ തരങ്ങളിലും അടിസ്ഥാനപരമായ മാറ്റങ്ങൾ കാണുന്നത് തുടരുന്നു. ഭാഷ നമ്മുടെ കൺമുന്നിൽ പക്വത പ്രാപിക്കുന്നു, ഇത് മാറ്റത്തിൻ്റെ യുക്തി മനസ്സിലാക്കുന്നത് എളുപ്പമാക്കുന്നു - നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, അത് മെച്ചപ്പെടുത്താൻ നിങ്ങൾക്ക് സഹായിക്കാനാകും. തീർച്ചയായും, ചിലർ ഇതിനെ ഒരു പോരായ്മയായി വിളിക്കാം, കാരണം സ്വിഫ്റ്റിൻ്റെ പഴയ പതിപ്പുകളിൽ എഴുതിയ പ്രോജക്റ്റുകൾ പുതിയവയിൽ പ്രവർത്തിക്കുന്നില്ല - എന്നാൽ മൈഗ്രേഷൻ അത്രയും സമയമെടുക്കുന്നില്ല, മാത്രമല്ല വാക്യഘടന ലളിതമാവുകയും ചെയ്യുന്നു.

3. ഇതൊരു സുരക്ഷിത പ്രോഗ്രാമിംഗ് ഭാഷയാണ്

സാധ്യമായത്ര കുറച്ച് കേടുപാടുകൾ ഒഴിവാക്കാനും കോഡ് പിശകുകളിൽ നിന്ന് കഴിയുന്നത്ര സുരക്ഷിതമാക്കാനുമുള്ള ആഗ്രഹത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ് സ്വിഫ്റ്റ്. പ്രോഗ്രാമർ തൻ്റെ തലയിൽ എല്ലാം സൂക്ഷിക്കുകയും എല്ലാം ട്രാക്ക് ചെയ്യുകയും ചെയ്യേണ്ടതില്ല. സി പോലുള്ള ഭാഷകളിൽ ഇത് ആവശ്യമാണ്, മറ്റുള്ളവരേക്കാൾ വേഗത്തിൽ പ്രവർത്തിച്ചതിനാൽ നേരത്തെ ഇത് ന്യായീകരിക്കപ്പെട്ടിരുന്നുവെങ്കിൽ, C++ ഉപയോഗിച്ചും സ്വിഫ്റ്റ് പ്രകടനത്തിൽ എത്തുന്നു - അത് മുന്നോട്ട് പോകുന്തോറും അത് ഒപ്റ്റിമൈസ് ചെയ്യപ്പെടും. സ്വിഫ്റ്റിൽ കോഡ് എഴുതുന്ന ഒരു പ്രോഗ്രാമർക്ക് മെമ്മറി മാനേജ്മെൻ്റും മറ്റ് കാര്യങ്ങളുമായി ബന്ധപ്പെട്ട ധാരാളം തലവേദനകൾ നഷ്ടപ്പെടും.

4. പൈത്തണും റൂബിയും പ്രചോദിപ്പിച്ച വാക്യഘടന വായിക്കാൻ എളുപ്പമാണ്.

സ്വിഫ്റ്റ് - എളുപ്പമാണ് വായിക്കാവുന്ന ഭാഷ, പൈത്തൺ പോലെ. പ്രധാന വ്യത്യാസം, ബ്ലോക്കുകൾ വേർതിരിക്കുന്നത് ഇൻഡൻ്റുകളാൽ അല്ല, ചുരുണ്ട ബ്രേസുകളാൽ ആണ് - ഇത് കൂടുതൽ പരിചിതവും സൗകര്യപ്രദവുമാണ്.

5. ആപ്പിൾ ഓപ്പൺ സോഴ്സ് സ്വിഫ്റ്റ്

സ്വിഫ്റ്റ് ആയിരിക്കും എന്ന് WWDC 2015-ൽ ആപ്പിൾ പ്രഖ്യാപിച്ചു. ഇതിനർത്ഥം ആപ്പിൾ അതിനെ പരിഷ്കരിക്കുന്നതിന് ഡെവലപ്പർ കമ്മ്യൂണിറ്റിയെ കൂടുതൽ ആശ്രയിക്കുമെന്ന് മാത്രമല്ല, പരിമിതമായതിനേക്കാൾ യഥാർത്ഥത്തിൽ മൾട്ടി-പ്ലാറ്റ്‌ഫോം ആകാനുള്ള കഴിവുണ്ട്. ആപ്പിൾ ഇക്കോസിസ്റ്റം. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, നിങ്ങൾ iOS-നായി സ്വിഫ്റ്റിൽ ഒരു ആപ്ലിക്കേഷൻ വികസിപ്പിച്ചെടുക്കുകയാണെങ്കിൽ, ഗൂഗിളിൻ്റെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഉപയോഗിക്കുന്ന ജാവ പഠിക്കാതെ തന്നെ നിങ്ങൾക്ക് അത് ആൻഡ്രോയിഡിലേക്ക് പോർട്ട് ചെയ്യാൻ കഴിയും എന്നതാണ് പ്രതീക്ഷ.

അവസാനമായി, അത് മനോഹരമായ ഒരു ഭാഷയാണ്. തീർച്ചയായും ഇത് വളരെ ആത്മനിഷ്ഠമാണ്, പക്ഷേ സ്വിഫ്റ്റ് കോഡ് മനോഹരമായി കാണപ്പെടുന്നു - ഒബ്ജക്റ്റീവ്-സിയെക്കുറിച്ച് അതിൻ്റെ അനന്തമായ അലങ്കോലത്തോടെ പറയാൻ കഴിയില്ല. ഏറ്റവും പ്രധാനമായി, സൗന്ദര്യവും സൗകര്യവും ശക്തിയെ ബാധിക്കുന്നില്ല.

iTunes-ലെ പ്രോഗ്രാമിംഗ് ഭാഷയിലേക്കുള്ള ഒരു ഗൈഡ്; ഭാഷയെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഡെവലപ്പർമാർക്കായി കമ്പനിയുടെ വെബ്‌സൈറ്റിലും ലഭ്യമാണ്.

miden16 ജൂൺ 10, 2014 01:06 pm

ഭാഷ സ്വിഫ്റ്റ് പ്രോഗ്രാമിംഗ്. റഷ്യൻ പതിപ്പ്

• iOS-നുള്ള വികസനം,
• സ്വിഫ്റ്റ്

ഹലോ, ഹബ്ർ! ജൂൺ 2 ന്, കമ്പനി എങ്ങനെയെന്ന് ഞങ്ങൾക്കെല്ലാം സ്വന്തം കണ്ണുകൊണ്ട് കാണാൻ കഴിഞ്ഞു ആപ്പിൾ ആരംഭിച്ചുഅവരുടെ പുതിയ പ്രോഗ്രാമിംഗ് ഭാഷയായ സ്വിഫ്റ്റിലേക്ക് ലോകത്തെ പരിചയപ്പെടുത്തി ഒബ്ജക്റ്റീവ്-സി ഡെവലപ്പർമാരുടെ ക്യാമ്പിൽ ഒരു വിപ്ലവം സൃഷ്ടിക്കുക. അതേ സമയം, ഭാഷയെക്കുറിച്ചുള്ള ഒരു ചെറിയ ഡോക്യുമെൻ്റേഷൻ അവൾ പൊതുജനങ്ങൾക്ക് ലഭ്യമാക്കി, ആവശ്യമുണ്ടെങ്കിൽ അത് വിവർത്തനം ചെയ്യാൻ ഞങ്ങൾ തീരുമാനിച്ചു. ആദ്യ അധ്യായത്തിൻ്റെ വിവർത്തനം ഞങ്ങൾ നിങ്ങളുടെ ശ്രദ്ധയിൽപ്പെടുത്തുന്നു. വിഷയം രസകരമാണെങ്കിൽ, ഞങ്ങൾ എല്ലാ ആഴ്ചയും വിവർത്തനം പ്രസിദ്ധീകരിക്കുന്നത് തുടരും.

ഭാഷാ ഗൈഡ്
അടിസ്ഥാനകാര്യങ്ങൾ
അടിസ്ഥാന ഓപ്പറേറ്റർമാർ
സ്ട്രിംഗുകളും കഥാപാത്രങ്ങളും
ശേഖരണ തരങ്ങൾ
നിയന്ത്രണ പ്രവാഹം
പ്രവർത്തനങ്ങൾ
അടച്ചുപൂട്ടലുകൾ
കണക്കുകൾ
ക്ലാസുകളും ഘടനകളും
പ്രോപ്പർട്ടികൾ
രീതികൾ
സബ്സ്ക്രിപ്റ്റുകൾ
അനന്തരാവകാശം
ആരംഭിക്കൽ
ഡീനിഷ്യലൈസേഷൻ
ഓട്ടോമാറ്റിക് റഫറൻസ് കൗണ്ടിംഗ്
ഓപ്ഷണൽ ചെയിനിംഗ്
കാസ്റ്റിംഗ് എന്ന് ടൈപ്പ് ചെയ്യുക
നെസ്റ്റഡ് തരങ്ങൾ
വിപുലീകരണങ്ങൾ
പ്രോട്ടോക്കോളുകൾ
ജനറിക്‌സ്
വിപുലമായ ഓപ്പറേറ്റർമാർ

ഭാഷാ റഫറൻസ്
ഭാഷാ റഫറൻസിനെക്കുറിച്ച്
ലെക്സിക്കൽ ഘടന
തരങ്ങൾ
ഭാവങ്ങൾ
പ്രസ്താവനകൾ
പ്രഖ്യാപനങ്ങൾ
ഗുണവിശേഷങ്ങൾ
പാറ്റേണുകൾ
പൊതുവായ പാരാമീറ്ററുകളും വാദങ്ങളും
വ്യാകരണത്തിൻ്റെ സംഗ്രഹം
വ്യാപാരമുദ്രകൾ

സ്വിഫ്റ്റിലേക്ക് സ്വാഗതം

സ്വിഫ്റ്റ് ഭാഷയെക്കുറിച്ച്

IOS, OS X ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുന്നതിനുള്ള ഒരു പുതിയ പ്രോഗ്രാമിംഗ് ഭാഷയാണ് Swift, അത് C, Objective-C എന്നിവയിൽ മികച്ചത് സംയോജിപ്പിക്കുന്നു, എന്നാൽ C യുമായി പൊരുത്തപ്പെടുന്നതിന് നിയന്ത്രണങ്ങൾ ഏർപ്പെടുത്താതെ തന്നെ സുരക്ഷിതമായ പ്രോഗ്രാമിംഗ് പാറ്റേണുകൾ ഉപയോഗിക്കുകയും ആധുനിക ഫീച്ചറുകൾ ചേർക്കുകയും ചെയ്യുന്നു. ലളിതവും കൂടുതൽ വഴക്കമുള്ളതും രസകരവുമായ പ്രക്രിയയിൽ ആപ്ലിക്കേഷൻ. സ്വിഫ്റ്റ്, ഞങ്ങൾ സൃഷ്ടിച്ചത് ശുദ്ധമായ സ്ലേറ്റ്, ആപ്ലിക്കേഷനുകൾ എങ്ങനെയാണ് വികസിപ്പിച്ചതെന്ന് പുനർവിചിന്തനം ചെയ്യാനുള്ള അവസരമാണ്.

നിരവധി വർഷങ്ങളായി സ്വിഫ്റ്റ് വികസനത്തിലാണ്. പുതിയ പ്രോഗ്രാമിംഗ് ഭാഷയുടെ അടിസ്ഥാനം നിലവിലുള്ള കമ്പൈലർ, ഡീബഗ്ഗർ, ചട്ടക്കൂടുകൾ എന്നിവയായിരുന്നു. ഓട്ടോമാറ്റിക് റഫറൻസ് കൗണ്ടിംഗ് (ARC) ഉപയോഗിച്ച് ഞങ്ങൾ മെമ്മറി മാനേജ്മെൻ്റ് ലളിതമാക്കിയിരിക്കുന്നു. ഞങ്ങളുടെ ചട്ടക്കൂടുകളും വലിയ നവീകരണത്തിന് വിധേയമായിട്ടുണ്ട്. ഒബ്ജക്റ്റീവ്-സി ബ്ലോക്കുകൾ, ലിറ്ററലുകൾ, മൊഡ്യൂളുകൾ എന്നിവയെ പിന്തുണയ്ക്കാൻ തുടങ്ങി - ഇതെല്ലാം നടപ്പിലാക്കുന്നതിന് അനുകൂലമായ സാഹചര്യങ്ങൾ സൃഷ്ടിച്ചു ആധുനിക സാങ്കേതികവിദ്യകൾ. ഭാവി വികസിപ്പിക്കാൻ ഉപയോഗിക്കുന്ന ഒരു പുതിയ പ്രോഗ്രാമിംഗ് ഭാഷയുടെ അടിത്തറയായി പ്രവർത്തിച്ചത് ഈ തയ്യാറെടുപ്പ് ജോലിയാണ് സോഫ്റ്റ്വെയർ ഉൽപ്പന്നങ്ങൾആപ്പിളിന്.

ഒബ്ജക്റ്റീവ്-സി ഡെവലപ്പർമാർ സ്വിഫ്റ്റിനെ പരിചിതമായി കണ്ടെത്തും. ഇത് പേരുനൽകിയ പാരാമീറ്ററുകളുടെ വായനാക്ഷമതയെ ഡൈനാമിക് ശക്തിയുമായി സംയോജിപ്പിക്കുന്നു ഒബ്ജക്റ്റ് മോഡൽലക്ഷ്യം-സി. ഇത് നിലവിലുള്ള കൊക്കോ ചട്ടക്കൂടുകൾ തുറക്കുകയും ഒബ്ജക്റ്റീവ്-സിയിൽ എഴുതിയ കോഡുമായി പൊരുത്തപ്പെടുകയും ചെയ്യുന്നു. ഈ പൊതു അടിത്തറയിൽ നിർമ്മിച്ച, ഭാഷ നിരവധി പുതിയ സവിശേഷതകൾ വാഗ്ദാനം ചെയ്യുകയും പ്രോഗ്രാമിംഗ് ഭാഷയുടെ നടപടിക്രമവും ഒബ്ജക്റ്റ്-ഓറിയൻ്റഡ് വശങ്ങളും ഏകീകരിക്കുകയും ചെയ്യുന്നു.

പുതിയ പ്രോഗ്രാമർമാരെയും സ്വിഫ്റ്റ് ഭയപ്പെടുത്തില്ല. ഒരു സ്ക്രിപ്റ്റിംഗ് ഭാഷ പോലെ അവബോധജന്യവും രസകരവുമായ ആദ്യത്തെ ശക്തമായ പ്രോഗ്രാമിംഗ് ഭാഷയാണിത്. ആപ്ലിക്കേഷൻ കംപൈൽ ചെയ്യാതെയും പ്രവർത്തിപ്പിക്കാതെയും തത്സമയം ഫലം കാണുന്നതിന് കോഡ് ഉപയോഗിച്ച് പരീക്ഷിക്കാൻ പ്രോഗ്രാമർമാരെ അനുവദിക്കുന്ന കളിസ്ഥലങ്ങൾ എന്ന് വിളിക്കപ്പെടുന്നതിനെ ഇത് പിന്തുണയ്ക്കുന്നു.

സ്വിഫ്റ്റ് ആധുനിക ഭാഷകളിൽ ഏറ്റവും മികച്ചത് ഉൾക്കൊള്ളുന്നു, ആപ്പിളിൻ്റെ വിപുലമായ അനുഭവം കണക്കിലെടുത്താണ് വികസിപ്പിച്ചിരിക്കുന്നത്. ഞങ്ങളുടെ കംപൈലർ പ്രകടനത്തിൻ്റെ പര്യായമാണ്, വിട്ടുവീഴ്ചകൾ കണക്കിലെടുക്കാതെ ഞങ്ങളുടെ ഭാഷ വികസനത്തിനായി ഒപ്റ്റിമൈസ് ചെയ്തിരിക്കുന്നു. നിങ്ങളുടെ ആദ്യത്തെ "ഹലോ, വേൾഡ്!" ആപ്ലിക്കേഷനും ഒരു മുഴുവൻ ഓപ്പറേറ്റിംഗ് സിസ്റ്റവും പോലും എളുപ്പത്തിൽ വികസിപ്പിക്കാൻ കഴിയുന്ന തരത്തിലാണ് ഇത് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. ഇതെല്ലാം സ്വിഫ്റ്റിനെ ഡെവലപ്പർമാർക്കും ആപ്പിളിനും ഒരു പ്രധാന ഉപകരണമാക്കി മാറ്റുന്നു.

iOS, OS X എന്നിവയ്‌ക്കായുള്ള ആപ്പുകൾ നിർമ്മിക്കുന്നതിനുള്ള ഒരു മികച്ച പുതിയ മാർഗമാണ് സ്വിഫ്റ്റ്, പുതിയ പ്രവർത്തനക്ഷമത ചേർത്തും പുതിയ ഫീച്ചറുകൾ അവതരിപ്പിച്ചും ഞങ്ങൾ അത് നിർമ്മിക്കുന്നത് തുടരും. നമ്മുടെ ലക്ഷ്യം അതിമോഹമാണ്. നിങ്ങൾക്ക് ഇത് ഉപയോഗിച്ച് എന്ത് സൃഷ്ടിക്കാൻ കഴിയുമെന്ന് കാണാൻ ഞങ്ങൾക്ക് കാത്തിരിക്കാനാവില്ല.

സ്വിഫ്റ്റിൻ്റെ ആമുഖം

ദീർഘകാല പാരമ്പര്യമനുസരിച്ച്, ഒരു പുതിയ ഭാഷയിലെ ആദ്യ പ്രോഗ്രാം സ്ക്രീനിൽ "ഹലോ, വേൾഡ്" എന്ന വാക്കുകൾ പ്രദർശിപ്പിക്കണം. സ്വിഫ്റ്റ് ഉപയോഗിച്ച് ഇത് ഇതുപോലെയാണ് ചെയ്യുന്നത്:

Println ("ഹലോ, വേൾഡ്")
നിങ്ങൾ എപ്പോഴെങ്കിലും സിയിലോ ഒബ്ജക്റ്റീവ്-സിയിലോ വികസിപ്പിച്ചിട്ടുണ്ടെങ്കിൽ, ഈ വാക്യഘടന നിങ്ങൾക്ക് പരിചിതമായി തോന്നും - സ്വിഫ്റ്റിൽ, ഈ കോഡിൻ്റെ ഒരു സമ്പൂർണ്ണ പ്രോഗ്രാമാണ്. കൺസോൾ I/O അല്ലെങ്കിൽ സ്ട്രിംഗ് കൃത്രിമത്വം പോലുള്ള അടിസ്ഥാന പ്രവർത്തനങ്ങൾ നൽകുന്നതിന് നിങ്ങൾ ഇനി പ്രത്യേക ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യേണ്ടതില്ല. ഗ്ലോബൽ സ്കോപ്പിൽ എഴുതിയ കോഡ് പ്രോഗ്രാമിലേക്കുള്ള പ്രവേശന പോയിൻ്റാണ്, അതിനാൽ പ്രധാന പ്രവർത്തനം ഇനി ആവശ്യമില്ല. ഓരോ വരിയുടെയും അവസാനം അർദ്ധവിരാമം ഇല്ല എന്നതും ശ്രദ്ധിക്കുക.

സ്വിഫ്റ്റിൽ കോഡിംഗ് ആരംഭിക്കുന്നതിന് ആവശ്യമായ വിവരങ്ങൾ ഈ ആമുഖം നൽകുന്നു. നിങ്ങൾക്ക് എന്തെങ്കിലും മനസ്സിലായില്ലെങ്കിൽ വിഷമിക്കേണ്ട - തുടർന്നുള്ള അധ്യായങ്ങളിൽ ഞങ്ങൾ എല്ലാം വിശദമായി വിശദീകരിക്കും.

അഭിപ്രായം
മെറ്റീരിയലിനെ കുറിച്ച് കൂടുതൽ മനസ്സിലാക്കുന്നതിന്, Xcode-ലെ കളിസ്ഥലം മോഡ് ഉപയോഗിക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു. ആപ്ലിക്കേഷൻ കംപൈൽ ചെയ്ത് റൺ ചെയ്യാതെ തന്നെ നിങ്ങളുടെ കോഡ് എഡിറ്റ് ചെയ്യുമ്പോൾ തന്നെ ഫലങ്ങൾ കാണാൻ പ്ലേഗ്രൗണ്ട് നിങ്ങളെ അനുവദിക്കുന്നു.

ലളിതമായ ഡാറ്റ തരങ്ങൾ

ഒരു സ്ഥിരാങ്കം സൃഷ്ടിക്കാൻ let ഉം ഒരു വേരിയബിൾ സൃഷ്ടിക്കാൻ var ഉം ഉപയോഗിക്കുക. സ്ഥിരാങ്കത്തിൻ്റെ തരം വ്യക്തമാക്കേണ്ടതില്ല; നിങ്ങൾക്ക് ഒരു തവണ മാത്രമേ അതിന് ഒരു മൂല്യം നൽകാനാകൂ.

Var myVariable = 42 myVariable = 50 myConstant = 42 എന്ന് അനുവദിക്കുക
ഒരു സ്ഥിരാങ്കത്തിൻ്റെയും വേരിയബിളിൻ്റെയും തരങ്ങൾ അവയ്‌ക്ക് നൽകിയിരിക്കുന്ന അനുബന്ധ മൂല്യങ്ങളുടെ തരങ്ങളുമായി പൊരുത്തപ്പെടണം. എന്നിരുന്നാലും, നിങ്ങൾ അവരുടെ തരം നേരിട്ട് വ്യക്തമാക്കണമെന്ന് ഇതിനർത്ഥമില്ല. അവയ്ക്ക് ഒരു മൂല്യം നൽകുമ്പോൾ കംപൈലർ സ്വയമേവ സ്ഥിരവും വേരിയബിളും തരം നിർണ്ണയിക്കും. അതിനാൽ, നൽകിയിരിക്കുന്ന ഉദാഹരണത്തിൽ, myVariable-ന് ഉണ്ടെന്ന് കംപൈലർ നിർണ്ണയിക്കും പൂർണ്ണസംഖ്യ തരം.

ഇനീഷ്യലൈസർ കാണുന്നില്ലെങ്കിലോ മതിയായ വിവരങ്ങൾ നൽകുന്നില്ലെങ്കിലോ, വേരിയബിളിന് ശേഷം നിങ്ങൾക്ക് തരം സ്വയം വ്യക്തമാക്കാം, ഒരു കോളൺ ഉപയോഗിച്ച് പേരും തരവും വേർതിരിക്കുന്നു:

implicitInteger = 70 ആകട്ടെ inplicitDouble = 70.0 inplicitDouble: ഇരട്ട = 70

നമുക്ക് പരീക്ഷണം നടത്താം
ഉപയോഗിച്ച് ഒരു സ്ഥിരാങ്കം സൃഷ്ടിക്കുക ഫ്ലോട്ട് തരം 4 എന്ന നമ്പറിൽ ഇത് സമാരംഭിക്കുക.

മൂല്യങ്ങൾ ഒരിക്കലും മറ്റൊരു തരത്തിലേക്ക് പരോക്ഷമായി പരിവർത്തനം ചെയ്യപ്പെടുന്നില്ല. നിങ്ങൾക്ക് ഒരു മൂല്യം മറ്റൊരു തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യണമെങ്കിൽ, അത് വ്യക്തമായി ചെയ്യുക:
ലെറ്റ് ലേബൽ = "വീതി എന്നത് " ലെറ്റ് വീതി = 94 ലെറ്റ് വീതി ലേബൽ = ലേബൽ + സ്ട്രിംഗ് (വീതി)

നമുക്ക് പരീക്ഷണം നടത്താം
ഇതിലേക്കുള്ള വ്യക്തമായ പരിവർത്തനം നീക്കം ചെയ്യാൻ ശ്രമിക്കുക സ്ട്രിംഗ് ടൈപ്പ് ചെയ്യുകഅവസാന വരിയിൽ. നിങ്ങൾക്ക് എന്ത് പിഴവ് ലഭിക്കും?

സ്ട്രിംഗുകളിൽ മൂല്യങ്ങൾ ഉൾപ്പെടുത്താനുള്ള എളുപ്പവഴി, പദപ്രയോഗം പരാൻതീസിസിൽ ഉൾപ്പെടുത്തുകയും അവയ്ക്ക് മുമ്പായി ഒരു ബാക്ക്‌സ്ലാഷ് (\) നൽകുകയും ചെയ്യുക എന്നതാണ്. ഉദാഹരണം:

ആപ്പിൾ = 3 ലെറ്റ് ഓറഞ്ചുകൾ = 5 അനുവദിക്കുക appleSummary = "എനിക്ക് \(ആപ്പിൾ) ആപ്പിൾ ഉണ്ട്." let fruitSummary = "എൻ്റെ പക്കൽ \(ആപ്പിൾ + ഓറഞ്ച്) പഴങ്ങൾ ഉണ്ട്."

നമുക്ക് പരീക്ഷണം നടത്താം
രണ്ട് പൂർണ്ണസംഖ്യ വേരിയബിളുകളുടെ ആകെത്തുകയുടെ ഫലവും ഒരാളുടെ പേരും ഉൾപ്പെടെ ഒരു സ്ട്രിംഗ് നിർമ്മിക്കുകയും പ്രിൻ്റ് ചെയ്യുകയും ചെയ്യുക.

അറേകളും അസോസിയേറ്റീവ് അറേകളും (നിഘണ്ടുക്കൾ) ഉപയോഗിച്ച് പ്രവർത്തിക്കുമ്പോൾ, ചതുര ബ്രാക്കറ്റുകൾ () ഉപയോഗിക്കുന്നു:

Var shoppingList = ["catfish", "water", "tulips", "blue paint"] shoppingList = "വെള്ളത്തിൻ്റെ കുപ്പി" var തൊഴിലുകൾ = [ "Malcolm": "Captain", "Kaylee": "Mechanic", ] തൊഴിലുകൾ ["ജെയ്ൻ"] = "പൊതുബന്ധങ്ങൾ"
ഒരു ശൂന്യമായ അറേ അല്ലെങ്കിൽ നിഘണ്ടു സൃഷ്ടിക്കാൻ, ഇനിപ്പറയുന്ന വാക്യഘടന ഉപയോഗിക്കുക:

ശൂന്യമായ അറേ = സ്ട്രിംഗ്() ശൂന്യനിഘണ്ടു = നിഘണ്ടു എന്ന് അനുവദിക്കുക ()
ശൂന്യമായ അറേകളും നിഘണ്ടുക്കളും സൃഷ്ടിക്കുന്നതിന്, യഥാക്രമം കൂടാതെ [:] ഉപയോഗിക്കുക-ഉദാഹരണത്തിന്, നിങ്ങൾ ഒരു വേരിയബിളിന് ഒരു പുതിയ മൂല്യം നൽകുമ്പോഴോ ഒരു ഫംഗ്ഷനിലേക്ക് ഒരു ആർഗ്യുമെൻ്റ് നൽകുമ്പോഴോ.

ഷോപ്പിംഗ് ലിസ്റ്റ് = // ഷോപ്പിംഗിന് പോയി എല്ലാം വാങ്ങി.

വ്യവസ്ഥകളും ചക്രങ്ങളും

വ്യവസ്ഥകൾ സൃഷ്‌ടിക്കുന്നതിന് എങ്കിൽ, സ്വിച്ച് സ്റ്റേറ്റ്‌മെൻ്റുകൾ ഉപയോഗിക്കുന്നു, ലൂപ്പുകൾ സൃഷ്‌ടിക്കാൻ ഫോർ-ഇൻ, ഫോർ, വെയ്ൽ, ഡു-വൈൽ സ്റ്റേറ്റ്‌മെൻ്റുകൾ ഉപയോഗിക്കുന്നു. ഈ സാഹചര്യത്തിൽ, ചുരുണ്ട ബ്രേസുകൾ ആവശ്യമായി വരുമ്പോൾ, വ്യവസ്ഥകൾ ഹൈലൈറ്റ് ചെയ്യേണ്ടതില്ല.

വ്യക്തിഗത സ്‌കോറുകളിലെ സ്‌കോറിന് വ്യക്തിഗത സ്‌കോറുകൾ = var ടീം സ്‌കോർ = 0 അനുവദിക്കുക (സ്‌കോർ> 50 (ടീം സ്‌കോർ += 3) മറ്റ് (ടീം സ്‌കോർ += 1)) ടീം സ്‌കോർ
if സ്റ്റേറ്റ്‌മെൻ്റിനുള്ളിലെ വ്യവസ്ഥ ഒരു ബൂളിയൻ ആയിരിക്കണം, അതിനർത്ഥം വ്യക്തമായ താരതമ്യമില്ലാത്തതിനാൽ (ഉദാഹരണത്തിന്, പൂജ്യത്തിനൊപ്പം) if സ്കോർ (...) പ്രസ്താവന ഒരു പിശകാണ് എന്നാണ്.

nil മൂല്യമുള്ള സ്ഥിരാങ്കങ്ങളും വേരിയബിളുകളും ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ if സ്റ്റേറ്റ്മെൻ്റ് let, var എന്നിവയുമായി സംയോജിച്ച് ഉപയോഗിക്കാം. അത്തരം സ്ഥിരാങ്കങ്ങളെയും വേരിയബിളുകളെയും ഓപ്ഷണൽ എന്ന് വിളിക്കുന്നു (അതായത്, അവയ്ക്ക് ഏതെങ്കിലും മൂല്യം എടുക്കാം അല്ലെങ്കിൽ പൂജ്യത്തിന് തുല്യമായിരിക്കും). ഒരു ഓപ്ഷണൽ വേരിയബിൾ അല്ലെങ്കിൽ സ്ഥിരാങ്കം സൃഷ്ടിക്കാൻ, ടൈപ്പിന് ശേഷം ഒരു ചോദ്യചിഹ്നം (?) ചേർക്കുക.

Var optionalString: String? = "Hello" optionalString == nil var optionalName: String? = "ജോൺ ആപ്പിൾസീഡ്" var ആശംസ = "ഹലോ!" എങ്കിൽ പേര് = ഓപ്ഷണൽ പേര് ( ആശംസ = "ഹലോ, \(പേര്)" )

നമുക്ക് പരീക്ഷണം നടത്താം
ഓപ്ഷണൽ നെയിം nil ആയി മാറ്റുക. സ്ക്രീനിൽ നിങ്ങൾ എന്താണ് കാണുന്നത്? ഓപ്ഷണൽ നെയിം ഇല്ലെങ്കിൽ കേസ് കൈകാര്യം ചെയ്യാൻ മറ്റൊരു ബ്ലോക്ക് ചേർക്കുക.

ഓപ്ഷണൽ മൂല്യം nil ആണെങ്കിൽ, വ്യവസ്ഥ തെറ്റായിരിക്കും, if-ന് ശേഷമുള്ള ചുരുണ്ട ബ്രേസുകളിലെ കോഡ് എക്സിക്യൂട്ട് ചെയ്യില്ല. അല്ലെങ്കിൽ, ആശംസാ വേരിയബിളിന് ഒരു പുതിയ മൂല്യം നൽകും.

മൾട്ടിപ്പിൾ ചോയ്‌സ് ഓപ്പറേറ്റർ സ്വിച്ച് അതിനുള്ളിൽ തന്നെയുള്ള മറ്റ് പല താരതമ്യ ഓപ്പറേറ്റർമാരെയും പിന്തുണയ്ക്കുന്നു, മാത്രമല്ല ഇത് ലളിതമായ താരതമ്യങ്ങളിൽ മാത്രം ഒതുങ്ങുന്നില്ല:

വെജിറ്റബിൾ = "ചുവന്ന കുരുമുളക്" പച്ചക്കറി മാറട്ടെ (കേസ് "സെലറി": വെജിറ്റബിൾ കമൻ്റ് ചെയ്യട്ടെ = "കുറച്ച് ഉണക്കമുന്തിരി ചേർത്ത് ഒരു തടിയിൽ ഉറുമ്പുകൾ ഉണ്ടാക്കുക." കേസ് "കുക്കുമ്പർ", "വാട്ടർക്രസ്": വെജിറ്റബിൾ കമൻ്റ് = "അത് നല്ലൊരു ടീ സാൻഡ്‌വിച്ച് ഉണ്ടാക്കും ." കേസ് ലെറ്റ് x എവിടെ x.hasSuffix("കുരുമുളക്"): ലെറ്റ് വെജിറ്റബിൾ കമൻ്റ് = "ഇത് എരിവുള്ളതാണോ \(x)?" ഡിഫോൾട്ട്: ലെറ്റ് വെജിറ്റബിൾ കമൻ്റ് = "സൂപ്പിൽ എല്ലാത്തിനും നല്ല രുചിയുണ്ട്." )

നമുക്ക് പരീക്ഷണം നടത്താം
ഡിഫോൾട്ട് അവസ്ഥ നീക്കം ചെയ്യാൻ ശ്രമിക്കുക. നിങ്ങൾക്ക് എന്ത് പിഴവ് ലഭിക്കും?

ഉചിതമായ ബ്ലോക്ക് കോഡ് എക്സിക്യൂട്ട് ചെയ്ത ശേഷം, തുടർന്നുള്ള വ്യവസ്ഥകൾ പരിശോധിക്കാതെ പ്രോഗ്രാം സ്വിച്ച് സ്റ്റേറ്റ്മെൻ്റ് വിടുന്നു. ഇതുവഴി ഓരോ കേസ് ബ്ലോക്കിൻ്റെയും അവസാനം നിങ്ങൾ സ്വമേധയാ ബ്രേക്ക് സ്റ്റേറ്റ്‌മെൻ്റുകൾ ചേർക്കേണ്ടതില്ല.

ഒരു അസോസിയേറ്റീവ് അറേയുടെ ഘടകങ്ങളിൽ ആവർത്തിക്കാൻ, ഓരോ കീ-മൂല്യ ജോഡിക്കും ഒരു ജോടി പേരുകൾ വ്യക്തമാക്കുന്നതിനൊപ്പം ഫോർ-ഇൻ സ്റ്റേറ്റ്മെൻ്റ് ഉപയോഗിക്കുക.

രസകരമായ സംഖ്യകൾ = [ "പ്രൈം": , "ഫിബൊനാച്ചി": , "സ്ക്വയർ": , ] var വലിയ = 0 (തരം, സംഖ്യകൾ) രസകരമായ സംഖ്യകളിൽ (അക്കങ്ങളിലെ സംഖ്യയ്ക്ക് (സംഖ്യയാണെങ്കിൽ > ഏറ്റവും വലുത് (ഏറ്റവും വലിയ = സംഖ്യ) ) ) ഏറ്റവും വലുത്

നമുക്ക് പരീക്ഷണം നടത്താം
കണ്ടെത്തിയ മൂന്ന് തരങ്ങളിൽ ഏതാണ് പരമാവധി സംഖ്യയെന്ന് കണ്ടെത്താൻ നിങ്ങളെ അനുവദിക്കുന്ന മറ്റൊരു വേരിയബിൾ ചേർക്കുക.

ഓപ്പറേറ്റർ ലൂപ്പ് സമയത്ത്വ്യവസ്ഥ തെറ്റാകുന്നതുവരെ അതിനുള്ളിലെ ഒരു ബ്ലോക്ക് കോഡ് എക്സിക്യൂട്ട് ചെയ്യാൻ അനുവദിക്കുന്നു. ബ്ലോക്കിന് ശേഷം വ്യവസ്ഥയും വ്യക്തമാക്കാം, ഈ സാഹചര്യത്തിൽ അത് അനുസരിച്ച് നടപ്പിലാക്കും ഇത്രയെങ്കിലുംഒരിക്കല്.

Var n = 2 അതേസമയം n< 100 { n = n * 2 } n var m = 2 do { m = m * 2 } while m < 100 m
രണ്ട് ഡോട്ടുകൾ (..) ഉപയോഗിച്ച് അല്ലെങ്കിൽ ഒരു ഇനീഷ്യലൈസർ, അവസ്ഥ, ഇൻക്രിമെൻ്റ് എന്നിവ ഉപയോഗിച്ച് സംഖ്യകളുടെ ഒരു ശ്രേണിയിൽ ആവർത്തിക്കാൻ ഫോർ സ്റ്റേറ്റ്മെൻ്റ് ഉപയോഗിക്കാം. നോക്കൂ, ഈ രണ്ട് ലൂപ്പുകളും ഒരേ കാര്യം ചെയ്യുന്നു:

Var firstForLoop = 0 for i-ൽ 0..3 (firstForLoop += i ) firstForLoop var secondForLoop = 0 for var i = 0; ഐ< 3; ++i { secondForLoop += 1 } secondForLoop
ഒരു ലൂപ്പ് സൃഷ്‌ടിക്കുമ്പോൾ, ശ്രേണിയിൽ വലിയ മൂല്യം ഉൾപ്പെടുത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ലെങ്കിൽ രണ്ട് ഡോട്ടുകളും (..) ചെറുതും വലുതുമായ മൂല്യങ്ങൾ ഉൾപ്പെടുത്താൻ മൂന്ന് ഡോട്ടുകളും (...) ഉപയോഗിക്കുക.

പ്രവർത്തനങ്ങളും അടച്ചുപൂട്ടലുകളും.

ഫംഗ്‌ഷനുകൾ പ്രഖ്യാപിക്കാൻ, ഫങ്ക് കീവേഡ് ഉപയോഗിക്കുക. ഒരു ഫംഗ്‌ഷൻ്റെ പേരും പരാൻതീസിസിലെ ആർഗ്യുമെൻ്റുകളുടെ ഒരു ലിസ്റ്റും സൂചിപ്പിച്ചാണ് വിളിക്കുന്നത്. റിട്ടേൺ തരം -> ഉപയോഗിച്ച് ഫോർമൽ ആർഗ്യുമെൻ്റ് ലിസ്റ്റിൽ നിന്ന് വേർതിരിക്കേണ്ടതാണ്.

ഫങ്ക് ഗ്രീക്ക്(പേര്: സ്ട്രിംഗ്, ദിവസം: സ്ട്രിംഗ്) -> സ്ട്രിംഗ് ("ഹലോ \(പേര്) തിരികെ നൽകുക, ഇന്നാണ് \(ദിവസം)." ) ഗ്രീറ്റ്("ബോബ്", "ചൊവ്വ")

നമുക്ക് പരീക്ഷണം നടത്താം
ദിവസം പാരാമീറ്റർ നീക്കം ചെയ്യുക. പകരം, ഉച്ചഭക്ഷണത്തിനായി വിളമ്പുന്ന വിഭവത്തിൻ്റെ പേര് സൂചിപ്പിക്കുന്ന ഒരു വേരിയബിൾ ചേർക്കുക.

ഒരു ഫംഗ്‌ഷൻ ഒന്നിലധികം മൂല്യങ്ങൾ നൽകുകയാണെങ്കിൽ, നിങ്ങൾ ഒരു ട്യൂപ്പിൾ ഉപയോഗിക്കണം:

Func getGasPrices() -> (Double, Double, Double) (റിട്ടേൺ (3.59, 3.69, 3.79) ) getGasPrices()
ഫംഗ്‌ഷനുകൾക്ക് അനിശ്ചിതകാല ആർഗ്യുമെൻ്റുകളും ഉണ്ടായിരിക്കാം:

Func sumOf(സംഖ്യകൾ: Int...) -> Int (സംഖ്യകളിലെ സംഖ്യയ്ക്ക് var sum = 0 ( sum += number ) റിട്ടേൺ തുക ) sumOf() sumOf(42, 597, 12)

നമുക്ക് പരീക്ഷണം നടത്താം
ഗണിത ശരാശരി കണ്ടെത്തുന്നതിന് ഒരു ഫംഗ്ഷൻ എഴുതുക ഏതെങ്കിലും നമ്പർഅവരുടെ വാദങ്ങൾ.

പ്രവർത്തനങ്ങൾ പരസ്പരം ഉള്ളിൽ കൂടുകൂട്ടാം. ഒരു നെസ്റ്റഡ് ഫംഗ്‌ഷന് ബാഹ്യ ഫംഗ്‌ഷനിൽ പ്രഖ്യാപിച്ച വേരിയബിളുകൾ ആക്‌സസ് ചെയ്യാൻ കഴിയും. സങ്കീർണ്ണമായ അല്ലെങ്കിൽ വലിയ ഫംഗ്‌ഷൻ്റെ കോഡ് ക്രമപ്പെടുത്തുന്നതിന് നെസ്റ്റഡ് ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുക.

Func returnFifteen() -> Int (var y = 10 func add() (y += 5 ) add() return y ) returnFifteen()
ഫംഗ്‌ഷനുകൾ ഫസ്റ്റ് ക്ലാസിലെ (ഫസ്റ്റ് ക്ലാസ് തരം) ഒബ്‌ജക്റ്റുകളാണ്, മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഒരു ഫംഗ്‌ഷന് അതിൻ്റെ ഫലമായി മറ്റൊരു ഫംഗ്‌ഷന് തിരികെ നൽകാനാകും.

Func makeIncrementer() -> (Int -> Int) ( func addOne(number: Int) -> Int ( റിട്ടേൺ 1 + number ) return addOne ) var increment = makeIncrementer() increment(7)
ഒരു ഫംഗ്‌ഷൻ അതിൻ്റെ ആർഗ്യുമെൻ്റുകളിലൊന്നായി മറ്റൊരു ഫംഗ്‌ഷൻ എടുക്കുകയും ചെയ്യാം.

Func hasAnyMatches(ലിസ്റ്റ്: Int, കണ്ടീഷൻ: Int -> Bool) -> Bool (ലിസ്റ്റിലെ ഇനത്തിന് (കണ്ടീഷൻ(ഇനം) (ശരിയായി തിരികെ നൽകുക) ) Func lessThanTen(number: Int) -> Bool ( റിട്ടേൺ നമ്പർ)< 10 } var numbers = hasAnyMatches(numbers, lessThanTen)
ഫംഗ്‌ഷനുകൾ അടച്ചുപൂട്ടലുകളുടെ ഒരു പ്രത്യേക സാഹചര്യമാണ്. ഒരു പേര് വ്യക്തമാക്കാതെയും ക്ലോഷറിൻ്റെ ബോഡി ചുരുണ്ട ബ്രേസുകൾ (()) ഉപയോഗിച്ച് ചുറ്റിപ്പറ്റിയും നിങ്ങൾക്ക് ഒരു ക്ലോഷർ സൃഷ്‌ടിക്കാനാകും. ക്ലോഷറിൻ്റെ ബോഡിയിൽ നിന്ന് ആർഗ്യുമെൻ്റുകളും റിട്ടേൺ തരവും വേർതിരിക്കുന്നതിന്, ഇൻ ഓപ്പറേറ്റർ ഉപയോഗിക്കുക.

Numbers.map(((നമ്പർ: Int) -> Int in let result = 3 * number return result ))

നമുക്ക് പരീക്ഷണം നടത്താം
എല്ലാ അധിക സംഖ്യകൾക്കും പൂജ്യം നൽകുന്ന തരത്തിൽ അടച്ചുപൂട്ടൽ വീണ്ടും എഴുതുക.

അടച്ചുപൂട്ടലുകൾ കൂടുതൽ സംക്ഷിപ്തമാക്കുന്നതിന് നിരവധി സാങ്കേതിക വിദ്യകളുണ്ട്. അടച്ചുപൂട്ടലിൻ്റെ തരം ഒരു പ്രിയോറി അറിയാമെങ്കിൽ (ഉദാഹരണത്തിന്, ഇത് ഒരു ഡെലിഗേറ്റിൻ്റെ കോൾബാക്ക് ആണ്), അതിൻ്റെ പാരാമീറ്ററുകളുടെ തരം കൂടാതെ/അല്ലെങ്കിൽ റിട്ടേൺ മൂല്യത്തിൻ്റെ തരം വ്യക്തമാക്കുന്നത് നിങ്ങൾക്ക് ഒഴിവാക്കാം. ഒരൊറ്റ പദപ്രയോഗം അടങ്ങുന്ന ക്ലോസറുകൾ ആ പദപ്രയോഗത്തിൻ്റെ ഫലം പരോക്ഷമായി നൽകുന്നു.

Numbers.map((3 ലെ നമ്പർ * നമ്പർ ))
ഒരു ക്ലോഷറിൽ, ഒരു വേരിയബിൾ നാമം വ്യക്തമാക്കുന്നതിനുപകരം, നിങ്ങൾക്ക് അതിൻ്റെ ഓർഡിനൽ നമ്പർ ഉപയോഗിക്കാം - ഷോർട്ട് സർക്യൂട്ടുകൾ എഴുതുമ്പോൾ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്. ഫംഗ്‌ഷൻ്റെ അവസാന ആർഗ്യുമെൻ്റായ ക്ലോഷർ, ബാക്കിയുള്ള പരാമീറ്ററുകളുടെ ലിസ്റ്റ് ഉള്ള പരാൻതീസിസുകൾക്ക് ശേഷം ഉടൻ തന്നെ അതിലേക്ക് കൈമാറാൻ കഴിയും.

അടുക്കുക() ( $0 > $1 )

വസ്തുക്കളും ക്ലാസുകളും

ഒരു ക്ലാസ് സൃഷ്‌ടിക്കാൻ, റിസർവ് ചെയ്‌ത പദ ക്ലാസ് ഉപയോഗിക്കുക. സാധാരണ സ്ഥിരാങ്കങ്ങളും വേരിയബിളുകളും പോലെ തന്നെ ക്ലാസ് അംഗങ്ങളെ പ്രഖ്യാപിക്കുന്നു. മാത്രമല്ല, ക്ലാസ് രീതികൾ സാധാരണ ഫംഗ്ഷനുകളായി പ്രഖ്യാപിക്കപ്പെടുന്നു.

ക്ലാസ് ആകൃതി (var numberOfSides = 0 func simpleDescription() ->

നമുക്ക് പരീക്ഷണം നടത്താം
ഒരു ക്ലാസ് അംഗ സ്ഥിരാങ്കവും അതിൻ്റെ വാദമായി എടുക്കുന്ന ഒരു ക്ലാസ് രീതിയും ചേർക്കുക.

ഒരു ക്ലാസിൻ്റെ ഒരു ഉദാഹരണം (ഒബ്ജക്റ്റ്) സൃഷ്ടിക്കാൻ, ക്ലാസിൻ്റെ പേരിന് ശേഷം പരാൻതീസിസ് ചേർക്കുക. രീതികളും ക്ലാസ് അംഗങ്ങളും ഒരു ഡോട്ടിലൂടെ ആക്സസ് ചെയ്യപ്പെടുന്നു.

വർ ആകൃതി = ആകൃതി() shape.numberOfSides = 7 var shapeDescription = shape.simpleDescription()
ഈ ഉദാഹരണത്തിൽ ഞങ്ങൾക്ക് ഒരെണ്ണം നഷ്ടമായി പ്രധാനപ്പെട്ട വിശദാംശങ്ങൾ- ക്ലാസ് കൺസ്ട്രക്റ്റർ, init രീതി.

Class NamedShape ( var numberOfSides: Int = 0 var name: String init(name: String) ( self.name = name ) func simpleDescription() -> String ( "\(numberOfSides) വശങ്ങളുള്ള ഒരു ആകൃതി തിരികെ നൽകുക." ) )
നെയിം കൺസ്‌ട്രക്‌റ്റർ ആർഗ്യുമെൻ്റിൽ നിന്ന് ക്ലാസ് മെമ്പർ എന്ന പേര് സ്വയം എങ്ങനെ വേർതിരിക്കപ്പെടുന്നുവെന്ന് ശ്രദ്ധിക്കുക. മറ്റേതൊരു ക്ലാസ് രീതിയും പോലെ, ആർഗ്യുമെൻ്റുകൾ സാധാരണ രീതിയിൽ കൺസ്ട്രക്റ്ററിന് കൈമാറുന്നു. ഓരോ ക്ലാസ് അംഗവും പ്രഖ്യാപിക്കപ്പെടുമ്പോൾ (നമ്പർഓഫ്സൈഡുകൾ പോലെ) അല്ലെങ്കിൽ കൺസ്ട്രക്റ്ററിൽ (പേര് പോലെ) ആരംഭിക്കണം.

ക്ലാസ് ഡിസ്ട്രക്റ്റർ എന്നത് ഡീനിറ്റ് രീതിയാണ്, ആവശ്യമെങ്കിൽ അത് തിരുത്തിയെഴുതാം.

ഇതിനകം ഒരു ക്ലാസ് അവകാശമാക്കാൻ നിലവിലുള്ള ക്ലാസ്, ചൈൽഡ് ക്ലാസിൻ്റെ പേര് വ്യക്തമാക്കിയ ശേഷം, നിങ്ങൾ ഒരു കോളൻ ഇടുകയും മാതാപിതാക്കളുടെ പേര് സൂചിപ്പിക്കുകയും വേണം. സ്വിഫ്റ്റിൽ, ഏതെങ്കിലും സ്റ്റാൻഡേർഡ് ക്ലാസിൻ്റെ നിർബന്ധിത അനന്തരാവകാശത്തിന് നിയന്ത്രണങ്ങളൊന്നുമില്ല.

ഒരു ചൈൽഡ് ക്ലാസ് അസാധുവാക്കുന്ന രീതികൾ അസാധുവാക്കൽ കീവേഡ് ഉപയോഗിച്ച് അടയാളപ്പെടുത്തിയിരിക്കണം - അസാധുവാക്കാതെയുള്ള രീതികൾ മറികടക്കുന്നത് ഒരു പിശകിന് കാരണമാകും. അസാധുവാക്കുന്നതായി അടയാളപ്പെടുത്തിയിരിക്കുന്ന രീതികളും കംപൈലർ കണ്ടെത്തുന്നു, എന്നാൽ അവയുടെ പാരൻ്റ് ക്ലാസിൻ്റെ ഏതെങ്കിലും രീതികൾ അസാധുവാക്കരുത്.
ക്ലാസ് സ്ക്വയർ: NamedShape (var sideLength: Double init(sideLength: Double, name: String) (self.sideLength = sideLength super.init(name: name) numberOfSides = 4 ) func area() -> Double ( return sidelength * sidelength ) അസാധുവാക്കുക func simpleDescription() -> സ്ട്രിംഗ് ("നീളത്തിൻ്റെ വശങ്ങളുള്ള ഒരു ചതുരം \(സൈഡ് ലെങ്ത്)" ) ) ടെസ്റ്റ് ചെയ്യട്ടെ = Square(sideLength: 5.2, name: "my test square") test.area() test.simpleDescript ()

നമുക്ക് പരീക്ഷണം നടത്താം
ഒരു സർക്കിൾ ക്ലാസ് സൃഷ്‌ടിച്ച് നെയിംഡ്‌ഷേപ്പ് ക്ലാസിൽ നിന്ന് അവകാശം നേടുക. സർക്കിൾ ക്ലാസിനായുള്ള കൺസ്ട്രക്റ്റർ രണ്ട് ആർഗ്യുമെൻ്റുകൾ എടുക്കുന്നു: ആരവും പേരും. ഏരിയ അസാധുവാക്കുകയും ഈ ക്ലാസിൻ്റെ രീതികൾ വിവരിക്കുകയും ചെയ്യുക.

ക്ലാസ് അംഗങ്ങൾക്ക് അവരുടേതായ ഗെറ്ററും സെറ്ററും ഉണ്ടായിരിക്കാം.

ക്ലാസ് EquilateralTriangle: NamedShape (var sideLength: Double = 0.0 init(sideLength: Double, name: String) ( self.sideLength = sideLength super.init(name: name) numberOfSides = 3 ) var ചുറ്റളവ്: ഇരട്ട (0 * വശത്തെ നീളം 3 നേടുക. ) സെറ്റ് ( sideLength = newValue / 3.0 ) ) അസാധുവാക്കുക func simpleDescription() -> സ്ട്രിംഗ് ("നീളത്തിൻ്റെ വശങ്ങളുള്ള ഒരു സമഭുജ ത്രികോണം \(വശം നീളം)" തിരികെ നൽകുക.) ) var triangle = EquilateralTriangle(sidelong: 3.1, name: "a triangle ") triangle.perimeter triangle.perimeter = 9.9 triangle.sideLength
പെരിമീറ്റർ വേരിയബിളിൻ്റെ സെറ്ററിൽ, അസൈൻ ചെയ്‌തിരിക്കുന്ന പുതിയ മൂല്യത്തെ പരോക്ഷമായി newValue എന്ന് വിളിക്കുന്നു. ഈ വേരിയബിളിൻ്റെ പേര് സെറ്റ് ചെയ്ത ഉടൻ തന്നെ പരാൻതീസിസിൽ ഇട്ടുകൊണ്ട് നിങ്ങൾക്ക് പേര് മാറ്റാവുന്നതാണ്.

EquilateralTriangle ക്ലാസിൻ്റെ കൺസ്ട്രക്റ്റർ ഘടന ശ്രദ്ധിക്കുക. ഈ രീതിയിൽ മൂന്ന് തുടർച്ചയായ ഘട്ടങ്ങൾ ഉൾപ്പെടുന്നു:

1. ഒരു ചൈൽഡ് ക്ലാസിലെ അംഗങ്ങളെ ആരംഭിക്കുന്നു;
2. പാരൻ്റ് ക്ലാസിൻ്റെ കൺസ്ട്രക്റ്ററെ വിളിക്കുന്നു;
3. പാരൻ്റ് ക്ലാസ്സിലെ അംഗങ്ങളുടെ മൂല്യങ്ങൾ മാറ്റുന്നു.

ഒരു വേരിയബിളിന് ഒരു പുതിയ മൂല്യം നൽകുന്നതിന് മുമ്പോ ശേഷമോ നിങ്ങൾക്ക് നിർദ്ദിഷ്ട കോഡ് എക്സിക്യൂട്ട് ചെയ്യണമെങ്കിൽ, നിങ്ങളുടെ ആവശ്യങ്ങൾക്ക് അനുയോജ്യമായ വിൽസെറ്റ്, ഡിഡ്സെറ്റ് രീതികൾ അസാധുവാക്കാം. ഉദാഹരണത്തിന്, ഒരു ത്രികോണത്തിൻ്റെ വശത്തിൻ്റെ നീളം എല്ലായ്പ്പോഴും ഒരു ചതുരത്തിൻ്റെ വശത്തിൻ്റെ നീളത്തിന് തുല്യമായിരിക്കും എന്ന് ചുവടെയുള്ള ക്ലാസ് ഉറപ്പ് നൽകുന്നു.

ക്ലാസ് ത്രികോണവും സമചതുരവും (var triangle: EquilateralTriangle ( willSet ( square.sideLength = newValue.sideLength ) ) var സ്ക്വയർ: Square ( willSet (triangle.sideLength = newValue.sideLength ) ) init(വലിപ്പം: ഇരട്ട, പേര്: ചതുരം) വശത്തെ നീളം: വലിപ്പം, പേര്: പേര്) ത്രികോണം = സമഭുജ ത്രികോണം (വശം നീളം: വലിപ്പം, പേര്: പേര്) ) var triangleAndSquare = TriangleAndSquare(വലിപ്പം: 10, പേര്: "മറ്റൊരു പരീക്ഷണ രൂപം") triangleAndSquare.square.sidedlength triangle ചതുരം = ചതുരം (വശത്തിൻ്റെ നീളം: 50, പേര്: "വലിയ ചതുരം") triangleAndSquare.triangle.sideLength
ക്ലാസ് രീതികൾക്ക് ഒന്നുണ്ട് പ്രധാന വ്യത്യാസംപ്രവർത്തനങ്ങളിൽ നിന്ന്. ഒരു ഫംഗ്‌ഷൻ്റെ ആർഗ്യുമെൻ്റുകളുടെ പേരുകൾ ആ ഫംഗ്‌ഷനിൽ മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ, അതേസമയം ഒരു ക്ലാസ് രീതിയിൽ, ആ രീതിയെ വിളിക്കുമ്പോൾ പാരാമീറ്ററുകളും ഉപയോഗിക്കുന്നു (ആദ്യ പാരാമീറ്റർ ഒഴികെ). ഡിഫോൾട്ടായി, ഒരു ക്ലാസ് രീതിക്ക് വിളിക്കുമ്പോഴും അതിനുള്ളിലും ഒരേ പാരാമീറ്റർ പേരുകൾ ഉണ്ട്. എന്നിരുന്നാലും, നിങ്ങൾക്ക് മറ്റൊരു പേര് (ചുവടെയുള്ള ഉദാഹരണത്തിൽ - സമയങ്ങൾ) വ്യക്തമാക്കാൻ കഴിയും, അത് ഈ രീതിക്കുള്ളിൽ മാത്രമേ ഉപയോഗിക്കൂ. ഈ സാഹചര്യത്തിൽ, ഈ രീതിയെ വിളിക്കാൻ, നിങ്ങൾ ആദ്യ നാമം (numberOfTimes) ഉപയോഗിക്കണം.

ക്ലാസ് കൗണ്ടർ (var count: Int = 0 func incrementBy(തുക: Int, numberOfTimes തവണ: Int) ( count += തുക * തവണ ) ) var counter = Counter() counter.incrementBy(2, numberOfTimes: 7)
ഓപ്ഷണൽ മൂല്യങ്ങളുമായി പ്രവർത്തിക്കുമ്പോൾ, രീതികൾ, ക്ലാസ് അംഗങ്ങൾ മുതലായവയ്ക്ക് മുമ്പ് ഒരു ചോദ്യചിഹ്നം (?) ചേർക്കുക. ചോദ്യചിഹ്നത്തിന് മുമ്പുള്ള മൂല്യം ശൂന്യമാണെങ്കിൽ, (?) ന് ശേഷമുള്ള എന്തും അവഗണിക്കുകയും മുഴുവൻ പദപ്രയോഗവും ശൂന്യവുമാണ്. അല്ലെങ്കിൽ, പദപ്രയോഗം പതിവുപോലെ വിലയിരുത്തപ്പെടുന്നു. രണ്ട് സാഹചര്യങ്ങളിലും, മുഴുവൻ എക്സ്പ്രഷനും ഒരു ഓപ്ഷണൽ മൂല്യത്തിന് കാരണമാകും.

ഓപ്ഷണൽ സ്ക്വയർ അനുവദിക്കുക: ചതുരം? = ചതുരം (സൈഡ് ലെങ്ത്: 2.5, പേര്: "ഓപ്ഷണൽ സ്ക്വയർ") സൈഡ് ലെങ്ത് = ഓപ്ഷണൽ സ്ക്വയർ?. സൈഡ് ലെങ്ത്

കണക്കുകളും ഘടനകളും

enumerations സൃഷ്ടിക്കാൻ enum കീവേഡ് ഉപയോഗിക്കുന്നു. കണക്കുകളിൽ രീതികളും അടങ്ങിയിരിക്കാമെന്നത് ശ്രദ്ധിക്കുക.

എന്ന റാങ്ക്: ഇൻ്റ് (കേസ് എയ്സ് = 1 കേസ് രണ്ട്, മൂന്ന്, നാല്, അഞ്ച്, ആറ്, ഏഴ്, എട്ട്, ഒമ്പത്, പത്ത് കേസ് ജാക്ക്, ക്വീൻ, കിംഗ് ഫങ്ക് സിമ്പിൾവിവരണം() -> സ്ട്രിംഗ് (സ്വിച്ച് സ്വിച്ച് (കേസ് .ഏസ്: റിട്ടേൺ " ace" കേസ് .ജാക്ക്: "ജാക്ക്" കേസ് തിരികെ നൽകുക .ടു റോ()

നമുക്ക് പരീക്ഷണം നടത്താം
2 റാങ്ക് സംഖ്യകളെ അവയുടെ മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കി താരതമ്യം ചെയ്യുന്ന ഒരു ഫംഗ്‌ഷൻ എഴുതുക.

മുകളിലുള്ള ഉദാഹരണത്തിൽ, enum മൂലകങ്ങൾ തുടക്കത്തിൽ പൂർണ്ണസംഖ്യയുടെ തരമാണ്, നിങ്ങൾ ആദ്യ മൂലകത്തിൻ്റെ മൂല്യം മാത്രം വ്യക്തമാക്കേണ്ടതുണ്ട് - ശേഷിക്കുന്ന മൂലകങ്ങളുടെ മൂല്യങ്ങൾ അവ ദൃശ്യമാകുന്ന ക്രമം അനുസരിച്ച് നിർണ്ണയിക്കപ്പെടും. മൂലക മൂല്യങ്ങളുടെ അസംസ്കൃത മൂല്യമായി നിങ്ങൾക്ക് സ്ട്രിംഗ് അല്ലെങ്കിൽ യഥാർത്ഥ തരങ്ങൾ തിരഞ്ഞെടുക്കാം.

യഥാർത്ഥ മൂല്യ തരം ഒരു എണ്ണൽ തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യാൻ, toRaw, fromRaw ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുക.

ConvertedRank = Rank.fromRaw(3) അനുവദിക്കുകയാണെങ്കിൽ ( threeDescription = convertedRank.simpleDescription() )
എണ്ണൽ മൂലകങ്ങളുടെ മൂല്യങ്ങൾ യഥാർത്ഥമാണെന്നും അവയുടെ യഥാർത്ഥ മൂല്യങ്ങളുടെ മറ്റൊരു പ്രാതിനിധ്യമല്ലെന്നും ശ്രദ്ധിക്കുക. പൊതുവായി പറഞ്ഞാൽ, നിങ്ങൾ അവയുടെ യഥാർത്ഥ മൂല്യങ്ങൾ വ്യക്തമാക്കേണ്ടതില്ല.

എനം സ്യൂട്ട് (കേസ് സ്പേഡുകൾ, ഹാർട്ട്സ്, ഡയമണ്ട്സ്, ക്ലബ്ബുകൾ ഫങ്ക് സിമ്പിൾവിവരണം() -> സ്ട്രിംഗ് (കേസ് .സ്പേഡുകൾ: റിട്ടേൺ "സ്പേഡ്സ്" കേസ് .ഹാർട്ട്സ്: റിട്ടേൺ "ഹാർട്ട്സ്" കേസ് .ഡയമണ്ട്സ്: റിട്ടേൺ "ഡയമണ്ട്സ്" കേസ് .ക്ലബ്ബുകൾ: തിരികെ "ക്ലബുകൾ" ) ) ഹൃദയങ്ങളെ അനുവദിക്കുക = സ്യൂട്ട്. ഹൃദയങ്ങൾ ഹൃദയങ്ങളെ അനുവദിക്കുക

നമുക്ക് പരീക്ഷണം നടത്താം
സ്‌പേഡുകൾക്കും ക്ലബ്ബുകൾക്കുമായി "കറുപ്പ്" എന്ന സ്ട്രിംഗും ഹൃദയങ്ങൾക്കും വജ്രങ്ങൾക്കും "ചുവപ്പ്" നിറവും നൽകുന്ന ഒരു വർണ്ണ രീതി ചേർക്കുക.

സ്യൂട്ട് എൻയുമറേഷൻ്റെ ഹാർട്ട്സ് അംഗം എങ്ങനെയാണ് ആക്സസ് ചെയ്തതെന്ന് ശ്രദ്ധിക്കുക. ഹൃദയങ്ങളുടെ സ്ഥിരാങ്കത്തിന് ഒരു മൂല്യം നൽകുമ്പോൾ, Suit.Hearts എന്ന പൂർണ്ണ നാമം ഉപയോഗിക്കുന്നു, കാരണം ഞങ്ങൾ സ്ഥിരാങ്കത്തിൻ്റെ തരം വ്യക്തമായി വ്യക്തമാക്കുന്നില്ല. സ്വിച്ചിൽ നമ്മൾ ഷോർട്ട് ഫോം .ഹാർട്ട്സ് ഉപയോഗിക്കുന്നു, കാരണം സ്വയം മൂല്യത്തിൻ്റെ തരം ഒരു പ്രിയോറി അറിയപ്പെടുന്നു. വേരിയബിളിൻ്റെ തരം വ്യക്തമായി വ്യക്തമാക്കിയിരിക്കുന്നിടത്തോളം കാലം നിങ്ങൾക്ക് ഹ്രസ്വ ഫോം ഉപയോഗിക്കാം.

ഘടനകൾ സൃഷ്ടിക്കാൻ struct കീവേഡ് ഉപയോഗിക്കുന്നു. രീതികളും കൺസ്ട്രക്റ്ററുകളും ഉൾപ്പെടെ സ്ട്രക്‌റ്റുകൾക്ക് ക്ലാസുകളുമായി നിരവധി സാമ്യങ്ങളുണ്ട്. സ്ട്രക്ച്ചറുകളും ക്ലാസുകളും തമ്മിലുള്ള ഏറ്റവും പ്രധാനപ്പെട്ട വ്യത്യാസം, ക്ലാസുകളുടെ ഉദാഹരണങ്ങളിൽ നിന്ന് വ്യത്യസ്തമായി, ഘടനകളുടെ ഉദാഹരണങ്ങൾ മൂല്യമനുസരിച്ച് ഫംഗ്ഷനുകളിലേക്ക് കൈമാറുന്നു (അതായത്, അവയുടെ പ്രാദേശിക പകർപ്പ് ആദ്യം സൃഷ്ടിച്ചതാണ്), ക്ലാസുകളുടെ ഉദാഹരണങ്ങൾ റഫറൻസ് വഴിയാണ് കടന്നുപോകുന്നത്.

സ്ട്രക്റ്റ് കാർഡ് (var റാങ്ക്: റാങ്ക് var സ്യൂട്ട്: Suit func simpleDescription() -> String ("The \(rank.simpleDescription()) of \(suit.simpleDescription())" ) ) മൂന്ന്OfSpades = Card(rank: . മൂന്ന്, സ്യൂട്ട്: .സ്പേഡുകൾ) മൂന്ന്ഓഫ്സ്പേഡ്സ്വിവരണം = threeOfSpades.simpleDescription()

നമുക്ക് പരീക്ഷണം നടത്താം
ഒരു മുഴുവൻ ഡെക്ക് കാർഡുകൾ സൃഷ്ടിക്കുന്ന ഒരു രീതി കാർഡ് ഘടനയിലേക്ക് ചേർക്കുക.

ഒരു എണ്ണൽ അംഗത്തിൻ്റെ ഉദാഹരണത്തിന് അതിൻ്റേതായ മൂല്യങ്ങൾ ഉണ്ടായിരിക്കാം, അവ വ്യത്യസ്തവുമാകാം. നിങ്ങൾ enum (ഉദാഹരണത്തിലെ വിജയ സ്ഥിരാങ്കം) തൽക്ഷണം ചെയ്യുമ്പോൾ ഈ മൂല്യങ്ങൾ നിയോഗിക്കുന്നു. ബന്ധിതവും യഥാർത്ഥവുമായ മൂല്യങ്ങൾ വ്യത്യസ്ത കാര്യങ്ങളാണ്: യഥാർത്ഥ മൂല്യംഒരു എണീമറേഷൻ അംഗം ഗണനത്തിൻ്റെ എല്ലാ സന്ദർഭങ്ങളിലും എല്ലായ്പ്പോഴും സ്ഥിരമായിരിക്കും, അത് പ്രഖ്യാപിക്കപ്പെടുമ്പോൾ അത് വ്യക്തമാക്കുന്നു.

ഒരു സെർവറിൽ നിന്ന് സൂര്യോദയവും അസ്തമയ സമയവും സ്വീകരിക്കുന്നതിൻ്റെ ഒരു ഉദാഹരണം നോക്കാം. പ്രസക്തമായ വിവരങ്ങളോ പിശക് സന്ദേശമോ ഉപയോഗിച്ച് സെർവർ പ്രതികരിക്കുന്നു.

Enum ServerResponse (കേസ് ഫലം(സ്ട്രിംഗ്, സ്ട്രിംഗ്) കേസ് പിശക്(സ്ട്രിംഗ്) ) വിജയിക്കട്ടെ = ServerResponse.Result("6:00 am", "8:09 pm") പരാജയപ്പെടട്ടെ = ServerResponse.Error("ചീസിന് പുറത്ത്." ) വിജയം മാറുക (കേസ് ലെറ്റ് .ഫലം(സൂര്യോദയം, സൂര്യാസ്തമയം): Let serverResponse = "സൂര്യോദയം \(സൂര്യോദയം) ആണ്, സൂര്യാസ്തമയം \(സൂര്യാസ്തമയം) ആണ്." കേസ് അനുവദിക്കുക .പിശക്(പിശക്): let serverResponse = "പരാജയം.. .\(പിശക്)" )

നമുക്ക് പരീക്ഷണം നടത്താം
മൾട്ടിപ്പിൾ ചോയ്സ് സ്വിച്ച് സ്റ്റേറ്റ്മെൻ്റിലേക്ക് മൂന്നാമത്തെ ഓപ്ഷൻ ചേർക്കുക

സെർവർ റെസ്‌പോൺസ് ഒബ്‌ജക്റ്റിൽ നിന്ന് സൂര്യോദയത്തിൻ്റെയും സൂര്യാസ്തമയത്തിൻ്റെയും സമയങ്ങൾ എങ്ങനെ വലിച്ചെടുക്കുന്നുവെന്ന് ശ്രദ്ധിക്കുക.

പ്രോട്ടോക്കോളുകളും വിപുലീകരണങ്ങളും.

ഒരു പ്രോട്ടോക്കോൾ പ്രഖ്യാപിക്കാൻ, പ്രോട്ടോക്കോൾ കീവേഡ് ഉപയോഗിക്കുക.

പ്രോട്ടോക്കോൾ ഉദാഹരണം പ്രോട്ടോക്കോൾ (var simpleDescription: String ( get ) mutating func adjust() )
ക്ലാസുകൾ, കണക്കുകൾ, ഘടനകൾ എന്നിവയാൽ പ്രോട്ടോക്കോളുകളെ പിന്തുണയ്ക്കാൻ കഴിയും.

Class SimpleClass: ExampleProtocol (var simpleDescription: String = "വളരെ ലളിതമായ ക്ലാസ്." var anotherProperty: Int = 69105 func adjust() ( simpleDescription += "ഇപ്പോൾ 100% ക്രമീകരിച്ചു." ) ) var a = SimpleClass() a.adjust( ) അനുവദിക്കുക aDescription = a.simpleDescription struct SimpleStructure: ExampleProtocol (var simpleDescription: String = "A simple structure" mutating func adjust() ( simpleDescription += " (adjusted)" ) var b = SimpleStructure() b. bDescription = b.simpleDescription

നമുക്ക് പരീക്ഷണം നടത്താം
ഈ പ്രോട്ടോക്കോൾ നടപ്പിലാക്കുന്ന ഒരു enum സൃഷ്ടിക്കുക.

സിമ്പിൾ സ്ട്രക്ചർ ഡെഫനിഷനിലെ മ്യൂട്ടേറ്റിംഗ് കീവേഡ് ശ്രദ്ധിക്കുക, അത് കംപൈലറോട് അനുബന്ധ രീതിയാണ് ഘടനയെ പരിഷ്കരിക്കുന്നതെന്ന് പറയുന്നു. നേരെമറിച്ച്, സിമ്പിൾക്ലാസ് ക്ലാസിൻ്റെ രീതികൾ മ്യൂട്ടേറ്റിംഗ് എന്ന് അടയാളപ്പെടുത്തേണ്ടതില്ല, കാരണം ക്ലാസിൻ്റെ രീതികൾക്ക് എല്ലായ്പ്പോഴും ഇടപെടാതെ തന്നെ അത് മാറ്റാൻ കഴിയും.

നിലവിലുള്ള തരത്തിലേക്ക് പുതിയ രീതികളോ ക്ലാസ് അംഗങ്ങളോ ചേർക്കുന്നതിന്, നിങ്ങൾ വിപുലീകരണങ്ങൾ ഉപയോഗിക്കണം. ഒരു ലൈബ്രറിയിൽ നിന്നോ ചട്ടക്കൂടിൽ നിന്നോ ഇറക്കുമതി ചെയ്തതാണെങ്കിലും, നിലവിലുള്ള ഒരു പ്രോട്ടോക്കോൾ നടപ്പിലാക്കാൻ നിങ്ങൾക്ക് വിപുലീകരണങ്ങളും ഉപയോഗിക്കാം.

എക്സ്റ്റൻഷൻ ഇൻ്റ്: ExampleProtocol (var simpleDescription: String ("The number \(self)" റിട്ടേൺ ചെയ്യുക ) mutating func adjust() ( self += 42 ) ) 7.simpleDescription

നമുക്ക് പരീക്ഷണം നടത്താം
ഒരു അംഗ വേരിയബിൾ absoluteValue ഉപയോഗിച്ച് ഇരട്ട ടൈപ്പിൻ്റെ ഒരു വിപുലീകരണം സൃഷ്ടിക്കുക.

മറ്റേതൊരു തരത്തെയും പോലെ നിങ്ങൾക്ക് പ്രോട്ടോക്കോൾ നാമം ഉപയോഗിക്കാം - ഉദാഹരണത്തിന്, വ്യത്യസ്ത തരത്തിലുള്ള ഒബ്‌ജക്റ്റുകളുടെ ഒരു നിര സൃഷ്ടിക്കാൻ, എന്നാൽ നടപ്പിലാക്കുന്നു പൊതുവായ പ്രോട്ടോക്കോൾ. ഈ തരത്തിലുള്ള ഒബ്‌ജക്‌റ്റുകൾക്കൊപ്പം പ്രവർത്തിക്കുമ്പോൾ, പ്രോട്ടോക്കോളിന് പുറത്ത് പ്രഖ്യാപിച്ച രീതികൾ ലഭ്യമല്ല.

പ്രോട്ടോക്കോൾ മൂല്യം അനുവദിക്കുക: ExampleProtocol = a protocolValue.simpleDescription // protocolValue.anotherProperty // പിശക് കാണുന്നതിന് അഭിപ്രായമിടാതിരിക്കുക
റൺ ടൈമിൽ പ്രോട്ടോക്കോൾ മൂല്യം വേരിയബിൾ സിമ്പിൾക്ലാസ് എന്ന തരത്തിലാണെങ്കിലും, അതിൻ്റെ തരം ExampleProtocol ആണെന്ന് കംപൈലർ അനുമാനിക്കുന്നു. ExampleProtocol-ന് പുറത്ത് നടപ്പിലാക്കുന്ന രീതികളോ ക്ലാസ് അംഗങ്ങളോ ആകസ്മികമായി നിങ്ങൾക്ക് ആക്‌സസ് ചെയ്യാൻ കഴിയില്ല എന്നാണ് ഇതിനർത്ഥം.

ജനറിക് തരങ്ങൾ

ഒരു സാധാരണ തരം സൃഷ്ടിക്കാൻ, ആംഗിൾ ബ്രാക്കറ്റുകളിൽ പേര് ചേർക്കുക (<>).

ഫങ്ക് ആവർത്തനം (ഇനം: ഇനം തരം, തവണ: Int) -> ItemType (var result = ItemType() for i 0.. തവണ (ഫലം += ഇനം ) ഫലം ) ആവർത്തിക്കുക ("തട്ടുക", 4)
ജനറിക് ഫംഗ്‌ഷനുകൾ, ക്ലാസുകൾ, കണക്കുകൾ, ഘടനകൾ എന്നിവ സൃഷ്‌ടിക്കുക.

// സ്വിഫ്റ്റ് സ്റ്റാൻഡേർഡ് ലൈബ്രറിയുടെ ഓപ്ഷണൽ തരം enum OptionalValue വീണ്ടും നടപ്പിലാക്കുക (കേസ് ഒന്നുമില്ല ചില (ടി) ) var സാധ്യമായ സംഖ്യ: ഓപ്ഷണൽ മൂല്യം = .സാധ്യമല്ല സംഖ്യാസംഖ്യ = .ചിലത്(100)
ഒരു പ്രോട്ടോക്കോൾ നടപ്പിലാക്കുകയോ ഒരു പ്രത്യേക ക്ലാസിൽ നിന്ന് അത് അവകാശമാക്കേണ്ടതോ പോലെയുള്ള ഒരു ജനറിക് തരത്തിനായുള്ള നിർദ്ദിഷ്ട ആവശ്യകതകൾ വ്യക്തമാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, എവിടെ ഉപയോഗിക്കുക .

ഏതെങ്കിലും സാധാരണ ഘടകങ്ങൾ പ്രവർത്തിപ്പിക്കുക (lhs: T, rhs: U) -> Bool (lhs-ലെ lhsItem-ന് (rhs-ലെ rhsItem-ന് (lhsItem == rhsItem (സത്യം തിരികെ നൽകുക) ) ) തെറ്റ് തിരികെ നൽകുക ) anyCommonElements(, )

നമുക്ക് പരീക്ഷണം നടത്താം
പൊതുവായ ഘടകങ്ങളുടെ ഒരു നിര തിരികെ നൽകുന്നതിന് anyCommonElements ഫംഗ്‌ഷൻ പരിഷ്‌ക്കരിക്കുക.

ലളിതമായ സന്ദർഭങ്ങളിൽ, നിങ്ങൾക്ക് എവിടെ എന്നത് ഒഴിവാക്കി കോളണിന് ശേഷം പ്രോട്ടോക്കോൾ അല്ലെങ്കിൽ ക്ലാസിൻ്റെ പേര് എഴുതാം. എക്സ്പ്രഷൻ പദപ്രയോഗത്തിന് തുല്യമാണ് .

iOS, Mac, Apple TV, Apple Watch എന്നിവയ്‌ക്കായി നിങ്ങൾക്ക് ആപ്പുകൾ സൃഷ്‌ടിക്കാൻ ഉപയോഗിക്കാവുന്ന ആപ്പിളിൻ്റെ ശക്തവും അവബോധജന്യവുമായ പ്രോഗ്രാമിംഗ് ഭാഷയാണ് സ്വിഫ്റ്റ്. ഇത് ഡെവലപ്പർമാർക്ക് അഭൂതപൂർവമായ സൃഷ്ടിപരമായ സ്വാതന്ത്ര്യം നൽകുന്നു. ഈ ലളിതവും ഉപയോഗിക്കാൻ എളുപ്പമുള്ളതുമായ ഓപ്പൺ സോഴ്‌സ് ഭാഷ ഉപയോഗിച്ച്, നിങ്ങൾക്ക് വേണ്ടത് അവിശ്വസനീയമായ എന്തെങ്കിലും സൃഷ്ടിക്കുന്നതിനുള്ള രസകരമായ ഒരു ആശയമാണ്.

ഡെവലപ്പർമാർ ഇതിനകം ഉപയോഗിക്കുന്നു
സ്വിഫ്റ്റിൻ്റെ അതിശയകരമായ സവിശേഷതകൾ.

പ്രീ-ബിൽറ്റ് ഒബ്ജക്റ്റീവ്-സി കോഡിലേക്ക് എളുപ്പത്തിൽ തിരുകാൻ കഴിയുന്ന വേഗതയേറിയതും കാര്യക്ഷമവും തത്സമയ പ്രോഗ്രാമിംഗ് ഭാഷയുമാണ് സ്വിഫ്റ്റ്. ഇപ്പോൾ ഡവലപ്പർമാർക്ക് കൂടുതൽ വിശ്വസനീയവും സുരക്ഷിതവുമായ കോഡ് എഴുതാൻ മാത്രമല്ല, സമയം ലാഭിക്കാനും വിപുലമായ കഴിവുകളുള്ള ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കാനും കഴിയും.

സ്വിഫ്റ്റിലെ മികച്ച ആപ്പ്.ഉപയോഗിക്കാനുള്ള എളുപ്പവും തത്സമയ പ്രതികരണശേഷിയുമാണ് VSCO അവരുടെ iOS ഫോട്ടോ ആപ്പിൻ്റെ പുതിയ പതിപ്പ് സൃഷ്ടിക്കാൻ Swift തിരഞ്ഞെടുത്തത്.

മികച്ച പ്രയോഗങ്ങൾ,
സ്വിഫ്റ്റ് ഭാഷയിൽ വികസിപ്പിച്ചെടുത്തു.

കൂടുതൽ കൂടുതൽ ഡവലപ്പർമാർ അവരുടെ ആപ്ലിക്കേഷനുകളിലേക്ക് സ്വിഫ്റ്റ് കോഡ് ഉൾപ്പെടുത്തുന്നു. ചിലർ സ്വിഫ്റ്റിൽ പൂർണ്ണമായും പുതിയ ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നു.

ഡ്യുവോലിംഗോ ഖാൻ
അക്കാദമി ക്ലിയർ സ്കൈ ഗൈഡ്

കിക്ക്സ്റ്റാർട്ടർ ഇവൻ്റ്ബ്രൈറ്റ് ഹിപ്മങ്ക് സൃഷ്ടിക്കുക

ഉത്പാദനക്ഷമത കൂടുതലാണ്. അപ്ലിക്കേഷനുകൾ മികച്ചതാണ്.

സ്വിഫ്റ്റ് ആപ്പുകൾ പ്രതീക്ഷകൾക്കപ്പുറമാണ്. ഉദാഹരണത്തിന്, സാധാരണ തിരയൽ അൽഗോരിതം സ്വിഫ്റ്റിൽ വളരെ വേഗത്തിൽ പ്രവർത്തിക്കുന്നു.

2.6 വരെ തവണ ഒബ്ജക്റ്റീവ്-സിയെക്കാൾ വേഗത്തിൽ

8.4 വരെ തവണ പൈത്തൺ 2.7 നേക്കാൾ വേഗത

ഡെപ്ത്-ഫസ്റ്റ് സെർച്ച് അൽഗോരിതം ഉപയോഗിച്ച് ഗ്രാഫിൽ 10,000 പൂർണ്ണസംഖ്യകൾ കണ്ടെത്തി*

സ്വിഫ്റ്റ് ഭാഷ ചേർത്തു
പാഠ്യപദ്ധതിയിലേക്ക്.

ഡെവലപ്പർമാർ മാത്രമല്ല സാധ്യതകളെ അഭിനന്ദിച്ചു വേഗതയേറിയ ഭാഷ. സർവ്വകലാശാലകളും മറ്റ് വിദ്യാഭ്യാസ സ്ഥാപനങ്ങളും പ്രോഗ്രാമിംഗ് ക്ലാസുകളിൽ സ്വിഫ്റ്റ് പഠിപ്പിക്കുകയും iTunes U-യിൽ സൗജന്യ കോഴ്സുകൾ പ്രസിദ്ധീകരിക്കുകയും ചെയ്യുന്നു, അതായത് തുടക്കക്കാർക്ക് പോലും അടിസ്ഥാന കോഡിംഗിൽ നിന്ന് പ്രോ-ലെവൽ പ്രോഗ്രാമിംഗിലേക്ക് എളുപ്പത്തിൽ മാറാൻ കഴിയും.

അവരുടെ പാഠ്യപദ്ധതിയിൽ സ്വിഫ്റ്റ് ഉൾപ്പെടുത്തിയിട്ടുള്ള സർവകലാശാലകൾ

• സാന്താക്രൂസിലെ കാലിഫോർണിയ സർവകലാശാല
• ഫൂട്ട്ഹിൽ കോളേജ്
• റോയൽ മെൽബൺ യൂണിവേഴ്സിറ്റി ഓഫ് ടെക്നോളജി
• മ്യൂണിക്കിലെ സാങ്കേതിക സർവകലാശാല
• ലോസൺ കമ്മ്യൂണിറ്റി കോളേജ്
• മാൻഹട്ടൻ കമ്മ്യൂണിറ്റി കോളേജ്

• മെസ കമ്മ്യൂണിറ്റി കോളേജ്
• ഹൂസ്റ്റൺ കമ്മ്യൂണിറ്റി കോളേജ്
• സെൻട്രൽ പീഡ്‌മോണ്ട് കമ്മ്യൂണിറ്റി കോളേജ്
• പ്ലൈമൗത്ത് സർവകലാശാല
• കാലിഫോർണിയ സ്റ്റേറ്റ് പോളിടെക്നിക് യൂണിവേഴ്സിറ്റി
• സ്റ്റാൻഫോർഡ് യൂണിവേഴ്സിറ്റി

• നോർത്ത് വെസ്റ്റ് കൻസാസ് ടെക്നിക്കൽ കോളേജ്
• ടെക്നോളജിക്കൽ ഇൻസ്റ്റിറ്റ്യൂട്ട് ഓഫ് മോണ്ടെറി
• അബെറിസ്റ്റ്വിത്ത് യൂണിവേഴ്സിറ്റി
• ഫുൾ സെയിൽ യൂണിവേഴ്സിറ്റി
• ഇൻഗെസപ്പ് സ്കൂൾ
• സതേൺ മെത്തഡിസ്റ്റ് യൂണിവേഴ്സിറ്റി

സ്വിഫ്റ്റ് എല്ലായിടത്തും ഉണ്ട്.
ഇപ്പോൾ അത് എല്ലാവർക്കുമായി തുറന്നിരിക്കുന്നു.

അപ്പാച്ചെ 2.0 ഓപ്പൺ സോഴ്‌സ് സോഫ്റ്റ്‌വെയർ ലൈസൻസിന് കീഴിലുള്ള ഡെവലപ്പർമാർക്കും അധ്യാപകർക്കും വിദ്യാർത്ഥികൾക്കും ഉപയോഗിക്കുന്നതിന് സ്വിഫ്റ്റ് സൗജന്യമായി ലഭ്യമാണ്. iOS, OS X, watchOS, tvOS, Linux എന്നിവയ്‌ക്കായി കോഡ് കംപൈൽ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന OS X, Linux ബൈനറികൾ ഞങ്ങൾ നൽകുന്നു. കൂടുതൽ ശക്തമായ ഭാഷയിലേക്ക് സ്വിഫ്റ്റിൻ്റെ വികസനം ത്വരിതപ്പെടുത്തുന്നതിന്, ഉപയോക്താക്കൾക്ക് നേരിട്ട് സംഭാവന ചെയ്യാൻ കഴിയുന്ന ഒരു പുതിയ കമ്മ്യൂണിറ്റി ഞങ്ങൾ സൃഷ്ടിച്ചു. ഉറവിടംസ്വിഫ്റ്റ്.

സ്വിഫ്റ്റിനെ കണ്ടുമുട്ടുക.

പ്രധാന പുസ്തകം

ട്യൂട്ടോറിയൽ ഡൗൺലോഡ് ചെയ്യുക സ്വിഫ്റ്റ് പ്രോഗ്രാമിംഗ് ഭാഷനിന്ന് ആപ്പിൾ ബുക്സ്സൗജന്യമായി സംഭരിക്കുക. സ്വിഫ്റ്റ് പ്രോഗ്രാമിംഗ് കൂടുതൽ സൗകര്യപ്രദവും വഴക്കമുള്ളതും രസകരവുമാക്കുന്നത് എങ്ങനെയെന്ന് അറിയുക.

Xcode

Mac, iOS എന്നിവയ്‌ക്കായി മറ്റ് ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുന്നതിന് രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്ന ഒരു Mac അപ്ലിക്കേഷനാണ് Xcode. നിങ്ങൾക്ക് അതിശയകരമായ ആപ്പുകൾ സൃഷ്ടിക്കാൻ ആവശ്യമായ എല്ലാ ഉപകരണങ്ങളും Xcode-ൽ ഉണ്ട്. ഇത് മാക് ആപ്പ് സ്റ്റോറിൽ നിന്ന് സൗജന്യമായി ഡൗൺലോഡ് ചെയ്യാം.

ഡെവലപ്പർ വെബ്സൈറ്റ്

വിശദമായി മനസ്സിലാക്കുക സാങ്കേതിക വിവരങ്ങൾസ്വിഫ്റ്റ് ഭാഷയെക്കുറിച്ചുള്ള ഞങ്ങളുടെ പൂർണ്ണ അവലോകനം പരിശോധിക്കുക. കാലികമായി തുടരാൻ ഡെവലപ്പർ ബ്ലോഗ് പരിശോധിക്കുക. പുതിയ വാർത്ത. ട്യൂട്ടോറിയലുകൾ, വീഡിയോകൾ, കോഡ് സാമ്പിളുകൾ എന്നിവ പോലുള്ള മികച്ച ഉറവിടങ്ങളിലേക്കും നിങ്ങൾക്ക് സൗജന്യ ആക്സസ് ഉണ്ട്.

അവസാനം അപ്ഡേറ്റ് ചെയ്തത്: 12/25/2017

ആപ്പിൾ ഉപകരണങ്ങൾ ഈ രംഗത്തെ അംഗീകൃത നേതാവാണ് വിവര സാങ്കേതിക വിദ്യകൾ. ഏറ്റവും പുതിയ ഡാറ്റ അനുസരിച്ച്, മറ്റ് മൊബൈൽ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾക്കിടയിൽ iOS-ൻ്റെ വിഹിതം ഏകദേശം 15-20% ചാഞ്ചാട്ടം കാണിക്കുന്നു, കൂടാതെ Mac OSX-ൻ്റെ പങ്ക് ഡെസ്ക്ടോപ്പ് സിസ്റ്റങ്ങൾവിവിധ സ്രോതസ്സുകൾ പ്രകാരം, ഇത് 15-20% ആണ്. ആപ്പിൾ ഉപകരണങ്ങളുടെ അത്തരം വ്യാപകമായ ഉപയോഗം ഈ ഉപകരണങ്ങൾക്കായി സോഫ്റ്റ്വെയറിൻ്റെ ആവശ്യകത സൃഷ്ടിക്കുന്നു.

പരമ്പരാഗതമായി, iOS, MacOS എന്നിവയുടെ പ്രധാന പ്രോഗ്രാമിംഗ് ഭാഷ ഒബ്ജക്റ്റീവ്-സി ആയിരുന്നു, എന്നാൽ 2014 ജൂൺ 2-ന് ഒരു ഡെവലപ്പർ കോൺഫറൻസിൽ ആപ്പിൾ WWDC 2014 പുതിയതും കൂടുതൽ സൗകര്യപ്രദവുമായ ഒരു പ്രോഗ്രാമിംഗ് ഭാഷ അവതരിപ്പിച്ചു - സ്വിഫ്റ്റ്. ഒബ്ജക്റ്റീവ്-സിയുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ, സ്വിഫ്റ്റിന് ഇനിപ്പറയുന്ന സവിശേഷതകൾ ഉണ്ട്:

ശുദ്ധമായ ഒബ്ജക്റ്റ് ഓറിയൻ്റഡ് പ്രോഗ്രാമിംഗ് ഭാഷയാണ് സ്വിഫ്റ്റ്

ലാളിത്യവും വ്യക്തവും സംക്ഷിപ്തവുമായ വാക്യഘടന

കർശനമായ ടൈപ്പിംഗ്. ഓരോ വേരിയബിളിനും ഒരു പ്രത്യേക തരം ഉണ്ട്

ഓട്ടോമാറ്റിക് മെമ്മറി മാനേജ്മെൻ്റ്

എന്നിരുന്നാലും, സി, ഒബ്ജക്റ്റീവ്-സി എന്നിവ ഉപയോഗിച്ചിരുന്ന മുമ്പ് എഴുതിയ കൊക്കോ എപിഐകളുമായി സ്വിഫ്റ്റ് പൂർണ്ണമായും പൊരുത്തപ്പെടുന്നു.

അതേ സമയം, സ്വിഫ്റ്റ് വികസിക്കുന്നത് തുടരുന്നു. 2017 സെപ്റ്റംബർ 19-ന്, പതിപ്പ് 4.0 പുറത്തിറങ്ങി, ഇത് iOS, Mac OS എന്നിവയ്‌ക്കായുള്ള വികസനത്തിനായി പുതിയ സവിശേഷതകൾ ചേർത്തു. തത്വത്തിൽ, എല്ലാ വർഷവും പുതിയ പതിപ്പുകൾ പുറത്തിറങ്ങുന്നു.

സ്വിഫ്റ്റ് ഒരു സമാഹരിച്ച പ്രോഗ്രാമിംഗ് ഭാഷയാണ്. അതായത്, ഡെവലപ്പർ സോഴ്സ് കോഡ് എഴുതുന്നു, തുടർന്ന് ഒരു കംപൈലർ ഉപയോഗിച്ച് ഈ കോഡ് കംപൈൽ ചെയ്യുന്നു നിയന്ത്രണ പരിപാടി. ഈ പ്രോഗ്രാം ഫയൽ പിന്നീട് AppStore-ലേക്ക് അപ്‌ലോഡ് ചെയ്യാനും മറ്റ് ഉപയോക്താക്കൾക്ക് വിതരണം ചെയ്യാനും കഴിയും.

iOS-നായി നിങ്ങൾ എന്താണ് വികസിപ്പിക്കേണ്ടത്?

ഒന്നാമതായി, നിങ്ങൾക്ക് ഉചിതമായ ഓപ്പറേറ്റിംഗ് സിസ്റ്റം Mac OS 10.12 Yosemite അല്ലെങ്കിൽ ഉയർന്നത് ആവശ്യമാണ്. Mac OS ഇല്ലാതെ ഒരു പ്രോഗ്രാം കംപൈൽ ചെയ്യുന്നത് മിക്കവാറും അസാധ്യമാണ്. ആപ്പിൾ കമ്പ്യൂട്ടറുകളിൽ (iMac, MacBook, MacBook Air, MacBook Pro) മാത്രമേ Mac OS പ്രവർത്തിക്കുമെന്ന് ഉറപ്പുനൽകാൻ കഴിയൂ എന്ന വസ്തുതയും ഇതേ കമ്പ്യൂട്ടറുകളുടെ ഉയർന്ന വിലയും കണക്കിലെടുക്കുമ്പോൾ ഈ സാഹചര്യം വികസന സാധ്യതകളെ വളരെയധികം പരിമിതപ്പെടുത്തുന്നു. എന്നിരുന്നാലും, Windows അല്ലെങ്കിൽ Linux അടിസ്ഥാനമാക്കിയുള്ള OS പ്രവർത്തിക്കുന്ന ഒരു സാധാരണ പിസിയിൽ iOS, Mac OS എന്നിവയ്ക്കായി ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നത് മിക്കവാറും അസാധ്യമാണ്.

കൂടെ ഓപ്ഷനുകളും ഉണ്ട് വെർച്വൽ മെഷീനുകൾ, Mac OS ഇൻസ്റ്റാൾ ചെയ്തിരിക്കുന്നതോ ഹാക്കിൻ്റോഷ് ഉപയോഗിക്കുന്നതോ ആണെങ്കിലും, അത്തരം ഓപ്ഷനുകളുടെ പ്രകടനം ഉറപ്പില്ല.

മറ്റൊരു ഓപ്ഷൻ ഉണ്ട് - ലഭ്യമായതിൽ കോഡ് എഴുതുക ഓപ്പറേറ്റിംഗ് സിസ്റ്റംകൂടെ കംപൈൽ ചെയ്യുന്നു പ്രത്യേക സേവനങ്ങൾഒരു ഫീസ് സൗജന്യമായി പോകുക. പക്ഷേ, അത്തരമൊരു സമീപനത്തിൻ്റെ ആശ്വാസം വളരെ കുറവാണെന്ന് വ്യക്തമാണ്.

വികസനത്തിന് തന്നെ, ഞങ്ങൾക്ക് സ്വിഫ്റ്റ് ഭാഷാ ഉപകരണങ്ങൾ ആവശ്യമാണ്, ടെക്സ്റ്റ് എഡിറ്റർകോഡ് എഴുതുന്നതിന്, ആപ്ലിക്കേഷൻ ഡീബഗ്ഗിംഗിനായി iPhone, iPad സിമുലേറ്ററുകൾ. ഈ എല്ലാ വികസന സവിശേഷതകൾക്കും മറ്റ് പലതിനും, ആപ്പിൾ സൗജന്യ XCode വികസന അന്തരീക്ഷം നൽകുന്നു.

നമുക്ക് ശരിക്കും ആവശ്യമുണ്ടോ ഐഫോൺ ഉപകരണങ്ങൾഅല്ലെങ്കിൽ വികസിപ്പിച്ച ആപ്ലിക്കേഷനുകൾ പരിശോധിക്കുന്നതിനുള്ള ഐപാഡ്? വലിയതോതിൽ, ഇല്ല, കാരണം XCode പരിശോധനയ്‌ക്കായി സിമുലേറ്ററുകൾ നൽകുന്നു, എന്നാൽ ചില വ്യക്തിഗത സാഹചര്യങ്ങളിൽ ഒരു യഥാർത്ഥ സ്മാർട്ട്‌ഫോണിൽ പരീക്ഷിക്കുന്നതാണ് നല്ലത്.

ഡെവലപ്പർ രജിസ്ട്രേഷൻ

കൂടാതെ, നിങ്ങൾ ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കാൻ തുടങ്ങുന്നതിനുമുമ്പ്, നിങ്ങൾ ആപ്പിൾ ഡെവലപ്പർ സെൻ്ററിൽ രജിസ്റ്റർ ചെയ്യേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, ലിങ്ക് പിന്തുടരുക https://developer.apple.com/register/:

രജിസ്റ്റർ ചെയ്യുന്നതിന്, നിങ്ങളുടെ സൈറ്റിൽ ലോഗിൻ ചെയ്യേണ്ടതുണ്ട് ആപ്പിൾ ഐഡിഐഡിയും പാസ്‌വേഡും. പെട്ടെന്ന് നിങ്ങൾക്ക് അത്തരമൊരു ഐഡൻ്റിഫയർ ഇല്ലെങ്കിൽ, Apple ID സൃഷ്ടിക്കുക എന്ന ലിങ്കിൽ ക്ലിക്കുചെയ്ത് നിങ്ങൾക്ക് ഒരു പുതിയ അക്കൗണ്ട് സൃഷ്ടിക്കാൻ കഴിയും. രജിസ്ട്രേഷനുശേഷം, വിവിധ വശങ്ങൾക്കായി നിങ്ങൾക്ക് വിവിധ വികസന സാമഗ്രികൾ കണ്ടെത്താൻ കഴിയുന്ന ഒരു പേജിലേക്ക് സൈറ്റ് റീഡയറക്‌ട് ചെയ്യും.