Variáveis em Prisma não possuem tipos fixos, são tipadas dinamicamente, ou seja, não é necessário declarar qual tipo
uma variável irá armazenar, basta inicializá-la, ex:
x = 12; x = 3.333333 ; x = “uma frase qualquer” ; x = {}; //veja que a variável x trocou de dados várias vezes.
cada valor guarda seu próprio tipo, eles são:
número, string , tabela, funcao , userdata, booleano, nulo;
numero
qualquer número, não diferencia entre decimal e inteiros.
ex:
|
1 2 3 4 5 |
x = 12; y = 3.14; imprima( tipo(x) , tipo(y) ); //saída será : numero numero //a funcao tipo() retorna o tipo de variável. |
string
qualquer sequência de caracteres entre aspas simples ou duplas, ou entre duplo-colchetes(multilinha);
ex:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
x = "nn Isto e uma stringn" ; //aceita caracteres de escape n = nova linha; y = 'nnIsto e uma string entre aspas simples' ; //sempre feche a string como o mesmo sinal que iniciou z = [[esta é uma string multilinha não aceita caracteres de escape ela e visualizada tal como se encontra aqui! ]] imprima ( tipo(x), tipo(y) , tipo (z) )// -->saida = string string string |
tabela:
Poderoso recurso para manipulação de dados em massa:
ex.:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
//inicializando uma tabela vazia use chaves vazias: tab = {}; //inicializando uma tabela com alguns índices: tab2 = { "um elemento string" , 12 , 14 , "Quinta" , "nome" }; //por padrão tabelas em prisma iniciam pelo índice 1 e não zero como na maioria das linguagens imprima( tab2 [1] , tab2 [2] , tab2 [3] , tab2 [4] , tab2 [5] ); ou use o comando desempacote: imprima( desempacote( tab2) ); // atribuindo novos elementos a matriz tab[1] = "primeiro elemento"; tab[2] = "segundo elemento"; //fazendo um array associativo, isto é, índices serão 'strings' e não números: tab3 = { ["dia"] = 15 , ["mes"] = 12 , ["ano"] = 2014 }; imprima( tab3[ 'dia' ] .. '-' .. tab3['mes'] .. '-' tab3['ano'] ) //--saída = 15-12-2014; //logicamente existe um jeito muito mais prático de fazer isso acima, veja: tab3 = {}; tab3.dia = 15; tab3.mes = 12 ; tab3.ano = 2014; imprima( tab3.dia .. '-' .. tab3.mes .. '-' .. tab3.ano ) // -->saída = 15-12-2014 //poderia ser também = tab3 = { dia = 15 , mes = 12 , ano = 2014 }; |
é possível fazer uma matriz de componentes facilmente em prisma:
|
1 2 3 4 5 6 7 |
para i = 1 , 4 inicio rotulo = "botao" .. i botao[ i ] = ig.botao( rotulo ); fim |
cria quatro botões; ( botao[1], botao[2] etc.)
Tabela é um recurso tão poderoso que podemos armazenar qualquer valor válido, inclusive funções:
|
1 2 3 4 5 6 7 8 9 |
console = {}; console.version = "Console-1.0"; funcao console.puts ( ... ) //lembre-se que usando os três pontos passamos número variável de argumentos. imprima( ... ); // recebe e imprima todos os argumentos passados fim |
|
1 2 3 4 5 6 7 8 9 |
//um array associativo de uma função funciona como um método de console. //ex: console.puts( 'Ola Mundo ' .. console.version ); // --> saída = Ola mundo Console-1.0 console.puts( tipo(console) ); // --> saída = tabela; console.puts( tipo( console.puts ) ) ; // -- > saída = funcao |
|
1 2 3 4 5 6 7 8 9 10 11 |
//poderíamos fazer uma função que passasse a própria tabela como parâmetro padrão "este"; //ex: funcao console:printVersion ( ) //ao usar dois pontos ':' passamos a própria tabela na variável reservada 'este'. imprima( este.version ); //portanto, este.version é o mesmo que console.version. fim console:printVersion() ; // saída = Console-1.0 |
funcao
são trechos automatizados de rotinas de execução, ex.:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
//declarando uma função soma use a palavra reservada funcao: funcao soma ( a , b) retorne a + b ; //retorna o valor de a somado com b fim funcao quadrado ( a ) retorne a * a; // retorna a multiplicado por a fim funcao raizquadrada ( a ) retorne a^ ( 1/2 ); //retorna a elevado a 0.5 , o que equivale a raiz quadrada de "a"; fim //chamando as funcoes imprima( "soma de 2 e 5 = " , soma( 2 , 5 ) ); //-- > saída = soma de 2 e 5 = 7 imprima ( "5 ao quadrado = " , quadrado( 5 ); // --> saída = 5 ao quadrado = 25 imprima( "raiz quadrada de 25 = " , raizquadrada( 25 ); //--> saída = raiz quadrada de 25 = 5 |
Funções em Prisma podem retornar mais de um valor:
|
1 2 3 4 5 6 7 8 9 10 11 |
funcao duploquadrado ( a , b ) retorne a*a , b*b; //cada retorno deve estar separado por vírgula. fim //recebendo os retorno separados por vírgulas n1 , n2 = duploquadrado ( 2 , 4 ); // retorna o numero 2 e o numero 4 elevados ao quadrado; //repare que para cada retorno deve ter uma variável à esquerda separada por vírgula. |
Userdata
É um tipo de dado que armazena um ponteiro para um programa C; Só é utilizado para acessar dados e funções em Prisma
do executável C. ex: ao usar a função jan = ig.janela( ) o retorno é um endereço de um ponteiro GtkWindow em C.
|
1 |
imprima( tipo ( jan ) ); // -- > saída = userdata |
Booleano
Armazena apenas dois valores: falso e verdadeiro ( em inglês: false , true );
ex:
|
1 |
imprima ( tipo(falso) ); // -- > saída = boolean |
Nulo
É qualquer valor inexistente, vazio. ex:
|
1 |
imprima ( tipo( x ) ); // se x não foi declarada ainda então não existe, logo a saída será nulo. |
para matar uma variável basta atribuir a ela o valor nulo;
|
1 2 3 |
x = 20; //x existe, possui um valor x = nulo; // x não existe mais, seu valor é nulo; |
Bom por enquanto é isso, até a próxima!