సేల్స్‌ఫోర్స్ అపెక్స్ మ్యాప్ అనేది డేటా స్ట్రక్చర్, ఇది ప్రధానంగా ట్రిగ్గర్ దృశ్యాలలో ఉపయోగించబడుతుంది మరియు జాబితా వలె సేల్స్‌ఫోర్స్ డేటాబేస్‌లోకి ఒకేసారి ఎక్కువ డేటాను లోడ్ చేయడంలో సహాయపడుతుంది. కానీ ఇది డేటాను {key:value} జత ఆకృతిలో నిల్వ చేస్తుంది మరియు నిర్వహిస్తుంది. మేము అపెక్స్ ప్రోగ్రామింగ్ భాషలో మ్యాప్ సేకరణ మరియు దాని పద్ధతుల గురించి చర్చిస్తాము. ఇక్కడ, మేము అన్ని ఉదాహరణల కోసం సేల్స్‌ఫోర్స్‌లో ఖాతా ప్రామాణిక వస్తువును ఉపయోగిస్తాము. త్వరగా ఈ ట్యుటోరియల్‌లోకి ప్రవేశిద్దాం.
మ్యాప్
మ్యాప్ {key:value} జత డేటాను ఇన్‌పుట్‌గా తీసుకుంటుంది మరియు దానిని సేల్స్‌ఫోర్స్ స్టాండర్డ్ లేదా కస్టమ్ ఆబ్జెక్ట్‌లలో నిల్వ చేస్తుంది. ఇది sObjectని కీ లేదా విలువగా తీసుకోవచ్చు.
మ్యాప్ సృష్టి
ఆబ్జెక్ట్ పేరుతో పాటు కీ మరియు విలువ యొక్క డేటా రకాలను పేర్కొనడం ద్వారా, మ్యాప్‌ను సృష్టించవచ్చు. ఇక్కడ, దాన్ని సృష్టించడానికి కొత్త కీవర్డ్ ఉపయోగించబడుతుంది. సృష్టి సమయంలో మూలకాలను పాస్ చేయడం ఐచ్ఛికం కావచ్చు.
ఖాళీ మ్యాప్ సింటాక్స్:
మ్యాప్సాధారణ వాక్యనిర్మాణం:
Mapకీ => విలువ,....};
sఆబ్జెక్ట్ సింటాక్స్:
Mapకీ => విలువ,....};
ఇక్కడ, sObject ఒక ప్రామాణిక లేదా అనుకూల వస్తువు కావచ్చు. ఈ మొత్తం కథనంలో, మేము 'ఖాతా' sObjectతో మ్యాప్‌తో మాత్రమే వ్యవహరిస్తాము.
అపెక్స్ “మ్యాప్” సేకరణ ద్వారా మద్దతిచ్చే పద్ధతులను ఒక్కొక్కటిగా చూద్దాం.
పర్యావరణ సెటప్
1. సేల్స్‌ఫోర్స్‌కి త్వరగా లాగిన్ చేయండి మరియు గేర్ చిహ్నాన్ని క్లిక్ చేయడం ద్వారా 'డెవలపర్ కన్సోల్' తెరవండి.
2. ఆపై, 'డీబగ్' మరియు 'ఓపెన్ ఎగ్జిక్యూట్ అనామక విండో'పై క్లిక్ చేయడం ద్వారా 'అనామక విండో' తెరవండి.
సాధారణ ఉదాహరణ:
ముందుగా, మేము రెండు సబ్జెక్ట్‌లతో మ్యాప్‌ను సృష్టించడం ద్వారా సాధారణ మ్యాప్ సృష్టిని చూస్తాము: “subject_id” ఇది కీగా మరియు “విలువ” విషయం పేరుగా పనిచేస్తుంది.
Mapsystem.debug(ప్రోగ్రామింగ్);
అవుట్‌పుట్:
- 'ఎగ్జిక్యూట్' పై క్లిక్ చేయండి.
- 'డీబగ్ మాత్రమే' ఎంపికను తనిఖీ చేయండి. మీరు 'ఎగ్జిక్యూషన్ లాగ్'లో అవుట్‌పుట్‌ని చూడవచ్చు.
మ్యాప్ పద్ధతులు
మొదట, మేము 'ఖాతా' ఆబ్జెక్ట్ నుండి మ్యాప్‌ను సృష్టిస్తాము. మేము ఒక్కొక్కటిగా పేర్లతో మూడు ఖాతాలను సృష్టిస్తాము. అప్పుడు, మేము కీ మరియు విలువతో మ్యాప్‌ను ప్రకటిస్తాము
ఖాతా ఖాతా1 = కొత్త ఖాతా(పేరు='లైనక్స్ సూచన');
ఖాతా ఖాతా2 = కొత్త ఖాతా(పేరు='సేల్స్‌ఫోర్స్');
ఖాతా ఖాతా3 = కొత్త ఖాతా(పేరు='పైథాన్');
// పైన పేర్కొన్న ఖాతాలను map_objకి కీలుగా జోడించండి
Map
account1 => 1000,account2 => 2000,account3 => 3000};
System.debug(map_obj);
అవుట్‌పుట్:
“map_obj” మూడు ఖాతాలను నిల్వ చేస్తుందని మీరు చూడవచ్చు.
1. Map.values()
ఇచ్చిన మ్యాప్ నుండి విలువలను మాత్రమే అందించడానికి, మేము విలువలు() పద్ధతిని ఉపయోగించవచ్చు. ఇది ఏ పారామితులను తీసుకోదు. ఇది కేవలం కామాతో వేరు చేయబడిన విలువల జాబితాను అందిస్తుంది.
సింటాక్స్:
map_object.values()ఉదాహరణ:
మునుపటి మ్యాప్ నుండి అన్ని విలువలను రిటర్న్ చేద్దాం. మీరు మునుపటి ఉదాహరణ కోడ్‌ని అమలు చేయాలని నిర్ధారించుకోండి (మూడు ఖాతాలతో మ్యాప్‌ను సృష్టించండి). లేకపోతే, మీరు లోపం పొందుతారు. కోడ్ కన్సోల్‌లో కూడా ఉండాలి.
// విలువలు()ని ఉపయోగించి అన్ని కీల కోసం విలువలను తిరిగి ఇవ్వండిSystem.debug(map_obj.values());
అవుట్‌పుట్:
map_objలో మూడు కీ:విలువ జతలు మాత్రమే ఉన్నాయి. విలువలు: 1000, 2000 మరియు 3000.
2. Map.keySet()
మ్యాప్ ఆబ్జెక్ట్‌లో ఉన్న కీలను తిరిగి ఇవ్వండి. విలువలు (), ఈ పద్ధతికి ఏ పరామితిని పాస్ చేయవలసిన అవసరం లేదు.
సింటాక్స్:
map_object.keySet()ఉదాహరణ:
మునుపటి మ్యాప్ నుండి అన్ని కీలను వాపసు చేద్దాం. మీరు మునుపటి ఉదాహరణ కోడ్‌ని అమలు చేశారని నిర్ధారించుకోండి (మూడు ఖాతాలతో మ్యాప్‌ను సృష్టించండి). లేకపోతే, మీరు లోపం పొందుతారు. కోడ్ కన్సోల్‌లో కూడా ఉండాలి.
// కీసెట్()ని ఉపయోగించి అన్ని కీలను తిరిగి ఇవ్వండిSystem.debug(map_obj.keySet());
అవుట్‌పుట్:
map_objలో మూడు కీ:విలువ జతలు మాత్రమే ఉన్నాయి. కీలు: {ఖాతా:{Name=Linux సూచన}, ఖాతా:{Name=Python} మరియు ఖాతా:{Name=Salesforce}.
3. Map.size()
కొన్ని సందర్భాల్లో, అపెక్స్ మ్యాప్‌లో ఉన్న మొత్తం అంశాల (కీ:విలువ) జతలను మనం తెలుసుకోవాలి. Size() అనేది map_objectలో ఉన్న మొత్తం (కీ:విలువ) జతలను అందించే పద్ధతి. ఈ పద్ధతికి పారామితులు అవసరం లేదు.
సింటాక్స్:
map_object.size()ఉదాహరణ:
మునుపటి మ్యాప్ ఆబ్జెక్ట్ పరిమాణాన్ని తిరిగి ఇవ్వండి.
// పరిమాణం()ని ఉపయోగించి మొత్తం జతల సంఖ్యను తిరిగి ఇవ్వండిSystem.debug(map_obj.size());
అవుట్‌పుట్:
3 జతల మాత్రమే ఉన్నందున, తిరిగి వచ్చిన పరిమాణం() 3.
4. Map.get()
కీని ఉపయోగించి మ్యాప్ నుండి విలువలను యాక్సెస్ చేయడం get() పద్ధతిని ఉపయోగించి చేయబడుతుంది. దీన్ని చేయడానికి, మేము కీని get() పద్ధతికి పారామీటర్‌గా పాస్ చేయాలి. తెలియని కీ పాస్ అయినట్లయితే, అది ఎర్రర్‌ను అందిస్తుంది.
సింటాక్స్:
map_object.get(కీ)ఉదాహరణ:
కీ-2 మరియు కీ-1 విలువలను విడివిడిగా అందించండి.
// రెండవ కీ విలువను పొందండిSystem.debug(map_obj.get(account2));
// మొదటి కీ విలువను పొందండి
System.debug(map_obj.get(account1));
అవుట్‌పుట్:
ఇక్కడ, 2000 అనేది “సేల్స్‌ఫోర్స్” కీ విలువ మరియు 1000 అనేది “Linux హింట్” కీ విలువ.
5. Map.clear()
అపెక్స్ మ్యాప్ సేకరణలోని అన్ని జతలను క్లియర్() పద్ధతిని ఉపయోగించి ఒకేసారి తొలగించవచ్చు. ఇది ఏ పారామితులను తీసుకోదు.
సింటాక్స్:
map_object.clear()ఉదాహరణ:
మునుపటి “map_obj”లోని జతలను తీసివేయండి.
//క్లియర్ అయ్యే ముందు()System.debug(map_obj);
// clear()ని ఉపయోగించి అన్ని జతలను తీసివేయండి
map_obj.clear();
//క్లియర్ అయిన తర్వాత()
System.debug(map_obj);
అవుట్‌పుట్:
మునుపు, “map_obj”లో 3 కీ-విలువ జతలు ఉన్నాయి. స్పష్టమైన () పద్ధతిని వర్తింపజేసిన తర్వాత, మొత్తం 3 తొలగించబడతాయి.
6. Map.equals()
సమాన () పద్ధతిని ఉపయోగించి మనం రెండు మ్యాప్ వస్తువులను పోల్చవచ్చు. రెండు మ్యాప్ ఆబ్జెక్ట్‌లలో అన్ని కీలు మరియు విలువలు ఒకేలా ఉంటే true యొక్క బూలియన్ విలువ తిరిగి ఇవ్వబడుతుంది. కనీసం ఒక విలువ భిన్నంగా ఉంటే తప్పు యొక్క బూలియన్ విలువ తిరిగి ఇవ్వబడుతుంది.
సింటాక్స్:
map_object1.equals(map_object2)ఉదాహరణ:
ఒక కీతో మూడు మ్యాప్ ఆబ్జెక్ట్‌లను క్రియేట్ చేద్దాం: విలువ జత, ప్రతి ఒక్కటి 'ఖాతా' ఆబ్జెక్ట్‌కు సంబంధించి. ఈ వస్తువులను వాటి మధ్య సరిపోల్చండి.
// ఖాతా-1ఖాతా ఖాతా1 = కొత్త ఖాతా(పేరు='లైనక్స్ సూచన');
Map
ఖాతా1 => 1000};
System.debug('మ్యాప్ - 1:' + map_obj1);
// ఖాతా-2
ఖాతా ఖాతా2 = కొత్త ఖాతా(పేరు='లైనక్స్ సూచన');
Map
ఖాతా2 => 1000};
System.debug('మ్యాప్ - 2:' + map_obj1);
// ఖాతా-3
ఖాతా ఖాతా3 = కొత్త ఖాతా(పేరు='పైథాన్');
Map
ఖాతా3 => 2000};
System.debug('మ్యాప్ - 3:' + map_obj3);
// సమానం()
System.debug('మ్యాప్ 1 & మ్యాప్ 2 సమానం: '+ map_obj1.equals(map_obj2));
System.debug('మ్యాప్ 1 & మ్యాప్ 3 సమానం: '+ map_obj1.equals(map_obj3));
అవుట్‌పుట్:
రెండు వస్తువులలో కీలు మరియు విలువలు రెండూ ఒకేలా ఉన్నందున మొదటి మరియు రెండవ మ్యాప్ వస్తువులు సమానంగా ఉంటాయి. కీలు మరియు విలువలు వేర్వేరుగా ఉన్నందున మొదటి మరియు మూడవ మ్యాప్ వస్తువులు సమానంగా ఉండవు.
7. Map.isEmpty()
మేము isEmpty() పద్ధతిని ఉపయోగించి మ్యాప్ ఖాళీగా ఉందో లేదో తనిఖీ చేయవచ్చు. అపెక్స్ మ్యాప్ సేకరణ ఖాళీగా ఉంటే ఒప్పు అందించబడుతుంది. లేకపోతే, తప్పు తిరిగి ఇవ్వబడుతుంది. పరిమాణం() పద్ధతి వలె, ఇది ఏ పరామితిని తీసుకోదు.
సింటాక్స్:
map_object.isEmpty()ఉదాహరణ:
'ఖాతా'కి సంబంధించిన రెండు మ్యాప్ ఆబ్జెక్ట్‌లను క్రియేట్ చేద్దాం మరియు ఈ రెండూ ఖాళీగా ఉన్నాయా లేదా అని తనిఖీ చేద్దాం.
// ఖాతా-1ఖాతా ఖాతా1 = కొత్త ఖాతా(పేరు='లైనక్స్ సూచన');
Map
ఖాతా1 => 1000};
// ఖాతా-2
మ్యాప్
// ఖాళీగా ఉంది()
System.debug('మ్యాప్-1 ఖాళీగా ఉంది: '+map_obj1.isEmpty());
System.debug('మ్యాప్-2 ఖాళీగా ఉంది: '+map_obj2.isEmpty());
అవుట్‌పుట్:
మొదటి మ్యాప్ ఒక కీ-విలువ జతను కలిగి ఉన్నందున అది ఖాళీగా లేదు. రెండవ మ్యాప్ ఏదీ కలిగి లేనందున అది ఖాళీగా ఉంది.
8. Map.remove()
అపెక్స్ మ్యాప్ సేకరణలో తొలగించు() పద్ధతి ఒక నిర్దిష్ట కీ-విలువ జతను అందులో పారామీటర్‌గా పేర్కొన్న కీ ఆధారంగా తీసివేయడానికి ఉపయోగించబడుతుంది. కీ ఉనికిలో లేకుంటే, లోపం తలెత్తుతుంది.
సింటాక్స్:
map_object.remove(కీ)ఉదాహరణ:
రెండు అంశాలతో మ్యాప్‌ను రూపొందించి, మొదటి అంశాన్ని తీసివేద్దాం.
ఖాతా ఖాతా1 = కొత్త ఖాతా(పేరు='లైనక్స్ సూచన');ఖాతా ఖాతా2 = కొత్త ఖాతా(పేరు='పైథాన్');
Map
ఖాతా1 => 1000, ఖాతా2 => 4000};
System.debug('ఇప్పటికే ఉన్న మ్యాప్'+ map_obj);
//తొలగించు()
map_obj.remove(account1);
System.debug('మొదటి అంశాన్ని తీసివేసిన తర్వాత:'+map_obj);
అవుట్‌పుట్:
మ్యాప్ నుండి మొదటి అంశాన్ని తీసివేసిన తర్వాత, ఒక అంశం మాత్రమే ఉంది – {ఖాతా:{Name=Python}=4000}.
9. Map.put()
ఈ పద్ధతిని ఉపయోగించి, మేము ఒకేసారి ఒక అంశాన్ని మ్యాప్ ఆబ్జెక్ట్‌కు నేరుగా జోడించవచ్చు. ఇది రెండు పారామితులను అంగీకరిస్తుంది: “కీ” మొదటి పరామితి అయితే “విలువ” రెండవ పరామితి.
సింటాక్స్:
map_object.put(కీ,విలువ)ఉదాహరణ:
ఒక కీ-విలువ జతతో మ్యాప్‌ని క్రియేట్ చేద్దాం. అప్పుడు, మేము 'account2'ని చొప్పించడానికి 'పుట్' పద్ధతిని ఉపయోగిస్తాము.
// ఖాతా-1ఖాతా ఖాతా1 = కొత్త ఖాతా(పేరు='లైనక్స్ సూచన');
Map
ఖాతా1 => 1000};
System.debug('అసలు మ్యాప్: '+map_obj1);
// ఖాతా-2
ఖాతా ఖాతా2 = కొత్త ఖాతా(పేరు='పైథాన్');
// పెట్టు()
map_obj1.put(ఖాతా2,2000);
System.debug('ఫైనల్ మ్యాప్: '+map_obj1);
అవుట్‌పుట్:
గతంలో, మ్యాప్‌లో {ఖాతా:{Name=Linux సూచన}=1000} అనే ఒకే ఒక కీ-విలువ జత మాత్రమే ఉంది. “account2”ని జోడించిన తర్వాత, చివరి మ్యాప్‌లో రెండు కీలక-విలువ జంటలు ఉంటాయి, అవి {ఖాతా:{Name=Linux సూచన}=1000 మరియు ఖాతా:{Name=Python}=2000}.
10. Map.putAll()
ఈ పద్ధతిని ఉపయోగించి, మేము ఒకేసారి మ్యాప్ ఆబ్జెక్ట్‌కు ఒకే లేదా బహుళ అంశాలను నేరుగా జోడించవచ్చు. ఇది మ్యాప్ సేకరణ వస్తువును పారామీటర్‌గా తీసుకుంటుంది.
సింటాక్స్:
map_object1.putAll(map_object2)ఉదాహరణ:
రెండు కీ-విలువ జతలతో మ్యాప్‌ని క్రియేట్ చేద్దాం మరియు ఐటెమ్‌లు లేకుండా ఖాళీ మ్యాప్ ఆబ్జెక్ట్‌ని మళ్లీ క్రియేట్ చేద్దాం. మొదటి మ్యాప్ ఆబ్జెక్ట్‌లో అందుబాటులో ఉన్న అంశాలను రెండవ మ్యాప్ ఆబ్జెక్ట్‌కు జోడించడానికి putAll() పద్ధతిని ఉపయోగించండి.
ఖాతా ఖాతా1 = కొత్త ఖాతా(పేరు='లైనక్స్ సూచన');ఖాతా ఖాతా2 = కొత్త ఖాతా(పేరు='పైథాన్');
Map
account1 => 1000, account2=> 2000};
System.debug(map_obj1);
మ్యాప్
//putAll()
map_obj2.putAll(map_obj1);
System.debug(map_obj2);
అవుట్‌పుట్:
ముగింపు
మ్యాప్ అనేది ప్రధానంగా ట్రిగ్గర్ దృశ్యాలలో ఉపయోగించబడే డేటా నిర్మాణం మరియు జాబితా వలె సేల్స్‌ఫోర్స్ డేటాబేస్‌లో ఒకేసారి ఎక్కువ డేటాను లోడ్ చేయడంలో సహాయపడుతుంది. ఐటెమ్‌లను మ్యాప్‌లోకి జోడించడానికి మాకు రెండు ఎంపికలు ఉన్నాయి: పుట్() మరియు పుట్ఆల్() ఉపయోగించి. అపెక్స్ మ్యాప్ సేకరణ నుండి నిర్దిష్ట అంశాన్ని తీసివేయడానికి తొలగించు() పద్ధతి ఉపయోగించబడుతుంది. అన్ని అంశాలను తొలగించడానికి స్పష్టమైన() పద్ధతి ఉపయోగించబడుతుంది. అలాగే, విలువలు() మరియు కీసెట్() పద్ధతులను ఉపయోగించి విలువలు మరియు కీలను ఎలా తిరిగి ఇవ్వాలో మేము నేర్చుకున్నాము.