Go é uma linguagem de uso geral projetada com a programação de sistemas em mente. Ela foi desenvolvida inicialmente no Google no ano de 2007 por Robert Griesemer, Rob Pike e Ken Thompson. É forte e estaticamente tipado, fornece suporte embutido para coleta de lixo e oferece suporte a programação simultânea. Os programas são construídos usando pacotes, para gerenciamento eficiente de dependências. As implementações de programação Go usam um modelo tradicional de compilação e link para gerar binários executáveis.

A seguir estão os benefícios de usar a programação Go -

• Suporte para ambiente adotando padrões semelhantes a linguagens dinâmicas. Por exemplo, inferência de tipo (x: = 0 é a declaração válida de uma variável x do tipo int).

• O tempo de compilação é rápido.

• Suporte de simultaneidade InBuilt: processos leves (via goroutines), canais, instrução select.

• Concisão, simplicidade e segurança.

• Suporte para interfaces e incorporação de tipo.

• Produção de binários nativos estaticamente vinculados sem dependências externas.

Sem suporte para herança de tipo.

Sem suporte para sobrecarga do operador.

Sem suporte para sobrecarga de método.

Não há suporte para aritmética de ponteiro.

Sem suporte para programação genérica.

Sim! Go é uma linguagem de programação que diferencia maiúsculas de minúsculas.

A declaração de variável de tipo estático fornece garantia ao compilador de que existe uma variável com o tipo e nome fornecidos para que o compilador prossiga para a compilação posterior sem precisar de detalhes completos sobre a variável. Uma declaração de variável tem seu significado apenas no momento da compilação, o compilador precisa da declaração da variável real no momento da vinculação do programa.

Uma declaração de variável de tipo dinâmico requer que o compilador interprete o tipo de variável com base no valor passado a ela. O compilador não precisa de uma variável para ter o tipo estaticamente como um requisito necessário.

Sim Variáveis ​​de diferentes tipos podem ser declaradas de uma vez usando a inferência de tipo.

var a, b, c = 3, 4, "foo"

O código a seguir imprime o tipo de uma variável -

var a, b, c = 3, 4, "foo"  
fmt.Printf("a is of type %T\n", a)

É uma variável de ponteiro que pode conter o endereço de uma variável.

Por exemplo -

var x = 5
var p *int
p = &x
fmt.Printf("x = %d", *p)

Aqui x pode ser acessado por * p.

break termina o loop for ou instrução switch e transfere a execução para a instrução imediatamente após o loop for ou switch.

continue faz com que o loop pule o restante de seu corpo e teste novamente sua condição antes de reiterar.

goto transfere o controle para a instrução rotulada.

A sintaxe de um loop for na linguagem de programação Go é -

for [condition |  ( init; condition; increment ) | Range] {
   statement(s);
}

Aqui está o fluxo de controle em um loop for -

• se a condição estiver disponível, o laço for será executado enquanto a condição for verdadeira.

• se a cláusula que é (init; condição; incremento) estiver presente, então

  A etapa de inicialização é executada primeiro e apenas uma vez. Esta etapa permite declarar e inicializar qualquer variável de controle de loop. Você não é obrigado a colocar uma declaração aqui, desde que apareça um ponto e vírgula.

  Em seguida, a condição é avaliada. Se for verdade, o corpo do loop é executado. Se for falso, o corpo do loop não é executado e o fluxo de controle pula para a próxima instrução logo após o loop for.

  Depois que o corpo do loop for é executado, o fluxo de controle salta de volta para a instrução de incremento. Esta instrução permite que você atualize quaisquer variáveis ​​de controle de loop. Esta afirmação pode ser deixada em branco, desde que apareça um ponto e vírgula após a condição.

  A condição agora é avaliada novamente. Se for verdade, o loop é executado e o processo se repete (corpo do loop, etapa de incremento e condição novamente). Depois que a condição se torna falsa, o loop for termina.

• se o intervalo estiver disponível, o loop for é executado para cada item do intervalo.

A forma geral de definição de uma função na linguagem de programação Go é a seguinte -

func function_name( [parameter list] ) [return_types] {
   body of the function
}

Uma definição de função na linguagem de programação Go consiste em um cabeçalho de função e um corpo de função . Aqui estão todas as partes de uma função -

• func func inicia a declaração de uma função.

• Function Name- Este é o nome real da função. O nome da função e a lista de parâmetros juntos constituem a assinatura da função.

• Parameters −Um parâmetro é como um espaço reservado. Quando uma função é chamada, você passa um valor para o parâmetro. Esse valor é conhecido como parâmetro ou argumento real. A lista de parâmetros se refere ao tipo, ordem e número dos parâmetros de uma função. Os parâmetros são opcionais; ou seja, uma função pode não conter parâmetros.

• Return Type- Uma função pode retornar uma lista de valores. oreturn_typesé a lista de tipos de dados dos valores que a função retorna. Algumas funções realizam as operações desejadas sem retornar um valor. Nesse caso, o return_type não é obrigatório.

• Function Body - O corpo da função contém uma coleção de instruções que definem o que a função faz.

Uma função Go pode retornar vários valores. Por exemplo -

package main
import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}
func main() {
   a, b := swap("Mahesh", "Kumar")
   fmt.Println(a, b)
}

Ao chamar uma função, existem duas maneiras de os argumentos serem passados ​​para uma função -

• Call by value- Este método copia o valor real de um argumento para o parâmetro formal da função. Nesse caso, as alterações feitas no parâmetro dentro da função não afetam o argumento.

• Call by reference −Este método copia o endereço de um argumento no parâmetro formal. Dentro da função, o endereço é usado para acessar o argumento real usado na chamada. Isso significa que as alterações feitas no parâmetro afetam o argumento.

Por padrão, Go usa chamada por valor para passar argumentos. Em geral, isso significa que o código dentro de uma função não pode alterar os argumentos usados ​​para chamar a função e o exemplo mencionado acima ao chamar a função max () usando o mesmo método.

A linguagem de programação Go oferece flexibilidade para criar funções dinamicamente e usá-las como valores. Podemos definir uma variável com uma definição de função e usá-la como parâmetro para uma função.

O fechamento de funções são funções anônimas e podem ser usadas na programação dinâmica.

A linguagem de programação Go suporta tipos especiais de funções chamadas métodos. Na sintaxe de declaração do método, um "receptor" está presente para representar o contêiner da função. Este receptor pode ser usado para chamar a função usando "." operador.

Uma variável local tem valor padrão, pois corresponde ao valor 0.

Uma variável global tem valor padrão, pois corresponde ao valor 0.

O ponteiro é inicializado com zero.

Imprime a saída formatada.

A expressão que aparece no lado direito do operador de atribuição é chamada de rvalue. Rvalue é atribuído a lvalue, que aparece no lado esquerdo do operador de atribuição. O lvalue deve designar uma variável, não uma constante.

Os parâmetros enviados para a função no final da chamada são chamados como parâmetros reais enquanto no recebimento da definição da função chamada como parâmetros formais.

A declaração associa o tipo à variável, enquanto a definição fornece o valor à variável.

Dividir o programa em subprogramas (módulos / função) para realizar a tarefa dada é uma abordagem modular. A definição de funções mais genéricas fornece a capacidade de reutilizar as funções, como funções de biblioteca integradas.

Um programa Go consiste em vários tokens e um token é uma palavra-chave, um identificador, uma constante, um literal de string ou um símbolo.

vamos para

Array é uma coleção de itens de dados semelhantes sob um nome comum.

O compilador Go atribui um valor Nil a uma variável de ponteiro no caso de você não ter o endereço exato a ser atribuído. Isso é feito no momento da declaração da variável. Um ponteiro atribuído a nulo é chamado de ponteiro nulo. O ponteiro nil é uma constante com valor zero definido em várias bibliotecas padrão.

É uma variável de ponteiro que pode conter o endereço de outra variável de ponteiro. Ele desrefere duas vezes para apontar para os dados mantidos pela variável de ponteiro designada.

var a int
var ptr *int
var pptr **int
a = 3000
ptr = &a
pptr = &ptr
fmt.Printf("Value available at **pptr = %d\n", **pptr)

Portanto, 'a' pode ser acessado por ** pptr.

Estrutura é outro tipo de dados definido pelo usuário disponível na programação Go, que permite combinar itens de dados de diferentes tipos.

Para definir uma estrutura, você deve usar instruções type e struct. A instrução struct define um novo tipo de dados, com mais de um membro para seu programa. A instrução de tipo associa um nome ao tipo que é struct em nosso caso.

O formato da instrução de estrutura é este -

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

Go Slice é uma abstração de Go Array. O As Go Array permite definir o tipo de variáveis ​​que podem conter vários itens de dados do mesmo tipo, mas não fornece nenhum método embutido para aumentar o tamanho dele dinamicamente ou obter um sub-array próprio. Slices cobre essa limitação. Ele fornece muitas funções de utilitário exigidas no Array e é amplamente usado na programação Go.

Para definir uma fatia, você pode declará-la como uma matriz sem especificar o tamanho ou usar a função make para criar uma.

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/

A função len () retorna os elementos presentes na fatia.

A função len () retorna os elementos presentes na fatia, onde a função cap () retorna a capacidade da fatia como quantos elementos ela pode acomodar.

Slice permite que o limite inferior e o limite superior sejam especificados para obter o subforte dele usando [limite inferior: limite superior].

A palavra-chave range é usada em for loop para iterar itens de uma matriz, fatia, canal ou mapa. Com matriz e fatias, ele retorna o índice do item como inteiro. Com mapas, ele retorna a chave do próximo par de valores-chave.

Go fornece outro mapa de tipo de dados importante que mapeia chaves exclusivas para valores. Uma chave é um objeto que você usa para recuperar um valor em uma data posterior. Com uma chave e um valor, você pode armazenar o valor em um objeto Map. Depois que o valor é armazenado, você pode recuperá-lo usando sua chave.

Você deve usar a função make para criar um mapa.

/* declare a variable, by default map will be nil*/
var map_variable map[key_data_type]value_data_type

/* define the map as nil map can not be assigned any value*/
map_variable = make(map[key_data_type]value_data_type)

A função delete () é usada para deletar uma entrada do mapa. Requer mapa e chave correspondente que deve ser excluída.

A conversão de tipo é uma maneira de converter uma variável de um tipo de dados para outro tipo de dados. Por exemplo, se você deseja armazenar um valor longo em um inteiro simples, você pode digitar cast long para int. Você pode converter valores de um tipo para outro usando o operador de conversão da seguinte forma -

type_name(expression)

A programação Go fornece outro tipo de dados chamado interfaces que representa um conjunto de assinaturas de método. O tipo de dados struct implementa essas interfaces para ter definições de método para a assinatura de método das interfaces.