Tecnología TOTVS

Árvore de páginas

Versões comparadas

Versão antiga 2

changes.mady.by.user Izac Silverio Ciszevski

Gravado em

comparado com

Nova versão Atual

changes.mady.by.user Silvana Cristina Cavazzana Pagotto

Gravado em

Chave

  • Esta linha foi adicionada.
  • Esta linha foi removida.
  • A formatação mudou.
Comentário: Migration of unmigrated content due to installation of a new plugin

...

  • Caracteres
  • Fechas
  • Matemáticos
  • Relacionales
  • Lógicos
  • Atribuidores
  • Incrementadores
  • Especiales
  • Macro

Algunos operadores son unarios, es decir, sólo requieren un operando, mientras que otros son binarios, o sea, requieren dos operandos. Operandos son datos, variables, campos o funciones sobre los que actúan los operadores.

 

Operadores de Caracteres

 

Todos los operadores de caracteres son binarios, es decir, siempre actúan sobre dos expresiones de datos tipo carácter. Existen sólo dos operadores de caracteres:

...

El operador (+), también conocido como concatenación con blancos, une dos cadenas de caracteres en una sola. Por ejemplo:  

Sem Formato
cTexto1 :=

...

 “AdvPL     “
cTexto2 := “ – Lenguaje de programación de TOTVS”

...


cTexto3 := cTexto1 +

...

 

 cTexto2


MSGALERT(cTexto3)

...

  // Resulta:

...

 “AdvPL     - Lenguaje de programación de TOTVS”

 

El operador menos ( - ), concatenación sin blancos, también une dos cadenas de caracteres en una sola. No obstante, los espacios en blanco que preceden al operador se mueven hacia el final de la cadena de caracteres que lo sigue. Por ejemplo: 

Sem Formato
cTexto1 := “AdvPL“

...


cTexto2 :=

...

cTexto3 := cTexto1 + cTexto2

 

 “      Lenguaje de programación de TOTVS”
cTexto3 := cTexto1 + cTexto2


MSGALERT(cTexto3)

...

  // Resulta:

...

 

cTexto4 := cTexto1 – cTexto2

 

 “AdvPL      Lenguaje de programación de TOTVS”


cTexto4 := cTexto1 – cTexto2


MSGALERT(cTexto4)

...

  // Resulta: “AdvPLLinguaje de programación de TOTVS”

...

 
Operadores de Fechas
 
Datos tipo fecha se pueden sumar o sustraer en términos de número de días por medio de los operadores suma ( + ) y sustracción ( - ).
...
Una adición de días a una fecha genera una nueva fecha en el futuro, mientras que una sustracción de días genera una nueva fecha en el pasado. En este caso, es obligatorio que el dato tipo fecha sea el primer operando y el número de días sea el segundo. Por ejemplo: 
 Sem Formato
MSGALERT(DATE())
...
  	
// Suponiendo que la fecha actual es 31/12/11, esta fecha es la que se mostrará.
...



MSGALERT(DATE() + 1)
...
  	
// Resulta: 01/01/12
...



MSGALERT(DATE() – 1)
...
  	
// Resulta: 30/12/11
...



MSGALERT(1 + DATE())
...
  	
/ Resulta en error
 
Una sustracción entre dos fechas resulta en un número valor numérico representando el intervalo de días entre ellas. Por ejemplo: 
 Sem Formato
MSGALERT(CTOD(“19/12/90”) – CTOD(“25/12/90”))  
// Resulta: 6. Es decir, seis días de intervalo.
...
 
Operadores Matemáticos
 
Todos os operadores matemáticos, excepto los signos unarios positivo y negativo, son binarios y operan sobre expresiones o datos numéricos, que generan otros valores numéricos como resultado. Son los siguientes:
...
  1. Los operadores unarios: + (positivo) o (negativo)
  2. La potenciación ( ^ )
  3. El módulo ( % ), la multiplicación ( * ) y la divisción ( / )
  4. La adición ( + ) y la sustracción ( - ).

Los paréntesis se utilizan para agrupar operaciones y modificar la precedencia de  las operaciones. Por ejemplo:
 Sem Formato
MSGALERT(4 * 2 + 1)
...
  	
// Resulta 9
...


MSGALERT(4 *
...
  (2 + 1))  
// Resulta 12
 
Se pueden definir tantos niveles de paréntesis como sean necesario, siempre y cuando su balanceo esté correcto. Es decir, el número de abre paréntesis debe ser idéntico al número de cierra paréntesis.
 
 
Operadores Relacionales
 
Los operadores relacionales son binarios y generan resultados lógicos (verdadero o falso) a partir de la comparación entre dos expresiones.. Se pueden utilizar en expresiones numéricas, carácter, fecha o NIL.
 
Las expresiones relacionadas deben ser obligatoriamente del mismo tipo de dato. Los operadores relacionales del AdvPL son:
...
Cuando se relacionan dos expresiones por medio de dichos operadores, la expresión de la derecha se compara con la de la izquierda. El  resultado de esta comparación es un valor lógico verdadero (.T.) o falso (.F.). Por ejemplo:  
 Sem Formato
nNum1 := 100
...

nNum2 :=
...
 
 200


MSGALERT(nNum1 > nNum2)
...
  	
// Resulta falso (.F.), puesto que 100 no es mayor que 200.
...



MSGALERT(nNum2 > nNum1)
...
  	
// Resulta verdadero (.T.), puesto que 200 es mayor que 100.
...



MSGALERT(nNum1 <> nNum2)
...
  	
// Resulta verdadero (.T.), puesto que 100 es diferente de 200.
...
 



MSGALERT(“AdvPL” = “Adv”)
...
  	
// Resulta verdadero (.T.)
...


MSGALERT(“Apple”
...
 <> “Aple”)  	
// Resulta verdadero (.T.)
 
Los operadores relacionales poseen tan sólo una orden de precedencia en la que las operaciones se realizan: de izquierda a derecha.
...
El operador $ (subcadena o substring) opera solamente sobre expresiones del tipo carácter. Éste compara la expresión de la izquierda con la de la derecha, regresando verdadero si la expresión de la izquierda está contenida en la de la derecha o si las dos expresiones son idénticas. Por ejemplo: 
 Sem Formato
cTextoA := “AdvPL”
...

cTextoB := “Programas”
...

cTextoC := “Lenguaje para generar programas de
...
 
 TOTVS”


MSGALERT(cTextoA $ cTextoB)  
// Resulta falso (.F.)
...


MSGALERT(cTextoA $ cTextoC)  
// Resulta verdadero (.T.)
...


MSGALERT(cTextoB $ cTextoC)  
// Resulta verdadero (.T.)
...


MSGALERT(cTextoC $ cTextoA)  
// Resulta falso (.F.)
 
El operador doble igual (==) actúa de manera idéntica al operador igual (=) para expresiones numéricas o tipo fecha. En el caso de expresiones del tipo carácter, retornará verdadero sólo si la expresión de la derecha es exactamente idéntica a la expresión de la izquierda. Por ejemplo: 
 Sem Formato
cTextoA := “Adv”
...

cTextoB :=
...
 
 “AdvPL”


MSGALERT(cTextoB = cTextoA)  
// Resulta verdadero (.T.)
...


MSGALERT(cTextoB == cTextoA)  
// Resulta falso (.F.)
 
Cuando se comparan dos array, el operador doble igual (==) regresa verdadero (.T.) si ambos tienen el mismo contenido. Es decir, si son idénticos, teniendo los mismos elementos y valores.
 
 
Operadores Lógicos
 
Los operadores lógicos suministran valores lógicos (falso / .F. o verdadero / .T.) a partir de la comparación de dos expresiones lógicas, que son sus operandos. Excepto el operador .NOT. o !, todos son binarios.
 
Los operadores lógicos del AdvPL son:
...
  1. Negación (.NOT. o !)
  2. Conector Y (.AND.)
  3. Conector O (.OR.)

Los operadores lógicos relacionan dos expresiones lógicas. Los siguientes ejemplos demuestran algunos casos: 
 Sem Formato
nNumA := 100
...

nNumB := 200
...

nNumC :=
...
 
 300


MSGALERT(nNumB > nNumA .AND. nNumC > nNumB)  
// Resulta verdadero (.T.)
...


MSGALERT(nNumB > nNumA .AND. nNumB = nNumC)  
// Resulta falso (.F.)
...


MSGALERT(nNumB > nNumA .OR. nNumB = nNumC)  
// Resulta verdadero (.T.)
 
El operador .NOT. o ! (negación) es unario. Es decir, actúa sobre una sola expresión. Si la expresión es verdadera, la transformará en falsa y viceversa. Por ejemplo: 
 Sem Formato
lCont := .T.
...
 



MSGALERT( .NOT. lCont )  
// Resulta falso (.F.)
...


MSGALERT( ! lCont )  
// Resulta falso (.F.)
...
 



// Función para buscar el código del cliente
...

FUNCTION PesqCli(cCodigo)
...
 



dbSelectArea(“SA1”)
...

dbSetOrder(1)
...

dbSeek(cCodigo)
...
 
...



IF ! FOUND()
...
  // Si no se
...
          RETURN  // Finaliza
 encontró
          RETURN  // Finaliza
ENDIF
 
Para comprender mejor el resultado de los operadores lógicos, verifique en la siguientes tabla las situaciones en las que se entrega el resultado verdadero (.T.):
...
 
Operadores de Atribución
 
Los operadores de atribución relacionados a continuación, atribuyen valores o datos a las variables, campos o elementos de array:
...
El operador igual ( = ) atribuye un valor para una variable o campo de archivo de datos. El primer operando debe ser el nombre del campo de un archivo de datos o el nombre de una variable. Por ejemplo: 
 Sem Formato
nNum =
...
 100  
// Atribuye el valor 100 a la variable nNum
...


cNome = “Laércio
...
 Cosentino”  
// Atribuye la cadena de caracteres a la variable cNome
...


SA1->A1_NOME =
...
 cNome  
// Atribuye el contenido de la variable cNome al campo del archivo de clientes
 
El operador en línea ( := ) es similar al operador igual ( = ). Entretanto, éste se puede utilizar en cualquier comando o función cuya sintaxis permita el uso de una expresión. Por ejemplo: 
 Sem Formato
// Declara variables privadas y las ejecuta
...

PRIVATE nNum1 := 100
...

PRIVATE nNum2 :=
...
 
...
 300


IF (total := nNum1 + nNum2)
...
 > 300  	
// Condición utilizando el operador en
...
 
 línea

	SA1->A1_OBS := SPACE(30)
...
  		
	// Se graba 30 espacios en blanco en el campo del archivo de datos
 
ENDIF
 
 
Los operadores de atribución compuestos realizan una operación entre dos operandos y después atribuyen el resultado al primero. La siguiente tabla aclara como funciona. Note que todos los operadores compuestos son del tipo en línea.
...
Operador
Utilización
Operación
+=
A += B
A := A + B
-=
A -= B
A := A – B
*=
A *= B
A := A * B
/=
A /= B
A := A / B
%=
A %= B
A := A / B
^=
A ^= B
A := A ^ B
 
 
Operadores de Incremento y Decremento
 
Los operadores de incremento son unarios, es decir, operan sobre un único operando del tipo numérico o fecha. El operando debe ser el nombre de una variable y no debe ser un campo de archivo de datos. El tipo de dato que resulta de la operación será idéntico al del operando. La siguiente tabla muestra estos operadores y su operación
...
Al utilizarlos como prefijo modifican el operando antes de efectuar la atribución. Al utilizarlos como sufijo modifican el operando después de realizar la atribución. Los ejemplos ilustran algunas operaciones típicas con estos operadores. 
 Sem Formato
nNum1 := 0
...

nNum2 := ++nNum1
...


MSGALERT(nNum1)
...
 // Resulta 1
...

MSGALERT(nNum2)
...
	// Resulta
...
 
...
 1


nNum2 := 1
...

nNum4 := nNum2--
...


MSGALERT(nNum2)
...
	// Resulta 0
...

MSGALERT(nNum4)
...
	// Resulta
...
 
...
 1


nNum5 := 2
...

MSGALERT(nNum5++ * nNum5)
...
	// Resulta 6
...

MSGALERT(nNum5)
...
                 // Resulta
...
 
 3


MSGALERT(nNum6 := 2)
...

MSGALERT(--nNum6 * nNum6)
...
  	// Resulta 1
...

MSGALERT(nNum6)
...
                 // Resulta 1
 
 
Operadores Especiales
 
La siguiente tabla muestra los operadores especiales del AdvPL y su respectivo objetivo.
...
Por lo general, las operaciones se efectúan a partir de los paréntesis más internos hacia los más externos, siendo que inicialmente se ejecutan las operaciones matemáticas, seguidas de las comparaciones relacionales. Finalmente, se evalúan los conectores lógicos. Por ejemplo, el resultado de la siguiente expresión es verdadero (.T.).  
 Sem Formato
lResult := ( 4 * ( 3 + 5 ) ) / 2 > 100 .OR. ( 5 * ( 3 + 4 ) ) / 2 < 100
 
En la ejecución de funciones, los paréntesis se utilizan después del nombre identificador de la respectiva rutina, incluso la lista de argumentos. Por ejemplo: 
 Sem Formato
MSGALERT(SQRT(nNum1))
...
  	
// Muestra en la pantalla la raíz cuadrada del número contenido en la variable nNum1
...



MSGALERT(“¡Ésta es una prueba!”)
...
	
// Muestra un mensaje en la pantalla
...



MSGALERT(DATE())
...
	
// Muestra en la pantalla la fecha actual
 
Los corchetes ( [ ] ) se utilizan en referencia a elementos de array. Por ejemplo: 
 Sem Formato
PRIVATE aTeste[10, 10]
...
	
// Declara el array aTeste con 10 líneas y 10 columnas
...



aTeste[1, 1] :=
...
 100	
// Atribuye el valor 100 al primer elemento del array aTeste
...



MSGALERT(aTeste[1, 1])
...
	
// Muestra en la pantalla el valor de dicho elemento del array. Resulta 100.
 
Las llaves ( { } ) se utilizan para crear y referenciar matrices literales, sólo con una dimensión. Los elementos de la matriz deben estar entre las llames, separados por comas. Las claves se utilizan también en la creación de bloques de código. Por ejemplo: 
 Sem Formato
PRIVATE aMatriz := { 10, 20, 30, 40, 50, 98
...
 }  	
// Crea un array sólo con una dimensión


MSGALERT(aMatriz[3])
...
                    	
// Muestra el valor 30 en la
...
 
...
 pantalla


bBloco := { | nDado, nCoef | nDado * nCoef }
...
  	
// Crea un bloque de código con dos argumentos
 
El identificador de alias ( -> ) se utiliza para hacer una referencia explícita a un campo de archivos de datos. Si el nombre de un área de trabajo (alias) precede este operador, el mismo puede ser seguido por un nombre de campo de archivo de datos correspondiente o por cualquier expresión válida que contenga referencias al archivo de datos abierto en el área de trabajo, cuyo alías se especificó. Por ejemplo: 
 Sem Formato
SA1->A1_NOME :=
...
 cNome  
// Se refiere al campo A1_NOME de la tabla SA1 (Archivo de Clientes)
 
Finalmente, el operador de paso de parámetros por referencia ( @ ) se utiliza precediendo argumentos de funciones. Es un operador unario que opera como prefijo de nombres de variables, indicando que el argumento se está pasando por referencia, en lugar de hacerlo por valor, como es lo normal, para la función invocada. Por ejemplo: 
 Sem Formato
// Ejecuta (Invoca) la función Búsqueda, pasando
...
 los argumentos 
// cCod y cCodF por referencia.
Pesquisa(@cCod, @cCodF, “Códigos Deseados”, “999”)
 
Otro ejemplo de pasaje de parámetros por referencia con el uso del operador @: 
 Sem Formato
FUNCTION Main()
...
 
...



LOCAL nA := 0
...

LOCAL nB := 1
...

LOCAL nC := 2
...

LOCAL nX :=
...
 
...
 0


nX := Calculo(@nA, nB, nC)
...
 



MSGALERT(nX)
...
  // Resulta 6
...

MSGALERT(nA)
...
  // Resulta
...
 
 3


// El valor de la variable nA se modificó porque ésta fue pasada por referencia a la función Calculo()
...
 
RETURN NIL
 
// Función de cálculo
...



RETURN NIL


// Función de cálculo
FUNCTION Calculo(nParam1, nParam2, nParam3)
...
 
...



LOCAL nRetorno :=
...
 
...
 0


nParam1 := nParam2 + nParam3
...

nRetorno := nParam1 * nParam2 *
...
 
...
 nParam3


RETURN nRetorno
 
 
El Operador Macro ( & )
 
El operador macro permite compilar expresiones durante la ejecución de los programas y la sustitución del nombre de variables o expresiones tipo carácter por su contenido o resultado. Siempre que el operador macro ( & ) sea encontrado, la expresión se someterá al compilador del AdvPL
...
El operador macro ( & ) puede ejecutar sustituciones de textos o compilación de expresiones durante la ejecución de un programa, dependiendo de como se especifique. Por ejemplo:
 
Sustitución de textos
 
 Sem Formato
cMacro := “colega”
...
 


MSGALERT(“Cómo está “ + &(cMacro) + “?”)
...
  // Resulta: ¿Cómo va colega?
...
 


//En este otro ejemplo, se mostrará el nombre del cliente. 
//Por ejemplo, el puntero del índice del archivo
...

//está ubicado en el registro Carlos Alberto Montagnini. 
//En este caso, el mensaje será:
...

//¿Cómo está Ud., Carlos Alberto Montagnini?
...

MSGALERT(“Cómo está Ud.,“ + &(SA1->A1_NOME) + “?”)
 
Compilación de expresiones
 
 Sem Formato
cMacro := “DTOC(DATE())”
...
 



MSGALERT( &(cMacro) )
...
  // Resulta “22/05/12”
 
El operador macro no se puede utilizar para sustituir o compilar las palabras clave que identifican los comandos. Por ejemplo: 
 Sem Formato
cMacro :=
...
 
 “PRIVATE”


&(cMacro) nJuros :=
...
 0  // No es válido!!!
 
En el caso del alias de archivos de datos, no es necesario utilizar el operador macro ( & ). Basta utilizar el abre y cierra paréntesis. Por ejemplo: 
 Sem Formato
(cAlias)->TRB_VALOR
 
 
Orden de Precedencia de los Operadores
 
Cuando varios operadores distintos se utilizan en una misma expresión, el orden de precedencia para ejecutar las operaciones es:
...