స్విఫ్ట్ నిఘంటువు

Svipht Nighantuvu

స్విఫ్ట్ డిక్షనరీ అనేది కీ-వాల్యూ జతల రూపంలో మూలకాలను నిల్వ చేసే సేకరణ.

స్విఫ్ట్‌లో, నిఘంటువును సృష్టించేటప్పుడు కీ మరియు విలువ జత యొక్క డేటాటైప్‌ను పేర్కొనాలి.

కీ-విలువ జతల రెండు డేటా రకాలు ఒకేలా లేదా భిన్నంగా ఉండవచ్చు.



ఖాళీ నిఘంటువును సృష్టిస్తోంది

నిఘంటువును రూపొందించడానికి రెండు మార్గాలు ఉన్నాయి. వాటిని ఒక్కొక్కటిగా చూద్దాం.



స్క్వేర్ బ్రాకెట్ లోపల కీ-విలువలను పేర్కొనడం మొదటి మార్గం: [] .



సింటాక్స్:

swift_dictionary : [ కీ_డేటాటైప్ : విలువ_డేటాటైప్ ] = [ : ]

ఉపయోగించి నిఘంటువును సృష్టించడం రెండవ మార్గం నిఘంటువు<> దానిలోని డేటా రకాలను పేర్కొనడం ద్వారా.

సింటాక్స్:



swift_dictionary : నిఘంటువు < కీ_డేటాటైప్ , విలువ_డేటాటైప్ >= [ : ]

ఇక్కడ, swift_dictionary అనేది నిఘంటువు పేరు మరియు key_datatype అనేది కీ డేటా రకాన్ని సూచిస్తుంది మరియు value_datatype విలువ డేటా రకాన్ని సూచిస్తుంది.

ఉదాహరణ

ఇక్కడ, మేము వివిధ డేటా రకాలతో ఖాళీ నిఘంటువుని సృష్టిస్తాము మరియు వాటిని రెండు విధాలుగా ప్రదర్శిస్తాము.

//పూర్ణాంక రకాలతో ఖాళీ నిఘంటువును ప్రకటించండి

swift_dictionary1ని అనుమతించండి : [ Int : Int ] = [ : ]

ముద్రణ ( 'పూర్ణాంక రకాలుగా కీ మరియు విలువ రెండింటితో ఖాళీ నిఘంటువు- \(swift_dictionary1)' )

//పూర్ణాంక రకాలతో ఖాళీ నిఘంటువును ప్రకటించండి

swift_dictionary2ని అనుమతించండి : నిఘంటువు < Int , Int > = [ : ]

ముద్రణ ( 'పూర్ణాంక రకాలుగా కీ మరియు విలువ రెండింటితో ఖాళీ నిఘంటువు- \(swift_dictionary2)' )

//కీని పూర్ణాంకం రకంగా మరియు విలువ స్ట్రింగ్ రకంగా ఉన్న ఖాళీ నిఘంటువుని ప్రకటించండి

swift_dictionary3ని అనుమతించండి : నిఘంటువు < Int , స్ట్రింగ్ > = [ : ]

ముద్రణ ( 'కీని పూర్ణాంకం రకంగా మరియు విలువ స్ట్రింగ్ రకంగా ఖాళీ నిఘంటువు- \(swift_dictionary3)' )

//కీని పూర్ణాంకం రకంగా మరియు విలువ స్ట్రింగ్ రకంగా ఉన్న ఖాళీ నిఘంటువుని ప్రకటించండి

swift_dictionary4ని అనుమతించండి : [ Int : స్ట్రింగ్ ] = [ : ]

ముద్రణ ( 'కీని పూర్ణాంకం రకంగా మరియు విలువ స్ట్రింగ్ రకంగా ఖాళీ నిఘంటువు- \(swift_dictionary4)' )

అవుట్‌పుట్:

లైన్లు 2-9:

మేము కీ మరియు విలువ రకం రెండూ పూర్ణాంకం అని రెండు విధాలుగా ఖాళీ నిఘంటువుని ప్రకటించి, వాటిని ప్రదర్శించాము.

లైన్లు 12-19:

మేము ఖాళీ నిఘంటువును రెండు విధాలుగా ప్రకటించాము: కీ పూర్ణాంకం రకం మరియు విలువ స్ట్రింగ్ రకం. చివరగా, మేము వాటిని ప్రదర్శించాము.

నిఘంటువు సృష్టిస్తోంది

ఇప్పటివరకు, మేము ఖాళీ నిఘంటువుని ఎలా సృష్టించాలో చర్చించాము. విలువలతో నిఘంటువును ఎలా రూపొందించాలో చూద్దాం.

మేము కీ-విలువ డేటా రకాలను పేర్కొనకుండానే నిఘంటువును కూడా ప్రకటించవచ్చు. దీన్ని బాగా అర్థం చేసుకోవడానికి కొన్ని ఉదాహరణలను చూద్దాం.

ఉదాహరణ 1

మేము పూర్ణాంక రకాలుగా కీ మరియు విలువలు రెండింటితో ఒక నిఘంటువుని సృష్టిస్తాము మరియు దానికి ఐదు విలువలను జోడిస్తాము.

//కొన్ని విలువలతో స్విఫ్ట్ నిఘంటువును రూపొందించండి

swift_dictionary1ని అనుమతించండి : [ Int : Int ] = [ 1 : 100 , రెండు : 400 , 3 : 600 , 4 : 800 , 5 : 1000 ]

ముద్రణ ( 'స్విఫ్ట్ నిఘంటువు- \(swift_dictionary1)' )

అవుట్‌పుట్:

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

ఉదాహరణ 2

మేము కీని పూర్ణాంకం రకంగా మరియు విలువలను స్ట్రింగ్ రకంగా ఉంచి ఒక నిఘంటువుని సృష్టిస్తాము.

//డేటా రకాన్ని పేర్కొనడం ద్వారా కొన్ని విలువలతో స్విఫ్ట్ నిఘంటువుని సృష్టించండి

swift_dictionary1ని అనుమతించండి : [ Int : స్ట్రింగ్ ] = [ 1 : 'స్విఫ్ట్ 1' , రెండు : 'స్విఫ్ట్ 2' , 3 : 'స్విఫ్ట్ 3' , 4 : 'స్విఫ్ట్ 4' , 5 : 'స్విఫ్ట్ 5' ]

ముద్రణ ( 'స్విఫ్ట్ నిఘంటువు- \(swift_dictionary1)' )

//డేటా రకాన్ని పేర్కొనకుండా కొన్ని విలువలతో స్విఫ్ట్ నిఘంటువుని సృష్టించండి.

swift_dictionary2ని అనుమతించండి = [ 1 : 'స్విఫ్ట్ 1' , రెండు : 'స్విఫ్ట్ 2' , 3 : 'స్విఫ్ట్ 3' , 4 : 'స్విఫ్ట్ 4' , 5 : 'స్విఫ్ట్ 5' ]

ముద్రణ ( 'స్విఫ్ట్ నిఘంటువు- \(swift_dictionary2)' )

అవుట్‌పుట్:

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

ఇక్కడ, మేము రెండవ నిఘంటువులో కీ-విలువ రకాలను పేర్కొనలేదు.

రెండు స్విఫ్ట్ శ్రేణుల నుండి నిఘంటువుని సృష్టించడం సాధ్యమవుతుంది.

సింటాక్స్:

నిఘంటువు(విలువలతో విశిష్టమైన కీలు:zip(swift_array1,swift_array2))

ఎక్కడ,

  1. swift_array1 అనేది కీలతో కూడిన మొదటి శ్రేణి
  2. swift_array2 అనేది విలువలతో కూడిన రెండవ శ్రేణి

ఉదాహరణ 3

ఇక్కడ, మేము ఐదు విలువలతో రెండు స్విఫ్ట్ శ్రేణులను మరియు వాటి నుండి స్విఫ్ట్ డిక్షనరీని సృష్టిస్తాము.

//కొన్ని కీలతో స్విఫ్ట్ అర్రేని సృష్టించండి

swift_array1ని అనుమతించండి = [ 1 , రెండు , 3 , 4 , 5 ]

//కొన్ని విలువలతో స్విఫ్ట్ అర్రేని సృష్టించండి

swift_array2ని అనుమతించండి = [ 'స్విఫ్ట్ 1' , 'స్విఫ్ట్ 2' , 'స్విఫ్ట్ 3' , 'స్విఫ్ట్ 4' , 'స్విఫ్ట్ 5' ]

//ఎగువ రెండు స్విఫ్ట్ శ్రేణుల నుండి swift_dictionaryని సృష్టించండి

swift_dictionaryని అనుమతించండి = నిఘంటువు ( ఏకైక కీలువిత్ విలువలు : జిప్ ( swift_array1 , swift_array2 ) )

ముద్రణ ( swift_dictionary )

అవుట్‌పుట్:

వివరణ

మేము రెండు స్విఫ్ట్ శ్రేణులను సృష్టించాము అంటే మొదటి శ్రేణి పూర్ణాంక రకాన్ని కలిగి ఉంటుంది మరియు రెండవ శ్రేణి స్ట్రింగ్ రకాన్ని కలిగి ఉంటుంది.

ఆ తరువాత, మేము రెండు శ్రేణుల నుండి నిఘంటువుని సృష్టించాము.

ముగింపు

ఈ స్విఫ్ట్ ట్యుటోరియల్‌లో, మేము స్విఫ్ట్ డిక్షనరీ గురించి చర్చించాము మరియు మూడు విధాలుగా నిఘంటువుని సృష్టించడం సాధ్యమవుతుంది. మొదటి మార్గం లోపల కీ-విలువ రకాలను పేర్కొనడం [] , రెండవ మార్గం ఉపయోగించడం నిఘంటువు<>, మరియు మూడవ మార్గం రెండు స్విఫ్ట్ శ్రేణులను ఉపయోగించడం. కీ-విలువ జతల రెండు డేటా రకాలు ఒకేలా లేదా భిన్నంగా ఉండవచ్చు. ఖాళీ నిఘంటువుని ఎలా సృష్టించాలో చూశాము. మీ మెషీన్‌లో మునుపటి ఉదాహరణలను అమలు చేయడం ద్వారా అనేక మార్గాల్లో నిఘంటువుని ఎలా సృష్టించాలో ఈ గైడ్ మీకు నేర్పుతుంది.