golang快速上手基础语法

发布于:2025-03-16 ⋅ 阅读:(11) ⋅ 点赞:(0)

变量

第一种,指定变量类型,声明后若不赋值,使用默认值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()
}

打印

参考

8小时转职Golang工程师(如果你想低成本学习Go语言)_哔哩哔哩_bilibili


网站公告

今日签到

点亮在社区的每一天
去签到