Canais de Golang

Um canal em Go refere -se a uma técnica através da qual as goroutinas podem se comunicar. Simplificando, um canal é um tubo através do qual você pode conectar goroutinas simultâneas, permitindo comunicação. A comunicação entre goroutines é bidirecional. Assim, permitindo que as goroutinas enviem e recebessem valor através do mesmo canal.

Golang Crie canal

Antes que possamos usar um canal em Go, devemos criar um. Para criar um canal no GO, podemos usar a função Make para criar um novo canal.

A sintaxe é como mostrado:

Make (Chan Val-Type)

Lembre -se de que um canal é sensível ao tipo de dados. Isso significa que não podemos enviar um valor int através de um canal de string.

O exemplo a seguir cria um canal que só pode suportar tipos de string:

CH: = Make (string chan)

Depois de declararmos um canal, podemos enviar e receber valores.

Enviando e recebendo valores

Podemos enviar e receber valores usando o canal <- operator. An example code is as shown below:

Pacote principal
importar "fmt"
funcmain ()
CH: = Make (Chanstring)
// Enviar para o canal
Gofunc ()
CH<- "Hello"
()
// recebe
msg: = <-ch
fmt.Println (msg)

No exemplo anterior, criamos uma goroutina básica para enviar os dados para o canal "ch". Em seguida, recebemos os dados do canal e os imprimimos.

Enviando estrutura via canal

Também podemos enviar dados de estrutura através de um canal, desde que criemos o canal com o tipo correto.

Considere o seguinte exemplo de código:

Pacote principal
importar "fmt"
Tipo de estrutura de usuário
Primeiro nome, por último

funcmain ()
Usuário1: = Usuário "Jane", "Doe"
CH: = Make (usuário chan)
Gofunc ()
CH<- user1
()
primeiro_name: = (<-ch).FirstName
fmt.Println (primeiro_name)

Se executarmos o código anterior, ele deve imprimir o primeiro nome recebido pela estrutura enviada pelo canal.

Canais unidirecionais

Como mencionado, os canais GO são bidirecionais por padrão. No entanto, podemos definir um canal para que ele possa enviar ou receber valores, mas não ambos. Isso é conhecido como um canal unidirecional.

A sintaxe é como mostrado:

CH: = Make (chan<- data_type) // send-only channel
CH: = Make (<-chan data_type) // receive only channel

Observe a posição do operador de canal na sintaxe anterior.

O exemplo a seguir cria um canal somente de envio:

Pacote principal
importar "fmt"
Tipo de estrutura de usuário
Primeiro nome, por último

funcmain ()
CH: = Make (chan<- string)
Gofunc ()
CH<- "Hi"
()
msg: = <- ch

Observe que o canal anterior está definido apenas para enviar. No entanto, tentamos receber através do canal e o compilador retorna um erro como mostrado:

operação inválida: <-ch (receive de Tipo somente de envio Chan<- string)

Canais de fechamento

Podemos fechar um canal depois que os valores necessários forem enviados. Para isso, usamos a função próxima. É preciso o nome do canal. Em seguida, fecha o canal e retorna um valor booleano que você pode usar para verificar se o canal está fechado.

Um exemplo é mostrado abaixo:

Pacote principal
importar "fmt"
Tipo de estrutura de usuário
Primeiro nome, por último

funcmain ()
CH: = Make (Chanstring)
Gofunc ()
CH<- "Hi"
()
_, ok: = <-ch
fechar (ch)
se !OK
fmt.Println ("fechado ... [ok]")

fmt.Println ("Fechar… [Fail!] ")

O exemplo anterior fecha o canal usando o método Close (). Em seguida, usamos o valor booleano retornado da função para verificar se o canal está fechado.

Conclusão

Este guia o leva a como trabalhar com canais na linguagem de programação Go. O processo de criação de um canal, envio e recebendo valores, enviando dados de estrutura por meio de um canal, explicando os canais unidirecionais e fechando os canais foram discutidos. Esperamos que você tenha achado este artigo útil. Confira os outros artigos de dica do Linux para obter mais dicas e informações.