Consejo: Una vez escrito el artículo, la tabla de contenido se puede generar automáticamente. Para saber cómo generarla, consulte el documento de ayuda a la derecha.
Directorio de artículos
1. Función
La declaración de función comienza con la palabra clave func. La función es un bloque de código que puede ser entrada y salida. El formato es:
func name(parameter) (result-list){
//body
}
1. Definir la función
1.1 Función de valor de retorno único
// 单返回值函数,返回值定义可以不需要括号
func add(a, b int) int{
return a + b
}
1.2 Función de retorno múltiple
func ppl(a int, b int) (int, bool) {
c := a + b
isBool := false
if a*2 > c {
isBool = true
}
return c, isBool
}
1.3 Especifique la función de nombre de variable de valor de retorno, que se puede devolver directamente
func ppl1(a int, b int) (number int, isBool bool) {
number = a + b
if a*2 > number {
isBool = true
}
return
}
1.4 Función de parámetro variable
// 参数可变函数
func ppl3(nums ...int)int{
fmt.Println("len of nums is : ", len(nums))
sum := 0
for _, v := range nums{
sum += v
}
return sum
}
Código completo:
package main
import "fmt"
func main() {
a := 2
b := 2
fmt.Println(ppl(a, b))
fmt.Println(ppl1(a, b))
fmt.Println(ppl2(a, b))
fmt.Println(ppl3(a, b))
}
// 单返回值函数,返回值定义可以不需要括号
func ppl2(a int, b int) bool {
number := a + b
if a*2 > number {
return true
}
return false
}
// 可多个形参，多个返回值需要定义使用括号，逗号分隔
func ppl(a int, b int) (int, bool) {
c := a + b
isBool := false
if a*2 > c {
isBool = true
}
return c, isBool
}
// 当返回值有定义变量名称时，可以直接return
func ppl1(a int, b int) (number int, isBool bool) {
number = a + b
if a*2 > number {
isBool = true
}
return
}
// 参数可变函数
func ppl3(nums ...int)int{
fmt.Println("len of nums is : ", len(nums))
sum := 0
for _, v := range nums{
sum += v
}
return sum
}
2. Función anónima
Función anónima, llamada directamente sin nombre de función
// 匿名函数
func() {
fmt.Println("匿名函数...")
}()
3.función de inicio
- La función init no tiene parámetros ni valor de retorno.
- La función init no permite a los usuarios llamarla explícitamente
- La función init se usa generalmente para la inicialización.
package main
import (
"fmt"
_ "ppl-golang/1-base/01/9-import/sub" // 仅会调用包的init函数
)
/*
1.init函数没有参数和返回值
2.init函数不允许用户显式调用
3.init函数一般用作初始化
*/
func init() {
fmt.Println("this is my init 111111")
}
func init() {
fmt.Println("this is my init 222222")
}
func main() {
//init() 不能这样调用
}
2. Importar paquete de importación
1. Importe el paquete usando la palabra clave: importar
Pero ¿qué es un bolso? Puede entenderse como un módulo funcional.
- Público: las funciones del paquete público que están abiertas al mundo exterior deben comenzar con una letra mayúscula; de lo contrario, no se pueden llamar;
- Privado: No abierto a llamadas externas (privado es solo para aquellas bajo el mismo nombre de paquete). Las funciones del paquete comienzan con una letra minúscula;
// 包
package sub
// 公有
func Sub(a, b int) int {
return a - b
}
// 私有
func low() {
}
2. Paquete de referencia
package main
import (
"fmt"
// . 表示包名下所有函数不推荐直接用,容易出现重复函数名冲突
. "ppl-golang/1-base/9-import/add"
// 导入包可在前面空格+重命名,如下:ppl
ppl "ppl-golang/1-base/9-import/sub"
)
func main() {
// 调用：包名.函数名
sum := Add(10, 5)
sub1 := ppl.Sub(sum, 2)
fmt.Println(sub1)
}
3. Parámetros de la línea de comando
1.os.Args obtiene parámetros de línea de comando
os.Args, el primer parámetro es el programa que se está ejecutando actualmente, como Windows es xx.exe,
por lo que el segundo parámetro es un parámetro personalizado, el segmento es 1, el siguiente código cmds [1]
package main
import (
"fmt"
"os"
)
func main() {
// 命令行参数
cmds := os.Args
fmt.Println("cmds个数=", len(cmds), "(需要>=2)")
if len(cmds) < 2 {
return
}
for k, cmd := range cmds {
fmt.Println("key：", k, " cmd：", cmd)
}
}
2. Parámetros de la línea de comando de prueba preliminar
El interruptor determina que los valores son iguales y se agrega break de forma predeterminada. Si desea continuar penetrando, agregue la palabra clave: fallthrough
package main
import (
"fmt"
"os"
)
func main() {
// 命令行参数
cmds := os.Args
fmt.Println("cmds个数=", len(cmds), "(需要>=2)")
if len(cmds) < 2 {
return
}
switch cmds[1] {
case "hello":
fmt.Println("cmds[1] is hello")
case "word":
// 如果值相等，默认会加了 break，如果想继续穿透加上关键字：fallthrough
fmt.Println("cmds[1] is word")
fallthrough
default:
fmt.Println("cmds[1] is default")
}
}
4. Etiqueta
Usa menos, solo entiéndelo
package main
import "fmt"
func main() {
// 标签名称是自定义
LABEL1:
for i := 0; i < 2; i++ {
for j := 0; j < 5; j++ {
if j == 3 {
/*
goto LABEL1：i每次进入此标签被重置值
continue LABEL1：i每次进入此标签会记录上次的值(状态)
break LABEL1：直接结束指定位置的循环
*/
//goto LABEL1
//continue LABEL1
break LABEL1
}
fmt.Println(i, j)
}
}
fmt.Println("over!")
}
Cinco, enumeración constante de iota.
enumeración constante de iota
package main
import "fmt"
const (
/*
1.iota是常量组计数器
2.iota从0计数,每行递增1,同一行多个只算一次
3.每隔常量组是独立的,如果再定义一个const会重iota新计数,不想被重新计数+1
*/
name = iota
age = iota
work = iota
single // 未赋值,默认与上一个常量值相同
work1, work2 = iota, iota // iota计数同一行多个只算一次
)
func main() {
fmt.Println(name)
fmt.Println(age)
fmt.Println(work)
fmt.Println(single)
fmt.Println(work1)
fmt.Println(work2)
}
Seis, diferir (retrasar)
La palabra clave defer se usa para modificar declaraciones y funciones para garantizar que esta declaración se ejecute cuando salga la pila actual. Es
justo lo opuesto a la función init. La función init se ejecuta antes y defer se ejecuta después, similar a la lectura de archivos de Python. con abierto().
package main
import (
"fmt"
"os"
)
func main() {
/*
defer 延迟用于修饰语句、函数，确保这条语句在当前栈退出时执行
一般用于清理工作，解锁、关闭文件操作,类似python读取文件 with open()
*/
fineName := "1-base/02/4-defer延迟.go"
redFine(fineName)
}
func redFine(fileName string) string {
f, err := os.Open(fileName)
defer f.Close() // 在当前栈退出时执行关闭文件
if err != nil {
fmt.Println("打开文件失败：", fileName)
}
buf := make([]byte, 1024)
f.Read(buf)
fmt.Println(string(buf))
// 多个defer,执行顺序为倒序
defer fmt.Println(1111111)
defer fmt.Println(2222222)
// 匿名函数
defer func() {
f.Close()
fmt.Println("匿名函数关闭文件...")
}()
defer fmt.Println(33333333)
return string(buf)
}
Fin