Bem vindo !

Não perca tempo, registre-se agora mesmo! Membros registrados tem acesso a muito mais conteúdos, além de poder participar de bate-papos, discussões e compartilhar novidades com a comunidade. Não perca essa oportunidade!

Visual Basic Dúvida em ...

Discussão em 'Dúvidas & Ajuda' iniciado por hobbo23, 13 Nov, 2017.

Compartilhe esta Página

  1. hobbo23

    Membro Avançado
    hobbo23
    Registro:
    25 Mar, 2014
    Posts:
    83
    Curtidas:
    1
    45/67
    Bem galera , estou entrando neste grande e belo mundo da programação ( n a prostituição , isso é no lol ) , e pesso algumas recomendações de livros e PDF bons para um bom desenvolvimento (ytb - eu vejo o Guanabara ).

    Se alguém puder me tirar umas dúvidas em looping , ajudaria , o raciocínio n entra em meu cérebro .

    Desde já obg.
    N sei se postei em local certo , pesso uma ajuda e compreensão dos moderadores .
     
  2. Arkanun1000 Game Developer & Java Developer

    Moderador Coordenador
    Arkanun1000
    Registro:
    25 Jan, 2011
    Posts:
    3,470
    Curtidas:
    694
    200/265
    Oi beleza?

    Voce pode começar com a Logica de programação caso nao tenha nenhuma base
    http://www.webcheats.com.br/forums/lógica-de-programação.58/

    E caso voce queira aprender VB (como ta no titulo da sua duvida) temos este espaço
    http://www.webcheats.com.br/forums/visual-basic.50/

    Em todos eles (logica, VB, Python, C++...etc) tem um topico fixado chamado "Biblioteca Digital"

    Exemplos:

    Biblioteca Digital - Lógica de Programação
    BIBLIOTECA DIGITAL - VISUAL BASIC
    BIBLIOTECA DIGITAL - JAVA

    La está sempre sendo atualizado com livros pra download pra estudar.

    Como tu quer saber um pouco sobre looping, segue este artigo (é feito em C++, mas a logica é a mesma)

    Comandos de Repetição (Laços ou Loops)
    Na última seção foi visto como desviar o fluxo do programa. Mas, e se for necessário realizar uma mesma tarefa muitas vezes seguidas? É aí que entram os loops. Existem três tipos: while, do while e for;

    While loop
    A sintaxe desse loop é a seguinte:
    while (expressão) {
    comandos;
    }
    Esse código executa comandos enquanto expressão for verdadeira. Quando expressão for falsa, o programa pula comandos e vai para depois do while;

    Por exemplo, o seguinte programa escreve os números de 1 a 10:
    1. #include <stdio.h>
    2. int main(){
    3. int i = 1; // Declaração e inicialização
    4. while(i <= 10){ // Expressão lógica
    5. printf("%d ", i); // Comando 1: escreve o número na tela
    6. i++; // Comando 2: Incrementação do i
    7. }
    8. getchar();
    9. return 0;
    10. }
    Output:
    1 2 3 4 5 6 7 8 9 10
    Obs
    : não se esqueça de incrementar o i, senão o loop se torna infinito.

    Do while loop

    do
    {
    comandos;
    } while (expressão);
    É bem parecido com o while loop, mas ele executa comandos pelo menos uma vez.
    Por exemplo, o seguinte programa pede do usuário um número entre 1 e 10. Enquanto ele não digitar um número válido, o programa vai perguntar de novo.
    1. #include <stdio.h>
    2. int main(){
    3. int num; // Declaração
    4. do {
    5. printf("Digite um numero entre 1 e 10: "); // Comando 1: pedido ao usuário
    6. scanf("%d", &num); // Comando 2: armazenamento em num
    7. } while(num < 1 || num > 10); // Epressão lógica
    8. getchar();
    9. return 0;
    10. }
    Exemplo de output (com input -3, 42 e 7):
    Digite um numero entre 1 e 10: -3
    Digite um numero entre 1 e 10: 42
    Digite um numero entre 1 e 10: 7

    Obs
    : não se esqueça do ponto-e-vírgula depois do while(expressão).


    For loop

    for (expr1; expr2; expr3) {
    comandos;
    }

    Parece mais complicado, mas é de longe o loop mais usado nos programas, em parte por ser mais sintético.
    Ele é equivalente ao seguinte código com o while loop:

    expr1;
    while (expr2) {
    comandos;
    expr3;
    }
    Normalmente, temos as seguintes correlações:
    - expr1: declarações e inicializações
    - expr2: expressão lógica
    - expr3: incrementação ou alteração de uma variável que está em expr2
    Por exemplo, o seguinte código também imprime os números de 1 a 10 (compare com o exemplo do while):
    1. #include <stdio.h>
    2. int main(){
    3. for (int i = 1; i <= 10; i++) {
    4. printf("%d ", i);
    5. }
    6. getchar();
    7. return 0;
    8. }
    Output:
    1 2 3 4 5 6 7 8 9 10

    Obs: o escopo das variáveis que foram declaradas na expr1 é apenas dentro do for.
    Particularidades:

    • As expressões podem ser vazias
    for(char ch = 'n'; ch != 's'; ){ // Sem expr3
    printf("Deseja sair (s/n) ? ");
    rewind(stdin); // Para esvaziar o buffer
    scanf("%c", &ch);
    }

    /* Ou até o seguinte loop infinito */

    for( ; ; ){ // Sem nenhuma
    printf("X");
    }
    • As expressões podem ser compostas
    for(int i=0, j=9; i < 10; i++, j--){ // expr1 e expr3 são compostas
    printf("%d - %d\n", i, j);
    }
    • As expressões podem ser outros comandos
    for(char ch = 'n'; ch != 's'; scanf("%c", &ch)){
    printf("Sair? ");
    rewind(stdin);
    }

    Break

    Essa palavra-chave faz com que o loop em que ela está termine. Se houver nested loops, apenas o loop mais interno será terminado.

    Por exemplo, retomemos o loop infinito do for, mas com um meio de sair do loop, clicando qualquer tecla:
    1. #include <stdio.h>
    2. #using <mscorlib.dll>
    3. using namespace System;
    4. int main(){
    5. for(; ; ){
    6. printf("X");
    7. if(Console::KeyAvailable)
    8. break;
    9. }
    10. getchar();
    11. return 0;
    12. }
    No programa acima, o loop roda continuamente. Quando alguém apertar alguma tecla, Console::KeyAvailableretornará true, e o comando break será executado. Ou seja, o programa sairá do loop.
    Continue
    Esse comando faz com que a execução do programa pule para o topo do loop.

    Por exemplo, o seguinte código imprime todos os números de 0 a 50, exceto os que são múltiplos de 3 ou 4:
    1. #include <stdio.h>
    2. int main(){
    3. for(int i=0; i<=50; i++){
    4. if(i%3 == 0 || i%4 == 0)
    5. continue;
    6. printf("%d ", i);
    7. }
    8. getchar();
    9. return 0;
    10. }
    Output:
    1 2 5 7 10 11 13 14 17 19 22 23 25 26 29 31 34 35 37 38 41 43 46 47 49 50

    Obs: Apesar de ter pulado o final do for, a variável i foi incrementada.

    Tome cuidado com o while e o continue, porque podem ocorrer loops infinitos:
    1. #include <stdio.h>
    2. int main(){
    3. int i=1;
    4. while(i < 10){
    5. if(i == 5)
    6. continue;
    7. printf("%d ", i);
    8. i++;
    9. }
    10. getchar();
    11. return 0;
    12. }
    O programa acima fica preso indefinidamente nas linhas 5, 6 e 7, a partir do momento em que i = 5;

    Aviso: os professores e livros de programação normalmente aconselham evitar o uso de break e continue, já que o código fica mais difícil de acompanhar (pula de um lado para o outro).


    Nested loops

    É possível colocar loops uns dentro dos outros, para realizar tarefas repetitivas dentro de outras tarefas repetitivas. Só cuidado com o escopo dos contadores (i, j, ...) .

    No seguinte código há um for dentro de outro for:
    1. #include <stdio.h>
    2. #include <math.h>
    3. #using <mscorlib.dll>
    4. using namespace System;
    5. int main(){
    6. // Mude este número se no seu computador estiver muito rápido ou muito lento
    7. const int tempo = 70;
    8. // Definindo a constante 'PI'.
    9. // A palavra 'const' faz com que essa variável não possa ser alterada depois
    10. const double PI = 3.14159265358979323846264338;
    11. // Vamos iterar ( = realizar ciclos ) enquanto o usuário não clicar em nenhuma tecla
    12. for(int i=0; !Console::KeyAvailable; i++){
    13. // A partir de 'i', calcula-se quantas vezes o " " será impresso
    14. for(int j = 0; j < 40 + 25*sin(PI/15*i); j++){
    15. printf(" ");
    16. }
    17. // Esse asterísco é o que vocês realmente veêm
    18. printf("*\n");
    19. // Pára o programa por 'tempo' milisegundos
    20. Threading::Thread::Sleep(tempo);
    21. }
    22. return 0;
    23. }
    Output:
    veja por si mesmo! (dessa vez pode copiar...)

    Obs: - para sair do programa, aperte qualquer tecla (isso é feito na linha 16)
    - Na linha 26, a função Sleep(tempo) faz com que o programa espere tempo ms antes de continuar

    Qualquer coisa é so falar!
    Abçs!
     
  3. hobbo23

    Membro Avançado
    hobbo23
    Registro:
    25 Mar, 2014
    Posts:
    83
    Curtidas:
    1
    45/67
    Tem como por em C# n entendi muito bem , pode ser em Portugol se preferir.
     
  4. Cr4cko software architect & fullstack developer

    Moderador Programador
    Cr4cko
    Registro:
    20 Dez, 2012
    Posts:
    1,281
    Curtidas:
    221
    75/133
    Looping nada mais é que passar várias vezes por um bloco. Pode ser infinitas vezes ou uma quantidade limitada.
    Por exemplo, no caso abaixo eu vou explicar sobre o FOR. O for é usado para normalmente fazer um looping em array de objetos/strings/números. No caso abaixo vou fazer 2 arrays uma de string e uma de objetos. Vou fazer me javascript, simples a sintaxe.

    HTML:
    <script>
    var array_string = ["oi", "tchau", "senta", "no", "meu", "celular"];
    
    for (var i = 0; i < array_string.length; i++){
        console.log("->", array_string[i]); //Será exibido palavra por palavra da array de strings.
    }
    </script>
    No caso acima, a condição do for é: tendo uma variavel i = 0, enquanto i for menor que o tamanho dessa array (no caso ela tem 6, mas sempre começará na posição 0), incrementa o i (i++ é i = i + 1). Ai dentro da instrução eu coloco um console.log (no javascript usamos isso para printar o valor no Console do DevTools do navegador).

    Código:
    <script>
    var array_objetos = [
        {
            nome: "Guilherme",
            idade: 21
        },
        {
            nome: "Vitória",
            idade: 20
        }
    ];
    
    for (var i = 0; i < array_objetos.length; i++){
        console.log("Nome: " + array_objetos.nome + ", Idade: " + array_objetos.idade);
    }
    </script>


    Acima é a mesma coisa, porém quando falamos de objeto, exibir apenas o array_objetos voce estaria printando todo o objeto. Precisa acessar os atributos.

    Tem outro looping que é o While e o Do While. Eu não uso muito eles, uso normalmente o while para fazer scripts que rodam eternamente. Eu uso mais em Python ou C++. Abaixo um exemplo em Python de um looping infinito:

    PHP:
    import time

    while True:
        
    time.sleep(1)
        print(
    "O Cr4cko é bonito")
    Veja que no python a sintaxe é mais simples ainda. Não precisamos dizer "while True = True" pra entrar numa condição infinita, apenas um while True já é o suficiente. Mas voce poderia sim fazer coisas obvias como while 1 = 1 ou deus = não existe
     
    kaway404 curtiu isso.
  5. hobbo23

    Membro Avançado
    hobbo23
    Registro:
    25 Mar, 2014
    Posts:
    83
    Curtidas:
    1
    45/67


    Então pelo o q entendi looping é uma ação
    q está ação enquanto for verdadeira entra em uma espécie de circulo até q se torne falso ?


    ps :
    Clique aqui e Registre-se para visualizar esse vídeo/imagem
     
  6. Cr4cko software architect & fullstack developer

    Moderador Programador
    Cr4cko
    Registro:
    20 Dez, 2012
    Posts:
    1,281
    Curtidas:
    221
    75/133
    Não mano, looping é uma instrução. No caso do while realmente, enquanto tiver true ele vai fazer o looping. Voce le literalmente "Enquanto TRUE, faça isso. Caso contrario pare." Agora no for, voce vai fazer um looping percorrendo as strings e objetos.
     
  7. Arkanun1000 Game Developer & Java Developer

    Moderador Coordenador
    Arkanun1000
    Registro:
    25 Jan, 2011
    Posts:
    3,470
    Curtidas:
    694
    200/265
    Em programação, LOOP é uma instrução para o programa repetir tarefas.

    No algoritmo da multiplicação, nós somamos o primeiro valor X vezes, sendo X o segundo valor.

    Os loops são muito utilizados no mundo da programação. Eles vêem em 3 sabores: ENQUANTO-FAÇA, REPITA-ATÉ e PARA-FAÇA.

    Na aula de hoje vamos estudar os dois primeiros: ENQUANTO-FAÇA e REPITA-ATÉ.

    Estrutura de repetição ENQUANTO-FAÇA
    O funcionamento da estrutura de repetição ENQUANTO-FAÇA (em inglês WHILE-DO) é tão simples quanto o SE-ENTÃO-SENÃO. A diferença é que os passos dentro deste bloco são repetidos enquantoa expressão booleana resultar VERDADEIRO.

    Obs: Lembrando os tipos de dados da aula 3, o tipo de dados booleano só pode assumir dois valores: VERDADEIRO ou FALSO.

    Voltando ao ENQUANTO … Vejamos como ficaria o pseudo-código desta estrutura:

    ENQUANTO <expressão booleana> FAÇA

    <instruções a serem executadas enquanto a expressão booleana resultar em VERDADEIRO>

    FIM-ENQUANTO

    Também chamamos esta estrutura de repetição de loop pré-testado, pois a expressão booleana é verificada antes da primeira execução. Se inicialmente ela já resultar em FALSO, as instruções que estão dentro do bloco não são executadas nenhuma vez.

    Este é o fluxograma desta estrutura de repetição. Repare que testamos a condição antes de entrar no LOOP.

    [​IMG]

    Hora de praticar
    Para aprender programação, nada melhor que praticar! Vamos ver um exemplo de LOOP com a estrutura ENQUANTO-FAÇA, utilizando a ferramenta VisuAlg.

    Vamos fazer um algoritmo para somar valores até o usuário digitar o valor 0. Ou seja, vamos somar todos os valores que o usuário digitar, porém quando ele digitar 0 o “loop” acaba, a cada iteração do loop vamos apresentar o resultado atual da soma.


    Código:
    algoritmo "SomaEnquantoValorDiferenteDe0"
    var
       valorDigitado : REAL
       soma : REAL
    inicio
          soma := 0
          ESCREVA ("Digite um valor para a soma: ")
          LEIA (valorDigitado)
          ENQUANTO valorDigitado <> 0 FACA
              soma := soma + valorDigitado
              ESCREVAL ("Total: ", soma)
              ESCREVA ("Digite um valor para a soma: ")
              LEIA (valorDigitado)
          FIMENQUANTO
          ESCREVAL ("Resultado: ", soma)
    fimalgoritmo
    
    Obs. A função ESCREVAL quebra a linha (como um ENTER) no final.

    O resultado deste algoritmo é algo assim:

    [​IMG]

    Estrutura de repetição REPITA-ATÉ
    Acho que você já deve imaginar como é esta estrutura né? Não!? Fácil!

    Lembra que eu disse que a estrutura ENQUANTO-FAÇA é conhecida como loop pré-testado. Então, a estrutura REPITA-ATÉ (REPEAT-UNTIL em inglês) é o contrário. Ela é um LOOP pós-testado. Isso significa que a verificação para repetir o LOOP é testada no final do bloco.

    Este é o pseudo-código do REPITA-ATÉ:

    REPITA

    <instruções a serem executadas repetidamente até a expressão booleana retornar VERDADEIRO>

    ATÉ <expressão booleana>

    Uma coisa muito importante a se notar é que além de ser pós-testada, esta estrutura testa o contrário do ENQUANTO. Ou seja, na estrutura REPITA-ATÉ, as instruções do bloco são executadas repetidamente enquanto a expressão booleana resultar FALSO. A partir do momento que a expressão booleana resultar VERDADEIRO, o fluxo do algoritmo sairá do LOOP.

    Veja o funcionamento no fluxograma.

    [​IMG]

    Não sei se você também percebeu, enquanto na estrutura ENQUANTO-FAÇA o bloco do LOOP pode não ser executado nenhuma vez, na estrutura REPITA-ATÉ o bloco é executado pelo menos uma vez.

    Hora de praticar
    Que tal fazer o mesmo exercício que fizemos acima com a estrutura ENQUANTO-FAÇA, mas desta fez utilizando a estrutura REPITA-ATÉ? Vamos ver como ficaria?


    Código:
    algoritmo "SomaAteValorIgualA0"
    var
       valorDigitado : REAL
       soma : REAL
    inicio
          soma := 0   
          REPITA
              ESCREVA ("Digite um valor para a soma: ")
              LEIA (valorDigitado)
              soma := soma + valorDigitado
              ESCREVAL ("Total: ", soma)
          ATE valorDigitado = 0
    fimalgoritmo
    
    Algumas diferenças …

    Se você prestar atenção, vai perceber que na estrutura ENQUANTO-FAÇA tivemos que repetir uma parte do código antes do LOOP e dentro do LOOP. Repetimos a seguinte parte:

    Código:
          ESCREVA ("Digite um valor para a soma: ")
          LEIA (valorDigitado)
    
    Isso aconteceu porque a estrutura ENQUANTO-FAÇA é pré-testada. Não daria pra testar se o usuário digitou o valor 0 se ele ainda não tivesse digitado valor nenhum.
     
  8. AcneNervoso Autista

    Membro Avançado
    AcneNervoso
    Registro:
    14 Jul, 2016
    Posts:
    108
    Curtidas:
    106
    35/67
    eu gosto de usar um comando semelhante, é bem simples e fácil de entender

    primeiro você declara a variável e depois diz onde a contagem comeca e onde termina
    Ex:

    For Contando as Integer = 0 to 100

    nessa linha você acaba de declarar uma variável que vai aumentar do numero 0 ao 100
    abaixo da linha você coloca o comando, agora vem a parte q é semelhante ao loop
    Ex:

    If Contando = 50 then
    Contando = 100
    End If
    Next


    ou você pode mandar a contagem reiniciar toda vez que chegar em certo valor
    Ex:

    If Contando = 70 then
    Contando = 0
    End if
    Next


    Obs: com .net você não enxerga nem a metade do belo mundo da programacão
     
  9. Bunchee

    Membro
    Bunchee
    Registro:
    14 Nov, 2017
    Posts:
    5
    Curtidas:
    0
    10/34
  10. kaway404 Viva la vida

    Moderador Programador
    kaway404
    Registro:
    6 Set, 2017
    Posts:
    181
    Curtidas:
    58
    10/34
    Como se queira em visual basic é facil, apenas criar um timer e dar um delay de 1000 ms!

    Ai para fazer verificação é simples

    if valor >= 50 then
    Label.Text = "50"
    else
    label.Text = "<50"
    end if

    Ai só colocar o código dentro de um timer :)

    Espero ter ajudado
     
Top