{"id":544,"date":"2015-01-12T16:48:22","date_gmt":"2015-01-12T16:48:22","guid":{"rendered":"http:\/\/linguagemprisma.net\/?page_id=544"},"modified":"2017-05-01T13:48:21","modified_gmt":"2017-05-01T17:48:21","slug":"manual-basico","status":"publish","type":"page","link":"https:\/\/linguagemprisma.br4.biz\/blog\/manual-basico\/","title":{"rendered":"Manual b\u00e1sico"},"content":{"rendered":"

INTRODU\u00c7\u00c3O \u00c0 LINGUAGEM PRISMA BR<\/strong><\/h1>\n

 <\/p>\n

\"cropped-prisma.png\"<\/a><\/p>\n

 <\/p>\n

Por Adalberto Amorim Felipe<\/h2>\n

 <\/p>\n

 <\/p>\n

<\/h1>\n

<\/h1>\n

fevereiro\/2016<\/strong><\/h1>\n

 <\/p>\n

 <\/p>\n

<\/h1>\n

<\/h1>\n

<\/h1>\n

<\/h1>\n

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

 <\/p>\n

Este material \u00e9 para iniciantes, ou para quem tem dificuldades em adentrar nos conceitos t\u00e9cnicos da linguagem Prisma. Portanto, \u00e9 para ser lido com paci\u00eancia percorrendo em detalhes a linguagem, ou para ser consultado na parte que mais interessa. Ele come\u00e7a bem do b\u00e1sico mesmo e a tend\u00eancia \u00e9 ir ao avan\u00e7ado, espero que seja \u00fatil.<\/p>\n

 <\/p>\n

Em primeiro lugar voc\u00ea deve conhecer alguns aspectos sobre a linguagem Prisma:<\/h3>\n

 <\/p>\n

O que \u00e9 Prisma?<\/h3>\n

 <\/p>\n

\u00c9 um conjunto que inclui:<\/p>\n

1 – linguagem de programa\u00e7\u00e3o e suas regras de comandos;<\/p>\n

2 – interpretador;<\/p>\n

3 – bibliotecas e arquivos externos.<\/p>\n

Vejamos cada item anterior:<\/strong><\/p>\n

linguagem de programa\u00e7\u00e3o e suas regras de comandos:<\/strong><\/p>\n

Digamos que qualquer linguagem possa ser inventada, basta voc\u00ea determinar as regras, as palavras reservadas fun\u00e7\u00f5es da biblioteca padr\u00e3o, enfim, o modo como escrev\u00ea-la, os s\u00edmbolos permitidos e para que servem, o que pode e o que n\u00e3o pode.<\/p>\n

\u00c9 exatamente as regras e mecanismos de funcionamento da linguagem que voc\u00ea deve dominar para fazer os programas, os aspectos da linguagem. Esses aspectos s\u00e3o a ess\u00eancia da linguagem e Prisma tem isso, podemos citar uma caracter\u00edstica importante dela que possui comandos em portugu\u00eas ao inv\u00e9s do ingl\u00eas que \u00e9 de costume.<\/p>\n

Definidos teoricamente os aspectos da linguagem, basta criar um meio de faz\u00ea-la funcionar, afinal, n\u00e3o queremos algo na teoria somente mas na pr\u00e1tica tamb\u00e9m.<\/p>\n

Interpretador:<\/strong><\/p>\n

Diversas linguagens possuem como mecanismo de execu\u00e7\u00e3o a compila\u00e7\u00e3o do c\u00f3digo-fonte para c\u00f3digo nativo do processador.<\/p>\n

Prisma \u00e9 diferente, ela possui um mecanismo de interpreta\u00e7\u00e3o, isto \u00e9, h\u00e1 o programa feito em C que interpreta os comandos do c\u00f3digo-fonte ou c\u00f3digo-byte. O interpretador pode ser chamado da seguinte forma por linha de comando:<\/p>\n

prisma.exe programa_prisma.prisma<\/strong><\/em>, na sequ\u00eancia temos o carregamento do arquivo fonte chamado ‘programa_prisma.prisma’ que \u00e9 convertido internamente para byte-codes (c\u00f3digos em bytes) e ap\u00f3s isso \u00e9 executado. Pode-se, ainda, compilar o c\u00f3digo-fonte do programa prisma para byte-codes usando o prismac, seu modo de chamar \u00e9:<\/p>\n

prismac -o programa_compilado.pbrexe programa_fonte.prisma<\/strong>, ser\u00e1 gerado um arquivo bin\u00e1rio chamado<\/p>\n

programa_compilado.pbrexe.<\/p>\n

Mas o que \u00e9 programa fonte, ou c\u00f3digo-fonte? Simples, todo programa em linguagem de alto-n\u00edvel \u00e9 escrito, isto \u00e9, o<\/em><\/p>\n

programa \u00e9 feito em frases, geralmente frases no imperativo, por exemplo, escreva ‘ola’, x = leia ( ); ig.feche ( );<\/em><\/p>\n

estas frases devem seguir as regras da linguagem. Portanto o c\u00f3digo fonte \u00e9 o arquivo texto que cont\u00e9m as frases dos comandos <\/em>do programa que se quer fazer. O prismac.exe converte esse texto para c\u00f3digo byte, isto \u00e9, as instru\u00e7\u00f5es (frases) s\u00e3o traduzidas <\/em>para zeros e uns (bytes) cuja organiza\u00e7\u00e3o pode ser compreendida e interpretada pelo prisma.exe ( o interpretador );<\/em><\/p>\n

Enfim, o interpretador \u00e9 o que torna a execu\u00e7\u00e3o de um programa prisma poss\u00edvel, sem ele n\u00e3o h\u00e1 como executar os programas feitos nesta linguagem. V\u00e1rias outras linguagens s\u00e3o assim, podemos citar Python, C#, Java, Ruby, Lua, Lisp, Php entre outras. O fato de uma linguagem ser interpretada garante algumas vantagens e perde outras, perde principalmente no uso da mem\u00f3ria e velocidade, mas ganha em portabilidade e simplicidade na cria\u00e7\u00e3o dos softwares.<\/p>\n

Prisma \u00e9, na verdade, uma modifica\u00e7\u00e3o dos fontes de Lua, uma linguagem brasileira de fama internacional muito usadas em jogos, pois \u00e9 das linguagens de scripts a mais veloz e leve. Como Prisma tem nela sua origem herda esses tra\u00e7os, sendo mais leve que Java, por exemplo, mais simples de se aprender que Python. Prisma tem um enorme potencial que se encontra no fato de quase tudo feito em C pode ser estendido a Prisma. Por exemplo, \u00e9 simples implementar fun\u00e7\u00f5es do gtk em Prisma, assim como em Lua.<\/p>\n

Bibliotecas e arquivos externos<\/strong><\/p>\n

Nem todo recurso necess\u00e1rio ser\u00e1 encontrado no interpretador Prisma diretamente. Por exemplo, se voc\u00ea quiser fazer um programa com janelas e bot\u00f5es, n\u00e3o conseguir\u00e1 fazer isso somente em prisma, dever\u00e1 usar fun\u00e7\u00f5es gr\u00e1ficas que est\u00e3o em outro programa chamado igbr, <\/strong>que \u00e9 uma biblioteca em prisma.<\/p>\n

Bibliotecas servem para isso, criar fun\u00e7\u00f5es que ainda n\u00e3o existem em prisma estendendo novas funcionalidades. Inclusive, voc\u00ea pode criar novas bibliotecas, seja na pr\u00f3pria linguagem Prisma ou em C. As bibliotecas chamadas tamb\u00e9m de m\u00f3dulos podem ter as seguintes extens\u00f5es: .pris para m\u00f3dulo em prisma (ou _pris.dll ) , e .dll para m\u00f3dulos nativos em C. (para m\u00f3dulos em C \u00e9 necess\u00e1rio saber programar em C e compilar dlls);<\/p>\n

( Em linux essas extens\u00f5es podem alterar para _pris.so e .so );<\/p>\n

Adiante veremos com detalhe como fazer suas pr\u00f3prias bibliotecas.<\/p>\n

Por fim, voc\u00ea precisa saber que para programar em Prisma deve estudar a linguagem – a parte do manual que trata da linguagem em si. J\u00e1 para programar com um tipo espec\u00edfico de biblioteca precisa estudar sobre a biblioteca a ser usada, seja ela um m\u00f3dulo de fun\u00e7\u00f5es gr\u00e1ficas, base de dados, ou network, etc.<\/p>\n

Aqui, mais especificamente, veremos sobre a linguagem em si!<\/h3>\n

<\/h3>\n

 <\/p>\n

 <\/p>\n

 <\/p>\n

 <\/p>\n

 <\/p>\n

Unidade I – Introdu\u00e7\u00e3o \u00e0 linguagem<\/strong><\/h1>\n

 <\/p>\n

 <\/p>\n

 <\/p>\n

Cap. 1 – Primeiro programa: fun\u00e7\u00e3o imprima() e leia() , strings, n\u00fameros e coment\u00e1rios –<\/strong><\/h2>\n

 <\/p>\n

Caso n\u00e3o tenha instalado prisma v\u00e1 para a p\u00e1gina de downloads e primeiros passos.<\/p>\n

 <\/p>\n

Vamos programar ent\u00e3o:<\/p>\n

C<\/strong>om o editor aberto, crie um arquivo, salve-o com o nome de ola.prisma em uma pasta de sua escolha e digite o seguinte comando dentro dele :<\/p>\n

imprima  \"Ola mundo em prisma!\";<\/pre>\n
 <\/p>\n
\"botaoexecutar\"<\/a> Execute-o pressionando o bot\u00e3o executar que se encontra na barra de ferramentas do prismacod ou no menu ferramentas->executar.<\/p>\n
Sim, uma \u00fanica linha aqui j\u00e1 \u00e9 um programa, que exibe a mensagem Ola mundo em prisma! na janela de comandos.<\/p>\n
Vejamos, voc\u00ea aprendeu aqui uma fun\u00e7\u00e3o imprima<\/em> (que imprime “frases na tela”), esse texto entre aspas \u00e9 chamado<\/p>\n
em programa\u00e7\u00e3o de string, que em ingl\u00eas significa corda ou cadeia, ou seja, no sentido de sequ\u00eancia de caracteres.<\/p>\n
O interpretador n\u00e3o interpreta nada do que est\u00e1 dentro de uma string, ela \u00e9 tratada como um objeto que se pode<\/p>\n
manipular e ser exibido na tela.<\/p>\n
 <\/p>\n
A fun\u00e7\u00e3o imprima dispensa o uso do par\u00eanteses, assim como qualquer outra fun\u00e7\u00e3o, na condi\u00e7\u00e3o de que tenha um \u00fanico par\u00e2metro e seja uma string (Tabelas como par\u00e2metro \u00fanico tamb\u00e9m dispensam o uso de par\u00eanteses ).<\/p>\n
 <\/p>\n
reescreva o comando anterior da seguinte forma:<\/h3>\n
imprima (\"Ola mundo em Prisma!\"); \/\/ execute e veja que o resultado ser\u00e1 o mesmo.<\/pre>\n
 <\/p>\n
tente agora:<\/p>\n
imprima ( \"Ola mundo \\n em \\n Prisma\" ); \/\/execute<\/pre>\n
 <\/p>\n
Deve ter notado uma grande diferen\u00e7a, cada trecho saiu em uma linha diferente, isso foi devido ao \\n <\/strong>que \u00e9 chamado de caractere de escape nova linha, quando h\u00e1 um desses dentro de uma string ele n\u00e3o \u00e9 impresso, ao inv\u00e9s disso o texto vai para linha seguinte. H\u00e1 diversos caracteres de escape, vejamos quais s\u00e3o eles:<\/p>\n
\n
 <\/p>\n
Sequ\u00eancias\u00a0de escape em Prisma:<\/strong><\/p>\n
\\a – campainha (d\u00e1 certo s\u00f3 no Windows):<\/strong><\/p>\n
para i = 1, 10 inicio\r\n  es.escreva('\\a\\a\\a\\a pressione enter\\n');\u00a0\r\nfim<\/pre>\n
 <\/p>\n
\\n – nova linha:<\/strong><\/p>\n
es.escreva('exemplo\\nde\\nescape de\\nnova linha: \\\\n\\n\\n');<\/pre>\n
 <\/p>\n
\u00a0\\b – backspace (apaga um caractere anterior):<\/strong><\/p>\n
es.escreva('exemplo de escape backspace apagando o n 3: 123\\b45');<\/pre>\n
 <\/p>\n
\u00a0\\f – avan\u00e7o de p\u00e1gina:<\/strong><\/p>\n
es.escreva('\\n\\nexemplo de\\fescape\\favan\u00e7o de\\fp\u00e1gina\\n\\n');<\/pre>\n
 <\/p>\n
\u00a0\\r – Retorno do carro (volta para o inicio da linha):<\/strong><\/p>\n
es.escreva('------------------------------- Carro!!!\\rExemplo de escape retorno do ');<\/pre>\n
 <\/p>\n
\u00a0\\t – tabula\u00e7\u00e3o horizontal:<\/strong><\/p>\n
es.escreva('\\n\\n Exemplo de \\t tabula\u00e7\u00e3o \\t horizontal\\n em Prisma \\t usando \\t a fun\u00e7\u00e3o es.escreva!!!\\n\\n');<\/pre>\n
\u00a0\\v – tabula\u00e7\u00e3o vertical:<\/strong><\/p>\n
es.escreva'\\nEste \u00e9 um exemplo\\vde\\vtabula\u00e7\u00e3o\\vvertical\\n\\n';<\/pre>\n
 <\/p>\n
\u00a0\\’ – aspas simples:<\/strong><\/p>\n
es.escreva('Entre aspas simples: \\'ola mundo!!!\\'\\n\\n');<\/pre>\n
 <\/p>\n
\u00a0\\” – aspas duplas:<\/strong><\/p>\n
es.escreva'\\\"aspas duplas\\\"\\n\\n';<\/pre>\n
 <\/p>\n
\u00a0\\\\ – barra invertida:<\/strong><\/p>\n
es.escreva(\"usando barras: \\\\ entre barras \\\\ \\n\\n\");<\/pre>\n
\u00a0Usando tabela ASCII: \\nnn \u00a0(preencha com zero \u00e0 esquerda)<\/strong><\/p>\n
es.escreva\"Usando tabela ASCII: \\065\\066\\067\\n\\n\";<\/pre>\n
 <\/p>\n
Tabela ASCII em hexa decimal: \\xhh<\/strong><\/p>\n
es.escreva\"Usando tabela ASCII em hexa: \\x41\\x42\\x43\\n\\n\";<\/pre>\n
 <\/p>\n
\n
 <\/p>\n
Alguns detalhes:<\/strong><\/p>\n
Note que na frente do comando escrevemos duas barras obl\u00edquas \/\/ e em seguida uma frase. <\/strong>Essas barras indicam que o que estiver depois delas at\u00e9 o fim da linha n\u00e3o deve ser interpretado, logo, o interpretador ignora esta parte do programa, isto \u00e9 chamado de coment\u00e1rio, eles s\u00e3o muito \u00fateis em programas de grande porte onde voc\u00ea deve lembrar para que serve cada comando criado, descrevendo explica\u00e7\u00f5es nos coment\u00e1rios.<\/p>\n
Outra forma de fazer coment\u00e1rios \u00e9 usando a sequ\u00eancia \/**( para abrir) e ** (para fechar),<\/strong> com isso pode-se criar coment\u00e1rios de v\u00e1rias linhas sem precisar colocar as \/\/<\/strong> em cada uma delas, ex.:<\/p>\n
\/**\r\n\r\neste \u00e9 um coment\u00e1rio\r\n\r\nmulti-linha! Esta parte do c\u00f3digo n\u00e3o ser\u00e1 executada\r\n\r\n**\r\n\r\n<\/pre>\n
Aten\u00e7\u00e3o: a partir da vers\u00e3o Prisma-1.0.99 o coment\u00e1rio multilinha foi modificado:<\/strong><\/span><\/p>\n
Para abrir use \/*\u00a0\u00a0\u00a0 e para fechar\u00a0 *\/<\/strong><\/p>\n
A fun\u00e7\u00e3o imprima pode mostrar n\u00e3o s\u00f3 textos entre aspas como tamb\u00e9m n\u00fameros diretamente, veja:<\/span><\/p>\n
imprima ( 1000000 ) ; \/\/imprime o n\u00famero um milh\u00e3o na tela de comandos<\/pre>\n
 <\/p>\n
Tente este outro comando:<\/p>\n
imprima ( 444 - 100 ); \/\/imprime o n\u00famero 344, que \u00e9 o resultado de 444 menos 100<\/pre>\n
 <\/p>\n
 <\/p>\n
\"\"<\/p>\n
obs. tente mudar os n\u00fameros e a opera\u00e7\u00e3o, os sinais b\u00e1sicos de matem\u00e1tica s\u00e3o: \/ divis\u00e3o, * mutilplica\u00e7\u00e3o, + soma, – subtra\u00e7\u00e3o.<\/em><\/p>\n
Note que prisma primeiro executa a opera\u00e7\u00e3o entre par\u00eanteses at\u00e9 obter um \u00fanico resultado para depois imprimir na tela.<\/p>\n
\"\"Dica: no final de cada comando coloque um ponte-e-v\u00edrgula para separar uns dos outros, veja:<\/em><\/p>\n
imprima( 5 ) ; imprima ( 6 ) ; imprima( \"Numeros 5 e 6\");<\/pre>\n
 <\/p>\n
Sem os pontos-e-v\u00edrgulas, a execu\u00e7\u00e3o quase sempre acontecer\u00e1 sem erros, mas \u00e9 bem mais organizado com o uso do ponto-e-v\u00edrgula.<\/p>\n
 <\/p>\n
At\u00e9 agora aprendemos a mostrar textos e n\u00fameros na janela de comandos (tela preta);<\/p>\n
Vejamos uma fun\u00e7\u00e3o diferente do imprima ()<\/strong>, a fun\u00e7\u00e3o leia(), <\/strong>veja:<\/p>\n
 <\/p>\n
\/\/exemplo do uso da fun\u00e7\u00e3o leia(), salve este exemplo como: leia.prisma\r\n\r\n  x = leia( );\r\n\/\/ aguarda o usu\u00e1rio digitar algo e armazena o resultado em x \r\n\/\/ depois da tecla enter ser pressionada ;\r\n\r\nimprima ( \"Voce digitou : \" , x );\r\n\r\n\/\/fim do programa<\/pre>\n
 <\/p>\n
Note que ao executar, o cursor ficou piscando dentro da tela de comandos do windows ou terminal do linux, esperando voc\u00ea digitar algo. Ao digitar e apertar a tecla Enter o resultado ficou gravado na palavra x<\/strong>, e depois \u00e9 impresso com a fun\u00e7\u00e3o imprima.<\/p>\n
Esse efeito de gravar um resultado em um nome \u00e9 chamado de atribuir uma vari\u00e1vel (no caso o x, <\/strong>mas poderia ser qualquer outro nome ), veremos sobre vari\u00e1veis mais adiante.<\/em><\/p>\n
Talvez voc\u00ea tenha notado que usamos uma v\u00edrgula dentro da fun\u00e7\u00e3o imprima desta vez, isso \u00e9 porque temos dois argumentos colocados dentro da fun\u00e7\u00e3o, primeiro o texto : “Voce digitou : “<\/strong> e segundo a vari\u00e1vel x, <\/strong>ent\u00e3o a fun\u00e7\u00e3o mostra o texto e na sequ\u00eancia o que est\u00e1 armazenado em x; <\/strong>Veja que n\u00e3o \u00e9 impresso o x mas o valor que foi digitado, este \u00e9 o conceito de vari\u00e1vel.<\/p>\n
\"obs\"<\/a>Obs.<\/strong> Note que vari\u00e1vel \u00e9 um nome criado sem aspas, tudo o que tiver entre aspas geralmente \u00e9 uma string.<\/p>\n
\"obs\"<\/a>Obs.<\/strong> Strings em prisma podem ser feitas de outras duas maneiras al\u00e9m do uso de aspas duplas:<\/p>\n
1 – usando aspas simples :<\/p>\n
'isto \u00e9 uma string\\n';<\/pre>\n
 <\/p>\n
2 – usando duplos colchetes, permitindo uma string multi-linha, n\u00e3o aceita caracteres de escape, se tiver algum ele ser\u00e1 impresso<\/p>\n
na tela como uma string:<\/p>\n
texto = [[\r\n\r\nisto \u00e9 uma string\r\n\r\nde v\u00e1rias linhas\r\n\r\no texto ser\u00e1 impresso exatamente como est\u00e1 aqui!\r\n\r\n]]\r\n\r\nimprima ( texto );<\/pre>\n
 <\/p>\n
H\u00e1 outra forma de fazer strings multilinhas:<\/p>\n
texto = \"isto \u00e9 uma string\\\r\nde v\u00e1rias linhas\\\r\no texto ser\u00e1 impresso\\\r\nexatamente como est\u00e1 aqui!\"\r\n\r\nimprima( texto );<\/pre>\n
Para esse estilo dar certo \u00e9 necess\u00e1rio, ap\u00f3s a barra, o fim da linha. Para isso pressione enter ap\u00f3s ela, caso tenha um \u00fanico espa\u00e7o, n\u00e3o dar\u00e1 certo. Note que o mesmo sinal que abriu a string (“) no in\u00edcio, \u00e9 o que fechou no final (“).<\/p>\n
<\/h2>\n
<\/h2>\n
 <\/p>\n
<\/h1>\n
 <\/p>\n
<\/h1>\n
 <\/p>\n
<\/h1>\n
 <\/p>\n
<\/h1>\n
Cap. 2 – Palavras reservadas, operadores relacionais e l\u00f3gicos<\/strong><\/h2>\n
 <\/p>\n
 <\/p>\n
Anteriormente, n\u00f3s vimos que al\u00e9m de outras coisas, uma linguagem \u00e9 composta por palavras reservadas, mas o que ser\u00e1 isso?<\/p>\n
Palavras reservadas:<\/strong> s\u00e3o palavras comando da pr\u00f3pria linguagem, n\u00e3o podendo ser usadas com outro prop\u00f3sito:<\/p>\n
Portugu\u00eas \/\/ ingl\u00eas:<\/p>\n
    \"e\", \/\/and\r\n    \"quebre\", \/\/break\r\n    \"inicio\", \/\/do\r\n    \"senao\", \/\/else\r\n    \"senaose\",\/\/elseif\",\r\n    \"fim\", \/\/ \"end\",\r\n    \"falso\", \/\/ \"false\",\r\n    \"para\" , \/\/ \"for\",\r\n    \"funcao\" , \/\/ \"function\",\r\n    \"vapara\", \/\/ \"goto\",\r\n    \"se\", \/\/   \"if\",\r\n    \"em\", \/\/  \"in\",\r\n    \"local\", \/\/ \"local\",\r\n    \"nulo\", \/\/ \"nil\",\r\n    \"nao\", \/\/ \"not\",\r\n    \"ou\", \/\/ \"or\",\r\n    \"repita\", \/\/  \"repeat\",\r\n    \"retorne\", \/\/  \"return\",\r\n    \"entao\", \/\/ \"then\",\r\n    \"verdadeiro\", \/\/ \"true\",\r\n    \"ate\", \/\/ \"until\",\r\n    \"enquanto\" , \/\/ \"while\",\r\n    \"este\" \/\/ this \/ self<\/pre>\n
 <\/p>\n
N\u00e3o se preocupe em decor\u00e1-las, voc\u00ea aprender\u00e1 a us\u00e1-las no decorrer dos estudos, s\u00f3 est\u00e3o listadas aqui para ilustra\u00e7\u00e3o.<\/p>\n
Note que devemos usar a palavra-chave tal como ela se apresenta, ex:<\/p>\n
use o se <\/strong>e n\u00e3o SE ou Se ou sE, <\/strong>Prisma \u00e9 case sensitive, isto \u00e9, diferencia mai\u00fasculas de min\u00fasculas.<\/p>\n
Palavras reservadas e fun\u00e7\u00f5es s\u00e3o coisas diferentes, as palavras s\u00e3o fixas e imut\u00e1veis, a n\u00e3o ser,<\/p>\n
que se modifique a pr\u00f3pria linguagem, j\u00e1 as fun\u00e7\u00f5es podem ser criadas modificadas e atribu\u00eddas. logo:
\n‘enquanto’ \u00e9 de categoria diferente de ‘imprima’ ( uma \u00e9 palavra-chave e outra fun\u00e7\u00e3o );<\/p>\n
————————————————————————<\/p>\n
Al\u00e9m das palavras reservadas, temos os sinais e suas fun\u00e7\u00f5es espec\u00edficas dentro da linguagem.<\/p>\n
Sinais especiais e operadores relacionais:<\/strong><\/h3>\n
   ..    ...         ==          >=          <=            <>            <           ><\/pre>\n
 <\/p>\n

\n<\/strong><\/span><\/p>\n
\"obs\"<\/a>obs.: Quando usar os sinais compostos jamais deixe espa\u00e7o entre eles, ex.:<\/p>\n
( < =<\/strong><\/span> \/\/errado ) ( <=<\/strong><\/span> \/\/certo )<\/p>\n
veja o uso deles respectivamente:<\/p>\n
concatenar strings \/ argumentos indefinidos para fun\u00e7\u00f5es \/ testa igualdade \/ maior ou igual a \/<\/span><\/p>\n
menor ou igual a \/ diferente de \/ menor que \/ maior que<\/span><\/p>\n
Exemplos de como usar:<\/strong><\/p>\n
‘..’ (Dois pontos seguidos)
\n<\/strong><\/p>\n
 x = \"Ola\" .. \" \" .. \"Mundo\" .. \" em Prisma!!!\"; \r\n\/\/une as strings e armazena o resultado na vari\u00e1vel x ficando assim:\r\n\r\n\/\/ x = ( \"Ola Mundo em Prisma!!!\" );<\/pre>\n
 <\/p>\n
———————————————————————————————-<\/p>\n
‘…’ (Retic\u00eancias)
\n<\/strong><\/span><\/span><\/p>\n
 funcao escreva (...) \/\/aceita n\u00famero vari\u00e1vel de par\u00e2metros\r\n\r\n       imprima( ... ); \/\/imprime os par\u00e2metros passados\r\n\r\nfim\r\n\r\nescreva ( \"ola\" , \"mundo\" , \"em\" , \"Prisma\");<\/pre>\n
Se n\u00e3o conseguiu entender completamente os … n\u00e3o tem problema, o veremos mais adiante, e al\u00e9m disso, n\u00e3o s\u00e3o muitas as situa\u00e7\u00f5es que voc\u00ea precisar\u00e1 usar no momento.<\/p>\n
\/\/ poderia converter a sequ\u00eancia de par\u00e2metros em tabela (matriz):\r\n\/\/   args = { ... }; ex.:\r\n\r\nfuncao escreva( ... )\r\n\r\n           t = { ... };\r\n\r\n           para i = 1 , #t  inicio\r\n                     imprima( t[i] );\r\n           fim\r\n\r\nfim\r\n\r\nescreva( \"ola\" , \"mundo\" , \"em\" , \"prisma\");\r\n\r\n<\/pre>\n
 <\/p>\n
\n
Agora os operadores relacionais:<\/h4>\n
==       >      <       <=       >=      <> ;<\/pre>\n
( s\u00e3o muito \u00fateis para testes de condi\u00e7\u00f5es, retornam verdadeiro ou falso)<\/span><\/strong><\/p>\n
veja:<\/p>\n
a = 1; b=2; \/\/ atribuindo valores \u00e0s v\u00e1riaveis\r\n\r\n\/\/n\u00e3o confunda o operador de atribui\u00e7\u00e3o '=' com o de teste de igualdade '=='\r\n\r\nse a == b entao\r\n\r\n                  imprima(\"iguais\");\r\n\r\nsenaose a <> b entao \r\n\r\n               imprima (\"diferentes\");\r\n\r\nsenaose a < b entao\r\n\r\n              imprima( \"a menor que b\");\r\n\r\nsenaose a > b entao\r\n\r\n             imprima (\"a maior que b\");\r\n\r\nsenaose a <= b entao\r\n\r\n           imprima ( \"a menor ou igual a b\");\r\n\r\nsenaose a >= b entao\r\n\r\n          imprima( \"a maior ou igual a b\");\r\n\r\nsenao\r\n\r\n          imprima ( \"nenhuma das alternativas\");\r\n\r\nfim<\/pre>\n
 <\/p>\n
Operadores l\u00f3gicos : ou , e , nao <\/em><\/h3>\n
 <\/p>\n
(em especial, d\u00ea uma aten\u00e7\u00e3o ao operadores l\u00f3gicos, ver\u00e1 o quanto ser\u00e1 recompensador, pois problemas complexos ser\u00e3o <\/em>facilmente resolvidos com o uso de um operador l\u00f3gico, ok!)<\/em><\/p>\n
ou :<\/strong><\/h1>\n
O ou<\/strong> retorna o primeiro valor v\u00e1lido dentre v\u00e1rios, ou ent\u00e3o nulo caso nenhum seja v\u00e1lido, muito \u00fatil para testar se uma vari\u00e1vel j\u00e1 existe e atribuir ou n\u00e3o um valor a ela. Veja:<\/p>\n
 x = x ou 1; \r\nimprima(x);<\/pre>\n
 Interprete assim: x<\/strong> \u00e9 igual ao pr\u00f3prio x<\/strong> se ele j\u00e1 tiver valor ou a 1 se ele ainda n\u00e3o tem valor, isto \u00e9, se \u00e9 igual a nulo.<\/em><\/p>\n
 <\/p>\n
Voc\u00ea pode colocar v\u00e1rios operadores ‘ou’<\/strong> em sequ\u00eancia, veja:<\/p>\n
x = T  ou B ou \"Eu sou valido\";\r\n\r\nimprima ( x ); \r\n\/\/caso T tivesse um valor atribu\u00eddo x seria T, mas T no caso \u00e9 nulo, ent\u00e3o\r\n\r\n\/\/o teste passa para B, que tamb\u00e9m \u00e9 nulo, logo o teste 'ou' \r\n\/\/ passa para \"Eu sou valido\" que \u00e9 uma string, isto \u00e9,\r\n\r\n\/\/v\u00e1lida, portanto x pega entre os tr\u00eas o terceiro valor \"Eu sou valido\";<\/pre>\n
 <\/p>\n
\"obs\"<\/a> ————————————————————————————————————————-<\/p>\n
Se voc\u00ea testar v\u00e1rios valores e todos forem nulo, o retorno \u00e9 nulo.<\/p>\n
Se voc\u00ea testar v\u00e1rios valores e um for falso e o restante for nulo, ent\u00e3o falso \u00e9 atribu\u00eddo, veja:<\/p>\n
z = falso; b = nulo; t = nulo; k = nulo;\r\n\r\nx = b ou t ou k ou z;\r\n\r\nimprima( x ) ; \/\/sa\u00edda ser\u00e1 falso;<\/pre>\n
\n
 <\/p>\n
 <\/p>\n
\"obs\"<\/a> O ou<\/strong> pode ser usado em testes de condi\u00e7\u00f5es com o comando ‘se’ <\/strong>que veremos mais adiante, veja:<\/em><\/p>\n
a = 1 ; b = 3;\r\n\r\nse a > 0 ou 3 > 0 entao\r\n\r\n       imprima(\" a ou b e maior que zero \\n\"); \r\n\r\nsenao\r\n\r\n       imprima(\"Nem a nem b e mairo que zero \\n\");\r\n\r\nfim\r\n\r\n<\/pre>\n
 <\/p>\n
e :<\/strong><\/h1>\n
o operador ‘e’ retorna o primeiro valor inv\u00e1lido ( falso ou nulo), caso contrario retorna o pr\u00f3ximo at\u00e9 encontrar um nulo ou falso.<\/p>\n
 <\/p>\n
x = \"valor valido\" e TT ;  \r\n\/\/TT \u00e9 nulo j\u00e1 que n\u00e3o atribu\u00edmos ela ainda\r\n\r\nimprima (x); \/\/sa\u00edda nulo\r\n\r\na = falso; b = 2; \/\/ somente b \u00e9 valido\r\n\r\nx = b e a;\r\n\r\nimprima( x); \/\/sa\u00edda falso\r\n\r\nx = falso e nulo;\r\n\r\nimprima (x); \/\/sa\u00edda falso<\/pre>\n
 <\/p>\n
 <\/p>\n
Caso n\u00e3o tenha nenhum valor inv\u00e1lido o \u00faltimo valor \u00e9 retornado, veja:<\/p>\n
x = 2 e 4 e 5;\r\n\r\nimprima (x) \/\/ sa\u00edda 5<\/pre>\n
Podemos usar o operador ‘e’ em um teste de condi\u00e7\u00e3o, neste caso ambos os valores devem ser v\u00e1lidos para a condi\u00e7\u00e3o ser satisfeita:<\/p>\n
a = 1;  b = 10;\r\n\r\nse a < 100 e b < 100 entao\r\n     imprima\"os dois numeros sao menores que 100\\n\";\r\nsenao\r\n     imprima \"Um dos n\u00fameros nao e menor que 100\\n\";\r\nfim<\/pre>\n
 <\/p>\n
 <\/p>\n
nao :<\/strong><\/h1>\n
 <\/p>\n
O operador l\u00f3gico ‘nao’ \u00e9 un\u00e1rio isto \u00e9 n\u00e3o exige dois valores para a opera\u00e7\u00e3o, apenas um, antecedendo-o, veja:<\/p>\n
x = nao y;\r\n\r\nimprima( x );<\/pre>\n
 <\/p>\n
Este operador retorna verdadeiro ou falso:<\/p>\n
Caso o valor seja v\u00e1lido, ele retorna o oposto, ou seja, falso.<\/p>\n
Caso o valor seja inv\u00e1lido, isto \u00e9, se o valor for nulo ou falso, ele retorna verdadeiro;<\/p>\n
ex.:<\/p>\n
imprima ( nao nulo ); \/\/sa\u00edda - verdadeiro;\r\n\r\nimprima( nao falso ); \/\/sa\u00edda - verdadeiro;\r\n\r\nimprima ( nao verdadeiro ); \/\/sa\u00edda - falso;\r\n\r\na = 1;\r\n\r\nimprima ( nao a ); \/\/sa\u00edda - falso;<\/pre>\n
 <\/p>\n
\u00c9 muito \u00fatil em condi\u00e7\u00f5es:<\/p>\n
a = es.abra( 'arquivo.txt' , 'leitura' );\r\n\r\nse nao a entao imprima 'erro ao tentar abrir arquivo' fim<\/pre>\n
Caso haja um erro ao tentar abrir o arquivo o retorno \u00e9 nulo. Sendo nulo o operador nao<\/strong> retornar\u00e1 o contr\u00e1rio, isto \u00e9, verdadeiro. Assim a condi\u00e7\u00e3o \u00e9 satisfeita e a mensagem de erro \u00e9 impressa.<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
Cap. 3 – Vari\u00e1veis, tipos e a fun\u00e7\u00e3o tipo()<\/strong><\/h2>\n
 <\/p>\n
 <\/p>\n
Ao se trabalhar com uma linguagem de programa\u00e7\u00e3o temos que saber quais s\u00e3o os tipos suportados, isto \u00e9, que dados podem ser usados nesta linguagem. J\u00e1 vimos dois tipos de dados nos primeiros programas, o tipo string “texto entre aspas” e o tipo n\u00famero 1000000 por exemplo.<\/p>\n
Dados podem ser ‘apelidados’, para que ao inv\u00e9s de passarmos o dado em si, passemos o apelido que \u00e9 chamado de vari\u00e1vel em programa\u00e7\u00e3o. Por exemplo, se quisermos chamar o valor 1200.00 de salario<\/strong><\/em>, ent\u00e3o salario<\/em><\/strong> ser\u00e1 a vari\u00e1vel que pode ser atribu\u00edda da seguinte forma: salario = 1200.00<\/em><\/strong>, o ‘=<\/strong>‘ \u00e9 o operador de atribui\u00e7\u00e3o. Podemos mudar o valor de uma vari\u00e1vel bastando reatribuir outro valor, veja: salario = 2000.00<\/strong>, desta forma onde usarmos a palavra salario, ser\u00e1 passado o valor atribu\u00eddo a ela, ex.:<\/p>\n
salario = 2000;\r\nimprima(salario);\r\n\/\/reatribuindo:\r\nsalario = 3000.99\r\nimprima( salario );  \r\n\/\/ mostrar\u00e1 na tela o n\u00famero armazenado na vari\u00e1vel salario.<\/pre>\n
\n
<\/h4>\n
Vari\u00e1veis<\/h4>\n
\"entendendo\"<\/a>O que s\u00e3o vari\u00e1veis afinal?<\/strong> S\u00e3o nomes criados pelo programador para simbolizar um dado dentro da linguagem. G<\/em>eralmente a vari\u00e1vel representa o endere\u00e7o na mem\u00f3ria do valor atribu\u00eddo.<\/em><\/p>\n
\"dica\"<\/a>Dica:<\/strong><\/p>\n
Uma vari\u00e1vel pode ser criada com qualquer nome que n\u00e3o seja uma palavra reservada, no entanto, devemos seguir alguns crit\u00e9rios:<\/em><\/p>\n
1-<\/strong> nunca inicie o nome de uma vari\u00e1vel por n\u00famero ou d\u00edgito, gerar\u00e1 erro. Pode iniciar por Underline (sublinhado) ou letra.<\/em><\/p>\n
2-<\/strong> Escolha nomes que t\u00eam algo a ver com o dado armazenado, ex.: gasto = 10.00 ; lucro = 100.00 ao inv\u00e9s <\/em>de n1 = 10.00; n2 = 100.00, visto que no primeiro caso ficou muito mais f\u00e1cil entender sobre o que se trata o dado.<\/em><\/p>\n
3 –<\/strong> Se for um nome composto use iniciais mai\u00fasculas, ex.: NomeDoCliente = “Marcos”; ou separados por sublinhado, <\/em>ex.: nome_do_cliente = “Marcos”, fica muito mais leg\u00edvel do que nomedocliente ;<\/em><\/p>\n
4<\/strong> – Cuidado para n\u00e3o sobrescrever um valor de uma vari\u00e1vel j\u00e1 existente, ex.: imprima = “nome do comando”; se depois disso voc\u00ea tentar usar a fun\u00e7\u00e3o imprima( ) ver\u00e1 que ela n\u00e3o funciona mais, pois voc\u00ea reatribuiu o valor da vari\u00e1vel imprima. Sim \u00e9 claro, fun\u00e7\u00f5es s\u00e3o tipos de vari\u00e1veis em Prisma.<\/em><\/p>\n
 <\/p>\n
Vari\u00e1veis em Prisma n\u00e3o possuem tipos fixos, s\u00e3o tipadas dinamicamente, ou seja, n\u00e3o \u00e9 necess\u00e1rio declarar qual tipo uma vari\u00e1vel ir\u00e1 armazenar ( como \u00e9 feito em C por exemplo: int x = 12;<\/strong> ), basta inicializ\u00e1-la, ex:<\/p>\n
x = 12; x = 3.333333 ; x = \"uma frase qualquer\" ; x = {};\r\n\r\n\/\/veja que a vari\u00e1vel x trocou de dados v\u00e1rias vezes.<\/pre>\n
 <\/p>\n
\"obs\"<\/a><\/p>\n
Note que ao atribuirmos um novo valor a uma vari\u00e1vel j\u00e1 existente, o valor antigo se perde e o novo fica em seu lugar!<\/em><\/p>\n
*Em Prisma vari\u00e1veis n\u00e3o t\u00eam um tipo fixo, mas o dado sim carrega seu pr\u00f3prio tipo, Prisma sabe que um n\u00famero \u00e9 um n\u00famero <\/em>e n\u00e3o uma string ou vice-versa, por exemplo.<\/em><\/p>\n
\"obs\"<\/a><\/p>\n
Se voc\u00ea \u00e9 iniciante em programa\u00e7\u00e3o, deve ter um pouco de dificuldade em assimilar o conceito de vari\u00e1vel de in\u00edcio. N\u00e3o <\/em>se preocupe, voc\u00ea vai dominar o conceito conforme o tempo de estudo, o que em Prisma n\u00e3o \u00e9 t\u00e3o demorado, <\/em>visto a sua simplicidade.<\/em><\/p>\n
Apenas saiba que usamos o sinal de ‘=’ para atribuir um valor que est\u00e1 \u00e0 direita do sinal a um nome \u00e0 esquerda do <\/em>sinal, este nome passa a carregar este valor atribu\u00eddo.<\/em><\/p>\n
 <\/p>\n
\"dica\"<\/a>Em Prisma podemos atribuir diversos valores para v\u00e1rias vari\u00e1veis ao mesmo tempo, usando a v\u00edrgula, veja:<\/em><\/p>\n
a , b , c = 1 , 10 , 100; \r\n\/\/a recebe 1, b recebe 10 e c recebe 100;<\/pre>\n
 <\/p>\n
Caso sobre uma vari\u00e1vel, o valor daquela que sobrou ser\u00e1 nulo, veja:<\/em><\/p>\n
a , b , c = 1 , 2; \r\n\/\/a = 1 ; b = 2 e c = nulo pois n\u00e3o tem um terceiro valor para c;<\/pre>\n
 <\/p>\n
Se o n\u00famero de vari\u00e1veis for menor que o n\u00famero de valores atribu\u00eddos, os valores extras s\u00e3o perdidos, veja:<\/em><\/p>\n
a , b = 1 , 2 , 3; \r\n\/\/ a = 1 ; b = 2 O valor 3 se perde pois n\u00e3o h\u00e1 \r\n\/\/ uma terceira vari\u00e1vel para guardar seu valor.<\/pre>\n
 <\/p>\n
\n
Tipos de dados<\/strong><\/span><\/h4>\n
 <\/p>\n
Diferentemente de outras linguagens que t\u00eam muitos tipos de dados, em Prisma o n\u00famero deles \u00e9 bem reduzido, o que favorece a rapidez do aprendizado. Bom, vejamos os dados em Prisma:<\/p>\n
  n\u00famero, string , tabela, funcao , userdata, boolean, nulo;<\/span><\/strong><\/span><\/h3>\n
\"obs\"<\/a> obs.: para sabermos o tipo de um dado existe a fun\u00e7\u00e3o tipo ( ); ex.: imprima ( tipo( 5 ) ) ; \/\/sa\u00edda \u00e9 ‘numero’<\/em><\/p>\n
 <\/p>\n
Agora analisaremos cada um deles com exemplos, se poss\u00edvel tente assimilar ao m\u00e1ximo o conceito e utilidade deles:<\/h4>\n
 <\/p>\n
 <\/p>\n
numero<\/h3>\n
 
\n<\/span><\/strong><\/h3>\n
\u00c9 qualquer n\u00famero, n\u00e3o diferencia entre decimal e inteiros.<\/p>\n
ex:<\/p>\n
 x = 12; y = 3.14;\r\n\r\nimprima( tipo(x) , tipo(y) ); \/\/sa\u00edda ser\u00e1 :  numero       numero\r\n\r\n\/\/a funcao tipo() retorna o tipo de vari\u00e1vel.\r\n\r\n<\/pre>\n
 \"obs\"<\/a> Obs. n\u00e3o use virgula para separar as casas decimais, em programa\u00e7\u00e3o \u00e9 usado o ponto<\/strong> para isso, ok!<\/em><\/p>\n
<\/h3>\n
string<\/strong><\/h3>\n
 <\/p>\n
Qualquer sequ\u00eancia de caracteres entre aspas simples ou duplas, ou entre duplo colchetes(multilinha);<\/p>\n
ex:<\/p>\n
x = \"\\n\\n Isto e uma string\\n\" ; \r\n\/\/aceita caracteres de escape \\n = nova linha;\r\n\r\ny = '\\n\\nIsto e uma string entre aspas simples'  ; \r\n\/\/sempre feche a string como o mesmo sinal que iniciou\r\n\r\nz = [[esta\r\n\r\n\u00e9 uma\r\n\r\nstring multilinha\r\n\r\nn\u00e3o aceita caracteres de escape ela e visualizada\r\n\r\ntal como se encontra aqui!\r\n\r\n]]\r\n\r\nimprima ( tipo(x), tipo(y) , tipo (z) )\r\n\/\/ -->saida = string        string        string<\/pre>\n
 <\/p>\n
 <\/p>\n
<\/h3>\n
tabela<\/strong><\/h3>\n
 <\/p>\n
Poderoso recurso para manipula\u00e7\u00e3o de dados em massa, nada mais \u00e9 do que uma vari\u00e1vel que armazena mais de um valor ao mesmo tempo e esses valores ficam guardados em subdivis\u00f5es dentro da tabela atrav\u00e9s de \u00edndices ou campos. N\u00e3o \u00e9 necess\u00e1rio declarar o tamanho da tabela como na maioria das linguagens.<\/p>\n
Obs.: Tabelas podem ser conhecidas como vetores, matrizes, arrays etc. em outras linguagens.<\/p>\n
ex.:<\/p>\n
\/\/inicializando uma tabela vazia use chaves vazias:\r\ntab = {};\r\n\r\n\/\/inicializando uma tabela com alguns \u00edndices:\r\ntab2 = { \"um elemento string\" , 12 , 14 , \"Quinta\" , \"nome\" };\r\n\r\n\/\/ por padr\u00e3o tabelas em prisma iniciam pelo \u00edndice 1 \r\n\/\/ e n\u00e3o zero como na maioria das linguagens\r\n\r\nimprima( tab2 [1] , tab2 [2] , tab2 [3] , tab2 [4] , tab2 [5]  );\r\n\r\n\/\/ou use o comando desempacote:\r\n\r\nimprima( desempacote( tab2) );\r\n\r\n\/\/ atribuindo novos elementos a matriz\r\n\r\ntab[1] = \"primeiro elemento\";\r\n\r\ntab[2] = \"segundo elemento\";\r\n\r\n\/\/fazendo um array associativo, isto \u00e9, \r\n\/\/\u00edndices ser\u00e3o 'strings' e n\u00e3o n\u00fameros:\r\n\r\ntab3 = { [\"dia\"] = 15 , [\"mes\"] = 12 , [\"ano\"] = 2014 };\r\n\r\nimprima( tab3[ 'dia' ] .. '-' .. tab3['mes'] .. '-' tab3['ano'] ) \r\n\/\/--sa\u00edda = 15-12-2014;\r\n\r\n\/\/ logicamente existe um jeito muito \r\n\/\/ mais pr\u00e1tico de fazer isso acima, veja:\r\n\r\ntab3 = {};\r\n\r\ntab3.dia = 15; tab3.mes = 12 ; tab3.ano = 2014;\r\n\r\nimprima( tab3.dia .. '-' .. tab3.mes .. '-' .. tab3.ano ) \r\n\/\/ -->sa\u00edda = 15-12-2014\r\n\r\n\/\/poderia ser tamb\u00e9m = tab3 = { dia = 15 , mes = 12 , ano = 2014 };<\/pre>\n
 <\/p>\n
 <\/p>\n
\"dica\"<\/a>\u00e9 poss\u00edvel fazer uma matriz de componentes facilmente em prisma:<\/p>\n
para i = 1 , 4 inicio\r\n\r\n    rotulo = \"botao\" .. i\r\n\r\n    botao[ i ] = ig.botao( rotulo );\r\n\r\nfim   \/\/fim para<\/pre>\n
 <\/p>\n
cria quatro bot\u00f5es; ( botao[1], botao[2] … etc.)<\/p>\n
 <\/p>\n
Tabela \u00e9 um recurso t\u00e3o poderoso que podemos <\/strong><\/h4>\n
armazenar <\/strong>qualquer valor v\u00e1lido, inclusive fun\u00e7\u00f5es:<\/strong><\/h4>\n
 <\/p>\n
console = {};\r\nconsole.version = \"Console-1.0\";\r\n\r\nfuncao console.puts ( ... )  \r\n    \/\/lembre-se que usando os tr\u00eas pontos \r\n    \/\/passamos n\u00famero vari\u00e1vel de argumentos.\r\n\r\n   imprima( ... ); \r\n\r\n    \/\/ recebe e imprime todos os argumentos passados\r\nfim  \/\/fim funcao\r\n\r\n<\/pre>\n
 <\/p>\n
Um array associativo de uma fun\u00e7\u00e3o funciona como um m\u00e9todo de console. Veja:<\/h4>\n
 <\/p>\n
console.puts( 'Ola Mundo ' .. console.version ); \/\/ --> sa\u00edda = Ola mundo Console-1.0\r\n\r\nconsole.puts( tipo(console) ); \/\/ --> sa\u00edda = tabela;\r\n\r\nconsole.puts( tipo( console.puts ) ) ; \/\/ -- > sa\u00edda = funcao<\/pre>\n
\"obs\"<\/a> Obs.: lembre-se que o ponto separa o nome da tabela de seu campo.<\/em><\/p>\n
 <\/p>\n
Poder\u00edamos fazer uma fun\u00e7\u00e3o que passasse a pr\u00f3pria tabela como par\u00e2metro padr\u00e3o “este”:<\/h4>\n
 <\/p>\n
\/\/ex:\r\nconsole = {};\r\nconsole.versao = \"Console-1.0\";\r\n\r\nfuncao console:mostreVersao ( )  \r\n      imprima( este.versao );  \r\nfim \/\/fim funcao\r\n\r\nconsole:mostreVersao() ; \r\n\/\/ sa\u00edda = Console-1.0\r\n\r\n<\/pre>\n
Ao usar dois pontos ‘:’<\/strong> passamos a pr\u00f3pria tabela na vari\u00e1vel reservada ‘este’<\/strong>. Portanto, este.versao<\/strong> \u00e9 o mesmo que console.versao<\/strong>.<\/p>\n
A partir da vers\u00e3o Prisma-1.0.99 (2017) \u00e9 poss\u00edvel usar tamb\u00e9m os sinais\u00a0 -> <\/strong>para acessar um m\u00e9todo veja:<\/p>\n
console->mostreVersao() ;<\/pre>\n
Fica optativo, use qual preferir: os ‘:’ ou ‘->’<\/strong><\/p>\n
\"obs\"<\/a> Obs.: ‘este’<\/strong> \u00e9 uma vari\u00e1vel reservada, n\u00e3o podendo ser usada de outra forma.<\/em><\/p>\n
fun\u00e7\u00e3o
\n<\/strong><\/h3>\n
 
\n<\/span><\/strong><\/p>\n
S\u00e3o trechos automatizados de rotinas de execu\u00e7\u00e3o, fun\u00e7\u00f5es podem ou n\u00e3o receber par\u00e2metros e retornar valores, s\u00e3o muito \u00fateis para organizar o programa em sub blocos execut\u00e1veis.<\/p>\n
ex.:<\/p>\n
\/\/declarando uma fun\u00e7\u00e3o soma use a palavra reservada funcao:\r\n\r\nfuncao soma ( a , b)\r\n\r\n  retorne a + b ; \/\/retorna o valor de a somado com b\r\n\r\nfim\r\n\r\nfuncao quadrado ( a )\r\n\r\n   retorne a * a; \/\/ retorna a multiplicado por a\r\n\r\nfim\r\n\r\nfuncao raizquadrada ( a )\r\n\r\n    retorne a^ ( 1\/2 ); \r\n\/\/retorna a elevado a 0.5 , o que \r\n\/\/equivale a raiz quadrada de \"a\";\r\n\r\nfim\r\n\r\n\/\/chamando as funcoes criadas\r\n\r\nimprima( \"soma de 2 e 5 = \" , soma( 2 , 5 )  ); \r\n\/\/ sa\u00edda = soma de 2 e 5 = 7\r\n\r\nimprima ( \"5 ao quadrado = \" , quadrado( 5 ) ); \r\n\/\/ sa\u00edda = 5 ao quadrado = 25\r\n\r\nimprima( \"raiz quadrada de 25 = \" , raizquadrada( 25 ) ); \r\n\/\/ sa\u00edda = raiz quadrada de 25 = 5\r\n\r\nimprima( tipo( raizquadrada )  ); \/\/ saida =  funcao\r\n\r\n<\/pre>\n
 <\/p>\n
Fun\u00e7\u00f5es em Prisma podem retornar mais de um valor:<\/strong><\/p>\n
funcao duploquadrado ( a , b )\r\n\r\n     retorne a*a , b*b;\r\n\/\/cada retorno deve estar separado por v\u00edrgula e no final um ponto e v\u00edrgula;\r\n\r\nfim\r\n\r\n \/\/recebendo os retorno separados por v\u00edrgulas\r\n\r\nn1 , n2 = duploquadrado ( 2 , 4 ); \r\n\/\/ retorna o numero 2 e o numero 4 elevados ao quadrado;\r\n\r\n\/\/repare que para cada retorno deve ter \r\n\/\/uma vari\u00e1vel \u00e0 esquerda separada por v\u00edrgula.\r\n\r\nimprima( n1 , n2 );\r\n\r\nleia();\r\n\r\n<\/pre>\n
\"obs\"<\/a> Se uma fun\u00e7\u00e3o retornar mais de um valor e voc\u00ea se esquecer de colocar mais de uma vari\u00e1vel \u00e0 esquerda do ‘=’<\/strong> , s\u00f3 o primeiro valor ser\u00e1 atribu\u00eddo os demais se perder\u00e3o.<\/p>\n
Userdata<\/strong><\/h3>\n
 <\/p>\n
\u00c9 um tipo de dado que armazena um ponteiro para um uma vari\u00e1vel do programa compilado em C; S\u00f3 \u00e9 utilizado para acessar dados e fun\u00e7\u00f5es em Prisma da linguagem C. ex: ao usar a fun\u00e7\u00e3o jan = ig.janela( ) o retorno \u00e9 um endere\u00e7o de um ponteiro GtkWindow em C.<\/p>\n
inclua 'igbr'\r\n\r\njan = ig.janela();\r\nimprima(  tipo ( jan )  ); \r\nig.conecte( jan, ig.destruido, \"sis.saia(0)\");\r\nig.componente_mostre( jan );\r\nig.fimprograma();\r\n\/\/ -- sa\u00edda = userdata \r\n\/\/exibe uma janelinha \r\n\r\n<\/pre>\n
 <\/p>\n
Boolean<\/strong><\/h3>\n
 <\/p>\n
Armazena apenas dois valores: falso e verdadeiro<\/strong> ( em ingl\u00eas: false , true );<\/p>\n
ex:<\/span><\/p>\n
imprima ( tipo(falso) ); \r\n\/\/ -- > sa\u00edda = boolean\r\na = falso;\r\nb = verdadeiro;\r\nse a == falso entao imprima'falso' fim\r\nse b == verdadeiro entao imprima 'verdadeiro' fim\r\n\r\n<\/pre>\n
 <\/p>\n
<\/h3>\n
Nulo<\/strong><\/h3>\n
 <\/p>\n
\u00c9 qualquer valor inexistente, vazio. Ex.:<\/p>\n
imprima (   tipo( x )    );  \r\n\/\/ se x n\u00e3o foi declarada ainda ent\u00e3o n\u00e3o existe,\r\n\/\/ logo a sa\u00edda ser\u00e1 nulo.\r\n\r\n<\/pre>\n
\"obs\"<\/a> Obs.: nulo \u00e9 considerado falso em testes de condi\u00e7\u00e3o em Prisma, ex.:<\/em><\/p>\n
x = nulo;\r\n\r\nse x entao \r\n   imprima 'existe' \r\nsenao \r\n   imprima 'nao existe' \r\nfim \/\/fim  se\r\n\r\n<\/pre>\n
Para matar uma vari\u00e1vel basta atribuir a ela o valor nulo:<\/strong><\/p>\n
x = 20; \/\/x existe, possui um valor\r\nx = nulo; \/\/ x n\u00e3o existe mais, seu valor \u00e9 nulo;<\/pre>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
Cap. 4 – Escopo das vari\u00e1veis<\/strong><\/h2>\n
 <\/p>\n
O escopo pode ser: global ou local.<\/strong><\/p>\n
Em Prisma, qualquer vari\u00e1vel declarada \u00e9 global<\/strong>, isto \u00e9, seu valor pode ser usado em qualquer parte do programa ou dos m\u00f3dulos do programa principal.<\/p>\n
J\u00e1 a vari\u00e1vel de escopo local ao ser declarada deve ser antecedida pela palavra reservada local<\/strong> ex.:<\/p>\n
local x = 1;<\/pre>\n
Deste modo este tipo de vari\u00e1vel n\u00e3o \u00e9 vis\u00edvel fora do bloco ao qual pertence. O bloco pode ser uma fun\u00e7\u00e3o, um la\u00e7o condicional ou de repeti\u00e7\u00e3o, um bloco simples ou um programa Prisma.<\/p>\n
A vantagem em se declarar uma vari\u00e1vel local \u00e9 a seguran\u00e7a para que ela n\u00e3o seja modificada por uma fun\u00e7\u00e3o externa acidentalmente, ou em caso de d\u00favidas ao atribuir vari\u00e1veis com mesmo nome.<\/p>\n
Para entender melhor vejamos os exemplos:<\/p>\n
\/\/exemplo de vari\u00e1veis locais e globais:\r\n\r\nfuncao mostre_var ( )\r\n       imprima ( var1 , var2 );\r\nfim \/\/fim funcao mostre_var\r\n\r\nfuncao inicie_var ( )\r\n     var1 = \"Ola!\" ;\r\n     local var2 = \"Mundo!\";\r\nfim \/\/fim funcao inicie_var\r\n\r\n\r\nfuncao inicie_programa ( )\r\n      inicie_var( ); \/\/chamando inicie_var\r\n      mostre_var ( );\/\/chamando mostre_var\r\nfim \/\/fim funcao inicie_programa\r\n\r\ninicie_programa ( ) ; \r\n\r\n<\/pre>\n
 <\/p>\n
O resultado ser\u00e1: Ola! nulo<\/strong><\/p>\n
A segunda vari\u00e1vel \u00e9 local por isso n\u00e3o \u00e9 vis\u00edvel fora da fun\u00e7\u00e3o inicie_var ( )<\/strong> e seu valor fora dela \u00e9 inexistente: nulo.<\/p>\n
 <\/p>\n
\"dica\"<\/a>Para controlar o escopo das vari\u00e1veis sem precisar fazer uma fun\u00e7\u00e3o toda vez, podemos criar um bloco de comandos com as palavras reservadas inicio fim<\/strong>, veja:<\/p>\n
 <\/p>\n
inicio  \/\/bloco\r\n   local var1 = 1;\r\n   local var2 = 2;\r\n\r\n  imprima ( var1 , var2 ); \r\n  \/\/sa\u00edda ser\u00e1 1   2\r\nfim \/\/fim bloco\r\n\r\nimprima ( var1 , var2 ); \r\n\/\/sa\u00edda ser\u00e1 nulo   nulo pois a vari\u00e1vel\r\n\/\/ n\u00e3o \u00e9 vis\u00edvel fora do bloco\r\n\r\n<\/pre>\n
 <\/p>\n
<\/h2>\n
<\/h2>\n
Cap. 5 – Controle de fluxo e la\u00e7os de repeti\u00e7\u00e3o <\/strong><\/h2>\n
(se, enquanto, repita, para)<\/strong><\/h2>\n
 <\/p>\n
Ao escrever um programa podemos querer que ele tome decis\u00f5es, por exemplo, fechar o programa se o usu\u00e1rio digitar ‘S’<\/strong> ou executar repetidas vezes uma fun\u00e7\u00e3o at\u00e9 chegar ao fim de um arquivo.<\/p>\n
Enfim, para isso existem os la\u00e7os de controle e repeti\u00e7\u00e3o. Esses comandos s\u00e3o t\u00e3o necess\u00e1rios que qualquer linguagem os possui, e com Prisma n\u00e3o \u00e9 diferente.<\/p>\n
Para exemplificar tomemos o primeiro exemplo acima, fechar o programa ao digitar ‘S’.<\/strong><\/p>\n
Usando o comando ‘se’ :<\/strong><\/h3>\n
 <\/p>\n
A estrutura b\u00e1sica \u00e9: se<\/strong> condi\u00e7ao entao<\/strong> …c\u00f3digo… fim<\/strong><\/p>\n
imprima (\"Digite S para Sair do programa, ou aperte Enter para continuar\");\r\n\r\n    opcao = leia ( ); \r\n\/\/l\u00ea o que for digitado pelo usu\u00e1rio e armazena o valor em opcao\r\n\r\n  se opcao == 'S' ou opcao == 's' entao\r\n            sis.saia( )\r\n  fim \/\/fim se opcao\r\n\r\nimprima (\"Voc\u00ea escolheu continuar...\");\r\nleia ( );\r\n\r\n<\/pre>\n
\"obs\"<\/a> N\u00e3o esque\u00e7a de fechar o comando se<\/strong> com um fim<\/strong> respectivo. N\u00e3o se esque\u00e7a de usar a palavra entao<\/strong> depois da condi\u00e7\u00e3o.<\/p>\n
Se o usu\u00e1rio digitar o S ou s o programa \u00e9 fechado imediatamente.<\/p>\n
Note que mesmo o usu\u00e1rio n\u00e3o digitando nada o programa n\u00e3o tem muito o que fazer depois, e logo fecha.<\/p>\n
 <\/p>\n
Colocando uma exce\u00e7\u00e3o para o comando se, usando o ‘senao’:<\/strong><\/h3>\n
 <\/p>\n
Estrutura b\u00e1sica \u00e9: se<\/strong> condi\u00e7\u00e3o entao<\/strong> …c\u00f3digo… senao<\/strong> …c\u00f3digo da exce\u00e7\u00e3o… fim<\/strong><\/p>\n
imprima (\"digite um n\u00famero:\");\r\n\r\nnumero = leia ( ); \r\n\/\/ l\u00ea o que \u00e9 digitado pelo usu\u00e1rio e guarda o valor em n\u00famero\r\n\r\nnumero = convnumero (numero); \r\n\/\/converte string para n\u00famero\r\n\r\nse numero < 0 entao\r\n\r\n       imprima (\"Numero menor que zero\\n\");\r\n\r\nsenao\r\n\r\n      imprima( \"Numero maior ou igual a zero\\n\");\r\n\r\nfim<\/pre>\n
 <\/p>\n
Neste caso se a verifica\u00e7\u00e3o numero < 0<\/strong> retornar verdadeiro a primeira fun\u00e7\u00e3o imprima ser\u00e1 executada, caso ela retorne falso a fun\u00e7\u00e3o depois do senao ser\u00e1 executada, \u00e9 f\u00e1cil entender, interprete desta maneira: se numero digitado pelo usu\u00e1rio for menor que zero realiza a primeira op\u00e7\u00e3o sen\u00e3o realize a exce\u00e7\u00e3o que \u00e9 o segundo imprima.<\/em><\/p>\n
 usando o ‘se’ o ‘senaose’ e ‘senao’:<\/strong><\/h3>\n
Estrutura b\u00e1sica:<\/p>\n
se<\/strong> condi\u00e7\u00e3o entao<\/strong> …c\u00f3digo… senaose<\/strong> condi\u00e7\u00e3o entao<\/strong> …codigo2 … senao<\/strong> …exce\u00e7\u00e3o… fim<\/strong><\/p>\n
Pode-se omitir o senao<\/strong> e usar somente o fim se n\u00e3o quiser nenhuma exce\u00e7\u00e3o, ficando assim:<\/p>\n
se<\/strong> condi\u00e7\u00e3o entao<\/strong> …c\u00f3digo… senaose<\/strong> condi\u00e7\u00e3o entao<\/strong> …codigo2 … fim<\/strong><\/p>\n
 <\/p>\n
O senaose<\/strong> \u00e9 justamente para testar uma s\u00e9rie de condi\u00e7\u00f5es subsequentes, caso uma delas seja verdadeira, o c\u00f3digo do seu corpo \u00e9 executado e as demais ignoradas. Veja um exemplo:<\/p>\n
imprima( \"Digite A B  ou C\");\r\n\r\nletra = leia ( ); \r\n\/\/ l\u00ea os dados digitados pelo usu\u00e1rio e armazena em letra\r\n\r\nse letra == 'a' entao\r\n\r\n     imprima (\"digitou A\");\r\n\r\nsenaose letra == 'b' entao\r\n\r\n     imprima (\"digitou B\");\r\n\r\nsenaose letra == 'c' entao\r\n\r\n     imprima(\"digitou C\");\r\n\r\nsenao\r\n\r\n     imprima(\"nao digitou A nem B nem C\");\r\n\r\nfim\r\n\r\nleia ();<\/pre>\n
 <\/p>\n
<\/h3>\n
Comando enquanto<\/strong><\/h3>\n
 <\/p>\n
Repete um bloco enquanto o retorno da condi\u00e7\u00e3o for verdadeiro, sua estrutura b\u00e1sica \u00e9:<\/p>\n
enquanto<\/strong> condi\u00e7\u00e3o  inicio<\/strong><\/p>\n
….c\u00f3digo …..<\/p>\n
fim<\/strong><\/p>\n
Exemplo:<\/p>\n
 <\/p>\n
  \r\nlocal teste = \"\"; \/\/string vazia\r\n\r\ncont =  1;\r\n\r\nenquanto teste <> 's' inicio \r\n\/\/enquanto teste for diferente de 's'\r\n\r\n imprima (\"Digite s para sair, ou tecle enter para continuar \" , cont  );\r\n\r\n cont = cont + 1; \r\n\/\/acrescenta 1 no valor atual de cont\r\n\r\n teste = leia ( );\r\n\/\/l\u00ea os dados digitados pelo usu\u00e1rio e armazena em teste\r\n\r\nfim<\/pre>\n
 <\/p>\n
usando o comando quebre:<\/strong><\/h3>\n
 <\/p>\n
Se preferir voc\u00ea pode fazer um la\u00e7o enquanto<\/strong> infinito e controlar a repeti\u00e7\u00e3o por dentro do la\u00e7o usando o quebre<\/strong>:<\/p>\n
 <\/p>\n
 teste = \"\"\r\n\r\n cont =  1;\r\n\r\n enquanto verdadeiro inicio \r\n\/\/o la\u00e7o \u00e9 infinito j\u00e1 que verdadeiro \u00e9 sempre verdadeiro\r\n\r\n   imprima (\"Digite s para sair, ou tecle enter para continuar \" , cont  );\r\n   cont = cont + 1; \/\/acrescenta 1 no valor atual de cont\r\n   teste = leia ( ); \r\n   \/\/l\u00ea os dados digitados pelo usu\u00e1rio e armazena em teste\r\n                       \r\n   se teste == 's' entao quebre fim; \r\nfim<\/pre>\n
\"obs\"<\/a> Ao usar quebre<\/strong> o la\u00e7o \u00e9 interrompido imediatamente.<\/p>\n
 <\/p>\n
 <\/p>\n
Comando repita<\/h3>\n
 <\/p>\n
Seu funcionamento \u00e9 semelhante ao enquanto, repete um bloco at\u00e9 que a condi\u00e7\u00e3o seja verdadeira.<\/p>\n
Sua estrutura b\u00e1sica \u00e9:<\/p>\n
repita <\/strong> …. comando … ate<\/strong> condicao<\/p>\n
teste = \"\";\r\n\r\nx = 1;\r\n\r\nrepita\r\n\r\n    imprima( \"Digite s para sair ou aperte enter para continuar\" , x );\r\n\r\n    teste = leia ( );\r\n\r\n    x = x + 1;\r\n\r\nate teste == 's'; \r\n\/\/ quando teste for igual a 's' o la\u00e7o \u00e9 interrompido<\/pre>\n
\"dica\"<\/a>Outro exemplo imprimindo de 1 a 1000:<\/p>\n
local n = 1;\r\nrepita\r\n    imprima ( n );\r\n    n = n + 1;\r\nate n == 1000; \/\/imprime ate 1000 e para a repeti\u00e7\u00e3o\r\n<\/pre>\n
<\/h2>\n
<\/h2>\n
Comando ‘para’ (num\u00e9rico)<\/h3>\n
 <\/p>\n
\"obs\"<\/a> Obs.: este modelo \u00e9 chamado de num\u00e9rico porque consiste na repeti\u00e7\u00e3o de um n\u00famero inicial at\u00e9 um n\u00famero final.<\/em><\/p>\n
Este comando tamb\u00e9m serve para repeti\u00e7\u00e3o. Ao contr\u00e1rio dos demais, nele \u00e9 preestabelecido o n\u00famero de repeti\u00e7\u00f5es no pr\u00f3prio cabe\u00e7alho do comando. Para entender melhor veja:<\/p>\n
Estrutura b\u00e1sica: para<\/strong> var_inicial, var_final inicio <\/strong> ….comandos ….  fim<\/strong><\/p>\n
ex.:<\/p>\n
 para i = 1 , 1000 inicio\r\n    imprima ( i );\r\n fim<\/pre>\n
Veja que o comando em si \u00e9 bem simples, leia o exemplo acima da seguinte forma:<\/p>\n
para o valor inicial de i que \u00e9 1 incremente at\u00e9 chegar ao valor 1000 ;<\/strong><\/p>\n
\"obs\"<\/a> Note que i \u00e9 uma vari\u00e1vel local ao bloco do comando para<\/strong>, poderia ser um nome de sua escolha (desde que v\u00e1lido, lembre-se das regras ao declarar uma vari\u00e1vel em Prisma) – ex.: para<\/strong> cont = 1 , 1000 inicio<\/strong> …c\u00f3digo… fim<\/strong>;<\/p>\n
Este primeiro exemplo foi o modo simples, existem outros modos do comando para<\/strong>, n\u00e3o se preocupe, veremos todos eles com calma, voc\u00ea dominar\u00e1 cada um aos poucos.<\/p>\n
<\/h3>\n
<\/h3>\n
Adicionando o terceiro par\u00e2metro no comando para<\/strong>, o incremento:<\/h3>\n
 <\/p>\n
As vezes voc\u00ea pode querer que a repeti\u00e7\u00e3o seja de 2 em 2 ao inv\u00e9s de 1 em 1, neste caso devemos usar um terceiro par\u00e2metro no comando para<\/strong>, o incremento; o qual foi omitido no primeiro exemplo. Veja:<\/p>\n
Estrutura b\u00e1sica –  para<\/strong> var_inicial , var_final , incremento inicio<\/strong> …comandos… fim<\/strong><\/p>\n
 <\/p>\n
para i = 1 , 100 , 2 inicio\r\n       imprima ( i );\r\nfim\r\n<\/pre>\n
\"obs\"<\/a> Obs.: o n\u00famero 2 \u00e9 o tipo de incremento que significa o acr\u00e9scimo de 2 ao valor de i a cada repeti\u00e7\u00e3o, teremos ent\u00e3o na <\/em>execu\u00e7\u00e3o: 1 3 5 … e assim por diante sempre somando 2 . Poderia ser outro n\u00famero de sua prefer\u00eancia, por exemplo se <\/em>quisesse contar de 10 em 10 deveria usar 10 no lugar de 2.<\/p>\n
Note que ao omitir o terceiro par\u00e2metro o valor padr\u00e3o \u00e9 1.<\/em><\/p>\n
\"dica\"<\/a>Nunca use o sinal de mais ‘+’ para o incremento, ou gerar\u00e1 erro! Veja que os exemplos do comando para<\/strong> aqui s\u00e3o simples, apenas <\/em>imprimem o valor do incremento a cada repeti\u00e7\u00e3o, mas voc\u00ea pode adaptar e colocar qualquer comando v\u00e1lido no bloco de <\/em>repeti\u00e7\u00e3o, visto que o comando para \u00e9 muito poderoso em determinadas tarefas, veremos mais adiante.<\/em><\/p>\n
<\/h3>\n
<\/h3>\n
Determinando um decremento<\/strong><\/h3>\n
 <\/p>\n
Em algumas situa\u00e7\u00f5es voc\u00ea vai preferir que o comando para<\/strong> inicie em um valor alto, 100 por exemplo, e diminua at\u00e9 chegar ao valor m\u00ednimo: 1 ou 0, por exemplo.<\/p>\n
Veja:<\/p>\n
Estrutura b\u00e1sica – para<\/strong> valor_maximo, valor_minimo , decremento inicio<\/strong> … c\u00f3digo … fim<\/strong><\/p>\n
para i = 100 , 1 , -1 inicio\r\n      imprima ( i );\r\nfim<\/pre>\n
\"obs\"<\/a> Note que usamos o sinal de menos para o decremento. O valor do decremento foi -1, isto \u00e9, diminui 1 de i a cada repeti\u00e7\u00e3o, mas poderia ser outro valor como -2, -3 ou -10, para diminuir 2, 3 ou 10 de i a cada repeti\u00e7\u00e3o, isso depende do prop\u00f3sito do programa e do programador.<\/p>\n
<\/h3>\n
<\/h3>\n
Comando ‘para’ no modo especial (gen\u00e9rico)<\/strong><\/h3>\n
 <\/p>\n
Trata-se de um modo bem espec\u00edfico de uso do comando para<\/strong> em que usamos iteradores especiais (fun\u00e7\u00f5es de incrementos que percorrem algum tipo de dado em sequ\u00eancia).<\/p>\n
Primeiro modo, lendo os \u00edndices de uma matriz:<\/p>\n
Estrutura b\u00e1sica – para<\/strong> var_indice , var_valor em <\/strong> ipares( matriz )<\/strong> inicio<\/strong> … c\u00f3digo … fim<\/strong><\/p>\n
\/\/declarando uma matriz, lembre-se que em prisma \r\n\/\/o primeiro elemento \u00e9 o \u00edndice 1 e n\u00e3o zero como nas outras linguagens  \r\n\r\nmatriz = { \"amarelo\", \"azul\", \"branco\",\r\n            \"cinza\" , \"marrom\" , \"verde\",\r\n           \"vermelho\" };\r\n\/\/a matriz pode ser feita em v\u00e1rias linhas!\r\n\r\npara indice, valor em ipares( matriz ) inicio\r\n\r\n      imprima (  indice ,  '=' , valor ); \r\n     \/\/imprime o \u00edndice e o valor correspondente\r\n\r\nfim<\/pre>\n
\"obs\"<\/a> Note que indice<\/strong> e valor<\/strong> s\u00e3o vari\u00e1veis locais que receber\u00e3o valores da tabela a cada repeti\u00e7\u00e3o. A fun\u00e7\u00e3o ipares() percorre os \u00edndices e valores de uma tabela em Prisma. Note tamb\u00e9m que n\u00e3o usamos a v\u00edrgula no cabe\u00e7alho do comando para ao inv\u00e9s disso usamos a palavra reservada em<\/strong>.<\/p>\n
(ipares vem de \u00edndice pares.)<\/em><\/strong><\/p>\n
 <\/p>\n
Este exemplo do para<\/strong> gen\u00e9rico funciona muito bem em matrizes que possuem apenas \u00edndices num\u00e9ricos, mas n\u00e3o funciona quando o \u00edndice \u00e9 um campo, por exemplo, matriz [ ‘nome’ ] = ‘Amanda’; no exemplo acima n\u00e3o imprimiria Amanda, somente as chaves num\u00e9ricas.<\/p>\n
N\u00e3o se preocupe! Para isso temos outra fun\u00e7\u00e3o: o pares. <\/strong>Simples, n\u00e3o \u00e9?<\/p>\n
veja:<\/p>\n
estrutura b\u00e1sica – para<\/strong> chave , valor em pares (<\/strong>tabela) inicio<\/strong> …comandos … fim<\/strong><\/p>\n
\/\/exemplo do uso da fun\u00e7\u00e3o pares() no comando para gen\u00e9rico:\r\n\r\ndados = { 12, 123, 1234, nome = \"Amanda\",\r\n          idade = 23 , telefone = '65 xxxx-xxxx',\r\n          12345 };\r\ndados.novocampo = \"novocampo\";\r\n\r\npara chave, valor em pares ( dados ) inicio\r\n    imprima ( chave , valor ); \r\n\/\/imprimir\u00e1 cada campo e valor da tabela criada acima\r\nfim \/\/fim para\r\n\r\n<\/pre>\n
\"obs\"<\/a> Note que a tabela criada no exemplo acima \u00e9 mista, ou seja, possui valores indexados de forma num\u00e9rica e pares de campo com valor, ainda inclu\u00edmos um novo campo depois da cria\u00e7\u00e3o da tabela dados.<\/p>\n
Veja que a atribui\u00e7\u00e3o de chave\/valor na fun\u00e7\u00e3o pares( ) vai na ordem de \u00edndices num\u00e9ricos ( na sequ\u00eancia 1-2-3 …) para depois os campos. Estes s\u00e3o impressos na sequ\u00eancia de cria\u00e7\u00e3o.<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 Cap.6 Fun\u00e7\u00f5es<\/strong><\/h2>\n
 <\/p>\n
Em Prisma podemos dizer que fun\u00e7\u00e3o \u00e9 uma vari\u00e1vel especial que pode executar um bloco de c\u00f3digo ao ser chamada, al\u00e9m disso, ela pode receber, manipular e devolver valores. Em outras linguagens, \u00e0s vezes, s\u00e3o chamadas de procedures ou sub-rotinas.<\/p>\n
Enfim, na pr\u00e1tica temos um programa bem organizado se utilizarmos fun\u00e7\u00f5es da forma correta do que um arquivo com um enorme emaranhado de comandos.<\/p>\n
Para fazer uma fun\u00e7\u00e3o usamos a palavra reservada funcao,<\/strong> veja:<\/p>\n
Estrutura b\u00e1sica –  funcao <\/strong> nome ( par\u00e2metros )<\/strong> …c\u00f3digos… fim <\/strong><\/p>\n
\/\/exemplo de fun\u00e7\u00e3o em Prisma\r\n\r\nfuncao mostre_ola ( )\r\n      imprima( \"Ola Mundo\\n\");\r\nfim \/\/fim funcao\r\n\r\n\/\/chamando a fun\u00e7\u00e3o:\r\nmostre_ola ( );\r\n\r\nleia( ); \r\n\/\/no windows \u00e9 bom usar o comando leia para o programa\r\n\/\/ n\u00e3o fechar de repente. Se for executado no prismacod n\u00e3o \u00e9 necess\u00e1rio!\r\n\r\n<\/pre>\n
Note que a fun\u00e7\u00e3o \u00e9 bem simples, n\u00e3o recebe par\u00e2metro nem retorna dados, apenas imprima a frase Ola Mundo.<\/strong><\/p>\n
Como fun\u00e7\u00f5es em Prisma s\u00e3o vari\u00e1veis, existe um outra forma de fazer a fun\u00e7\u00e3o acima, veja:<\/p>\n
mostre_ola = funcao ( )\r\n    imprima (\"Ola Mundo\\n\");\r\nfim \/\/fim funcao\r\n\r\nmostre_ola( );\r\n\r\n<\/pre>\n
<\/h3>\n
 <\/p>\n
Definindo par\u00e2metros<\/h3>\n
 <\/p>\n
Veja, o mesmo exemplo acima, mas modificado para receber um valor e imprimir esse valor:<\/p>\n
 <\/p>\n
\/\/exemplo funcao recebendo valores\r\nfuncao escreva ( msg )\r\n    imprima ( msg );\r\nfim \/\/fim funcao\r\n\r\nescreva ( \"Ola Mundo em Prisma!\\n\");\r\n<\/pre>\n
No exemplo acima n\u00f3s definimos um par\u00e2metro para a fun\u00e7\u00e3o escreva, criando uma vari\u00e1vel entre os par\u00eanteses, sendo assim essa vari\u00e1vel \u00e9 local, isto \u00e9, s\u00f3 pode ser acessada no bloco da fun\u00e7\u00e3o.<\/p>\n
Dentro do corpo da fun\u00e7\u00e3o usamos a fun\u00e7\u00e3o imprima para imprimir o argumento passado para a fun\u00e7\u00e3o escreva.<\/p>\n
\"obs\"<\/a> Obs. Nunca coloque ponto e v\u00edrgula ap\u00f3s fechar o par\u00eanteses da fun\u00e7\u00e3o. ( funcao ( msg ); \/\/ errado )<\/em><\/p>\n
<\/h3>\n
<\/h3>\n
Devolvendo valores com o comando retorne<\/strong><\/h3>\n
 <\/p>\n
Al\u00e9m de receber valores uma fun\u00e7\u00e3o pode retornar valores, veja:<\/p>\n
funcao soma (  n1 , n2 )\r\n  local resultado = n1 + n2 ;\r\n  retorne resultado; \r\n \/\/retornando o valor da vari\u00e1vel resultado\r\nfim \/\/fim funcao\r\n\r\na = soma ( 9 , 3 ); \r\n\/\/ a soma de 9 e 3 \u00e9 retornada para a vari\u00e1vel a;\r\n\r\nimprima ( a ); \r\n\/\/imprime o valor retornado;<\/pre>\n
 <\/p>\n
\"obs\"<\/a> Observe que uma fun\u00e7\u00e3o pode receber muito mais do que dois par\u00e2metros<\/em><\/p>\n
\"dica\"<\/a>Dica – sempre nomeie as fun\u00e7\u00f5es de acordo com a tarefa que elas realizam, isso ajuda a ler e entender um programa futuramente.<\/em><\/p>\n
Ex.: raiz_quadrada ( ) ; le_texto ( ) ; dobro ( ) ; etc.<\/em><\/p>\n
 <\/p>\n
Uma vantagem em Prisma \u00e9 que uma fun\u00e7\u00e3o pode retornar mais de um resultado ao mesmo tempo, isso \u00e9 feito por meio do uso de v\u00edrgulas. Veja:<\/p>\n
funcao maior_para_menor ( n1 , n2 )\r\n\r\n            se n1 > n2 entao \r\n                 primeiro = n1 ;\r\n                 segundo = n2;\r\n           senao\r\n                 primeiro = n2;\r\n                 segundo = n1;\r\n           fim \/\/fim se\r\n\r\n    retorne primeiro , segundo; \r\n    \/\/retorna dois valores;\r\nfim \/\/fim funcao\r\n\r\n\r\nvalor1 , valor2 = maior_para_menor ( 80, 100 ); \r\n\/\/recebendo os dois valores em ordem do maior para o menor\r\n\r\nimprima( valor1, valor2 );\r\n\r\n<\/pre>\n
\"obs\"<\/a>  Veja que para cada retorno deve haver uma vari\u00e1vel \u00e0 esquerda do operador de atribui\u00e7\u00e3o ‘=’, e cada vari\u00e1vel deve <\/em>estar separada por v\u00edrgula.<\/em><\/p>\n
Caso um par\u00e2metro fosse omitido ao chamar a fun\u00e7\u00e3o, o segundo par\u00e2metro ficaria com valor nulo, veja:<\/strong><\/p>\n
valor1 , valor2 = maior_para_menor ( 9 ) ;<\/strong> \/\/n2 na fun\u00e7\u00e3o n\u00e3o foi passado ent\u00e3o seu valor \u00e9 nulo. E isso ocasionaria um erro interno na fun\u00e7\u00e3o, pois ao tentar concatenar nulo ou executar uma opera\u00e7\u00e3o com valor nulo, o programa falha e uma mensagem de erro \u00e9 exibida.<\/p>\n
E se o n\u00famero de vari\u00e1vel n\u00e3o for igual ao n\u00famero de retorno?<\/strong><\/p>\n
valor = maior_para_menor ( 1, 2 );<\/strong><\/p>\n
Neste caso somente o primeiro retorno foi passado para a vari\u00e1vel valor, o segundo retorno foi descartado!<\/p>\n
Se o n\u00famero de argumentos passados for maior do que os par\u00e2metros exigidos pela fun\u00e7\u00e3o, os argumentos extras s\u00e3o descartados.<\/p>\n
 <\/p>\n
Recursividade em fun\u00e7\u00f5es<\/h3>\n
 <\/p>\n
Este efeito \u00e9 obtido quando uma fun\u00e7\u00e3o chama a si mesma. N\u00e3o \u00e9 muito recomendado usar este recurso pelo perigo de erro dif\u00edcil de ser detectado, e pelo simples fato de o mesmo poder ser feito de outra forma mais segura.<\/p>\n
Veja, a fun\u00e7\u00e3o chama a si mesma e soma \u00e0 vari\u00e1vel um valor que \u00e9 o retorno da pr\u00f3pria fun\u00e7\u00e3o com o par\u00e2metro igual a ela mesma menos 1 v\u00e1rias vezes at\u00e9 chegar a zero:<\/p>\n
 <\/p>\n
\/\/exemplo de recursividade em Prisma,\r\n\/\/ quando uma fun\u00e7\u00e3o chama a si mesma:\r\n\r\nfuncao soma ( valor )\r\n       se valor == 0  entao    \r\n               imprima ( valor ) ; \r\n               retorne valor;\r\n       senao\r\n               valor = valor + soma( valor - 1 ) ;\r\n               imprima ( valor );\r\n               \r\n               retorne valor;\r\n        fim \/\/fim se\r\n\r\nfim \/\/fim funcao\r\n\r\nsoma ( 3 ) ; \r\n\/\/ o resultado \u00e9 a soma de 3 + 2 + 1 + 0 que \u00e9 6\r\n\r\n<\/pre>\n
Note que a sequ\u00eancia de impress\u00e3o na tela \u00e9: 0 1 3 e 6; em cada linha. Isso ocorre porque a fun\u00e7\u00e3o busca um resultado em seu retorno at\u00e9 chegar a zero, ent\u00e3o de tr\u00e1s para frente ela vai somando os resultados.<\/p>\n
\"entendendo\"<\/a>Para entender, imagine ao passar o n\u00famero 3 todo o processo que a fun\u00e7\u00e3o faz:<\/span><\/span><\/p>\n
1 – fun\u00e7\u00e3o soma \u00e9 chamada com o par\u00e2metro numero 3:<\/span><\/p>\n
 compara 3 com 0 n\u00e3o \u00e9 igual, entao: valor \u00e9 igual a valor + soma ( 3 – 1 );<\/span><\/p>\n
2 – fun\u00e7\u00e3o soma chamada novamente mas com o par\u00e2metro n\u00famero 2 ( que \u00e9 o resultado de 3 – 1);<\/span><\/p>\n
 compara 2 com 0 n\u00e3o \u00e9 igual ent\u00e3o: valor \u00e9 igual valor + a soma ( 2 – 1 );<\/span><\/p>\n
3 – soma \u00e9 chamada novamente de dentro dela mesma com o valor 1 ( resultado de 2 -1 )<\/span><\/p>\n
 compara 1 com 0 n\u00e3o \u00e9 igual ent\u00e3o: valor \u00e9 igual a valor + soma( 1 – 1 );<\/span><\/p>\n
4 – soma \u00e9 chamada novamente com valor 0 como par\u00e2metro ( resultado de 1 – 1 )<\/span><\/p>\n
 compara 0 com 0, \u00e9 igual ent\u00e3o retorna valor que \u00e9 0;<\/span><\/p>\n
 ao chegar ao resultado zero, todas as chamadas da fun\u00e7\u00e3o soma v\u00e3o retrocedendo o valor somando o \u00faltimo com o anterior, 0 + 1 + 2 + 3 chegando no resultado final 6, por isso na tela apareceu os n\u00fameros nesta ordem:<\/span><\/p>\n
0\r\n\r\n1\r\n\r\n2\r\n\r\n3\r\n\r\n6<\/pre>\n
 <\/p>\n
Como dito antes n\u00e3o \u00e9 recomendado o uso da recursividade pelo fato de que as possibilidades de gerar um erro oculto s\u00e3o maiores, e porque o mesmo resultado pode ser obtido de uma outra forma mais segura. \u00c9 totalmente dispens\u00e1vel o uso da recursividade, at\u00e9 mesmo pela sua complexidade.<\/p>\n
Veja a fun\u00e7\u00e3o anterior de outra forma mais segura:<\/p>\n
funcao soma ( valor )\r\n  local temp = 0;\r\n   para i = 0 , valor  inicio \r\n   \/\/de i que \u00e9 igual a 0 at\u00e9 valor\r\n           temp = temp + i;\r\n           imprima (temp);\r\n   fim \/\/fim para\r\n\r\n  retorne temp;\r\nfim \/\/fim funcao\r\n\r\nsoma ( 3 );<\/pre>\n
Veja que o comando para<\/strong> torna a recursividade obsoleta, sem necessidade.<\/p>\n
 <\/p>\n
\"dica\"<\/a> Uma detalhe ao se falar de fun\u00e7\u00f5es \u00e9 que quando o \u00fanico argumento for uma string ou tabela, podemos dispensar o uso de par\u00eanteses, veja:<\/p>\n
    \r\n imprima 'ola mundo';\r\n\r\n funcao imp_tabela( tab )\r\n\r\n     para i = 1 , #tab inicio\r\n            imprima( tab[i] );\r\n     fim \/\/fim para\r\n\r\n fim \/\/fim funcao \r\n\r\nimp_tabela {\"Maria\", \"Joao\", \r\n            \"Marcos\", \"Paulo\",\r\n            \"Gabriela\"};\r\n\r\n\/\/note que funciona se a string ou tabela \r\n\/\/for passada diretamente como \u00fanico argumento.\r\n\/\/com uma vari\u00e1vel n\u00e3o daria certo.\r\n\r\n<\/pre>\n
 <\/p>\n
 <\/p>\n
Al\u00e9m de tudo que vimos acima sobre fun\u00e7\u00f5es, um aspecto interessante \u00e9 que elas podem ser passadas como argumentos para outras fun\u00e7\u00f5es ou retornar fun\u00e7\u00f5es, veja:<\/p>\n
 <\/p>\n
funcao recebe_funcao (   func , param )\r\n      retorne      func( param );\r\nfim\r\n\r\n\r\nfuncao quadrado ( num )\r\n       retorne num*num; \r\n   \/\/retorna o n\u00famero vezes ele mesmo,\r\n  \/\/ ou seja, elevado ao quadrado;\r\nfim\r\n\r\nfuncao cubo ( num )\r\n      retorne num*num*num;\r\nfim\r\n\r\na = recebe_funcao ( quadrado , 2 );\r\n\/\/passamos a fun\u00e7\u00e3o quadrado com primeiro par\u00e2metro.\r\n\r\nimprima ( a ) ; \/\/saida ser\u00e1 4;\r\n\r\nb = recebe_funcao ( cubo , 2 );\r\n\r\nimprima( b ) ; \/\/sa\u00edda ser\u00e1 8 ( 2 * 2 * 2 );\r\n\r\n<\/pre>\n
 <\/p>\n
 <\/p>\n
N\u00famero indefinido de par\u00e2metros em fun\u00e7\u00f5es<\/h3>\n
 <\/p>\n
Lembre-se da fun\u00e7\u00e3o imprima() que pode receber um, dois, tr\u00eas, ou indefinidamente mais par\u00e2metros (claro que n\u00e3o infinito). Para fazermos isso em Prisma usamos o sinal de retic\u00eancias ‘…’ dentro dos par\u00eanteses no cabe\u00e7alho da fun\u00e7\u00e3o. Veja:<\/p>\n
funcao some_todos (  ...  ) \r\n     local tabela_num = { ... };\r\n     local tmp = 0;\r\n     para i = 1 , #tabela_num inicio\r\n          tmp = tmp + tabela_num[i];\r\n     fim \/\/fim para\r\n retorne tmp;\r\nfim \/\/fim funcao\r\n\r\nimprima(  some_todos( 2 , 3 , 5 )  );\r\nimprima( some_todos( 2 , 3 , 6, 54, 32 , 556 , 7)  );\r\n\r\n\/\/n\u00e3o importa se \u00e9 um ou cem argumentos passados,\r\n\/\/a fun\u00e7\u00e3o retornar\u00e1 a soma de todos.\r\n\r\n<\/pre>\n
 <\/p>\n
Veja que os ‘…’ <\/strong>representam o n\u00famero variado de argumentos que podemos colocar entre chaves e com isso criar uma tabela com todos os argumentos passados, n\u00e3o importa se um ou cem ou mais.<\/p>\n
Veja a sa\u00edda no modo prompt do interpretador:<\/p>\n
Prisma 1.0.9 Interpretador Prisma por <adalbermirom@gmail.com><\/strong>
\nSeja Bem-vindo! Tente digitar algum comando como: imprima(‘Ola, Mundo!’)<\/strong><\/p>\n
>>> funcao some_todos ( … ) <\/strong>
\n … local tabela_num = { … };<\/strong>
\n … local tmp = 0;<\/strong>
\n … para i = 1 , #tabela_num inicio<\/strong>
\n … tmp = tmp + tabela_num[i];<\/strong>
\n … fim \/\/fim para<\/strong>
\n … retorne tmp;<\/strong>
\n … fim \/\/fim funcao<\/strong>
\n>>> <\/strong>
\n>>> imprima( some_todos( 2 , 3 , 5 ) );<\/strong>
\n10<\/strong>
\n>>> imprima( some_todos( 2 , 3 , 6, 54, 32 , 556 , 7) );<\/strong>
\n660<\/strong>
\n>>> <\/strong>
\n>>> \/\/n\u00e3o importa se \u00e9 um ou cem argumentos passados,<\/strong>
\n>>> \/\/a funcao retornar\u00e1 a soma de todos.<\/strong><\/p>\n
 <\/p>\n
<\/h2>\n
<\/h2>\n
<\/h2>\n
<\/h2>\n
<\/h2>\n
<\/h2>\n
Cap. 7 Operador de tamanho e operadores aritm\u00e9ticos<\/strong><\/h2>\n
 <\/p>\n
\"matematica\"<\/a><\/p>\n
S\u00e3o eles:<\/strong><\/p>\n
#<\/strong> <\/span>(tamanho)<\/p>\n
*<\/strong><\/span> (vezes), \/<\/strong> <\/span>(divis\u00e3o) +<\/strong><\/span> (soma) , –<\/strong><\/span> (subtra\u00e7\u00e3o) , %<\/strong><\/span> (resto) , ^<\/strong><\/span> (elevado a);<\/p>\n
 <\/p>\n
\n
Veja como usar cada um deles:<\/strong><\/p>\n
 # <\/strong><\/h4>\n
<\/h4>\n
(determina o tamanho de strings e tabelas) :<\/strong><\/h4>\n
 <\/p>\n
frase = \"o tamanho desta frase e = \"\r\n\r\nimprima(  frase , #frase );  \r\n\/\/ sa\u00edda - o tamanho desta frase e =    26 \r\n   \r\ntab = { \"um elemento\" , \"outro elemento\" , 3, 4, 5, 6, 7, 8, 9 };\r\n\r\nimprima( \"A tabela tab tem\" , #tab , \"elementos\\n\" ); \r\n\/\/sa\u00edda - A tabela tab tem      9     elementos\r\n<\/pre>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
<\/h3>\n
Operadores matem\u00e1ticos ( servem para fazer opera\u00e7\u00f5es aritm\u00e9ticas):<\/strong><\/h3>\n
 <\/p>\n
imprima ( \"\\na soma de 10 e 2 = \" .. 10 + 2 );  \r\n\/\/ o \\n N\u00e3o aparece na sa\u00edda, caractere de escape nova linha\r\n \r\nimprima ( \"\\na subtracao de 10 por 2 = \" .. 10 - 2 ); \r\n\/\/lembre-se que os '..' serve para unir strings\r\n\/\/ao unir um n\u00famero a uma string, \r\n\/\/o n\u00famero \u00e9 convertido automaticamente para string!\r\n \r\nimprima( \"\\n10 vezes 2 = \" .. 10 * 2 );\r\n \r\nimprima( \"\\n10 dividido por 2 = \" .. 10 \/ 2 );\r\n \r\nimprima ( \"\\no resto de 10 dividido por 3 = \" .. 10 % 3 );\r\n \r\nimprima( string.formate ( \r\n \"numero com 4 casas decimais = %.4f , formatado para 2 casas = %.2f \" ,\r\n 2.1234 , \r\n 2.1234                \r\n )   \r\n);\r\n \r\nimprima ( \"\\n10 elevado a 2 = \" .. 10^2 );\r\n \r\nimprima ( \"\\nRaiz quadrada de 100 = \" .. 100^ (1\/2)   );\r\n \r\nimprima ( \"\\nRaiz cubica de 27 = \" .. 27^(1\/3)    );\r\n \r\nimprima ( \"\\nRaiz Quadrupla de 16 = \"  .. 16^(1\/4)  );\r\n \r\nimprima( \"\\n\\n15 por cento de 39 = \" .. 15 * (39\/100)  );\r\n\r\n<\/pre>\n
Mais adiante veremos a biblioteca ‘mat’ com fun\u00e7\u00f5es especiais para matem\u00e1tica e trigonometria;
\n<\/strong><\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
<\/h1>\n
 <\/p>\n
Unidade II – Biblioteca padr\u00e3o<\/strong><\/h1>\n
\"prisma_library\"<\/a><\/p>\n
Introdu\u00e7\u00e3o<\/strong><\/h2>\n
Prisma, assim como outras linguagens, possui fun\u00e7\u00f5es predefinidas, e que ficam organizadas em conjuntos chamados de biblioteca. Bibliotecas, tamb\u00e9m chamadas libs, podem ser internas ou externas.<\/p>\n
As internas s\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 carreg\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 mais 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
S\u00e3o as fun\u00e7\u00f5es simples tais como a imprima( ) ; tipo ( ) entre outras. Elas n\u00e3o seguem o modelo das 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
imprima ( … )<\/strong><\/h3>\n
Exibe na tela preta do cmd no Windows ou terminal no Linux texto ou n\u00fameros. Podemos passar v\u00e1rios argumentos de uma s\u00f3 vez separados por v\u00edrgulas;<\/p>\n
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 faz a impress\u00e3o ir para linha seguinte.<\/p>\n
\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, podendo 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
 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 ser 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
<\/h2>\n
\n
<\/h2>\n
Aproveitando aqui veja algumas vari\u00e1veis predefinidas importantes:<\/span>
\n<\/span><\/strong><\/h2>\n
 <\/p>\n
 * _versao –<\/strong> vari\u00e1vel que guarda a vers\u00e3o de prisma, tente executar: imprima( _versao );<\/strong><\/p>\n
 * 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
 * args –<\/strong> \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
poe ( string )<\/h3>\n
 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, n\u00e3o aceita por exemplo mais de um argumento, \u00e9 bom para strings apenas. Ex.:<\/span><\/p>\n
poe(\"Ola mundo em Prisma!\");<\/pre>\n
 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 <\/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
 <\/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 desde o in\u00edcio com a fun\u00e7\u00e3o inclua<\/strong>. <\/em>Ficando assim: executestring “seu_comando_aqui” .<\/strong><\/p>\n
\n
 executearquivo ( “caminho_do_arquivo.prisma” )<\/strong><\/span><\/h3>\n
Semelhante ao comando executestring, mas ao inv\u00e9s de executar uma string, executa um programa prisma, que pode estar compilado ou n\u00e3o.<\/p>\n
Muito \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, caso contr\u00e1rio sim.<\/p>\n
ex.:<\/p>\n
 \r\nexecutearquivo( 'ola.prisma'); \r\n\/\/--> executa um programa prisma chamado ola.prisma;<\/pre>\n
\"obs\"<\/a> Obs. Lembre-se que o nome do arquivo a ser executado deve ser escrito com a extens\u00e3o.<\/p>\n
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
 [[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: \/<\/strong><\/p>\n
 \r\n'\/home\/user\/ola.prisma'<\/pre>\n
<\/h3>\n
carregue ( string )<\/strong><\/h3>\n
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
Se houver erros, simplesmente nenhum valor \u00e9 retornado e o valor da fun\u00e7\u00e3o ser\u00e1 nulo;<\/p>\n
<\/h3>\n
<\/h3>\n
carreguearquivo ( “programa.prisma” )<\/strong><\/h3>\n
 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
Esta fun\u00e7\u00e3o, ao contr\u00e1rio da executearquivo, d\u00e1 a possibilidade de fazer um tratamento de erro:<\/p>\n
execute_arquivo = carreguearquivo ( 'ola.prisma' );\r\n\r\nse execute_arquivo entao\r\n        execute_arquivo ( ) ;\r\nsenao\r\n       imprima ( \"erro no arquivo\");\r\nfim \/\/executa o programa carregado.\r\n\r\n<\/pre>\n
 convnumero( string )<\/strong><\/h3>\n
Converte uma string para numero. 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
 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
 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 v\u00e1lido.<\/p>\n
Sua sintaxe \u00e9 :  x = tente ( 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
cod ( ‘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 tecla 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, \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
pchame ( funcao, argumentos )<\/h3>\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 principal. Ela retorna dois valores, o primeiro \u00e9 um boolean (falso ou verdadeiro) 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 a 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( funcao , funcao_erro , argumentos … )<\/h3>\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( [‘#’ ou inteiro] , args … )<\/h3>\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: selecione ( tipo , args ); \/\/onde tipo pode ser ‘#’ ou um n\u00famero inteiro.<\/p>\n
ex.:<\/p>\n
   funcao    tam ( ... );\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 \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: voce escolher a partir do argumento 3 56 78 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
\"biblioteca_str\"<\/a><\/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
Relembre a fun\u00e7\u00e3o cod,<\/strong> \u00e9 exatamente a mesma fun\u00e7\u00e3o empacotada na biblioteca string. Ela converte um caractere para sua representa\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 da 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
 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: <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: <\/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: string.procure( “string maior” , “chave” , n\u00famero_inicio );<\/p>\n
 string 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 duas 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 pelo 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 indispens\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 a 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
Sintaxe: retorno = string.formate( “String_formatacao” , args , … );<\/p>\n
Exemplo b\u00e1sico:<\/p>\n
s = string.formate( \"Ola %s!\" , \"Mundo\");\r\nimprima(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> 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