op=
 Operadores Compostos -- binário                   (Atribuiçao)
--------------------------------------------------------------------------------

 Sintaxe

     <idVar>  += <cString>          (concatenaçao)
     <idVar>  += <nNumero>          (adiçao)

     <idVar>  -= <cString>          (concatenaçao)
     <idVar>  -= <nNumero>          (subtraçao)
     <idVar>  -= <dData>            (subtraçao)

     <idVar>  *= <nNumero>          (multiplicaçao)
     <idVar>  /= <nNumero>          (divisao)
     <idVar>  %= <nNumero>          (modulo)
     <idVar> **= <nNumero>          (exponenciaçao)

 Tipo:  Caractere, data, memo, numérico

 Operandos

     <idVar> é um identificador de variável de qualquer classe de
     armazenamento, inclusive variáveis de campo.  A variável deve ser
     inicializada antes de executar a operaçao.

     Se a referência a <idVar> for ambígua (ou seja, nao declarada em tempo
     de compilaçao e nao explicitamente qualificada com um alias), sempre é
     assumido que <idVar> é do tipo MEMVAR.  As variáveis de campo podem ser
     atribuidas declarando-se o nome da variável de campo em uma declaraçao
     FIELD, ou referindo-se ao nome de campo através do alias FIELD ou o
     nome da área de trabalho.

     <cString> é a cadeia de caracteres utilizada na operaçao com
     <idVar>.

     <nNúmero> é a expressao numérica utilizada na operaçao com
     <idVar>.

     <dData> é o valor data utilizado na operaçao com <idVar>.

 Descriçao

     Além dos operadores de atribuiçao simples (=) e in-line (:=), há uma
     série de operadores de atribuiçao compostos que executam uma operaçao e
     depois atribuem um valor.  Eles têm a forma:

     <idVar> <operador>= <exp>

     Cada expressao de atribuiçao composta é equivalente à expressao de
     atribuiçao:

     <idVar> := ( <idVar> <operador> <exp> )

     Para cada tipo de dados que suporta um operador, o operador de
     atribuiçao composto executa a mesma operaçao antes de executar a
     operaçao de atribuiçao.  A tabela a seguir detalha todos os operadores
     compostos:

     Tabela: Operadores de Atribuiçao Compostos
     ------------------------------------------------------------------------
     Operador       Definido como     Operaçoes
     ------------------------------------------------------------------------
     a += b         a := (a + b)      concatenaçao, adiçao
     a -= b         a := (a - b)      concatenaçao, subtraçao
     a *= b         a := (a * b)      multiplicaçao
     a /= b         a := (a / b)      divisao
     a %= b         a := (a % b)      módulo
     a **= b        a := (a **b)      exponenciaçao
     ------------------------------------------------------------------------

     ------------------------------------------------------------------------
     . Nota 

     O operador de exponenciaçao (^) nao possui um operador de atribuiçao
     correspondente.  O operador de atribuiçao composto de exponenciaçao  é
     **=.
     ------------------------------------------------------------------------

     Como os operadores de atribuiçao compostos sao baseados no operador de
     atribuiçao in-line (:=), a operaçao retorna o resultado de sua operaçao
     como o valor da expressao.  Isto significa que estes operadores podem
     ser utilizados dentro de expressoes, da mesma forma que o operador de
     atribuiçao in-line (:=).

 Exemplos

       Os exemplos a seguir demonstram o operador de concatenaçao e
        adiçao composto:

        // Caractere (concatenaçao)
        LOCAL cString := "Hello"
        ? cString += " there"                   // Resulta: "Hello there"

        // Data (adiçao)
        LOCAL dDate := CTOD("12/12/90")
        dDate += 12                             // Resulta: 12/24/90

        // Numérico (adiçao)
        LOCAL nValue := 10
        ? SQRT(nValue += 15)                    // Resulta:  5
        ? nValue                                // Resulta: 25

       Os exemplos a seguir demonstram o operador de atribuiçao de
        subtraçao e concatenaçao composto:

        // Caractere (concatenaçao)
        LOCAL cString := "Hello   "
        ? cString -= "There"                    // Resulta: HelloThere

        // Data (subtraçao)
        LOCAL dDate := CTOD("12/24/90")
        dDate -= 12                             // Resulta: 12/12/90

        // Numérico (subtraçao)
        LOCAL nValue := 10
        ? newValue := (nValue -= 5) ** 2        // Resulta: 25
        ? nValue                                // Resulta:  5

       O exemplo a seguir demonstra o operador de atribuiçao de
        multiplicaçao composto:

        LOCAL nValue := 10
        ? newValue := (nValue *= 5) + 100       // Resulta: 150
        ? nValue                                // Resulta:  50

       O exemplo a seguir demonstra o operador de atribuiçao de
        divisao composto:

        LOCAL nValue := 10
        ? newValue := (nValue /= 5) + 100       // Resulta: 102
        ? nValue                                // Resulta:   2

       O exemplo a seguir demonstra o operador de atribuiçao de
        módulo composto:

        LOCAL nValue := 10
        ? newValue := (nValue %= 4) * 100       // Resulta: 200
        ? nValue                                // Resulta:   2

       O exemplo a seguir demonstra o operador de atribuiçao de
        exponenciaçao composto:

        LOCAL nValue := 10
        ? newValue := (nValue **= 3) + 50       // Resulta: 1050
        ? nValue                                // Resulta: 1000
 To download this example - click here.

See Also: := + - * / % ** ++ --