45 perguntas e respostas para entrevistas de emprego Golang em 2024

Golang, também conhecido como Go, é uma linguagem de programação de código aberto criada pela Google em 2007 e lançada em 2009. Ele foi projetado para ser uma linguagem de programação moderna que pode lidar com uma variedade de aplicações, desde sistemas de rede até aplicações de web e mobile. Golang é amplamente utilizado por desenvolvedores em todo o mundo para criar aplicativos robustos e escaláveis.

A Golang foi desenvolvida com o objetivo de fornecer uma linguagem eficiente, simples e segura para lidar com sistemas de larga escala e de alta performance, incluindo sistemas de rede, servidores web, infraestrutura de nuvem e outras aplicações de backend.

Go é especialmente adequado para tarefas que requerem concorrência, paralelismo e processamento distribuído, sendo uma linguagem de programação popular em áreas como DevOps e computação em nuvem. Além disso, ele é conhecido por sua sintaxe limpa, sua eficiência em termos de tempo de compilação e sua execução rápida, características que fazem dele uma escolha popular para projetos de código aberto e empresas de tecnologia.

Esta é uma pergunta comum em entrevistas de emprego Golang. Pacotes Go (abreviados como pkg) são simplesmente diretórios no espaço de trabalho Go que contêm arquivos de código-fonte Go ou outros pacotes Go. Cada parte do código criada nos arquivos de origem, desde variáveis até funções, é então colocada em um pacote vinculado. Cada arquivo de origem deve estar associado a um pacote.

Uma literal de string é uma sequência de caracteres encadeados que forma uma string. As literais de string são divididas em dois tipos: literais de string brutas, ou raw, e literais de string interpretadas. As literais de string brutas são delimitadas pelo símbolo ` (foo), do acento grave, e contêm caracteres UTF-8 não interpretados. As literais de string interpretadas são strings escritas entre aspas duplas (“ “) e podem conter qualquer caractere, exceto novas linhas e aspas duplas incompletas.

Esta é uma pergunta comum em entrevistas Golang, relacionada ao escopo da linguagem. Aqui vão os tipos de dados usados pela Go, com seus nomes já em inglês:

• Slice
• Struct
• Pointer
• Function
• Method
• Boolean
• Numeric
• String
• Array
• Interface
• Map
• Channel

Uma Goroutine é uma função ou procedimento que é executado simultaneamente com outras Goroutines em uma thread dedicada de Goroutines. As threads de Goroutines são mais leves do que as threads comuns e a maioria dos programas Golang usa milhares de Goroutines ao mesmo tempo. Uma Goroutine pode ser interrompida ao passar para ela um sinal de channel. Como as Goroutines só podem responder aos sinais se forem ensinadas a realizar verificações, é preciso colocar verificações em lugares lógicos, como no topo do seu for loop.

Com suítes de testes personalizados, o Golang fornece testes automatizados para pacotes. Então, para testar pacotes você pode seguir os seguintes passos:

Crie uma nova suíte escrevendo um arquivo que termine com _test.go e contenha uma função TestXxx, onde Xxx é substituído pelo nome da funcionalidade que está sendo testada. Um método que testa as capacidades de login, por exemplo, seria chamado de TestLogin. O arquivo da suíte de testes é então incluído no mesmo pacote do arquivo a ser testado. O arquivo de teste será ignorado durante a execução usual, mas será executado quando o comando go test for usado.

Esta é uma pergunta de entrevista de Golang que pode ser considerada uma pegadinha, já que o Golang não suporta classes, portanto não há herança. No entanto, é possível usar a composição para imitar o comportamento de herança ao aproveitar um objeto struct existente para estabelecer o comportamento inicial de um novo objeto. Depois que o novo objeto é criado, a funcionalidade da struct original pode ser aprimorada.

Só existe um looping construct no Go: o for loop. O for loop é composto por três partes separadas por ponto e vírgula:

• Antes do loop começar, a declaração Init é executada. Geralmente é uma declaração de variável que só é acessível no escopo do for loop;
• Antes de cada iteração, a declaração de condição é avaliada como um Boolean para determinar se o loop deve continuar;
• No final de cada ciclo, a declaração post é executada.

Esta é uma pergunta importante em entrevistas de emprego Golang. Go é uma tentativa de criar uma nova linguagem que fosse concorrente, coletora de lixo e com compilação rápida, contando com as seguintes vantagens:

• Uma grande aplicação Go pode ser compilada em questão de segundos com uma só máquina;
• Go fornece uma arquitetura para desenvolvimento de software que simplifica a análise de dependências enquanto evita grande parte da complexidade associada a programas no estilo C, como arquivos e bibliotecas;
• Por não haver hierarquia no sistema de tipos do Go, nenhum trabalho é desperdiçado descrevendo as relações entre tipos. Além disso, embora a Golang use tipos estáticos, ela se esforça para tornar os tipos mais leves do que em linguagens OO tradicionais;
• Go conta com um coletor de lixo e suporta execução paralela e comunicação em sua base;
• O design do Go apresenta um método para desenvolver software de sistemas em processadores multicore.

A declaração de variável de tipo dinâmico requer que o compilador interprete o tipo de variável com base no valor fornecido. O compilador não considera necessário que uma variável tenha um tipo estático.

A declaração de variável de tipo estático garante ao compilador que há apenas uma variável com o nome e tipo fornecidos, permitindo que o compilador continue compilando sem ter todos os detalhes da variável. Uma declaração de variável só tem significado durante a compilação do programa; o compilador exige uma declaração de variável genuína durante a vinculação do programa.

Essa é uma pergunta de entrevista de emprego Golang bastante comum. Em um canal não-bufferizado (unbuffered channel), o remetente irá bloquear até que o receptor receba dados do canal, e o receptor irá bloquear no canal até que o remetente coloque dados no canal.

O remetente do canal bufferizado (buffered channel) irá bloquear quando não houver um slot vazio no canal, porém o receptor irá bloquear no canal quando estiver vazio, ao contrário do canal não bufferizado.

fmt é um pacote da biblioteca padrão do Golang que fornece funções para formatação de strings, leitura e escrita de dados no console e em arquivos, entre outras funcionalidades relacionadas à formatação de saída. É frequentemente usado para formatar strings de log, depuração e mensagens de erro. O pacote fmt também é usado para imprimir valores na saída padrão usando as funções Print, Printf, Println, além de outros métodos úteis para trabalhar com strings e formatar a saída.

Uma interface é uma abstração que define um conjunto de comportamentos esperados de um tipo, sem especificar como esses comportamentos são implementados.

As interfaces em Golang são definidas usando a palavra-chave interface seguida por um conjunto de assinaturas de método. Um tipo que implementa todos os métodos especificados em uma interface é considerado como implementando essa interface e, portanto, pode ser tratado como esse tipo de interface.

Em Golang, a configuração do ambiente e dos job paramenters, ou parâmetros de trabalho, é feita por meio do uso de variáveis de ambiente e argumentos de linha de comando, respectivamente.

As variáveis de ambiente são usadas para armazenar informações importantes para o sistema, como chaves de API, credenciais de autenticação, configurações de ambiente, etc. No Go, é possível acessar as variáveis de ambiente por meio do pacote os.

Os argumentos da linha de comando são usados para passar informações para o programa durante a execução. O Go suporta a passagem de argumentos de linha de comando usando a variável os.Args. O primeiro elemento em os.Args é o nome do programa e os elementos restantes são os argumentos passados para o programa.

Para utilizar custom packages na linguagem de programação Go, primeiro é necessário criar o pacote. Isso pode ser feito criando um diretório com o nome do pacote e adicionando arquivos Go dentro desse diretório.

Dentro do diretório do pacote, deve ser criado um arquivo com o nome go.mod, que é o arquivo de definição do módulo. Esse arquivo contém o nome do módulo, versão e outras informações relevantes.

Após criar o pacote, pode-se utilizá-lo em um programa Go através da declaração import. O nome do pacote deve ser o mesmo nome do diretório do pacote. A partir daí, é possível utilizar as funções, tipos e variáveis definidas no pacote como se fossem parte do programa atual.

Em Golang, não existe um tipo de dados chamado "enum". Em vez disso, é comum usar constantes não tipadas para representar valores discretos. As constantes são definidas usando a palavra-chave "const" e não podem ser alteradas durante a execução do programa.

No Go, o tipo de uma variável é verificado em tempo de compilação, não em tempo de execução. Isso significa que, uma vez que um programa Go é compilado com sucesso, o tipo de todas as variáveis é conhecido e verificado pelo compilador.

No entanto, há casos em que é necessário lidar com valores desconhecidos em tempo de compilação, como ao trabalhar com interfaces, e neste caso, é possível usar a verificação de tipo em tempo de execução usando a sintaxe .(type) no Go. Essa sintaxe é conhecida como type assertion e é usada para acessar o valor subjacente de uma interface como o tipo subjacente. Se o valor subjacente não for do tipo esperado, a verificação de tipo falhará em tempo de execução.

Uma data race, ou corrida de dados, ocorre em Golang quando duas ou mais goroutines tentam acessar e modificar uma mesma variável simultaneamente, sem sincronização adequada. Isso pode levar a resultados imprevisíveis, incluindo falhas de segmentação, pânico, corrupção de dados ou outras anomalias.

A coexistência de duas ou mais goroutines, em tempo de execução, criam a possibilidade de corridas de dados. Isso pode ocorrer quando duas ou mais goroutines acessam a mesma variável simultaneamente, sem a proteção adequada. Essa condição pode ocorrer mesmo que as goroutines envolvidas estejam tentando executar leituras, já que as leituras de uma goroutine podem ocorrer simultaneamente com as escritas de outro.

A coleta de lixo (ou garbage collection, em inglês) é um recurso que muitas linguagens de programação oferecem para gerenciar automaticamente o uso da memória no programa. Em Golang, a coleta de lixo é usada para liberar a memória que não está mais sendo usada pelo programa, ou seja, aquela que não possui mais referências para ser acessada. Isso é feito pelo coletor de lixo do Golang, que identifica e remove as áreas de memória não utilizadas pelo programa, deixando-as disponíveis para outros fins.

Em Golang, os testes são escritos usando o pacote testing da própria linguagem. O pacote testing fornece funções e tipos para escrever unit tests em Golang. Para escrever um teste, você pode criar um arquivo com o sufixo _test.go no mesmo pacote do código que está sendo testado.

Dentro desse arquivo, você pode definir funções de teste usando a convenção de nomenclatura TestXxx, onde "Xxx" é o nome do teste. Dentro da função de teste, você pode usar as funções fornecidas pelo pacote testing para verificar se o código funciona conforme o esperado.

Já para executar os testes, você pode usar o comando go test no diretório raiz do seu projeto ou em um pacote específico. O comando go test compila o código do pacote e executa todos os testes encontrados no pacote. Ele também fornece detalhes sobre o resultado de cada teste.

Slices são uma estrutura de dados em Golang que permitem trabalhar com sequências de elementos de um array de forma flexível e conveniente. Eles são um tipo de referência que envolve um array subjacente e um par de ponteiros: um apontando para o início do slice e outro apontando para o seu final.

Slices também são uma forma eficiente de passar subconjuntos de dados para funções, sem a necessidade de copiar os dados subjacentes do array original. Além disso, os slices oferecem uma variedade de funções integradas para manipulação de dados, como append(), copy() e len().

A heap memory é a área da memória usada para alocar memória para valores que duram além do ciclo de vida de uma função. Ela é uma área de memória dinamicamente alocada que pode ser acessada por várias partes do programa e é gerenciada pelo coletor de lixo da linguagem.

Function closures, ou simplesmente closures, são funções que capturam variáveis definidas fora de seu escopo. Em outras palavras, uma closure é uma função que possui acesso às variáveis em seu ambiente léxico, mesmo que essas variáveis não estejam mais disponíveis em seu escopo original. Isso é possível porque a closure mantém uma referência a essas variáveis, permitindo que elas sejam acessadas mesmo depois que a função original foi concluída.

A declaração goto é uma estrutura de controle em Golang que permite que o código salte para uma determinada linha de código identificada por um rótulo. No entanto, o uso de goto em programas Golang é desencorajado, pois pode tornar o código difícil de entender e manterjá que seu uso pode criar loops infinitos, tornar o código menos legível e dificultar a depuração. Isso faz com que o uso de goto seja considerado uma prática de programação ruim em muitas comunidades de desenvolvimento de software.

Lvalue é uma expressão que se refere a um valor armazenado na memória, e pode ser usada como um endereço de memória. Ou seja, é uma expressão que pode ser atribuída a um valor.

Por outro lado, Rvalue é uma expressão que é avaliada para um valor, mas não pode ser usada como um endereço de memória.

Design patterns são soluções para problemas comuns de programação que surgem repetidamente em projetos de software. Eles são soluções comprovadas e testadas que os desenvolvedores podem usar para resolver problemas específicos em seus projetos.

Embora o Golang não tenha suporte nativo para todos os padrões de design orientado a objetos, muitos deles ainda podem ser implementados em Golang usando seus recursos, como structs, interfaces, métodos e composição.

Golang não segue completamente o paradigma da orientação a objetos que nem outras linguagens, como Java e C#. Embora ele tenha tipos de dados estruturados, o Golang não suporta classes e herança de forma tradicional.

Em vez disso, ele usa structs para definir tipos de dados personalizados e métodos para definir comportamentos associados a esses tipos. A struct é uma coleção de campos de dados relacionados que podem ser acessados ​​por meio do nome do campo. O Golang usa o conceito de composição em vez de herança. Isso significa que uma struct pode incorporar campos de outras structs para reutilizar o código.

O Golang também suporta interfaces, que são coleções de métodos que definem um comportamento. Uma struct pode implementar uma ou mais interfaces e, em seguida, ser usada como um tipo de valor da interface. Isso permite que ele suporte polimorfismo.

Embora o Golang possa ser usado para escrever programas orientados a objetos, ele é frequentemente usado para escrever programas estruturados ou funcionais, que são conceitos mais comuns na linguagem.

O Golang suporta conversões de dados entre os tipos básicos, como inteiros, ponto flutuante, booleanos, entre outros. Também é possível converter strings para outros tipos básicos ou vice-versa usando funções como strconv.Atoi, strconv.ParseFloat, strconv.ParseBool, strconv.FormatInt, entre outras. Além disso, é possível converter dados de um tipo de struct para outro usando a sintaxe de conversão de tipo.

Uma struct é um tipo de dados composto que representa um registro ou objeto contendo um conjunto de campos nomeados. Cada campo da struct tem um nome e um tipo de dados, semelhante a uma classe em outras linguagens de programação orientadas a objetos.

A struct é uma estrutura de dados leve que permite agrupar diferentes tipos de dados em um único objeto. Além disso, elas podem ser aninhadas e ter campos exportados (iniciados com letra maiúscula) ou não exportados (iniciados com letra minúscula), dependendo da visibilidade necessária.

As structs são usadas frequentemente para representar tipos de dados complexos, como estruturas de dados, registros de banco de dados, objetos JSON, entre outros.

cgo é uma ferramenta disponível no Golang que permite a interação com código C. É uma funcionalidade importante que permite que o Golang use bibliotecas e funções C existentes e fornece interoperabilidade entre código Go e código C.

Ele permite que os programadores escrevam código Go que chame funções C, use tipos C e inclua arquivos de cabeçalho C. Isso torna mais fácil a reutilização de código legado escrito em C ou a integração do Golang com outras bibliotecas que não estão disponíveis nativamente no Golang.

Cursors são usados para percorrer os resultados de uma consulta ou busca em um banco de dados. O cursor é um objeto que aponta para um registro específico dentro do conjunto de resultados e permite que você avance ou retroceda nesses resultados, lidando com grandes quantidades de dados de maneira eficiente e evitando a sobrecarga de memória.

Basicamente, ele permite que você recupere um pequeno conjunto de dados de cada vez, em vez de tentar recuperar todos os dados de uma só vez. Isso é particularmente útil quando se trabalha com conjuntos de dados muito grandes que podem esgotar a memória disponível se forem recuperados de uma só vez.

Concurrency e parallelism, ou concorrência e paralelismo, são conceitos relacionados, mas diferentes em Golang.

Concurrency refere-se à capacidade de executar várias tarefas em um determinado momento, mas não necessariamente simultaneamente. Em Golang, a concorrência é alcançada por meio de goroutines, que são threads leves gerenciadas pelo runtime do Golang. As goroutines são executadas de forma assíncrona e podem ser iniciadas em paralelo.

Por outro lado, parallelism refere-se à capacidade de executar várias tarefas simultaneamente. Em Golang, o parallelism é alcançado executando múltiplas goroutines em paralelo em múltiplos núcleos de CPU.

Goroutines são mais leves do que as threads convencionais e usam multiplexação em vez de paralelismo real. As goroutines são executadas em uma única thread, gerenciadas pelo tempo de execução de Golang (GOROOT) e são cooperativas, o que significa que elas voluntariamente liberam o controle para permitir que outras goroutines sejam executadas.

Por outro lado, as threads são geralmente mais pesadas do que as goroutines, exigindo mais recursos do sistema operacional. As threads são escalonadas pelo sistema operacional e competem por recursos, como memória e CPU.

Sim, é possível fazer algo em goroutines sem usar channels. As goroutines podem ser usadas para executar uma função de forma assíncrona sem a necessidade de comunicação explícita entre elas. Por exemplo, podemos usar uma goroutine para executar uma tarefa em segundo plano enquanto a thread principal continua a executar outras tarefas. No entanto, em geral, o uso de channels é uma maneira conveniente e segura de se comunicar e sincronizar dados entre goroutines.

Em Golang, um array é uma sequência fixa de elementos do mesmo tipo com um tamanho específico definido na sua criação, enquanto um slice é uma estrutura de dados dinâmica que fornece uma visão flexível de uma sequência de elementos de um array. Em outras palavras, um array tem um tamanho fixo definido na sua criação e não pode ser redimensionado, enquanto um slice pode ser redimensionado e manipulado com funções como append() e copy().

Ao contrário dos arrays, que são passados por valor, os slices são passados por referência e têm uma capacidade subjacente ao array que eles se referem. Além disso, os slices podem ser usados para criar sub-slices que compartilham a mesma matriz subjacente, permitindo a manipulação eficiente de grandes conjuntos de dados sem a necessidade de copiar ou realocar grandes blocos de memória.

Em Golang, não é possível dizer explicitamente a uma goroutine para usar menos threads, pois a alocação de threads é gerenciada automaticamente pelo sistema de tempo de execução (runtime).

No entanto, é possível ajustar algumas configurações do runtime, como o número de threads alocadas, a quantidade de memória usada e o limite de CPU, usando as funções da biblioteca runtime. Mas é importante lembrar que fazer ajustes incorretos nessas configurações pode afetar negativamente o desempenho do programa.

Um mapa (map) pode armazenar valores de qualquer tipo que sejam comparáveis. Isso inclui tipos básicos, como int, string, float, bool, bem como tipos compostos, como arrays, structs e até mesmo outros mapas. No entanto, os tipos de chaves devem ser comparáveis e, portanto, não podem incluir funções, mapas ou slices. Além disso, os tipos de valor podem ser quaisquer tipos, incluindo tipos definidos pelo usuário, como structs ou ponteiros.

Uma rune é um tipo de dado que representa um ponto de código Unicode. Ela é um alias para o tipo int32, o que significa que cada rune é representado internamente como um número inteiro de 32 bits. runes são usadas para trabalhar com caracteres Unicode em Go, uma vez que permite que cada caractere seja representado por um único valor. Isso é importante porque alguns caracteres Unicode são compostos por vários pontos de código. A utilização de rune permite trabalhar com strings que contêm caracteres Unicode de forma mais fácil e eficiente.

Em Go, não existe um conceito de "services" (serviços) como no Angular ou em outros frameworks. No entanto, é possível criar pacotes ou módulos que forneçam funcionalidades específicas, que podem ser considerados como serviços em um sentido mais amplo. Esses pacotes podem fornecer funções ou métodos que executam tarefas específicas, como conexão com bancos de dados, comunicação com APIs externas, processamento de arquivos, entre outras.

Além disso, é comum em Go criar estruturas que encapsulam um conjunto de dados e as funções que operam sobre eles. Essas estruturas podem ser consideradas como "serviços" em um sentido mais restrito, já que fornecem funcionalidades específicas para um conjunto de dados, como validação, persistência e processamento.

Um singleton é um padrão de projeto que garante que apenas uma instância de uma determinada classe seja criada e usada durante todo o tempo de vida de uma aplicação. Ele é uma forma de garantir que apenas uma instância de um objeto seja criada e usada em toda a aplicação. Em outras palavras, o singleton é uma forma de criar uma única instância de um objeto e garantir que ela seja usada por toda a aplicação, evitando que várias instâncias do mesmo objeto sejam criadas e usadas. Em Golang, é possível implementar o padrão singleton de diversas formas, uma das mais comuns sendo através de variáveis globais.

Golang é uma linguagem projetada para tornar a programação mais simples, rápida e segura, o que significa que muitas tarefas podem ser feitas sem a necessidade de um framework. No entanto, existem casos em que o uso de um framework pode ser apropriado em Golang.

Por exemplo, se você estiver desenvolvendo uma aplicação web complexa, um framework como o Gin, o Echo ou o Beego pode ser útil para lidar com rotas, gerenciamento de sessões, autenticação e outras tarefas comuns. Esses frameworks são projetados para serem leves e eficientes em termos de recursos, para que possam ser usados sem afetar significativamente o desempenho da aplicação.

Em Go, a orientação a objetos é alcançada através de tipos, interfaces e métodos. Em vez de usar classes, Go usa a composição para construir tipos mais complexos a partir de tipos mais simples. Isso significa que nela, as funções e os dados são agrupados em tipos que podem ser usados para definir structs, que são semelhantes a objetos em outras linguagens.

As goroutines são leves porque elas são executadas em threads gerenciadas pelo próprio sistema operacional, o que permite que o Go crie milhares de goroutines com facilidade. Isso é diferente de outras linguagens de programação em que cada thread consome uma grande quantidade de memória e recursos do sistema.

Em vez disso, em Go, cada goroutine é executada em uma pequena pilha de memória, que é criada quando a goroutine é iniciada e é liberada automaticamente quando a goroutine é encerrada. Além disso, o Go possui um coletor de lixo eficiente que gerencia a memória, o que ajuda a evitar vazamentos de memória e a manter o desempenho em níveis elevados.

Sim, as threads em Golang, chamadas de goroutines, compartilham memória por meio da comunicação por canais (channels) e do uso de tipos de dados seguros para concorrência, como os tipos atomic e mutex. Em Golang, a comunicação por canais é a principal forma de sincronização entre goroutines e é uma abordagem que evita problemas comuns em outras linguagens, como as condições de corrida (race conditions). Dessa forma, as goroutines podem compartilhar informações sem a necessidade de travar regiões críticas da memória, o que pode levar a problemas de desempenho.