Encapsulación en Golang

La encapsulación se define como el empaquetado de datos en una sola unidad. Es el mecanismo que une el código y los datos que manipula. De otra manera, el encapsulamiento es un escudo protector que evita que el código acceda a los datos fuera de este escudo.

En los lenguajes orientados a objetos, las variables o datos de una clase están ocultos para cualquier otra clase y solo se puede acceder a ellos a través de cualquier función miembro de la propia clase en la que se declaran. Pero el lenguaje Go no admite clases y objetos. Entonces, en el lenguaje Go, la encapsulación se logra mediante el uso de paquetes. Go proporciona dos tipos diferentes de identificadores, es decir, identificadores exportados y no exportados. La encapsulación se logra mediante elementos exportados ( variables , funciones , métodos , campos, estructuras ) de los paquetes, ayuda a controlar la visibilidad de los elementos (variables, funciones, métodos, campos, estructuras). Los elementos son visibles si el paquete en el que están definidos está disponible en su programa.

1. Identificadores exportados: Los identificadores exportados son aquellos identificadores que se exportan del paquete en el que están definidos. La primera letra de estos identificadores siempre está en mayúscula. Esta letra mayúscula indica que el identificador dado es un identificador exportado. Los identificadores exportados siempre están limitados al paquete en el que están definidos. Cuando exporta el identificador especificado del paquete, simplemente exporta el nombre, no la implementación de ese identificador. Este mecanismo también es aplicable para funciones, campos, métodos y estructuras.

Ejemplo:

// Go program to illustrate
// the concept of encapsulation
// using exported function
package main
  
import (
    "fmt"
    "strings"
)
  
// Main function
func main() {
  
    // Creating a slice of strings
    slc := []string{"GeeksforGeeks", "geeks", "gfg"}
  
    // Convert the case of the
    // elements of the given slice
    // Using ToUpper() function
    for x := 0; x < len(slc); x++ {
  
        // Exported Method
        res := strings.ToUpper(slc[x])
  
        // Exported Method
        fmt.Println(res)
    }
}

Producción:

GEEKSFORGEEKS
GEEKS
GFG

Explicación: En el ejemplo anterior, convertimos el caso de los elementos del segmento slc a mayúsculas exportando la función ToUpper() del paquete de strings.

res := strings.ToUpper(slc[x])

Aquí, la primera letra de la función ToUpper() está en mayúsculas, lo que indica que esta función es una función exportada. Si intenta cambiar el caso de la función ToUpper() a minúsculas, el compilador dará un error, como se muestra a continuación:

res := strings.toUpper(slc[x])

Output:
./prog.go:22:9: cannot refer to unexported name strings.toUpper
./prog.go:22:9: undefined: strings.toUpper

Entonces, este proceso (exportación de variables, campos, métodos, funciones, estructuras) se conoce como encapsulación. Debido a la encapsulación, solo exportamos el nombre de la función, no la definición completa de la función en nuestro programa y la definición de la función ToUpper() está envuelta dentro del paquete de strings, por lo que para exportar la función ToUpper() primero debe importar el paquete de strings. en tu programa

2. Identificadores no exportados: Los identificadores no exportados son aquellos identificadores que no se exportan de ningún paquete. Siempre están en minúsculas. Como se muestra en el siguiente ejemplo, la función de adición no está relacionada con ningún paquete, por lo que es una función no exportada y la visibilidad de este método se limita solo a este programa.

Ejemplo:

// Go program to illustrate
// the unexported function
package main
  
import "fmt"
  
// The addition function returns
// the sum of the elements
// Unexported function
func addition(val ...int) int {
    s := 0
  
    for x := range val {
        s += val[x]
    }
  
    fmt.Println("Total Sum: ", s)
    return s
}
  
// Main function
func main() {
  
    addition(23, 546, 65, 42, 21, 24, 67)
}

Producción:

Total Sum:  788

Beneficios de la encapsulación:

• Ocultar detalles de implementación del usuario.
• Aumentar la reutilización del código.
• Evita que los usuarios establezcan las variables de la función de forma arbitraria. Solo establece la función en el mismo paquete y el autor de ese paquete se asegura de que la función mantenga sus invariantes internas.