{"id":1309,"date":"2015-09-11T12:38:58","date_gmt":"2015-09-11T16:38:58","guid":{"rendered":"http:\/\/linguagemprisma.net\/blog\/?page_id=1309"},"modified":"2017-02-21T10:30:00","modified_gmt":"2017-02-21T14:30:00","slug":"tutorial-principais-funcoes-prisma","status":"publish","type":"page","link":"https:\/\/linguagemprisma.br4.biz\/blog\/tutorial-principais-funcoes-prisma\/","title":{"rendered":"Tutorial – Principais fun\u00e7\u00f5es Prisma"},"content":{"rendered":"

Unidade II – Biblioteca padr\u00e3o<\/strong><\/h1>\n

\"prisma_library\"<\/a><\/p>\n

Introdu\u00e7\u00e3o<\/strong><\/h2>\n

 <\/p>\n

Prisma, assim como outras linguagens, possui fun\u00e7\u00f5es predefinidas, e que ficam organizadas em conjuntos chamados\u00a0de biblioteca.\u00a0Bibliotecas, tamb\u00e9m chamadas libs, podem ser internas ou\u00a0externas.<\/p>\n

As internas\u00a0s\u00e3o as embutidas no interpretador Prisma, e por isso n\u00e3o precisam ser importadas com o comando ‘inclua’.<\/p>\n

Todas as outras bibliotecas externas que precisam ser inclu\u00eddas n\u00e3o s\u00e3o predefinidas, portanto \u00e9 necess\u00e1rio\u00a0carreg\u00e1-las na execu\u00e7\u00e3o do programa prisma.<\/p>\n

Bibliotecas s\u00e3o importantes pois potencializam o poder da linguagem, \u00e9 com suas fun\u00e7\u00f5es que \u00e9 poss\u00edvel escrever programas\u00a0mais complexos.<\/p>\n

Aqui ser\u00e3o tratadas o conjunto de biblioteca padr\u00e3o, isto \u00e9, somente as internas, s\u00e3o elas:<\/p>\n

base, string, mat, sis, es, tabela<\/strong><\/p>\n

A biblioteca “win” com fun\u00e7\u00f5es da api do Windows fica em um tutorial separado, clique aqui para acessar.<\/a><\/p>\n

<\/h2>\n

<\/h2>\n
\n

<\/h2>\n

<\/h2>\n

<\/h2>\n

Cap. 1 – Fun\u00e7\u00f5es da biblioteca base<\/strong><\/h2>\n

 <\/p>\n

S\u00e3o as fun\u00e7\u00f5es simples tais como a imprima( ) ; tipo ( ) entre outras. Elas n\u00e3o seguem o modelo\u00a0das demais que usam o nome da biblioteca e o ponto separando o m\u00e9todo.<\/p>\n

Veja as fun\u00e7\u00f5es e seus exemplos de uso:<\/p>\n

<\/h3>\n

\u00a0imprima ( … )<\/strong><\/h3>\n

Exibe na tela preta do cmd no Windows ou terminal no Linux \u00a0texto ou n\u00fameros. Podemos passar v\u00e1rios argumentos de uma s\u00f3 vez separados por v\u00edrgulas;<\/p>\n

\u00a0 ex.:<\/p>\n

imprima(\"Ola Mundo!\");\r\nimprima(\"Ola \" , \"Mundo \" , \"Em Prisma!\" );\r\nimprima(\"Ola\\nMundo\\nEm\\nPrisma\");\r\n\r\nimprima('\\97\\98\\99') \/\/sa\u00edda: abc\r\n<\/pre>\n
Note que com a barra invertida ‘\\’ \u00e9 poss\u00edvel passar o c\u00f3digo e a sa\u00edda ser\u00e1 o caractere correspondente ao c\u00f3digo num\u00e9rico<\/p>\n
Note tamb\u00e9m que \\n \u00a0faz a impress\u00e3o ir para linha seguinte.<\/p>\n
 <\/p>\n
<\/h3>\n
leia ( )<\/strong><\/h3>\n
Uma vers\u00e3o simples do es.leia( )<\/strong> (que trataremos adiante), a fun\u00e7\u00e3o leia aguarda o usu\u00e1rio digitar algo e retorna o que foi digitado,\u00a0podendo ser armazenado em uma vari\u00e1vel do seguinte modo:<\/p>\n
poe \"Digite algo: \";\r\n\r\nalgo = leia ( );\r\n\r\npoe ( algo ); \r\n\/\/sa\u00edda ser\u00e1 aquilo que o usu\u00e1rio digitar;\r\n\r\n<\/pre>\n
\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 tipo ( valor )
\n<\/strong><\/h3>\n
Esta fun\u00e7\u00e3o retorna uma string descrevendo o tipo de valor. Muito \u00fatil para sabermos qual tipo de vari\u00e1vel \u00e9 um dado. Valor<\/em><\/strong> pode\u00a0ser uma vari\u00e1vel ou diretamente um valor. Exemplos de uso:<\/p>\n
  \r\ns = \"ol\u00e1 mundo\";\r\nn = 12;\r\nf = 2.4;\r\ng = {};\r\nbol = falso;\r\nfuncao ola () \r\n  imprima'ola';\r\nfim\r\n\r\nimprima( tipo(s) , tipo(n) , tipo(f) , tipo(g) , tipo(bol) , tipo(ola), 1250 );\r\n\r\n\/\/sa\u00edda: string numero numero tabela boolean funcao numero\r\n\r\nse tipo(9) == \"numero\" entao\r\n   imprima'\u00e9 um n\u00famero');\r\nsenao\r\n   imprima'n\u00e3o \u00e9 um n\u00famero';\r\nfim\r\n\r\n<\/pre>\n
\u00a0<\/span><\/span><\/strong><\/h2>\n
\n
<\/h2>\n
Aproveitando aqui veja algumas vari\u00e1veis predefinidas importantes:<\/span>
\n<\/span><\/strong><\/h2>\n
\u00a0<\/strong><\/p>\n
\u00a0* _versao –<\/strong> vari\u00e1vel que guarda a vers\u00e3o de prisma, tente executar: imprima( _versao );<\/strong><\/p>\n
\u00a0* prismadir<\/strong> – vari\u00e1vel que guarda o diret\u00f3rio do execut\u00e1vel prisma: imprima ( prismadir );<\/strong><\/p>\n
OBS – prismadir n\u00e3o funciona no Linux se o interpretador estiver no diret\u00f3rio bin.<\/em><\/span><\/p>\n
\u00a0* args –<\/strong>\u00a0 \u00e9 uma tabela<\/strong><\/em> dos argumentos externos passados como par\u00e2metros em linha de comando:<\/p>\n
imprima (  args [ 0 ] ); \r\n\/\/ imprime o nome do programa prisma sendo executado.\r\n\r\nimprima ( args [-1] );\r\n\/\/imprime o nome do interpretador, \r\n\/\/que pode ser o prisma.exe ou o igprisma.exe;\r\n\/\/ no linux prisma\r\n\r\n<\/pre>\n
<\/h3>\n
\n
<\/h3>\n
Voltando para as fun\u00e7\u00f5es da biblioteca base<\/span><\/h3>\n
\u00a0<\/strong> poe ( string )<\/h3>\n
\u00a0\u00a0 V\u00eam do verbo p\u00f4r (poe, ingl\u00eas = put ), coloca na tela preta o resultado, \u00e9 o mesmo que a fun\u00e7\u00e3o imprima, mas com limita\u00e7\u00f5es,\u00a0n\u00e3o aceita por exemplo mais de um argumento, \u00e9 bom para strings apenas. Ex.:<\/span><\/p>\n
poe(\"Ola mundo em Prisma!\");<\/pre>\n
\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 executestring( string )<\/strong>
\n<\/span><\/h3>\n
Executa um trecho de comando em uma string em tempo de execu\u00e7\u00e3o, retorna zero caso tenha sucesso ou 1 caso falhe.
\n<\/span><\/p>\n
Muito \u00fatil quando voc\u00ea quer que seu programa leia e interprete comandos. Exemplo:<\/p>\n
 \r\n x = executestring ( \"imprima ( 'Ola Mundo' ) ; \" ); \r\n\/\/imprime na tela Ola Mundo\r\n\r\n   se x == 0 entao\r\n        imprima 'string executada com sucesso'\r\n   senaose x == 1 entao\r\n        imprima 'a string nao foi executada por algum erro'; \r\n   fim\r\n\r\n<\/pre>\n
Dica: cuidado com as aspas, se a string a ser executada possui apas internamente voc\u00ea tem\u00a0<\/strong><\/em>algumas op\u00e7\u00f5es:<\/strong><\/em><\/p>\n
1 – Usar aspas simples internamente, e duplas externamente ou o inverso, como no exemplo acima;<\/span><\/em><\/strong><\/p>\n
 \r\nx = executestring ( \"imprima ( 'Ola Mundo' ) ; \" );<\/pre>\n
2 – Usar o mesmo tipo de aspas. Mas as internas devem ser antecedidas por barra obl\u00edqua: \\”<\/span> ou \\’ <\/span>ex.:<\/span><\/em><\/strong><\/p>\n
executestring ( 'imprima(\\'ola mundo\\') ' );<\/pre>\n
\u00a0<\/em><\/strong><\/p>\n
Ou<\/span><\/em><\/strong><\/p>\n
3 – Usar duplos colchetes:<\/span><\/em><\/strong><\/p>\n
 executestring( [[ imprima (\"ola mundo\" ) ]] );<\/pre>\n
Como o argumento \u00e9 uma \u00fanica string podemos omitir o par\u00eanteses da fun\u00e7\u00e3o como fazemos\u00a0desde o in\u00edcio com a fun\u00e7\u00e3o inclua<\/strong>. <\/em>Ficando assim:\u00a0 executestring “seu_comando_aqui” .<\/strong><\/p>\n
\n
\u00a0\u00a0\u00a0\u00a0\u00a0 executearquivo ( “caminho_do_arquivo.prisma” )<\/strong><\/span><\/h3>\n
\u00a0\u00a0 <\/strong>Semelhante ao comando executestring, mas ao inv\u00e9s de executar uma string, executa um programa prisma, que pode estar\u00a0compilado ou n\u00e3o.<\/p>\n
\u00a0Muito \u00fatil quando seu programa tem v\u00e1rios subprogramas separados, sendo chamados pelo programa principal.<\/p>\n
Esta fun\u00e7\u00e3o, executearquivo<\/em>, em caso de haver erro no programa executado, simplesmente trava a execu\u00e7\u00e3o do programa principal, fechando-o e imprimindo mensagem de erro na tela cmd (no Linux terminal).<\/p>\n
Se o programa prisma a ser executado estiver na mesma pasta que o programa principal, n\u00e3o \u00e9 necess\u00e1rio usar o caminho completo,\u00a0caso contr\u00e1rio sim.<\/p>\n
\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 ex.:<\/p>\n
 \r\nexecutearquivo( 'ola.prisma'); \r\n\/\/--> executa um programa prisma chamado ola.prisma;<\/pre>\n
\"obs\"\u00a0\u00a0 Obs. Lembre-se que o nome do arquivo a ser executado deve ser escrito com a extens\u00e3o.<\/p>\n
\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Lembre-se de que no Windows as barras devem ser duplas, ex:<\/p>\n
\"C:\\\\Users\\\\Admin\\\\ola.prisma\";<\/pre>\n
Ou use duplos colchetes:<\/p>\n
\u00a0[[C:\\Users\\Admin\\ola.prisma]];<\/pre>\n
J\u00e1 no L\u00ednux n\u00e3o \u00e9 necess\u00e1rio, pois as barras de endere\u00e7o s\u00e3o assim: \u00a0\/<\/strong><\/p>\n
\u00a0\r\n'\/home\/user\/ola.prisma'<\/pre>\n
<\/h3>\n
\u00a0\u00a0 carregue ( string )<\/strong><\/h3>\n
\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 Semelhante a fun\u00e7\u00e3o executestring<\/em><\/strong> com a diferen\u00e7a de que esta carrega a string e retorna uma fun\u00e7\u00e3o dela para uma vari\u00e1vel. Ex:<\/strong><\/p>\n
 \r\nimprima_ola = carregue ( \"imprima 'ola mundo' \" ); \r\n\/\/primeiro carrega a string em uma fun\u00e7\u00e3o\r\n\r\n imprima_ola() ; \r\n\/\/executa a string carregada nesta funcao;\r\n\r\n<\/pre>\n
\u00a0\u00a0\u00a0\u00a0\u00a0 Se houver erros o primeiro retorno \u00e9 nulo e o segundo \u00e9 uma string descrevendo o erro.<\/p>\n
Ex.:<\/p>\n
local s = 'imprima(a+2)';\r\nlocal f, msg_erro = carregue(s);\r\nse f entao\r\n  f();\/\/executa fun\u00e7\u00e3o f se for v\u00e1lido\r\nsenao\r\n  erro(msg_erro);\/\/imprime a mensagem de erro se f for nulo.\r\nfim<\/pre>\n
 <\/p>\n
<\/h3>\n
<\/h3>\n
\u00a0carreguearquivo ( “programa.prisma” )<\/strong><\/h3>\n
\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 S<\/strong>imilar \u00e0 fun\u00e7\u00e3o carregue, no entanto, esta carrega um arquivo fonte prisma ou programa compilado prisma em uma fun\u00e7\u00e3o que ao ser executada executa o programa carregado. Exemplo:<\/p>\n
execute_arquivo = carreguearquivo ( 'ola.prisma' );\r\n\r\nexecute_arquivo () ; \/\/executa o programa carregado.\r\n\r\n<\/pre>\n
\u00a0Esta fun\u00e7\u00e3o, ao contr\u00e1rio da executearquivo, d\u00e1 a possibilidade de fazer um tratamento de erro:<\/p>\n
f, msg_erro = carreguearquivo ( 'ola.prisma' );\r\n\r\nse f entao\r\n        f() ;\/\/executa o programa carregado.\r\nsenao\r\n       imprima (msg_erro);\r\nfim \r\n\r\n<\/pre>\n
\u00a0 convnumero( string )<\/strong><\/h3>\n
\u00a0 Converte uma string para n\u00famero. Exemplo:<\/p>\n
  x = \"12\";\r\n\/\/ x = x + x -- errado!\r\n\r\n  x = convnumero( x ); \/\/correto!\r\n\r\n  x = x + x; \r\nimprima(x);\r\n\/\/depois de convertermos para n\u00famero\r\n\r\n<\/pre>\n
<\/h3>\n
\u00a0\u00a0\u00a0\u00a0 convstring ( numero )<\/strong><\/h3>\n
Faz o contr\u00e1rio da fun\u00e7\u00e3o anterior, converte um n\u00famero para string.<\/p>\n
 \r\nx = \"1 + 1 = \" .. 2 ; \r\n\/\/ao concatenar a convers\u00e3o \u00e9 autom\u00e1tica,\r\n\/\/mas \u00e9 recomend\u00e1vel que se converta antes:\r\n\r\nx = \"1 + 1 = \" .. convstring ( 2 );\r\nimprima(x);\r\n\r\n<\/pre>\n
<\/h3>\n
\u00a0\u00a0\u00a0 tente ( comando , ‘mensagem erro’);
\n<\/strong><\/h3>\n
Esta fun\u00e7\u00e3o verifica um valor e retorna um mensagem de erro caso esse valor seja falso ou nulo, ou o pr\u00f3prio valor caso ele seja\u00a0v\u00e1lido.<\/p>\n
\u00a0Sua sintaxe \u00e9 :\u00a0\u00a0\u00a0 x\u00a0 = tente (\u00a0\u00a0\u00a0 valor , String_erro );<\/span><\/strong><\/p>\n
Esta fun\u00e7\u00e3o \u00e9 \u00f3tima para testar abertura de arquivos. Veja seu uso:<\/p>\n
x = tente ( falso , \"erro - valor invalido\" ); \r\n\r\n\/**\r\nretorna o valor se for v\u00e1lido ou a mensagem \r\nde erro se valor for inv\u00e1lido, isto \u00e9, se for \r\nfalso ou nulo\r\n**\r\n\r\n<\/pre>\n
Outro exemplo de uso com a fun\u00e7\u00e3o que abre arquivo em Prisma:<\/p>\n
x = tente( \r\n    es.abra ( \"teste.txt\" , \"escrita\" ), \r\n   \"erro - arquivo nao pode ser aberto\"\r\n); \/\/tente\r\n\r\n\/** \r\nse a fun\u00e7\u00e3o conseguir abrir o arquivo retorna o \r\narquivo para x sen\u00e3o fecha o programa e retorna\r\na mensagem de erro, que \u00e9 a string definida no \r\nsegundo par\u00e2metro.\r\n**\r\n\r\nse x entao \r\n\/\/ se x tiver algum valor v\u00e1lido entao:\r\n   x:escreva (\"uma linha escrita no arquivo\"); \r\n\/\/escreve no arquivo aberto\r\n\r\n   x:feche ( ); \r\n\/\/ depois \u00e9 necess\u00e1rio fechar o arquivo aberto.\r\n\r\nfim \/\/fim se\r\n\r\n<\/pre>\n
<\/h3>\n
\u00a0cod ( ‘Car’ )<\/h3>\n
Esta fun\u00e7\u00e3o converte um caractere para sua representa\u00e7\u00e3o em bytes (n\u00famero), h\u00e1 uma certa correspond\u00eancia ao n\u00famero de cada\u00a0tecla do teclado.<\/p>\n
Exemplo:<\/p>\n
  \r\nimprima ( cod ('A')  ) ; \/\/ sa\u00edda --> 65\r\na = \"tangerina\";\r\nimprima( cod(a ,1, #a) ) \/\/ desde o caractere 1 at\u00e9 o tamanho de a\r\n\/\/sa\u00edda--> 116 97 110 103 101 114 105 110 97\r\n\r\n<\/pre>\n
No exemplo, podemos observar que esta fun\u00e7\u00e3o converte a letra ‘A’ para o n\u00famero 65.<\/p>\n
E todos os caracteres de “tangerina” na vari\u00e1vel a.<\/p>\n
Obs.: O nome da fun\u00e7\u00e3o ‘cod’ faz refer\u00eancia a c\u00f3digo (‘codifique’);<\/p>\n
car ( cod )<\/h3>\n
Esta fun\u00e7\u00e3o converte de codigo para caractere, ou seja, o par\u00e2metro \u00e9 um n\u00famero que ser\u00e1 convertido para caractere.<\/p>\n
Ex.:<\/p>\n
 \r\nimprima ( car ( 65 )   ); \/\/ sa\u00edda -- > A\r\n\r\nimprima( car(65,66,67) ); \/\/ sa\u00edda --> ABC\r\n\r\n<\/pre>\n
<\/h3>\n
compile( fun\u00e7\u00e3o )<\/h3>\n
Esta fun\u00e7\u00e3o converte uma fun\u00e7\u00e3o prisma em byte-code em tempo de execu\u00e7\u00e3o retornando em forma de string codificada,\u00a0\u00e9 poss\u00edvel gravar em arquivo o resultado e cham\u00e1-lo posteriormente com os comandos inclua, carreguearquivo ou executearquivo.<\/p>\n
ex.:<\/p>\n
\/\/ex. compile\r\nfuncao soma ( a , b ) \r\n\/\/criando uma fun\u00e7\u00e3o para ser compilada\r\n\r\n  imprima ( a + b);\r\nfim\r\n\r\n xsoma = compile( soma ); \r\n\/\/compilando a fun\u00e7ao, o retorno \u00e9 uma string compilada\r\n\r\n   x = carregue( xsoma ); \r\n\/\/para usar basta carregar a string compilad\r\n\/\/e depois chamar como uma funcao qualquer:\r\n\r\n   x( 3 , 4 ) ; \/\/saida -->      7\r\n\r\n<\/pre>\n
N\u00e3o precisa necessariamente declarar a fun\u00e7\u00e3o antes, pode passar a fun\u00e7\u00e3o sem nome\u00e1-la, isto \u00e9 chamado de fun\u00e7\u00e3o an\u00f4nima:<\/p>\n
ex.2:<\/p>\n
\/\/ex. compile()\r\nx = compile ( funcao( ) imprima( 'Ola Mundo') fim   ); \r\n\/\/a fun\u00e7\u00e3o \u00e9 passada como argumento, mas sem nome;\r\n\r\ng = carregue ( x ); \/\/carregando a string compilada\r\n\r\ng ( ); \r\n\/\/executando como uma fun\u00e7\u00e3o, sa\u00edda -- > Ola Mundo\r\n\r\n<\/pre>\n
No pr\u00f3ximo exemplo vou demonstrar como gravar em um arquivo e depois executar o arquivo:<\/p>\n
ex.3:<\/p>\n
\/\/ex. compile()\r\nx = compile(  \r\n\/\/o argumento pode ocupar normalmente mais que uma linha:\r\n\r\nfuncao (  ) \r\n\r\n         para i = 1 , 100       inicio  imprima ( i )       fim   \r\n\r\nfim \r\n\r\n\r\n);\r\n\r\narquivo = es.abra ( 'teste.prisma' , 'escritabin' ); \r\n\/\/abre um arquivo em modo escrita bin\u00e1ria\r\n\r\n     arquivo:escreva ( x ) ; \r\n\/\/ escrevendo no arquivo a string compilada 'x'\r\n\r\narquivo:feche( ); \/\/pronto, arquivo fechado\r\n\r\n\/\/executando o arquivo, pode ser de v\u00e1rias \r\n\/\/maneiras, mas aqui vou usar o 'executearquivo'\r\n\r\nexecutearquivo \"teste.prisma\" ; \r\n\/\/deve ser o mesmo nome criado acima, ok!\r\n\r\n\/\/sa\u00edda -- >  de 1 a 100 na tela do cmd.\r\n\r\n<\/pre>\n
Voc\u00ea pode usar em combina\u00e7\u00e3o com a fun\u00e7\u00e3o carreguearquivo e compilar um arquivo, veja:<\/p>\n
\/\/ex. carreguearquivo\r\n\r\nx = carreguearquivo( 'teste.prisma') ;\r\n \/\/carrega um arquivo prisma em uma fun\u00e7\u00e3o\r\n\r\ng = compile ( x ) ; \r\n\/\/podemos compilar x j\u00e1 que \u00e9 uma fun\u00e7\u00e3o\r\n\/\/ retornando a string compilada para g;\r\n\r\na = es.abra( 'out.prisma' , 'escritabin'); \r\n\/\/abrindo um arquivo em modo escrita bin\u00e1ria\r\n\r\na:escreva( g ) ; \r\n\/\/escrevendo a string compilada para o arquivo\r\n\r\na:feche( );\r\n\r\n\/\/pronto o arquivo foi compilado para byte-code \r\n\/\/a partir de um programa feito em prisma!\r\n\r\n<\/pre>\n
\n
<\/h3>\n
\u00a0pchame ( funcao, argumentos )<\/h3>\n
 <\/p>\n
Chama (executa) uma fun\u00e7\u00e3o em modo protegido, isto \u00e9, se a fun\u00e7\u00e3o contiver erros a mesma n\u00e3o interfere na execu\u00e7\u00e3o do programa\u00a0principal. Ela retorna dois valores, o primeiro \u00e9 um boolean (falso ou verdadeiro)\u00a0 e o segundo \u00e9 a mensagem de erro caso tenha.<\/p>\n
Caso haja um erro a fun\u00e7\u00e3o n\u00e3o \u00e9 executada e o primeiro retorno \u00e9 um falso seguido pela mensagem de erro se n\u00e3o tiver erro\u00a0a fun\u00e7\u00e3o \u00e9 executada, o primeiro retorno \u00e9 verdadeiro e o segundo \u00e9 o valor de retorno da fun\u00e7\u00e3o se houver, veja:<\/p>\n
O primeiro par\u00e2metro \u00e9 a fun\u00e7\u00e3o a ser chamada e do segundo em diante s\u00e3o seus argumentos se tiver.<\/p>\n
funcao soma ( a , b )\r\n   imprima( a + b );\r\nfim\r\n\r\nx , msg = pchame ( soma , 'a' , 3 ); \r\n\/\/isto gerar\u00e1 um devido a soma de uma letra com um n\u00famero\r\n\r\nse x == falso entao\r\n\r\n          imprima( msg ) \r\n\/\/imprimindo a mensagem de erro\r\n\r\nsenao\r\n\r\n         imprima 'Fun\u00e7\u00e3o executada com \u00eaxito' ;\r\n\r\nfim<\/pre>\n
\n
<\/h3>\n
xpchame(\u00a0 funcao , funcao_erro , argumentos … )<\/h3>\n
 <\/p>\n
Muito semelhante a de cima, mas com uma fun\u00e7\u00e3o de erro customizada, veja:<\/p>\n
funcao soma( a , b )\r\n\r\n     imprima( a  + b );\r\n\r\nfim\r\n\r\nfuncao imprima_erro ( msg_erro )\r\n\r\n    imprima ( \"ocorreu um erro, veja: \" , msg_erro );\r\n\r\nfim\r\n\r\na , b = xpchame ( soma , imprima_erro , 2 , 'a' ) ; \r\n\/\/ o 'a' gerar\u00e1 um erro, pois \u00e9 uma opera\u00e7\u00e3o aritm\u00e9tica com string\r\n\r\nimprima ( a , b );\r\n\r\nleia( );\r\n\r\n<\/pre>\n
<\/h3>\n
<\/h3>\n
selecione( \u00a0[‘#’ ou inteiro] \u00a0, \u00a0args … \u00a0)<\/h3>\n
 <\/p>\n
Essa fun\u00e7\u00e3o realiza uma sele\u00e7\u00e3o entre v\u00e1rios argumentos passados como par\u00e2metro, ou se usar o ‘#’ retorna o n\u00famero de argumentos.<\/p>\n
sintaxe: \u00a0 \u00a0selecione ( \u00a0 tipo , args ); \/\/onde tipo pode ser ‘#’ ou um n\u00famero inteiro.<\/p>\n
ex.:<\/p>\n
\u00a0 \u00a0funcao \u00a0 \u00a0tam ( ... );\r\n       imprima(  'voce passou ' , selecione('#' , ... ) , 'argumentos');\r\n   fim\r\n tam( 1 , 2 , 3, 4 , 5 ); \/\/saida = voce passou    5   argumentos\r\n\u00a0\r\n<\/pre>\n
No exemplo acima retorna o n\u00famero de argumentos variados, pois usamos o tipo ‘#’ como primeiro par\u00e2metro para selecione;<\/p>\n
Podemos usar um n\u00famero inteiro e definir o retorno a partir dessa posi\u00e7\u00e3o para frente dos argumentos passados:<\/p>\n
funcao selec ( num , ... )\r\n    imprima('voce escolheu a partir do argumento' , num , selecione( num , ... )  )\r\nfim\r\nselec( 3 , 12 , 34 , 56 , 78 , 90 ); \r\n\r\n<\/pre>\n
Sa\u00edda ser\u00e1: \u00a0 voce escolher a partir do argumento \u00a0 \u00a0 \u00a0 3 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 56 \u00a0 \u00a0 78 \u00a0 90<\/p>\n
Perceba que ao usar o 3 como primeiro par\u00e2metro da fun\u00e7\u00e3o selecione, ela retorna os elementos a partir do terceiro, se us\u00e1ssemos o 4 seria a partir do quarto, se 5 a partir do quinto, se 2 a partir do segundo e assim por diante.<\/p>\n
<\/h2>\n
\n
<\/h2>\n
<\/h2>\n
Cap. 2 – Fun\u00e7\u00f5es da biblioteca string<\/strong><\/h2>\n
 <\/p>\n
Muito importante para o processamento de strings como procurar, recortar, substituir trecho de string por outra, etc.<\/p>\n
string.cod \/ string.byte<\/h3>\n
A mesma fun\u00e7\u00e3o com nomes diferentes, use a forma que preferir.<\/em><\/p>\n
\u00a0\u00a0\u00a0 Relembre a fun\u00e7\u00e3o cod,<\/strong> \u00e9 exatamente a mesma fun\u00e7\u00e3o empacotada na biblioteca string. Ela converte um caractere para sua\u00a0representa\u00e7\u00e3o em bytes, veja:<\/p>\n
Aceita dois par\u00e2metros, o primeiro \u00e9 o caractere ou string, o segundo \u00e9 o n\u00famero que indica na sequ\u00eancia qual caractere\u00a0da string a ser convertido. Quando o segundo par\u00e2metro \u00e9 omitido, o primeiro caractere da string \u00e9 o padr\u00e3o.<\/p>\n
imprima (string.byte (\"ABC\")) \/\/ sa\u00edda --> 65 *(A \u00e9 65 in ASCII) \r\n\/\/converte o primeiro car, o 'A' pois o segundo par\u00e2metro foi omitido\r\nimprima (string.cod (\"ABC\", 1 ,  3 ) )\r\n\/\/ ( 'string' , ponto_inicial , ponto_final )  \r\n\/\/retorna 3 valores a primeira, segunda e terceira letra.\r\n\/\/sa\u00edda -- > 65   66    67\r\n\/\/ se quis\u00e9ssemos salvar os valores em vari\u00e1veis, fica assim:\r\na , b , c = string.byte( \"ABC\" , 1  , 3 ) ; \r\n\/\/ ( 'string' ,  ponto_inicial , ponto_final )\r\nimprima( a , b , c ) ; \/\/sa\u00edda -->  65    66    67\r\n\r\n\/\/ou em uma tabela:\r\ntab = tabela.empacote(   string.cod ( \"ABCDE\" , 1 , 5 )    );  \r\n\/\/empacota os resultados em uma tabela.\r\nimprima( tabela.desempacote( tab )   );\r\n<\/pre>\n
\n
<\/h3>\n
string.car<\/h3>\n
 <\/p>\n
\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 exatamente a mesma fun\u00e7\u00e3o car vista na biblioteca base, use qual preferir<\/em><\/p>\n
Converte o c\u00f3digo num\u00e9rico (ASCII) em caractere;<\/p>\n
Aceita n\u00famero variado de par\u00e2metros separados por v\u00edrgula e retorna a string formada por eles, ou caractere se for \u00fanico.<\/p>\n
sintaxe:\u00a0 \u00a0<span style="font-size: small;">s = string.car (n1, n2, n3, ...)<\/span><\/code><\/p>\n
\n
Descri\u00e7\u00e3o:<\/b><\/p>\n
Recebe 0 ou mais n\u00fameros e converte todos em caracteres correspondentes. \u00c9 o oposto da fun\u00e7\u00e3o string.byte \/ string.cod<\/p>\n
imprima ( string.car (65, 66 , 67 ) ) \/\/sa\u00edda --> ABC<\/pre>\n
<\/h3>\n
string.compile<\/strong><\/h3>\n
Exatamente a mesma fun\u00e7\u00e3o que vimos na base: compile, use o modo que preferir.<\/em><\/p>\n
Converte uma fun\u00e7\u00e3o em bin\u00e1rio (byte-codes);<\/p>\n
Sintaxe:\u00a0 \u00a0 <\/b><span style="font-size: small;">s = string.compile ( f )<\/span><\/code><\/p>\n
\n
Descri\u00e7\u00e3o:<\/b><\/p>\n
Converte uma fun\u00e7\u00e3o f em sua representa\u00e7\u00e3o bin\u00e1ria, que pode ser posteriormente processada com a fun\u00e7\u00e3o carregue( ).<\/p>\n
Como a fun\u00e7\u00e3o compile foi bem tratada na biblioteca base, aqui s\u00f3 vou demonstrar um simples exemplo.<\/p>\n
Ex.:<\/p>\n
funcao f () imprima \"Alo, Mundo\" fim\r\n    s = string.compile (f)\r\ntente (carregue (s) ) () \/\/--> Alo, Mundo\r\n\r\n\/\/n\u00e3o estranhe ao colocar os () na frente da fun\u00e7\u00e3o tente,\r\n\/\/ o retorno, que \u00e9 uma fun\u00e7\u00e3o \u00e9 executado logo ap\u00f3s tente ( carregue(s) );\r\n\/\/\u00e9 o mesmo que g = tente ( carregue (s) ) ;    g ( ); mas sem o g.<\/pre>\n
<\/h3>\n
string.procure<\/strong><\/h3>\n
Procura uma ‘string’ chave em uma string maior retornado sua posi\u00e7\u00e3o:<\/p>\n
sintaxe:\u00a0\u00a0\u00a0 string.procure( “string maior” , “chave” , n\u00famero_inicio );<\/p>\n
\u00a0string maior<\/strong> \u00e9 a string onde queremos procurar a string chave;<\/p>\n
chave <\/strong>\u00e9 a string a ser encontrada na maior;<\/p>\n
n\u00famero_inicio<\/strong> \u00e9 a posi\u00e7\u00e3o inicial para come\u00e7ar a procurar na string maior, se omitido, seu valor padr\u00e3o \u00e9 1;<\/p>\n
Ex.:<\/p>\n
 s = \"esta \u00e9 uma string onde iremos procurar por uma string menor\";\r\n\r\n         pos_inic , pos_fim = string.procure( s , 'menor' ); \r\n\/\/localiza a string 'menor' dentro de s;\r\n\r\n        imprima ( pos_inic , pos_fim ); \r\n\/\/sa\u00edda --> 56   60<\/pre>\n
H\u00e1 dois retornos, o primeiro \u00e9 a posi\u00e7\u00e3o inicial da string localizada, o segundo \u00e9 a posi\u00e7\u00e3o final, portanto precisamos usar\u00a0duas vari\u00e1veis para receber os valores.<\/p>\n
Como dito antes o terceiro par\u00e2metro, \u00edndice de posi\u00e7\u00e3o inicial de busca, \u00e9 opcional, e por padr\u00e3o \u00e9 1, isto \u00e9 a busca inicia\u00a0pelo primeiro caractere da string.<\/p>\n
Mas, as vezes voc\u00ea pode querer procurar por mais resultados da mesma chave de busca, e para isso o terceiro par\u00e2metro \u00e9\u00a0indispens\u00e1vel. A estrat\u00e9gia \u00e9 guardar a posi\u00e7\u00e3o do primeiro resultado de busca e por meio de um la\u00e7o de repeti\u00e7\u00e3o reiniciar\u00a0a busca do ponto posterior ao \u00faltimo resultado, veja:<\/p>\n
s = \" alo mundo, alo mundo , alo , mundo, alo\";\r\n\r\npi = {}; \r\n\/\/vamos criar duas tabelas (matrizes)\r\n\/\/ uma posi\u00e7\u00e3o inicial (pi) e outra posi\u00e7\u00e3o final (pf)\r\n\r\npf = {};\r\n\r\nx = 1;\r\n\r\npos_busca = 1; \/\/ponto inicial da busca\r\n\r\nenquanto 1 inicio \/\/cria um la\u00e7o infinito\r\n\r\n \r\n    pi[ x ] , pf [ x ] = string.procure ( s , 'alo' , pos_busca ); \r\n\/\/como pf[1] = 0 entao 0+1 = 1 , inicia do primeiro caractere a busca\r\n    \r\n    \r\n \r\n    se pi[x] == nulo entao  \r\n\/\/se o retorno de pi for nulo entao interrompe o la\u00e7o\r\n               quebre\r\n    senao                             \/\/senao salva uma nova posicao de busca\r\n                pos_busca = pf [ x ] + 1;\r\n    fim;\r\n   \r\n\r\nx = x + 1; \r\n\/\/fazendo o incremento de x\r\n\r\nfim\r\n\r\n\/\/imprimindo todos os resultados:\r\n\r\npara i = 1 , #pi  inicio\r\n\r\n      imprima( 'Busca numero ' .. i .. ' : ' .. pi[ i ]  .. ' - ' .. pf [ i ] );\r\n\r\n\/\/imprime todos os resultados para a busca 'alo' \r\n\/\/ a posi\u00e7\u00e3o inicial e final dentro da string s\r\n\r\nfim<\/pre>\n
\u00c9 poss\u00edvel usar patterns de busca ( caracteres especiais de busca).<\/p>\n
Localizando uma string entre aspas, parenteses e chaves:<\/strong><\/p>\n
 s = \" x = 'entre_aspas' ; imprima(entre_parenteses) ; tab = {entre_chaves} {asdf} \";\r\n imprima( string.procure( s , \"'.*'\" , 1 ); \/\/--> 6  18\r\n imprima( string.procure( s , \"'(.*)'\" , 1 ) ) ; \r\n\/\/--> 6 18 entre_aspas\r\n \r\n imprima( string.procure( s , '%((.*)%)' , 1 ) ) ; \r\n\/\/como ( j\u00e1 \u00e9 um sinal interno, usamos %( e %)\r\n  \/\/--> 29 46 entre_parenteses\r\n\r\n imprima( string.procure( s , '{(.+)}' , 1 ) ); \r\n\/\/-> 56 76 entre_chaves} {asdf\r\n imprima( string.procure( s , '{(.-)}' , 1 ) );\r\n\/\/o menos obt\u00e9m somente a 1\u00aa ocorr\u00eacia\r\n\/\/-> 56 69 entre_chaves\r\n \r\n<\/pre>\n
string.formate<\/strong><\/p>\n
Esta fun\u00e7\u00e3o serve para formatar strings por meio de caracteres de formata\u00e7\u00e3o, muito semelhante ao sprintf do C.<\/p>\n
\u00a0 \u00a0Sintaxe: \u00a0retorno = string.formate( “String_formatacao” , args , … );<\/p>\n
Exemplo b\u00e1sico:<\/p>\n
s = string.formate( \"Ola %s!\" , \"Mundo\");\r\nimprims(s); \/\/ -> Ola Mundo!<\/pre>\n
Perceba que a sa\u00edda \u00e9 a primeira string mas no lugar do %s \u00e9 posto o segundo argumento “Mundo”.<\/p>\n
O %s \u00e9 um exemplo de caractere de formata\u00e7\u00e3o para strings.<\/p>\n
N\u00famero variado de argumentos<\/strong><\/p>\n
s = string.formate ( 'Ola %s em %s!' , 'Mundo' , 'Prisma');\r\n\r\nimprima(s); \/\/ -> Ola Mundo em Prisma!\r\n\r\n<\/pre>\n
Note que poder\u00e1 ser muito mais do que dois argumentos de formata\u00e7\u00e3o.<\/p>\n
\"obs\"<\/a>\u00a0 Obs.: para cada argumento de formata\u00e7\u00e3o deve haver um caractere de formata\u00e7\u00e3o respectivo(na mesma sequ\u00eancia).<\/span><\/p>\n
Outros caracteres de formata\u00e7\u00e3o e exemplos:<\/strong><\/p>\n