Go es un lenguaje de propósito general diseñado con la programación de sistemas en mente. Fue desarrollado inicialmente en Google en el año 2007 por Robert Griesemer, Rob Pike y Ken Thompson. Tiene un tipo fuerte y estático, proporciona soporte incorporado para la recolección de basura y admite programación concurrente. Los programas se construyen utilizando paquetes, para una gestión eficiente de las dependencias. Las implementaciones de programación de Go utilizan un modelo de enlace y compilación tradicional para generar binarios ejecutables.

Los siguientes son los beneficios de usar la programación Go:

• Soporte para entornos que adoptan patrones similares a los lenguajes dinámicos. Por ejemplo, la inferencia de tipo (x: = 0 es una declaración válida de una variable x de tipo int).

• El tiempo de compilación es rápido.

• Soporte de concurrencia InBuilt: procesos livianos (a través de goroutines), canales, declaración de selección.

• Concisión, sencillez y seguridad.

• Soporte para interfaces y tipo embdding.

• Producción de binarios nativos vinculados estáticamente sin dependencias externas.

No se admite la herencia de tipos.

No hay soporte para la sobrecarga del operador.

No se admite la sobrecarga de métodos.

No hay soporte para aritmética de punteros.

Sin soporte para programación genérica.

¡Si! Go es un lenguaje de programación sensible a mayúsculas y minúsculas.

La declaración de variable de tipo estático proporciona seguridad al compilador de que existe una variable con el tipo y el nombre dados, de modo que el compilador proceda a una compilación posterior sin necesidad de detalles completos sobre la variable. Una declaración de variable tiene su significado solo en el momento de la compilación, el compilador necesita una declaración de variable real en el momento de vincular el programa.

Una declaración de variable de tipo dinámico requiere que el compilador interprete el tipo de variable en función del valor que se le pasa. El compilador no necesita una variable para tener un tipo estáticamente como requisito necesario.

Sí Las variables de diferentes tipos se pueden declarar de una vez mediante la inferencia de tipos.

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

El siguiente código imprime el tipo de una variable:

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

Es una variable de puntero que puede contener la dirección de una variable.

Por ejemplo

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

Aquí se puede acceder a x mediante * p.

break termina la instrucción for loop o switch y transfiere la ejecución a la instrucción que sigue inmediatamente al bucle for o switch.

continue hace que el bucle omita el resto de su cuerpo e inmediatamente vuelva a probar su condición antes de reiterar.

goto transfiere el control a la declaración etiquetada.

La sintaxis de un bucle for en el lenguaje de programación Go es:

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

Aquí está el flujo de control en un bucle for:

• si la condición está disponible, el ciclo for se ejecuta siempre que la condición sea verdadera.

• si la cláusula for que es (init; condición; incremento) está presente entonces

  El paso init se ejecuta primero y solo una vez. Este paso le permite declarar e inicializar cualquier variable de control de bucle. No es necesario que coloque una declaración aquí, siempre que aparezca un punto y coma.

  A continuación, se evalúa la condición. Si es cierto, se ejecuta el cuerpo del bucle. Si es falso, el cuerpo del ciclo no se ejecuta y el flujo de control salta a la siguiente instrucción justo después del ciclo for.

  Después de que se ejecuta el cuerpo del bucle for, el flujo de control vuelve a la instrucción de incremento. Esta declaración le permite actualizar cualquier variable de control de bucle. Esta declaración se puede dejar en blanco, siempre que aparezca un punto y coma después de la condición.

  La condición ahora se evalúa nuevamente. Si es cierto, el ciclo se ejecuta y el proceso se repite (cuerpo del ciclo, luego paso de incremento, y luego condición de nuevo). Una vez que la condición se vuelve falsa, el ciclo for termina.

• si el rango está disponible, el ciclo for se ejecuta para cada elemento del rango.

La forma general de una definición de función en el lenguaje de programación Go es la siguiente:

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

Una definición de función en el lenguaje de programación Go consta de un encabezado de función y un cuerpo de función . Aquí están todas las partes de una función:

• func func inicia la declaración de una función.

• Function Name- Este es el nombre real de la función. El nombre de la función y la lista de parámetros juntos constituyen la firma de la función.

• Parameters −Un parámetro es como un marcador de posición. Cuando se invoca una función, se pasa un valor al parámetro. Este valor se conoce como parámetro o argumento real. La lista de parámetros se refiere al tipo, orden y número de parámetros de una función. Los parámetros son opcionales; es decir, una función puede no contener parámetros.

• Return Type- Una función puede devolver una lista de valores. losreturn_typeses la lista de tipos de datos de los valores que devuelve la función. Algunas funciones realizan las operaciones deseadas sin devolver un valor. En este caso, return_type no es obligatorio.

• Function Body - El cuerpo de la función contiene una colección de declaraciones que definen lo que hace la función.

Una función Go puede devolver varios valores. Por ejemplo

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)
}

Al llamar a una función, hay dos formas en que se pueden pasar argumentos a una función:

• Call by value- Este método copia el valor real de un argumento en el parámetro formal de la función. En este caso, los cambios realizados en el parámetro dentro de la función no tienen ningún efecto en el argumento.

• Call by reference −Este método copia la dirección de un argumento en el parámetro formal. Dentro de la función, la dirección se usa para acceder al argumento real usado en la llamada. Esto significa que los cambios realizados en el parámetro afectan el argumento.

De forma predeterminada, Go usa la llamada por valor para pasar argumentos. En general, esto significa que el código dentro de una función no puede alterar los argumentos utilizados para llamar a la función y el ejemplo mencionado anteriormente mientras se llama a la función max () utiliza el mismo método.

El lenguaje de programación Go proporciona flexibilidad para crear funciones sobre la marcha y utilizarlas como valores. Podemos establecer una variable con una definición de función y usarla como parámetro de una función.

El cierre de funciones son funciones anónimas y se pueden utilizar en programación dinámica.

El lenguaje de programación Go admite tipos especiales de funciones llamadas métodos. En la sintaxis de declaración de método, un "receptor" está presente para representar el contenedor de la función. Este receptor se puede utilizar para llamar a la función utilizando "." operador.

Una variable local tiene un valor predeterminado ya que corresponde al valor 0.

Una variable global tiene un valor predeterminado ya que corresponde al valor 0.

El puntero se inicializa a cero.

Imprime la salida formateada.

La expresión que aparece en el lado derecho del operador de asignación se llama rvalue. Rvalue se asigna a lvalue, que aparece en el lado izquierdo del operador de asignación. El lvalue debe designar a una variable, no a una constante.

Los parámetros enviados a la función al final de la llamada se llaman como parámetros reales mientras que en la recepción de la definición de función se llaman como parámetros formales.

La declaración asocia el tipo a la variable, mientras que la definición le da el valor a la variable.

Dividir el programa en subprogramas (módulos / función) para lograr la tarea dada es un enfoque modular. La definición de funciones más genéricas brinda la capacidad de reutilizar las funciones, como las funciones de biblioteca integradas.

Un programa Go consta de varios tokens y un token es una palabra clave, un identificador, una constante, una cadena literal o un símbolo.

ir

Array es una colección de elementos de datos similares con un nombre común.

Vaya al compilador y asigne un valor cero a una variable de puntero en caso de que no tenga una dirección exacta para asignar. Esto se hace en el momento de la declaración de la variable. Un puntero al que se le asigna nil se denomina puntero nil. El puntero nulo es una constante con un valor de cero definido en varias bibliotecas estándar.

Es una variable de puntero que puede contener la dirección de otra variable de puntero. Desreferencia dos veces para apuntar a los datos que contiene la variable de puntero 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)

Por lo tanto, se puede acceder a 'a' mediante ** pptr.

La estructura es otro tipo de datos definido por el usuario disponible en la programación de Go, que le permite combinar elementos de datos de diferentes tipos.

Para definir una estructura, debe utilizar declaraciones de tipo y estructura. La declaración de estructura define un nuevo tipo de datos, con más de un miembro para su programa. La sentencia type une un nombre con el tipo que es struct en nuestro caso.

El formato de la declaración de estructura es este:

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

Go Slice es una abstracción de Go Array. As Go Array le permite definir el tipo de variables que pueden contener varios elementos de datos del mismo tipo, pero no proporciona ningún método incorporado para aumentar el tamaño de forma dinámica u obtener una submatriz propia. Slices cubre esta limitación. Proporciona muchas funciones de utilidad requeridas en Array y se usa ampliamente en la programación Go.

Para definir un segmento, puede declararlo como una matriz sin especificar el tamaño o usar la función make para crear el uno.

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*/

La función len () devuelve los elementos presentes en el segmento.

La función len () devuelve los elementos presentes en el segmento donde la función cap () devuelve la capacidad del segmento según la cantidad de elementos que se pueden acomodar.

Slice permite especificar el límite inferior y el límite superior para obtener su sublicencia usando [lower-bound: upper-bound].

La palabra clave range se usa en el bucle for para iterar sobre elementos de una matriz, segmento, canal o mapa. Con matriz y rebanadas, devuelve el índice del elemento como entero. Con mapas, devuelve la clave del siguiente par clave-valor.

Go proporciona otro mapa importante de tipos de datos que asigna claves únicas a valores. Una clave es un objeto que usa para recuperar un valor en una fecha posterior. Dada una clave y un valor, puede almacenar el valor en un objeto Map. Una vez almacenado el valor, puede recuperarlo utilizando su clave.

Debe utilizar la función make para crear un 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)

La función delete () se utiliza para eliminar una entrada del mapa. Requiere mapa y clave correspondiente que se eliminará.

La conversión de tipos es una forma de convertir una variable de un tipo de datos a otro tipo de datos. Por ejemplo, si desea almacenar un valor largo en un entero simple, puede escribir cast long a int. Puede convertir valores de un tipo a otro utilizando el operador de conversión de la siguiente manera:

type_name(expression)

La programación de Go proporciona otro tipo de datos llamado interfaces que representa un conjunto de firmas de métodos. El tipo de datos de estructura implementa estas interfaces para tener definiciones de método para la firma de método de las interfaces.