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