స్విఫ్ట్ ట్యుటోరియల్: స్విఫ్ట్ ఉపయోగించి iOS అభివృద్ధితో ప్రారంభించండి

ఈ స్విఫ్ట్ ట్యుటోరియల్ బ్లాగులో, స్విఫ్ట్ యొక్క కొన్ని ప్రాథమిక అంశాలను నేను మీకు పరిచయం చేయబోతున్నాను. కానీ, ముందుకు వెళ్ళే ముందు, “స్విఫ్ట్ అంటే ఏమిటి” గురించి మీకు తెలిసిపోతుంది మరియు మీ సిస్టమ్‌లో స్విఫ్ట్‌ను ఎలా ఇన్‌స్టాల్ చేయవచ్చు. కాబట్టి, ఇప్పుడే ప్రారంభిద్దాం !!

స్విఫ్ట్ ట్యుటోరియల్‌లోని ఈ బ్లాగులో, నేను ఈ క్రింది అంశాలను కవర్ చేస్తాను:

• స్విఫ్ట్ అంటే ఏమిటి?
• స్విఫ్ట్ను ఎలా ఇన్స్టాల్ చేయాలి?
• ప్రాథమిక సింటాక్స్
• వేరియబుల్స్, డేటాటైప్స్ & టైప్‌కాస్టింగ్
• ఆపరేటర్లు
• షరతులతో కూడిన ప్రకటనలు
• పునరావృత ఉచ్చులు
• శ్రేణులు & టుపుల్స్
• సెట్స్ & డిక్షనరీలు
• విధులు
• మూసివేతలు & నిర్మాణాలు
• తరగతి & వారసత్వం
• ప్రోటోకాల్స్
• పొడిగింపులు
• జెనెరిక్స్
• గణనలు

స్విఫ్ట్ ట్యుటోరియల్: స్విఫ్ట్ అంటే ఏమిటి?

స్విఫ్ట్ అనేది ప్రోగ్రామింగ్ భాష, ఇది సి మరియు ఆబ్జెక్టివ్-సి యొక్క ఉత్తమమైన వాటిని స్వీకరిస్తుంది మరియు ఆపిల్ ఇంక్ చేత iOS / OS X అభివృద్ధి కోసం ఇప్పటికే ఉన్న అనేక iOS 6 మరియు OS X 10.8 ప్లాట్‌ఫామ్‌లపై అమలు చేయడానికి అభివృద్ధి చేయబడింది.

స్విఫ్ట్ ట్యుటోరియల్: స్విఫ్ట్ను ఎలా ఇన్స్టాల్ చేయాలి?

స్విఫ్ట్ ఉపయోగించడానికి, ప్లేగ్రౌండ్‌లో మీ స్విఫ్ట్ కోడింగ్‌ను అమలు చేయడానికి మీకు ఎక్స్‌కోడ్ సాఫ్ట్‌వేర్ అవసరం మరియు మీరు స్విఫ్ట్‌తో సౌకర్యంగా ఉంటే, మీరు iOS / OS x అప్లికేషన్ అభివృద్ధి కోసం Xcode IDE ని ఉపయోగించవచ్చు.

కాబట్టి, మీకు ఆపిల్ డెవలపర్ వెబ్‌సైట్‌లో ఖాతా ఉందని uming హిస్తే, మీరు వెళ్ళాలి ఆపిల్ డెవలపర్‌ల కోసం డౌన్‌లోడ్ చేయండి.

ఒకసారి, మీరు లింక్‌కి వెళ్లి, అందుబాటులో ఉన్న ఎక్స్‌కోడ్ యొక్క తాజా వెర్షన్‌ను ఎంచుకుని, డిస్క్ ఇమేజ్ దగ్గర ఇచ్చిన లింక్‌పై క్లిక్ చేయడం ద్వారా డౌన్‌లోడ్ చేసుకోండి.

Dmg ఫైల్‌ను డౌన్‌లోడ్ చేసిన తర్వాత, దానిపై డబుల్ క్లిక్ చేయడం ద్వారా మీరు దీన్ని ఇన్‌స్టాల్ చేయవచ్చు.

సరే !! కాబట్టి, మీరు మీ xCode ను కలిగి ఉంటే, తెరవడానికి దానిపై రెండుసార్లు క్లిక్ చేసి, ఆపై వెళ్ళండి ఫైల్ -> క్రొత్తది మరియు ఎంచుకోండి ఆట స్థలం . అప్పుడు iOS ని ఎంచుకోండి మరియు ఆట స్థలం పేరును పేర్కొనండి. మీరు ఆ క్లిక్‌తో పూర్తి చేసిన తర్వాత సృష్టించండి.

చిత్రం 1: Xcode IDE లో ఆట స్థలాన్ని సృష్టించడం - స్విఫ్ట్ ట్యుటోరియల్

కాబట్టి, ఇప్పుడు మీ ఆట స్థలం సిద్ధంగా ఉంది, కొన్ని కోడింగ్‌తో ప్రారంభిద్దాం!

కాబట్టి, ప్రారంభంలో ప్రాథమిక వాక్యనిర్మాణంతో ప్రారంభిద్దాం, ఆపై హలో వరల్డ్ ప్రోగ్రామ్‌ను వ్రాద్దాం.

స్విఫ్ట్ ట్యుటోరియల్: ప్రాథమిక సింటాక్స్

• టోకెన్లు - టోకెన్ ఒక కీవర్డ్ , ఐడెంటిఫైయర్, స్థిరాంకం, స్ట్రింగ్ అక్షరాలా లేదా చిహ్నం.
• సెమికోలన్లు - స్విఫ్ట్‌లో మీరు కోడ్‌లోని ప్రతి స్టేట్‌మెంట్ తర్వాత సెమికోలన్ () ను టైప్ చేయవలసిన అవసరం లేదు. ఒకే వరుసలో బహుళ స్టేట్‌మెంట్‌లను ఉపయోగిస్తున్న సందర్భంలో మాత్రమే, సెమికోలన్ డీలిమిటర్‌గా ఉపయోగించబడుతుంది.
• కీవర్డ్లు - కీలకపదాలు కోడింగ్ భాషలలో రిజర్వు చేయబడిన పదాలు, ఇవి బ్యాక్‌టిక్‌లతో తప్పించుకోకపోతే స్థిరాంకాలు లేదా వేరియబుల్స్ లేదా మరే ఇతర ఐడెంటిఫైయర్ పేర్లుగా ఉపయోగించబడవు (`& హెల్ప్`).
• సాహిత్యం - అక్షరాలా ప్రధానంగా పూర్ణాంకం, తేలియాడే పాయింట్ సంఖ్య లేదా స్ట్రింగ్ రకం విలువ యొక్క సోర్స్ కోడ్ ప్రాతినిధ్యం. కాబట్టి, సాహిత్యం ఒక పూర్ణాంక సాహిత్యం, తేలియాడే సాహిత్యం, స్ట్రింగ్ సాహిత్యం లేదా బూలియన్ సాహిత్యం కావచ్చు.
• వ్యాఖ్యలు - సంకలనం చేయని పాఠాలను విస్మరించడానికి వ్యాఖ్యలు కంపైలర్లకు సహాయపడతాయి. బహుళ-లైన్ వ్యాఖ్యలతో ప్రారంభమవుతుంది / * మరియు ముగించండి * / సింగిల్-లైన్ వ్యాఖ్యలు ఉపయోగించి వ్రాయబడతాయి // వ్యాఖ్య ప్రారంభంలో.
• ఐడెంటిఫైయర్స్ - స్విఫ్ట్ అనేది కేస్-సెన్సిటివ్ భాష మరియు ఐడెంటిఫైయర్‌లలో @, $ మరియు% వంటి ప్రత్యేక అక్షరాలను అనుమతించదు. ఒక ఐడెంటిఫైయర్ A నుండి Z లేదా a నుండి z లేదా అండర్ స్కోర్ _ తో మొదలవుతుంది, తరువాత ఎక్కువ అక్షరాలు, అండర్ స్కోర్లు మరియు అంకెలు (0 నుండి 9 వరకు).
• తెల్లని ఖాళీలు - ఖాళీలు, ట్యాబ్‌లు, న్యూలైన్ అక్షరాలు, వ్యాఖ్యలను వివరించడానికి మరియు స్టేట్‌మెంట్‌లోని ఒక భాగాన్ని మరొకటి నుండి వేరు చేయడానికి వైట్‌స్పేస్ స్విఫ్ట్‌లో ఉపయోగించబడుతుంది. ఒక ప్రకటనలోని ఒక మూలకం ఎక్కడ ముగుస్తుందో మరియు తదుపరి మూలకం ఎక్కడ ప్రారంభమవుతుందో గుర్తించడానికి ఇది కంపైలర్‌కు సహాయపడుతుంది.

హలో వరల్డ్ ప్రోగ్రామ్

/ * హలో వరల్డ్ ప్రోగ్రామ్ * / దిగుమతి UIKit // మేము iOS ఆట స్థలం కోసం ప్రోగ్రామ్‌ను సృష్టిస్తున్నందున, మేము UiKit var myString = 'హలో వరల్డ్!' ప్రింట్ (myString) // 2 స్టేట్‌మెంట్‌లు కలిసి ఉపయోగించినప్పటి నుండి ఉపయోగించిన సెమికోలన్

అవుట్పుట్ :

హలో వరల్డ్!

ఇప్పుడు, మీరు మీ మొదటి ప్రోగ్రామ్‌ను వ్రాశారు, వేరియబుల్స్ మరియు డేటా రకాలను గురించి మరింత అర్థం చేసుకుందాం.

స్విఫ్ట్ ట్యుటోరియల్: వేరియబుల్స్, డేటాటైప్స్ & టైప్‌కాస్టింగ్

వేరియబుల్స్

వేరియబుల్స్ విలువలను నిల్వ చేయడానికి రిజర్వు చేసిన మెమరీ స్థానాలు తప్ప మరొకటి కాదు. మీరు వేరియబుల్ సృష్టించినప్పుడు మీరు మెమరీలో కొంత స్థలాన్ని రిజర్వు చేస్తారు.

var a = 42 // వేరియబుల్ డిక్లేరింగ్ var a: Int = 42 // మీరు డేటా రకాన్ని పేర్కొనడం ద్వారా వేరియబుల్ ను కూడా ప్రకటించవచ్చు. b = 32 // స్థిరమైన ముద్రణ (varA) ను ప్రకటించనివ్వండి

డేటాటైప్స్

ఏ ఇతర ప్రోగ్రామింగ్ భాష మాదిరిగానే, స్విఫ్ట్ అంతర్నిర్మిత డేటా రకాలను అందిస్తుంది, మీరు ఈ క్రింది పట్టికలో సూచించవచ్చు:

ఇప్పుడు, ఇక్కడ ఒక ఆసక్తికరమైన విషయం మీకు చెప్తాను.

స్విఫ్ట్‌లో, మీరు వేరియబుల్‌ను ప్రకటించినప్పుడు డేటా రకాన్ని తప్పనిసరిగా నిర్వచించాల్సిన అవసరం లేదు.

కాబట్టి, మీరు వేరియబుల్ డిక్లేర్ చేస్తారని అనుకుందాం var b = 'హాయ్' , అప్పుడు స్విఫ్ట్ స్వయంచాలకంగా అర్థం అవుతుంది బి ఒక స్ట్రింగ్ టైప్ వేరియబుల్, మీరు ఇచ్చిన ఇన్పుట్ ఆధారంగా.

కాస్టింగ్ అని టైప్ చేయండి

ఇప్పుడు మీరు టైప్ కన్వర్షన్ లేదా టైప్ కాస్టింగ్ కూడా చేయవచ్చు.

ఉదాహరణకు, మీరు పూర్ణాంక విలువను ఫ్లోట్ విలువగా మార్చవచ్చు మరియు దీనికి విరుద్ధంగా చేయవచ్చు.

మాజీ పరిగణించండిక్రింద తగినంత:

లెట్ ఎ: Int = 5679 // డిక్లేర్ 2 స్థిరాంకాలు b: ఫ్లోట్ = 2.9999 // ఫ్లోట్‌ను Int ప్రింట్‌గా మారుస్తుంది (“ఈ సంఖ్య ఇప్పుడు ఒక Int (Int (b))”) // Int ని ఫ్లోట్ ప్రింట్‌గా మారుస్తుంది (“ఇది సంఖ్య ఇప్పుడు ఫ్లోట్ (ఫ్లోట్ (ఎ)) ”)

అవుట్పుట్:

ఈ సంఖ్య ఇప్పుడు Int 2 ఈ సంఖ్య ఇప్పుడు 5679.0 ఫ్లోట్

స్విఫ్ట్ ట్యుటోరియల్: ఆపరేటర్లు

ఆపరేటర్లు అంటే ఒపెరాండ్ల విలువలను మార్చగల నిర్మాణాలు. 7 + 3 = 10 అనే వ్యక్తీకరణను పరిగణించండి, ఇక్కడ 7 మరియు 3 ఒపెరాండ్స్ మరియు + ఆపరేటర్ అంటారు.స్విఫ్ట్ క్రింది రకాల ఆపరేటర్లకు మద్దతు ఇస్తుంది:

అత్తి 2: స్విఫ్ట్లో వివిధ ఆపరేటర్లు - స్విఫ్ట్ ట్యుటోరియల్

ఇప్పుడు, నేను లోతుగా వెళ్ళడానికి వెళ్ళడం లేదు, కానీ స్విఫ్ట్‌లో కొన్ని సాధారణ కార్యకలాపాలను మీకు చూపిస్తాను. దిగువ ఉదాహరణను పరిశీలించండి:

print ('5 + 3 = (5 + 3)') // అదనంగా ముద్రణ ('5 - 3 = (5 - 3)') // వ్యవకలనం ముద్రణ ('5 * 3 = (5 * 3)') // గుణకారం ముద్రణ ('5/3 = (5/3)') // డివిజన్ ప్రింట్ ('5% 3 = (5% 3)') // మాడ్యులస్

అవుట్పుట్:

5 + 3 = 8 5 - 3 = 2 5 * 3 = 15 5/3 = 1 5% 3 = 2.3 

సరే !! ఇప్పుడు, మీకు ప్రాథమిక ఆపరేటర్‌లు తెలుసు, షరతులతో కూడిన స్టేట్‌మెంట్‌లతో ప్రారంభిద్దాం.

స్విఫ్ట్ ట్యుటోరియల్: షరతులతో కూడిన ప్రకటనలు

కొన్ని షరతులు నిజమైతే స్టేట్‌మెంట్ లేదా స్టేట్‌మెంట్‌ల సమూహాన్ని అమలు చేయడానికి షరతులతో కూడిన స్టేట్‌మెంట్‌లు ఉపయోగించబడతాయి.మూడు షరతులతో కూడిన ప్రకటనలు ఉన్నాయి - ఉంటే, ఉంటే-వేరే మరియు మారండి ప్రకటనలు.

కాబట్టి, ఇఫ్ స్టేట్‌మెంట్‌తో ఇప్పుడే ప్రారంభిద్దాం.

స్టేట్మెంట్ ఉంటే

ఒక, ఒకవేళ స్టేట్మెంట్ ఒక సాధారణ ఉంటే, లేదా స్టేట్మెంట్ ఉంటే గూడు కావచ్చు.

కాబట్టి, ఒక సాధారణ ఉంటే స్టేట్మెంట్ అనేది చాలా సరళమైన నిర్ణయం తీసుకునే స్టేట్మెంట్, ఇది ఒక నిర్దిష్ట స్టేట్మెంట్ లేదా స్టేట్మెంట్ యొక్క బ్లాక్ అమలు చేయబడుతుందో లేదో నిర్ణయిస్తుంది.

జావా ఫ్రంట్ ఎండ్ డెవలపర్ పున ume ప్రారంభం

అత్తి 3: షరతులతో కూడిన స్టేట్మెంట్ యొక్క ఫ్లో చార్ట్ - స్విఫ్ట్ ట్యుటోరియల్

క్రింది ఉదాహరణను పరిశీలించండి:

var x: Int = 10 ఉంటే x<20 { print('x is less than 20') } print('Value of variable x is (x)') 

అవుట్పుట్:

x 20 కన్నా తక్కువ వేరియబుల్ x యొక్క విలువ 10

సమూహ-ఉంటే

ఇప్పుడు, ఉంటే గూడు if స్టేట్మెంట్ లేదా if స్టేట్మెంట్ లోపల if-else స్టేట్మెంట్.

అత్తి 4: షరతులతో కూడిన స్టేట్మెంట్ ఉంటే నెస్టెడ్ యొక్క ఫ్లో చార్ట్ - స్విఫ్ట్ ట్యుటోరియల్

క్రింది ఉదాహరణను పరిశీలించండి:

var x: Int = 100 var y: Int = 200 ఉంటే x == 100 {ప్రింట్ ('మొదటి షరతు సంతృప్తి చెందింది') ఉంటే y == 200 {ప్రింట్ ('రెండవ షరతు కూడా సంతృప్తి చెందుతుంది')}} ముద్రణ ('విలువ వేరియబుల్ x అనేది (x) ') ప్రింట్ (' వేరియబుల్ y యొక్క విలువ (y) ')

అవుట్పుట్:

మొదటి పరిస్థితి సంతృప్తికరంగా ఉంది రెండవ పరిస్థితి సంతృప్తికరంగా ఉంటుంది వేరియబుల్ x యొక్క విలువ 100 వేరియబుల్ y యొక్క విలువ 200

ఉంటే-వేరే ప్రకటన

If-else స్టేట్మెంట్ షరతును పరీక్షిస్తుంది మరియు షరతు తప్పు అయితే ‘else’ స్టేట్మెంట్ అమలు అవుతుంది.

అత్తి 5: ఫ్లో చార్ట్ ఆఫ్ ఇఫ్ - వేరే షరతులతో కూడిన స్టేట్మెంట్ - స్విఫ్ట్ ట్యుటోరియల్

దిగువ ఉదాహరణను పరిశీలించండి:

var x: Int = 10 ఉంటే x<20 { print('x is less than 20') } else { print('x is not less than 20')} print('Value of variable x is (x)') 

అవుట్పుట్:

x 20 కన్నా తక్కువ

If-else..if-else (if-else నిచ్చెన)

ఇప్పుడు, మీరు కూడా కలిగి ఉండవచ్చు if-else నిచ్చెన.కాబట్టి, if-else-if నిచ్చెన వినియోగదారుని ఒక లూప్‌లోని వేరే స్టేట్‌మెంట్‌లను ఉపయోగించడానికి అనుమతిస్తుంది మరియు ఒకవేళ షరతులో ఒకటి నిజమైతే మిగిలిన ఉచ్చులు బైపాస్ చేయబడతాయి.

అత్తి 6: ఫ్లో చార్ట్ ఆఫ్ ఇఫ్ - లేస్ లాడర్ షరతులతో కూడిన స్టేట్మెంట్ - స్విఫ్ట్ ట్యుటోరియల్

దిగువ ఉదాహరణను పరిశీలించండి:

var x: Int = 100 var y: Int = 200 ఉంటే xy {/ * పరిస్థితి నిజమైతే ఈ క్రింది వాటిని ప్రింట్ చేయండి * / print ('x y కన్నా గొప్పది')} else {/ * పరిస్థితి తప్పు అయితే కింది వాటిని ప్రింట్ చేయండి * / ముద్రణ ('x y కి సమానం')} ముద్రణ ('వేరియబుల్ x మరియు y యొక్క విలువ: (x) మరియు (y)')

అవుట్పుట్:

x y కంటే తక్కువ వేరియబుల్ x మరియు y యొక్క విలువ: 100 మరియు 200

ఎస్ మంత్రగత్తె

స్విచ్ స్టేట్మెంట్ కోడ్ యొక్క వివిధ భాగాలకు పరిస్థితులను అమలు చేయడానికి సులభమైన మార్గాన్ని అందిస్తుంది.

అత్తి 7: ఫ్లో చార్ట్ ఆఫ్ స్విచ్ షరతులతో కూడిన స్టేట్మెంట్ - స్విఫ్ట్ ట్యుటోరియల్

దిగువ ఉదాహరణను పరిశీలించండి:

var a = 20 స్విచ్ ఇండెక్స్ {కేసు 10: ప్రింట్ ('ఇండెక్స్ విలువ 10') ఫాల్‌త్రూ కేసు 15,20: ప్రింట్ ('ఇండెక్స్ విలువ 15 లేదా 20') ఫాల్‌త్రూ కేసు 30: ప్రింట్ ('ఇండెక్స్ విలువ 30 ') డిఫాల్ట్: ప్రింట్ (' డిఫాల్ట్ కేసు ')}

అవుట్పుట్:

సూచిక విలువ 15 లేదా 20 సూచిక విలువ 30

ఇప్పుడు, మీరు అవుట్పుట్ను గమనిస్తే, మా పరిస్థితి సంతృప్తి చెందిన తర్వాత కూడా, మేము తదుపరి స్టేట్మెంట్ కూడా ముద్రించబడుతున్నాము. మేము స్టేట్‌మెంట్ ఉపయోగిస్తున్నందున దీనికి కారణం పతనం . కాబట్టి, మీరు ఉపయోగించకపోతే a పతనం స్టేట్మెంట్, అప్పుడు ప్రోగ్రామ్ బయటకు వస్తుంది మారండి మ్యాచింగ్ కేసు స్టేట్‌మెంట్‌ను అమలు చేసిన తర్వాత స్టేట్‌మెంట్.

ఇప్పుడు, పునరుక్తి ఉచ్చులకు వెళ్దాం.

స్విఫ్ట్ ట్యుటోరియల్: పునరావృత ఉచ్చులు

సాధారణంగా, ప్రకటనలు వరుసగా అమలు చేయబడతాయి. ఒక ఫంక్షన్‌లో మొదటి స్టేట్‌మెంట్ మొదట అమలు చేయబడుతుంది, తరువాత రెండవది మరియు మొదలైనవి.మీరు కోడ్ యొక్క బ్లాక్‌ను చాలాసార్లు అమలు చేయాల్సిన అవసరం వచ్చినప్పుడు పరిస్థితి ఉండవచ్చు.

లూప్ స్టేట్మెంట్ ఒక స్టేట్మెంట్ లేదా స్టేట్మెంట్ సమూహాన్ని చాలాసార్లు అమలు చేయడానికి అనుమతిస్తుంది. కాబట్టి, పునరుక్తి ఉచ్చులు ప్రధానంగా ఉంటాయి ఫర్-ఇన్ , ఉండగా మరియు డు-అయితే లూప్.

ఫర్-ఇన్ లూప్

ఫోర్-ఇన్ లూప్ సంఖ్యల శ్రేణులు, శ్రేణిలోని అంశాలు లేదా స్ట్రింగ్‌లోని అక్షరాలు వంటి అంశాల సేకరణపై మళ్ళిస్తుంది.

అత్తి 8: ఫర్-ఇన్ లూప్ యొక్క ఫ్లో చార్ట్ - స్విఫ్ట్ ట్యుటోరియల్

దిగువ ఉదాహరణను పరిశీలించండి:

నేను 1 లో ... 3 {ముద్రణ ('హలో వరల్డ్! మరియు i యొక్క విలువ (i)')}

అవుట్పుట్:

హలో ప్రపంచం! మరియు i యొక్క విలువ 1 హలో ప్రపంచం! మరియు i యొక్క విలువ 2 హలో ప్రపంచం! మరియు i యొక్క విలువ 3

లూప్ అయితే

ఇచ్చిన షరతు నిజం అయినంతవరకు స్విఫ్ట్ ప్రోగ్రామింగ్ భాషలో కాసేపు లూప్ స్టేట్మెంట్ టార్గెట్ స్టేట్మెంట్ ను పదేపదే అమలు చేస్తుంది.

అత్తి 9: ఫ్లో చార్ట్ ఆఫ్ లూప్ - స్విఫ్ట్ ట్యుటోరియల్

దిగువ ఉదాహరణను పరిశీలించండి:

var ప్రస్తుత: Int = 0 // వేరియబుల్స్ ప్రారంభించండి var ఫైనల్: Int = 3 లెట్ కంప్లీట్ = ట్రూ అయితే (కరెంట్<= final) // condition { //play game if Completed { print('You have passed the level (current)') current = current + 1 //statement to be executed if the condition is satisfied } } print('The while loop ends') //Statement executed after the loop ends 

అవుట్పుట్:

మీరు స్థాయి 0 ను అధిగమించారు మీరు స్థాయి 1 లో ఉత్తీర్ణులయ్యారు మీరు స్థాయి 2 లో ఉత్తీర్ణులయ్యారు మీరు స్థాయి 3 లో ఉత్తీర్ణులయ్యారు అయితే లూప్ ముగుస్తుంది

లూప్ చేస్తున్నప్పుడు చేయండి / పునరావృతం చేయండి

లూప్‌ల ఎగువన ఉన్న లూప్ కండిషన్‌ను పరీక్షించే లూప్‌ల కోసం మరియు కాకుండా, రిపీట్… లూప్ దాని స్థితిని లూప్ దిగువన తనిఖీ చేస్తుంది.

అత్తి 10: డూ-లూప్ యొక్క ఫ్లో చార్ట్ - స్విఫ్ట్ ట్యుటోరియల్

దిగువ ఉదాహరణను పరిశీలించండి:

var val = 5 పునరావృతం {ముద్రణ ('విలువ (val)') val = val + 1 index అయితే సూచిక<10 

అవుట్పుట్:

విలువ 5 విలువ 6 విలువ 7 విలువ 8 విలువ 9

ఆల్రైట్, గైస్! ఇది ఉచ్చులకు ముగింపు, ఇప్పుడు త్వరగా అర్రేస్ & టుపుల్స్ లోకి వెళ్దాం.

స్విఫ్ట్ ట్యుటోరియల్: శ్రేణులు & టుపుల్స్

శ్రేణులు

శ్రేణి అనేది మూలకాల జాబితాను కలిగి ఉన్న డేటా నిర్మాణం. ఈ మూలకాలు పూర్ణాంకం లేదా స్ట్రింగ్ వంటి ఒకే డేటా రకం.కాబట్టి, మీరు మీ స్నేహితుల పేర్లను నిల్వ చేయాలనుకుంటే అనుకుందాం. మీరు ఈ క్రింది విధంగా ఒక ప్రోగ్రామ్ రాయవచ్చు:

var స్నేహితులు: అర్రే = ['ఆకాష్', 'సంజన', 'అవినాష్', 'స్వతీ']

అనుబంధం () పద్ధతిని ఉపయోగించి మీరు శ్రేణిలోకి కొత్త అంశాలను కూడా జోడించవచ్చు. దిగువ ఉదాహరణను చూడండి:

friends.append ('ఆయుషి') ముద్రణ (స్నేహితులు)

అవుట్పుట్:

ఆకాష్ సంజన అవినాష్ స్వతీ ఆయుషి

టుపుల్స్

ఒకే సమ్మేళనం విలువలో బహుళ విలువలను సమూహపరచడానికి టుపుల్స్ ఉపయోగించబడతాయి. దిగువ ఉదాహరణను పరిశీలించండి:

var వైఫల్యం 404 = (404, “గేట్‌వే కనుగొనబడలేదు”) ముద్రణ (“కోడ్ (వైఫల్యం 404.0)”) ముద్రణ (“లోపం యొక్క నిర్వచనం (వైఫల్యం 404.1)”) var వైఫల్యం 404 = (వైఫల్యం కోడ్: 404, వివరణ: “గేట్‌వే కనుగొనబడలేదు”) ముద్రణ (వైఫల్యం 404.ఫాలియర్‌కోడ్) // ప్రింట్లు 404.

అవుట్పుట్

కోడ్ 404 లోపం యొక్క నిర్వచనం గేట్వే కనుగొనబడలేదు 404

సరే, ఇప్పుడు మీరు అరేస్‌ని అర్థం చేసుకున్నారు, సెట్‌లు మరియు నిఘంటువులతో ప్రారంభించడానికి సమయం ఆసన్నమైంది.

స్విఫ్ట్ ట్యుటోరియల్: సెట్స్ & డిక్షనరీలు

సెట్ చేస్తుంది

శ్రేణుల వలె ఖచ్చితమైన క్రమం లేకుండా, ఒకే రకమైన విభిన్న విలువలను నిల్వ చేయడానికి సెట్‌లు ఉపయోగించబడతాయి. కాబట్టి, మీరు నకిలీ విలువలు లేవని నిర్ధారించుకోవాలనుకుంటే లేదా మూలకాల క్రమం సమస్య కాకపోతే మీరు శ్రేణులకు బదులుగా సెట్లను ఉపయోగించవచ్చు .
కామాతో వేరు చేయబడిన వంకర కలుపులలో అన్ని అంశాలను (మూలకాలను) ఉంచడం ద్వారా ఒక సెట్ సృష్టించబడుతుంది. దిగువ ఉదాహరణను పరిశీలించండి:

evenNumber: సెట్ = [2,4,6,8,12]

ఇప్పుడు, యూనియన్, ఖండన, వ్యవకలనం వంటి సెట్ ఆపరేషన్లను కూడా మీరు చేయగలరని నేను మీకు చెప్తాను.

యూనియన్: A మరియు B యొక్క యూనియన్ రెండు సెట్ల నుండి అన్ని మూలకాల సమితి. ఉపయోగించి యూనియన్ నిర్వహిస్తారు .యూనియన్ () పద్ధతి.

నేను ntersection: A మరియు B యొక్క ఖండన రెండు సెట్లలో సాధారణమైన మూలకాల సమితి. ఉపయోగించి ఒక ఖండన నిర్వహిస్తారు .ఇంటర్సెక్షన్ () పద్ధతి.

తీసివేయడం: A మరియు B యొక్క వ్యత్యాసం (A - B) అనేది A లో మాత్రమే కాని B లో లేని మూలకాల సమితి. అదేవిధంగా, B - A అనేది మూలకాల సమితి, అనగా B లో కానీ A లో కాదు.దిగువ కోడ్‌ను చూడండి:

evenNumber: సెట్ = [10,12,14,16,18,20] బేసి నంబర్: సెట్ = [5,7,9,11,13,15] లెట్ ప్రైమ్ నంబర్: సెట్ = [2,3,5,7, 13,17,19] odNumber.union (evenNumber) .సార్టెడ్ () odNumber.intersection (evenNumber) .సార్టెడ్ () odNumber.subtracting (primeNumber) .సార్టెడ్ ()

అవుట్పుట్:

[5,7,9,10,11,12,13,14,15,16,18,20] [] [9, 11, 15]

నిఘంటువులు

ఒకే రకమైన విలువల క్రమం లేని జాబితాలను నిల్వ చేయడానికి నిఘంటువులు ఉపయోగించబడతాయి మరియు డిక్షనరీలో తప్పు రకాన్ని నమోదు చేయడానికి స్విఫ్ట్ మిమ్మల్ని అనుమతించదు.దిగువ ఉదాహరణను పరిశీలించండి.

var exampleDict: [Int: string] = [1: 'One', 2: 'Two', 3: 'Three'] // నిఘంటువులను సృష్టించడం var accessval = exampleDict [1] // నిఘంటువు విలువలను యాక్సెస్ చేయడం ముద్రణ ('కీ విలువ = 1 అనేది (యాక్సెస్‌వాల్ ') ముద్రణ (' కీ విలువ = 2 (ఉదాహరణడిక్ట్ [2]) ') ముద్రణ (' కీ విలువ = 3 (ఉదాహరణడిక్ట్ [3]) ')

అవుట్పుట్:

కీ = 1 యొక్క విలువ ఐచ్ఛికం ('ఒకటి') కీ = 2 యొక్క విలువ ఐచ్ఛికం ('రెండు') కీ = 3 యొక్క విలువ ఐచ్ఛికం ('మూడు')

స్విఫ్ట్ ట్యుటోరియల్: విధులు

ఒక ఫంక్షన్ ప్రాథమికంగా ఒక నిర్దిష్ట పనిని నిర్వహించడానికి కలిసి నిర్వహించిన ప్రకటనల సమితి. మీరు ఒక ఫంక్షన్‌కు కాల్ చేయవచ్చు, పారామితులతో / లేకుండా ఫంక్షన్ చేయవచ్చు, రిటర్న్ విలువలతో / లేకుండా ఫంక్షన్ చేయవచ్చు, ఫంక్షన్ రకాలను కలిగి ఉండవచ్చు మరియు సమూహ ఫంక్షన్లను కూడా ఉపయోగించవచ్చు.ఫంక్షన్లను ఎలా నిర్వచించాలో మరియు కాల్ చేయాలో అర్థం చేసుకోవడానికి క్రింది ఉదాహరణను చూడండి. దిగువ ఉదాహరణను పరిశీలించండి:

func ఉద్యోగి (empname: స్ట్రింగ్) -> స్ట్రింగ్ {// ఫంక్షన్ రిటర్న్ empname} print (ఉద్యోగి (empname: 'Sayantini')) // ఫంక్షన్ ప్రింట్‌కు కాల్ చేయడం (ఉద్యోగి (empname: 'Kislay'))

అవుట్పుట్:

సయంతిని కిస్లే

ఇప్పుడు, బ్లాగ్ యొక్క తరువాతి విభాగానికి వెళ్దాం, అంటే మూసివేతలు & నిర్మాణాలు.

స్విఫ్ట్ ట్యుటోరియల్: మూసివేతలు & నిర్మాణాలు

మూసివేతలు

మూసివేతలు సాధారణంగా ప్రతి ఒక్కరినీ గందరగోళానికి గురిచేస్తాయి, కానీ అవి బ్లాక్‌లుగా నిర్వహించబడే ఫంక్షన్ వంటి స్వీయ-నియంత్రణ సంకేతాలు. అవి అనామకంగా ఉండవచ్చు, అయితే ఫంక్షన్‌కు ఫంక్షన్ పేరు ఉండాలి. దిగువ ఉదాహరణను పరిశీలించండి.

పేరు = {ముద్రించనివ్వండి ('స్విఫ్ట్ మూసివేతలకు స్వాగతం')} పేరు ()

అవుట్పుట్:

మూసివేతలకు స్వాగతం

నిర్మాణాలు

struct ఉద్యోగి వివరాలు {// ఒక నిర్మాణాన్ని నిర్వచించడం var name = 'బాబ్' var id = 11021 varphonenumber = 9876543210 details వివరాలు = ఉద్యోగి వివరాలు () // నిర్మాణం మరియు లక్షణాల ముద్రణను యాక్సెస్ చేయడం ('ఉద్యోగి పేరు (వివరాలు.పేరు)') ముద్రణ ('ఉద్యోగి యొక్క ఐడి (details.id)') ముద్రణ ('ఉద్యోగి యొక్క ఫోన్ సంఖ్య (details.phonenumber)')

అవుట్పుట్:

ఉద్యోగి పేరు బాబ్ ఉద్యోగి ఐడి 11021 ఉద్యోగి ఫోన్ నంబర్ 9876543210

ఇప్పుడు, మీరు అబ్బాయిలు నిర్మాణాలను అర్థం చేసుకున్నారు, తరగతులు & వారసత్వాన్ని అర్థం చేసుకుందాం.

స్విఫ్ట్ ట్యుటోరియల్: తరగతులు & వారసత్వం

తరగతులు

స్విఫ్ట్‌లోని తరగతులు ప్రాథమికంగా సౌకర్యవంతమైన నిర్మాణాల బిల్డింగ్ బ్లాక్స్. కాబట్టి, స్థిరాంకాలు, వేరియబుల్స్ మరియు ఫంక్షన్ల మాదిరిగానే వినియోగదారు తరగతి లక్షణాలు మరియు పద్ధతులను నిర్వచించవచ్చు.

తరగతి వివరాలు నిర్మాణం {// తరగతి వర్ ఐడిని నిర్వచించడం: Int init (id: Int) {self.id = id}} class studentDetails {var id = 125612 student studentid = studentDetails () print ('Student id is (studentid.id ) ')

అవుట్పుట్:

స్టూడెంట్ ఐడి 125612

వారసత్వం

ఇప్పటికే ఉన్న తరగతుల నుండి కొత్త తరగతులను సృష్టించే ప్రక్రియ వారసత్వం. ఉత్పన్నమైన తరగతి వారసత్వంగా బేస్ క్లాస్ యొక్క అన్ని సామర్థ్యాలు మరియు దాని స్వంత కార్యాచరణలను కూడా జోడించగలవు.

తరగతులను మరింత వర్గీకరించవచ్చు ఉపవర్గం మరియు సూపర్ క్లాస్ .

ఉపవర్గం: ఒక తరగతి మరొక తరగతి నుండి లక్షణాలు, పద్ధతులు మరియు విధులను వారసత్వంగా తీసుకుంటే, దానిని ఉపవర్గం అంటారు.

సూపర్ క్లాస్ : ఇతర తరగతులు దాని నుండి వారసత్వంగా పొందటానికి లక్షణాలు, పద్ధతులు మరియు విధులను కలిగి ఉన్న తరగతిని సూపర్ క్లాస్ అంటారు. దిగువ ఉదాహరణను పరిశీలించండి.

తరగతి ఎంప్లాయీ వివరాలు {var id: Int var number: Int init (details1: Int, details2: Int) {id = details1 number = details2} func print () {print ('ఉద్యోగి ఐడి: (id), ఉద్యోగి ఫోన్ నంబర్: (సంఖ్య) ')}} తరగతి ప్రదర్శన: ఎంప్లాయీ వివరాలు {init () {super.init (వివరాలు 1: 94567, వివరాలు 2: 9876543210) // సూపర్ క్లాస్ నుండి పారామితులను & పద్ధతులను పిలవడానికి సూపర్ కీవర్డ్ ఉపయోగించబడుతుంది employee employee ఉద్యోగి సమాచారం = ప్రదర్శన ( ) ఉద్యోగి సమాచారం.ప్రింట్ ()

అవుట్పుట్:

ఉద్యోగి ఐడి94567, ఉద్యోగి ఫోన్ నంబర్9876543210

ఇప్పుడు, మీరు అబ్బాయిలు స్విఫ్ట్ లోని ప్రధాన అంశాల గురించి ఒక ఆలోచన కలిగి ఉన్నారు. ప్రోటోకాల్స్, ఎక్స్‌టెన్షన్స్, జెనెరిక్స్ మరియు ఎన్యూమరేషన్స్ వంటి విస్తరించిన విషయాలను నేర్చుకోవడం ఇప్పుడు ప్రారంభిద్దాం.

స్విఫ్ట్ ట్యుటోరియల్: ప్రోటోకాల్స్

ప్రోటోకాల్ ఫ్లై {var ఫ్లైస్: బూల్ {సెట్ సెట్} ఫంక్ ఫ్లైయబుల్ (మైళ్ళు కవర్: డబుల్) -> స్ట్రింగ్} క్లాస్ వెహికల్: ఫ్లై {var ఫ్లైస్: బూల్ = తప్పుడు వర్ పేరు: స్ట్రింగ్ = 'డిఫాల్ట్ పేరు' ఫంక్ ఫ్లైయబుల్ (మైళ్ళు కవర్: డబుల్) - > స్ట్రింగ్ {if (self.flies) {return '(self.name) ఫ్లైస్ (మైళ్ళు కవర్డ్) మైళ్ళు'} else {return '(self.name)'}}} var BMWX1 = వాహనం () BMWX1.name = ' BMW X1 'BMWX1.flies = తప్పుడు ముద్రణ (BMWX1.flyable (34%)

BMW X1 ఎగురుతుంది

స్విఫ్ట్ ట్యుటోరియల్: పొడిగింపులు

ఇప్పటికే ఉన్న తరగతి, నిర్మాణం లేదా గణన రకం యొక్క కార్యాచరణలను జోడించడానికి పొడిగింపులు ప్రాథమికంగా ఉపయోగించబడతాయి. పొడిగింపులతో, మీరు కంప్యూటెడ్ లక్షణాలు మరియు కంప్యూటెడ్ టైప్ లక్షణాలను జోడించవచ్చు, కొత్త సమూహ రకాలను నిర్వచించవచ్చు మరియు ఉపయోగించవచ్చు, ఉదాహరణ మరియు రకం పద్ధతులను నిర్వచించవచ్చు, కొత్త ఇనిషియేజర్‌లను అందించవచ్చు, సబ్‌స్క్రిప్ట్‌లను నిర్వచించవచ్చు మరియు ఇప్పటికే ఉన్న రకాన్ని ప్రోటోకాల్‌కు అనుగుణంగా చేయవచ్చు.

దిగువ ఉదాహరణను పరిశీలించండి:

పొడిగింపు Int {var జోడించు: Int {returnelf + 10} varsubtract: Int {returnelf- 34} var గుణకారం: Int {returnelf * 5} var విభజన: Int {returnelf / 5}} అదనంగా చేర్చు = 3.ad ప్రింట్ ('విలువ జోడించిన తరువాత (జోడించు) ') వ్యవకలనం = 120.సబ్‌ట్రాక్ట్ ముద్రణ (' వ్యవకలనం చేసిన తర్వాత విలువ (వ్యవకలనం) ') గుణకారం = 25 ను అనుమతించండి. బహుళ ముద్రణ (' విలువ మ్యుటిప్లింగ్ (గుణకారం) ') విభజన = 55 .విభజన ముద్రణ ('విభజన తరువాత విలువ (విభజన)') కలపనివ్వండి = 10.add + 34.సబ్‌ట్రాక్ట్ ముద్రణ ('లెక్కించిన విలువ (మిక్స్)')

అవుట్పుట్:

జోడించిన తరువాత విలువ 13 తీసివేసిన తరువాత విలువ 86 విలువ 125 విభజన తరువాత విలువ 11 విలువ లెక్కించినది 20

స్విఫ్ట్ ట్యుటోరియల్: జెనెరిక్స్

సరళమైన మరియు పునర్వినియోగ విధులు మరియు రకాలను వ్రాయడానికి సాధారణ రకాలను ఉపయోగిస్తారు. కాబట్టి, ప్రాథమికంగా నకిలీని నివారించడానికి జెనెరిక్‌లను ఉపయోగించవచ్చు. దిగువ ఉదాహరణను పరిశీలించండి:

జావాలో సింగిల్టన్ తరగతిని సృష్టించండి

func swap (x: inout T, y: inout T) temp temp = xx = yy = temp} var str1 = 'హలో' var str2 = 'ఎడురేకా' ప్రింట్ ('ఇచ్చిపుచ్చుకునే ముందు స్ట్రింగ్ విలువలు: (str1) మరియు (str2) ) ') స్వాప్ (x: & str1, y: & str2) ప్రింట్ (' స్ట్రింగ్ చేసిన తర్వాత స్ట్రింగ్ విలువలు: (str1) మరియు (str2) ') var num1 = 1996 var num2 = 1865 ముద్రణ (' Int విలువలను మార్చుకునే ముందు: (num1 ) మరియు (num2) ') స్వాప్ (x: & num1, y: & num2) print (' Int విలువలను మార్చుకున్న తర్వాత: (num1) మరియు (num2) ')

అవుట్పుట్:

ఇచ్చిపుచ్చుకునే ముందు స్ట్రింగ్ విలువలు: హలో మరియు ఎడురేకా ఇచ్చిపుచ్చుకున్న స్ట్రింగ్ విలువలు: ఎడురేకా మరియు హలో మార్చే ముందు స్ట్రింగ్ విలువలు: 1996 మరియు 1865 మార్పిడి తర్వాత స్ట్రింగ్ విలువలు: 1865 మరియు 1996

స్విఫ్ట్ ట్యుటోరియల్: గణనలు

సరళమైన పరంగా ఒక గణన అనేది వినియోగదారు నిర్వచించిన డేటా రకం, ఇది సంబంధిత విలువల సమితిని కలిగి ఉంటుంది. కీవర్డ్ enum లెక్కించిన డేటా రకాన్ని నిర్వచించడానికి ఉపయోగిస్తారు. దిగువ ఉదాహరణను పరిశీలించండి:

enum రంగు: Int {case blue case green case red case yellow init () {self = .red} func getDetails () -> స్ట్రింగ్ {స్విచ్ (సెల్ఫ్) {కేసు .బ్లూ: రిటర్న్ 'కలర్ ఈజ్ బ్లూ' కేసు .గ్రీన్: రిటర్న్ 'రంగు ఆకుపచ్చ' కేసు .రెడ్: తిరిగి 'రంగు ఎరుపు' కేసు .అన్ని: తిరిగి 'రంగు పసుపు' డిఫాల్ట్: తిరిగి 'రంగు కనుగొనబడలేదు'}}} var ఎంపిక రంగు = రంగు ముద్రణ (selectColor.rawValue) var favColor = రంగు .గ్రీన్ ప్రింట్ (favColor.rawValue) if (favColor == Color.green) {print ('ఇష్టమైన రంగు ఆకుపచ్చ')} ముద్రణ (favColor.getDetails ())

అవుట్పుట్:

2 ఒకటి ఇష్టమైన రంగు ఆకుపచ్చగా ఉంటుంది ఆకుపచ్చ

ఈ స్విఫ్ట్ ట్యుటోరియల్ చదవడం మీరు ఆనందించారని నేను నమ్ముతున్నాను. మేము స్విఫ్ట్ యొక్క అన్ని ప్రాథమికాలను కవర్ చేసాము, కాబట్టి మీరు ఇప్పుడు ప్రాక్టీస్ చేయడం ప్రారంభించవచ్చు.

స్విఫ్ట్ గురించి దాని వివిధ అనువర్తనాలతో పాటు లోతైన జ్ఞానం పొందడానికి, మీరు చేయవచ్చు 24/7 మద్దతు మరియు జీవితకాల ప్రాప్యతతో ప్రత్యక్ష ఆన్‌లైన్ శిక్షణ కోసం.

మాకు ప్రశ్న ఉందా? యొక్క వ్యాఖ్యల విభాగంలో వాటిని పేర్కొనండి “ స్విఫ్ట్ ట్యుటోరియల్ ”మరియు మేము మీ వద్దకు తిరిగి వస్తాము.