String y qué es un método

Si alguna vez escribiste TRIM(LastName) o UPPER(Country) en un campo fórmula, ya has usado métodos sin llamarlos así. La diferencia es de puntuación: donde la fórmula pone la función delante, Apex la pega detrás del dato.

Qué es un método

Un método es una acción con nombre que un dato sabe hacer consigo mismo. Se escribe pegado al dato con un punto, lleva paréntesis (siempre, aunque estén vacíos) y devuelve algo: un texto nuevo, un número, un sí o un no. Dentro de los paréntesis van los datos extra que necesita: trim() ninguno, replace('a', 'b') dos.

Ese último detalle confunde al principio: un String es inmutable. Ningún método lo cambia por dentro; todos devuelven un texto nuevo, así que si no guardas el resultado, el trabajo se pierde.

String rawName = '  acme corp  ';

rawName.trim();                    // se calcula… y se tira
String cleanName = rawName.trim(); // se calcula y se guarda

Escribir texto y los métodos de cada día

El texto va entre comillas simples, no dobles; si necesitas una comilla dentro, se escribe con una barra invertida delante. Para unir textos se usa el signo más, igual que en una fórmula se usa el ampersand.

String owner = 'María';
String note = 'Cuenta de ' + owner + ': Northwind';   // 'Cuenta de María: Northwind'
String quoted = 'El cliente dijo \'sí\' ayer';     // El cliente dijo 'sí' ayer

Encadenar: un método detrás de otro

Lo que devuelve un método es un dato nuevo, y a ese dato le puedes pedir otro método con otro punto. rawCompany.trim().substring(0, 4).toUpperCase() se lee de izquierda a derecha: cada paso actúa sobre lo que devolvió el anterior.

La nutria: Como anidar funciones en una fórmula, pero al derecho

Yo ya hacía esto en fórmulas: UPPER(LEFT(Company, 4)) primero recorta y luego pone en mayúsculas, aunque lo escribas de fuera hacia dentro. En Apex se escribe en el mismo orden en que ocurre, de izquierda a derecha. A mí me resultó más fácil de seguir.

String rawCompany = '  northwind trading  ';

// Desarmada: un paso por línea, cada resultado con nombre
String trimmed = rawCompany.trim();          // 'northwind trading'
String firstFour = trimmed.substring(0, 4);  // 'nort'
String code1 = firstFour.toUpperCase();      // 'NORT'

// Encadenada: los mismos tres pasos, en una línea
String code2 = rawCompany.trim().substring(0, 4).toUpperCase(); // 'NORT'

String es una clase que ya trae Apex

La nutria: Como un objeto estándar

Así lo entendí yo: String es como Account. No lo creas tú, viene con Apex y ya trae sus «botones», que son sus métodos. Cada texto concreto, como 'Ana Torres', es como un registro. Y hay dos tipos de botón: los que se pulsan en un registro (nombre.trim(): «este texto, límpiate») y los que se pulsan en el objeto, como «Nuevo» (String.valueOf(42): «clase String, fabrícame un texto con esto»). Simplificación: un registro se guarda en la base de datos; un texto solo vive mientras corre tu código.

Los métodos de la clase llevan el dato dentro de los paréntesis. Dos te van a acompañar todo el curso: String.isBlank(), que funciona aunque el texto ni siquiera exista, y String.valueOf(), el TEXT() de tus fórmulas, que convierte un número o una fecha en texto.

String region = '   ';
Integer total = 42;

Boolean empty = String.isBlank(region);   // true: vacío, solo espacios o null
String a = total;                         // ✗ no compila: 42 es un número, no un texto
String b = String.valueOf(total);         // ✓ '42'
String c = 'Total: ' + total;             // ✓ al pegarlo con +, Apex lo convierte solo

Anidar: un método dentro de los paréntesis de otro

Una llamada a un método ES un valor, así que puede ir dentro de los paréntesis de otra. Aquí la lectura sí es de dentro hacia fuera, como en una fórmula: Apex resuelve primero lo de dentro y le pasa el resultado al de fuera.

String rawName = '  ana torres  ';

String lengthText = String.valueOf(rawName.trim().length());
//   primero rawName.trim().length()  → 10
//   después String.valueOf(10)       → '10'

Boolean found = rawName.contains('TORRES'.toLowerCase());   // contains('torres') → true

La nutria: Mi truco para leer cualquier línea

TEXT(LEN(TRIM(Name))) en una fórmula es exactamente String.valueOf(name.trim().length()). Para leer cualquier línea busco el paréntesis más interno, lo resuelvo en la cabeza y lo sustituyo por su valor. Repito hasta que no queda nada.

Comparar textos: la sorpresa de Apex

En Apex, == entre textos no distingue mayúsculas: 'EMEA' == 'emea' es verdadero, casi al revés que en cualquier otro lenguaje. Si la mayúscula importa, usa equals(); si quieres dejar claro que no importa, equalsIgnoreCase().

Boolean loose  = 'EMEA' == 'emea';          // true
Boolean strict = 'EMEA'.equals('emea');     // false
Boolean same   = 'EMEA'.equalsIgnoreCase('emea'); // true, y se lee mejor que ==

La nutria: Por qué esto te suena

Es lo mismo que un filtro de informe: Industry igual a «technology» también saca los «Technology». Cómodo casi siempre… y yo caí la vez que comparaba códigos donde la mayúscula sí significaba algo.