Golang 基础语法、常量、变量、数据类型

淡淡的烟草味﹌ 2022-10-21 11:59 211阅读 0赞

### 目录 ###

*   *   *  .go文件基本结构
         *  变量
         *  常量
         *  数据类型
         *   *  内建数据类型
             *  指针 Pointer
             *  结构体
             *  接口
             *   *  接口的定义和实现
                 *  任何类型
                 *  接口的组合
             *  内建容器
             *   *  数组 Array
                 *  切片 Slice
                 *  集合 Map
             *  类型转换
             *  类型扩展

Go，又称Golang，是google开源的编程语言，原生支持并发编程

*  没有对象的概念，不支持继承、多态，没有泛型、try…catch
 *  有接口、函数式编程、csp并发模型（goroutine+channel）

### .go文件基本结构 ###

/* 一个包可以对应多个目录，一个目录只能对应一个包，同一目录下包名需要保持一致 */
    package main
    
    
    /* 如果导入的包依赖其它包，会先导入其它包 导入包时，会先初始化包中的公共常量、变量，如果有init()方法，会自动执行init()方法 */
    import (
    	"fmt"
    	complex "math/cmplx" //定义别名，可通过别名来引用
    )
    
    
    /* 同一包中，不能有同名的公共常量、变量、自定义的方法名，只能有一个main()方法 */
    const name = "chy"
    var age = 1
    
    
    func init() { 
    	fmt.Println("执行init()...")
    	fmt.Println(name)
    	fmt.Println(age)
    }
    
    
    /* 执行入口是main包下的main()方法 执行main时，会先导入依赖的包，再初始化常量、变量，如果有init()还会执行init()，最后执行main() */
    func main() { 
    	fmt.Println("执行main()...")
    	complex.Abs(1 + 1i)
    }

### 变量 ###

//go是先写变量名，再写数据类型
    var name1 string = "chy"
    //可以缺省类型，会自动推断类型
    var name2 = "chy"
    
    
    //可以同时声明多个变量，进行多个变量的赋值
    var name3, age3 = "chy", 20
    name3, age3 = "chy1", 21
    
    //可以指定数据类型，这个数据类型是给前面所有的变量指定的
    //var age4, age5 int = 20, 20
    
    //也可以这样写
    var (
    	name6 = "chy"
    	age6 = 20
    )

func f1() { 
    	//函数外可以定义未被使用的变量，函数内不能随便定义变量，定义了变量就必须使用
    	var age1 = 20
    
    	//直接用 = 赋值不能算是使用
    	age1 += 1
    
    	//在函数内，可以用 := 表示声明并赋值，相当于冒号相当于var
    	name1 := "chy"
    	name2, age2 := "chy", 20
    
    	fmt.Println(name1, name2, age2)
    }

*  函数的作用域是当前包中，函数外声明的变量作用域也是当前包中
 *  函数内声明的变量的作用域是局部变量，作用域是当前函数内

### 常量 ###

*  golang中常|变量名的大小写有特殊含义，常量名一般不全大写
 *  golang没有专门的枚举类型，可以用常量实现类似的功能
 *  iota是一个内置的自然数递增器，需要和const搭配使用

//常量的用法和变量差不多，但常量声明时就需要赋值，且后续不能修改值；变量可以先声明再赋值，但声明时必须指定数据类型
    var name1 string
    const name1 = "chy"
    
    
    //如果要定义多个常量，更推荐这种写法
    const (
    	name2 = "xxx"
    	port2 = 9000
    )

//自增型常量，0，1，2... 可以用_跳过当前值
    const (
    	java = iota
    	_
    	python
    	golang
    )
    
    
    //支持表达式，1，3，5...
    const (
    	a = iota*2 + 1
    	b
    	c
    )
    
    
    //1（2^0），1024（2^10），1024*1024（2^20）...
    const (
    	byte = 1 << (10 * iota)
    	kb
    	mb
    	gb
    )

### 数据类型 ###

#### 内建数据类型 ####

*  (u)int8、(u)int16、(u)int32、(u)int64、(u)int：go没有short、int、long之类的整型，以数字标识位数，/8即是该类型的字节数，以对应不同长度的整型。(u)int由操作系统位数决定，32位操作系统分配32位，64位操作系统分配64位。u表示无符号。
 *  uintptr 无符号整型，用于存放一个指针
 *  float32、float64：分别对应其它语言中的float、double。不用像其它语言一样需要在值末尾加f。
 *  complex64、complex128：复数，64是32位实数+32位虚数，128是64位实数+64位虚数。
 *  byte：uint8的别名
 *  rune：int32的别名，相当于其它语言中的char
 *  bool
 *  string：工具类strings提供了很多操作字符串的方法

//双引会解析其中的转义字符，反引号则不解析其中的转义字符
    var str1, str2 = "hello\nworld\n", `hello\nworld\n`
    fmt.Println(str1, str2)
    
    
    //复数，cmplx库也提供了很多操作复数的函数
    var c1, c2 = 1 + 1i, 2 + 2i
    fmt.Println(c1 + c2)

已声明但未赋值，也有默认的初始值，整型、浮点型初始值为0，字符串初始值为空串，bool型初始值为false。

#### 指针 Pointer ####

参数传递方式

*  值传递：把实参的值copy一份传给形参，如果是对象，copy的是对象的引用。java中只有值传递。
 *  指针传递：传入的实参的指针|地址，对形参的操作就是对实参的操作。
 *  引用传递：形参是实参的别名，对形参的操作就是对实参的操作。

//值传递
    func f1(a int) { 
    	a = 1
    }
    
    
    //指针传递。参数的数据类型是*int，在原类型前加*。可以把 *形参变量 当做 实参变量
    func f2(pa *int) { 
    	fmt.Println(*pa)
    	*pa = 100
    }
    
    //指针传递，交换2个变量的值
    func swap(a, b *int) { 
    	*a, *b = *b, *a
    }

//引用传递，此处以c++为例。&a可以理解为 给实参取别名a
    void swap(int &a, int &b) { 
    	int temp = a;
    	a = b;
    	b= temp;
    }
    
    int main() { 
    	int x = 1;
    	int y = 2;
    	swap(x, y);
    	return 0;
    }

#### 结构体 ####

//结构体。里面定义字段即可
    type node struct { 
    	value     int
    	pre, next *node
    }
    
    //自定义的工厂函数，golang允许返回局部变量的地址给外部使用
    func createNode(value int) *node { 
    	return &node{ value: value}
    }
    
    //调用方式是node.getValue()
    func (node node) getValue1() int { 
    	return node.value
    }
    
    //调用方式是getValue2(node)
    func getValue2(node node) int { 
    	return node.value
    }
    
    //参数不加*是传值，copy整个实参对象传给形参，对形参的修改不会影响到实参；加*是传地址，对形参的修改就是对实参的修改
    func (node *node) setValue1(value int) { 
    	node.value = value
    }
    
    //xxx(*xxx,xxx)调用，*作为参数时，需要&取地址传入
    func setValue2(node *node, value int) { 
    	node.value = value
    }
    
    
    func main() { 
    	//各字段都会初始化为对应类型的默认值，指针类型的默认初始值是nil
    	var head node
    
    	//0
    	fmt.Println(head.value)
    	//nil
    	fmt.Println(head.pre)
    	//报错，需要先判断，head.pre != nil 才进行操作
    	//fmt.Println(head.pre.value)
    
    	
    	//可以用new直接创建，效果和var head node一样，都是初始化各字段为该类型的默认初始值
    	head.pre = new(node)
    	//可以调用自定义的工厂函数创建
    	head.next = createNode(10)
    
    	//也可以node{}创建。node{}和var head node效果差不多，各字段都是使用默认的初始值
    	head = node{ }
    	//可以只给部分字段赋值，但需要指定字段名
    	head = node{ value: 10}
    	//给全部字段赋值时，可以缺省字段名
    	head = node{ 10, nil, nil}
    
    
    	//可以直接（访问|修改）操作字段。指针类型赋的是地址
    	head.value = 0
    	head.pre = &node{ }
    	head.next = &node{ 100, nil, nil}
    
    
    	//如果定义函数时：参数是指针（加*），会自动取head的地址（&head）传入；如果参数没有加*，会自动copy整个对象传入
    	head.setValue1(111)
    	//如果定义函数时：参数是指针（加*），需要&取地址传入；如果参数没有加*，直接传入head即可
    	setValue2(&head, 111)
    
    	fmt.Println(head.getValue1())
    	fmt.Println(getValue2(head))
    
    
    	//数组形式
    	nodeArr := []node{ 
    		{ },
    		{ value: 1},
    		{ 1, nil, nil},
    	}
    	fmt.Println(nodeArr)
    }

*  golang只支持封装，不支持继承和多态。
 *  golang中，局部变量不一定在栈上创建，不一定随着方法调用的结束而销毁。如果局部变量暴露出去给外部使用，这个局部变量会在堆上创建，由gc回收。
 *  如果要修改实参，参数使用指针；如果结构体变量很大，copy开销大，也可以考虑直接传入指针。

#### 接口 ####

##### 接口的定义和实现 #####

//定义一个接口，里面包含一些方法
    	type UserService interface { 
    		findUsernameById(id int) string
    	}

//定义一个结构体，实现接口中的所有方法
    //实现接口中的所有方法，这个结构体就算实现了接口，只实现了部分方法则不算
    type UserServiceImpl struct { 
    
    }
    
    //方法要写成xxx.xxx()的调用形式
    func (userServiceImpl UserServiceImpl) findUsernameById(id int) string { 
    	return "xxx"
    }

func f1(userService UserService, id int) { 
    	username := userService.findUsernameById(id)
    	fmt.Println(username)
    }
    
    func main() { 
    	userServiceImpl := UserServiceImpl{ }
    	f1(userServiceImpl, 1)
    }

##### 任何类型 #####

interface\{ \}表示任意类型，相当于java中的Object

func f2(i interface{ }) { 
    	fmt.Println(i)
    }
    
    func main() { 
    	var a interface{ } = 1
    	//可以更改值的类型
    	a = "xxx"
    	f2(a)
    }

##### 接口的组合 #####

Get接口

type Get interface { 
    	Get(url string) string
    }
    
    type GetImpl struct { 
    }
    
    func (get GetImpl) Get(url string) string { 
    	return "this is get response：" + url
    }

Post接口

type Post interface { 
    	Post(url string) string
    }
    
    type PostImpl struct { 
    }
    
    func (post PostImpl) Post(url string) string { 
    	return "this is the post response：" + url
    }

Http接口

//相当于接口的继承，可以继承其它接口，继承之后可以调用父接口中的方法
    type Http interface { 
    	//可包含一些其它接口，这些接口相当于当前接口的父接口
    	Get
    	Post
    	//可包含一些其它方法
    }
    
    type HttpImpl struct { 
    	//父接口的实现类
    	GetImpl
    	PostImpl
    }
    
    //其它方法实现

使用

func f1(http Http) { 
    	url := "http://www.baidu.com"
    	getResp := http.Get(url)
    	postResp := http.Post(url)
    	fmt.Println(getResp, postResp)
    }
    
    func main() { 
    	http := HttpImpl{ }
    	f1(http)
    }

#### 内建容器 ####

##### 数组 Array #####

//元素不够时，自动填充为该类型的初始值
    var arr1 = [5]int{ 1, 2, 3}
    
    //可以将长度写成... 自动取元素的实际个数
    var arr2 = [...]int{ 1, 2, 3}
    
    //可以先声明、后续赋值，已声明、但未赋值的数组，各元素为该类型的初始值
    var arr3 [11]int
    
    //二维数组，5行4列，元素是一维数组，元素不够时自动填充（该类型的初始值的一维数组）
    var arr4 = [5][4]int{ { }, { 1}, { 1, 2}, { 1, 2, 3}}

func f1(arr [5]int) { 
    	arr[0] = 100
    }
    
    func f2(arr [...]int) { 
    	arr[0] = 100
    }
    
    
    func main() { 
    	//arr1和f2的参数类型不匹配，不能传入
    	arr1 := [5]int{ 1, 2, 3}
    	f1(arr1)
    	f2(arr1)
    
    	//arr2的实际类型是[3]int，和f1、f2的参数类型均不匹配，不能传入
    	arr2 := [...]int{ 1, 2, 3}
    	f1(arr2)
    	f2(arr2)
    
    	//arr3已声明、未赋值，类型还是[...]int，可以传给f2，不能传给f1
    	var arr3 [...]int
    	f1(arr3)
    	f2(arr3)
    }

*  数组属于值传递，传的并不是数组的地址、引用，而是把整个数组copy一份传给形参，对形参数组的修改不会影响到实参数组。
 *  \[3\]int、\[5\]int、\[…\]int是三种数据类型，传入的数据类型要对应。
 *  golang中一般不直接使用数组，而是使用切片代替。

##### 切片 Slice #####

切片：从数组或其它切片上切下一个连续片段。

//与数组相比，切片不指定长度
    var arr = [...]int{ 1, 2, 3, 4, 5}
    var slice = []int{ 1, 2, 3, 4, 5}
    
    func main() { 
    	//切片的数据可以来源于数组，也可以来源于另一个切片，此处是来源于另一个切片
    
    	//[1,3)
    	var slice1 = slice[1:3]
    	//[0,3)
    	var slice2 = slice[:3]
    	//到末尾
    	var slice3 = slice[1:]
    	//全部元素
    	var slice4 = slice[:]
    
    	//不管来源于数组、还是另一个切片，切片的底层数据结构都是数组
    	//切片只是底层数组的一个视图，对切片的修改实际是对底层数组的修改，对底层数组的修改也会同步到对应的视图（切片）上
    	slice[0] = 100
    	slice1[1] = 1000
    	fmt.Println(slice1, slice2, slice3, slice4)
    }

无论是数组还是切片，golang都不支持负数索引。

**slice的组成**

*  ptr：slice中第一个元素的指针
 *  len：slice的长度（实际元素个数）
 *  cap：可用容量，ptr到底层数组末尾都属于可用范围，slice扩展时只能向后扩展，使用底层数组中的位置，数组本身不可扩展，如果底层数组容量不够，会自动扩容——声明一个容量更大的数组，将原数组的元素复制到新数组中。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoeV8xODg4MzcwMTE2MQ_size_16_color_FFFFFF_t_70]

**slice的扩展**

slice := []int{ 0, 1, 2, 3, 4}
    
    //只有2个元素0、1
    slice1 := slice[0:2]
    
    //使用slice时只能使用slice本身的索引，不能越过slice的边界使用底层数组的索引，否则会报越界
    //slice1[2] = 10
    
    //slice不能向前扩展，但可以向后扩展。append()会将元素添加到slice尾部，即底层数组中slice的后面
    //返回的是新分片，原分片不变
    slice1 = append(slice1, 2, 3, 4)
    fmt.Println(slice1)

//切片属于引用类型，已声明、未赋值时默认为nil，可以把nil理解为创建了容器对象，但这个容器中没有元素、是空的
    var slice []int
    
    //true
    fmt.Print(slice == nil)
    
    for i := 0; i < 100; i++ { 
    	fmt.Println(len(slice), cap(slice), slice)
    	slice = append(slice, i)
    }

**slice的常见操作**

//slice可以从数组、其它slice创建，也可以使用make()直接创建，会初始化各元素为该类型的默认值
    //第一个参数指定slice的len，第二个参数指定底层数组的cap，第二个参数可选
    slice1 := make([]int, 10)
    slice2 := make([]int, 10, 20)
    
    //修改元素
    slice1[0] = 1
    
    //在末尾添加元素
    slice1 = append(slice1, 1)
    
    //删除头部几个元素
    slice1 = slice1[2:]
    //删除尾部几个元素
    slice1 = slice1[:len(slice1)-2]

source := []int{ 1, 3, 5, 7, 9}
    target := []int{ 0, 2, 4, 6, 8, 10}
    
    //复制分片元素，第一个参数指定目标slice，第二个参数指定源slice
    //会将source中元素都复制到target中，是覆盖并非添加，如果target中放不下，不会自动扩容，放不下的部分就不要了
    copy(target, source)

##### 集合 Map #####

// map[key类型]value类型。支持复合map，value也可以是一个map
    m1 := map[string]string{ 
    	"name": "chy",
    	//最后一个元素末尾需要加逗号
    	"age": "20",
    }
    
    //通过make创建时，创建的是空map，!=nil
    m2 := make(map[string]string)
    
    //已声明、未赋值的的map，==nil
    var m3 map[string]string
    
    
    //获取元素个数
    count := len(m1)
    
    
    //获取key对应的value。如果key不存在，会返回对应类型的默认初始值作为value
    //name := m1["name"]
    
    //所以一般用2个变量接收返回值，第一个是value，第二个是bool型 标识key是否存在
    name, isExist := m1["name"]
    fmt.Println(isExist)
    if isExist { 
    	//key存在
    	fmt.Println(name)
    } else { 
    	//key不存在
    }
    
    
    //删除指定的键值对
    delete(m1, "name")

*  map是无序的
 *  map使用哈希表存储元素，但不需要手动实现hashCode()、equals()方法
 *  除slice、map、function以外的内建类型，以及成员字段均不是这三种类型的struct，都可以作为key

#### 类型转换 ####

go不支持类型的隐式转换，eg. 不会自动将0、1、空串等转换为bool型，需要手动转换。

var a float32=1.5
    
    //目标类型(变量名)，不能直接 目标类型(值)
    var b int=int(a)
    
    fmt.Println(a,b)

#### 类型扩展 ####

golang没有继承，可以通过组合、定义别名来扩展现有类型。  
   
组合

type Node struct { 
    	Value     int
    	Pre, Next *node
    }
    
    type NodeExt struct { 
    	Node  *node
    	Score float32
    }
    
    func main() { 
    	node := Node{ 10, nil, nil}
    	//如果定义中没有使用指针（加*），此处就不用&取地址，直接传入即可，但这种对内部字段的修改不会影响|同步到实参
    	nodeExt := NodeExt{ &node, 10.0}
    	fmt.Println(nodeExt)
    }

定义别名

//定义别名，Queue是[]int的别名
    type Queue []int
    
    //结构体的字段如果要暴露给其它包访问，需要将字段名首字母大写；如果要把方法暴露给其他包使用，只需将方法名首字母大写，不需要将形参名首字母大写
    func (q *Queue) Push(value int) { 
    	*q = append(*q, value)
    }
    
    func (q *Queue) Pop() int { 
    	head := (*q)[0]
    	*q = (*q)[1:]
    	return head
    }
    
    func (q *Queue) IsEmpty() bool { 
    	return len(*q) == 0
    }
    
    func main() { 
    	queue := Queue{ }
    	queue.Push(10)
    	fmt.Println(queue.Pop())
    	fmt.Println(queue.IsEmpty())
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoeV8xODg4MzcwMTE2MQ_size_16_color_FFFFFF_t_70]: /images/20221021/419f7e986b9e43aa83cd3b0e2260d4b2.png