Apex is a strongly typed, object-oriented programming language that allows developers to

execute flow and transaction control statements on the Salesforce Platform server, in
conjunction with calls to the API. It is used to extend the functionality of Salesforce and to build
custom applications.

Apex code can be used to perform a variety of tasks, including:

 Adding business logic to Salesforce objects

 Creating custom Lightning components

 Developing web services

 Automating tasks

 Integrating with other systems

Apex is a powerful tool that can be used to create custom solutions that meet the specific needs
of your business.

Here are some of the benefits of using Apex:

 Flexibility: Apex is a powerful and flexible language that can be used to create a wide variety of
solutions.
 Extensibility: Apex can be used to extend the functionality of Salesforce, making it possible to
create custom solutions that meet the specific needs of your business.
 Integration: Apex can be used to integrate Salesforce with other systems, making it possible to
create a seamless user experience.
 Scalability: Apex is a scalable language that can be used to create solutions that can grow with
your business.

If you are looking for a powerful and flexible language that can be used to extend the
functionality of Salesforce and to build custom applications, then Apex is a great option.

use cases for Apex:

 Adding business logic to Salesforce objects: Apex can be used to add custom logic to
Salesforce objects, such as validating data, performing calculations, and sending notifications.
 Creating custom Lightning components: Apex can be used to create custom Lightning
components, which are reusable UI elements that can be used to add new functionality to
Salesforce pages.
 Developing web services: Apex can be used to develop web services, which can be used to
expose Salesforce data and functionality to other applications.
 Automating tasks: Apex can be used to automate tasks, such as sending emails, updating
records, and creating reports.
 Integrating with other systems: Apex can be used to integrate Salesforce with other systems,
such as CRM systems, ERP systems, and marketing automation systems.
 Apex collections are a type of variable that can store multiple items. They are used to store and
manage groups of data in Salesforce.

There are three types of Apex collections:

 Lists: Lists are ordered collections of items of the same type. They can contain any data type,
including primitive data types, sObjects, and collections. Lists have an index, which allows you
to access items by their position in the list.
 Sets: Sets are unordered collections of unique items. They can contain any data type, except for
null values. Sets do not have an index, so you cannot access items by their position in the set.
 Maps: Maps are collections of key-value pairs. The keys must be unique, but the values can be
of any data type. Maps do not have an index, so you cannot access items by their position in the
map.

Apex collections can be used to perform a variety of tasks, such as:

 Storing and managing data

 Filtering data

 Sorting data

 Searching data

 Calculating statistics on data

 Retrieving data from external systems

Apex collections are a powerful tool that can be used to simplify and improve the performance
of your Apex code.

 Lists: Lists are the most commonly used type of Apex collection. They are easy to use and
understand, and they offer a wide range of functionality.
 Sets: Sets are less commonly used than lists, but they can be useful in certain situations. For
example, sets can be used to efficiently remove duplicate items from a collection.
 Maps: Maps are the least commonly used type of Apex collection. They can be useful for storing
data in a key-value format, but they can be more complex to use than lists or sets.
What is an Apex collection list?

An Apex collection list is a data structure that can store a collection of objects of the same type.
The objects in a list can be primitive data types, such as strings or numbers, or they can be
complex data types, such as Apex classes or Salesforce objects.

How to declare an Apex collection list

To declare an Apex collection list, you use the List keyword followed by the data type of the
objects that the list will store. For example, the following code declares a list of strings:
List<String> myList = new List<String>();
How to add objects to an Apex collection list
You can add objects to an Apex collection list using the add() method. The add() method takes
one argument, which is the object that you want to add to the list. For example, the following
code adds the string "Hello, World!" to the myList list:
myList.add("Hello, World!");
How to remove objects from an Apex collection list
You can remove objects from an Apex collection list using the remove() method. The remove()
method takes one argument, which is the index of the object that you want to remove. For
example, the following code removes the first object from the myList list:
myList.remove(0);
How to iterate through an Apex collection list
You can iterate through an Apex collection list using a for loop. The for loop will iterate over
each object in the list, and you can access the current object using the current() keyword. For
example, the following code iterates through the myList list and prints each object to the
console:
for (String s : myList) {
System.debug(s);
}
What are the benefits of using Apex collections lists?

There are several benefits to using Apex collections lists. First, they allow you to store a
collection of objects in a single variable. This can make your code more concise and easier to
read. Second, collections lists provide a number of methods that make it easy to add, remove,
and iterate through objects in the list. Third, collections lists are dynamically sized, which means
that they can grow or shrink as needed. This can help you to optimize the performance of your
code.

Apex collections lists are a powerful tool that can be used to store and manipulate collections of
objects in Salesforce. If you are developing Apex code, I encourage you to learn more about
collections lists and how to use them.
 What is a Map?
A Map is a collection of key-value pairs where each unique key maps to a single value. Keys
and values can be any data type—primitive types, collections, sObjects, user-defined types, and
built-in Apex types.
For example, the following code creates a Map with two key-value pairs:
Map<String, Integer> myMap = new Map<String, Integer>();
myMap.put("key1", 1);
myMap.put("key2", 2);

In this example, the key "key1" maps to the value 1, and the key "key2" maps to the value 2.

 How to use a Map in Apex?

There are many ways to use a Map in Apex. Here are a few examples:

 Adding key-value pairs to a Map: You can use the put() method to add key-value pairs to a
Map. For example, the following code adds two key-value pairs to the Map myMap:
myMap.put("key1", 1);
myMap.put("key2", 2);
 Getting the value for a key: You can use the get() method to get the value for a key in a Map.
For example, the following code gets the value for the key "key1" from the Map myMap:
Integer value = myMap.get("key1");
 Iterating over a Map: You can use the entrySet() method to iterate over the key-value pairs in
a Map. For example, the following code iterates over the key-value pairs in the Map myMap and
prints the key and value for each pair:
for (Map.Entry<String, Integer> entry : myMap.entrySet()) {
System.debug(entry.getKey() + " => " + entry.getValue());
}
 Clearing a Map: You can use the clear() method to clear all the key-value pairs from a Map.
For example, the following code clears the Map myMap:
myMap.clear();
 What are the Map methods available in Salesforce?

The following are some of the Map methods available in Salesforce:

 put(): Adds a key-value pair to a Map.

 get(): Gets the value for a key in a Map.
 entrySet(): Returns an iterator for the key-value pairs in a Map.
 clear(): Clears all the key-value pairs from a Map.
 size(): Returns the number of key-value pairs in a Map.
 isEmpty(): Returns true if a Map is empty.
 containsKey(): Returns true if a Map contains a key.
 containsValue(): Returns true if a Map contains a value.
 remove(): Removes a key-value pair from a Map.
 What is the use of Map collection in Salesforce?

The Map collection can be used for a variety of purposes in Salesforce, such as:
 Storing data in a key-value format.

 Grouping data together.

 Filtering data.

 Sorting data.

 Searching data.

The Map collection is a powerful tool that can be used to simplify and improve the performance
of your Salesforce applications.
 An Apex collection set is an unordered collection of elements that do not contain any duplicates.
Set elements can be of any data type—primitive types, collections, sObjects, user-defined
types, and built-in Apex types.

Here are some of the key features of Apex collections set:

 Unordered: The order in which elements are added to a set does not matter.
 No duplicates: A set cannot contain duplicate elements. If you try to add an element that already
exists in the set, the element will not be added.
 Dynamic: Sets can grow and shrink dynamically at runtime.

Apex collections set can be used for a variety of tasks, such as:

 Storing unique values: A set can be used to store unique values, such as a list of customer IDs
or a list of product names.
 Eliminating duplicates: A set can be used to eliminate duplicates from a collection of data.
 Performing set operations: Apex collections set supports a variety of set operations, such as
union, intersection, and difference.

Here is an example of how to create an Apex collections set:

Set<String> names = new Set<String>();

names.add("John");
names.add("Jane");
names.add("Mary");

System.debug(names); // Prints "Set{John, Jane, Mary}"

As you can see, the names set now contains three elements: "John", "Jane", and "Mary". The
order in which the elements were added to the set does not matter.

Here is another example of how to use Apex collections set:

Set<Account> accounts = new Set<Account>();

accounts.add(new Account(Id = "001"));
accounts.add(new Account(Id = "002"));
accounts.add(new Account(Id = "001"));

System.debug(accounts); // Prints "Set{001, 002}"

As you can see, the accounts set now contains two elements: "001" and "002". The duplicate
element "001" was not added to the set.
 DML stands for Data Manipulation Language. It is a set of statements used to manage data in a
database. In Salesforce, DML operations can be performed using Apex code.

There are six DML operations in Salesforce:

 Insert: This operation creates a new record in a Salesforce object.

 Update: This operation updates the values of one or more fields in an existing record.
 Delete: This operation deletes an existing record from a Salesforce object.
 Upsert: This operation is a combination of insert and update. It first checks if a record with the
specified key already exists. If it does, the operation updates the record. If it does not, the
operation inserts a new record.
 Undelete: This operation restores a deleted record to its previous state.
 Merge: This operation merges two records into a single record. The merge operation is only
supported for certain types of objects.

DML operations in Apex are performed using the following statements:

 insert: This statement creates a new record in a Salesforce object.

 update: This statement updates the values of one or more fields in an existing record.
 delete: This statement deletes an existing record from a Salesforce object.
 upsert: This statement is a combination of insert and update. It first checks if a record with the
specified key already exists. If it does, the operation updates the record. If it does not, the
operation inserts a new record.
 undelete: This statement restores a deleted record to its previous state.
 merge: This statement merges two records into a single record. The merge operation is only
supported for certain types of objects.

When performing DML operations in Apex, it is important to be aware of the following:

 DML operations are atomic. This means that either all of the changes are committed to the
database, or none of them are committed.

 DML operations can only be performed within a transaction.

 There are governor limits on the number of DML operations that can be performed per
transaction.
 What is Apex SOQL?

Apex SOQL stands for Salesforce Object Query Language. It is a Salesforce scripting language
that allows you to query Salesforce data from within your Apex code. Apex SOQL is similar to
SQL, but it has some Salesforce-specific features.

How to use Apex SOQL

To use Apex SOQL, you need to wrap your SOQL query in square brackets and assign the
return value to an array of sObjects. For example, the following Apex code retrieves all account
records with two fields, Name and Phone, and returns an array of Account sObjects:

Account[] accounts = [SELECT Name, Phone FROM Account];

You can also use Apex SOQL to query related records. For example, the following Apex code
retrieves all contacts that are related to an account with the ID 12345:

Contact[] contacts = [SELECT ContactId, Name FROM Contact WHERE AccountId =

12345];
Limitations of Apex SOQL

Apex SOQL has some limitations that you should be aware of:

 You cannot use Apex SOQL to modify Salesforce data.

 You cannot use Apex SOQL to query more than 1000 records at a time.

 You cannot use Apex SOQL to query data from custom objects that are not visible to the current
user.

How to learn Apex SOQL

There are many resources available to help you learn Apex SOQL. Here are a few suggestions:

 The Salesforce Developer Guide has a section on SOQL and SOSL.

 The Salesforce Trailhead has a module on Apex SOQL.

 There are many third-party websites and blogs that offer Apex SOQL tutorials and examples.
 What is Apex SOSL?
Apex SOSL stands for Salesforce Object Search Language. It is a Salesforce search language
that is used to perform text searches in records. Unlike SOQL, SOSL can query multiple types
of objects at the same time. SOSL can also use a word match to match fields, while SOQL
needs the exact phrase.
 How to use Apex SOSL?
To use Apex SOSL, you need to use the search method. The search method takes a SOSL
query string as its parameter. The SOSL query string is a text string that specifies the search
criteria.

The following is an example of a SOSL query string that searches for accounts and contacts
that have any fields with the word "SFDC":

FIND 'SFDC' IN ALL FIELDS RETURNING Account(id,name),Contact(id,name)

This query string tells Salesforce to search for the word "SFDC" in all fields of the Account and
Contact objects. The results of the query will be a list of accounts and contacts that have any
fields with the word "SFDC".

 Advantages of Apex SOSL

There are several advantages to using Apex SOSL:

 It can query multiple types of objects at the same time.

 It can use a word match to match fields.

 It is more flexible than SOQL.

 Disadvantages of Apex SOSL

There are also a few disadvantages to using Apex SOSL:

 It can be slower than SOQL.

 It is not as well-supported as SOQL.

Apex SOSL is a powerful tool that can be used to perform text searches in Salesforce records. It
is more flexible than SOQL and can query multiple types of objects at the same time. However,
it can be slower than SOQL and is not as well-supported.
 An Apex controller is a class that is used to handle user interactions and process data in
Salesforce. It is responsible for routing requests from Visualforce pages to the appropriate Apex
methods, and for returning data from Apex methods back to Visualforce pages.

There are two types of Apex controllers:

 Standard controllers: These controllers are provided by Salesforce and are used to access the
standard functionality of Salesforce objects. For example, the standard controller for the
Account object provides methods for creating, editing, and deleting accounts.
 Custom controllers: These controllers are created by developers and can be used to add
custom functionality to Salesforce. Custom controllers can be used to access data from custom
objects, or to perform custom logic that is not available in the standard controllers.
Apex controllers are created in the Salesforce Developer Console. To create a new Apex
controller, click File > New > Apex Class. In the Class Name field, enter the name of your
controller class. The class name must start with the word "Controller".

Once you have created your Apex controller class, you can add methods to it. Methods in Apex
controllers are used to handle user interactions and process data. When a user interacts with a
Visualforce page that is bound to an Apex controller, the controller's methods are called to
handle the interaction.

Apex controllers are an essential part of Salesforce development. They are used to handle user
interactions, process data, and return data back to Visualforce pages. By understanding how
Apex controllers work, you can create powerful and efficient Salesforce applications.

 Increased flexibility: Apex controllers give developers the flexibility to add custom functionality to
Salesforce. This can be used to extend the functionality of standard objects, or to create entirely
new objects and processes.
 Improved performance: Apex controllers can improve the performance of Salesforce
applications by offloading processing from the browser to the server. This can be especially
beneficial for complex applications that require a lot of data processing.
 Enhanced security: Apex controllers can be used to implement security measures that are not
available in the standard controllers. This can help to protect Salesforce data from unauthorized
access.
 What is an Apex trigger?

An Apex trigger is a piece of code that Salesforce executes automatically when a specific event
occurs on a Salesforce object. For example, you could create an Apex trigger that sends an
email notification whenever a new lead is created.

Types of triggers
There are two types of triggers: before triggers and after triggers. Before triggers are executed
before the event occurs, while after triggers are executed after the event occurs.
When are triggers executed?

Triggers are executed for the following events:

 Object creation: When a new record is created on an object.

 Object update: When an existing record is updated on an object.
 Object deletion: When an existing record is deleted from an object.
 Object undeletion: When an object that has been deleted is restored.
How to create an Apex trigger

To create an Apex trigger, you must have the following permissions:

 Create Apex triggers permission on the object that you want to create the trigger for.
 Edit trigger permission on the object that you want to create the trigger for.

To create an Apex trigger, follow these steps:

1. In the Salesforce user interface, go to Setup > Develop > Apex > Triggers.
2. Click New.
3. In the Name field, enter a name for your trigger.
4. In the Object field, select the object that you want to create the trigger for.
5. In the Trigger field, select the event that you want the trigger to fire for.
6. In the Before or after field, select whether you want the trigger to fire before or after the event
occurs.
7. Click Save.
How to write an Apex trigger

The body of an Apex trigger is written in Apex code. Apex code is a programming language that
is specifically designed for Salesforce.

To write an Apex trigger, you must first understand the following concepts:

 Trigger context: The trigger context is a set of variables that are available to the Apex trigger
code. The trigger context includes information about the record that was changed, the user who
made the change, and the time of the change.
 Trigger events: The trigger event is the event that triggers the execution of the Apex trigger
code. The trigger event can be object creation, object update, object deletion, or object
undeletion.
 Trigger order: Triggers are executed in a specific order, based on the object and the trigger
event. The order of execution is as follows:
o Before triggers for object creation

o After triggers for object creation

o Before triggers for object update

o After triggers for object update

o Before triggers for object deletion

o After triggers for object deletion

o Before triggers for object undeletion

o After triggers for object undeletion

Best practices for Apex triggers

 Use triggers sparingly: Triggers can be a powerful tool, but they can also slow down your
Salesforce org. Use triggers only when you absolutely need them.
 Keep triggers simple: Triggers should be as simple as possible. The more complex a trigger is,
the more likely it is to have errors.
 Test triggers thoroughly: Before you deploy a trigger to production, make sure to test it
thoroughly. Test the trigger with different data and different scenarios.
 Document triggers: Make sure to document your triggers so that other developers can
understand how they work.
 What is an Apex trigger?

An Apex trigger is a piece of code that runs automatically when a specific event occurs in
Salesforce. Triggers can be used to perform custom actions before or after an event, such as
inserting, updating, or deleting a record.

What are Apex trigger events?

Apex trigger events are the specific events that can trigger an Apex trigger to run. There are six
different Apex trigger events in Salesforce:

 Before insert: This event fires before a record is inserted into Salesforce.
 Before update: This event fires before a record is updated in Salesforce.
 Before delete: This event fires before a record is deleted from Salesforce.
 After insert: This event fires after a record is inserted into Salesforce.
 After update: This event fires after a record is updated in Salesforce.
 After delete: This event fires after a record is deleted from Salesforce.
 After undelete: This event fires after a record is undeleted from Salesforce.
How to use Apex trigger events

Apex trigger events can be used to perform a variety of custom actions in Salesforce. For
example, you can use a trigger to:

 Validate the data being inserted or updated

 Send an email notification when a record is created or updated

 Update related records when a record is changed

 Restrict certain users from making changes to records

Best practices for Apex trigger events

When using Apex trigger events, it is important to follow some best practices to ensure that your
triggers are efficient and effective. Here are a few tips:

 Use triggers sparingly. Triggers can be a powerful tool, but they can also slow down your
Salesforce org if they are not used carefully.

 Use before triggers for validation and after triggers for other actions. This will help to ensure that
your triggers are executed in the correct order.

 Use triggers to perform a single action. If you need to perform multiple actions, consider using a
workflow instead.

 Test your triggers thoroughly before deploying them to production. This will help to prevent
unexpected errors or performance problems.
 Apex trigger context variables are implicit variables that allow developers to access runtime
context in their Apex trigger code. These variables are contained in the System.Trigger class.

There are a number of different Apex trigger context variables, each of which provides
information about the current trigger execution. Some of the most commonly used Apex trigger
context variables include:

 Trigger.new: This variable contains a reference to the new record that was inserted or updated,
or to a list of deleted records.
 Trigger.old: This variable contains a reference to the old record that was updated or deleted, or
to null if the trigger was fired for an insert operation.
 Trigger.Parent: This variable contains a reference to the parent record of the record that was
inserted, updated, or deleted.
 Trigger.RecordId: This variable contains the ID of the record that was inserted, updated, or
deleted.
 Trigger.EventType: This variable contains a string that identifies the type of trigger event that
caused the trigger to fire.
 Trigger.IsExecuting: This variable returns true if the current context for the Apex code is a
trigger, not a Visualforce page, a Web service, or an executeanonymous() API call.

Apex trigger context variables can be used to perform a variety of tasks in Apex trigger code,
such as:

 Validating the data that is being inserted, updated, or deleted.

 Enforcing business rules.

 Logging or reporting on trigger activity.

 Sending notifications.

 Updating related records.

Apex trigger context variables are a powerful tool that can be used to extend the functionality of
Salesforce triggers. By understanding how to use these variables, developers can write more
efficient and effective trigger code.

 Trigger context variables cannot be used in Apex DML operations. This means that you cannot
use trigger context variables to insert, update, or delete records.
 The values of trigger context variables can change during the execution of a trigger. This means
that you should be careful not to rely on the values of trigger context variables in ways that
could lead to unexpected results.
 Trigger context variables are not available in after insert, after update, or after delete triggers.
This is because these triggers are fired after the record has been saved, and the values of
trigger context variables are no longer valid at this point.
A recursive trigger is a trigger that calls itself. This can happen when a trigger performs an
action that causes another trigger to fire, which in turn causes the first trigger to fire again. This
can lead to an infinite loop, which is why recursive triggers are not allowed in Salesforce.

There are a few ways to avoid recursive triggers in Salesforce. One way is to use a static
variable. A static variable is a variable that is shared by all instances of a class. You can use a
static variable to keep track of whether or not the trigger has already been fired. If the trigger
has already been fired, then you can simply return without doing anything.

Another way to avoid recursive triggers is to use a static set. A static set is a collection of
objects that is shared by all instances of a class. You can use a static set to keep track of the
IDs of records that have already been updated by the trigger. If the ID of a record is already in
the set, then you can simply skip that record.

Finally, you can also use the trigger on/off switch to avoid recursive triggers. The trigger on/off
switch is a setting that allows you to disable a trigger temporarily. If you are unsure whether or
not a trigger will cause a recursive loop, then you can disable it until you can confirm that it is
safe to enable.

Here is an example of a recursive trigger in Salesforce:

trigger MyRecursiveTrigger on Account (after update) {

// Check if the trigger has already been fired.
static boolean firstCall = true;
if (firstCall) {
firstCall = false;
// Do something.
update this;
// Call the trigger again.
MyRecursiveTrigger();
}
}

This trigger will update the account record that is being updated. However, it will also call itself
recursively. This will cause the trigger to be fired again and again, until the governor limits are
reached.

To avoid this recursive loop, you can use a static variable or a static set. For example, you could
use the following code:

trigger MyRecursiveTrigger on Account (after update) { // Check if the trigger has already been
fired. static Set<Id> updatedAccounts = new Set<Id>(); if (!updatedAccounts.contains(this.id)) {
updatedAccounts.add(this.id); // Do something. update this; // Call the trigger again, but only if
the account record has not been updated by the trigger yet. if
(!updatedAccounts.contains(this.id)) { MyRecursiveTrigger(); } } }

This code will only call the trigger again if the account record has not been updated by the
trigger yet. This will prevent the trigger from causing an infinite loop.
 Apex trigger governor limits are restrictions that Salesforce enforces on the number of
operations that can be performed by an Apex trigger in a single transaction. These limits are
designed to prevent runaway Apex code from monopolizing shared resources and impacting the
performance of other users.

There are a number of different Apex trigger governor limits, including:

 The maximum number of SOQL queries that can be executed in a transaction: This limit is 100
per transaction.
 The maximum number of DML statements that can be executed in a transaction: This limit is
150 per transaction.
 The maximum number of records that can be processed as a result of DML statements: This
limit is 10,000 records per transaction.
 The maximum stack depth for any Apex invocation that recursively fires triggers due to insert,
update, or delete statements: This limit is 16.
 The maximum number of callouts (HTTP requests or web services calls) in a transaction: This
limit is 100 per transaction.
 The maximum cumulative timeout for all callouts (HTTP requests or web services calls) in a
transaction: This limit is 120 seconds.
 The maximum number of methods with the future annotation allowed per Apex invocation: This
limit is 50.
 The maximum number of Apex jobs added to the queue with System.enqueueJob: This limit is
50.
 The maximum number of sendEmail methods allowed: This limit is 10.
 The total heap size: This limit is 12 MB.
 The maximum CPU time on the Salesforce servers: This limit is 60,000 milliseconds.
 The maximum execution time for each Apex transaction: This limit is 10 minutes.

If an Apex trigger exceeds any of these governor limits, it will throw an exception and will not be
executed.

 Use SOQL queries sparingly: SOQL queries can be a major source of governor limit violations.
When possible, avoid using SOQL queries and instead use Apex code to access data.
 Use DML statements sparingly: DML statements can also be a major source of governor limit
violations. When possible, avoid using DML statements and instead use Apex code to modify
data.
 Use recursion carefully: Recursion can quickly lead to stack overflow errors, which can trigger
governor limit violations. When using recursion, be sure to carefully consider the stack depth
and the number of times the recursive method will be called.
 Use the future annotation: The future annotation can be used to defer the execution of an Apex
method until a later time. This can be helpful for avoiding governor limit violations, as it allows
you to execute the method outside of the current transaction.
 Use the Limits class: The Limits class provides methods for getting information about the
current governor limits. This can be helpful for debugging governor limit violations.