Go语言入门心法(一)

一: go语言中变量认知 

---

go语言中变量的定义:  （要想飞|先会走）||（翻身仗|抹遗憾 ）   |（二八定律）
                    (先量变)|(再质变)||（冰冻三尺非一日寒）|(扶贫之旅|继续裸奔)

         (1)go语言中变量认知升维
         (2)go语言中变量与强类型语言java类似,变量使用必须先声明后使用
         (3)go语言中变量标准的声明使用var关键字进行声明: var 变量名 变量类型;变量声明后必须使用,否则编译器会报错
         (4)go语言中变量声明时可以赋予初始值,如果不赋初始值,则默认为各变量的类型的默认值 var name string = "外卖小哥哥"
         (5)go语言中变量如果声明的同时赋予初始值,则可以省略变量的类型: var age = 30
          (6)go语言中变量什么并附初始值时可以使用简易默认,也是go语言中变量定义的常用方式: name := "boss";此时可以省略var关键字与数据类型
          (7)go语言可以对多个变量同时进行块声明:
               var (
                   personName := "张三"
                   personAge  := 30
                   sex := 1
                   marry := false
               )

---

附录实例一:

---

package main

import (
	"fmt"
	"reflect"
)

/*
go语言中变量的定义域:

			(1)go语言中变量认知升维
			(2)go语言中变量与强类型语言java类似,变量使用必须先声明后使用
			(3)go语言中变量标准的声明使用var关键字进行声明: var 变量名 变量类型;变量声明后必须使用,否则编译器会报错
			(4)go语言中变量声明时可以赋予初始值,如果不赋初始值,则默认为各变量的类型的默认值 var name string = "外卖小哥哥"
			(5)go语言中变量如果声明的同时赋予初始值,则可以省略变量的类型: var age = 30
		    (6)go语言中变量什么并附初始值时可以使用简易默认,也是go语言中变量定义的常用方式: name := "boss";此时可以省略var关键字与数据类型
		    (7)go语言可以对多个变量同时进行块声明:
	            var (
	                personName := "张三"
	                personAge  := 30
	                sex := 1
	                marry := false
	            )
*/
func main() {
	a := 1
	b := "test"
	c := true

	fmt.Println("a变量类型： ", reflect.TypeOf(a))
	fmt.Println("b变量类型： ", reflect.TypeOf(b))
	fmt.Println("c变量类型： ", reflect.TypeOf(c))

	fmt.Println("=========================变量类型转换===============================")
	var d int16 = 97
	fmt.Println("变量a的值为: ", d, " ,变量的类型为: ", reflect.TypeOf(d))
	e := int32(d)
	fmt.Println("变量e的值为: ", e, " ,变量的类型为: ", reflect.TypeOf(e))
	fmt.Println("变量e的类型为字符串: ", string(e))
	fmt.Println("变量e的类型为字符串string : ", reflect.TypeOf(string(e)))

	desc := `再进行变量类型转换中
             需要特别注意转换后的数值是否发生变化
             `
	fmt.Println("注意事项： ", desc)
	var as int32 = 1234567891
	fmt.Println("变量as的值：", as, " ,变量类型: ", reflect.TypeOf(as))
	fmt.Println("转换as的类型为int16,变量as的值为: ", int16(as), " ,变量as类型: ", reflect.TypeOf(int16(as)))
}

---

实例运行效果：

---

GOROOT=D:\program_file_worker\go1.20 #gosetup
GOPATH=D:\program_file_worker\go1.20\bin;C:\Users\Administrator\go #gosetup
D:\program_file_worker\go1.20\bin\go.exe build -o C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_VariableParameterDifinition_go.exe D:\program_file\go_workspace\org.jd.data\VariableParameterDifinition.go #gosetup
C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_VariableParameterDifinition_go.exe
a变量类型：  int
b变量类型：  string
c变量类型：  bool
=========================变量类型转换===============================
变量a的值为:  97  ,变量的类型为:  int16
变量e的值为:  97  ,变量的类型为:  int32
变量e的类型为字符串:  a
变量e的类型为字符串string :  string
注意事项：  再进行变量类型转换中
             需要特别注意转换后的数值是否发生变化

变量as的值： 1234567891  ,变量类型:  int32
转换as的类型为int16,变量as的值为:  723  ,变量as类型:  int16

Process finished with the exit code 0
 

---

附录实例二:

---

package main

import (
	"fmt"
	"reflect"
)

/*
变量交换值,使用变量简短什么方式来声明及赋值
*/
func main() {
	var name string
	var age int
	var salary float32
	fmt.Println("变量a与b交换值:")
	a := 1
	b := 3
	a, b = b, a
	fmt.Println("a:", a)
	fmt.Println("b:", b)

	println("name变量的默认初始值: ", name)
	println("age变量的初始值: ", age)
	println("salary的默认初始值: ", salary)

	/*
	  go语言中变量的定义与java中定义的变量类型,都需要先声明后使用的
	  (1)申明变量的语法:
	  var 变量名  类型
	  这样声明的变量,没有赋予初始值时,go会自动赋予该类型变量的默认初始值字符串默认初始值为空串
	  (2)定义变量的同时赋予初始值: 标准的声明变量赋值
	  var typeNum int = 0
	  (3)同时声明多个变量时,没有赋予初始值,则变量类型必须保留
	   var (
	      a string
	      b int
	      c string
	      d float
	   )
	   (4) 编译器推导类型格式
	   var num  = 20
	*/
	var college string
	println("变量college= ", college)
	var typeNum int64
	println("变量type= ", typeNum)
	/*
	  (1)go语言可以批量声明变量,声明变量的同时可以赋予初始值
	  (2)go语言中变量声明后必须使用,但是常量声明后,不一定使用
	*/
	var (
		// 赋值的变量,可以省略类型,go编译器会自动进行类型推断;为简介,通常附初始值的变量可以省略变量类型
		tName string = "张三"
		tAge  int    = 28
		tSex  bool
	)

	var numCount = 20
	println("numCount type is ", reflect.TypeOf(numCount))
	println("numCount = ", numCount)

	str := "这是第一个go语言程序"
	println("str=", str)
	strNum := `
             通过反引号可以定义字符串
             多行字符串定义
          `
	println("多行字符串定义: strNum = ", strNum)
	desc := `
            (1) 在go语言中有两种类型
             uint8：代表了 ASCII码的一个字符串
             rune类型: 代表了UTF-8格式的一个字符(如中文,日文或者其他复合字符,本质就是int32类型)
          `
	println(desc)

	english := 'a'
	chinese := '我'

	fmt.Println(english)
	fmt.Println(chinese)

	println("名称: ", tName, " ,年龄: ", tAge, " ,性别(true-男;false-女): ", tSex)

}

---

运行效果：

---

OOT=D:\program_file_worker\go1.20 #gosetup
GOPATH=D:\program_file_worker\go1.20\bin;C:\Users\Administrator\go #gosetup
D:\program_file_worker\go1.20\bin\go.exe build -o C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ChangeParamaValue_go.exe D:\program_file\go_workspace\org.jd.data\ChangeParamaValue.go #gosetup
C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ChangeParamaValue_go.exe
变量a与b交换值:
a: 3
b: 1
name变量的默认初始值:
age变量的初始值:  0
salary的默认初始值:  +0.000000e+000
变量college=
变量type=  0
numCount type is  (0xed14a0,0xe9c920)
numCount =  20
str= 这是第一个go语言程序
多行字符串定义: strNum =
             通过反引号可以定义字符串
             多行字符串定义

            (1) 在go语言中有两种类型
             uint8：代表了 ASCII码的一个字符串
             rune类型: 代表了UTF-8格式的一个字符(如中文,日文或者其他复合字符,本
质就是int32类型)

97
25105
名称:  张三  ,年龄:  28  ,性别(true-男;false-女):  false

Process finished with the exit code 0
 

---

二: go语言常量认知

---

go语言中的常量的定义:
    (1)使用关键字const定义常量;
    (2)常量申明后可以不使用;不想变量那样,定义后必须使用,否则编译检查报错
    (3)常量的值在初始化后,不能修改
    (4)常量枚举: 针对一个有穷序列集合而言,一个集的枚举就是列出有穷序列集的所有成员

---

package main

import (
	"fmt"
)

/*
   go语言中的常量的定义:
       (1)使用关键字const定义常量;
       (2)常量申明后可以不使用;不想变量那样,定义后必须使用,否则编译检查报错
       (3)常量的值在初始化后,不能修改
       (4)常量枚举: 针对一个有穷序列集合而言,一个集的枚举就是列出有穷序列集的所有成员
*/

func main() {
	fmt.Println("---------------循序渐进代码实操演示学习go编程语言--------------")
	fmt.Println("-------------------------go语言中定义常量------------------------------")
	const PersonName string = "GO语言实战系列"
	println("第一个常量: ", PersonName)
	const aa = 20
	const bb int16 = 50
	println("常量定义时,可以使用编译器进行类型推断,从而可以省略变量的类型")
	println("常量[a] = ", aa)
	println("常量[b]= ", bb)

	println("常量与变量都可以批量定义:")
	const (
		personName    string = "小张"
		personAge     int16  = 30
		personAddress        = "北京市海淀区马连洼街道120路105号"
	)

	println("使用批量定义的常量:")
	println("名称: ", personName, " ,年龄: ", personAge, " ,上班等死地址: ", personAddress)

	/*
	  go语言现阶段还没有枚举,但是可以通过使用一种特殊的常量“iota”类模拟枚举
	  iota在const关键字出现时被重置为0,const中的每新增一行常量申明,将使iota进行一次计数,
	  可以简单第将iota理解为const语句块中的行索引
	*/
	const (
		a = iota
		b
		c = "你好呀,欢迎来到特工世界"
		d
		e = iota
	)
	println("a:", a)
	println("b:", b)
	println("c:", c)
	println("d:", d)
	println("e:", e)

}

---

实例运行效果:

---

GOROOT=D:\program_file_worker\go1.20 #gosetup
GOPATH=D:\program_file_worker\go1.20\bin;C:\Users\Administrator\go #gosetup
D:\program_file_worker\go1.20\bin\go.exe build -o C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ConstParameterDefinition_go.exe D:\program_file\go_workspace\org.jd.data\ConstParameterDefinition.go #gosetup
C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ConstParameterDefinition_go.exe
---------------循序渐进代码实操演示学习go编程语言--------------
-------------------------go语言中定义常量------------------------------
第一个常量:  GO语言实战系列
常量定义时,可以使用编译器进行类型推断,从而可以省略变量的类型
常量[a] =  20
常量[b]=  50
常量与变量都可以批量定义:
使用批量定义的常量:
名称:  小张  ,年龄:  30  ,上班等死地址:  北京市海淀区马连洼街道120路105号
a: 0
b: 1
c: 你好呀,欢迎来到特工世界
d: 你好呀,欢迎来到特工世界
e: 4

Process finished with the exit code 0

---

三: go中各种运算符认知

---

package main

import "fmt"

func main() {
	/*
	  go语言中的各种表达式:
	      (1)赋值表达式 = , +=,-+
	      (2)条件表达式  if 条件判断
	      (3)逻辑表达式  && || !
	      (4)算术表达式  + , - , * ,/
	      (5)位运算符
	*/

	fmt.Println("go语言中的各种表达式")

	a := 1
	b := 2
	println("算术运算符: ")
	println("a+b = ", a+b)
	println("a-b = ", a-b)
	println("a*b = ", a*b)
	println("求商(a/b) = ", a/b)
	println("求余数(a%b) = ", a%b)
	println()
	println("比较运算符：")
	println("a==b：", a == b)
	println("a>=b：", a >= b)
	println("a<=b：", a <= b)
	println("ab：", a > b)
	println("a!=b：", a != b)

	println()
	println("赋值运算符: ")
	var d = 10
	fmt.Println("变量d = ", d)
	d += 2
	fmt.Println("d+=2: ", d)
	d -= 2
	fmt.Println("d-=2: ", d)
	d *= 2
	fmt.Println("d*=2: ", d)
	d /= 2
	fmt.Println("d/=2: ", d)
	d %= 2
	fmt.Println("d%=2: ", d)

	println()
	println("位运算符: ")
	c := 9
	e := 13
	fmt.Println("e&c = ", e&c)
	fmt.Println("e|c = ", e|c)
	fmt.Println("e^c = ", e^c)
	fmt.Println("e<>c = ", e>>c)
	println()
	println("逻辑运算符: ")

	f := true
	g := false
	fmt.Println("f&g  = ", f && g)
	fmt.Println("f||g  = ", f || g)
	fmt.Println("!f = ", !f)

}

---

运行效果:

---

GOROOT=D:\program_file_worker\go1.20 #gosetup
GOPATH=D:\program_file_worker\go1.20\bin;C:\Users\Administrator\go #gosetup
D:\program_file_worker\go1.20\bin\go.exe build -o C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ExpressionToGoGrammar_go.exe D:\program_file\go_workspace\org.jd.data\ExpressionToGoGrammar.go #gosetup
C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ExpressionToGoGrammar_go.exe
go语言中的各种表达式
算术运算符:
a+b =  3
a-b =  -1
a*b =  2
求商(a/b) =  0
求余数(a%b) =  1

比较运算符：
a==b： false
a>=b： false
a<=b： true
a a>b： false
a!=b： true

赋值运算符:
变量d =  10
d+=2:  12
d-=2:  10
d*=2:  20
d/=2:  10
d%=2:  0
位运算符:
e&c =  9
e|c =  13
e^c =  4
e< e>>c =  0

逻辑运算符:
f&g  =  false
f||g  =  true
!f =  false

Process finished with the exit code 0

---

四: 流程控制认知

package main

import (
	"fmt"
	"runtime"
)

/*
go语言流程控制:

	go语言中,通过if 关键字构成的条件判断语句进行条件判断,格式如下:
	 if 条件表达式 {
	    分支一
	 }else if 条件表达式2 {
	    分支二
	 }else {
	    分支3
	 }
*/
func main() {

	fmt.Println(`Go语言的编程者需要通过流程控制语句来控制程序的逻辑走向和执行顺序.
                     流程控制语句主要包括: 条件判断语句(if和switch),
                     循环控制语句(for,break,continue和跳转语句goto)
              `)
	a := 101
	if a > 100 {
		fmt.Println(a, " > 100")
	} else if a == 100 {
		fmt.Println(a, " = 100")
	} else {
		fmt.Println(a, " < 100")
	}

	println(`
              if还有一种比较常见的写法,就是在if表达式前添加一个语句,使用变量接收语句返回的值，通过对该变量的判断在
               选择执行的分支;这一点更python的  if条件判断类似,而java需要另外一个变量来接收
           `)
	if num := runtime.NumCPU(); num >= 1 {
		println("程序使用的CPU核数为:", num)
	}

	println()
	println(`
        Go语言中的循环逻辑通过for关键字实现;不同于其他编程语言,Go语言没有while关键字,不存在while循环
        for循环格式如下:
           for 初始语句;条件表达式;赋值表达式 {
               循环体
           }
      `)
	println()
	for i := 1; i < 10; i++ {
		fmt.Println("循环的次数：", i)
	}

	println(`
        break跳出循环：
           break语言用来跳出for循环，而且可以在语句后面添加标签;表示退出标签对应的代码块逻辑;
           注意: break语句如果不带标签,则默认跳出最内层的for循环
   `)

	i := 1
	for {
		for {
			if i > 5 {
				println("跳出内层for循环")
				break
			}
			fmt.Println("循环次数: ", i)
			i++
		}
		fmt.Println("跳出外层for循环")
		break
	}

	println()
	fmt.Println(`
        使用带标签的break语句,直接跳出最外层的for循环:
    `)
	t := 1
OuterLoop:
	for {
		for {
			if t > 5 {
				println("break标签跳出最内层循环.....")
				break OuterLoop // 跳出OuterLoop标签对应的循环体
			}
			fmt.Println("循环次数: ", t)
			t++
		}
	}
	println()
	println(`
       continue继续循环:
           continue可以立即结束当前循环体中的逻辑,开始下一次循环;
           与break语句类似,continue语句之后也可跟标签,表示循环开始标签所对应的循环
    `)
OuterLoopContinue:
	for i := 0; i < 5; i++ {
		for j := 0; j < 6; j++ {
			if j == 1 {
				fmt.Println(i, j)
				continue OuterLoopContinue
			}
		}
	}
}

---

运行效果：

---

GOROOT=D:\program_file_worker\go1.20 #gosetup
GOPATH=D:\program_file_worker\go1.20\bin;C:\Users\Administrator\go #gosetup
D:\program_file_worker\go1.20\bin\go.exe build -o C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ControlFlowToGrammar_go.exe D:\program_file\go_workspace\org.jd.data\ControlFlowToGrammar.go #gosetup
C:\Users\Administrator\AppData\Local\Temp\GoLand\___go_build_ControlFlowToGrammar_go.exe
Go语言的编程者需要通过流程控制语句来控制程序的逻辑走向和执行顺序.
                     流程控制语句主要包括: 条件判断语句(if和switch),
                     循环控制语句(for,break,continue和跳转语句goto)

101  > 100

              if还有一种比较常见的写法,就是在if表达式前添加一个语句,使用变量接收语句返回的值，通过对该变量的判断在
               选择执行的分支;这一点更python的  if条件判断类似,而java需要另外一
个变量来接收

程序使用的CPU核数为: 20

        Go语言中的循环逻辑通过for关键字实现;不同于其他编程语言,Go语言没有while关键字,不存在while循环
        for循环格式如下:
           for 初始语句;条件表达式;赋值表达式 {
               循环体
           }

循环的次数： 1
循环的次数： 2
循环的次数： 3
循环的次数： 4
循环的次数： 5
循环的次数： 6
循环的次数： 7
循环的次数： 8
循环的次数： 9

        break跳出循环：
           break语言用来跳出for循环，而且可以在语句后面添加标签;表示退出标签对应
                                                                              应的代码块逻辑;
           注意: break语句如果不带标签,则默认跳出最内层的for循环

循环次数:  1
循环次数:  2
循环次数:  3
循环次数:  4
循环次数:  5
跳出内层for循环
跳出外层for循环

        使用带标签的break语句,直接跳出最外层的for循环:

循环次数:  1
循环次数:  2
循环次数:  3
循环次数:  4
循环次数:  5
break标签跳出最内层循环.....

       continue继续循环:
           continue可以立即结束当前循环体中的逻辑,开始下一次循环;
           与break语句类似,continue语句之后也可跟标签,表示循环开始标签所对应的循
                                                                              循环

0 1
1 1
2 1
3 1
4 1

Process finished with the exit code 0

---

五: swith语句匹配认知

---

六: goto跳转认知

---

 

忙着去耍帅,有时间补充完整..............