Tip Semanal 036: Funciones macro (parte 1)

[Berenice25]

Ya hemos visto en los Tips 023 y 024 la creación y el uso de variables macro. 
Es hora entonces de pasar a la siguiente etapa: las funciones macro. 
Llegado a este punto, es imprescindible determinar la diferencia entre el lenguaje de programación SAS y el lenguaje de macros de SAS. Si no lo hacemos, todo lo que presentemos sobre el uso de macros será cada vez más 'oscuro'. 
Veamos: 
1.- Lenguaje de programación SAS: 
 incluye Pasos Data, Procs, Libnames, Options y demás.

funciona en 2 etapas: 

1. Compilación: entre otras cosas, chequea errores y transforma el programa a código de máquina. 
   Ejecución: trabaja propiamente con los datos. 
    2.- Lenguaje de macros de SAS: 

• incluye %Let, %Put, funciones macro y demás.
• funciona separadamente y ANTES de la etapa de Compilación.

 Desde ya, estos lenguajes se entrelazan. Con esto las posibilidades de programación se extienden de manera impensadas para los programadores que no usan macros.

Así como las variables macro llevan un símbolo '&' al principio, las funciones macro utilizan el símbolo '%' (el porcentaje) al principio. 
Esto distingue a las variables y funciones macro de las variables y funciones de programación 'comunes'.

Vayamos entonces a unos ejemplos. Verán que todos ellos corresponden a funciones alfanuméricas..... 
¡Por supuesto! Recuerden que estamos hablando de modificar el texto de un programa, no de trabajar con los datos.

Si buscan más información sobre estas funciones macro pueden mirar en: 
https://documentation.sas.com/doc/en/pgmsascdc/9.4_3.5/mcrolref/p1oqafzmrka91un13k8xwap0xv47.htm 
https://documentation.sas.com/doc/en/pgmsascdc/9.4_3.5/mcrolref/p1nhhymw6gxixvn1johcfl6kaygw.htm 
https://documentation.sas.com/doc/en/pgmsascdc/9.4_3.5/mcrolref/n0nq1hkovbu54en1h78i6ci7gz51.htm

*****************************************
* 							  			*
* 	Funciones macro (primera parte)		*
* 							  			*
****************************************;


/*----------------------*/
/* Ejemplo 1: 	 		*/
/* Función %UPCASE 		*/
/*----------------------*/

/* La función UPCASE transforma texto a mayúscula. Entonces la función 	*/
/* %UPCASE transformará el argumento (valor constante, variable común, 	*/
/* variable macro) a mayúscula.											*/

*%put _automatic_; /* es por si necesitan ver la lista de variables macro 
					automáticas */
%put &sysday;
%put %upcase(&sysday);
%put %upcase(miércoles); /* función macro aplicada a un valor constante */

/****************************************/
/* El Log muestra lo siguiente:			*/
/* 28         %put &sysday;				*/
/* Saturday								*/
/* 29         %put %upcase(&sysday);	*/
/* SATURDAY								*/
/* 30         %put %upcase(miércoles);	*/
/* MIÉRCOLES							*/
/****************************************/


/* ¿Y si utilizo upcase en vez de %upcase? */
%put upcase(miércoles);
 /* ¡'upcase(miércoles)' es un texto! La función upcase funciona, valga la 
redundancia, en la etapa de ejecución. Mucho después de cuando funciona %upcase */



/*----------------------*/
/* Ejemplo 2: 	 		*/
/* Función %SUBSTR 		*/
/*----------------------*/

/* La función SUBSTR extrae una subcadena de un texto. Por lo tanto la función	*/
/*  %SUBSTR hará lo mismo, pero antes de la compilación de un programa.			*/

%put _automatic_;  /* si necesitan ver la lista de variables macro automáticas */
%put Anio=%substr(&sysdate9,6);
%put Hora=%substr(&systime,1,2);

/************************************************/
/* El Log muestra lo siguiente:					*/
/* 29         %put Anio=%substr(&sysdate9,6);	*/
/* Anio=2023									*/
/* 30         %put Hora=%substr(&systime,1,2);	*/
/* Hora=00										/*
/************************************************/



/*--------------------------------------*/
/* Ejemplo 3.1: 	 					*/
/* Función %SCAN usando %Let y %Put		*/
/*--------------------------------------*/

/* Tal como lo hace la función SCAN, %SCAN devuelve una 'palabra' de una	*/
/* cadena de texto.															*/

%Let dataset_texto=¡sashelp.cars! Esta es la tabla que necesito;
%put tabla=%scan(&dataset_texto,2);
%put libreria=%scan(&dataset_texto,1, "¡!. ");  /*	lista personalizada de 
													delimitadores*/

/****************************************************************************************/
/* El Log muestra lo siguiente:												 			*/
/*28         %Let dataset_texto=¡sashelp.cars! Esta es la tabla que necesito;			*/
/*29         %put tabla=%scan(&dataset_texto,2);										*/
/*tabla=cars																			*/
/*30         %put libreria=%scan(&dataset_texto,1, "¡!. ");  /*	lista personalizada de	*/
/*libreria=sashelp																		*/
/*31         													delimitadores*/			*/
/****************************************************************************************/



/*--------------------------------------*/
/* Ejemplo 3.2: 	 					*/
/* Función %SCAN usando el Paso Data y	*/
/* Proc Print							*/
/*--------------------------------------*/

options symbolgen; /* para poder ver cómo resuelven las macros cuando operan */

data clase;
	set sashelp.class;
run;

proc print data=&syslast (obs=5);
	Title1 Tenemos la tabla %scan(&syslast,2);
	Title2 de la librería %scan(&syslast,1);
run;

options nosymbolgen; /* volvemos al log standard */

/********************************************************************/
/* El Log del proc print muestra lo siguiente:						*/
/* 34         proc print data=&syslast (obs=5);						*/
/* SYMBOLGEN:  La macro variable SYSLAST se resuelve en WORK.CLASE 	*/                          
/* 35         	Title1 Tenemos la									*/
/* SYMBOLGEN:  La macro variable SYSLAST se resuelve en WORK.CLASE 	*/                          
/* 35       !                    tabla %scan(&syslast,2);			*/
/* 36         	Title2 de la										*/
/* SYMBOLGEN:  La macro variable SYSLAST se resuelve en WORK.CLASE  */                         
/* 36       !               librería %scan(&syslast,1);				*/
/* 37         run;
/********************************************************************/



/*----------------------*/
/* Ejemplo 4: 	 		*/
/* Función %INDEX 		*/
/*----------------------*/

/* La función %INDEX devuelve la posición de una subcadena dentro de 	*/
/* un texto.															*/

%put tabla_pos=%INDEX(&dataset_texto,cars);
%put tabla_pos=%INDEX(&dataset_texto,esta); /*es case sensitive; cuando no encuentra 
										el texto buscado devuelve '0' (cero)*/
%put tabla_pos=%INDEX(&dataset_texto,Esta);
%Let letra=h;
%put tabla_pos=%INDEX(&dataset_texto,&letra); /*recuerden: ¡está haciendo reemplazos en 
										  el código!*/

/*****************************************************************************************************/
/* El Log del proc print muestra lo siguiente:														 */
/* 28         %put tabla_pos=%INDEX(&dataset_texto,cars);											 */
/* tabla_pos=10																						 */	
/* 29         %put tabla_pos=%INDEX(&dataset_texto,esta); /*es case sensitive; cuando no encuentra	 */
/* tabla_pos=0																						 */
/* 30         										el texto buscado devuelve '0' (cero)*/			 */
/* 31         %put tabla_pos=%INDEX(&dataset_texto,Esta);											 */
/* tabla_pos=16																						 */
/* 32         %Let letra=h;																			 */
/* 33         %put tabla_pos=%INDEX(&dataset_texto,&letra); /*recuerden: ¡está haciendo reemplazos en*/
/* tabla_pos=5																						 */
/* 34         										  el código!*/									 */
/*****************************************************************************************************/

Hemos visto ejemplos de funciones macro alfanuméricas. Este comienzo plantea varias preguntas, por ejemplo: 
1) Como estamos modificando texto (un programa) no tiene mucho sentido tener funciones macro que resuelvan cálculos numéricos. 
Pero... ¿y si necesitamos hacerlos? 
2) ¿Todas las funciones macro se escribirán agregando el símbolo de '%' al nombre de una función de las que ya conocemos? ¿Existirán %PROPCASE, %CATS y demás?

Intentaremos resolver estas 2 preguntas y otras más en los futuros Tips.

/*-------------------*/
/* fin del código 	 */
/*-------------------*/