Estruturas básicas

Ler mais

Toda essa seção do tutorial, de um ponto de vista didático, se pressupõe. Isto é, o todo dá sentido às partes e as partes ao todo - e as partes mesmas umas às outras - de maneira que não há alguma via fácil para principiar a aprendizagem uma vez que uma parte do sentido de cada coisa sempre depende de outra. Assim, é preciso - me refiro aos leitores para os quais a programação é uma novidade - reler algumas vezes essa seção a fim de que a totalidade do sistema venha gradativamente a fazer sentido na medida em que se esquadrinha a relação das partes entre si e com o todo [blá-bla-blá de nerd...].

Procure entender essas estruturas básicas como ferramentas da própria mente humana [ou pelo menos de como ela conversaria com uma máquina], as mais básicas delas, das quais as mais robustas dependeriam. Com o hábito, ficará cada vez mais fácil desenhar qualquer algorítimo apenas com essas ferramentas. O fato é que quase toda a lógica de programação e, consequentemente, a qualidade dos seus programas depende principalmente de quão bem essa sessão foi/é compreendida, pois é a base para todo o restante.

Para evitar a confusão - e favorecer a visão geral e sistemática - destaquei resumidamente no corpo dessa página as estruturas [conceito e sintaxe] assinalando ao final de cada item o link para uma página mais completa sobre ele.

Variáveis

Variávais, num sentido geral, são expectativas formais de valores, de qualidades ou quantidades válidas relativas as objetos. Na programação, variáveis são valores associados a identificadores (nomes válidos) e tem um sentido muito amplo... A variável, em Go, é suporte de valores ou objetos complexos [é um identificador associado a quase qualquer coisa]. Há três maneiras de declarar variáveis conforme a conveniência e o contexto. Repare que o tipo é declarado poposto ao nome da variável e isso constitui uma peculiaridade de Go.

var nome_da_var tipo = valor // Global ou local (com ou sem valor)   var nome_da_var = valor // Global ou local (com valor)   nome_da_var := valor // Local (com valor)

A sintaxe permite a atribuição de mais de uma variável numa só expressão. Isso tem aplicação interessante quando trabalhamos com funções de retorno plural como veremos adiante.

x, y, z := 10, 10.0, "dez"

Leila mais

Funções

As funções são ações formais. Elas (considerando funções não triviais) mudam, conforme uma regra, o estado das coisas como, por exemplo, o conteúdo de variáveis. A função, na programação, é um bloco de código associado a um nome (identificador). Ela pode receber parâmetros e pode retornar algum ou alguns valores/objetos. Dá-se um nome válido a uma função, define-se, em seu interior, o que se há de fazer ao ser executada e se é executada quando chamada pelo nome.

É uma maneira de compartimentalizar o código, abstraí-lo, encapsulá-lo e tratá-lo em termos de input e output, de evitar escrever a mesma coisa várias vezes e tornar a solução dos problemas bem mais elegante e intuitiva. Veremos adiante como a orientação a objeto leva essa idéia a outra dimensão ao isolar contextos.

func nomeDaFunção(x tipo, y tipo) tipo_do_retorno {  /* código */  return y // tipo de y conforme definido  }   func funçãoSemCorpo(begin, end uintptr) // implementada externamente 

Estruturas de controle

As estruturas de controle são recursos lógicos, matemáticos e pragmáticos para manipular o código e desenhar a estrutura lógica de seu programa. As três estruturas a seguir tiveram sua implementação enriquecida e flexibilizada em Go.

If

if x > 0 { // código }

Sentindo falta do else? Veja o switch.

For

Go a implementa for de forma mais genérica e flexível que o usual. É usado para executar uma ação massiva (sobre múltiplos itens, ou diversas vezes). Falou em plural, falou em for.

// Como o for do C for inicial; condição; final { /* código */ }   // Como o while do C for condição { /* código */ }   // Loop, como o for(;;) do C for { /* código */ }   // Percorrer uma lista for c, v := range lista { // c = chave (key), v = valor }

Leia mais

Switch

É geralmente usado para testagens massivas sobre um mesmo objeto/valor, porém Go permite o uso mais amplo também nesse caso. Algo a ser testado pode tanto ser um valor simples quanto um objeto complexo e para cada case pode-se fazer mais de um teste.

switch algo { default:  /* código */  case "A", "B", "C"/* código */  case "1", "2", "3"/* código */  }

O uso a seguir é um tanto inusitado... Veja que os testes não se referem a um único objeto/valor, mas são condições como no teste if comum. Essa característica flexibiliza bastante as testagens.

switch { case condição1:  /* código */ case condição2:  /* código */ case condição3:  /* código */ }

Leila mais

Subpáginas (1): Variáveis
Comments