Ang Salesforce Apex map ay isang istraktura ng data na pangunahing ginagamit sa mga senaryo ng pag-trigger at tumutulong na mag-load ng higit pang data sa isang pagkakataon sa database ng Salesforce tulad ng isang listahan. Ngunit iniimbak at inaayos nito ang data sa {key:value} na format ng pares. Tatalakayin natin ang koleksyon ng mapa sa Apex programming language at mga pamamaraan nito. Dito, gagamitin namin ang Account standard object sa Salesforce para sa lahat ng halimbawa. Mabilis na sumisid tayo sa tutorial na ito.
Mapa
Kinukuha ng Map ang data ng pares na {key:value} bilang input at iniimbak ito sa pamantayan o custom na mga bagay ng Salesforce. Maaari nitong kunin ang sObject bilang susi o halaga.
Paglikha ng Mapa
Sa pamamagitan ng pagtukoy sa mga uri ng data ng susi at halaga kasama ang pangalan ng bagay, maaaring malikha ang mapa. Dito, isang bagong keyword ang ginagamit upang likhain ito. Maaari itong maging opsyonal na ipasa ang mga elemento sa panahon ng paggawa.
Walang laman na Syntax ng Mapa:
MapaGeneric na Syntax:
MapaSusi => halaga,....};
sObject Syntax:
MapSusi => halaga,....};
Dito, ang sObject ay maaaring isang standard o custom na bagay. Sa buong artikulong ito, haharapin lamang natin ang mapa gamit ang 'Account' sObject.
Tingnan natin ang mga pamamaraan na sinusuportahan ng koleksyon ng Apex 'mapa' isa-isa.
Pag-setup ng Kapaligiran
1. Mabilis na mag-log in sa Salesforce at buksan ang 'Developer Console' sa pamamagitan ng pag-click sa icon na gear.
2. Pagkatapos, buksan ang 'Anonymous Window' sa pamamagitan ng pag-click sa 'Debug' at 'Open Execute Anonymous Window'.
Pangkalahatang Halimbawa:
Una, makikita natin ang generic na paggawa ng mapa sa pamamagitan ng paggawa ng mapa na may dalawang paksa: ang 'subject_id' na gumaganap bilang isang susi at 'value' bilang pangalan ng paksa.
Mapsystem.debug(programming);
Output:
- Mag-click sa 'Ipatupad'.
- Lagyan ng check ang opsyong 'Debug Only'. Maaari mong makita ang output sa 'Execution Log'.
Mga Paraan ng Mapa
Una, gumawa kami ng mapa mula sa object na 'Account'. Gumawa kami ng tatlong account na may mga pangalan nang paisa-isa. Pagkatapos, idedeklara namin ang isang mapa na may susi at halaga bilang
Account account1 = bagong Account(Pangalan='Linux Hint');
Account account2 = bagong Account(Pangalan='Salesforce');
Account account3 = bagong Account(Pangalan='Python');
// Idagdag ang mga account sa itaas bilang mga susi sa map_obj
Map
account1 => 1000,account2 => 2000,account3 => 3000};
System.debug(map_obj);
Output:
Makikita mo na ang 'map_obj' ay nag-iimbak ng tatlong account.
1. Map.values()
Upang ibalik lamang ang mga halaga mula sa ibinigay na mapa, maaari naming gamitin ang values() na paraan. Hindi ito kukuha ng anumang mga parameter. Ibinabalik lamang nito ang listahan ng mga halaga na pinaghihiwalay ng kuwit.
Syntax:
map_object.values()Halimbawa:
Ibalik natin ang lahat ng mga halaga mula sa nakaraang mapa. Tiyaking kailangan mong isagawa ang nakaraang halimbawang code (lumikha ng mapa na may tatlong account). Kung hindi, makakakuha ka ng isang error. Ang code ay dapat ding umiiral sa console.
// Ibalik ang mga halaga para sa lahat ng mga susi gamit ang mga halaga ()System.debug(map_obj.values());
Output:
Mayroon lamang tatlong key:value pairs sa map_obj. Ang mga halaga ay: 1000, 2000, at 3000.
2. Map.keySet()
Ibalik ang mga susi na nasa object ng mapa. Katulad ng values(), hindi na kailangang magpasa ng anumang parameter sa paraang ito.
Syntax:
map_object.keySet()Halimbawa:
Ibalik natin ang lahat ng mga susi mula sa nakaraang mapa. Tiyaking isagawa mo ang nakaraang halimbawang code (lumikha ng mapa na may tatlong account). Kung hindi, makakakuha ka ng isang error. Ang code ay dapat ding umiiral sa console.
// Ibalik ang lahat ng Keys gamit ang keySet()System.debug(map_obj.keySet());
Output:
Mayroon lamang tatlong key:value pairs sa map_obj. Ang mga susi ay: {Account:{Name=Linux Hint}, Account:{Name=Python}, at Account:{Name=Salesforce}.
3. Map.size()
Sa ilang mga sitwasyon, kailangan nating malaman ang kabuuang mga pares ng item (key:value) na nasa Apex map. Size() ay ang paraan na nagbabalik ng kabuuang (key:value) na mga pares na umiiral sa map_object. Ang mga parameter ay hindi kailangan para sa pamamaraang ito.
Syntax:
map_object.size()Halimbawa:
Ibalik ang laki ng nakaraang object ng mapa.
// Ibalik ang kabuuang bilang ng mga pares gamit ang size()System.debug(map_obj.size());
Output:
Dahil mayroon lamang 3 pares, ang ibinalik na laki() ay 3.
4. Map.get()
Ang pag-access sa mga halaga mula sa mapa gamit ang key ay ginagawa gamit ang get() method. Para magawa ito, kailangan nating ipasa ang key bilang parameter sa get() method. Kung naipasa ang isang hindi kilalang susi, nagbabalik ito ng error.
Syntax:
map_object.get(key)Halimbawa:
Ibalik ang mga value ng key-2 at key-1 nang magkahiwalay.
// makuha ang halaga ng pangalawang keySystem.debug(map_obj.get(account2));
// makuha ang halaga ng unang key
System.debug(map_obj.get(account1));
Output:
Dito, 2000 ang value ng 'Salesforce' key at 1000 ang value ng 'Linux Hint' key.
5. Map.clear()
Ang lahat ng mga pares sa isang koleksyon ng Apex map ay maaaring tanggalin sa isang pagkakataon gamit ang clear() na paraan. Hindi ito kukuha ng anumang mga parameter.
Syntax:
map_object.clear()Halimbawa:
Alisin ang mga pares sa nakaraang “map_obj”.
//Bago malinaw()System.debug(map_obj);
// Alisin ang lahat ng pares gamit ang clear()
map_obj.clear();
//After clear()
System.debug(map_obj);
Output:
Dati, mayroong 3 key-value pairs sa “map_obj”. Pagkatapos ilapat ang clear() na paraan, lahat ng 3 ay tatanggalin.
6. Map.equals()
Maaari nating ihambing ang dalawang bagay sa mapa gamit ang equals() na pamamaraan. Ang Boolean na halaga ng true ay ibinalik kung ang lahat ng mga susi at mga halaga ay pareho sa parehong mga bagay sa mapa. Habang ang Boolean na halaga ng false ay ibinabalik kung hindi bababa sa isang halaga ang iba.
Syntax:
map_object1.equals(map_object2)Halimbawa:
Gumawa tayo ng tatlong bagay sa mapa na may isang key:value pair, bawat isa ay may kinalaman sa object na 'Account.' Ihambing ang mga bagay na ito sa kanila.
// Account-1Account account1 = bagong Account(Pangalan='Linux Hint');
Map
account1 => 1000};
System.debug('Map - 1:' + map_obj1);
// Account-2
Account account2 = bagong Account(Pangalan='Linux Hint');
Map
account2 => 1000};
System.debug('Map - 2:' + map_obj1);
// Account-3
Account account3 = bagong Account(Pangalan='Python');
Map
account3 => 2000};
System.debug('Map - 3:' + map_obj3);
// katumbas ng()
System.debug('Map 1 at Map 2 are Equal: '+ map_obj1.equals(map_obj2));
System.debug('Map 1 at Map 3 are Equal: '+ map_obj1.equals(map_obj3));
Output:
Ang una at pangalawang mga bagay sa mapa ay pantay-pantay dahil ang parehong mga susi at mga halaga ay pareho sa parehong mga bagay. Ang una at pangatlong mga bagay sa mapa ay hindi pantay dahil ang mga susi at mga halaga ay magkaiba.
7. Map.isEmpty()
Maaari naming suriin kung ang mapa ay walang laman o hindi gamit ang isEmpty() na pamamaraan. Ibinabalik ang True kung walang laman ang koleksyon ng mapa ng Apex. Kung hindi, ibabalik ang false. Katulad ng size() na paraan, hindi ito kukuha ng anumang parameter.
Syntax:
map_object.isEmpty()Halimbawa:
Gumawa tayo ng dalawang bagay sa mapa na nauugnay sa 'Account' at tingnan kung walang laman ang dalawang ito o wala.
// Account-1Account account1 = bagong Account(Pangalan='Linux Hint');
Map
account1 => 1000};
// Account-2
Map
// isEmpty()
System.debug('Walang laman ang Map-1: '+map_obj1.isEmpty());
System.debug('Walang laman ang Map-2: '+map_obj2.isEmpty());
Output:
Walang laman ang unang mapa dahil nagtataglay ito ng isang pares ng key-value. Walang laman ang pangalawang mapa dahil wala itong laman.
8. Map.remove()
Ang paraan ng remove() sa koleksyon ng mapa ng Apex ay ginagamit upang alisin ang isang partikular na pares ng key-value batay sa key na tinukoy dito bilang isang parameter. Kung ang susi ay hindi umiiral, ang isang error ay nakataas.
Syntax:
map_object.remove(key)Halimbawa:
Gumawa tayo ng mapa na may dalawang item at alisin ang unang item.
Account account1 = bagong Account(Pangalan='Linux Hint');Account account2 = bagong Account(Pangalan='Python');
Map
account1 => 1000,account2 => 4000};
System.debug('Umiiral na Mapa'+ map_obj);
//alisin()
map_obj.remove(account1);
System.debug('Pagkatapos tanggalin ang unang item:'+map_obj);
Output:
Pagkatapos alisin ang unang item mula sa mapa, isang item lang ang umiiral – {Account:{Name=Python}=4000}.
9. Map.put()
Gamit ang pamamaraang ito, maaari tayong direktang magdagdag ng isang item sa object ng mapa sa isang pagkakataon. Tumatanggap ito ng dalawang parameter: 'key' ang unang parameter habang ang 'value' ay ang pangalawang parameter.
Syntax:
map_object.put(key,value)Halimbawa:
Gumawa tayo ng mapa na may isang key-value pair. Pagkatapos, ginagamit namin ang 'put' na paraan upang ipasok ang 'account2'.
// Account-1Account account1 = bagong Account(Pangalan='Linux Hint');
Map
account1 => 1000};
System.debug('Actual Map: '+map_obj1);
// Account-2
Account account2 = bagong Account(Pangalan='Python');
// put()
map_obj1.put(account2,2000);
System.debug('Panghuling Mapa: '+map_obj1);
Output:
Dati, isa lang ang key-value pair sa mapa na {Account:{Name=Linux Hint}=1000}. Pagkatapos idagdag ang “account2”, ang panghuling mapa ay mayroong dalawang key-value pairs na {Account:{Name=Linux Hint}=1000 at Account:{Name=Python}=2000}.
10. Map.putAll()
Gamit ang pamamaraang ito, maaari tayong direktang magdagdag ng isa o maramihang mga item sa object ng mapa sa isang pagkakataon. Nangangailangan ito ng object ng koleksyon ng mapa bilang isang parameter.
Syntax:
map_object1.putAll(map_object2)Halimbawa:
Gumawa tayo ng mapa na may dalawang pares ng key-value at gumawa muli ng walang laman na object ng mapa na walang mga item. Gamitin ang putAll() na paraan upang idagdag ang mga item na available sa unang object ng mapa sa pangalawang object ng mapa.
Account account1 = bagong Account(Pangalan='Linux Hint');Account account2 = bagong Account(Pangalan='Python');
Map
account1 => 1000, account2 => 2000};
System.debug(map_obj1);
Map
//putAll()
map_obj2.putAll(map_obj1);
System.debug(map_obj2);
Output:
Konklusyon
Ang Map ay isang istraktura ng data na pangunahing ginagamit sa mga senaryo ng pag-trigger at tumutulong na mag-load ng higit pang data sa isang pagkakataon sa database ng Salesforce tulad ng isang listahan. Mayroon kaming dalawang pagpipilian upang idagdag ang mga item sa mapa: gamit ang put() at putAll(). Ang paraan ng remove() ay ginagamit upang alisin ang isang partikular na item mula sa koleksyon ng Apex map. Ang clear() na paraan ay ginagamit upang tanggalin ang lahat ng mga item. Gayundin, natutunan namin kung paano ibalik ang mga value at key gamit ang values() at keySet() na mga pamamaraan.