Skip to main content
La Trailblazer Community en Slack ya está en fase beta abierta. Únase y conéctese en tiempo real. Únase a nosotros en Slack

Información general sobre Apex

Objetivos de aprendizaje

Después de completar esta unidad, podrá:

  • Describir las funciones clave del lenguaje de programación Apex.
  • Guardar una clase de Apex y llamar a métodos mediante código Apex anónimo.
  • Utilizar Web Console (Consola web) para inspeccionar los registros de depuración.
Nota

Nota

¿Su idioma de aprendizaje es español? Comience el reto en un Trailhead Playground en español y utilice las traducciones proporcionadas entre paréntesis para navegar. Copie y pegue solo los valores en inglés, ya que las validaciones del reto se basan en los datos en inglés. Si no aprueba el reto en su organización en español, le recomendamos que (1) cambie la configuración regional a Estados Unidos, (2) cambie el idioma a inglés, siga las instrucciones descritas aquí y, a continuación, (3) vuelva a hacer clic en el botón Check Challenge (Comprobar el reto).

Consulte la insignia Trailhead en su idioma para obtener más información sobre cómo aprovechar la experiencia de Trailhead en otros idiomas.

Antes de comenzar

Nos complace acompañarlo en su recorrido por Apex. Este módulo contiene información básica sobre el lenguaje de programación para que aprenda los conceptos esenciales de forma rápida. Si este módulo es su primer acercamiento a Apex, le recomendamos completar antes el proyecto Inicio rápido: Apex. Después, vuelva a esto. Le estaremos esperando.

¿Qué es Apex?

Apex es un lenguaje de programación que usa una sintaxis similar a Java y funciona como los procedimientos almacenados de base de datos. Apex permite a los desarrolladores agregar lógica empresarial a los eventos de sistema, como clics en botones, actualizaciones de registros relacionados y páginas de Visualforce.

Como lenguaje, Apex se caracteriza por lo siguiente:

  • Alojamiento: Apex se guarda, compila y ejecuta en el servidor Salesforce Platform.
  • Orientación a objetos: Apex admite clases, interfaces y elementos heredados.
  • Tipificación consistente: Apex valida las referencias a objetos en tiempo de compilación.
  • Múltiples arrendatarios: dado que Apex se ejecuta en una plataforma de múltiples arrendatarios, protege muy bien el código no controlado mediante la aplicación de límites. Estos límites permiten impedir que el código monopolice los recursos compartidos.
  • Integración con la base de datos: el acceso y la manipulación de registros son sencillos. Apex permite el acceso directo a los registros y sus campos, y proporciona declaraciones y lenguajes de consulta para manipular estos registros.
  • Datos como objetivo: Apex proporciona un acceso transaccional a la base de datos, lo que permite operaciones de reversión.
  • Facilidad de uso: Apex se basa en el conocido lenguaje Java.
  • Pruebas sencillas: Apex ofrece compatibilidad integrada para la creación de pruebas de unidades, la ejecución y la cobertura de código.
  • Compatibilidad con versiones: el código Apex personalizado se puede guardar en distintas versiones de la API.

Apex es un lenguaje de programación basado en la nube.

Aspectos destacados del lenguaje Apex

Como ocurre con otros lenguajes de programación orientados a objetos, estos son algunos de los elementos de lenguaje que admite Apex:

  • Clases, interfaces, propiedades y colecciones (listas, mapas y conjuntos).
  • Notación de objetos y conjuntos.
  • Expresiones, variables y constantes.
  • Declaraciones condicionales (if-then-else) y declaraciones de flujo de control (bucles for y bucles while).

A diferencia de otros lenguajes de programación orientados a objetos, Apex admite lo siguiente:

  • Desarrollo en la nube, dado que Apex se almacena, compila y ejecuta en la nube.
  • Desencadenadores, los cuales son similares a los desencadenadores de sistemas de base de datos.
  • Declaraciones de base de datos que permiten hacer llamadas directas a la base de datos y lenguajes de consulta para consultar y buscar datos.
  • Transacciones y reversiones.
  • El modificador de acceso global, que es más permisivo que el modificador public y permite el acceso a espacios de nombres y aplicaciones.
  • Control de versiones de código personalizado.

Además, no se aplica la distinción entre mayúsculas y minúsculas al lenguaje Apex.

Herramientas de desarrollo

Puede escribir y depurar Apex en el ordenador cliente mediante las extensiones de Salesforce para Visual Studio Code. Consulte Desarrollar con facilidad con las extensiones de Salesforce.

También puede escribir Apex y acceder a la información de depuración directamente en el navegador mediante la interfaz de usuario de Salesforce. Web Console (Consola web) es un entorno de desarrollo integrado (IDE) moderno, ligero y basado en navegador, diseñado para salvar la distancia entre las herramientas heredadas obsoletas y los entornos de desarrollo de alto consumo de recursos. Para obtener más información, consulte la documentación para desarrolladores de Web Console (Consola web).

Puede abrir Web Console (Consola web) desde el menú de acceso rápido (Icono de engranaje de Configuración).

Web Console (Consola web)

Descripción general de tipos de datos

Apex admite varios tipos de datos, incluido un tipo de datos específico para Salesforce (tipo de datos sObject).

Apex admite los siguientes tipos de datos:

  • Primitivo (por ejemplo, Integer, Double, Long, Date, Datetime, String, ID y Boolean entre otros).
  • sObject, ya sea un sObject genérico o un sObject específico, como una cuenta, un contacto o MyCustomObject__c). (Obtendrá más información sobre sObjects en otra unidad).
  • Colección, lo que incluye lo siguiente:
    • Una lista: una recopilación ordenada e indexada de elementos. Una elementos de la lista pueden ser cualquier tipo de datos, como tipos de primitivos, colecciones, sObjects, tipos definidos por el usuario y tipos de código Apex integrados (incluidos en el sistema).
    • Un conjunto: una recopilación no ordenada de elementos. Los elementos de un conjunto también pueden ser de cualquier tipo de datos y no pueden contener valores duplicados.
    • Un mapa: una recopilación de pares clave-valor que pueden ser de cualquier tipo de datos.
  • Lista tipificada de valores, llamada también enumeración.
  • Clases de Apex (personalizadas) definidas por el usuario
  • Clases de Apex (integradas) suministradas por el sistema

Colecciones de Apex: Lista

Las listas contienen una colección ordenada de datos del mismo tipo.

Las dos declaraciones siguientes son equivalentes. La variable colors se declara mediante la sintaxis de lista.

List<String> colors = new List<String>();

De forma alternativa, la variable colors se puede declarar utilizando la notación de matrices.

String[] colors = new List<String>();

Si desea ampliar las colecciones, utilice el método List.add() para agregar nuevos elementos. Puede utilizar la notación de conjuntos entre corchetes para hacer referencia a elementos existentes en la colección según el índice, Sin embargo, no se puede emplear para agregar más elementos.

Este ejemplo muestra cómo se agregan elementos a una lista una vez creada y, a continuación, se utiliza el método add() para agregar otros.

// Create a list and add elements to it in one step
List<String> colors = new List<String> { 'red', 'green', 'blue' };
// Add elements to a list after it has been created
List<String> moreColors = new List<String>();
moreColors.add('orange');
moreColors.add('purple');

Los elementos de la lista se pueden leer mediante la especificación de un índice entre corchetes, que se conoce como notación de conjuntos. Además, puede usar el método get() para leer un elemento de la lista. Este ejemplo se basa en las listas creadas en el ejemplo anterior, y en él se muestra cómo leer los elementos de la lista mediante cualquier método. En el ejemplo se muestra además cómo iterar en los elementos de lista.

// Get elements from a list
String color1 = moreColors.get(0);
String color2 = moreColors[0];
System.assertEquals(color1, color2);
// Iterate over a list to read elements
System.debug('Print out the colors in moreColors:');
for(String color : moreColors) {
    // Write value to the debug log
    System.debug(color);
}

Más allá de los aspectos básicos

Apex admite dos tipos de colecciones: conjunto y asignación. Puede obtener más información al respecto en la sección Colecciones de la Guía del desarrollador de Apex.

Clases de Apex

Una de las ventajas de las clases de Apex es la reutilización del código. Se puede llamar a métodos de clase mediante desencadenadores y otras clases. El siguiente tutorial es una guía para el almacenamiento de una clase de ejemplo en la organización, el uso de esta clase para actualizar descripciones de cuentas y la inspección de registros de depuración.

Guardar una clase de Apex

La clase AccountProcessor tiene un método público updateAccountDescriptions(). Este método toma una lista de cuentas y actualiza su descripción según el formato especificado en el método auxiliar privado applyStandardFormatting(). No es posible llamar a los métodos auxiliares privados de forma externa; deben llamarse desde dentro de la clase. La clase AccountProcessor también contiene el método auxiliar privado inspectResults(), que inspecciona los resultados de la operación de actualización de la base de datos.

Guarde la clase AccountProcessor en su organización de Trailhead.

  1. Abra Web Console (Consola web) desde el menú de acceso rápido (Icono de engranaje de Configuración).
  2. En Web Console (Consola web), pulse Control+Mayús+P (Windows) o ⌘+Mayús+P (macOS) para abrir Command Palette (Paleta de comandos).
  3. Introduzca SFDX: Create Apex Class (SFDX: Crear clase de Apex) y pulse Intro.
  4. Para el tipo de plantilla, seleccione DefaultApexClass y, a continuación, pulse Intro.
  5. Para el nombre de la clase, introduzca AccountProcessor y, a continuación, pulse Intro.
  6. Para el directorio de salida, seleccione force-app/main/default/classes y, a continuación, pulse Intro.
  7. Sustituya el cuerpo de clase predeterminado por el ejemplo de clase AccountProcessor.
public with sharing class AccountProcessor {
    /**
     * Applies a standard formatting to the descriptions of accounts in the list,
     * and updates each account.
     */
    public void updateAccountDescriptions(List<Account> acctList) {
        if (acctList == null || acctList.isEmpty()) {
            System.debug('Account list is null or empty.');
            return;
        }
        for (Account acc : acctList) {
            applyStandardFormatting(acc);
        }
        Database.SaveResult[] srList = Database.update(acctList,
false,
AccessLevel.USER_MODE);
        inspectResults(srList);
    }
    /**
     * Private helper method to handle the description formatting logic.
     */
    private static void applyStandardFormatting(Account acc) {
        String timestamp = String.valueOf(Datetime.now());
        if (String.isBlank(acc.Description)) {
            acc.Description = 'Account updated on: ' + timestamp;
        } else {
            acc.Description += ' | Last processed: ' + timestamp;
        }
    }
    /*
     * Private helper method to inspect the returned results.
     */
    private static void inspectResults(Database.SaveResult[] results) {
        for (Database.SaveResult sr : results) {
            if (sr.isSuccess()) {
                System.debug('Successfully updated account. Account ID: ' + sr.getId());
            } else {
                for (Database.Error err : sr.getErrors()) {
                    System.debug('The following error has occurred.');
                    System.debug(err.getStatusCode() + ': ' + err.getMessage());
                    System.debug('Account fields that affected this error: ' +
err.getFields());
                }
            }
        }
    }
}
  1. Para guardar la clase, pulse Control+S (Windows) o ⌘+S (macOS).

Salesforce compila e implementa la clase al guardarla.

Note

Si la clase contiene errores, la Implementación falla al intentar guardarla. Puede ver información sobre los errores en el panel Output (Salida) situado en la parte inferior de la ventana de Web Console (Consola web).

Más allá de los aspectos básicos

La clase que acaba de guardar usa la programación orientada a objetos (OOP). La clase encapsula los métodos relacionados con la gestión de correo electrónico. Para ser un ejemplo perfecto de OOP, la clase debe contener además variables de miembro (atributos) y métodos de descriptor de acceso para acceder a estos atributos, aunque para simplificar nuestra clase no se incluyen estos elementos.

Llamar a un método para actualizar una descripción de cuenta

Vamos a invocar el método público. Usaremos la ejecución de Apex anónimo para esto. El código Apex anónimo permite ejecutar líneas de código sobre la marcha y es un método útil para invocar Apex y sobre todo para probar la funcionalidad. Se generan resultados del registro de depuración, como en el caso de cualquier otra ejecución de Apex.

Note

Hay otros métodos para la invocación de Apex (por ejemplo, mediante desencadenadores). Obtendrá más información sobre los desencadenadores en otro módulo.

  1. En Web Console (Consola web), pulse Control + Mayús + P (en Windows) o Comando + Mayús + P (en macOS) para abrir Command Palette (Paleta de comandos).
  2. Introduzca SFDX: Create Anonymous Apex Script (SFDX: Crear script anónimo de Apex) y pulse Intro.
  3. Para el nombre de la clase, introduzca UpdateAccounts y, a continuación, pulse Intro.
  4. Como directorio de salida, seleccione scripts/apex y, a continuación, pulse Intro.
  5. Introduzca este código.
// Create new accounts
List<Account> newAccts = new List<Account>();
newAccts.add(new Account(Name='My New Account', Description='Original Description'));
newAccts.add(new Account(Name='My Second New Account'));
// Insert them into the database
try {
    insert as user newAccts;
    System.debug('Successfully inserted ' + newAccts.size() + ' accounts.');
} catch (Exception e) {
    System.debug('An error inserting the records occurred: ' + e.getMessage());
}
// Instantiate an AccountProcessor object
AccountProcessor myAcctProcessor = new AccountProcessor();
// Pass the original list to update the account descriptions
myAcctProcessor.updateAccountDescriptions(newAccts);
  1. Para guardar el script, pulse Control+S (Windows) o ⌘+S (macOS).
  2. Para ejecutar el script, haga clic con el botón derecho en el editor de texto y seleccione SFDX: Execute Anonymous Apex with Currently Open Editor (SFDX: Ejecutar Apex anónimo con el editor abierto).
  3. En Salesforce, abra las páginas de detalles del registro de My New Account (Mi nueva cuenta) y My Second New Account (Mi segunda cuenta nueva).

El campo Description (Descripción) de My New Account (Mi nueva cuenta) debe ser Original Description | Last processed: 2026-01-01 00:00:00 (Descripción original | Último procesamiento: 2026-01-01 00:00:00) y el campo Description (Descripción) de My Second New Account (Mi segunda cuenta nueva) debe ser Account updated on: 2026-01-01 00:00:00 (Cuenta actualizada el: 2026-01-01 00:00:00), aunque ambas marcas de tiempo reflejarán la hora y la fecha en que se ejecutó la transacción de Apex anónima.

Inspeccionar registros de depuración

Los registros de depuración son útiles para depurar el código. Al ejecutar métodos de Apex, las llamadas se incluyen en el registro de depuración. Además, puede escribir sus propios mensajes de depuración en el registro, lo que facilita la depuración del código en caso de errores. El método auxiliar inspectResults(), al que se llama mediante updateAccountDescriptions(), escribe mensajes en el registro mediante el método System.debug() para indicar si la operación de envío de actualización de la base de datos es correcta o ha generado errores. Puede buscar estos mensajes en el registro de depuración generado al ejecutar el método.

  1. Después de ejecutar el script UpdateAccounts en Web Console (Consola web), abra el panel Output (Salida).
  2. Seleccione Debug Only (Solo depurar) para filtrar el registro de modo que solo se muestren las líneas de registro para las declaraciones System.debug().
  3. En el campo filter (filtro) situado en la parte superior del panel Output (Salida), introduzca USER_DEBUG para filtrar el registro de modo que solo se muestren las líneas de registro correspondientes a las declaraciones System.debug().
  4. También puede ver el registro de depuración en el directorio .sfdx/tools/debug/logs.

Filtrar el registro de depuración en Web Console (Consola web) para ver los mensajes de depuración

Verá los siguientes mensajes en la vista de registro filtrada, suponiendo que el script se haya enviado sin errores.

DEBUG|Successfully inserted 2 accounts.
DEBUG|Successfully updated account. Account ID: {id}
DEBUG|Successfully updated account. Account ID: {id}
Note

Además, puede filtrar el registro de depuración buscando cualquier palabra clave en el campo filter (filtro). Para ver los tipos de eventos de registro, consulte Debug Log Levels (Niveles de registro de depuración).

Llamar a un método estático

Dado que el método updateAccountDescriptions() de nuestra clase no tiene acceso a las variables de miembro de clase, no es necesario que sea un método de instancia. Vamos a cambiarlo a un método estático mediante la adición de la palabra clave static a su declaración. Es más fácil llamar a los métodos estáticos que a los métodos de instancia, ya que no necesitan llamarse en una instancia de la clase, sino que se llama directamente en el nombre de la clase.

  1. En Web Console (Consola web), abra el archivo de la clase AccountProcessor.cls.
  2. Modifique la primera línea de la definición de updateAccountDescriptions(). El único cambio es la adición de la palabra clave static.
public static void updateAccountDescriptions(List<Account> acctList) {
  1. Para guardar la clase, pulse Control+S (Windows) o ⌘+S (macOS). La clase se vuelve a implementar al guardar.
  2. Abra el archivo de script de la clase Apex anónima UpdateAccounts.apex.
  3. Sustituya el código actual por el siguiente, de modo que el script llame al método estático por el nombre de la clase.
// Create new accounts
// For clarity, use different account names than the ones you used previously
List<Account> newAccts = new List<Account>();
newAccts.add(new Account(Name='My Third New Account', Description='Original Description'));
newAccts.add(new Account(Name='My Fourth New Account'));
// Insert them into the database
try {
    insert as user newAccts;
    System.debug('Successfully inserted ' + newAccts.size() + ' accounts.');
} catch (Exception e) {
    System.debug('An error inserting the records occurred: ' + e.getMessage());
}
// Pass the original list to update the account descriptions
// The static method is called directly on the class
AccountProcessor.updateAccountDescriptions(newAccts);
  1. Para guardar el script, pulse Control+S (Windows) o ⌘+S (macOS).
  2. Para ejecutar el script, haga clic con el botón derecho en el editor de texto y seleccione SFDX: Execute Anonymous Apex with Currently Open Editor (SFDX: Ejecutar Apex anónimo con el editor abierto). Ahora que se ha ejecutado este método, puede verificar las descripciones de cuenta actualizadas en Salesforce y, si quiere, el registro de depuración como en los pasos anteriores.

Recursos

Comparta sus comentarios sobre Trailhead en la Ayuda de Salesforce.

Nos encantaría conocer su experiencia con Trailhead. Ahora puede acceder al nuevo formulario de comentarios cuando quiera desde el sitio de la Ayuda de Salesforce.

Más información Continuar para compartir comentarios