Top 5 Salesforce Apex Best Practices

You cannot talk about Salesforce development without talking about Apex. It is a strongly-typed, object-oriented, on-demand programming language run entirely on the platform of Force.com. From Salesforce AppExchange development t to carrying out seamless third-party integrations, developers use
Salesforce Apex for customizing Salesforce instances.

Acting like stored procedures, the Apex syntax is extremely similar to that of Java. The programming language allows Salesforce developers to attach suitable business logic to records and processes according to the specific needs
of the organization. It also has in-built support for unit test creation and
execution.

Here are five of the best Apex practices you should carry out if you are willing to make the most of the dynamic programming language:

1. Apply The KISS Principle While Coding

The KISS (keep it stupid simple) applies to software development as well. When it comes to Salesforce development using Apex, it is always advisable to keep your codes simple and concise. Writing simple and clean codes is always a
better option instead of unnecessarily messing up the process.

The platform of Salesforce is designed in a way that clean and precise coding will provide you with the best results. Also, this saves the time and effort spent by developers in programming. When you write a single method and get rid of unwanted clutter from the code, it makes the code easier to run and maintain.

1. Refrain From SOQL Queries Or DML Statements Within “for” Loops Developers often make the mistake of placing queries or DML statements inside a “for” loop. Salesforce has a governor limit that restricts the maximum
   number of SOQL queries that can be placed by a developer. Another governor limit restricts the placement of DML statements (insert, update, delete,
   undelete).

When a developer puts these operations inside a “for” loop, it involves the database operations once per iteration of the loop. This makes it easy to reach

these governor limits. It is always advisable to move these database operations outside the “for” loop.

In case you need to query, you can query once, retrieve all necessary data in that single query, and then iterate over the results. If you are willing to modify your data, batch it up in a single list and invoke your DML once on the concerned list.

1. Using Multiple Triggers On A Single Salesforce Object

It is important for a Salesforce developer to reduce all inefficiencies while deploying multiple triggers on a single Salesforce object. If you have developed redundant queries independently, it is possible to have them query the same dataset or have redundant “for” statements.

In the case of 100 queries, instead of a single trigger getting the maximum number of queries, all triggers on the same Salesforce object should share the 100 queries. This is what makes it important for a developer to ensure that
multiple triggers are efficient without any scope for redundancies.

1. Ensuring Appropriate Use of @future

Salesforce Apex can be written in a synchronous and asynchronous way. Although Apex written in an asynchronous way has its own set of higher governor limits, there still are some governor limits you should be aware of.
Here are some of the governor limits pertaining to the @future annotation:

• Do not exceed 10 method calls per Apex action

• Methods with @future annotation cannot take Salesforce objects as
arguments
• Do not exceed 200 method calls for every Salesforce license per 24
hours
• Methods with @future annotation cannot be used in Visualforce
controllers

1. Make Use Of Relationships To Reduce Queries

If you are willing to reduce queries and make SOQL queries more effective, it is advisable to make use of object relationships. Also, SOQL allows developers to query for the parent record information, increasing the efficacy of queries.