golang快速上手基础语法

news2025/3/18 3:43:55

变量

第一种，指定变量类型，声明后若不赋值，使用默认值0

package main

import "fmt"

func main() {
	var a int //第一种，指定变量类型，声明后若不赋值，使用默认值0。
	fmt.Printf(" a= %d\n", a)
}

打印

第二种，根据值自行判定变量类型

package main

import "fmt"

func main() {
	var a = 33 //第二种，根据值自行判定变量类型
	fmt.Printf("a= %d\n", a)
}

打印

第三种，直接定义变量需首次定义之前不可以为已用过的变量

package main

import "fmt"

func main() {
c := 3 //第三种，直接定义 变量需首次定义之前不可以为已用过的变量 
	fmt.Printf(" a= %d\n", c)
}

打印

const

常量

package main

import "fmt"


func main() {
	const LENGTH int = 3
	const WIDTH int = 10
	var area int
	const a, b, c = 1, false, "str" //多重赋值

	area = LENGTH * WIDTH
	fmt.Printf("面积为 : %d\n", area)
	println(a, b, c)

}

这里和Java的常量定义是相同的

打印

多重定义枚举

const (
    Unknown = 0
    Female = 1
    Male = 2
)

iota

它简化了常量用于增长数字的定义，给以上相同的值以准确的分类。

package main

import "fmt"

const (
	One   int = 1 + iota // 1+0
	Two                  // 1+1
	Three                // 1+2
	Four                 // 1+3
	Five                 // 1+4
	Six                  // 1+5

)

func main() {

	fmt.Println(One)
	fmt.Println(Two)
	fmt.Println(Three)
	fmt.Println(Four)
	fmt.Println(Five)
	fmt.Println(Six)

}

打印

用于常量定义中，常量组中仅仅有一个标示符在一行的时候，它将使用增长的iota取得前面的表达式并且再运用它

if

if语句和Java里的if相同

for循环

package main

import "fmt"

func main() {
	//常规for循环类似于Java 对比少了for(i := 0; i < 10; i++)少了括号
	for i := 0; i < 10; i++ {
		fmt.Println(i)
	}
}

打印

类似于Java里while的for循环

如下for循环实现当value=10的时候退出for循环

package main

import "fmt"

func main() {
	value := 0
	for {
		value += 1
		fmt.Println(value)
		if value == 10 {
			break
		}
	}
}

打印

import和init

import导包和Java的import 差不多

目录结构

fun1

package fun1 //这里的包名最好和目录名保持相同

import (
	"fmt"
)

func init() {
	fmt.Println("fun1")
}
func TestFun1() {
	fmt.Println("testFun1")
}

fun2

package fun2 //这里的包名最好和目录名保持相同

import "fmt"

func init() {
	fmt.Println("fun2")
}
func TestFun2() {
	fmt.Println("testFun2")
}

主函数

package main

import (
	"fmt"

	"githup.com/kanyu/moudles_test/basic/fun1"
	"githup.com/kanyu/moudles_test/basic/fun2"
)

func main() {
	fun1.TestFun1()
	fun2.TestFun2()
	fmt.Println("main")
}

打印

详细执行流程

1，主函数导入依赖

2，依赖函数再次判断有无依赖，有依赖再重复导入无依赖执行函数的init函数

3，执行其它的函数

指针

go语言中和C语言相同用*来表达变量的地址用&来取指针指向的数值

函数值传递与指针传递

值传递，即在函数传参的过程中，原来的参数不会被调用函数的行为所改变值

在传递参数的时候会把值复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。 go默认值传递

package main

import "fmt"

func swap(x, y string) (string, string) {
	return y, x
}

func main() {
	stra := "字符串a"
	strb := "字符串b"
	fmt.Println("交换之前打印")
	fmt.Println(stra, strb)
	a, b := swap(stra, strb)
	fmt.Println("交换之后打印")
	fmt.Println(a, b)
}

打印

指针传递

//引用传递
package main


import "fmt"


func main() {
   /* 定义局部变量 */
   var a int = 100
   var b int= 200

   fmt.Printf("交换前 a 的值为 : %d\n", a )
   fmt.Printf("交换前 a 的地址值为 : %d\n", &a )
   fmt.Printf("交换前 b 的值为 : %d\n", b )
   fmt.Printf("交换前 b 的地址值为 : %d\n", &b )


   /* 调用 swap() 函数
   * &a 指向 a 指针，a 变量的地址
   * &b 指向 b 指针，b 变量的地址
   */
   swap(&a, &b)//调用时候传入地址值


   fmt.Printf("交换后，a 的值 : %d\n", a )
   fmt.Printf("交换后 a 的地址值为 : %d\n", &a )
   fmt.Printf("交换后，b 的值 : %d\n", b )
   fmt.Printf("交换后 b 的地址值为 : %d\n", &b )

}


func swap(x *int, y *int) {//指针参数变量 这里的交换指的把对应指针指向的值给交换了 所以a和b的地址未变化
   var temp int
   temp = *x    /* 保存 x 地址上的值 */
   *x = *y      /* 将 y 值赋给 x */
   *y = temp    /* 将 temp 值赋给 y */
}

打印

defer

延迟函数，defer在rerurn之后再执行延迟函数用于如打开/关闭文件、获取/释放锁、连接/断开连接等，确保资源被适当地释放，即使在发生错误或提前返回的情况下也能保证执行

package main

import "fmt"

func deferFunc() int {
    fmt.Println("defer func called")
    return 0
}

func returnFunc() int {
    fmt.Println("return func called")
    return 0
}

func returnAndDefer() int {

    defer deferFunc()

    return returnFunc()
}

func main() {
    returnAndDefer()
}

打印