Canales golang

Un canal en Go se refiere a una técnica a través de la cual las goroutinas pueden comunicarse. En pocas palabras, un canal es una tubería a través de la cual puede conectar goroutinas concurrentes, permitiendo comunicación. La comunicación entre Goroutinas es bidireccional. Por lo tanto, permitir que las goroutinas envíen y reciban valor a través del mismo canal.

Golang Crear canal

Antes de que podamos usar un canal en Go, debemos crear uno. Para crear un canal en GO, podemos usar la función Make para crear un nuevo canal.

La sintaxis es como se muestra:

hacer (tipo chan valv)

Tenga en cuenta que un canal es sensible al tipo de datos. Esto significa que no podemos enviar un valor int a través de un canal de cadena.

El siguiente ejemplo crea un canal que solo puede admitir tipos de cadenas:

ch: = make (cadena chan)

Una vez que tenemos un canal declarado, podemos enviar y recibir valores.

Enviar y recibir valores

Podemos enviar y recibir valores usando el canal <- operator. An example code is as shown below:

paquete principal
importar "fmt"
funcmain ()
CH: = Make (Chanstring)
// Enviar al canal
gofunc ()
pez<- "Hello"
()
// recibir
Msg: = <-ch
fmt.Println (msg)

En el ejemplo anterior, creamos una Goroutine básica para enviar los datos al canal "CH". Luego recibimos los datos del canal e los imprimimos.

Enviar estructura a través del canal

También podemos enviar datos de estructura a través de un canal, siempre que creemos el canal con el tipo correcto.

Considere el siguiente ejemplo del código:

paquete principal
importar "fmt"
Escriba la estructura de usuario
FirstName, LastNamestring

funcmain ()
user1: = user "jane", "doe"
CH: = Make (usuario de Chan)
gofunc ()
pez<- user1
()
First_Name: = (<-ch).FirstName
fmt.Println (first_name)

Si ejecutamos el código anterior, debe imprimir el primer nombre como recibido por la estructura enviada a través del canal.

Canales unidireccionales

Como se mencionó, los canales GO son bidireccionales por defecto. Sin embargo, podemos definir un canal para que pueda enviar o recibir valores, pero no ambos. Esto se conoce como un canal unidireccional.

La sintaxis es como se muestra:

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

Observe la posición del operador del canal en la sintaxis anterior.

El siguiente ejemplo crea un canal de envío solo:

paquete principal
importar "fmt"
Escriba la estructura de usuario
FirstName, LastNamestring

funcmain ()
CH: = hacer (chan<- string)
gofunc ()
pez<- "Hi"
()
Msg: = <- ch

Nota El canal anterior está configurado para enviar solo. Sin embargo, intentamos recibir a través del canal, y el compilador devuelve un error como se muestra:

operación inválida: <-ch (receive de envío solo chan<- string)

Canales de cierre

Podemos cerrar un canal después de que se envíen los valores requeridos. Para eso, usamos la función cerrada. Se necesita el nombre del canal. Luego cierra el canal y devuelve un valor booleano que puede usar para verificar si el canal está cerrado.

A continuación se muestra un ejemplo:

paquete principal
importar "fmt"
Escriba la estructura de usuario
FirstName, LastNamestring

funcmain ()
CH: = Make (Chanstring)
gofunc ()
pez<- "Hi"
()
_, OK: = <-ch
Cerrar (CH)
si !OK
fmt.Println ("cerrado ... [ok]")

fmt.Println ("Cerrar ... [Fail!] ")

El ejemplo anterior cierra el canal usando el método Close (). Luego usamos el valor booleano devuelto de la función para verificar si el canal está cerrado.

Conclusión

Esta guía lo guía a través de cómo trabajar con canales en el lenguaje de programación GO. Se discutió el proceso de crear un canal, enviar y recibir valores, enviar datos de estructura a través de un canal, explicar los canales unidireccionales y cerrar los canales. Esperamos que hayas encontrado este artículo útil. Consulte los otros artículos de Sugerencia de Linux para obtener más consejos e información.