go 学习笔记

第一个go程序

# 定义一个包名，源文件必须存在包名，go通过包来管理命名空间
package main

# 引入一个外部的包，
import "fmt"


# 定义一个函数，main，main代表程序的入口
func main() {
    #调用包里的函数， 输出字面量"hello"
	fmt.Println("hello")
}


关键字
package import func

标识符

main main Println

字面量
"fmt"  "hello"

操作符
() {} .



# 一个程序简单的框架

package xxxx

iport {
    xxx
    xxx
}

func xx(){
       
}

运行程序 go run  源文件

打包程序 go build  -o 指定打包后文件名 源文件 

词法单元

编译

编译器编译源程序的第一步就是将源程序分割成一个个独立的token(token是构成源程序的基本不可再分割的单元),这个过程叫做词法分析

go 语言的token 可以分为关键字、标识符、操作符、分隔符、字面量等

token分隔符有两类，操作符和没有任何含义的纯分割符(空格、回车、换行符等)

a=b+c  :  =和+既是操作符也是分割符

package main  中间的空格就是纯分隔符

 标识符

标识符：用来标识变量、类型、常量等对象的符号名称

标识符分两类，预留标识符和编程者自定义标识符

命名规则：以字母或下划线开头，后面跟任意多个字符、数字、下划线，并且区分大小写

程序预留的标识符包括关键字、内置数据类型标识符、常量类型标识符、内置函数和空白标识符

关键字（keyword）

# go 语言中存在25个关键字
# 参照功能划分

# 引导程序整体结构
package 定义包名关键字
import 导入包名关键字
const 声明常量关键字
var 声明变量关键字
fanc 函数定义关键字
defer 延迟执行关键字
go 并发语法关键字
return 函数返回关键字

# 声明复合数据结构关键字
struct 定义结构类型关键字
interface 定义接口类型关键字
map 定义或创建map类型关键字
chan 声明或创建通道类型关键字

# 控制程序结构关键字
if else   if判断关键字
for range break continue  for循环关键字 
switch select type case default fallthrough   switch和select语句使用的关键字
goto 跳转语句关键字

内置数据类型标识符(20个)
数值
    整型
        byte int int8 int16 int32 int64
        uint unint8 unint16 unint32 unint64 unintprt
    浮点型
        float32 float64
    复合型
        complex64 complex128
字符和字符串型
    string rune
接口型
    error
布尔型
    bool

内置函数(15个)

make new len cap append copy delete panic recover close complex real image Print Printin

常量值标识符
true flase bool常量 真和假
iota  用在连续的枚举类型的声明中
nil   变量的默认值

空白标识符
_

操作符和分隔符

 操作符就是语言所使用的的符号集合，包括运算符、显式的分隔符，以及其他语法辅助符号。操作符不但本身是一个token,具备语法含义，同时其自身也是分隔其他token的分隔符。

纯粹分隔符的有四个：空格、制表符、回车和换行。

字面常量

程序中表示固定值的符号叫字面常量，简称字面量。

字面量分类：

整型字面量  使用特定字符序列来表示具体的整型数值

浮点字面量  使用特定字符序列来表示一个浮点数值

复数类型字面量 使用特定的字符序列来表示复数类型的常量值

字符型字面量  go采用utf-8的编码方式，字符占用1~4个字节

字符串字面量 使用 " " 将字符序列包括在内，双引号内可以是utf-8字面量也可以是其编码值

变量和常量

高级语言通过标识符来绑定一块特定的内存，后续对特定的内存的操作都可以使用该标识符来代替。这类绑定某个存储单元的标识符又可以分为两类，一类称之为'变量'，一类称之为'常量'。变量指向的内存可以被修改，常量指向的内存不可以被修改

变量

使用一个名称来绑定一块内存地址，该内存地址中存放的数据类型由定义变量时指定的类型决定，该内存地址里存放的内容可以改变

# 显示声明

var varName dataType [ = value ]

var 关键字
varName  标识符
dataType 基本类型
value 初始值，字面量或其他变量，如果不指定初始值，则类型默认的初始值
go 变量声明后会为其在内存中划分出空间

例
var a int = 1
var a int = 2+2
var a int = b

# 短类型声明
varName := value
:= 只能在函数中使用
编译器会自动判断变量类型

常量

使用一个名称来绑定一块内存地址，该内存地址中存放的数据类型由定义变量时指定的类型决定，该内存地址里存放的内容不可以改变，go 中常量分为布尔型、字符串型和数值型常量。常量存储在程序的只读段里。

# 预声明标识符
iota 用在常量声明中，初始值为0，一组常量同时声明时其值逐行递增，可以看做自增枚举变量，专门用来初始化常量

package main

import "fmt"

# 使用iota初始化一组常量
const (
	c0 = iota
	c1 = iota
)

# 使用iota初始化常量简写
const (
	c2 = iota
	c3
)

var a int = 1

func main() {
	fmt.Println(c0)
	fmt.Println(c1)
	fmt.Println(c2)
	fmt.Println(c3)
}

# 输出结果
0
1
0
1

基本数据类型

go 是一种强类型的静态编译语言，类型是高级语言的基础，有了类型，高级语言才能对不同类型抽象出不同运算，编程者才能更加专注更高抽象层次上操纵数据，而不关注存储和运算细节

布尔类型

布尔类型关键字是bool,值只有两个true和fasle
比较表达式和逻辑表达式的结果都是布尔型
if和for语句的条件部分一定是布尔类型的值或表达式
for ;true; {}   等价于 while True

声明布尔型变量如果不指定初始值默认false

整型

go语言内置了12种整型类型，不同类型的整型必须进行强制类型转换

浮点型

浮点型用于表示包含小数点的数据。
浮点数字面量会被自动类型推断为float64类型
var b := 10.00
计算机很难进行浮点数的精确表示和存储，因此两个浮点数之间不应该使用==或者！=进行比较操作
高精度计算应使用math标准库

字符串

# 字符串是一种原生的数据类型，可以直接初始化为字符串字面量
var  name = "li lei"

# 字符串是常量，可以通过索引访问其字节，但不能直接修改
b := name[0]
name[1] = 'a' // 不能操作

# 字符串转为字节数组
c := []byte(name)

# 字符串切片
d := name[0:4]

# 字符串运算
e := c + d

# 获取字符串长度
len(e)

流程控制

if 语句

package main

import "fmt"

func f1() {
	a := 2
	if a == 1 || a > 1 {
		fmt.Println("大于")
	}

}

func f2() {
	a := 2
	if a == 1 {
		fmt.Println("等于")
	} else {
		fmt.Println("不等于")
	}
}

func f3() {

	if a := 3; a > 1 {
		fmt.Println("大于")
	} else if a == 3 {
		fmt.Println("等于")
	} else {
		fmt.Println("小于")
	}
}

func main() {
	f1()
	f2()
	f3()
}

1 在判断时可以同时执行定义赋值等操作

2  Golang中所有判断不可直接使用数字，或非零值等判断，只能判断true或false，无论通过哪种方式返回布尔值给与Golang判断

 3 尽量减少语句的复杂度，减少嵌套层数，让代码扁平更易于阅读

switch 语句

package main

import "fmt"

func f1() {
	day := 7
	switch day {
	case 1, 2, 3, 4, 5:
		fmt.Println("工作日")
	default:
		fmt.Println("休息日")
	}
}

func f2() {
	num := 100
	switch num {
	case 100:
		fmt.Println("100")
        // 会跳过下一个 case表达式，直接执行下一个case语句
		fallthrough
	case 200:
		fmt.Println("200")
	case 300:
		fmt.Println("300")
	default:
		fmt.Println("10000")
	}
}
func main() {
	// f1()
	f2()
}

左花括号{必须与switch处于同一行；
条件表达式不限制为常量或者整数；
单个case中，可以出现多个结果选项；
与C语言等规则相反，Go语言不需要用break来明确退出一个case；
只有在case中明确添加fallthrough关键字，才会继续执行紧跟的下一个case；

switch也可以设置表达式，这时候作用跟if……else 一样

switch { 
    case 0 <= Num && Num <= 3: 
        fmt.Printf("0-3") 
    case 4 <= Num && Num <= 6: 
        fmt.Printf("4-6") 
    case 7 <= Num && Num <= 9: 
        fmt.Printf("7-9") //http://www.cnblogs.com/osfipin/
}