go基础，go变量，go函数

Go 即Golang，是Google公司2009年11月正式对外公开的一门编程语言---->新语言---》吉祥物是鼹鼠

-python  1989年
-java    1990年

goland和golang有什么区别？

-golang：go语言，一门编程语言
-goland：jetbrains公司出的编辑器，等同于pycharm

特点

Go是静态强类型语言，是区别于解析型语言的编译型语言(静态：类型固定 强类型：不同类型不允许直接运算)。
# Python是动态强类型，js是动态弱类型语言，java是静态强类型
# java 数字+字符串 隐式类型转换 python，go 强制类型转换---》手动做
解析型语言——源代码是先翻译为中间代码，然后由解析器对代码进行解释执行，需要有解释器，解释器跨平台，语言天然跨平台

编译型语言——源代码编译生成机器语言，然后由机器直接执行机器码即可执行。

java：一处编码，处处运行，跨平台-----》jvm---》java的源代码---》编译----》.class,jar,war---->运行在java虚拟机之上----》jvm运行在不同平台上，java代码就跨平台了

go语言代码---》开发完了----》编译---》可执行文件

-go语言可以   跨平台编译

go发展

-go 1版本发布：2012年
-go1.5：2015年 ，实现了自举 ---》自己写自己
-go1.11：2018  加入了modules支持
-go 1.19 最新  2022年

应用领域

服务开发、并发、分布式、微服务，自动化运维，区块链等方向

相关面试题

-python代码如何加密？
	-源代码---》打包成exe：https://zhuanlan.zhihu.com/p/430490285
    -docker---》打包到docker镜像中----》docker run  授权码 

5 Go语言开发环境搭建#

# go 的sdk  （只是开发阶段用） 1.19最新
# 编辑器：vscode，goland（jetbrains公司出的）


# 下载go sdk ，一路下一步安装https://golang.google.cn/dl/---》自动加入环境变量
	go 就有反应

# 下载goland，一路下一步

	

6 第一个Helloworld#

package main //任何一个go文件的，第一行必须指定包名，表示main包，一个项目必须有一个main包
import "fmt"
// 导入fmt包，sdk内置的包，打印相关

// main 函数
func main() {
	// 打印hello world
	fmt.Println("hello world")

}


/*
1 任意一个go文件第一行，都是声明包
2 任意一个go项目，必须包含main包，整个项目的入口
3 main包下要有一个main函数，是项目入口，编译型语言都有入口
4 包的导入在goland是自动的，如果一个包导入了，没有使用程序会报错，编译不通过
5 Println 的a 只是编辑器给的提示，实际是没有的
6 把源代码编译成win的可执行文件---》运行
	go build s1.go
	go build go_day01

7 开发阶段，每次都要编译，运行---》麻烦---》可以使用一个命令，编译并运行
	go run s1.go
	goland 点右键运行   本质就是执行了go run
 */

7 命名规范#

// 变量的命名规范
Go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个简单的命名规则：
1 一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线
2 大写字母和小写字母是不同的：Name和name是两个不同的变量
3 关键字和保留字都不建议用作变量名   ---》内置函数 包 模块名 


// 25个关键字----变颜色
break      default       func     interface   select
case       defer         go       map         struct
chan       else          goto     package     switch
const      fallthrough   if       range       type
continue   for           import   return      var


// 37个保留字
go语言中有37个保留字，主要对应内建的常量、类型和函数
内建常量: true false iota nil
内建类型:  int int8 int16 int32 int64
          uint uint8 uint16 uint32 uint64 uintptr
          float32 float64 complex128 complex64
          bool byte rune string error

内建函数: make len cap new append copy close delete
          complex real imag
          panic recover


// 注意
1 这些保留字并不是关键字，可以在定义中重新使用它们。在一些特殊的场景中重新定义它们也是有意义的，但是也要注意避免过度而引起语义混乱
2 Go语言程序员变量推荐使用 驼峰式 命名
3 go文件的名字，建议用下划线的方式命名

1 变量#

# go 介绍---》编译型语言---》编译过程
	go build 文件
    go run   文件
 
# go 环境搭建  go的sdk，编辑器goland
	-1.19版本
    	-go 命令
        -go env   go的环境变量
        	-GO111MODULE=
            -GOPATH=C:\Users\oldboy\go   # go path模式下，go的源代码必须在gopaht路径下的src文件夹下
            -GOROOT           # go的安装路径---》go的sdk在这个路径下，import 'fmt'
		   -GOPROXY=https://proxy.golang.org,direct  # go get 包名，国内的镜像站
        
# 第一个helloworld

# 变量命名规范
	-21关键字
    -37个保留字
    

package main

import "fmt"

// 变量
func main() {
   // 1 完整定义  var关键字 变量名 变量类型= 变量值
   //var name string ="lqz"
   //fmt.Println(name)

   // 2 类型推导（自动推到出变量类型）  var关键字  变量名  = 变量值
   //var name ="pyy"
   //var name =10
   //fmt.Printf("%T",name)
   //fmt.Println(name)

   // 3 简略声明
   //name := "pyy"
   //name=10  // 类型不能变化
   //fmt.Println(name)

   // 4 一次声明多个变量
   //var name,age,sex string="lqz","10","男"
   //var name,age,sex ="lqz",10,"男"
   //name,age,sex :="lqz",10,"男"
   //
   //var (
   // name string="pyy"
   // age =10
   // sex string
   //)
   //
   //sex="男"
   //fmt.Println(name,age,sex)



   // 5 只定义变量，不初始化，只能使用完整声明
   //var age int
   //fmt.Println(age)

   // 6 简略声明的方式，左侧必须有未定义的变量
   //var name ="lqz"
   var age =99
   name,age:="pyy",19
   fmt.Println(name,age)

}

/*
1 变量定义了，必须使用，不使用就报错
2 同变量只能定义一次，不能重复定义
3 变量在定义阶段，类型就固定了，后期不能改变
*/

2 类型#

// 基础数据类型
	-数字
    	-整数类型： int,   int8,int16,int32,int64
		java		     byte short  int  long
		 	-int8 表示的范围：占1个字节，8个比特位，一个比特位只能放0或1，所以它表示的范围是：-2的7次方 --- +2的7次方-1  -128到+127之间
			-int16  -2的15次方到+2的15次放-1
			-以此类推
			-特殊的 int ：表示的范围是在32位机器上是int32，在64位机器上是int64
	    -正整数：uint,uint8,uint16,uint32,uint64
			-特殊的 uint ：表示的范围是在32位机器上是 uint32 ，在64位机器上是 uint64
			-uint8  0-255之间
	    -浮点型：   float32,float64
			java   float  double
			-表示的范围不一样
			- float32 小数点后 5--7
			- float64  小数点   15位左右
		-复数：    complex64 , complex128     // 实部和虚部
		-其它： rune , byte    用在字符和字符串
				 byte 是 uint8的别名
				 rune 是 int32的别名

    -字符串
		- string   使用双引号，或`` 包裹的   用单引号包裹的表示字符
    -布尔
   		- bool

3 常量#

# python 没有常量，用全大小约定俗成，恒定不变的，一旦初始化，不能再改变了

package main

import "fmt"

const name = "lqz"

// 常量
func main() {
   // 1 定义方式 const关键字  名字  类型 = 值
   //const name string ="lqz"

   //const name  ="lqz"
   //fmt.Println(name)
   //name="pyy"  // 不能修改

   // 2 常量定义必须初始化，后期不能改
   //const a =99
   //fmt.Println(a)

   // 3 变量的作用域范围

   ////var name ="pyy"
   //name="xx"
   //fmt.Println(name)

   // 4 一次定义多个常量
   //const name,age, sex ="lqz",19,"男"

   //const (
   // name string ="lqz"
   // age = 19
   // sex ="男"
   //)

   // 5 iota的使用,常量计数器
   // 一次性定义多个常量，没有初始化，实际上已经初始化了，参照上一个常量初始化
   //const (
   // a=1
   // b
   // c=9
   // d
   //)
   //fmt.Println(a,b,c,d)

   //const (
   // a=iota   // 特殊，第一次出现是0
   // b
   // c
   // d
   //)
   //const (
   // a=iota   // 特殊，出现再哪一行，就是几，从0开始
   // b=iota
   // c=iota
   // d=iota
   //)


   const (
      a = 10
      b
      c=iota
      d = 20
      e=iota
      f
      g=8
      h=iota
   )
   fmt.Println(a, b, c, d,e,f,g,h)

}

4 函数#

//  函数的定义格式
func 函数名(变量名 变量类型,变量名 变量类型){
    
}

package main

import "fmt"

// 函数的定义和使用
func main() {
   //test1()
   //var a =9
   //test2(a,2)  // 没有关键字传参，都是按位置
   //test3(5,2)

   //a:=test4(8,8)
   //fmt.Println(a)

   //a,b,c:=test5(3,4)
   //a:=test5(3,4)   // go 中函数返回几个值就要用几个变量来接收
   //_,_,c:=test5(3,4)   // go 中函数返回几个值就要用几个变量来接收
   //// 使用 _ 忽略掉某个返回值
   //fmt.Println(c)

   //res,res2:=test6(4,5)
   //fmt.Println(res,res2)

   //test7()

   // 返回值是函数类型---》源自于：头等函数，一等公民
   //f:=test8()
   //f()

   // 闭包函数使用
   //f:=test9(10)
   //f()

   // 参数是函数,可以传有名，可以传无名
   //f:=test10(func() {
   // fmt.Println("我是无名函数")
   //})
   //f()

   res := test11()
   res(5, 6)


}

// 1 没有参数，没有返回值的函数
func test1() {
   fmt.Println("test1")
}

// 2 有参数，没有返回值
func test2(a int, b int) {
   fmt.Println(a + b)
}

// 3 多个参数，同一种类型
func test3(a, b int) {
   fmt.Println(a + b)
}

// 4 多个参数，一个返回值
func test4(a, b int) int8 {
   return int8(a + b)
}

// 5 多个参数，多个返回值
func test5(a, b int) (int, int, string) {
   return a + b, a * b, "成功"
}

// 6 命名返回值
func test6(a, b int) (sum, sum1 int) {
   sum = a + b
   sum1 = a * b
   return // 不写返回值，也有返回值，就是返回sum，sum1
}

// 7 函数高级之 匿名函数（函数没有名字）---》只能定义再函数内部

func test7() {
   // 匿名函数定义并使用
   func(a int) {
      fmt.Println(a)
      fmt.Println("我是匿名函数")
   }(10)
}

// 8 go，python中函数是一等公民【头等函数】---》函数可以赋值给一个变量
func test8() func() {
   // 匿名函数定义并使用
   f := func() {
      fmt.Println("我是匿名函数")
   }
   return f
}

// 9 写个闭包函数
func test9(a int) func() {
   f := func() {
      fmt.Println(a)
   }
   return f
}

// 10 函数的参数是函数类型
func test10(a func()) func() {
   f := func() {
      a()
   }
   return f
}

// 11 函数是一种类型，参数和返回值都是类型的一部分，参数和返回值不同，不是同一个类型
func test11() func(a, b int) {
   return func(a, b int) {
      fmt.Println(a + b)
   }
}