manual_de_uso_geral_do_BFC-Script

Prévia do material em texto

Manual de uso geral do BFC-
Script 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Histórico de revisões 
 
Data Descrição da alteração 
12/04/2017 Criação deste manual. 
18/05/2017 Inclusão do item 8 e exemplo no item 3.2. 
29/05/2017 Inclusão dos itens 10.6 e 17. 
30/06/2017 Inclusão do sistema Tributos (Cloud) no item 20.1 
28/09/2017 Inclusão dos itens 3.6 e 9 
25/04/2018 Inclusão do item 19 referente às APIs de Assinatura e documentos. 
27/07/2018 Formatação integral do layout visual do manual e Inclusão do item 17.4 
referente a utilização de scripts do tipo componente. 
17/08/2018 Inclusão dos itens 22.1.1 referente aos sistemas e-Nota fly e 22.1.2 
Cidadão Web. 
21/09/2018 Inclusão dos itens 22.2.1.20 a 22.2.1.59 referente ao sistemas tributos 
(Cloud). 
02/10/2018 Inclusão do sistema Educação (Cloud) no item 22.2.2 
26/10/2018 Remoção de todas as fórmulas específicas dos sistemas do Manual. 
15/08/2019 - Inclusão no item 14.5 referente ao anexo() e anexo(id); 
- Inclusão do item 14.7; 
- Inclusão no item 14.8 referente ao exemplo 4; 
- Inclusão no item 17.2.12 referente ao DELETE; 
- Inclusão do item 20 referente a API de Execução. 
11/09/2019 - Inclusão de novas funções no item 9.5 Funções para manipulação de 
números referente a decimal e inteiro; 
- Alterado a descrição no item 9.5 Funções para manipulação de 
números referente a função numero; 
15/10/2019 - Inclusão do item 18.3 referente a Múltiplos assinantes na API de 
Assinatura. 
07/11/2019 - Inclusão no item 14.7 referente a padraoHex() 
 
 
 
 
 
 
 
 
SUMÁRIO 
 
 
A linguagem BFC-SCRIPT ...................................................................................................................................... 9 
1 Delimitadores ...................................................................................................................................................... 9 
1.1 Comentários de linha .................................................................................................................................. 9 
1.2 Comentários de bloco ................................................................................................................................. 9 
1.3 Operadores ................................................................................................................................................. 9 
1.3.1 Atribuição ( = ) ................................................................................................................................ 9 
1.3.2 Adição ( + ) ................................................................................................................................... 10 
1.3.3 Subtração ( - ) .............................................................................................................................. 10 
1.3.4 Operadores de multiplicação ( * ) ................................................................................................ 10 
1.3.5 Operadores de divisão ( / ) .......................................................................................................... 10 
1.3.6 Operadores de igualdade ( == ) ................................................................................................... 10 
1.3.7 Operadores de diferenciação ( != ) .............................................................................................. 11 
1.3.8 Operadores lógico OU ( || ) .......................................................................................................... 11 
1.3.9 Operadores lógico E ( && ) .......................................................................................................... 11 
2 Comandos ........................................................................................................................................................ 11 
2.1 imprimir ..................................................................................................................................................... 12 
2.2 percorrer ................................................................................................................................................... 12 
2.2.1 Controle do fluxo de execução .................................................................................................... 13 
2.2.2 parar() .......................................................................................................................................... 13 
2.2.3 continuar() .................................................................................................................................... 13 
2.2.4 Nomeando os comandos percorrer ............................................................................................. 13 
2.3 retornar ..................................................................................................................................................... 15 
2.4 se .............................................................................................................................................................. 15 
2.5 tentar/tratar/finalizar .................................................................................................................................. 15 
2.5.1 suspender .................................................................................................................................... 16 
2.5.2 esperar ......................................................................................................................................... 16 
2.5.3 exportar ........................................................................................................................................ 17 
2.5.4 importar ........................................................................................................................................ 17 
3 Listas ................................................................................................................................................................ 17 
4 Mapas ............................................................................................................................................................... 19 
5 Intervalos .......................................................................................................................................................... 20 
6 Datas ................................................................................................................................................................ 20 
7 Parâmetros ....................................................................................................................................................... 23 
8 Valores nulos .................................................................................................................................................... 23 
9 API padrão ........................................................................................................................................................ 25 
 
 
 
 
 
 
 
9.1 Funções para manipulação de caracteres................................................................................................ 25 
9.2 Expressões regulares ............................................................................................................................... 28 
9.2.1 equivalente() ................................................................................................................................ 28 
9.2.2 totalGrupos() ................................................................................................................................ 29 
9.2.3 dividir() ......................................................................................................................................... 29 
9.2.4 substituirPor(valor) .......................................................................................................................29 
9.2.5 substituirPrimeiroPor(valor) ......................................................................................................... 29 
9.2.6 encontrouPadrao() ....................................................................................................................... 29 
9.2.7 concatenarValoresEncontrados() ................................................................................................ 30 
9.2.8 concatenarValoresEncontrados(separador) ................................................................................ 30 
9.2.9 Caractere de escape .................................................................................................................... 30 
9.3 Múltiplas ocorrências e grupos ................................................................................................................. 31 
9.3.1 posicaoInicial() ............................................................................................................................. 32 
9.3.2 posicaoFinal() ............................................................................................................................... 32 
9.3.3 posicaoFinal() ............................................................................................................................... 32 
9.3.4 valoresGrupos() ........................................................................................................................... 32 
9.3.5 valorGrupo(indice) ....................................................................................................................... 32 
9.3.6 valorEncontrado()......................................................................................................................... 33 
9.3.7 concatenarValoresGrupos() ......................................................................................................... 33 
9.3.8 concatenarValoresGrupos(separador) ........................................................................................ 33 
9.4 Datas ......................................................................................................................................................... 34 
9.5 Funções para manipulação de números .................................................................................................. 37 
10 API de Arquivos ................................................................................................................................................ 38 
10.1 Leitura de arquivos ................................................................................................................................... 38 
10.2 Escrita de arquivos ................................................................................................................................... 39 
10.3 Download .................................................................................................................................................. 39 
10.4 Arquivos Texto (txt) ................................................................................................................................... 40 
10.4.1 Leitura .......................................................................................................................................... 40 
10.4.2 lerLinha() ...................................................................................................................................... 40 
10.4.3 contemProximaLinha() ................................................................................................................. 40 
10.4.4 Escrita .......................................................................................................................................... 40 
10.4.5 escrever(texto) ............................................................................................................................. 40 
10.4.6 novaLinha() .................................................................................................................................. 40 
10.5 Arquivos CSV (csv) ................................................................................................................................... 41 
10.5.1 Leitura .......................................................................................................................................... 41 
10.5.2 lerLinha() ...................................................................................................................................... 41 
10.5.3 contemProximaLinha() ................................................................................................................. 41 
10.5.4 pularLinhas(int linhas) .................................................................................................................. 41 
 
 
 
 
 
 
 
10.5.5 lerProximoValor() ......................................................................................................................... 41 
10.5.6 contemProximoValor() ................................................................................................................. 42 
10.5.7 Escrita .......................................................................................................................................... 42 
10.5.8 escrever(texto) ............................................................................................................................. 42 
10.5.9 novaLinha() .................................................................................................................................. 42 
10.6 Arquivos XML (xml) ................................................................................................................................... 43 
10.6.1 Leitura .......................................................................................................................................... 43 
10.6.1.1 tipo() ...................................................................................................................................... 43 
10.6.1.2 valor() .................................................................................................................................... 43 
10.6.1.3 contemValor() ....................................................................................................................... 44 
10.6.1.4 contemNome() ...................................................................................................................... 44 
10.6.1.5 nome() .................................................................................................................................. 44 
10.6.1.6 xml() ...................................................................................................................................... 44 
10.6.1.7 namespaces() ....................................................................................................................... 44 
10.6.1.8 contemNamespace(namespace) .......................................................................................... 44 
10.6.1.9 contemNamespace(namespace, prefixo) ............................................................................. 44 
10.6.1.10 atributos() ............................................................................................................................ 44 
10.6.1.11 contemAtributo(nome) ........................................................................................................ 45 
10.6.1.12 contemAtributo(nome, namespace) ................................................................................... 45 
10.6.1.13 contemAtributo(nome, namespace, prefixo) ...................................................................... 45 
10.6.1.14 atributo(nome) .................................................................................................................... 45 
10.6.1.15 atributo(nome,namespace) ................................................................................................ 45 
10.6.1.16 atributo(nome, namespace, prefixo) ................................................................................... 45 
10.6.1.17 ehTipoInicioDocumento ...................................................................................................... 45 
10.6.1.18 ehTipoFimDocumento ........................................................................................................ 45 
10.6.1.19 ehTipoTexto ........................................................................................................................ 45 
10.6.1.20 ehTipoComentario .............................................................................................................. 45 
10.6.1.21 ehTipoFimElemento............................................................................................................ 45 
10.6.1.22 ehTipoInicioElemento ......................................................................................................... 46 
10.6.1.23 ehTipoEspaco ..................................................................................................................... 46 
10.6.1.24 ehTipoCData ....................................................................................................................... 46 
10.6.1.25 ehTipoAtributo .................................................................................................................... 46 
10.6.1.26 ehTipoNamespace.............................................................................................................. 46 
10.6.1.27 contemProximo() ................................................................................................................ 46 
10.6.1.28 tipoProximo() ...................................................................................................................... 46 
10.6.1.29 proximo() ............................................................................................................................. 46 
10.6.1.30 proximaTag() ...................................................................................................................... 47 
10.6.1.31 contemProximoElemento() ................................................................................................. 47 
 
 
 
 
 
 
 
10.6.1.32 proximoElemento() ............................................................................................................. 47 
10.6.1.33 proximoElemento(nome) .................................................................................................... 47 
10.6.1.34 proximoElemento(nome, namespace) ................................................................................ 47 
10.6.2 Escrita .......................................................................................................................................... 48 
10.6.2.1 namespacePadrao(namespace) .......................................................................................... 48 
10.6.2.2 prefixo(prefixo, uri) ................................................................................................................ 48 
10.6.2.3 escreverAtributo(nome, valor) .............................................................................................. 48 
10.6.2.4 escreverAtributo(nome, valor, namespace) ......................................................................... 48 
10.6.2.5 escreverAtributo(nome, valor, namespace, prefixo) ............................................................. 48 
10.6.2.6 escreverCData(data) ............................................................................................................ 48 
10.6.2.7 escreverTexto(texto) ............................................................................................................. 48 
10.6.2.8 escreverComentario(comentario) ......................................................................................... 49 
10.6.2.9 escreverNamespace(namespace) ........................................................................................ 49 
10.6.2.10 escreverNamespace(namespace, prefixo) ......................................................................... 49 
10.6.2.11 escreverDTD(dtd) ............................................................................................................... 49 
10.6.2.12 escreverElementoVazio(elemento) .................................................................................... 49 
10.6.2.13 escreverElementoVazio(elemento, namespace) ................................................................ 49 
10.6.2.14 escreverElementoVazio(elemento, namespace, prefixo) ................................................... 49 
10.6.2.15 escreverInicioDocumento() ................................................................................................. 49 
10.6.2.16 escreverInicioDocumento(encoding) .................................................................................. 49 
10.6.2.17 escreverInicioDocumento(encoding, versao) ..................................................................... 49 
10.6.2.18 escreverInicioDocumento(encoding, versao, standalone) ................................................. 49 
10.6.2.19 escreverFimDocumento() ................................................................................................... 50 
10.6.2.20 escreverInicioElemento(nome) ........................................................................................... 50 
10.6.2.21 escreverInicioElemento(nome, namespace) ...................................................................... 50 
10.6.2.22 escreverInicioElemento(nome, namespace, prefixo) ......................................................... 50 
10.6.2.23 escreverFimElemento() ...................................................................................................... 50 
10.6.2.24 nomeElementoAtual() ......................................................................................................... 50 
10.6.2.25 escreverFimElementos() .................................................................................................... 50 
10.6.2.26 escreverFimElementos(elementoParar) ............................................................................. 50 
10.6.2.27 escreverElementoTexto(nome, valor) ................................................................................ 51 
10.6.2.28 escreverElementoTexto(nome, valor, namespace) ............................................................ 51 
10.6.2.29 escreverElementoTexto(nome, valor, namespace, prefixo) ............................................... 51 
10.6.2.30 escrever(xml) ...................................................................................................................... 51 
10.6.2.31 contemElementoAberto() .................................................................................................... 51 
10.6.2.32 escreverReferencia(nome, id, valor) .................................................................................. 51 
10.6.2.33 escreverInstrucaoProcessamento(target, conteudo) ......................................................... 51 
10.6.2.34 escreverEspaco(conteudo) ................................................................................................. 51 
 
 
 
 
 
 
 
10.6.2.35 escreverEspacoIgnoravel(conteudo) .................................................................................. 51 
10.7 Arquivos ZIP (zip) ..................................................................................................................................... 52 
10.7.1 Leitura .......................................................................................................................................... 52 
10.7.2 Escrita ..........................................................................................................................................52 
10.7.2.1 criarDiretorio ......................................................................................................................... 52 
10.7.2.2 adicionar(Arquivo) ................................................................................................................. 53 
10.7.2.3 adicionar(Arquivo, Nome do arquivo no zip) ........................................................................ 53 
10.7.2.4 adicionar(Arquivo, Nome do arquivo no zip, Diretório) ......................................................... 53 
10.7.2.5 adicionar(Lista de arquivos) ................................................................................................. 53 
10.7.2.6 adicionar(Lista de arquivos, Diretório) .................................................................................. 54 
10.7.2.7 comentario(Comentário) ....................................................................................................... 54 
11 API de E-mail .................................................................................................................................................... 54 
11.1 Mensagem ................................................................................................................................................ 55 
11.2 Anexos ...................................................................................................................................................... 55 
11.3 Exemplos .................................................................................................................................................. 57 
12 API de Notificações .......................................................................................................................................... 59 
12.1 Mensagem ................................................................................................................................................ 59 
13 API de Mensagens ........................................................................................................................................... 60 
14 API de SOAP .................................................................................................................................................... 61 
14.1 Serviço ...................................................................................................................................................... 61 
14.1.1 Soap.servico(url) .......................................................................................................................... 61 
14.1.2 Soap.servico(url, namespace, prefixo) ........................................................................................ 61 
14.1.3 Soap.servico(url, namespace, prefixo, usuario, senha)............................................................... 62 
14.1.4 Soap.criarNamespace(namespace, prefixo) ............................................................................... 62 
14.1.5 cabecalho(nome, valor) ............................................................................................................... 62 
14.1.6 mensagem() ................................................................................................................................. 62 
14.1.7 mensagem(namespace, prefixo) ................................................................................................. 62 
14.1.8 mensagem(namespace) .............................................................................................................. 62 
14.1.9 tempoLimite(valor) ....................................................................................................................... 63 
14.2 Mensagem ................................................................................................................................................ 63 
14.2.1 namespace(namespace, prefixo)................................................................................................. 63 
14.2.2 namespace(namespace) ............................................................................................................. 63 
14.2.3 namespaces() .............................................................................................................................. 63 
14.2.4 namespacePadrao() .................................................................................................................... 63 
14.2.5 corpo() .......................................................................................................................................... 63 
14.2.6 corpo(conteudo) ........................................................................................................................... 63 
14.2.7 corpo(arquivo) .............................................................................................................................. 63 
14.2.8 cabecalho() .................................................................................................................................. 64 
 
 
 
 
 
 
 
14.2.9 cabecalho(conteudo) ................................................................................................................... 64 
14.2.10 cabecalho(arquivo) ...................................................................................................................... 64 
14.2.11 operacao(operacao) ..................................................................................................................... 64 
14.2.12 executar() ..................................................................................................................................... 64 
14.2.13 executar(operacao) ...................................................................................................................... 64 
14.2.14 requisicao() .................................................................................................................................. 64 
14.3 Elementos ................................................................................................................................................. 65 
14.3.1 nome() .......................................................................................................................................... 65 
14.3.2 namespace() ................................................................................................................................ 65 
14.3.3 adicionarElemento(nome) ............................................................................................................ 65 
14.3.4 adicionarElemento(nome, namespace, prefixo) .......................................................................... 65 
14.3.5 adicionarElemento(nome, namespace) ....................................................................................... 65 
14.3.6 adicionarTexto(texto) ................................................................................................................... 65 
14.3.7 adicionarElementoTexto(nome, texto) ......................................................................................... 66 
14.3.8 adicionarElementoTexto(nome, texto, namespace, prefixo) ....................................................... 66 
14.3.9 adicionarElementoTexto(nome, texto, namespace) .................................................................... 66 
14.3.10 adicionarAtributo(nome, valor) ..................................................................................................... 66 
14.3.11 adicionarAtributo(nome, valor, namespace, prefixo) ................................................................... 66 
14.3.12 adicionarAtributo(nome, valor, namespace) ................................................................................ 67 
14.3.13 adicionarNamespace(namespace, prefixo) ................................................................................. 67 
14.3.14adicionarNamespace(namespace) .............................................................................................. 67 
14.3.15 elementoAnterior() ....................................................................................................................... 67 
14.3.16 contemElementoAnterior() ........................................................................................................... 67 
14.3.17 proximoElemento() ....................................................................................................................... 67 
14.3.18 contemProximoElemento() .......................................................................................................... 68 
14.4 Métodos .................................................................................................................................................... 68 
14.5 Resposta ................................................................................................................................................... 69 
14.6 Base 64 ..................................................................................................................................................... 70 
14.6.1 Contornando a limitação cumulativa ............................................................................................ 72 
14.7 Hash .......................................................................................................................................................... 72 
14.8 Exemplos .................................................................................................................................................. 74 
15 API de Fonte de Dados .................................................................................................................................... 77 
15.1 Ativo .......................................................................................................................................................... 77 
15.2 Tema ......................................................................................................................................................... 77 
15.3 Operações ................................................................................................................................................ 78 
15.3.1 Operação de busca ...................................................................................................................... 78 
15.3.2 Operação de criação .................................................................................................................... 79 
15.3.3 Operação de atualização ............................................................................................................. 79 
 
 
 
 
 
 
 
15.3.4 Operação de exclusão ................................................................................................................. 80 
16 API de Scripts ................................................................................................................................................... 80 
16.1 Executando scripts .................................................................................................................................... 80 
16.1.1 identificador .................................................................................................................................. 80 
16.1.2 executar(parametros) ................................................................................................................... 80 
16.1.3 variaveis(Map) .............................................................................................................................. 81 
16.2 Retorno dos scripts ................................................................................................................................... 83 
16.2.1 valor ............................................................................................................................................. 83 
16.2.2 vazio ............................................................................................................................................. 83 
16.2.3 variavel(nome) ............................................................................................................................. 83 
16.2.4 retornar ......................................................................................................................................... 84 
16.3 Executando scripts em lotes ..................................................................................................................... 84 
16.4 Componentes ............................................................................................................................................ 85 
17 API de HTTP..................................................................................................................................................... 89 
17.1 Requisição ................................................................................................................................................ 89 
17.1.1 cookie(nome, valor) ..................................................................................................................... 90 
17.1.2 cookie(nome, valor, caminho, domínio, versão) .......................................................................... 90 
17.1.3 cookie(Mapa[nome, valor]) .......................................................................................................... 90 
17.1.4 cabecalho(nome, valor) ............................................................................................................... 90 
17.1.5 cabecalho(nome, lista de valores) ............................................................................................... 90 
17.1.6 cabecalho(Mapa[nome, valor]) .................................................................................................... 90 
17.2 Parâmetros e caminhos ............................................................................................................................ 90 
17.2.1 parametro(nome, valor) ............................................................................................................... 91 
17.2.2 parametro(nome, lista de valores) ............................................................................................... 91 
17.2.3 parametro(Mapa[nome, valor]) .................................................................................................... 91 
17.2.4 caminho(caminho) ....................................................................................................................... 92 
17.2.5 aceitarTipoMidia(midias) .............................................................................................................. 92 
17.2.6 credenciais(usuario, senha) ......................................................................................................... 92 
17.2.7 tempoLimite(valor) ....................................................................................................................... 92 
17.2.8 GET (Mapa[marcadores]) ............................................................................................................ 93 
17.2.9 OPTIONS (Mapa[marcadores]) ................................................................................................... 93 
17.2.10 HEAD (Mapa[marcadores]) .......................................................................................................... 93 
17.2.11 TRACE (Mapa[marcadores]) ....................................................................................................... 93 
17.2.12 DELETE ....................................................................................................................................... 93 
17.2.13 POST ...........................................................................................................................................94 
17.2.14 PUT .............................................................................................................................................. 94 
17.2.15 PATCH ......................................................................................................................................... 95 
17.2.16 METODO ..................................................................................................................................... 96 
 
 
 
 
 
 
 
17.3 Formulários ............................................................................................................................................... 96 
17.3.1 Formulario .................................................................................................................................... 96 
17.3.2 parametro(nome, valor) ............................................................................................................... 97 
17.3.3 parametro(Mapa[nome, valor]) .................................................................................................... 97 
17.3.4 POST() - POST(Mapa[marcadores]) ........................................................................................... 97 
17.3.5 PUT() - PUT(Mapa[marcadores]) ................................................................................................. 97 
17.3.6 PATCH() - PATCH(Mapa[marcadores]) ...................................................................................... 97 
17.3.7 METODO(método) - METODO(método, Mapa[marcadores]) ..................................................... 97 
17.4 Formulario Multipart .................................................................................................................................. 98 
17.4.1 parametro ..................................................................................................................................... 98 
17.4.2 POST() - POST(Mapa[marcadores]) ........................................................................................... 98 
17.4.3 PUT() - PUT(Mapa[marcadores]) ................................................................................................. 98 
17.4.4 PATCH() - PATCH(Mapa[marcadores]) ...................................................................................... 98 
17.4.5 METODO(método) - METODO(método, Mapa[marcadores]) ..................................................... 98 
17.5 Resposta ................................................................................................................................................... 99 
17.5.1 codigo() ........................................................................................................................................ 99 
17.5.2 tipoMidia() .................................................................................................................................... 99 
17.5.3 ehJson() ....................................................................................................................................... 99 
17.5.4 sucesso() ...................................................................................................................................... 99 
17.5.5 tamanho() ..................................................................................................................................... 99 
17.5.6 contemResultado() ..................................................................................................................... 100 
17.5.7 ultimaModificacao() .................................................................................................................... 100 
17.5.8 cookie(nome) ............................................................................................................................. 100 
17.5.9 contemCookie(nome) ................................................................................................................. 100 
17.5.10 cookies() ..................................................................................................................................... 100 
17.5.11 cabecalho(nome) ....................................................................................................................... 100 
17.5.12 contemCabecalho(nome) ........................................................................................................... 101 
17.5.13 cabecalhos() ............................................................................................................................... 101 
17.5.14 imprimir() .................................................................................................................................... 101 
17.5.15 conteudo() .................................................................................................................................. 101 
17.5.16 arquivo() ..................................................................................................................................... 101 
17.5.17 json() .......................................................................................................................................... 102 
18 API de Assinatura ........................................................................................................................................... 102 
18.1 Assinando documentos........................................................................................................................... 102 
18.2 Assinando lote de documentos ............................................................................................................... 103 
18.3 Múltiplos assinantes ................................................................................................................................ 104 
18.4 Script de call-back ................................................................................................................................... 105 
19 API de Critério ................................................................................................................................................ 105 
 
 
 
 
 
 
 
19.1 Criação .................................................................................................................................................... 105 
19.2 Operações .............................................................................................................................................. 106 
19.2.1 Obrigatoriedade dos valores ...................................................................................................... 106 
19.3 Delimitador nas operações contidoEm/naoContidoEm .......................................................................... 107 
19.3.1 Com delimitador ......................................................................................................................... 107 
19.3.2 Sem delimitador ......................................................................................................................... 107 
19.3.3 Com formatação e delimitador ................................................................................................... 107 
19.4 Filtros compostos .................................................................................................................................... 108 
19.5 Agrupamento .......................................................................................................................................... 108 
19.6 Datas ....................................................................................................................................................... 108 
19.6.1 Informar uma das formatações pré-definidas (data e hora) ...................................................... 108 
19.6.2 Informar uma formatação customizada .....................................................................................109 
20 API de Execução ............................................................................................................................................ 109 
20.1 Consultar o protocolo da execução ........................................................................................................ 109 
20.2 Consultar se a execução foi cancelada pelo usuário ............................................................................. 109 
20.3 Exemplos ................................................................................................................................................ 109 
21 Integração de APIs ......................................................................................................................................... 109 
21.1 Integrando com uma aplicação ............................................................................................................... 109 
21.2 Executando um script ............................................................................................................................. 109 
21.2.1 Passando parâmetros para um script ........................................................................................ 111 
21.2.1.1 Beans .................................................................................................................................. 111 
21.2.1.2 Coleções ............................................................................................................................. 112 
21.2.1.3 NullsafeProxy ...................................................................................................................... 112 
21.3 Anotações ............................................................................................................................................... 113 
21.4 Metadados .............................................................................................................................................. 114 
21.5 Obtendo dados de um script ................................................................................................................... 116 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9 
 
A linguagem BFC-SCRIPT 
 
O bfc-script é um framework que possibilita a integração de scripts com aplicações. O framework oferece 
um ambiente de desenvolvimento, compilação e execução de scripts, bem como uma linguagem amigável para 
usuários não técnicos e APIs utilitárias. 
A linguagem possui poucos comandos e algumas similaridades com a linguagem JavaTM, como os 
operadores (lógico, comparação, atribuição e aritmético), o uso de chaves para circundar blocos, sintaxe case 
sensitive, etc. 
Para simplificar os scripts, não é necessário usar ponto e vírgula no final de cada instrução e os 
comandos foram desenvolvidos em português, para simplificar o seu uso a usuários sem experiência em 
linguagens de programação. 
 
1 Delimitadores 
 
Os delimitadores têm função importante no editor de Scripts. Através deles torna-se possível adicionar 
comentários de linha e bloco, ou seja, pode-se incluir notas aos scripts para descrever o que se quiser. Assim, 
não modificam o programa executado e servem somente para ajudar o programador a melhor organizar os 
códigos. 
 
1.1 Comentários de linha 
 
Comentário de linha, como o próprio nome diz, são notas que podem ser incluídas nas linhas do código 
fonte, com objetivo de ajudar o programador a organizar seu código. Ou seja, pode-se descrever o que se quiser, 
pois os comentários não modificam os scripts. 
Eles podem ser representados da seguinte forma: 
 
// comentario 
 
1.2 Comentários de bloco 
 
Os comentários de bloco tem a mesma função do comentário de linha, exceto por ponderações longas 
que ocupam várias linhas. Isso pode ser representado da seguinte forma: 
 
/* comentário 
em bloco */ 
 
1.3 Operadores 
 
Os operadores indicam ao script a necessidade de se fazer manipulações matemáticas ou lógicas. 
 
1.3.1 Atribuição ( = ) 
 
Este operador indica a atribuição de um determinado valor a uma variável, como mostra os exemplos 
abaixo: 
 
Atribuição de um valor para uma variável 
 
valor = 10 
 imprimir 'O valor é: ' + valor 
 
 
 
 
 
10 
 
Atribuição de uma string para uma variável 
 
nome = 'Antônio da Silva' 
imprimir nome 
 
1.3.2 Adição ( + ) 
 
O operador de adição (+) poderá ser utilizado em diversas situações não somente em cálculos 
aritméticos, mas também em concatenações de strings. 
 
Exemplo 
valor = 5 + 1 
imprimir 'Resultado: ' + (valor + 4) 
 
1.3.3 Subtração ( - ) 
 
O operador de subtração (-) subtrai um determinado valor de outro. 
 
Exemplo 
valor1 = 10 
valor2 = 20 
imprimir 'Resultado: ' + (valor2 - valor1) 
 
1.3.4 Operadores de multiplicação ( * ) 
 
O operador de multiplicação (*) efetua a multiplicação de um valor por outro. 
 
Exemplo 
valor1 = 10 
valor2 = 20 
imprimir 'Resultado: ' + (valor2 * valor1) 
 
1.3.5 Operadores de divisão ( / ) 
 
O operador de divisão (/) divide um determinado número por outro. 
 
Exemplo 
valor1 = 200 
valor2 = 4 
imprimir 'Resultado: ' + (valor1 / valor2) 
 
 
 
 
1.3.6 Operadores de igualdade ( == ) 
 
O operador de igualdade verifica se uma determinada expressão ou valor é igual a outro. Geralmente 
este operador é utilizado em comandos se … senao … ou onde houver necessidade de se utilizar uma 
comparação. 
 
 
 
 
 
 
11 
 
Exemplo 
valor = 'S' 
 
se ( valor == 'S' ){ 
 imprimir 'O valor é ...' 
}senao{ 
 imprimir O valor não é...' 
} 
 
1.3.7 Operadores de diferenciação ( != ) 
 
O operador de diferenciação ( != ) verifica se uma determinada expressão ou valor é diferente de outro. 
Geralmente é utilizado em comandos como se … senão ... ou onde houver necessidade de se utilizar 
comparação. 
 
Exemplo 
se (valor != 'S'){ 
 imprimir 'Valor do imposto está sendo retido' 
}senao{ 
 imprimir 'Valor do imposto não está sendo retiro' 
} 
 
1.3.8 Operadores lógico OU ( || ) 
 
O operador lógico OU ( || ) é utilizado para comparar duas expressões, sendo o resultado verdadeiro 
quando uma das duas expressões forem verdadeiras. Geralmente é utilizado em comandos se … senão … ou 
onde houver necessidade de se utilizar uma comparação. 
 
Exemplo 
se (valor1.vazio || valor2.vazio){ 
 suspender 'Os valores estão vazios ...' 
} 
 
1.3.9 Operadores lógico E ( && ) 
 
O operador lógico E ( && ) é utilizado para comparar duas expressões, sendo o resultado verdadeiro 
quando as duas expressões forem verdadeiras. Geralmente é utilizado em comandos se … senão … ou onde 
houver necessidade de se utilizar uma comparação. 
 
Exemplo 
se (valor1.vazio && valor2.vazio){ 
 suspender 'Informe os valores ...' 
} 
2 Comandos 
 
A seguir, temos a lista de todos os comandos que podem ser utilizados no desenvolvimento dos scripts 
juntamente com alguns exemplos de utilização. 
 
 
 
 
 
 
12 
 
2.1 imprimir 
 
Exibe uma mensagem no console. 
1. imprimir 'John Doe' 
2.2 percorrer 
 
Permite iterar valores e obter o índice atual da iteração. 
1. percorrer(ate:5){ 
2. imprimir indice 
3. } 
O comando disponibiliza uma variável implícita chamada indice que representa o índice corrente da 
iteração. 
1. percorrer(de:3, ate:5){ 
2. imprimir indice 
3. } 
A variável indice pode ser atribuída a uma outra variável com um nome personalizado, permitindo que a 
mesma seja acessada em diversos níveis do comando percorrer. 
1. percorrer(de:3, ate:5){ idPrincipal -> 
2. imprimir idPrincipal 
3. percorrer(de:6, ate:8){ idSecundario -> 
4. imprimir 'ID princial: ' + idPrincipal 
5. imprimir 'ID secundário: ' + idSecundario 
6. } 
7. } 
É possível também iterar pelos valores de uma lista informando ou não o índice inicial e final da iteração 
1. numeros = [1,2,3] 
2. percorrer(de:1,ate:3, itens: numeros){ 
3. imprimir item 
4. } 
5. // Irá imprimir os números 1, 2 e 3 
1. letras = ['A','B','C'] 
2. percorrer(de:2, ate:3, itens: letras){ 
3. imprimir item 
4. } 
5. // Irá imprimir as letras B e C, ou seja, do índice 2 até o índice 3 
 
 
 
 
 
13 
 
• Caso o índice inicial não seja informado irá utilizar como padrão o valor 1 (primeiro item). 
• Caso o índice final não seja informado irá utilizar como padrão o índice final da lista (último item). 
 
2.2.1 Controle do fluxo de execução 
 
O fluxo de execução de um comando percorrer pode ser alterado utilizando as 
funções parar() e continuar(). Este controle é especialmente útil quando se deseja interromper a execução de 
um comando percorrer devido à uma condição específica ou avançar para um próximo item do laço. 
 
2.2.2 parar() 
 
A função parar interrompe um comando percorrer em determinada condição, e continua a execução do 
script sem passar pelas repetições seguintes. 
O seguinte código irá imprimir os números 1, 2 e a palavra Ok: 
1. numeros = [1,2,3,4] 
2. percorrer(numeros){ 
3. se(item == 3){ 
4. parar() 
5. } 
6. imprimir item 
7. } 
8. 
9. //As instruções fora do comando percorrer serão executadas normalmente, somente o c
omando percorrer 
10. //será interrompido e não todo o script 
11. imprimir 'Ok' 
2.2.3 continuar() 
 
A função continuar faz com que o comando percorrer passe para a próxima repetição/item. Esta função 
é especialmente útil em situações em que se deseje ignorar o processamento de um item com base em uma 
condição. 
O seguinte código irá imprimir os números 1, 2 e 4 ignorando o número 3: 
1. numeros = [1,2,3,4] 
2. percorrer(numeros){ 
3. se(item == 3){ 
4. continuar() 
5. } 
6. imprimir item 
7. } 
2.2.4 Nomeando os comandos percorrer 
 
Em situações onde são utilizados mais de um comando percorrer aninhados e se 
deseje parar ou continuar um percorrer específico, a atribuição de um nome ao comando se faz necessário. 
Para nomear o comando basta preencher a propriedade nome na declaração da instrução: 
 
 
 
 
 
14 
 
1. numeros = [1,2,3,4] 
2. percorrer(itens: numeros, nome: 'p1'){ 
3. imprimir 'p1: ' + item 
4. percorrer(de: 1, ate: 5){ 
5. se (indice == 3){ 
6. parar 'p1' 
7. } 
8. imprimir 'p2: ' + indice 
9. } 
10. } 
A saída do script será: 
1. p1: 1 // primeiro item da lista de números do percorrer 'p1' 
2. p2: 1 // primeiro índice do segundo percorrer 
3. p2: 2 // ... 
4. p2: 3 // ... 
5. p2: 4 // No índice 4 o comando parar 'p1' foi executado interrompendo a execução de 
todos os comandos percorrer até o 'p1' 
A mesma regra se aplica ao comando continuar(), porém ao invés de interromper a execução do 
comando percorrer irá avançar para o próximo índice/item. 
1. numeros = [1,2,3] 
2. percorrer(itens: numeros, nome: 'p1'){ 
3. imprimir 'p1: ' + item 
4. percorrer(de: 1, ate: 5, nome: 'p2'){ 
5. se (indice == 2){ 
6. continuar 'p1' 
7. } 
8. imprimir 'p2: ' + indice 
9. } 
10. } 
A saída do script será: 
 
1. p1: 1 // primeiro item da lista de números do percorrer 'p1' 
2. p2: 1 // primeiro índice do segundo percorrer 
3. // Ao passar pelo segundo ídice o comando continuar 'p1' foi execuado parando 
a execução do percorrer atual e avançando o item do 
4. // percorrer 'p1' para a próxima iteração, neste caso o número 2 
5. p1: 2 
6. p2: 1 
7. p1: 3 
8. p2: 1 
 
 
 
 
 
15 
 
2.3 retornar 
 
Permite submeter dados como retorno de um script. 
Conforme podemos observar, a variável valor é submetida como retorno do script utilizando o comando 
retornar. 
1. valor = 10 * 2 * 3 
2. retornar valor 
No exemplo abaixo, os valores são retornados pelo comando retornar através de um mapa. As chaves 
valor e nome recebem seus respectivos valores e são submetidas ao comando retornar e serão resgatadas 
programaticamente através de um java.util.Map. 
1. retornar valor:10 * 2 * 3, nome:'David Crosby' 
2.4 se 
 
Permite criar expressões condicionais. 
1. se(10 == 10){ 
2. imprimir 'verdadeiro' 
3. } 
4. 
5. se(9 <= 20){ 
6. imprimir 'verdadeiro' 
7. }senao{ 
8. imprimir 'falso' 
9. } 
2.5 tentar/tratar/finalizar 
 
Às vezes, a execução de uma ação pode acarretar em uma exceção. Quando isto ocorre, é possível que 
seja realizado um tratamento para que o script continue sua execução realizando alguma outra ação, como por 
exemplo, notificar outros usuários, tratar alguns retornos conhecidos, tentar realizar a ação novamente, etc. 
No bloco tentar devem ser colocadas as ações onde pode ocorrer um erro. Por exemplo, chamar um 
serviço HTTP, SOAP, escrever em um arquivo, etc. 
Dentro do bloco tratar deve ser especificado o código que será executado em caso de erro dentro do 
bloco tentar. Nele, existe uma variável chamada excecao que é uma representação do erro ocorrido. Ela possui 
os seguintes atributos: 
codigo - É um identificador alfanumérico erro para facilitar sua localização nos manuais e documentações 
mensagem - Uma mensagem passada pela API ou linguagem que representa a descrição do erro 
ocorrido 
linha - Linha onde ocorreu o erro 
1. tentar { 
2. resultado = Http.servico('https://endereco-nao-existe').GET() 
3. imprimir resultado.codigo() 
4. } tratar { 
 
 
 
 
 
16 
 
5. // Ao mandar imprimir o objeto excecao, será impresso o código, mensagem e linha 
(se existir) 
6. imprimir 'Estou tratando uma exceção: ' + excecao 
7. } 
Ainda é possível que independentemente de ocorrer uma falha ou não, ao final da execução do método 
seja executada alguma ação. Para isso, existe também o bloco finalizar. Onde tudo o que for definido neste 
bloco, será executado independentemente de ocorrer um erro ou não. 
1. tentar { 
2. resultado = Http.servico('https://endereco-nao-existe').GET() 
3. imprimir resultado.codigo() 
4. } tratar { 
5. // Ao mandar imprimir o objeto excecao, será impresso o código, mensagem e linha 
(se existir) 
6. imprimir 'Estou tratando uma exceção: ' + excecao 
7. } finalizar { 
8. imprimir 'O conteúdo deste bloco sempre será executado' 
9. } 
Algumas observações referentes à este recurso: 
 
• O bloco finalizar sempre é executado 
• Dentro do bloco finalizar, a variável excecao já não está disponível 
• O comando suspender não é tratado 
 
2.5.1 suspender 
 
Permite suspender a execução de um script com uma exceção. 
1. se(codigo != 10){ 
2. suspender "O código $codigo é inválido" 
3. } 
 
2.5.2 esperar 
 
O comando esperar permite que a execução de um script entre em modo de pausa por um determinado 
intervalo tempo. 
Este comando se mostra útil quando o acesso a um serviço é limitado por um intervalo de tempo. 
1. imprimir Datas.hoje() 
2. esperar 2000 //O script irá pausar a execução neste ponto durante 2000 millisegundo
s 
3. imprimir Datas.hoje() 
É possível informar o intervalo de tempo utilizando a forma simplificada de tempo/datas da engine: 
http://test.betha.com.br/documentacao/bfc-script/2.7.X/index.html#datas
 
 
 
 
 
17 
 
1. imprimir Datas.hoje() 
2. esperar 1.segundo //O script irá pausar a execução neste ponto durante 1 segundo 
3. imprimir Datas.hoje() 
O tempo máximo de espera permitido por comando é de 60 segundos. Essa função está disponível ao 
usuário final apenas através da Ferramenta de Scripts. 
 
2.5.3 exportar 
 
Comando utilizado para exportar símbolos declarados no escopo atual. Aceita como parâmetro um mapa 
com o nome externo e uma referência ao recurso exportado. 
1. // exportando uma constante 
2. exportar PI_APROXIMADO: 3.1415 
3. 
4. // exportando múltiplos símbolos 
5. exportar( 
6. nomeExterno: referencia, 
7. outroNome: outraReferencia 
8. ) 
Este comando está disponível apenas na Ferramenta de Scripts. 
 
2.5.4 importar 
 
Comando utilizado para importar recursos de um componente. Aceita como parâmetro uma String com 
onome do identificador do componente desejado, e retorna um objeto com os recursos importados. 
1. log = importar("log") 
2. math = importar("calculadora") 
3. counter = importar("contador") 
4. 
5. log.info("Iniciando execução") 
6. acum = 0 
7. 
8. percorrer(ate: 20) { 
9. counter.incrementar() 
10. acum = math.somar(acum, indice) 
11. log.info("Executando operação #$indice") 
12. } 
Este comando está disponível apenas na Ferramenta de Scripts. 
 
3 Listas 
 
Também conhecida como Arrays, podemos trabalhar com listas de maneira bem simplificada. 
 
 
 
 
 
18 
 
1. //Instancia uma lista com valores 
2. valores = [0, 1, 2, 3, 4] 
3. 
4. //Instancia uma lista vazia 
5. nomes = [] 
6. 
7. //Adiciona um item na lista 
8. nomes << 'Chuck Norris' 
9. 
10. //Itera uma lista 
11. percorrer(valores){ 
12. imprimir item 
13. } 
14. 
O comando percorrer possui uma variável implícita para obter o valor da iteração chamada item. 
A variável item e indice podem ser atribuídas à outras variáveis com nomes personalizados utilizando a 
seguinte sintaxe do comando percorrer: 
1. percorrer(valores){ valor -> 
2. imprimir valor 
3. } 
4. 
5. percorrer(valores){ valor, posicao -> 
6. imprimir valor // Equivale a item 
7. imprimir posicao // Equivale a indice 
8. } 
9. 
10. percorrer(valores){ item, posicao -> 
11. imprimir item 
12. percorrer(outros){ 
13. imprimir item //Equivale ao item do percorrer principal pois utilizou o mes
mo nome da variável implícita 
14. } 
15. } 
Obtendo e atribuindo valores em posições específicas da lista. A primeira posição da lista tem o índice 0 
(zero), a segunda posição tem o índice 1, e assim por diante. Os dados são acessados assim: lista[indice] 
1. //Instancia uma lista com valores 
2. nomes = ['Harrison Reid', 'Thomas Sharpe', 'Louie Hill'] 
3. 
4. //nomes[0] contém o valor 'Harrison Reid' 
5. //nomes[1] contém o valor 'Thomas Sharpe' 
6. //nomes[2] contém o valor 'Louie Hill' 
7. 
 
 
 
 
 
19 
 
8. //Obtendo o nome da segunda posição da lista: 
9. nomeDaSegundaPosicao = nomes[1] 
4 Mapas 
 
É possível criar mapas simplificados e acessar seus valores de forma explícita. 
1. pessoa = [nome:'João da Silva', idade:25, profissao: 'Contador'] 
2. 
3. imprimir pessoa.nome 
4. imprimir pessoa.idade 
5. imprimir pessoa.profissao 
Observe o exemplo abaixo, usando uma lista de mapas: 
1. //Declaração da lista. Será composta por um mapa que contém o nome, a idade e a pro
fissão. 
2. dadosPessoais = [] 
3. 
4. //Adicionando dados à lista 
5. dadosPessoais << [nome:'Luca Ingram', idade:25, profissao: 'Process pipeline drafte
r'] 
6. dadosPessoais << [nome:'Jack Young', idade:30, profissao: 'Industrial economist'] 
7. dadosPessoais << [nome:'Jake Sullivan', idade:31, profissao: 'Gastroenterology nurs
e'] 
8. 
9. //Imprimindo os dados... 
10. percorrer(dadosPessoais) { 
11. imprimir 'Posição: ' + indice + ' -> Dados:' + item 
12. } 
13. 
14. //Temos o resultado: 
15. Posição: 0 -> Dados:[nome:Luca Ingram, idade:25, profissao:Process pipeline drafter
] 
16. Posição: 1 -> Dados:[nome:Jack Young, idade:30, profissao:Industrial economist] 
17. Posição: 2 -> Dados:[nome:Jake Sullivan, idade:31, profissao:Gastroenterology nurse
] 
18. 
19. //Agora, vamos alterar última posição da lista com novos dados. 
20. //Jake Sullivan trocou de profissão e precisamos atualizar seu dado profissional. F
azemos isso substituindo um mapa por outro: 
21. dadosPessoais[2] = [nome:'Jake Sullivan', idade:31, profissao: 'Administrative lead
er'] 
22. 
23. //Voltamos a imprimir. Resultado: 
 
 
 
 
 
20 
 
24. Posição: 0 -> Dados:[nome:Luca Ingram, idade:25, profissao:Process pipeline drafter
] 
25. Posição: 1 -> Dados:[nome:Jack Young, idade:30, profissao:Industrial economist] 
26. Posição: 2 -> Dados:[nome:Jake Sullivan, idade:31, profissao:Administrative leader] 
27. 
28. //Outro exemplo: Preciso saber a idade do segundo profissional da lista, Jack Young
: 
29. imprimir dadosPessoais[1].idade 
30. //Resultado: 30 
5 Intervalos 
 
Intervalos permitem que você crie uma lista de valores sequenciais podendo ser utilizados como listas. 
A notação define um intervalo, do primeiro item até o último. Intervalos definidos com a notação.< incluem o 
primeiro valor, mas não o último valor. 
1. //Cria um intervalo 
2. dias = 1..3 
3. 
4. //Percorre um intervalo 
5. percorrer(dias){ 
6. imprimir item 
7. } 
8. 
9. //Percorre um intervalo 
10. percorrer(4..7){ 
11. imprimir item 
12. } 
13. 
14. //Percorre um intervalo de forma decrescente 
15. percorrer(8..7){ 
16. imprimir item 
17. } 
18. 
19. //Percorre um intervalo decrescente desconsiderando o último valor 
20. percorrer(6..<4){ 
21. imprimir item 
22. } 
23. 
O comando percorrer possui uma variável implícita para obter o valor da iteração chamada item. 
 
6 Datas 
 
A linguagem permite trabalhar com datas de forma simplificada. Várias funções estão embutidas nos 
elementos de data facilitando muito o uso, além de tornar as implementações intuitivas. Os exemplos abaixo 
 
 
 
 
 
21 
 
demonstram o uso de algumas funções para manipulação de datas, além de demonstrar formas nativas para 
somar datas/horas/etc. 
1. //Funções para obter-se uma data/dataHora 
2. hoje = Datas.hoje() 
3. primeiroDiaDoAno = Datas.data(hoje.ano,1 ,1 ) 
4. ultimoDiaDoAno = Datas.dataHora(hoje.ano, 12, 31, 23, 59) 
5. 
6. imprimir Datas.adicionaSegundos(hoje, 10) 
7. imprimir hoje + 10.segundos 
8. 
9. imprimir Datas.adicionaMinutos(hoje, 10) 
10. imprimir hoje + 10.minutos 
11. 
12. imprimir Datas.adicionaHoras(hoje, 10) 
13. imprimir hoje + 10.horas 
14. 
15. imprimir Datas.adicionaDias(hoje, 10) 
16. imprimir hoje + 10.dias 
17. 
18. imprimir Datas.adicionaMeses(hoje, 10) 
19. imprimir hoje + 10.meses 
20. 
21. imprimir hoje + 1.segundo 
22. imprimir hoje + 1.minuto 
23. imprimir hoje + 1.hora 
24. imprimir hoje + 1.dia 
25. imprimir hoje + 1.mes 
26. 
27. imprimir hoje + 10.anos + 9.meses + 8.semanas + 7.dias + 6.horas + 5.minutos + 4.se
gundos + 3.milesegundos 
28. 
29. imprimir Datas.ano(hoje) 
30. imprimir hoje.ano 
31. imprimir Datas.mes(hoje) 
32. imprimir hoje.mes 
33. imprimir Datas.dia(hoje) 
34. imprimir hoje.dia 
35. imprimir Datas.hora(hoje) 
36. imprimir hoje.hora 
37. imprimir Datas.minuto(hoje) 
38. imprimir hoje.minuto 
39. imprimir Datas.segundo(hoje) 
40. imprimir hoje.segundo 
41. 
42. imprimir Datas.diaSemana(hoje) 
 
 
 
 
 
22 
 
43. imprimir hoje.diaSemana 
44. 
45. imprimir Datas.removeDias(hoje, 10) 
46. imprimir hoje - 10.dias 
47. 
48. imprimir Datas.removeMeses(hoje, 10) 
49. imprimir hoje - 10.meses 
50. 
51. imprimir Datas.extenso(hoje) 
52. imprimir hoje.extenso 
53. 
54. imprimir Datas.nomeDiaSemana(hoje) 
55. imprimir hoje.nomeDiaSemana 
56. 
57. imprimir Datas.nomeMes(hoje) 
58. imprimir hoje.nomeMes 
59. 
60. imprimir Datas.ehData('01/01/2010') 
61. 
62. imprimir Datas.diferencaAnos(primeiroDiaDoAno, ultimoDiaDoAno) 
63. imprimir Datas.diferencaDias(primeiroDiaDoAno, ultimoDiaDoAno) 
64. imprimir Datas.diferencaHoras(primeiroDiaDoAno, ultimoDiaDoAno) 
65. imprimir Datas.diferencaMeses(primeiroDiaDoAno, ultimoDiaDoAno) 
66. imprimir Datas.diferencaMinutos(primeiroDiaDoAno, ultimoDiaDoAno) 
67. imprimir Datas.diferencaSegundos(primeiroDiaDoAno, ultimoDiaDoAno) 
68. 
69. amanha = hoje + 1.dia 
70. 
71. //Podemos criar intervalos com datas 
72. percorrer(hoje..amanha){ 
73. imprimir item.extenso 
74. } 
75. 
76. percorrer(hoje+1.semana..<amanha+2.semanas){ 
77. imprimir item.extenso 
78. } 
79. 
80. //Podemos obter uma data apartir de uma expressão como esta 
81. semanaQueVem = 7.dias.apartirDe.hoje 
82. 
83. imprimir semanaQueVem + 5.diasÉ importante notar que os valores numéricos informados nas funções de data para representar ano, mês, 
dias, horas e segundos, diferentemente da formatação Brasileira, não devem conter zeros à esquerda: 
 
 
 
 
 
 
23 
 
1. //Correto 
2. Datas.data(2017, 8, 5) 
3. 
4. //Incorreto (Erro de compilação) 
5. Datas.data(2017, 08, 05) 
7 Parâmetros 
 
A linguagem permite manipular os valores dos parâmetros informados pelos usuários de forma 
simplificada, através da função parametros.nomedoparametro.selecionado.valor. 
 
parametros.mes.selecionado.valor 
Pega o valor do parâmetro mês, selecionado pelo usuário. 
 
parametros.ExercicioPPA.selecionado.valor 
Pega o valor do parâmetro ExercicioPPA, selecionado pelo usuário. 
 
8 Valores nulos 
 
Em programação de computadores, null é um valor especial para um ponteiro (ou qualquer outro tipo de 
referência) que indica que este ponteiro, intencionalmente, não se refere a um objeto (ponteiro nulo). 
Este recurso se mostra útil para identificar quando um valor não está disponível, assumindo um valor 
próprio para este comportamento, o nulo ou vazio. 
A palavra reservada nulo representa o valor para este comportamento, de modo que no exemplo abaixo 
estamos dizendo que a variável valorCusto é igual a nulo ou em outras palavras, que seu valor é vazio. 
1. valorCusto = nulo 
2. 
Um script pode receber variáveis com valores nulo, onde em certas ocasiões é necessário checar se o 
valor da variável é nulo ou não. Podemos realizar as checagens de duas formas: 
1. valorCusto = nulo 
2. 
3. // Forma 1 
4. se (valorCusto != nulo){ 
5. imprimir ("A variável valorCusto não está nula.") 
6. } 
7. 
8. // Forma 2 
9. se (valorCusto){ 
10. imprimir ("A variável valorCusto não está nula.") 
11. } 
12. 
13. se (!valorCusto){ 
14. imprimir ("A variável valorCusto está nula.") 
15. } 
 
 
 
 
 
24 
 
16. 
17. se (valorCusto && funcionario.agenciaBancaria){ 
18. imprimir ("A variável valorCusto a a agência bancária do funcionário não es
tão nulas.") 
19. } 
20. 
O acesso às referências nulas gera erros durante a execução de um script. No exemplo abaixo, 
suponhamos que a agência bancária do funcionário esteja nula: 
1. nomeFuncionario = funcionario.agenciaBancaria.nome 
2. 
Ao tentar obter o nome de uma agência bancária nula, recebemos um erro de execução: A 
propriedade nome não é acessível em um elemento nulo. Para evitar este comportamento, podemos utilizar o 
operador de navegação segura (?): 
1. nomeFuncionario = funcionario.agenciaBancaria?.nome 
2. 
O operador deve ser utilizado em diversos níveis de uma referência, caso seja apropriado: 
1. nomeFuncionario = funcionario.agenciaBancaria?.municipio?.nome 
2. 
3. // valor impresso 'null' 
4. imprimir(nomeFuncionario) 
5. 
No exemplo acima, caso não utilizassemos o operador (?) no município (municipio?.nome), receberiamos 
um erro durante a execução, devido ao fato de que a agenciaBancária esta nula. Como resultado final o valor da 
variável nomeFuncionario é nula. 
Em algumas ocasiões, gostariamos de considerar um valor padrão onde o resultado seria nulo. Para este 
propósito utilizamos a expressão ternária (?:), como podemos observar abaixo: 
1. nomeFuncionario = funcionario.agenciaBancaria?.municipio?.nome 
2. 
3. imprimir(nomeFuncionario?:'Sem nome') 
4. 
No exemplo acima, quando o valor da variável nomeFuncionario for nulo, o valor retornado será Sem 
nome. 
Poderiamos usar esta expressão diretamente, conforme o exemplo abaixo: 
1. nomeFuncionario = funcionario.agenciaBancaria?.municipio?.nome?:'Sem nome' 
2. 
3. imprimir(nomeFuncionario) 
4. 
 
 
 
 
 
25 
 
 
9 API padrão 
 
A engine padrão disponibiliza uma API com várias funções utilitárias para manipulação de datas, 
caracteres e números. As funções são separadas por classes e são invocadas como métodos. Alguns métodos 
para manipulação de datas e caracteres podem ser utilizados de maneira direta, invocando o método a partir do 
próprio elemento, não necessitando a invocação através da classe. 
Este capítulo abordará detalhes de cada função da API padrão. Essas funções estarão disponíveis ao 
usuário final e serão absorvidas plenamente conforme a utilização. 
 
9.1 Funções para manipulação de caracteres 
 
A seguir são descritas todas as funções disponíveis para a manipulação de caracteres. Da mesma forma 
que para as funções de manipulação de números, serão apresentadas as funções, sua descrição e sintaxe em 
uma tabela, a fim de facilitar o entendimento. 
 
 
FUNÇÃO DESCRIÇÃO / OBJETIVO SINTAXE 
capitaliza 
 
Por meio desta função é possível colocar a 
primeira letra de cada palavra de um texto 
em maiúsculo e as outras letras para 
minúsculo. 
Caracteres.capitaliza(texto) 
OU 
texto.capitaliza 
direita 
Obtém uma quantidade específica de 
caracteres iniciados da direita para 
esquerda. 
Caracteres.direita(texto, quantidade) 
OU 
texto.direita(quantidade) 
dividir 
Esta função divide um texto de acordo com a 
expressão regular informada. 
Caracteres.dividir("boa|tarde", ~/\|/) //[boa, 
tarde] 
OU 
valor.dividir(~/\|/) 
equivalente 
Verifica se uma expressão está contida em 
um texto. 
Caracteres.equivalente(texto, expressao) 
OU 
texto.equivalente(expressao) 
esquerda 
Obtém uma quantidade específica de 
caracteres iniciados da esquerda para 
direita. 
Caracteres.esquerda(texto, quantidade) 
OU 
texto.esquerda(quantidade) 
 
maiusculo 
 
Converte todos os caracteres de um texto 
em maiúsculo. 
 
Caracteres.maiusculo(texto) 
OU 
texto.maiusculo 
minusculo 
Converte todos os caracteres de um texto 
em minúsculo. 
 
Caracteres.minusculo(texto) 
OU 
texto.minusculo 
posicao 
Obtém a posição onde um caracter se 
encontra em uma texto. 
Caracteres.posicao(texto, expressao, 
posicaoInicio) 
OU 
texto.posicao(expressao, posicaoInicio) 
posicaoFinal 
Obtem a posição final de uma expressão 
regular em um texto. 
Caracteres.posicaoFinal(texto, expressao 
regular, posicaoInicio) 
OU 
texto.posicaoFinal(expressao regular, 
posicaoInicio) 
 
 
 
 
 
26 
 
removeEspacos Remove o excesso de espaços de um texto. 
Caracteres.removeEspacos(texto) 
OU 
texto.removeEspacos 
removeEspacosDireita 
Remove o excesso de espaços de um texto 
a esquerda. 
 
Caracteres.removeEspacosDireita(texto) 
OU 
texto.removeEspacosDireita 
removeEspacosEsquerda 
Remove o excesso de espaços de um texto 
à direita. 
Caracteres.removeEspacosEsquerda(texto) 
OU 
texto.removeEspacosEsquerda 
 
sobrepor 
Sobrepõe um texto em outro em uma 
determinada posição e com uma quantidade 
específica de caracteres. 
Caracteres.sobrepor(texto, posicaoInicial, 
quantidadeSobrepor, textoSobrepor) 
OU 
texto.sobrepor(posicaoInicial, 
quantidadeSobrepor, textoSobrepor) 
substituir 
Substitui as ocorrências de uma expressão 
localizada em um texto por outra expressão. 
 
Caracteres.substituir(texto, textoLocalizar, 
textoSubstituir) 
OU 
texto.substituir(textoLocalizar, textoSubstituir) 
subTexto 
Obtém um número específico de caracteres 
de uma posição específica de um texto. 
Caracteres.subTexto(texto, inicio, tamanho) 
OU 
texto.subTexto(inicio, tamanho) 
tamanho Obtém o tamanho de um texto. 
Caracteres.tamanho(texto) 
OU 
texto.tamanho 
vazio 
Verifica se uma palavra está vazia. 
 
Caracteres.vazio(valor) 
OU 
valor.vazio 
repetir 
Repete um texto especificado de acordo com 
uma quantidade definida. 
Caracteres.repetir(texto, repeticao) 
OU 
texto.repetir(repeticao) 
 
Um exemplo prático de utilização do Repetir é para completar os caracteres de um campo de um leiaute 
bancário. Por exemplo, no leiaute tem o campo nome com 100 caracteres, porém, se o nome não tiver 100 
caracteres, então, o campo deve ser preenchido com espaços em branco à direita.