布尔类型 - 由两个预定义常量组成:true、
false,默认值为false
package main import "fmt" func main() { var ( a bool //默认值为false b bool = true ) fmt.Println(a,b) }
整型:
浮点型:
其他数字类型:
表示方式:
区别:使用反引号定义的字符串保留原始字符(如换行\n,\t等)会对特殊字符进行转义,打印时候原样输出,而双引号则不转义。
字符串底层是一个byte的数组。
字符串本身是不可变的,因此要改变字符串中的字符,需要将字符串转变为数组,修改数组后再将数组转换为字符串:
package main import "fmt" func main() { str := "hello world" s := []byte(str) s[0] = 'W' str = string(s) fmt.Println(str) }//结果 Wello world
双引号、反引号区别:
package main import "fmt" func main() { var ( a string =`wd\n` b string = "age \n" ) fmt.Println(a,b) } //结果 wd\n age
不同的数据类型之间是不允许进行赋值或运算操作,必须经过类型转化才能进行运算或者赋值
转换方法:数据类型()
package main import "fmt" func main() { var a int32 = 1 var b int64 = 64 c:= int64(a)+ b //不转换编译报错 fmt.Println(c) }
位运算符对整数在内存中的二进制位进行操作。
//假设A = 60, B = 13; 二进制格式表示 A = 0011 1100 B = 0000 1101 ----------------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001
&a
将给出变量a
的实际地址)*a
是指向变量a
的指针)if condition1 { } else if condition2 { //else 一定要和大括号在一行 } else if condition3 { } else { }
一般for循环
for i := 0; i < 100; i++ { //语句使用分号隔开 }
死循环(类似python中的while)
for true { } //或者 for { }
使用range遍历数组、slice、map、chan等
package main import "fmt" func main() { str := "hell world" for k :=range str { //字符串遍历 fmt.Printf("index=%d val=%c len=%d\n",k,str[k],len(str)) //k代表索引、v代表值 } }//结果 index=0 val=h len=10 ....
package main import "fmt" func main() { str := "hell world" for index,val :=range str { //字符串遍历 fmt.Printf("index=%d val=%c len=%d\n",index,val,len(str)) //k代表索引、v代表值 } }//结果 index=0 val=h len=10 ....
switch条件控制,当条件匹配当前case时候,执行当前case,不会进行往下执行,若都没有匹配到,则执行default,当然也可以使用fallthrought关键字强制执行下面语句。
switch var { case 条件一: case 条件二: case 条件三: default: }
package main import "fmt" func main() { var a = 0 switch a { case 0: fmt.Println("this is 0") case 1: fmt.Println("this is 1") case 2: fmt.Println("this is 2") default: fmt.Print("this is default") } }//结果 this is 0
package main import "fmt" func main() { var a = 0 switch { //这里没有变量 case a > 0 && a <3: //a in 0-3 fmt.Println("a in 0-3") case a < -1 || a > 3: fmt.Println("a <0 or a > 3") case a == 0: fmt.Println("a equal 0") default: fmt.Print("this is default") } //结果 a equal 0 }
package main import "fmt" func main() { var a = 0 switch { case a > 0 && a <3: //a in 0-3 fmt.Println("a in 0-3") case a < -1 || a > 3: fmt.Println("a <0 or a > 3") case a == 0: fmt.Println("a equal 0") fallthrough //使用fallthrought关键字当满足该条件时候,继续执行下面语句 default: fmt.Printf("this is default\n") } //结果 a equal 0 //this is default }
label作为一个标记,语法是字符串+冒号定义,在循环中使用lable可调至label的定义的位置
package main import ( "fmt" "time" ) func main() { LABLE: //定义名称为LABLE //fmt.Println("回到label") for i := 0; i < 10; i++ { fmt.Println("-->",i) for true { i++ if i == 6 { time.Sleep(time.Second * 5) break LABLE //跳出循环到LABLE定义的地方 } fmt.Println(i) } } }
goto作用在于跳转到label标签定义的地方继续执行。上述代码修改为goto,将是死循环
package main import ( "fmt" "time" ) func main() { LABLE: //定义名称为LABLE //fmt.Println("回到label") for i := 0; i < 10; i++ { fmt.Println("-->",i) for true { i++ if i == 6 { time.Sleep(time.Second * 5) goto LABLE //跳出循环到LABLE定义的地方 } fmt.Println(i) } } }//结果:每5秒打印1,2,3,4,5
函数是go语言编程的核心。特点:
函数定义语法:
func 函数名( 参数 ) [(返回值列表)] { 函数体 }// [] 代表非必需
package main import ( "fmt" ) func add(a int,b int) int { return a + b } func main() { c := add d := c(1,2) // 加括号代表调用函数 fmt.Println(d) }//结果:3
package main import ( "fmt" ) func add(a int,b int) (int,int) { return a + b,a } func main() { c := add d , _ := c(1,2) //使用_忽略第二个返回值 fmt.Println(d) }//结果:3
值传递:一般基本的数据类型都是值传递,如数字、字符串。
引用传递:复杂的数据类型,如map、chan、interface,是引用传递。
注意:无论是值传递还是引用传递,传递给函数的都是变量的副本,不过值传递是值的拷贝,引用传递拷贝的是地址,一般来说地址拷贝更为高效。而值拷贝取决于拷贝对象大小,对象越大,则性能相对低。
go 函数的返回值或者结果参数可以指定一个名字(名字不是强制的),并且像原始的变量那样使用,就像输入参数那样。如果对其命名,在函数开始时,它们会用其类型的零值初始化;如果函数在不加参数的情况下执行了 return
语句,结果参数的当前值会作为返回值返回。
package main import "fmt" //斐波那契数列实现 func Factorial(x int) (result int) { //给函数返回值命名为result if x <= 1 { result = 1 } else { result =Factorial(x - 2) + Factorial(x - 1) } return } func main() { b := Factorial(4) fmt.Println(b) }//结果:5
匿名函数(对比javascript)即没有函数名的函数,只能放在函数中,可以实现函数嵌套定义的功能。
package main import "fmt" func main() { c := func(a int,b int ) int { return a + b }(3,4) fmt.Println(c) }//结果:7
go语言中,也可以像python一样传递可变参数(意思是传递时候才确定有几个参数,定义时候不知道参数个数),可以认为参数是数组形式:
func funcname(arg...type) { }
package main import "fmt" func add(a int, arg...int) int { var sum = 0 for i := 0; i < len(arg); i++ { sum += arg[i] //取参数的值 } return sum } func main() { c := add(1) //传递一个参数 d := add(2,3,4) //传递两个参数 fmt.Println(c,d) }//结果:0,7
当函数中存在defer关键字时候,一旦函数返回则执行defer语句,因此,defer可以做一些资源清理的事情。
特性:
package main import "fmt" func main() { i := 0 defer fmt.Println(i) // 放入栈 i++ defer fmt.Println(i) //在放入栈,先执行 fmt.Println("wd") return }//结果:wd ,1,0
概念:
flag.Xxx
等这种形式定义了的参数。输入参数时需要 -flag
形式。-flag
形式的参数。-
、--
和 --flag
都属于 non-flag 参数。来自命令行的参数在程序中通过os.Args(对比python的sys.agrv)
获取,导入包 os 即可。其中 os.Args[0]
为执行的程序名,os.Args[1]
~ os.Args[n-1]
是具体的参数。
//示例 test.exe 1 2 //test.exe 为os.Args[0] ,1是 os.Args[1],2是os.Args[2]
初始化顺序规则: 引入的包 -->包中的常量、变量、init-->当前包的常量、变量、init -->main函数
图示:
注意事项:
如对本文有疑问, 点击进行留言回复!!
网友评论