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


 

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扩展时只能向后扩展,使用底层数组中的位置,数组本身不可扩展,如果底层数组容量不够,会自动扩容——声明一个容量更大的数组,将原数组的元素复制到新数组中。
    在这里插入图片描述

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())
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值