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 con Apex anónimo.
  • Usar la Consola web para inspeccionar los registros de depuración.
Nota

Nota

¿Es su idioma de aprendizaje español (LATAM)? Comience el reto en un Trailhead Playground en español (LATAM) y utilice las traducciones entre paréntesis para navegar. Copie y pegue solo los valores en inglés, ya que las validaciones del reto dependen de los datos en ese idioma. Si no aprueba el reto en su organización en español (LATAM), recomendamos que (1) cambie la configuración local a Estados Unidos, (2) cambie el idioma a inglés (según estas instrucciones) y, luego, (3) haga clic en el botón “Check Challenge” (Comprobar el reto) nuevamente.

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 realizar antes el proyecto Inicio rápido: Apex. Luego, regrese. ¡Estaremos esperando por usted!

¿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 de negocio 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:

  • Alojado: Apex se guarda, compila y ejecuta en el servidor (Salesforce Platform).
  • Orientado a objetos: Apex admite clases, interfaces y elementos heredados.
  • Fuertemente tipado: Apex valida las referencias a objetos en tiempo de compilación.
  • Diseñado para entornos multiusuario: dado que Apex se ejecuta en una plataforma multiusuario, protege muy bien el código no controlado mediante la aplicación de límites. Estos límites impiden que el código monopolice los recursos compartidos.
  • Integrado con la base de datos: el acceso a registros y su manipulación son sencillos. Apex permite el acceso directo a los registros y sus campos, y proporciona declaraciones y lenguajes de consulta para manipular estos registros.
  • Centrado en los datos Apex proporciona un acceso transaccional a la base de datos, lo que permite operaciones de reversión.
  • Fácil de usar: Apex se basa en el conocido lenguaje Java.
  • Fácil de probar: Apex ofrece compatibilidad integrada para la creación de pruebas de unidades, la ejecución y la cobertura de código.
  • Versionado: 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 (si..., entonces...) 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 a medida 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 la computadora cliente mediante las extensiones de Salesforce para Visual Studio Code. Consulte Desarrollar sin dificultades 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. La Consola web es un Entorno de Desarrollo Integrado (IDE) moderno, ligero y basado en navegador, diseñado para cerrar la brecha entre las herramientas heredadas obsoletas y los entornos de desarrollo de sobrecarga alta. Para obtener más información, consulte la documentación para desarrolladores de la Consola web.

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

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 los sObjects en una unidad posterior).
  • Colección, lo que incluye lo siguiente:
    • Una lista: una recopilación de elementos ordenada e indexada. Los elementos de la lista pueden ser de cualquier tipo de datos, por ejemplo, tipos primitivos, recopilaciones, sObjects, tipos definidos por usuario y tipos de Apex (integrados) ofrecidos por el sistema.
    • Un conjunto: una recopilación de elementos desorganizada. 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 incluyen 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>();

Como alternativa, la variable colors puede declararse mediante una anotación de matrices.

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

Si desea ampliar las colecciones, utilice el método List.add() para agregar nuevos elementos. La anotación de matrices entre corchetes se puede usar 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 que se haya creado y, luego, 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, lo que se conoce como “anotación de matrices”. 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 también se muestra cómo iterar los elementos de la 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 fundamentos

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 su organización, el uso de esta clase para actualizar las 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 sus descripciones 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 base de datos de actualización.

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

  1. Abra la Consola web desde el menú de acceso rápido (Ícono de engranaje de configuración).
  2. En la Consola web, presione Ctrl+Shift+P (Windows) o ⌘+Shift+P (macOS) para abrir la Paleta de comandos.
  3. Ingrese SFDX: Create Apex Class (SFDX: Crear una clase de Apex) y presione Intro.
  4. Para el tipo de plantilla, seleccione DefaultApexClass y, luego, presione Intro.
  5. Para el nombre de clase, ingrese AccountProcessor y, luego, presione Intro.
  6. Para el directorio de salida, seleccione force-app/main/default/classes y, luego, presione Intro.
  7. Reemplace 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 su clase, presione Ctrl+S (Windows) o ⌘+S (macOS).

Salesforce compila e implementa su clase cuando la guarda.

Note

Si su clase contiene errores, la implementación fallará cuando intente guardarla. Puede ver información sobre los errores en el panel Output (Salida) en la parte inferior de la ventana de la Consola web.

Más allá de los fundamentos

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 email. 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 incluye estos elementos.

Llamar a un método para actualizar la descripción de una 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 la Consola web, presione Ctrl+Mayús+P (Windows) o Cmd+Mayús+P (macOS) para abrir la paleta de comandos.
  2. Ingrese SFDX: Create Anonymous Apex Script (SFDX: Crear secuencia de comandos de Apex anónimo) y presione Intro.
  3. Para el nombre de clase, ingrese UpdateAccounts y, luego, presione Intro.
  4. Para el directorio de salida, seleccione scripts/apex y, luego, presione Intro.
  5. Ingrese 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 su secuencia de comandos, presione Ctrl+S (Windows) o ⌘+S (macOS).
  2. Para ejecutar la secuencia de comandos, 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 actualmente).
  3. En Salesforce, abra las páginas de detalles del registro de My New Account (Mi cuenta nueva) y My Second New Account (Mi segunda cuenta nueva).

El campo Description (Descripción) de My New Account (Mi cuenta nueva) 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 ejecutó la transacción de Apex anónimo.

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 usando el método System.debug() para indicar si la operación de actualización de la base de datos se realizó correctamente o generó errores. Puede buscar estos mensajes en el registro de depuración generado al ejecutar el método.

  1. Después de ejecutar la secuencia de comandos UpdateAccounts en la 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) en la parte superior del panel Output (Salida), ingrese USER_DEBUG para filtrar el registro y mostrar únicamente las líneas de registro de las instrucciones System.debug().
  4. También puede ver el registro de depuración en el directorio .sfdx/tools/debug/logs.

Filtre el registro de depuración en la Consola web para ver los mensajes de depuración.

Verá los siguientes mensajes en la vista de registro filtrada suponiendo que la secuencia de comandos se haya ejecutado 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 mediante la búsqueda de cualquier palabra clave en el campo filter (filtrar). Para conocer los tipos de eventos de registro, consulte 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 ser llamados en una instancia de la clase, sino que se llama directamente en el nombre de la clase.

  1. En la Consola web, abra el archivo de clase AccountProcessor.cls.
  2. Modifique la primera línea de la definición de updateAccountDescriptions(). El único cambio es la palabra clave static (estático) que se agrega.
public static void updateAccountDescriptions(List<Account> acctList) {
  1. Para guardar su clase, presione Ctrl+S (Windows) o ⌘+S (macOS). La clase se vuelve a implementar al guardar.
  2. Abra el archivo de secuencia de comandos de Apex anónimo UpdateAccounts.apex.
  3. Reemplace el código actual con el siguiente código, de modo que la secuencia de comandos llame al método estático en 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 su secuencia de comandos, presione Ctrl+S (Windows) o ⌘+S (macOS).
  2. Para ejecutar la secuencia de comandos, 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 actualmente). Una vez ejecutado este método, puede verificar las descripciones actualizadas de cuentas en Salesforce y, de forma opcional, el registro de depuración como en los pasos anteriores.

Recursos

Comparta sus comentarios de Trailhead en la Ayuda de Salesforce.

Nos encantaría saber más sobre su experiencia con Trailhead. Ahora puede acceder al nuevo formulario de comentarios en cualquier momento en el sitio de Ayuda de Salesforce.

Más información Continuar a Compartir comentarios