Gambas Linguagem de Programação introdução em PT.

[portaro]

Há algum tempo pediram-me para ver se podia criar algum material sobre a linguagem Gambas, mesmo sabendo quem mo pediu que eu não sou programador, tentei um blog mas não conseguia visitas de portugueses e pensei que talvez através de um fórum se possa dar um lugarzinho a este meu grande amigo o Gambas.

A título introdutório, não deve ser entendido de outra forma colocarei aqui mini tutoriais e se puder acompanho de vídeo em alguma ocasião e espero que se houver pessoas interessadas entendidas em Basic possam dar-me a sua mãozinha em prol de todos.

Espero que o material que deixarmos aqui ajude , não havendo hoje um fórum dedicado a Gambas em PT com conteúdo acessivel a quem não tem grandes conhecimentos de programação.

Enfim espero que sirva esta pequena contribuição que devo ao mundo Gambas, se não servir também se pode mover ou apagar.

Já agora agradecer aqui a jsbsan, Vuott, Gambas Guru e outros que pelo caminho encontrei ...

Fontes:
http://gambas.sourceforge.net/en/main.html
http://www.etnassoft.com/biblioteca/gambas-programacion-visual-con-software-libre/
http://jsbsan.blogspot.pt/
http://www.tuinstitutoonline.es/aula/course/view.php?id=307
https://gambas.guru/tiki-index.php
-------------------------------------------------------------------------------------------------------------------------

Capítulo 1 - A semente.

1.1- Linguagens de programação

1.1.1- Tudo é código máquina ! 0101 , assim todo o computador na verdade é um objecto bastante "limitado" só entende 0's e 1's , não conhece outra coisa e precisa de que alguém lhe dê - só o que ele entende- para poder fazer algo senão simplesmente não entende nada - não faz nada.

Falamos de instruções que são reconhecidas pela - lista de instruções- directamente executáveis pela -unidade de processamento e representadas de forma binária(0 e 1).

Problema do código máquina (manipulação de instruções e dados de forma binária, localização e organizaçã oda informação em memória) -são  programas dificieis de escrever ler e depurar e portanto dificieis de colocar em operação.

1.1.2- Devido a esta problemática viriam a nascer outras linguagens diversas , as linguagens ensamblador foram como a primeira resposta ao problema e consistem em instruções código máquina em forma simbólica, códigos nometécnicos fáceis de ler e recordar. No entanto um programa escrito para ensamblador não é directamente executável em máquina e será traduzido a código máquina mediante programa compativel - ensamblador - Assembler.
Ou seja do Assembly passa a Assembler para fim máquina.

1.1.3- Mais tarde surgiram as chamadas de linguagens de Alto Nível, que foram muito impulsionadas pela necessidade de tornar a escrita de código numa escrita mais voltada a semelhanças lógico-matemáticas.
Estas linguagens rápidamente foram ganhando o seu estatuto e hoje são milhares, não obstante elas terão sempre de ser traduzidas a código máquina - isso surge através dos famosos compiladores ou Intérpretes.

Método compilador →
O compilador é em sí um programa que a partir de uma código fonte produz um programa objecto(linguagem máquina):

Método Intérprete →
em tempo execução transcreve a linguagem máquina, executando um por um a sequência do código fonte do programa

1.1.4- Liguagens Estruturadas e orientadas a objectos, são um paradigma de programação orientada a melhorar a claridade qualidade e tempo de desenvolvimento de um programa de computador, utilizando apenas subrutinas e 3 estruturas , sequência , selecção, interacção. Teorema proposto por Böhm-Jacopini.
Este tipo de programação tem vantagens como a claridade do código, a simplicidade de código e tstes, reduz custos de mantimento e aumenta a produtividade.

As linguagens orientadas a objectos evoluem dos estruturados , um outro passo, neles fala-se de objectos que têm um det. estado, com det. comportamento (métodos que podem mudar o seu estado) e uma identidade (que os diferencia do resto).
Mas , se na programação estruturada os dados e procedimentos que actuam sobre os mesmos dados estão separados, já na programação orientada a objectos estão unidos.

Exemplo : um objecto pessoa que teria como dados a data de nascimento, peso.., e como métodos o "fazr anos", "engordar", poderiamos criar tantas instâncias do objecto pessoa como quiséssemos e trabalahr com elas individualmente.

Bom tudo na história tende a simplificar métodos para obter mesmos fins, essa simplificação tende a fazer mais fácil processos para que os métodos sejam mais fáceis e rápidos e claro nas linguagens de programaçã oassistimos um pouco a isso, tal qual o primeiro computador era um gigante e hoje existem do tamanho de uma mão é de supor que outras melhoras venham a surgir no futuro ao nível da tarefa de programar.

1.2-Linguagens de programação quantas são?

Milhares, seria a resposta.
Existem umas mais famosas outras menos , uma muito famosa é o Java por exemplo é multi-plataforma, sintaxe similar ao C/C+,  voltado a WEB (derivação) e tem uma grande comnunidade éd e tipo  alto nível.
Alguns nomes de algumas linguagens  para os mais curiosos - COBOL, FORTRAN, BASIC, PASCAL, C/C++, PYTHON...

A nós no Gambas interessa o Basic, Beginner'sAll Purpose Symbolic lnstruction Code , surge em 1964 - Dartmouth College por John George Kemeny e Tom Kurtzas, com o objectivo de construirem uma linguagem fácil de aprender para os seus estudantes.
O primeiro programa feito em BASIC ocorreu às 4:00 da madrugada de 1 de Maio de 1964 , o devenir viria a dotar o BASIC como uma das linguagens mais populares, passando assim do âmbito ciêntifico ao comercial num ápice.

1.3- O Gambas diz Bem-vindo!

Sim cá está o amigo Gambas um poderoso IDE que se dedica a GNU/Linux e transporta o BASIC para este sistema e muita , mas muita atenção combinar Gambas com GNU/Linux é "pólvora" em cano de "arma" , conheço algum amigo que diz Gambas = ao poder do GNU/Linux aliado à facilidade do BASIC .

O autor do Gambas é Benoît Minisini que podem ver aqui →

O Gambas surgiu porque o amigo Minisini se fartou do Visual Basic e dos seus erros e somava a isso a ânsia de poder usar GNU/Linux um sistema digno desse nome no seu computador e assim começou ele próprio a desenhar o seu ambiente para GNU/Linux surgindo o Gambas como um IDE - 28 Fevereiro de 2002, foi aí que começou o seu caminho para outros e pese embora o Gambas seja um jovem, já está dotado de muitas características importantes e metas interessantes por exemplo voltar-se não só para aplicações desktop como também WEB.

O Gambas tem uma licença GPL e  é usado em GNU/Linux um sistema também de licença livre GPL, portanto conjuga-se bem com a filosofia Livre , Libre, Free , cumprindo as 4 condições do Software Livre GPL.

A minha experiẽncia com Gambas é pequena, mas muito proveitosa e porventura dificil para mim, pois vejo programas escritos com ele que são um mundo para mim , desde programas que estão dirigidos a escolas, pequenos jogos, programas com gestão de bases de dados , programas de aceleração gráfica, de sistema , de interface a arduino etc...
Um sem fim.

Tentarei então contribuir através daqui com alguns tutorias sobre Gambas a ver se mais usuários portugueses o usam e fazem melhor do que eu que sou um curioso neste mundo.

No próximo capítulo aprenderemos um pouco mais, mesmo para quem não sabe nada de Programar!
Ensinarei o processo de instalar o Gambas em GNU/Linux Ubuntu.

Assim sendo-
Bem-vindos ao Gambas !!
Até ao próximo capítulo

[portaro]

Capítulo 2 -  O Corpo.

Antes do conhecermos o Gambas vamos aprender a instalar no Ubuntu temos um ppa com 2 versões uma estável outra a dia a dia actualizada →

Daily Build

sudo add-apt-repository ppa:gambas-team/gambas-daily

sudo apt-get update

sudo apt-get install gambas3

Stable

sudo add-apt-repository ppa:gambas-team/gambas3

sudo apt-get update

sudo apt-get install gambas3

No meu caso eu uso o Gambas no Flavitu 14 e não tenho tido problemas com ele, se surgir algum é abrir tópico na comunidade Linuxeira - Ubuntu / Debian etc...

Têm, quem quiser, uma distribuição mantida por alguns amigos como Willy Raets, o GambOS http://gambos.org/index.php?page=download&keep_session=2012252373, é uma distro com o Gambas já instalado, com adições de Gambas HowTo e ShowCase.
Ref: http://gambos.org/

Deve referir-se também que o desenvolvimento de aplicações ou o acto de programar envolve umas fases de desenvolvimento e implementação, normalmente o motivo programa surge de um problema e o acto de programar resolve / ultrapassa esse problema , reponde-lhe, existem muitos conceitos que poderiamos chamar aqui como o pseudocódigo, o algoritmo , a lógica matemática da programação etc, mas infelizmente eu não sei muito bem explicar todo esse mundo.
Mas vamos tocar nas partes mais importantes e claro , referir a etapas de desenvolvimento:
-1 Análise recolher informação para a qual o programa se vai dirigir como resposta a... sem neste momento especificar como fazer para...
2-Desenho, decompõe-se a fase análise em elementos que possam desenvolver-se, tende a dividir-se um problema grande em pequenos problemas e depois em paralelo desenvolver as respostas a cada um, avançar de modo lógico e fácil.
3- Implementação e codificação - ou seja implementa-se o código fonte e uma linguagem de programação
4-Compilação - após escrever o código compila-se para obter executáveis capazes de se portarem a outros amigos, que tenham o mesmo efeito.
5 - Teste - Alpha Beta, já ouviram falar? usa-se muito em GNU/Linux, no mundo empresarial existem empresas que contratam pessoa para dar clicks em programas com a única função de testar a ver se dá ERRO , ( tomara eu um emprego assim) eheh , é isso fase teste - comprovamos se o programa não tem erros e toma-mo-lo como apto a ser lançado (release) ou a ser estagnado (inapto) para revisão.

Bom , convém saberem que existe todo um processo anterior , antes de começar a escrever código e desenhar programas! .

1- Elementos do Gambas.

O Gambas exige uma série de elementos para se poder desenvolver nele como o:
- compilador  que transforma o código fonte e arquivos de código que conformam o projecto Gambas , tornando-os num programa executável.
-intérprete, capaz de fazer os programas criados capazes de se executarem no sistema operativo GNU/Linux.
-ambiente de desenvolvimento, facilita a programação e desenho integrado GUI de programas.
-componentes, adicionam funcionalidades aos programas Gambas, são librarias específicas da linguagem que a dotam de mais funcionalidades, por exemplo o uso de xml, conexões a rede, openg, sdl, ODBC, bases de dados, expressões regulares, QT, GTK, etc... são como que addons que permitem tal função adicional.

O processo Gambas para um programa é fácil:
-abrir o IDE
-criar um projecto
-escrever código fonte
-compilar programa traduzindo tudo a código executável em máquina
-intérprete "apanha" esse programa executável e manda ao sistema dizendo "faz isso"
- o sistema operativo "acorda" e executa o programa e realiza as acções programadas no código.

O Gambas e o seu corpo:

Logo após o lançamento apresenta a seguinte janela

Depois é o momento de escolhermos entre várias opções a que interessa a programadores é Novo Projecto.

Após tal escolha surge:

Nesta nova janela apresenta-se como que uma sangria , podemos escolher entre um projecto nivel terminal, gráfico etc, para os tutoriais que aqui vou deixar vamos usar mais o terminal logo a primeira opção.

A seguir só falta escolher o caminho do projecto (onde se gurda tudo relativo a ele):

Finalmente o nome e título do projecto :

Depois entramos no nível desenho, código e opções de edição de projecto:

[youtube ][MEDIA=youtube]Bf5jef_50tk[/MEDIA][/youtube]

O corpo do nosso Gambas é muito fácil de decorar , nada de opções estranhas , a facilidade de uso é o seu lema e como viram acima no próximo capítulo iremos já tratar de código linguagem Gambas, similar ou quase Basic, mesmo os que nada entendem de programação vão entender , eu mesmo não sei nada de programação e consigo dominar um pouquinho o Gambas.
Espero que venham a gostar do que vão encontrar nos próximos tutoriais de introdução!

https://en.wikipedia.org/wiki/Gambas
http://gambaswiki.org/wiki
https://en.wikibooks.org/wiki/Gambas
http://www.ubuntubuzz.com/2011/10/ebook-beginners-guide-to-gambas.html

[portaro]

Capítulo 3 - Linguagem Gambas

Cá estamos nós outra vez, para começarmos a dize olá , é isso que vamos fazer agora, apresentar-mo-nos perante outros dizendo um olá com o amigo Gambas. Vamos a isso:

Abrimos o Gambas , deslocamos até Novo Projecto, Terminal e aproveitamos para criar um path novo onde vamos guardar todos os distintos programas que fizermos ao longo dos tutoriais (do Minguno) :

Vejam bem eu escolhi o path /home/USER/Documentos/BASIC/zwamers , ou seja o path zwamers alvergará o meu projecto agora e esse path ficará marcado para as próximas aberturas de novos projectos facilitando o uso desse directório como albergue dos projectos , se depois mais tarde o quiser mudar procedo a mudar o path para outros directórios que eu queira, neste caso se optarem por ter um directório já escolhido para os distintos tutoriais têm a facilidade de ficarem todos os projectos num mesmo lugar!

Agora tenho de dar o nome e título ao projecto (não são editáveis mais tarde esta opção é apenas definida nesta fase!):

Pronto estamos agora a iniciar a tela de desenho de programas :

Á esquerda temos um menu de navegação entre paths/arquivos do programa : Ola-Zwamers → projecto→Fontes (aqui vivem os códigos)→dados (aqui irão dados diversos do programa exemplo - imagens).

Reparem bem que dentro de Fontes temos um Main , se clicarem lá abre-se o source code e é lá que podem escrever linguagem Gambas, nestas mesmas Fontes podemo adicionar outros "módulos" com títulos próprios, imaginem que queremos adicionar um chamado zwame pois bem clicamos no Fontes e adicionamos um novo "módulo" e ser-nos-à pedido um nome para ele que colocamos como zwame :

Ok

Ficaria uma coisa como a seguir podem ver:

Uma coisa importante é que se queremos que o nosso módulo seja o inicial dentro do programa temos de dizer isso ao nosso Gambas e fazê-mo-lo da seguinte forma - colocamos o rato sobre o nosso módulo "zwame" e damos click direito abrir-se-à um menu de opções uma dessa é "marcar como classe inicial" , carregamos nela e pronto ela será a inicial do projecto:

Vamos então agora aproveitar para escrever código no Gambas nesse nosso novo módulo!

(Uma coisa que devemos agora saber e lembrar - acho que todos nos lembramos quando iamos à escola pela primeira vez e nos começavam a ensinar o "A" , "B", .... ora nesses inícios nós não conhecíamos esses símbolos , caractéres do Abecedário , eram algo novo, depois o mesmo com as primeiras palavras, só após a segunda aula é que já assumiamos bem que um "A" era um letra lida de det. forma, com uma fonética e que conjugada com outros símbolos caractéres do Abecedário davam - palavras e mais tarde frases etc...
Ora nas linguagens de programação é exactamente o mesmo ou seja nos inícios aparecem umas palavras sem sentido nenhum para nós mas que fazem sentido dentro da "sintaxe" "própria" da "linguagem" Gambas temos de apenas as ir assimilando para depois entendermos o seu sentido, é tal qual como no primeiro dia de aulas - o "A" é "A" por ser uma letra do Abecedário só nos resta conhecer pois vamos usar porque vamos aprender a saber o Abecedário - esse estranho que entra pela sala de aula e nós não sabemos quem é! só passados umas aulas entendemos o porquê de em det. altura nos ter resultado estranho - porque afinal estávamos a aprender símbolos que nunca antes haviamos visto mas que em det. contexto - a comunicação e  linguagem entre pessoas - fazem todo sentido!).

Ora então vejam bem→

Isto é código , tentemos entender um pouco dele ↓

Logo no inicio da sintaxe temos

' Gambas module file

Isto é um comentário está a cinzento , sim é um comentário de programa, os comentários são extremamente úteis não tanto em programas de poucas linhas mas sim naqueles de muitas e muitas linhas, é que com o comentários o grémio de programadores tem uma tarefa simplificada - a de saber que det. linha do código faz, que pode sugerir det. alteração numa outra linha de código ou num outro source de chamada dentro do programa etc, é uma forma de comunicação entre programadores para dar "aviso" ou apenas remarcar algo importante.

Com o comentário acima ficamos a saber que é um módulo de programa Gambas , e anotem bem o comentário começa com ' .

E depois vem →

Public Sub Main ()

Public e Sub são palavras chave da sintaxe Gambas , ou seja sem elas não podemos "falar" "escrever" esta linguagem. Outras palavras também são chave como o Print

Elas Public Sub  estão a iniciar um procedimento , com uma função de programa , através do método de inicio Main

Print "Olá Zwamers"

O Print imprime o que está dentro de " " , é como um enviar desses caracteres para a saída neste caso para um terminal de texto.

End

End finaliza o procedimento de programa.

O resultado é :

Para aqueles que quiserem podemos ressaltar o código através de temas que o Gambas traz consigo , vejam no menu →tools → tema→ eu escolhi o Saphire e fica como vêem a seguir→

[portaro]

3.1 - Ponto à parte, entendendo código.

Para aqueles que não entendem mesmo nada de programação é muito importante arranjar alguma maneira de dar aos códigos uma forma minima de entendimento, não é fácil entender como raio um Public Sub Main () seguido de algo faz det. função.
Esse é o problema da maioria das pessoas que não saibam nada nada de programação ou que ainda por cima nem de matemáticas venham - tudo é matemática. Como eu mesmo experimentei esse problema nos inicios e me resultava dificil entender estes conjuntos de instruções e o proquê de fazerem algo, comecei a tentar estudar o proquê de cada qual (não é fácil encontrar na internet os porquês - acho que quem faz documentação de programação tende a pedir logo de inicio ao usuário lógica matemática e que se abstenha de debater os porquê das palavrinhas - Public, Sub , Main etc ....) .

Eu aqui vou optar por tentar explicar e tenho a certeza que deste modo facilito a tarefa do modo de pensar sobre esta temática ,daqueles que venham de letras e humanidades como eu ou a bem escrever que estão a zero absoluto e acabam assim por entender o porquê das palavrinhas para fazer det. fim dentro de uma sintaxe de linguagem .

Ora bem comecemos:

Temos para já a grandes rasgos 3 grandes conceitos
→ 1 → Sintaxe " Na linguística, a sintaxe é o ramo que estuda os processos generativos ou combinatórios das frases das línguas naturais, tendo em vista especificar a sua estrutura interna e funcionamento. O termo "sintaxe" também é usado para referir o estudo das regras que regem o comportamento de sistemas matemáticos, como a lógica, e as linguagens de programação de computadores." Ref: https://pt.wikipedia.org/wiki/Sintaxe
Ora então a bem dizer a sintaxe é uma combinação lógica que obedece a umas regras que geram um entendimento lógico através de uma estrutura e funcionamento conhecido e consensuado pelos que a usam.
→2→ Dentro de um programa de código temos de ter uma organização de código , eu não posso escrever um código sem me limitar às opções de sintaxe que tenho disponíveis  e essas mesmas regras de sintaxe não são definidas por mim mas sim chegam-me pelo programa que uso para programar, é ele quem tem a cabeceira de termos de sintaxe próprios e eu é que tenho de os conhecer , senão não conseguirei nem organizar  o código nem fazer com que funcione.
→3→ A sintaxe dentro do programa obedece a uma ordem específica, quase hierárquica é dizer não é o mesmo eu colocar Public Sub , que colocar Sub Public.

Portanto , para aqueles que não entendam nada de programação remarquem a importância de conhecer a sintaxe , e agora tentemos explicar o que é o Public o Sub etc...

Ora :

Public Sub Main ()

Vejam bem o Public dentro da linguagem Gambas tem um significado , sim tem um significado , tal como quando nós usamos a palavra cão dentro da sintaxe do nosso idioma PT , cão significa um animal da família canídeo subspécie lobo..., ou seja quando eu digo olha o cão voçês como conhecem essa palavra associam logo ao que ela significa , nas linguagens de programação os termos de sisntaxe da língua também significam algo. Voltemos ao Public → determina que aquilo que se declara a seguir é público (estupidamente simples não é, em Inglês Public é Público) pois bem esse é o seu significado e dentro desse âmbito esse Public dá um certo estado que por exemplo é diferente de Private , o Public não está mais do que a dizer que aquele código que se inicia é público a outras instâncias do programa ou seja é acessivel totalmente.
O Sub tem um sentido de subrutina de certo tipo, ou seja antecipa um rotina! que terá um certo tipo, por exemplo tipo Main!
O Main é o target da subrutina através do Main o programa vai accionar o que vem dentro dele ou seja no nosso caso um Print.
Esse Print tem o significado de imprimir algo e fá-lo sempre segundo uma regra = que o que seja para imprimir esteja dentro de aspas " "!

E agora que entramos em aceleração, se eu vos disser que o Private ao contrário do Public o que faz é tornar o que a seguir a ele vem em privado, ou seja só acessivel dentro do ficheiro em que é específicado ou chamado, faz todo o sentido .

Fácil não é!

Afinal a sintaxe das linguagens de programação é muito mais similar àquelas das línguas faladas do que pensamos, isto enquanto à sua estrutura lógica de entendimento interno da linguagem segue os mesmo parâmetros básicos.

Ehehehe, isto é a aprendizagem de programação ao estilo Minguno , não é porventura a mais assertiva mas pelo menos torna-a assimilável a cabeças como a minha que ao invés de pensarem bem em lógica das matemáticas pensam mais em lógica letras.

Muitas vezes o problema de se iniciarem na programação pessoas que nada sabem disso é este , fazê-las perceber as similitudes com o que já conhecem (colocá-las na zona de conforto para as levar depois às de não conforto e a partir daí - ala que se faz tarde - começam a carburar e ninguém as apanha).

Vou aproveitar aqui este balanço para denotar alguns pontos importantes a reterem →
Lembram-se de acima eu vos ter ensinado a adicionar um novo módulo?, ehehe, estava pensado para vocês ficarem a conhecer / olharem pelo menos para aquela secção da janela do nosso amigo Gambas, ora bem lá dentro andam umas pastas e olhem que elas estão mais organizadas do que parece, anotem aí - o código fonte do Gambas está composto por 1 ou mais arquivos e esses arquivos conformam um !Projecto Gambas! ;
Os arquivos tipo código, anotem bem, tipo código podem ser de 3 tipos - Módulos (contêm código Basic que se executa directamente , remarquem bem execução directa) , Classes ( contêm código Basic que executa um Objecto, remarquem , um Objecto de classe portanto) , Formulários (ora , ora , onde se desenha, remarquem, formulários servem para desenhar uma interface gráfica - janelinhas de programa, como se vocês fossem estilistas da moda dos programas eheh);
Ora assim os projectos tipo texto por exemplo o nosso acima é desse tipo só contêm Módulos e Classes os Formulários nestes casos nã ose precisam;
Ora os dados, faltam os dados, como já referi acima lá metem-se  outros, remarquem , outros tipos de arquivo que vão ou podem ser cabeceira de programa , imaginem que o vosso programa tem uma imagem.png , essa imagem.png tem de ir com o programa se for para ser instalado em algum lado, "et voilá" o arquivo imagem.png será alocado em dados senão o Gambas dirá " olha tu arranja-te mas eu não sei onde está a imagem - sê organizado!".

Mais adiante aprendermos também que a organização dos arquivos que contêm código Basic também obedecem a uma hierarquia, primeiro dizemos quais são as nossas variáveis e só depois as elencamos em possíveis subrotinas ou funções, isto é igual à organização de uma frase exemplo :
"O cão ladrava ao gato!" não é igual a - "O ! ladrava ao gato cão" , ou seja tem de haver uma organização ,como as variáveis variam consoante nós queremos, temos de identificar ao Gambas que tal "palavra" é uma variável , antes de lhe dizer - faz-me esta rotina com esta função procedimental com essa variável em consideração.

Então a recordar sempre!

Primeiro → Declaramos variável
Segundo → Subrotinas e funções para ela / com ela etc

Fácil, não é!

Já começamos a dominar o verbo Gambar ?
Eu gambo
Tu Gambas
Ele Gamba
Nós Gambamos
Eles Gambam,

No fim gambamos todos e sabemos então programar algo , nem que seja um pouquinho!

Se mesmo assim os novos amigos que estão a dar os primeiros passos em programação e chegados até aqui ainda tẽm dúvidas , sugere-se lêr e reler novamente, não saiam deste ponto sem entenderem bem isto da organização de código e de que temos de ser nós a adaptar-nos à sintaxe de código estruturado e não o contrário!

[portaro]

3.2-Dados Variáveis, Dados constantes e alguns tipos assumidos

Os programas são gestores de dados,letras , números,textos ...
Ora num programa existem dois tipos de dados, ou seja o "ser" de um certo dado assume duas opções  - ou variável ou constante!

ser Variável - o seu valor muda conforme o programa se executa.
ser Constante - o valor permanece sempre.

Como já referi acima a variável comummente conhecida assim (entender como dado que varia)  vem sempre antes do procedimento dela num Módulo, se ela vem antes fica assim depois disponível para o procedimento e sub rotinas de todo o código desse programa.

Se queremos adicionar um certo dado o qual é variável no principio de um Módulo procedemos a →

(PUBLIC | PRIVATE) nome_variável AS tipodela

Recordem se o dado variável o definirmos como PUBLIC  é público, acessivel desde outros ficheiros do programa distintos ao seu onde foi declarada, se a definimos PRIVATE só fica disponivel dentro desse ficheiro , não é acessível desde outros ficheiros distintos ao seu.

Se por outro lado queremos declarar um dado o qual é  variável já dentro de um procedimento usamos o DIM (outra palavra nova da sintaxe Gambas)

DIM nome_variável AS tipodela

Os dados assumidos constantes -!Só são definidos no principio dos Módulos!-

(PUBLIC | PRIVATE) CONST nome_de_constante AS tipo_constante = valor

!!!Então as constantes também podem ser públicas ou privadas!!!

Como assumem os dados o seu tipo de - dado de programa?

-Fácil adquirem o tipo pelo conjunto de dados que a linguagem entende também vejam bem →

Boolean
Byte
Short
Integer
Long
Single
Float
Date
String
Variant
Object (objecto criado em Gambas)


Em prática →

PUBLIC iMeuValor AS Integer 'dado variável de tipo inteiro
PUBLIC sMeuNome AS String  'dadovariável de tipo texto
PUBLIC fMeuNumero AS Float 'dado variável de tipo real

...

Para o primeiro caso teríamos um dado assumindo-se como variável de nome  iMeuValor que iria ser declarada no inicio de um módulo com um estatuto público - PUBLIC, com um tipo AS (como) inteiro (Integer).

Depois dentro desse procedimento damos o valor  - exemplificando →

iMeuValor = 1984 (Integer)
sMeuNome = Minguno (String)
fMeuNumero = 123,45 (Float)

Olha , olha , olha uma ideia e se eu quisesse que um dado variável tivesse ou assumi-se o valor de outro ?

Primeiro teria que  declarar e depois voltava a dar-lhe o valor no procedimento mas desta vez indicando-lhe , não o valor do outro dado  variável mas sim o nome do próprio dado variável ficando assim:

PUBLIC iMeuValor AS Integer 'variável de tipo inteiro
PUBLIC sMeuNome AS String  'variável de tipo texto
PUBLIC fMeuNumero AS Float 'variável de tipo real
PUBLIC sPrimeiroNome AS String 'variável tipo texto

Dentro do  procedimento

iMeuValor = 1984 (Integer)
sMeuNome = "Minguno" (String)
fMeuNumero = 123,45 (Float)
sPrimeiroNome = sMeuNome (String)*
* onde a variável sPrimeiroNome "apanha" o valor da sMeuNome e fica também com o valor dela , pois eu estou a dizer-lhe que o sPrimeiroNome é igual ao sMeuNome.

Recordem → 'isto é um comentário

Recordem → uma variável pode tomar o valor de outra mas tem de se ter em atenção o tipo dela um Boolean não é igual a String por exemplo!!!

Recordem → para que uma varável String assuma o seu valor texto temos de usar "" , exemplo "Minguno" .

Imagino que alguém ficasse com a dúvida do porquê de abaixo do Public sMeuNome As String = "Minguno" | estar um Public Sub Main()

É bastante fácil , recordem que antes do procedimento declaramos variáveis (dados) que variam , e depois podemos usar, mas se nós declarássemos o :

Public sMeuNome As String = "Minguno"

sem depois lhe darmos o procedimento Public Sub Main() -> (aqui ressalto a rotina Main) o Gambas apenas saberia que estava realmente ali um dado declarado de estatuo público , com um tipo de dado assumido String que era capaz de ser variável e  com o valor Minguno, não obstante era apenas a declaração de dado valor assumido mais nada, precisariamos do procedimento de uso que vem com :

Public Sub Main()Print sMeuNome

reparem que o Print chama o dado variável pelo seu nome - sMeuNome

Vamos falar e pegar no exemplo do dado que é um constante!

Assim entende-se bem como dizer ao Gambas que um certo dado não pode variar e portanto torna-se uma constante .

Para dizer ao Gambas que um dado não varia e é constante (fixo) usamos o termo sintaxe Const precedendo o nome do dado.

E agora finalmente acho que já conseguem entender a imagem a seguir →

Aproveitamos agora  para explicar timtim por timtim a coisa que cá nos trás.

Ora bem , dentro dos programas existem un certos dados.

Esse dados em virtude do que queremos fazer com eles podem assumir dois tipos de existência ou são variáveis ou constantes.

O Gambas precisa de que esses dados estejam disponivieis seguindo umas regras:
- a primeira a de declarar o dado (a existência dele)
- a segunda o de o poder usar depois num procedimento (sem procedimento é só dado) por exemplo usando a subrotina Main.

Feito isso temos de pensar mais uma vez na sintaxe e o Gambas precisa de saber o estatuto (Public) (Private) o qual antecede tudo o resto.

Depois tem de saber se ele vai variar ou não , ora se for para variar não colocamos nada entre o PUBLIC|PRIVATE e o Nome do dado , no entanto se não quisermos que varie  temos de lá colocar um CONST.

Ao colocarmos o CONST sabemos que ele não vai variar jamais!

Depois importa saber que os dados têm de ser conhecidos pelo Gambas e como fazemos isso? - dando-lhe nomes os que nós desejarmos  e lembrem-se um nome pode ser um alvo de valor a tomar por exemplo um dado variável pode tomar o valor de um outro exemplo - sPrimeiroNome=sMeuNome.

Depois também temos de saber que existe o AS (que é um como) sem o AS nada feito.

E finalmente devemos saber que tipo o dado assume (STRING, BOOLEAN...)
Para que o "valor" assuma um valor  !atenção aos valores !, não fique orfão portanto , temos de os especificar ou no momento de declarar o dado no inicio de um Módulo ou dentro de um procedimento exemplo Main (aqui dentro de um Main antes do nome do dado variável colocamos um DIM), assim e então dar alvo de valor  faz-se tão simplesmente com um -( = )valor.

Se esse valor for do tipo String então à frente do = levará umas aspas "" e dentro delas algo escrito exemplo = "Minguno" , caso contrário o Gambas diz ERRO! volta cá para a próxima! eheh.

Se esse valor for numérico exemplo um Integer não leva as aspas exemplo = 1984.

E nesse fim de tipo de dado assumido ficamos a saber que o que varia é na verdade ele (esse fim) um String pode variar para outro etc, se houver um CONST essa variação fica bloqueada o valor é fixo!!!


E assim → na imagem anterior vocês já percebem o todo e o porquê disso que dizem ser variáveis - porque variam e se não forem para variar tem que se meter lá o "coisinho" a dizer - CONST! Por certo um "coisinho" que faz parte de uma det. sintaxe , lembram-se da sintaxe!

Tudo é sintaxe e matemática ou lógico-matemática (esta é a parte chata da coisa e onde eu sou como gato para ir a banho de água  , tento sempre fugir ehehe).

Gostaram?

Na próxima vamos bater mais sobre isto, e se algum amigo sem conhecimentos de programação ainda tiver dificuldades , convido-o a reler , eu fui daqueles que andei e andei e andei e andei, até começar a entender algo , é encontrar a forma como nós e o nosso cérebro gosta de assimilar as coisas e depois já vai bem, acreditem em mim, já sofri muito para entender aquela etapa dita básica do Gambas. E agora estou aqui a colocar-vos a matéria do modo mais fácil que consigo, algo que eu não tive, aprendi sozinho lendo código e pedindo ajuda em códigos a usuários programadores, nesse grémio não te ensinam assim desta maneira esmiuçada - só te dão luzes depois desenrasca-te e fazem bem acho eu , se queres aprender ou lês mesmo ou vais pagar e tirar um curso como eles fizeram.


Se houver dificuldades releiam esse é o segredo, tal como o segredo de um bom programador é ler código.

A seguir exemplo de um jogo feito em Gambas por jsbsan, por enquanto nós estamos na fase do texto e feedback texto , - escrevemos código e obtemos por linha de comando a saída é importante ter boas noções da linguagem e os primeiros passos em toda a programação e seguindo essa opção ajuda  , para depois dar o salto para os métodos de uso botão janelinha etc...

[portaro]

Tipos de dados, deixo uma descrição para lerem, os conhecerem e terem em atenção o seguinte:
- nos computadores novos não, mas nos antigos era importante usar o tipo de dado correcto para uma boa relação de aplicação e consumo de RAM, devem ter em atenção a forma como estimam e aplicam o tipo de dado a usar, ainda hoje existem máquinas mais antigas em uso e nelas esta escolha ainda conta, para evitar sobrecarga / ultrapassagem da RAM da máquina nas aplicações desenhadas em Gambas temos de escolher o tipo de dado mais correcto para o nosso código.





Podem baixar o PDF aqui → https://mega.nz/#!uZl1UTbJ!A6CXEuO6ZuQGaz6wUkokWm_R1d6Yq5_70nz8ZFJmAIw

[portaro]

3.3- Dos dados variáveis às operações aritméticas , matemáticas.

Nos capítulos anteriores estabelecemos um pouco as bases mais básicas no Gambas recordemos um pouco:
O código tipo módulo / que virá a ser formulário (área de desenho de janelas programa) composto por sintaxe própria.
O uso de dados , dentro de projecto e dentro de código escrito conhecidos como variáveis ou constantes , públicos ou privados, dentro ou não de procedimentos de sub rotina (DIM).
A importância do uso do tipo de dado correcto para a melhor performance em máquina.
...

ATENÇÃO -> em alguns dos códigos seguintes aparecerá - DIM RESULTADO e depois chamada a uso em operação identificado como Resultado = .... ; foi um pequeno erro que ao estar a escrever distintos exemplos me passou despercebido até bem entrada a evolução do curso, neste caso o GAMBAS não me devolveu erro nenhum, no entanto devemos sempre fazer e certificar de que cada dado variável e posterior uso tem o mesmo nome - exacto ou igual para leitura e bom entendimento, devem portanto recordar isto, ainda que o Gambas não tome como erro do lado de programador é um erro - o código tem sempre de ser bem escrito e isso envolve tudo o que parte é do código portanto a definição de algo deve ser sempre igual sem usarmos maiúsculas e minúsculas depois para nos referirmos ao mesmo!



É um erro que dado o volume de screens e copy paste de código já feitas(os) levar-me-ia muito tempo a reescrever assim peço o vosso entendimento e as desculpas especialmente aos programadores que já me devem estar a meter numa fogueira ehehe.

Feito esse aviso, espero que não cause muita confusão e obviamente podem ficar descansados que em nada afecta o código e resultados fidedignos das operações, devem é evitar esses erros se querem um código bem limpinho e que nenhum programador possa depois queixar-se.


Hoje tocará um pouco de código  conhecer operadores aritméticos e fazer-mos a devida referência a uma nova descoberta que conhecemos do Gambas -

Antes de seguirmos para códigos mais compostos devem ficar com esta ideia -
-Os códigos fonte dos programas Gambas são compostos de um ou mais arquivos que conformam um programa!
-Os aqrquivos de código podem ser Módulos (contêm código Basic executado directamente) ou Formulários (desenhos de interface - click do action).
-Os Projectos de texto só contêm Módulos . Mas os de Formulários podem conter Formulários e Módulos!

Operadores aritméticos :

Operações básicas - + | - | * | / | ;
Operações de Potências - ^ - exemplo 4 ^ 3 ;

para a divisão existem ainda \ e MOD que respectivamente um devolve a parte inteira do resultado , o outro o resto - exemplo :
9 \ 2 = 4 , 9 MOD 4 =1

Mais à frente deixarei outras funções matemáticas usadas para cáculoas mais complexos.
Por agora entramos já em código →

Abrimos um novo projecto no path de projectos dedicados aos tuto zwame ex:
/home/USER/Documentos/BASIC/zwamers ; nome de projecto aritmetica; com o título operaçãoaritmética (exemplos de nomes podem escolher outros)

Abrimos Módulo Main um clicar sobre ele abre-o e colocamos código ! → devem nesta altura ser capazes de entender cada uma das linhas a seguir lendo o código , tal qual leriam um texto de um conto.

Vamos lá

' Gambas module file

Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Integer
   Dim NUM2 As Integer
   
   'Tenho portanto já duas variáveis dentro da rotina de procedimento acima Main
   
   'Dou-lhe instruções de uso com operador a seguir
   NUM1 = 3
   NUM2 = -6
   
   'Temos então que nesta altura os dados variáveis NUM1 NUM2 tomam valor respectivamente
   
   

End

Nesta altura temos duas secções principais de código que já entendemos todos bem
1- Abre rotina de procedimento
2- dentro da rotina declaro dados variáveis (DIM)
3-dou instruções de uso na rotina (NUM1=3) , o dado variável toma valor 3.
4-Fim

Ora o código assim apenas tem declarações de rotina procedimento e delcarações de identificação e uso dentro da rotina procedimento.

Ora , ora , ora lembram-se do Print, será que dá jeito aqui , eu acho que sim vejam bem!

Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Integer
   Dim NUM2 As Integer
   
   'Tenho portanto já duas variáveis dentro da rotina de procedimento acima Main
   
   'Dou-lhe instruções de uso com operador a seguir
   NUM1 = 3
   NUM2 = -6
   
   'Temos então que nesta altura os dados variáveis NUM1 NUM2 tomam valor respectivamente
   
   
   'vamos imprimir os NUM1 e NUM2!
   Print "====>>>" & NUM1 & " | " & NUM2 & " | " & - NUM1 & " | " & - NUM2

End

Ora vejam bem novas coisas da sintaxe a linha Print chamamos o Print para imprimir algo que o procedimento tem como operação neste caso ele :
imprime um "====>"
de seguido uso um novo operador o & (usado para concatenar em Gambas, concatenar é ligar entre código e expressão)
depois imprime / concatena com o & NUM1 & tal como está ou seja 3 ,
depois volta a imprimir  com o que vem a seguir que é um Print de " | " separador,
mais uma vez a seguir outro & NUM2 & que imprime o NUM2 tal como está,
mais uma impressão de separador " | "
e a seguir outro & -NUM1 &  o qual imprime o valor de NUM1 mas com o símbolo - antes pois eu disse para imprimir - NUM1, transformo o valor 3 a -3
a seguir outro " | " separador
e seguido outro & -NUM2 & ou seja eu digo que imprima concatene o NUM2 mas antes também lhe coloco um símbolo - este facto produz uma operação de - com um  - negativo anula e passa a positivo ou seja imprime o valor de NUM2 em vez de como está definido transformado a positivo neste caso 6!
Resultado =

====>>>3 | -6 | -3 | 6

Ponto de reflexão -
o concatenar envolve colocar de maneria ordenada o diálogo entre representação print texto e print dado variável ou resultado

Print "====>>>" & NUM1 & " | " & NUM2 & " | " & - NUM1 & " | " & - NUM2

As aspas dizem ao print imprime isto tal qual a concatenação concatena com valores , dado variavel etc .
Isto é um print tal qual  - "====>>>"
Isto é a concatenação para impressão neste caso do valor de NUM1 -  & NUM1 &
Isto volta a ser uma impressão tal qual de um separador - " | "

E agora  , vamos aos menos e mais e print resultado →

"Se algum prof de matemática ou programação andar por aqui recomenda-se que fuja eheh"

Criem um novo módulo , chamem-lhe subtrair, marquem como clase inicial (já ensinei acima como fazer) :

' Gambas module file


Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Integer
   Dim NUM2 As Integer
   Dim RESULTADO As Integer
   
   'Tenho portanto já três variáveis dentro da rotina de procedimento acima Main
   
   'Dou-lhe instruções de uso 
   NUM1 = 8
   NUM2 = 4
   Resultado = NUM1 - NUM2
   
   'Temos então que nesta altura os dados variáveis NUM1 NUM2 tomam valores e o RESULTADO armazena o resultado da subtracção de NUM1 por NUM2
   
   
   'vamos imprimir os NUM1 e NUM2!
   Print "====>>>" " " & RESULTADO

End

Atentem no seguinte , o dado RESULTADO armazena o resultado da operação de subtrair o valor de NUM1 por NUM2 , no final o Prin tem "====>>>" " " ora este  " " imprime um espaço senão no temrinal saíria algo assim - ====>>>4  ; como o uso da impressão de um espaço " " fica assim - ====>>> 4   !!! mais organizadito.

Somemos então... novo módulo, nome soma, marquem como classe inicial...

' Gambas module file




Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Integer
   Dim NUM2 As Integer
   Dim RESULTADO As Integer
   
   'Tenho portanto já três variáveis dentro da rotina de procedimento acima Main
   
   'Dou-lhe instruções de uso 
   NUM1 = 8
   NUM2 = 8
   Resultado = NUM1 + NUM2
   
   'Temos então que nesta altura os dados variáveis NUM1 NUM2 tomam valores e o RESULTADO armazena o resultado da soma de NUM1 por NUM2
   
   
   'vamos imprimir os NUM1 e NUM2!
   Print "====>>>" " " & RESULTADO

End

Nada novo.

Vamos à Multiplicação.

Novo Módulo → nome multiplicar (por exemplo), marcamos como classe inicial e código :

' Gambas module file

Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Integer
   Dim NUM2 As Integer
   Dim RESULTADO As Integer
   
   'Tenho portanto já três variáveis dentro da rotina de procedimento acima Main
   
   'Dou-lhe instruções de uso 
   NUM1 = 8
   NUM2 = 5
   Resultado = NUM1 * NUM2
   
   'Temos então que nesta altura os dados variáveis NUM1 NUM2 tomam valores e o RESULTADO armazena o resultado da subtracção de NUM1 por NUM2
   
   
   'vamos imprimir o resultado!
   Print "====>>>" " " & RESULTADO

End

Continuamos para o exemplo divisão.

Novo Módulo → nome dividir (exemplo) , marcamos como classe inicial e código :

' Gambas module file


Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Integer
   Dim NUM2 As Integer
   Dim RESULTADO As Integer
   
   'Tenho portanto já três variáveis dentro da rotina de procedimento acima Main
   
   'Dou-lhe instruções de uso 
   NUM1 = 8
   NUM2 = 5
   Resultado = NUM1 / NUM2
   
   'Temos então que nesta altura os dados variáveis NUM1 NUM2 tomam valores e o RESULTADO armazena o resultado da divisão de NUM1 por NUM2
   
   
   'vamos imprimir o resultado!
   Print "====>>>" " " & RESULTADO

End

UUUUUPPPPS !!! Soou algum apito!

Eu acho que sim, o programador cometeu uma falha! Será que 8 a dividir por 5 dá 1 ?
Não na verdade dá 1,6 !

Ora, ora o problema é do programador vejam bem , adivinham qual é o problema?

Uhau acho que acertaram então vamos lá corrigir o código!
Tipo de dado Integer não é igual a tipo de dado Float - sim , um só se ocupa de inteiros e outros ocupa-se de valores com decimais portanto seria mais certo usar um Float para o resultado ser com decimais incluídas.

' Gambas module file


Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Integer
   Dim NUM2 As Integer
   Dim RESULTADO As Float  'Float para décimais lembrem
   
   'Tenho portanto já três variáveis dentro da rotina de procedimento acima Main
   
   'Dou-lhe instruções de uso 
   NUM1 = 8
   NUM2 = 5
   Resultado = NUM1 / NUM2
   
   'Temos então que nesta altura os dados variáveis NUM1 NUM2 tomam valores e o RESULTADO armazena o resultado da divisao de NUM1 por NUM2
   
   
   'vamos imprimir o resultado!
   Print "====>>>" " " & RESULTADO

End

Se eu não usá-se o Float teria um envio de resultado inteiro sem julgamento de , décimais, 1. 4 - 1 , 1.6 - 1 .
Portanto ficamos avisados o tipo de dado é sempre muito mas muito importante dentro de um procedimento senão podemos obter pequenos dados problemáticos, sempre que possivel programar o mais objectivo possivel quando projectamos o código...

[portaro]

Continuamos e vamos à divisão inteira.

Novo Módulo → divinteira (exemplo de nome) , marquem como classe inicial e código:

' Gambas module file


Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Integer
   Dim NUM2 As Integer
   Dim RESULTADO As Integer 
   
   'Tenho portanto já três variáveis dentro da rotina de procedimento acima Main
   
   'Dou-lhe instruções de uso 
   NUM1 = 9
   NUM2 = 5
   Resultado = NUM1 \ NUM2
   
   'Temos então que nesta altura os dados variáveis NUM1 NUM2 tomam valores e o RESULTADO armazena o resultado da divisao inteira de NUM1 por NUM2
   
   
   'vamos imprimir o resultado!
   Print "====>>>" " " & RESULTADO

End

Outra vez , obtemos apenas 1 porque usamos o operador ( \ ) - divisão inteira (inteiros) , não devolve décimais tome-no como se o computador apaga-se tudo o que está despois da (,) , ora vamos aproveitar e usar outro operador para que nos retorne o resto .

' Gambas module file


Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Integer
   Dim NUM2 As Integer
   Dim RESULTADO As Integer 
   Dim RESTO As Integer  'criamos novo dado variável aramazena o resto da divisão inteira
   
   'Tenho portanto já três variáveis dentro da rotina de procedimento acima Main
   
   'Dou-lhe instruções de uso 
   NUM1 = 9
   NUM2 = 5
   RESULTADO = NUM1 \ NUM2
   RESTO = NUM1 Mod NUM2  'usamos o operador MOD
   
   'Temos então que nesta altura os dados variáveis NUM1 NUM2 tomam valores e o RESULTADO armazena o resultado da divisao inteira de NUM1 por NUM2
   
   
   'vamos imprimir o resultado!
   Print "====>>>" " " & RESULTADO
   Print "====>>>" " " " E o resto é" " " & RESTO

End

E agora vamos usar um dos exemplos para demonstrar como o Gambas Lê os códigos (de cima para baixo) imaginem os seguintes códigos em que o procedimento é uma divisão inteira :

' Gambas module file


Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Integer
   Dim NUM2 As Integer
   Dim RESULTADO As Integer 
   
   'Tenho portanto já três variáveis dentro da rotina de procedimento acima Main
   
   'Dou-lhe instruções de uso 
   NUM1 = 9
   NUM2 = 5
   Resultado = NUM1 \ NUM2
   
   'Temos então que nesta altura os dados variáveis NUM1 NUM2 tomam valores e o RESULTADO armazena o resultado da divisao inteira de NUM1 por NUM2
   
   
   'vamos imprimir o resultado!
   Print "====>>>" " " & RESULTADO

End

Dim RESULTADO As Integer   substituamos o tipo por de dado por Float

' Gambas module file


Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Integer
   Dim NUM2 As Integer
   Dim RESULTADO As Float
   
   'Tenho portanto já três variáveis dentro da rotina de procedimento acima Main
   
   'Dou-lhe instruções de uso 
   NUM1 = 9
   NUM2 = 5
   RESULTADO = NUM1 \ NUM2
   
   'Temos então que nesta altura os dados variáveis NUM1 NUM2 tomam valores e o RESULTADO armazena o resultado da divisao inteira de NUM1 por NUM2
   
   
   'vamos imprimir o resultado!
   Print "====>>>" " " & RESULTADO

End

Lembremos que na declaração de dados variável nós dissemos ao Gambas - .Dim RESULTADO As Float , mas depois no procedimento nós dissemo - Resultado = NUM1 \ NUM2 , ora o Gambas fez a seguinte leitura :

Começou a ler o código do Módulo de cima para baixo :
→A primeira coisa que encontrou foi - Public Sub Main() ; ou seja inicio de procedimento rotina Main.
→Depois encontrou - Dim NUM1 As Integer.
→Depois - Dim NUM2 As Integer
→Depois - Dim RESULTADO As Float    ' aqui ele marcou o RESULTADO como lembrete a dizer " isto é um tipo de dado variável com tipo Float que para ele diz - tenho de mostrar isto com décimais se houver.
→ Depois - NUM1 = 9 , NUM1 tomou valor 9.
→ Depois - NUM2 = 5 , NUM2 tomou valor 5
→ Depois - RESULTADO = NUM1 \ NUM2 , ' o Gambas viu que afinal o RESULTADO agora já não era para ser mostrado usando décimais mas sim que agora passou a a ser o tal RESULTADO uma divisão inteira ( que só toma o que está antes da vírgulas) processou-a então substituindo este processo de procedimento o tipo de dado que definimos anteriormente no caso tomar o RESULTADO como Float.
→ Depois - Print "====>>>" " " & RESULTADO , imprimiu o dado armazenado em RESULTADO que é o resultado da operação (\)
→ Depois - End , finalizou o Procedimento rotina Main.

O Gambas lê o código sempre de cima para baixo e a operação ou variável dada fica sempre com o último valor /ordem encontrado(a) no código.

Vamos agora saltar para uma outra "Mingunada" com o exemplo de potências.

Novo Módulo, nome potencias (exemplo) , marquem como classe inicial e código :

' Gambas module file


Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Integer
   Dim NUM2 As Integer
   Dim RESULTADO As Integer

   
   'Tenho portanto já três variáveis dentro da rotina de procedimento acima Main
   
   'Dou-lhe instruções de uso 
   NUM1 = 2
   NUM2 = 4
   RESULTADO = NUM1 ^ NUM2 'multiplica o valor base 2 fazendo uso do expoente neste caso 4 - numero de vezes a multiplicar 2- 2*2*2*2
   
   'Temos então que nesta altura os dados variáveis NUM1 NUM2 tomam valores e o RESULTADO armazena o resultado
   
   
   'vamos imprimir o resultado!
   Print "====>>>" " " & RESULTADO

End

É altura agora de conhecermos outros operadores , além dos que já usamos...

3.3.1-Operadores extra.

Abs → devolve o valor absoluto de um número
Dec → Diminuir
Inc → Incrementar
Frac → devolve a parte décimal de um número
Int → devolve a parte inteira de um número
Max → devolve apenas o número maior
Min → devolve o número menor
Round → redondeia um número com os décimais desejados
Sgn → devolve o signo de um número
Rnd → devolve um número aleatório compreendido entre Mínimo e Máximo se não se lhe expressa nada devolve um entre 0 e 1 , se só se expressa um número a operação derá feita entre 0 esse expressado, antes de ser usado precisa da instrução Randomize que é a que se inicializa para gerar números aleatórios, se ela nã ose inicializa o Rnd dará sempre o mesmo número sempre que usado.

Exemplo de um Dec,

Novo Módulo, nome diminuir, marquem como classe inicial e código :

' Gambas module file

Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Integer
   Dim NUM2 As Integer

  'Dou-lhe instruções de uso 
   NUM1 = 7
   NUM2 = 4
  'a seguir usamos o DEC e Inc
   Dec NUM1
   Inc NUM2
   
   'vamos imprimir o resultado!
   Print "====>>>" " " & NUM1 & " | " & NUM2

End

Dec → diminui o número em menos 1 ou seja 7 - 1 = 6
Inc→ incrementou o número em 1 ou seja 4 + 1 = 5

3.3.2-Conversão de tipo de dados explicita e implicita.

O Gambas é fenómeno e permite a conversão de tipo de dados, a forma de converter pode ser implícita e explicita.

Exemplo de conversão Implícita:

' Gambas module file

Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Float
   Dim NUM2 As Float
   Dim RESULTADO As Integer

  'Dou-lhe instruções de uso 
   NUM1 = 7.4
   NUM2 = 4
   RESULTADO = NUM1 * NUM2

   
   'vamos imprimir o resultado!
   Print "====>>>" " " & RESULTADO

End

Como faz o Gambas para poder multiplicar , faz uma conversão implícita, ou seja ele transforma o NUM2 = 2 EM NUM2 = 2.0 para assim poder multiplicar os diferentes valores e devolver num tipo de dado RESULTADO (Integer).
Porquê do Gambas fazer isto ?
Simples os computadores têm que 2 é diferente de 2.0 , para o nosso cérebro é uma informação assimilável que nada afecta o processo mas para um computador é um problema dos grandes ehehehe , então ele precisa de saber com exactidão que tipo  de dado é e o Gambas como é nosso amigo sabe que o computador é um "tipo com mau humor" e então converte o 2 a um número real  e manda efectuar a operação.

A conversão Explicita é feita pelo próprio programador no acto de escrever código, realizar operações e misturar dados de tipos diferentes etc..., para isso usa funções do Basic do Gambas!

Puff ,,, Ora final de classe...

Hey PSSSTSTS
E chega o típico aluno estraga a tábua e pergunta - e a divisão por zero (a mim deu-me erro) ?

Lembram-se da divisão e se o valor do NUM2  for zero? experimentem ->

' Gambas module file


Public Sub Main()

  'Declaro dado variável
   Dim NUM1 As Integer
   Dim NUM2 As Integer
   Dim RESULTADO As Integer

   
   'Tenho portanto já três variáveis dentro da rotina de procedimento acima Main
   
   'Dou-lhe instruções de uso 
   NUM1 = 9
   NUM2 = 0
   RESULTADO = NUM1 / NUM2

   
 
   Print "====>>>" " " & RESULTADO

End

Se nós tentarmos efectuar essa operação o Gambas vai dar uma mensagem de erro a dizer , division by zero.
Como o programa pode ficar num ciclo, devemos carregar no Stop e parar o ciclo.

Solução - simples - não dividir por zero!

Porque devemos reparar nisto, porque se fosse um típico aluno estraga a tábua  era capaz de colocar o código assim e se fosse para programa já de janelinhas podia ou ia dar em ciclos  de erro por uma questão simples, é impossivel dividir por zero. se trocarmos e colocarmos o 0 no NUM1 já não haverá esse problema, porque zero a dividir por 9 dá 0.

Ref: http://www.somatematica.com.br/faq/r34.html

Gostaram?
Segue mais um exemplo de programa Gambas muito mas muito interessante, um programa para um serviço médico com gestão de base de dados , sim no Gambas podemos fazer aqueles programas que se encontram muito por aí no dia a dia (programas de factura , de venda, de escola etc) ... neste caso o programa é feito por jsbsan a modo de exemplo →

http://cursogambas.blogspot.com.es/2012/09/mapbd-mapeador-de-bases-de-datos.html
http://mapbdvistas.blogspot.com.es/

Até ao próximo capítulo...

[portaro]

3.3.3- Conversão Explícita.

Como já vimos anteriormente a conversão explícita é feita pelo próprio programador.
Essas conversões exigem o uso de funções Basic , as principais são:

CInt (texto) - devolve o valor numérico inteiro de uma cadeia de texto
CFloat (texto) - devolve o valor numérico real de uma cadeia de texto
Cstr (número) - devovle a cadeia de texto de um número

* recordem por motivos de fácil assimilação de termos para usuários mais novos chamamos até agora às variáveis como dados variáveis , evitando assim possíveis confusões entre termos variáveis / constantes agora podemos simplificar já que nesta altura já percebemos bem as bases de escrita de um código, portanto aligeirando e usando os termos mais usados em livros / cursos chamamos variáveis apenas. No entanto para aqueles que precisem podem continuar a usar o termo dado variável.

Vamos agora ver conversões explícitas a modo exemplo em código ,

Novo projecto → linha de comando terminal → path - /home/USER/Documentos/BASIC/zwamers  → nomede projecto e título → seguimos para código.

Novo Módulo → converter (exemplo nome) , marquem como classe inicial.

' Gambas module file

Public Sub Main()

'Declaração de variáveis
Dim valor1 As Float
Dim valor2 As Integer
Dim valor3 As Float

'Uso
valor1 = 2.45
valor2 = CInt(valor1)
Valor3 = CFloat(valor1)

Print valor2

Print valor3

End

Um outro exemplo com uso de um input via user →

Novo Módulo → input (exemplo nome) , marquem como classe inicial.

' Gambas module file

Public Const texto As String = "Input - receber algo interactuar - exemplo"


Public Sub Main()
'Declaramos variáveis
Dim numero As Float
Dim valor As Float

Print texto
Print " -------------------"

Print " Introduza número " 'Pedimo a introdução do número
'Espera o input teclado e depois do Enter asigna-o à variável numero
Print " -------------------"


'Usos das variáveis
Line Input numero

Print numero

Print " -------------------"

valor = CInt(numero) 'conversão tipo - a inteiro , retira portanto o que está para além da vírgula caso o user coloque número com


Inc valor 'incrementamos 1 ao valor da variável

Print " -------------------"


'Finalmente apresentamos o resultado

Print " O número introduzido ao qual incrementei 1 dá : " & valor



 
End

Um outro exemplo seria :

' Gambas module file

Public Const texto As String = "Input - receber algo interactuar - exemplo"


Public Sub Main()
'Declaramos variáveis
Dim numero As String
Dim valor As Integer

Print texto
Print " -------------------"

Print " Introduza número " 'Pedimo a introdução do número
'Espera o input teclado e depois do Enter asigna-o à variável numero
Print " -------------------"


'Usos das variáveis
Line Input numero

Print numero

Print " -------------------"

valor = CInt(numero) 'conversão tipo - a inteiro , retira portanto o que está para além da vírgula caso o user coloque número com


Inc valor 'incrementamos 1 ao valor da variável

Print " -------------------"


'Finalmente apresentamos o resultado

Print " O número introduzido ao qual incrementei 1 dá : " & valor



 
End

onde valor = CInt(numero) convertia a inteiro o valor que estava como string.

O Line Input é um comando reconhecido que se pode usar em Basic, para que o usuário introduza algo e depois de dar Enter seja usado para o procedimento de programa.

Até à próxima.

[portaro]

3.3.4 - Desanuviando tensões , um tuto dedicado a reflectir.

Vamos agora fazer um alto no caminho ,já que estamos a meio do uso básico de Gambas modo texto, numa altura em que já entendemos a importância das sintaxes, da matemática, da programação que resolve problemas e torna as coisas fáceis para comunicar com máquinas chamadas computadores, tablets etc.

Trata-se de desanuviar um pouco e alimentar a força daqueles que estão a iniciar-se a zero em tentarem entender o que afinal é a programação e provávelmente a debaterem-se com dúvidas como - isto parece dificil valerá o esforço?.

Para aqueles que não são programadores o saber programar pode ajudar de muitas formas:
-Como hobbie, passatempo, já pensaram alguns nas horas que dedicam ao Pshibook? secalhar esse tempo investido em aprender algo gera melhores e mais proveitosos resultados.
-Se souberem programar seja em Gambas ou outros estão aptos a resolver problemas vossos relativos às vossas necessidades informáticas, afinal os computadores são hoje algo primário em todos os locais.
-Se tiverem um negócio, uma empresa podem aprender a fazer programas relativos a ele(a) e eles -  esses programas - ajudar-vos-ão de futuro a poupar em gastos , a ser usuários capazes de melhor julgar ofertas de programas privados ou mesmo saber fundamentar melhorias em programas já em uso.
Como exemplo eu conheço programas que têm uma certa licença e são colocados por certas empresas e que se perguntar a um programador o valor de um programa daqueles me diz que o seu valor para ele fazer aquilo resultaria em ser metade dos tais com licença, ou seja eu preocupo-me em saber isso e portanto sei que se se fizesse de forma diferente custaria muito menos. Mesmo sendo apenas curioso da programação sei perceber se é ou não possivel haver alternativas a um modelo etc...nem que seja por isso já vale a pena é uma mais valia.
-Saber programar para uma pessoa ligada a humanidades por exemplo pode ter a vantagem de lhe ser útil , não com enfoque informático mas sim relativo à sua formação - como que um extra - , num outro tópico de fórum eu dei um exemplo - um sociólogo a nível currículo não tem grandes vantagens em referir que sabe programar, nem o deve fazer afinal não é programador certificado , mas se entender algo de programação de forma altruísta pode então ele mesmo fazer o seu  programa que o ajude a resolver problemas relativos à sua profissão e vida e que ele não encontra resolvidos com programas comuns, ou dedicados com falhas. Um programa que por exemplo permita manter um relação de dados sobre certa comunidade e que seja fácil de entender e usar que ele mesmo desenha e até pode compartir com colegas - totalmente personalizado. No campo das humanidades temos poucos hackers chegados daí ao mundo da informática mas houve alguns, uma das grandes e poucas hackers mulher chegou vinda dessa rama de estudos e não por isso deixou de ser tida e entrar na elite de grandes exemplos neste grémio, brincar com o código está ao alcance de todos ainda que pareça que não! .
-Saber programar ajuda sempre, é como lêr um bom livro sabemos que o tempo investido nos serve para algo, seja mais de presente ou futuro , contará sempre.
- Saber programar ajuda-vos a poder contribuir para certas comunidades ditas abertas e ajudar a desenvolver programas mundias facilitando a vida aos que dedicam tempo a essas mesmas iniciativas, geram-se amigos, contactos, etc.
- No fundo saber programar ajuda-vos a vós mesmos é uma mais valia sempre.

E agora volto à carga se por alguma razão algum dos meus amigos chegou aqui leu os tutos e pouco entendeu , não se apoquente!
É absolutamente normal.
Recomendo o de sempre leiam ,releiam e escrevam código , !guardanapo que encontram escrevam código!
Eu levei horas , dias , semanas, meses, a entender tudo o que acima vos explicitei até agora e mesmo agora como eu não sou programador tenho dúvidas, sim ainda tenho dúvidas vejam bem,  todos os dias e com cada código  elas me surgem.

E claro lembrem-se que apesar dos programadores certificados saberem muito e muito , que a nós nos deixa de boca aberta, também eles não sabem tudo, usam a internet e resenhas de programação, receitas só do grémio etc,  para se lembrarem de como definir aquele uso, como usar aquele complemento etc, eles não trazem tudo na cabeça e que eu saiba poucos têm mochila capaz (um camião talvez chegasse) para levar a catrafada de papeis e livros atrás!

Saber programar é uma arte não de elites, mas uma arte ao alcance de quem quiser, enfim saber um pouquinho nem que seja por curiosidade ou muito por profissão.

Tempo ao tempo, se custar avancem é sinal que está a funcionar!

Já temos 400 visitas nestes tópicos , e vamos para as 1000  e eu vou acompanhado de vós, portanto quero todos no final da meta.

Na próxima cá trarei mais para debitar.

[portaro]

3.3.5 - Exemplo , conversões, para ...

Cáculo de média aritmética :

' Gambas module file

'Programa criado por Minguno.

Public Const texto As String = "Input - receber algo interactuar - exemplo"

Public Sub Main()
  'Declaro variáveis
  Dim ler1 As String
  Dim ler2 As String
  Dim calculo1 As Float
  Dim calculo2 As Float
  Dim resultado As String
  'zona de info e prints para interface usuário com line input
    Print " Introduza 1º número  "
    Print "-------------------------"
    Line Input ler1
    Print " O número introduzido foi " & ler1
    Print "-------------------------"
    Print " Introduza 2º número  "
    Print "-------------------------"
    Line Input ler2
    Print " O número introduzido foi " & ler2
    Print "-------------------------"
    'zona conversão
      calculo1 = CFloat(ler1)
      calculo2 = CFloat(ler2)
                    'zona cálculo
                   resultado = (calculo1 + calculo2) / 2
                        Print "-------------------------"
                        Print resultado
 
End

[portaro]

Mais um exemplo de conversão e uso :
- novo Módulo, nome milhas (por exemplo) marquem como classe inicial

, um programa que converte Milhas a Quilómetros:

' Gambas module file

'Programa criado por Minguno.

Public Const milha As Float = 1.6


Public Sub Main()
   'zona de info e prints para interface usuário com line input
   
      'Declaro variáveis
        Dim ler1 As String
        Dim calculos As Float
        Dim resultado As String

Print " introduza valor em Km - 1 milha é igual a 1,6 KM "   

            Line Input ler1
           
            Print "-------------------------"
           
            Print " introduziu: " & ler1 & " milhas"
            Print
            Print "-------------------------"
           
                  'calculos
                     calculos = CFloat(ler1)
                     resultado = calculos * milha
           
                      ' impr. final
                       Print ler1 & " milhas equivalem a  " & resultado & " quilómetros "
 
End

[portaro]

3.3.6 - Operadores texto , Operadores relacionais e lógicos.

https://mega.nz/#!CJFyWDTC!mheWGDtMk69BHDlVjHHSp7uy2MNJkTWeRPUIJ92CWYU

Ora vamos então colocar aqui alguns códigos a Módulo Gambas sobre Operadores texto :
Referir  que  as tarefas com operadores texto são muito usadas tanto em programa com base de dados como saídas de texto.
Também devemos saber que o & é um operador que permite concatená-las como já vimos.


Abrimos um novo Projecto → aplicação terminal→ path que já referimos anteriormente e deixamos como está (podem mudar se quiserem gravar noutro lugar) → Nome de projecto Cadeiastexto | título cadeiastexto.

Módulo , título - cadeiatexto (exemplo) marcamos classe inicial e código:

' Gambas module file

'cadeias texto

Public texto As String = " - Exemplo de actividade cadeia texto"

Public Sub Main()
  'Declaro variáveis
  Dim cad1 As String
  Dim cad2 As String
  '---------------------
    'tomam valor
    cad1 = "cadeia"
    cad2 = "junta"
 
  '---------------------
       'Uso
       Print texto
       Print
       Print "---->" & cad1 & cad2
       
              'variáveis mudam e tomam novo valor
               cad1 = " Gambas"
               cad2 = " melhor"
                   
                    'uso
                     Print
                     Print "---->" & cad1 & " é o " & cad2
               
 
End

Continuamos no mesmo código e fazemos uma pequena alteração , adiante aproveitaremos este seguinte código para ressaltar três aspectos importantes para o futuro do curso:

' Gambas module file

'cadeias texto

Public texto As String = " - Exemplo de actividade cadeia texto"

Public Sub Main()
  'Declaro variáveis
  Dim cad1 As String
  Dim cad2 As String
  '---------------------
    'tomam valor
    cad1 = "cadeia"
    cad2 = "junta"
 
  '---------------------
       'Uso
       Print texto
       Print
       Print "---->" & cad1 & cad2
       
              'variáveis mudam e tomam novo valor
               cad1 = " Gambas"
               cad2 = " melhor"
               
               texto = "Este foi um exemplo de cadeias texto"
                   
                    'uso
                     Print
                     Print "---->" & cad1 & " é o " & cad2
                     Print
                     
                     Print texto
 
End

Vamos ressaltar agora 3 aspectos :

1- reparem no sentido do fluxo de código é sempre ↓

2- reparem na variável texto , como muda o seu valor e como inicia numa declaração Public e é chamada no método de procedimento Main.

3- no uso e renovação de valor ao longo do código dos dados de código (variáveis) e como ao longo dele seguem sempre o rumo do fluxo.

Tudo é organizado segundo o fim e  esse fim é marcado pelo End, portanto devemos tentar sempre estruturar bem os códigos antes de os começar a escrever para eles serem mais limpos e fáceis de manipular.

Vamos agora a um exemplo de procura de cadeias sobre uma cadeia.

Novo Módulo , procuracadeia (exemplo nome) marquem como classe inicial:

o mesmo código apenas com uma pequena alteração em:

cad1 = "abc def ghi jkl"

para

cad1 = " abc def ghi jkl"

levará a um resultado diferente →

No Basic as cadeias começam sempre na posição 1!!!


Seguimos para outro exemplo conversão maiúsculas e minúsculas:

Novo módulo convertermaisaminus (exemplo de nome) marquem classe inicial

Seguimos para outro exemplo de eliminação de espaços em branco:

Novo Módulo eliminaespabranco (exemplo de nome) marquem classe inicial

Vamos agora a um exemplo de sub-cadeias em cadeias:

Novo módulo subcadeia (exemplo de nome) marquem classe inicial

Vamos agora aprender a substituir  cadeias

Novo módulo , substituir (exemplo de nome) marquem classe inicial

Agora atentem no mesmo código com uma nova adição e na cadeia /t  e como ela é interpretada pelo Gambas.

Agora vamos ver os operadores relacionais e lógicos sendo eles os:
Relacionais->
=; <>;<=;=>;
Lógicos ->
AND; OR; NOT; XOR.

https://mega.nz/#!WVl1nILT!tx_ZD8uDqXZsgb02DcOmCoPcTLOMTYgiC8G67G6RE4k

Exemplo de código que usa operação Lógica.

Public Sub Main()
 
  Dim var1 As Boolean
  Dim var2 As Boolean
 
  var1 = False
  var2 = False
 
  Print "var1 AND var2 resultado:"
  Print var1 And var2
 
  Print "var1 OR var2 resultado:"
  Print var1 Or var2
 
 
  Print "NOT var1 resultado:"
  Print Not var1
End

Estamos quase a terminar o curso de introdução a modo texto em Gambas que é a parte mais básica e mais importante para poder depois dar os passos para os cursos modo gráfico e médio / avançado.
------------------------------------------------------------------------------------------------------------


-------------------------------------------------------------------------------------------------


No próximo capitulo trarei material sobre as "estructuras de controlos" - condições e as famosas palavras reservadas tipo  IF , ELSE, ELSEIF...

[portaro]

3.3.7 - Estruturas de controlo e condições.

Vamos hoje deixar aqui algo sobre este a estrutura de controlo e o uso de condições , como acima vêem temos ali umas quantas palavras reservadas da sintaxe Gambas, que só se usam para instruções de programa e não podem ser usadas como variáveis !
Muito bem comecemos pelo controlo de fluxo→

Módulo
   ↓
Estrutura
---¨---
Public sub Main()
Instrução 1
Instrução 2
....

End

Todo o programa Gambas tem uma ordem de sequência de "uso" esse uso nada mais é que uma execução de algo, e segue uma direcção do topo para o fim!
Se o programa não envolver decisões "entre", o problema não se põe mas se as envolver o computador precisa de saber como tomar decisões em função de algumas condições de programa, por exemplo segundo valores de variáveis . Essas decisões podem envolver um stop de programa, ou um regresso a ciclo de condição , se (condição) - então (instrução) - se não (instrução alterna) } IF THEN ELSE.
Este tipo de acções afectam o controlo de fluxo de uma parte importante do programa:

-então para usarmos as instruções IF THEN ELSE teriamos para uma só instrução um:
IF expressão THEN sentença a executar
-para várias instruçoes envolveriam mais decisões teríamos umas:
IF expressão THEN (instrução 1) (instrução2) ...

ENDIF

Observem bem o comportamento do IF , ele é reponsável por verificar se uma condição se cumpre ou não e facto disso toma uma ou outra decisão de ciclo

' Gambas module file

Public Sub Main()
'declaro
  Dim cad1 As String
  Dim cad2 As String
 
  'uso
  Line Input cad1
  Print "->" & cad1
  Line Input cad2
  Print "->" & cad2
 
 
  If cad1 = cad2 Then
    Print "são iguais"
    Else If cad1 <> cad2 Then
      Print "são diferentes"
     
  Endif

End

' Gambas module file

Public Sub Main()
  'declaro
  Dim idade As Integer
 
  'toma valor
  idade = 0
 
  'uso
  Print " introduza um número"
  Print
  Line Input idade
  Print idade
  If idade >= 0 And idade < 2 Then
  Print "bébé" 'considera bébé idades situadas entre 0 e 2
   Else If idade < 10 Then
     Print "Menino(a)" 'considera menino idades entre 2 e 9 anos
     Else If idade < 18 Then
       Print "jovem" 'considera jovem idades entre 10 e 17 anos
       Else
         Print "adulto" 'tudo o que seja acima de ou igual a 18 é adulto
         
         Endif
         
 
End

Neste último exemplo usamos o Quit que sai do programa se verifica que os números introduzidos são negativos ou seja a condição de negativo conduz a uma saída , uma condição positiva prossegue outras instruções seguidas.

Haveria muitos exemplos que se poderiam colocar mas o principal está feito.

No próximo capítulo fechamos esta secção introdutória e deixar-vos-ei uns links para poderem seguir se quiserem com o curso Gambas, será então o final, depois desta parte do curso devem fazer a transição para o modo gráfico em que têm de entender uma série de novos conceitos mas já tendo uma base de pensamento pró-sintaxe e percebendo um pouquinho do Gambas como vão ver em video depois o próprio Gambas vos ajuda nesta transição.

Até à próxima.

[portaro]

3.3.8 - Validar dados e dinâmicas de opções modo consola.

Vamos agora deter-nos um pouco nas opções de validação de dados de entrada via pedido a usuário.
Jogamos com 6 funções:
IsBoolean (valor] → devolve verdadeiro se o valor tipo é booleano, ou falso não sendo.
IsDate(valor) → devolve verdadeiro se o valor tipo é data , ou falso não sendo.
IsInteger(valor) → devolve verdadeiro se o valor tipo é um inteiro , ou falso não sendo.
IsFloat (valor) → devolve verdadeiro se o valor tipo é real, ou falso não sendo.
IsString (valor) → devolve verdadeiro se o valor tipo é cadeia texto, ou falso não sendo.
IsNull (valor) → devolve verdaeiro se o valor tipo está em branco - portanto nulo, ou falso não estando.

Ou seja é uma função em sí que permite assegurar o tipo de entrada para evitar erros de programa e más execuções dentro deles.

Um exemplo:

' Gambas module file

Public Sub Main()

Dim numero As String
Dim valor1 As Variant
Dim valor2 As Integer
Dim resto As Integer

Print " Introduza Número"
Line Input numero

valor1 = Val(numero)

If IsInteger(numero) = True Then
 
  valor2 = CInt(valor1)
 
  resto = valor2 Mod 2
 
  If resto = 0 Then
    Print "o número" & valor2 & "é par"
  Else
    Print "o número" & valor2 & "é ímpar"
  Endif
Else
Print "o - " & numero & " não é um número inteiro"
Endif
End

O mesmo código com uma alteração:

' Gambas module file

Public Sub Main()

Dim numero As String
Dim valor1 As Variant
Dim valor2 As Integer
Dim resto As Integer

Print " Introduza Número"
Line Input numero

valor1 = Val(numero)

If IsInteger(valor1) = True Then
 
  valor2 = CInt(valor1)
 
  resto = valor2 Mod 2
 
  If resto = 0 Then
    Print "o número" & valor2 & "é par"
  Else
    Print "o número" & valor2 & "é ímpar"
  Endif
Else
Print "o - " & numero & " não é um número inteiro"
Endif
End

Executem o programa vejam o resultado?
Erro!!

Aproveitemos esse erro para aprenderem a usar o modo ponto de parada que vos ajuda a ver onde pára a execução de programa:
-executem o programa
-introduzam um número
-vejam o erro

-carreguem em F9 (aparece a bolinha de ponto de parada = é aí que existe um erro grave!)
-parem o programa
-carreguem F8 (vão ver os pontos de execução de programa - Print ... Line Input ... espera de introdução ...

Desta forma podemos perceber muito melhor a ajuda que o Gambas nos oferece n oque concerne a ajudar o programador básico a aperceber-se rápidamente de onde procurar erro ou problema código (confusões) em programas muito longos dá uma ajuda tremenda!

Se observarem no Menu Gambas contam ainda com uns botões de passo a passo ao lado do Stop!
E ainda contam com um Depurar no Menu topo do Gambas!

Portanto estão sempre bem apetrechados para todas as ocasiões.

Continuamos vamos agora fazer um programa tipo programa de janelinhas mas em consola um daquels tipo click escolha mas aqui as escolhas vão ser executadas com entrada de um valor e as opções seguirão esse caminho são dinâmicas de consola, muito usadas por exemplo em scripts GNU/Linux!

' Gambas module file

Public Sub Main()
 
  Dim option As String
  Dim v2 As String
  Dim v3 As String
  Dim v4 As Integer
 
  Print " MUT "
  Print "------------------------------------------------"
 
  Print "1→ concatenar cadeias"
  Print "2→ subcadeia pela esquerda"
  Print "3→ programa descrição"
  Print "4→ Exit"
   Input option
   If (option = 1) Then
     Print "Introduza a primeira cadeia"
     Line Input v2
     Print "Introduza a segunda cadeia"
     Line Input v3
     Print v2 & " " & v3 & " é a concatenação das cadeias"
 
    Else If (option = 2) Then
         Print "Introduza a cadeia"
         Line Input v2
         Print "Introduza o número de caracteres"
         Line Input v3
         If IsInteger(v3) = False Then
           Print "não é inteiro"
           Quit
         Endif
         v3 = Left(v2, v3)
         Print v3
         
   
     Else If (option = 3) Then
          Print "MUT, programa multi escolha, em Gambas consola modo"
   
     Else If (option = 4) Then
          Quit
     
     Else If (v4 = 0) Or (v4 > 4)
          Quit
   Endif 

End

E pronto estamos no fim daquilo que é a parte texto Gambas, que tem também funções matemáticas mais avançadas e alguns outros pontos interessantes mas para ususários novos torna-se uma matéria mais dificil de digerir, evita-mo-la por agora certamente no futuro se depararão com essas vertentes já depois dos primeiros passos com o desenho gráfico de aplicações.

Agora para aqueles que quiserem passar um pouco mais à frente é lerem este livro principalemnte ajudar-vos-à na transição ao modo gráfico desenho de aplicações. classes etc →
https://openlibra.com/en/book/gambas-programacion-visual-con-software-libre

Deverão também atentar a novas propostas como o Código Limpio →
http://www.casadellibro.com/libro-codigo-limpio/9788441532106/2007424

Uma das coisas que  não tocamos foi a sangria de código , podem procurar no google , a partir de agora vão começar a escrever programas mais longos , já que a passagem de texto a modo médio é muito rápida em Gambas.

Se quiserem aparecer nos fóruns oficias →
http://www.gambas-es.org/forum.php
https://gambas.guru/Welcome



No próximo capítulo final trarei alguns vídeos interessantes -introdutórios- ao movimento dentro do corpo Gambas com trabalho gráfico de desenho e já portanto com Formulários.

E aí já ficam com uma ideia de como trabalhamos em gambas no desenho em si, coisa que terão de descobrir conforme forem tendo as vossas ideias.