10 Essential Salesforce Interview Questions *

To retain the view state and use the previous page’s variable in a redirected page, we have to call setRedirect(false) on a new PageReference instance (in a button’s click handler, for example.)

SOAP APIs use WSDL files to make objects and database access available to Salesforce. REST can be JSON- or XML-based, while SOAP is only XML-based. REST is most often used by mobile apps, while SOAP is used to connect with legacy systems. For example, if we want to connect to SAP using Salesforce, then SAP will provide a WSDL file to connect to their database. We can use REST when a third-party system wants to extract data from or insert data into a Salesforce database.

We use insert so that if any error occurs in any record, the system will throw a System.DmlException: Insert failed exception and none of the records will be inserted.

If we want to allow partially successful bulk insert operations, we use database.insert() instead.

A batch class is an asynchronous method, so when the batch class runs, each execution method is processed in a separate thread. Now if we have mentioned one list globally to update all of the processed records in a finish method, then we will need to make this batch class stateful to retain the values of global variables. Otherwise, each thread will have its own separate copy of all global variables, so none of them will add to the list used by the main thread’s finish method.

Schema.DescribeFieldResult fieldResult = Account.Industry.getDescribe();
List ple = fieldResult.getPicklistValues();

There are four types of sandbox org available with Enterprise Edition:

• Developer provides 200 MB of data space
• Developer Pro provides 1GB of data space
• Partial Copy provides 5GB of data space, records (a sample of selected objects), and sandbox template support
• Full Copy is the same as a production org, with the same record ids the production records have

Note that all of them provide:

• Standard configuration as built into Salesforce
• Apex and Metadata
• All users copied from production

The uses of the sandbox org types are:

• Developer and Developer Pro: The only difference between these two being their data space, they are both used to code and enhance existing functionality and then move it to production.
• Partial Copy: Generally, when we are dealing with large amounts of data and want to have real-time testing data, then this sandbox is helpful because Salesforce gives up to 10,000 records of each object from production data.
• Full Copy: When you want to replicate a production issue in a sandbox and fix it, then this sandbox is the perfect fit. That’s because even if you wanted to debug directly in production, you can’t. Also, sometimes to reproduce an issue and fix it, we need the exact same data, which is what a Full Copy sandbox gives you.

Yes, we can call a class method from a custom button. To call a class method, we need to use connection JS and Apex JS in the custom button, and then we can call the Apex class method using the following syntax:

{!requireScript("/soap/ajax/20.0/connection.js")}
{!requireScript("/soap/ajax/20.0/apex.js")}

retStr = sforce.apex.execute("SampleClass", "SampleMethod",{parameters of method});

Note: The class you are calling must be a global or Webservice class.

Because the string is not a full date, we cannot use functions like Date.parse(). Now let’s say the field name is month:

FirstDate = date.newInstance(month.split('-')[1],month.split('-')[0],1);
LastDate = firstDate.addMonth(1).addDays(-1);

A wrapper class is an outer class that we use to bind values or objects which are not available in the inner class.

Use cases:

• Let’s say we want to display account records and we want to let the user select a record to perform an action on. We can create a wrapper class with one field as a boolean value and another as an account object, to bind the two together.
• A wrapper class is also used when we have to display data in a matrix format.
• If we want to show a scoreboard of recruiters from a placement object in a table, then we need to use a wrapper to store the recruiter name and corresponding score. Since there are many placements and many recruiters, we have to map the given placement number to its recruiters, and only then can we bind recruiters with scores and display them in a table.

Heap size is the size of the temporary storage of your data while executing your code in synchronous mode. All of your global variables get stored on the heap. For asynchronous mode, the heap size limit is 12 MB, and for synchronous mode, the heap size limit is 6 MB.

To reduce heap size, take the following steps:

1. Reduce using global variables if not needed.
2. Avoid using too many maps if not necessary. Try to reuse maps that are already defined if you’re using them for the same purpose later on, or call clear() when you’re done with them to free up heap space as you go.
3. Use filters to avoid storing unnecessary data in List and Map. The heap size mainly increases due to storing data retrieved from a database in a variable. So if data are not necessary then we should clear() them after we finish our use of a particular Map or List.
4. Avoid using nested for loops. If there is no way to avoid nested loops then put filter conditions in such a way that you can reduce execution statements.