Arrays:

     Um array é uma lista de variáveis, com o mesmo tipo de dados e nome. Quando trabalhamos com apenas um item, usamos a variável. Mas quando temos uma lista de itens, do mesmo tipo, precisamos declarar um array de variáveis, ao invés de usar uma variável para cada item.

• Dimensão do Array:

     Um Array pode ser dimensional ou multidimensional. Um array dimensional é como uma lista de itens, ou uma tabela onde possui uma linha e uma coluna. Um array multidimensional é uma tabela de itens, que contem suas linhas e colunas. O formado do array dimensional é Array(x), o formado do bidimensional é Array(x, y), e do tridimensional é Array(x, y, z). Exemplos:

Array Dimensional:

Lista de Alunos: Aluno(1), Aluno(2), Aluno(3)

Array MultiDimensional:

Lista de Alunos: Aluno(1,1), Aluno(1,2),  Aluno(1,3)

                           Aluno(2,1), Aluno(2,2), Aluno(2,3)

                          Aluno(3,1), Aluno(3,2), Aluno(3,3)

     No Visual Basic exitem 2 tipos de arrays: Fixed-Size e Dynamic. 

• Fixed-Size Arrays:

     É possível fazer uma analogia do array com um rack de cds. No caso do tipo Fixed-Size o número de slots do rack é limitado. Suponhamos que você tenha 3 cds, um do Deftones, outro do Pink Floyd e outro do AC\DC. Para guardar eles no seu rack, ele precisa ter 3 slots. Então, no VB temos que declarar esses 3 slots:

Dim strCDRack (0 To 2) As String
strCDRack(0) = "Deftones"
strCDRack(1) = "PinkFloyd"
strCDRack(2) = "ACDC"

     O formato geral para se declarar um array é o seguinte:

Dim|Public|Private NomedoArray(Subscript) As TipodeDado

- O Dim numa procedure vai fazer com que o array fique disponível apenas com essa procedure. Usar o Private vai fazer com que fique acessível apenas no form ou módulo, já o Public vai tornar público para todo o projeto.

 - NomedoArray, como o nome diz é o nome que você vai dar para o Array.

- Subscript é a dimensão do array.

- TipodeDado é qualquer tipo válido de dados.

• Dynamic Arrays:

     Suponhamos que você tem o quarto cd, mas o rack só suporta 3 slots, e você não quer jogar fora os seus 3 cds que já estão por lá. Então você decide construir um novo slot:

Dim strCDRack() As String
ReDim strCDRack (0 To 2) As String
strCDRack(0) = "Deftones"
strCDRack(1) = "PinkFloyd"
strCDRack(2) = "ACDC"
ReDim Preserve (0 To 3) As String

strCDRack(3) = "Rammstein"

     O Preserve força o VB a preservar os valores existentes nos arrays.  Sem essa palavra-chave todos os 3 cds seriam perdidos. 

     A sintaxe do ReDim é a seguinte:

ReDim [Preserve] NomedoArray(Subscript) As TipodeDado

- ReDim significa que você está redimencionando o array.

- Preserve é opcional. Ele força o VB a manter o valor dos elementos. Sem ela, todos os elementos iriam retornar os seus valores padrões. (tipos de dados numéricos iriam retornar 0, variable-lenght strings retornariam "",  fixed-lenght strings seriam preenchidos por zeros, e variants ficariam vazias).

• Exemplo Prático:

* No exemplo, foi utilizado 1 botão e 1 listbox:
Dim NomeAluno(10) As String
Dim num As Integer

Private Sub addNome()
For num = 1 To 10
NomeAluno(num) = InputBox("Digite o nome do aluno")
List1.AddItem NomeAluno(num)
Next
End Sub

Private Sub Command1_Click()
addNome
End Sub

* Fontes:
http://www.vbtutor.net/vb6/lesson16.html
http://patorjk.com/programming/tutorials/vbarrays.htm
 

Subrotinas e Funções:

• Subrotinas:

     As subrotinas podem ser definidas como miniaturas dos programas. A subrotina precisa de uma nome para ser atribuido à ela, assim como as variáveis. Mas ao invés das variáveis que armazenam dados, as subrotinas armazenam códigos. Algumas subrotinas são chamadas automaticamente quando certas ações são executas, é o caso da subrotina Form_Load que é chamada automaticamente quando um form é executado.

     As subrotinas são úteis para eliminar as redundâncias, facilitando a manutenção do programa.

• Criando uma Subrotina:

     Para criar uma subrotina é muito simples, são apenas 2 linhas de código:

Sub NomedaSubrotina()

End Sub

• Escopo da Subrotina:

     É uma palavra-chave que vem depois do Sub. Private e Public são exemplos de escopos.  Ele representa onde a subrotina pode ser chamada no seu programa. Subrotinas com o escopo Public pode ser chamado em qualquer lugar do projeto, enquando as Private só podem ser chamada por outro form. 

     Os escopos das subrotinas são muito utilizadas para se evitar erros!! Se declarar uma subrotina como pública em todo lugar, pode gerar algum erro difícil de ser encontrado, causando muita dor de cabeça. 

• Parâmetros:

     Parâmentros, também chamados de Argumentos, são variáveis que podem ser definidas nas subrotinas. As subrotinas com parâmentros são assim:

Private Sub Adicao(x As Integer, y As Integer)
    MsgBox x + y
End Sub

Private Sub Form_Load()
Dim a As Integer
Dim b As Integer
a = 3
b = 7
Adicao a, b

End Sub

     As variáveis x e y são Parâmentros, e Adicao é a Subrotina. No exemplo acima, a e b são representações dos parâmentros x e y. 

• ByRef e ByVal:

     Parâmentros podem ser enviadas para as subrotinas por: referência(ByRef) e por valor(ByVal).

      Quando os parâmentros são passados por referência (ByRef) , apenas a memória das variáveis é passada. Isso significa que os valores podem ser modificados pela subrotina, que terá o novo valor quando a subrotina terminar. A variável que irá conter o valor de "retorno"  ou se saída deve ser definida pelo ByRef.

     Quando os parâmetros são passados pelo valor (ByVal) , ca cópia das variáveis é passada.  Isso significa que mesmo se os valores forem alterados pela subrotina, o valor original é mantido pela subrotina. Quando a subrotina finaliza, a variável passada por valor (ByVal) retêm o valor que foi passado originalmente antes da chamada do programa.

 Exemplo:

Sub ExSubrotina()
    MsgBox "MsgBox pela Sub!!"
End Sub

Private Sub Form_Load()
    MsgBox "MsgBox pelo Form_Load!!!"
    ExSubrotina
End Sub

• Criando uma função: 

As funções são basicamente a mesma coisa que as Subrotinas, exceto por elas retornarem um valor. Isso significa que uma função tem um tipo, que irá retornarum valor que foi definido pelo código da função.

     O formato geral das funções é: 

Public function NomedaFunção (Parâmentro as TipodeDado, ...) As TipodeDado

* as funções do tipo Public podem ser usadas por todo o projeto, se for criado em um módulo.

ou

Private function NomedaFunção (Parâmentro as TipodeDado, ...) As TipodeDado

* as funções do tipo Private podem ser usadas somente em alguns módulos ou procedures.

Exemplo de função:

* No módulo:

Public Function Conta(x As Integer, y As Integer, z As Integer)
Dim Operacao As Integer
Operacao = (x * y)
Operacao = Operacao * 30
Operacao = Operacao * z
Conta = Operacao
End Function

* No Form (adicione 3 textbox, 1 botão, 1 label e mais outras labels a seu critério)

Private Sub Command1_Click()
Dim a As Integer
Dim b As Integer
Dim c As Integer
Dim d As Integer
a = Text1.Text
b = Text2.Text
c = Text3.Text
d = Conta(a, b, c)
Label1.Caption = "Eu bebo " & d & " copos de água em " & c & " meses!!!"
End Sub

•  Subrotinas ou Funções? Eis a questão.

    Se estiver em dúvida em utilizar uma Subrotina ou Função, apenas se pergunte: Vou precisar retornar um valor?? Se a resposta for sim, então use a Função. Se não, use a subrotina. ;)

* Fontes:

http://en.wikiversity.org/wiki/Functions_and_Subroutines_in_VB6

http://www.vb6.us/tutorials/understanding-subroutines-and-functions-vb

http://www.vbtutor.net/vb6/lesson14.html

Conversão de tipo de dados:

       Os tipos de dados na programação é um tipo de dado com valores pré definidos. Exemplos de tipos de dados: inteiros, ponto flutuantes, caractere, string e ponteiro. Os tipos de dados no Visual Basic podem ser dividios em 3 grupos:

1) Nativo: Esses tipos da dados podem ser interpretados diretamente pelo compilador do Visual Basic, sem a assistência do programador.

2) Definido pelo usuário: Comumente referido pelas iniciais UDT (User Defined Type), que corresponde aos registros do Pascal ou estruturas da linguagem C.

3) Classes: São o básico para a programação orientada a objeto no Visual Basic. Note os Forms e vários Add-Inn e designers do banco de dados são classes.

       As conversões do tipo de dados são compiladas na linha de código, ou seja, fazem parte do código que valida a expressão. As expressões que permitem as conversões sempre começam com a letra "C": CBool, CByte, CChar, CDate, CDbl, CDec, CInt, CLng, CObj, CSByte, CShort, CSng, CStr, CUInt, CULng, CUShort, exceto as expressões Val e Str que convertem string para número e número para string respectivamente.

       O nome da função determina o tipo de valor que ele vai retornar.

1)  CBool:

Converte alguma expressão válida em booleano. Valores zero converte para False, e os outros valores para True. 

Exemplo: CBool(50) = True

               CBool(0) = False

2) CByte:

Converte a expressão para o tipo byte. O seu valor não pode exceder 255 e não deve ser negativo.

Exemplo: CByte(255.75) =  256

               CByte(300.99) = Overflow - Só é permitido 0 - 255.

               CByte("abcd") = Type mismatch

               CByte(3.5) = 3

3) CCur:

Converte uma expressão para o tipo de dados corrente. A expressão precisa ser um número (ou uma representação númerica de uma string). O resultado é aproximadamente 4 dígitos  depois do ponto decimal.

Exemplo: CCur(1234.56789)  = 1234.5679

              CCur(1234.56782) = 1234.5678

4) CDate:

Converte um número ou string no tipo de dados para datas. Para expressões numéricas, o 0 representa a data 30/12/1899 e valores negativos representam datas acima de 30/12/1899. 

Exemplo: CDate("1 Janeiro, 2012") = 01/01/2012

               CDate(123) = 02/05/1900

              CDate(123.456) = 02/05/1900 10:56:38 

5) CDbl:

Converte a expressão para o tipo double. A expressão precisa ser um número (ou a representação numérica de uma string) .

Exemplo: CDbl("1250.530") = 1250530

6) CDec:

Converte uma expressão para o tipo de dados decimal.
Exemplo: CDec("123.456") = 123456

7) CInt:
Converte uma expressão para o tipo inteiro. A expressão precisa ser um número, e os números depois do ponto decimal são automaticamente arredondados para seu valor mais próximo.
Exemplo: CInt("-1,8")  = -2

8) CLng:
Converte uma expressão para o tipo de dados Long (é um número de 32 bits, que podem ser de: -2,147,483,648 à 2,147,483,647). A expressão precisa ser um número, e os valores depois do ponto decimal são arredondados para seu valor aproximado.
Exemplo: CLng("4,4") = 4

9) CSng:
Converte uma expressão no tipo de dados Single (É um número de 32-bits, usado para números fracionários).  Precisa ser um número.
Exemplo:  CSng("123,450") = 123,45

10) CStr:
Converte a expressão de qualquer tipo de dados para uma String. Se a expressão for o Date, a menor expressão é retornada (m/d/yy). Se for Booleano, a string "True" ou "False" vai ser retornada. Se for um número, uma string representando um número vai ser retornada.
Exemplo: Str(False) = False
               Str("123,456") = 123,456

11) CVar:
Converte uma variável para uma variante. Se o argumento for numérico, retorna o tipo Double. Se for não numérico, retorna uma string.
Exemplo: CVar(Date)

12) Função Val:
É a maneira mais genérica (e menos eficiente) de converter uma string em número. Tecnicamente, ele retorna um tipo da dados Double. Quando uma string não puder ser convertida em número, vai ser retornado o "0", retornando o erro "Type Mismatch error".
Exemplo: Val("      123456    Visual Basic Land") = 123456

13) Função Str:
É uma antiga função que converte o número para uma string.
Exemplo: Str("987,001") = 987.001

* Fontes:

http://en.wikibooks.org/wiki/Visual_Basic/Data_Types
http://searchsoa.techtarget.com/definition/data-type
http://www.chennaiiq.com/developers/reference/visual_basic/functions/cbyte.asp#top
http://msdn.microsoft.com/pt-br/library/s2dy91zy%28v=vs.80%29.aspx
http://www.vb6.us/tutorials/learn-how-convert-visual-basic-data-types

Funções de manipulação de strings:

    O Visual Basic possui várias funções para manipulação de strings (sequência de caracteres: letras, números e símbolos). Cada string é representada por um código ASCII (American Standard Code for Information Interchange) que é uma codificação de 8 bits baseada no alfabeto inglês, criada nos anos 60. A faixa de valores é de 0 a 255, onde os valores de 0 a 127 pertencem a primeira tabela ASCII, e os valores de 128 a 255 à segunda tabela ASCII.

      A tabela abaixo é muito utilizada no Visual Basic, juntamente com as funções de manipulação de strings.

Tabela ASCII - 1

     Algumas funções retornam strings e outras números.

1) Len:

A função Len retorna o comprimento da string.

Sintaxe: Len(string)

Exemplo: Len("Visual Basic Land") = 17

2) Mid:

Retorna a string da posição inicial até a posição final, especificada no código. 

Sintaxe: Mid("String", n, n)

Exemplo: Mid("Esse animal é o caracól", 5, 14) = "animal é o cara"

3) Left:

Retorna o conteúdo da esquerda da string. 

Sintaxe: Left("String", n)

Exemplo: Left("Maria gosta de amarelo", 19) = "Maria gosta de amar"

4) Right:

Retorna o conteúdo da direita da string.

Sintaxe: Right("String", n)

Exemplo: Right("Contabilidade estuda o patrimônio", 22)  = "idade estuda o patrimônio"

5) UCase:

Converte todas as strings em minúsculo em letras maiúsculas.

Sintaxe: UCase(string)

Exemplo: UCase("visual basic land") = "VISUAL BASIC LAND"

6) LCase:

Converte todas as strings em maiúculo em letras minúsculas.

Sintaxe: LCase(string)

Exemplo: LCase("VISUAL BASIC LAND") = "visual basic land"

7) InStr:

Retorna a posição da string, a partir da posição indicada pelo código.

Sintaxe: (n, "String", "palavra/frase à procurar")

Exemplo: InStr(1, "Visual Basic Land", "Land") =  14

8) InStrRev:

Retorna a posição da string a ser procurada.

Sintaxe: InStrRev("String", "letra/palavra à procurar")

Exemplo: InStrRev("Visual Basic Land", "B")

9) String:

Converte um número em uma string.

Sintaxe: String(n, n)

Exemplo: String(5, 98) = "bbbbb"

10) Space:

Retorna uma string com determinado número de espaços.

Sintaxe: Space(n)

Exemplo: Space(5) & "Visual" & Space(5) & "Basic" = "     Visual     Basic"

11) Replace:

Substitui uma string por outra.

Sintaxe: Replace(expressão, procurar, trocar por[, inicio[, contador[, comparar]]]) 

* contador, comparar = são opcionais.

Exemplo: Replace("24/06/2012", "/", "-")  = 24-06-2012

12) StrReverse:

Retorna uma string ao contrário.

Sintaxe: StrReverse("String")

Exemplo: StrReverse("Visual Basic Land") = "dnaL cisaB lausiV"

13) LTrim:

Remove os espaços em branco do lado esquerdo da string.

Sintaxe: LTrim(string) 

Exemplo: LTrim("     Visual Basic Land") = "Visual Basic Land" 

14) RTrim:

Remove os espaços em branco do lado direito da string.

Sintaxe: RTrim(string)

Exemplo: RTrim ("Visual Basic Land     ")

15) Trim:

Remove os espaços em branco de ambos os lados da string.

Sintaxe: Trim(string)

Exemplo: Trim("     Visual Basic     ")

16) Asc:

Converte o ASCII da string para o código ASCII correspondente.

Sintaxe: Asc(string)

Exemplo: Asc("*") =  42

17) Chr:

Retorna a string do código ASCII correspondente.

Sintaxe: Chr(string)

Exemplo: Chr(122) = z

* Fontes:
http://pt.wikipedia.org/wiki/ASCII
http://www.macoratti.net/strings.htm
http://www.vb6.us/tutorials/vb6-string-functions
http://www.vbtutor.net/vb6/lesson13.html

A origem do Visual Basic:

     O Microsoft Visual Basic foi escrito baseado na linguagem para iniciantes chamada BASIC (Beginner's All-purpose Symbolic Instruction Code), em português: Código de Instruções Simbólicas de Uso Geral para Principiantes. 

* Uma linguagem de programação consiste em vários comandos, chamados argumentos, que dão as intruções para o computador. Essas linguagens possuem em média 300 comandos, que na maioria são palavras que podemos entender (Ex: open, next).

    O BASIC é uma linguagem de programação criada com fins didádicos, pelos professores John George Kemenu e Thomas Eugene Kurtz em 1964 no Dartmouth College. Essa linguagem foi desenvolvida para que os iniciantes pudessem utiliza-la e para que novos programadores conseguissem entendê-la com proeficiência. Era uma linguagem muito mais fácil do que Cobol, Fortran ou Assembler que precisavam de muito mais dedicação e estudo para serem compreendidas.

      O BASIC é uma linguagem baseada no modo texto e interpretada. Das várias versões do Basic criadas pela Microsoft, o Visual Basic se difere por ser gráfica. O Visual Basic possui o seu código e elementos gráficos. Ela se tornou uma linguagem popular pela sua facilidade de uso, e por ser interpretada e compilada!!!

     O diferencial do Visual Basic está no seu próprio nome: Visual. Atualmente, o sistema operacional Windows necessita que a interação entre a tela, teclado, mouse e impressora ocorra graficamente. Linguagens antigas como o Basic era baseado apenas no texto, e não suportava a inteface gráfica utilizada hoje em dia.

     O Microsoft Visual Basic é uma das linguagens de alto nível mais utilizadas, por ser  RAD (Rapid Application Development), fornecer acesso ao banco de dados Access e outros, possuir prototipação GUI (Graphical User Interface) e por permitir: internet scripting, design desktop e cliente/servidor e desenvolvimento de jogos.

* Fontes: 

- Teach Yourself Visual Basic 6 in 21 Days
- Visual Basic Programming for the Absolute Beginner 2001

- http://pt.wikipedia.org/wiki/BASIC

     Criei esse blog para compartilhar o meu estudo sobre Visual Basic 6.0. Espero que o conteúdo aqui disponibilizado ajude outras pessoas à se aventurarem na programação da linguagem Basic. Como é uma linguagem antiga, seu material é difícil de ser encontrado na internet, então sempre que eu achar algum artigo ou site interessante vou estar postando por aqui!!! 

Sejam muito bem vindos ao meu novo Blog!!!