Explorando las variables e identificadores del lenguaje Go: almacenamiento flexible de datos

Tabla de contenido

identificador

reglas de nomenclatura

convenio de denominación

Ejemplos de uso de identificadores

variable

Tipos de variables comunes

Declaración y asignación de variables

Inicialización de variables

imagen

Para obtener más puntos técnicos relacionados con Go, preste atención a la cuenta pública: publicaciones posteriores de CTO Plus . Si tiene alguna pregunta, deje un mensaje en segundo plano para comunicarse.

Texto original: Explorando las variables e identificadores del lenguaje Go: almacenamiento flexible de datos

Dado que muchos fanáticos dejaron mensajes en segundo plano para preguntar sobre la información técnica del desarrollo de Go, rápidamente me tomé un tiempo los fines de semana y hasta altas horas de la noche para planificar el contenido de los artículos sobre la serie Go. Creo que se puede dividir en tres etapas. stage es la sintaxis completa de Go. La segunda etapa es el contenido avanzado de Go que implica alta concurrencia distribuida. La tercera etapa es la parte de desarrollo back-end, marco web y operación de base de datos.

En artículos anteriores, también brindamos una introducción general a Go, incluidos algunos proyectos de código abierto y materiales de aprendizaje. Para obtener más detalles, consulte la lectura recomendada al final del artículo.

Hay casi 60 artículos en la primera etapa y el contenido general es el siguiente:

【Ir a la primera etapa】

"Funciones avanzadas, tendencias de desarrollo y proyectos de código abierto más populares recomendados en lenguaje Go"
"Explicación detallada de las nuevas funciones y la versión estable de Go 1.21"
"Explicación detallada del entorno de desarrollo multiterminal de Go y la construcción del compilador (imágenes y texto)"
"Vaya a codificar, primero los estándares"
"Introducción detallada al desarrollo de paquetes de código Go y paquetes personalizados"
"Tutorial resumido de operaciones de comando Go"
"Resumen de los métodos de salida de impresión en Go Language"
"Explorando las variables del lenguaje Go: almacenamiento flexible de datos"
"Descifrado de constantes del lenguaje Go: valores constantes"
"Comprensión profunda de los tipos de datos en el lenguaje Go"
"El secreto de las operaciones con cadenas en el lenguaje Go: procesar texto de manera eficiente"
"Análisis completo y excavación del control de procesos de Go (si, para, cambiar, ir a)"
"Técnicas de cruce de cadenas en Go: manipule texto fácilmente"
"Ir a la conversión de tipo gconv de idioma: conversión perfecta de datos"
"Uso de strconv para convertir los tipos int, float y string de Go entre sí: conversión flexible de tipos de datos"
"Descifrado del operador de Go: exploración de los secretos de la informática"
"Análisis de expresiones en Go: comprensión del núcleo del código"
"Técnica de corte de Go: operación flexible de colecciones ordenadas"
"Comprensión profunda y análisis en profundidad de las porciones del lenguaje Go (Slice): exploración del mecanismo subyacente"
"Consejos de Go's Slice: mejorar la eficiencia del código"
"Se revela el recorrido del rango de Go: dominar las habilidades de iteración y procesar las recopilaciones de datos de manera eficiente"
"Análisis de runas de Go: comprensión profunda del procesamiento de personajes"
"El secreto de la operación (colección) de mapas en lenguaje Go: dominar las habilidades cartográficas eficientes"
" Análisis de palabras clave de Go Language: comprensión de los elementos clave del código "
"Habilidades de mapeo lingüístico de Go: operación flexible de recopilaciones de datos"
"Ir a la asignación de idiomas y análisis (profundo) de copia: análisis en profundidad del procesamiento de datos"
"Análisis de matrices en lenguaje Go: procesamiento eficiente de datos ordenados"
"El uso inicial de matrices por parte de Go y cómo utilizarlas como parámetros de función"
"Comparación de las diferencias y características de la matriz, división y mapa de estructuras de datos integradas de Go"
"El arte del manejo de errores en Go: un estudio en profundidad del mecanismo de manejo de errores del lenguaje Go"
"Una breve discusión sobre el controvertido error de Golang: discusión de sus ventajas, desventajas y escenarios de aplicación"
"El maravilloso mundo de los punteros Go: análisis del uso de punteros en el lenguaje Go"
"El encanto de los métodos Go: dominar las habilidades de utilizar métodos en el lenguaje Go"
"Explorando la programación modular de Go: el diseño y uso de módulos en el lenguaje Go"
"El maravilloso viaje de las funciones de Go: comprensión profunda de las características funcionales del lenguaje Go"
"La diferencia entre las funciones y métodos de Go: revelando sus puntos en común y diferencias"
"El encanto de las funciones recursivas de Go: exploración del uso mágico de la recursividad en el lenguaje Go"
"El secreto de las eficientes funciones integradas de Go: las funciones integradas del lenguaje Go comúnmente utilizadas en el desarrollo"
"Exploración de la programación funcional de Go: ventajas, desventajas y explicación práctica de la aplicación del módulo"
"El encanto de las funciones de orden superior de Go: dominar la programación funcional en el lenguaje Go"
"Introducción detallada a la función y el uso de las funciones de orden superior de Go"
"El maravilloso mundo de las interfaces Go: comprensión profunda de las funciones de la interfaz en el lenguaje Go"
"Análisis de caja negra de la recolección de basura de Go: exploración del mecanismo de recolección de basura en el lenguaje Go"
"Go Quickly Integrar el módulo de registro: Guía de integración del módulo de registro en Go Language Framework"
"Análisis de estructuras (estructuras) de Go: domine las habilidades de uso de estructuras en el lenguaje Go"
"Se revelan las técnicas de prueba de rendimiento de Go: optimización del rendimiento de los programas de idiomas de Go"
"Go depuración y pruebas unitarias: habilidades de depuración y prueba en el desarrollo del lenguaje Go"
"Análisis integral de las operaciones de Go Time: domine las habilidades de procesamiento del tiempo"
"La implementación subyacente de los cierres de funciones de Go: una discusión en profundidad sobre los principios de los cierres en el lenguaje Go"
"El secreto de la seguridad de la concurrencia de Go: comprensión profunda del principio de implementación de sync.Map, la seguridad de la concurrencia en el lenguaje Go"
"El maravilloso mundo del contexto: conceptos básicos de la programación concurrente de Go: qué es el contexto y exploración de la aplicación y práctica del contexto en el lenguaje Go"
"Ir al mod de herramienta de administrador de paquetes"
"Comparación de herramientas de gestión de paquetes en lenguaje Go: Módulos Go y dep"
"Ir al departamento de herramientas de gestión de dependencias"
"Análisis del mecanismo de gestión de memoria y recolección de basura de Go"
"Cómo utilizar el paquete de registro en Go"
"Comunicación entre Go Ejecutores"
"Go Coroutines: Computación paralela"

imagen

El lenguaje Go es un lenguaje de programación de tipo estático y las variables se utilizan para almacenar y manipular datos en Go. En Go, las variables deben declararse antes de usarse y cada variable tiene un tipo específico.

Los datos durante la ejecución del programa se almacenan en la memoria. Si queremos operar ciertos datos en el código, necesitamos encontrar la variable en la memoria. Pero si operamos la variable directamente a través de la dirección de memoria en el código, la legibilidad de El código será muy pobre y propenso a errores, por lo que usamos variables para guardar la dirección de memoria de estos datos. En el futuro, podremos encontrar la dirección y los datos correspondientes en la memoria directamente a través de esta variable.

El lenguaje Go es un lenguaje de programación de tipo estático, por lo que cuando utilice variables, primero debe declarar su tipo. Las variables son uno de los componentes más básicos de un programa en el lenguaje Go. Se utilizan para almacenar datos en el programa.

imagen

En este artículo, presentaré en detalle los identificadores, variables y reglas de nomenclatura de variables en el lenguaje Go, incluida la declaración de variables, la asignación, la deducción de tipos y los tipos de variables comunes, y lo demostraré mediante ejemplos de código.

El próximo artículo resumirá e presentará el alcance, el ciclo de vida y la conversión de tipos de Go.

identificador

En los lenguajes de programación, los identificadores son palabras con significados especiales definidos por los programadores, como nombres de variables, nombres de constantes, nombres de funciones, etc. Los identificadores en el idioma Go constan de caracteres alfanuméricos y _ (guión bajo) y solo pueden comenzar con letras y _. Por poner algunos ejemplos: abc, _, _123, a123.

Los identificadores de lenguaje Go son nombres que se utilizan para nombrar entidades de programas como variables, constantes, funciones y tipos. En el lenguaje Go, los identificadores tienen algunas reglas y convenciones, aprenderemos más sobre ellas a continuación.

reglas de nomenclatura

En el lenguaje Go, la denominación de identificadores (variables) debe seguir algunas reglas, que son las siguientes:

1. Un identificador (nombre de variable) consta de una o más letras, números o guiones bajos.

2. El primer carácter del identificador (nombre de la variable) debe ser una letra o un guión bajo, no un número.

3. Los identificadores (nombres de variables) distinguen entre mayúsculas y minúsculas. Por ejemplo, nombre y Nombre son identificadores (variables) diferentes.

4. Las palabras clave del idioma Go no se pueden utilizar como identificadores (nombres de variables), como if, for, etc.

5. El identificador (nombre de la variable) debe ser descriptivo y poder expresar claramente el significado de la variable (ver el nombre para conocer el significado).

Para la introducción y el uso de palabras clave, puede consultar el artículo de la cuenta pública CTO Plus " Simplemente lea este artículo para resumir las funciones, características y uso de las palabras clave de Go en detalle ".

En términos generales, el estilo de nomenclatura del lenguaje Go adopta el método de nomenclatura en mayúsculas y minúsculas, es decir, la primera letra está en minúscula y la primera letra de las palabras siguientes está en mayúscula, como el nombre de usuario y la edad del estudiante.

convenio de denominación

Además de las reglas de nomenclatura, el lenguaje Go también tiene algunas convenciones de nomenclatura que se utilizan para mejorar la legibilidad y el mantenimiento del código.

1. Utilice la denominación de casos de camello: Go Language recomienda utilizar la denominación de casos de camello para nombrar los identificadores. La nomenclatura CamelCase se divide en dos formas: la nomenclatura CamelCase con la primera letra en minúscula (como myVariable) se usa para variables privadas y variables locales, y la nomenclatura camelCase con la primera letra en mayúscula (como MyVariable) se usa para variables públicas y variables globales.

2. Utilice nombres significativos: los nombres identificadores deben ser descriptivos y expresar claramente su propósito y significado. Evite el uso de letras sueltas o nombres sin significado.

3. Siga las convenciones de nomenclatura: el lenguaje Go tiene algunas convenciones de nomenclatura, como el uso de nombres de un solo carácter para las variables de iteración (como i, j, k), el uso de err como nombre de las variables de error, etc. Seguir estas convenciones puede mejorar la legibilidad de su código.

4. Evite el uso de abreviaturas: intente evitar el uso de abreviaturas para nombrar identificadores a menos que la abreviatura sea bien conocida. El uso de palabras completas mejora la legibilidad de su código.

Ejemplos de uso de identificadores

A continuación se muestran algunos ejemplos del uso de identificadores de idioma Go:

package main

import "fmt"

func myFunction(age int) int {
  var count int
  return count + age
}

func simple_variable() {
  var age int = 28
  var name string = "SteveRocket"

  fmt.Println("name:", name, "age:", age) // name: SteveRocket age: 28
  fmt.Println(myFunction(age))            // 28
}

func main() {
  simple_variable()
}

En el ejemplo anterior, hemos utilizado algunos identificadores como edad, nombre, myFunction y recuento. Estos identificadores siguen las reglas y convenciones de nomenclatura del lenguaje Go, son descriptivos y fáciles de entender y mantener.

A continuación, presentamos las reglas de declaración, asignación y denominación de variables.

variable

El lenguaje Go se escribe estáticamente. Las variables Go deben declararse primero y luego usarse. El tipo de variable debe quedar claro al declarar la variable. Una diferencia significativa entre el lenguaje Go y otros lenguajes es que los tipos del lenguaje Go están detrás de las variables. Por ejemplo, en C/C++ y Java, declarar un todo generalmente se escribe como int a = 1. En el lenguaje Go, debe escribirse así, como se muestra en el siguiente ejemplo de código:

func main() {
  var num int      // // 声明一个保存整型的变量num，如果没有赋值，默认为0
  fmt.Println(num) // 0

  var num2 int = 123 // 声明时赋值
  fmt.Println(num2)  // 123

  //因为 456 是 int 类型，所以赋值时，num3 自动被确定为 int 类型，所以类型名可以省略不写
  var num3 = 456    // 声明时赋值
  fmt.Println(num3) // 456

  var nick_name string  // 声明一个保存字符串类型的变量nick_name
  fmt.Println(nick_name) // 空字符串
  // 更简单的声明赋值
  name := "SteveRocket"
  fmt.Println(name) // SteveRocket

  var isNull bool  // 声明一个保存布尔类型的变量isNull，默认为false
  fmt.Println(isNull)
}

imagen

Tipos de variables comunes

La función de las variables (Variable) es almacenar datos. Diferentes tipos de variables pueden almacenar diferentes tipos de datos. El lenguaje Go proporciona múltiples tipos de datos para almacenar diferentes tipos de datos. Los tipos de variables comunes (tipos de datos) incluyen:

Tipos de enteros: int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, etc.
Tipos de números de coma flotante: float32, float64.
Tipo booleano: bool, el valor es verdadero o falso.
Tipo de cadena: cadena.
Tipo de carácter: byte, utilizado para representar caracteres ASCII.

Para obtener una introducción detallada a los tipos de datos, siga el artículo "Comprensión profunda de los tipos de datos del lenguaje Go" detrás de la cuenta pública CTO Plus.

Además de los tipos de datos básicos anteriores, el lenguaje Go también proporciona tipos compuestos, como matrices, sectores, mapas, estructuras, etc., para almacenar múltiples valores o valores de diferentes tipos.

Para obtener una introducción detallada a los tipos de datos compuestos, preste atención al artículo detrás de la cuenta pública CTO Plus:

"El secreto de la operación (colección) de mapas en lenguaje Go: dominar las habilidades cartográficas eficientes"
"Técnica de corte de Go: operación flexible de colecciones ordenadas"
"Comprensión profunda y análisis en profundidad de las porciones del lenguaje Go (Slice): exploración del mecanismo subyacente"
"Consejos de Go's Slice: mejorar la eficiencia del código"
"Habilidades de mapeo lingüístico de Go: operación flexible de recopilaciones de datos"
"Análisis de matrices en lenguaje Go: procesamiento eficiente de datos ordenados"
"El uso inicial de matrices por parte de Go y cómo utilizarlas como parámetros de función"
"Comparación de las diferencias y características de la matriz, división y mapa de estructuras de datos integradas de Go"

Cada variable en el lenguaje Go tiene su propio tipo y la variable debe declararse antes de poder usarse. A continuación, presentaremos la declaración y asignación de variables.

Declaración y asignación de variables

En el lenguaje Go, la palabra clave var se usa para declarar una variable. Cuando se usa la palabra clave var para declarar una variable, debe especificar el nombre y el tipo de la variable. La sintaxis es la siguiente:

tipo de nombre de variable var

Por ejemplo, declare una variable edad de tipo entero:

var edad int

Una vez declarada una variable, se puede asignar un valor inicial a la variable mediante una operación de asignación. La tarea utiliza el signo igual =, por ejemplo:

edad = 25

También puede asignar un valor al declarar una variable, lo que se denomina inicialización de la variable, por ejemplo:

var nombre cadena = "Juan"

Dentro de la función, se puede utilizar.

En el lenguaje Go, la declaración de variables se puede simplificar usando la palabra clave var o usando el símbolo más simple := para declarar e inicializar variables (declaración de variable corta). Cuando se utiliza el método de declaración corta (:=), se pueden omitir la palabra clave var y la declaración de tipo, por ejemplo:

edad := 25

nombre := "SteveRocket"

Cuando se utiliza la notación := para simplificar, el tipo de variable se deduce automáticamente del valor asignado (el valor de la derecha).

Las variables en el lenguaje Go deben declararse antes de poder usarse y las declaraciones repetidas no se admiten en el mismo ámbito. Y las variables del lenguaje Go deben usarse después de declararse.

En el lenguaje Go, la asignación de variables se puede realizar usando el símbolo =, por ejemplo:

edad := 18

edad = 20

Al asignar valores, tenga en cuenta que el tipo de variable debe ser coherente con el tipo del valor asignado; de lo contrario, se producirá un error de compilación.

Al mismo tiempo, el lenguaje Go también admite múltiples tareas, como:

a, b := 1, 2

a, b = b, a

En el código anterior, utilizamos asignación múltiple para intercambiar los valores de a y b.

Ejemplo de código completo:

package main

import "fmt"

// go语言中推荐使用驼峰命名
var studentName string

func variable() {
  Age := 30        // 变量区分大小写
  fmt.Println(Age) // 30

  age := 28
  fmt.Println(age) // 28
  age = 30         // 赋值
  fmt.Println(age) //30
  age = 25.0       // 重新赋值
  fmt.Println(age) // 25

  //在赋值时，需要注意变量的类型必须与所赋的值的类型一致，否则会导致编译错误。
  //age = 25.55  // cannot use 25.55 (untyped float constant) as int value in assignment (truncated)

  fmt.Println(age, Age) // 25 30
  age, Age = Age, age
  fmt.Println(age, Age) // 25 30
}

func main() {
  variable()
}

imagen

Inicialización de variables

Cuando el lenguaje Go declara una variable, inicializará automáticamente el área de memoria correspondiente a la variable. Cada variable se inicializará con el valor predeterminado de su tipo, por ejemplo:

El valor predeterminado de las variables enteras es 0.
El valor predeterminado de las variables de punto flotante es 0,0.
El valor predeterminado de una variable de cadena es la cadena vacía "".
El valor predeterminado de las variables booleanas es falso.
El valor predeterminado de sectores, funciones y variables de puntero es nulo.

func variable_default_value() {
  var name string
  var age int
  var isNull bool
  var salary float64
  // 切片
  var slice []int
  // 函数
  var fn func()
  // 指针变量
  var ptr *int
  fmt.Println(name, age, isNull, salary, slice, fn, ptr) // 输出结果："" 0 false 0 [] <nil> <nil>
}

Tenga en cuenta que estos valores predeterminados solo se aplican si a la variable no se le asigna explícitamente un valor cuando se declara. Si se asigna explícitamente un valor inicial al declarar una variable, la variable se inicializará a ese valor inicial. El formato estándar para la inicialización de variables por lotes es el siguiente:

var nombre de variable tipo = expresión

var nombre2, edad2, wechat = "SteveRocket", 28, "CTO Plus"

Declaración estándar

El formato de declaración de variables del lenguaje Go es:

var nombre de variable tipo de variable

La declaración de variable comienza con la palabra clave var, el tipo de variable se coloca después de la variable y no es necesario un punto y coma al final de la línea. Por ejemplo:

cadena de nombre var

var edad int

var es bool nulo

Declaración de lote

Sería engorroso escribir la palabra clave var cada vez que se declara una variable. El lenguaje Go también admite la declaración de variables por lotes:

//Declarar variables en lotes

era (

número1 entero

cadena de nombre

edad int32

es bool nulo

flotación salarial32

)

inferencia de tipos

A veces omitiremos el tipo de variable, en este caso el compilador deducirá el tipo de variable en función del valor en el lado derecho del signo igual para completar la inicialización.

nombre var = "SteveRocket"

tenía edad = 18

variable anónima

Cuando se utiliza una asignación múltiple, si desea ignorar un determinado valor, puede utilizar una variable anónima. Las variables anónimas se representan con un guión bajo _, por ejemplo:

func annoymous_variable(salary float64) (int, string, bool, float64) {
  return 28, "SteveRocket", true, salary
}
func main() {
  age, _, sex, _ := annoymous_variable(0)
  fmt.Println(age, sex) // 28 true
  //_, _, _, _ := annoymous_variable(0)  // no new variables on left side of :=
  _, _, _, salary := annoymous_variable(0)
  fmt.Println(salary)
}

Las variables anónimas no ocupan el espacio de nombres ni asignan memoria, por lo que no hay declaraciones repetidas entre variables anónimas. También se pueden usar como marcadores de posición en Python.

Código de muestra

Aquí hay un código de muestra que usa variables, de la siguiente manera:

package main

import "fmt"

// 全局变量studentName  go语言中推荐使用驼峰命名
var studentName string

// 批量声明全局变量
// 声明全局变量建议使用批量声明，方便追加
var (
  num1   int
  name   string
  age    int32
  isNull bool
  salary float32
)

// 声明变量
var myName string
var myAge int
var isSex bool

// 批量初始化变量(一次初始化多个变量)
var name2, age2, wechat = "SteveRocket", 28, "CTO Plus"

func variable() {
  Age := 30        // 变量区分大小写
  fmt.Println(Age) // 30

  age := 28
  fmt.Println(age) // 28
  age = 30         // 赋值
  fmt.Println(age) //30
  age = 25.0       // 重新赋值
  fmt.Println(age) // 25

  //在赋值时，需要注意变量的类型必须与所赋的值的类型一致，否则会导致编译错误。
  //age = 25.55  // cannot use 25.55 (untyped float constant) as int value in assignment (truncated)

  fmt.Println(age, Age) // 25 30
  age, Age = Age, age
  fmt.Println(age, Age) // 25 30
}

func variable02() {
  // 非全局变量（局部变量）声明了就必须使用，不使用就无法编译通过（全局变量声明或初始化了不使用也可以编译通过）
  // 不使用报错：blog declared and not used
  var blog = "https://mp.weixin.qq.com/s/0yqGBPbOI6QxHqK17WxU8Q"
  fmt.Println(blog)

  //同一个作用域，不能重复声明同名变量
  //blog := "" // no new variables on left side of :=
  blog = "" // 但可以重新赋值
  fmt.Println(blog)

}
func variable_default_value() {
  var name string
  var age int
  var isNull bool
  var salary float64
  // 切片
  var slice []int
  // 函数
  var fn func()
  // 指针变量
  var ptr *int
  fmt.Println(name, age, isNull, salary, slice, fn, ptr) // "" 0 false 0 [] <nil> <nil>
}

func annoymous_variable(salary float64) (int, string, bool, float64) {
  // 匿名变量 是一个特殊的变量： _
  // 匿名变量使用_指定，用来作为一个占位符，匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明
  return 28, "SteveRocket", true, salary
}

func main() {
  variable()
  variable02()
  variable_default_value()
  age, _, sex, _ := annoymous_variable(0)
  fmt.Println(age, sex) // 28 true
  //_, _, _, _ := annoymous_variable(0)  // no new variables on left side of :=
  _, _, _, salary := annoymous_variable(0)
  fmt.Println(salary)
}

En el ejemplo anterior, demostramos completamente la declaración de variables, el uso de variables anónimas, la inicialización de variables, la deducción de tipos de variables cortas, etc., así como la asignación de valores iniciales a estas variables mediante operaciones de asignación y el uso de fmt. .Println() La función imprime el valor de una variable en la salida estándar.

Para obtener más información sobre cómo utilizar la impresión en idioma Go, consulte este artículo en la cuenta pública CTO Plus: "Resumen de métodos de impresión en idioma Go"

imagen

Resumir

Después de la introducción del artículo anterior, a continuación se resumen algunas notas sobre el uso de variables:

Precauciones

Cada declaración fuera de una función debe comenzar con una palabra clave (var, const, func, etc.).
:= no se puede utilizar fuera de una función.
_ se usa principalmente para marcadores de posición y el valor de identificación se puede ignorar.
En el lenguaje Go, a las variables de diferentes tipos se les asignan valores predeterminados cuando se declaran. El valor predeterminado de las variables enteras es 0, el valor predeterminado de las variables de punto flotante es 0.0 y el valor predeterminado de las variables de cadena es la cadena vacía " ". El valor predeterminado de las variables booleanas es falso y el valor predeterminado de las variables de sector, función y puntero es nulo.
Si se asigna explícitamente un valor inicial al declarar una variable, la variable se inicializará a ese valor inicial y deberá usarse en el código; de lo contrario, se producirá un error de compilación.

En general, las variables en el lenguaje Go se utilizan para almacenar y manipular datos y deben declararse antes de su uso. La variable se declara utilizando la palabra clave var y se puede asignar un valor inicial a la variable mediante una operación de asignación. La denominación de las variables debe seguir ciertas reglas y debe ser descriptiva. El lenguaje Go proporciona múltiples tipos de datos para almacenar diferentes tipos de datos. Mediante el uso razonable de variables, los datos se pueden gestionar y manipular fácilmente.

Al mismo tiempo, los identificadores del lenguaje Go se utilizan para nombrar entidades del programa como variables, constantes, funciones y tipos. Los identificadores tienen algunas reglas y convenciones de nomenclatura, como el uso de nombres en casos de camellos, el uso de nombres significativos, el seguimiento de convenciones de nomenclatura, etc. Seguir estas reglas y convenciones puede mejorar la legibilidad y el mantenimiento de su código.

¡Espero que este artículo te ayude a comprender los identificadores (variables) del lenguaje Go!

Columna de microservicios y nativos de la nube
https://blog.csdn.net/zhouruifu2015/category_5704941

Para obtener más noticias interesantes, siga mi cuenta oficial y aprendamos y crezcamos juntos.

imagen