AEVal

Executa um bloco de código para cada elemento de um array.

Sintaxe

AEval( < aArray >, < bBlock >, [ nStart ], [ nCount ] )

Parâmetros

Nome	Tipo	Descrição	Obrigatório
aArray	vetor	Indica o array que será lido.	X
bBlock	bloco de código	Indica o bloco de código que será executado para cada elemento encontrado.	X
nStart	numérico	Indica o elemento inicial.
nCount	numérico	Indica a quantidade de elementos que serão processados a partir do parâmetro nStart.

Retorno

Nome	Tipo	Descrição
aRet	vetor	Retorna uma cópia do array indicado por aArray após a operação.

Observações

Caso nStart não seja especificado, é considerado o valor 1.
Caso nCount não seja especificado, o padrão será todos os elementos do array a partir de nStart.
Caso aArray seja um array multi-dimensional, serão passados como parâmetros os arrays de primeiro nivel para bBlock.

Exemplos

Exemplo 1

#DEFINE CRLF Chr(13)+Chr(10)
#DEFINE TAB  Chr(09)

User Function aeval1()
  Local aMatriz := {}
  Local bBloco := { | nArg | nArg + 1 }
  Local cChar := "", cMensagem := ""
  Local lFound := .F.
  Local nCount := 0
  
  For nCount := 65 To 90
      AAdd( aMatriz, Chr( nCount ) )
  Next nCount
  
  //+----------------------------------------------------------------------------+
  //|Exemplifica o uso da função AEval                                           |
  //+----------------------------------------------------------------------------+
  
  cChar := "T"
  cMensagem += "Pesquisando [" + cChar + "] em " + CRLF
  
  AEval( aMatriz, { | aMatriz | cMensagem += aMatriz + " " } )
  cMensagem += CRLF
  
  lFound := .F.
  AEval( aMatriz, { | aMatriz | IIf( aMatriz == cChar, lFound := .T., ) } )
  cMensagem += "A partir da posição 01: " + IIf( lFound, "", "não " ) + "encontrado" + CRLF
  
  lFound := .F.
  AEval( aMatriz, { | aMatriz | IIf( aMatriz == cChar, lFound := .T., ) }, 21 )
  cMensagem += "A partir da posição 21: " + IIf( lFound, "", "não " ) + "encontrado" + CRLF
  
  lFound := .F.
  AEval( aMatriz, { | aMatriz | IIf( aMatriz == cChar, lFound := .T., ) }, 1, 19 )
  cMensagem += "A partir da posição 01 e até a posição 19: " + IIf( lFound, "", "não " ) + "encontrado" + CRLF
  
  lFound := .F.
  AEval( aMatriz, { | aMatriz | IIf( aMatriz == cChar, lFound := .T., ) }, 19, 2 )
  cMensagem += "A partir da posição 19 e até a posição 21: " + IIf( lFound, "", "não " ) + "encontrado" + CRLF
  
  //+----------------------------------------------------------------------------+
  //|Apresenta uma mensagem com os resultados obtidos                            |
  //+----------------------------------------------------------------------------+
Return MsgInfo(cMensagem, "AEval - Exemplo 1")

Exemplo 2

#DEFINE CRLF Chr(13)+Chr(10)

user function aeval2()
  //Este exemplo utiliza AEVAL() para fazer uma lista que consiste em
  // itens selecionados de um vetor multidimensional.
  
  Local aFiles := Directory( "\*.txt" ), aNames := {}
  Local cMensagem := ""
  
  AEval( aFiles,  { | file | AAdd( aNames, file[1] ) } )
  varinfo( "aNames", aNames )
  
  AEval( aNames, { | name | cMensagem += ( name + CRLF ) } )
  
return MsgInfo( cMensagem, "AEval - Exemplo 2" )

Exemplo 3

user function aeval3()
  Local aArray := { "Teste", 123 }
  Local bBlock := { | x, y | conout( x ), conout( valtype( x ) ), conout( y ) }
  Local nI := 0, nTotal := 0
  
  AEval( aArray, bBlock )
  
  // No exemplo acima, criamos um array com 2 elementos: O primeiro é um Caracter e o segundo é um número;
  // e criamos um code block que receberá em x (primeiro parametro fornecido pela função AEval)
  // cada elemento do array, e y (segundo parametro fornecido pela AEval) o número do elemento do array
  // que está sendo processado nesta execução.
  // 
  // O resultado de tela no console do Application Server deverá ser:
  // Teste --> Conteudo do primeiro elemento
  // C     --> Tipo do conteudo
  // 1     --> Numero do elemento processado
  // 123   --> Conteudo do segundo elemento
  // N     --> Tipo do Segundo Elemento
  // 2     --> Numero do elemento processado
  // 
  // Vejamos uma aplicação mais complexa: Em um array multi-dimensional temos 2 colunas,
  // uma de código (string) e uma de valor (numérica), e seja necessário realizar um cálculo
  // de totalização da coluna numérica:
  
  ASize( aArray, 0 )
  AAdd( aArray, { "Branco", 10 } )
  AAdd( aArray, { "Preto", 15 } )
  AAdd( aArray, { "Cinza", 12 } )
  
  // Podemos realizar a totalização pelo metodo tradicional:
  nTotal := 0
  For nI := 1 to len( aArray )
    nTotal := nTotal + aArray[nI][2]
  Next
  conout( nTotal ) // Vai exibir "37"
   
  // Ou utilizando a função AEval 
  nTotal := 0
  AEval( aArray, { | x | nTotal += x[2] } )
  conout( nTotal ) // Vai exibir os mesmos "37"
return