Golang.Go语言基础
Posted qq_51102350
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Golang.Go语言基础相关的知识，希望对你有一定的参考价值。
Go
一，惊鸿一瞥
1，Hello，World
package main
import
"fmt"
func main()
fmt.Println("Hello, World!")
package关键字声明代码所属的包，本例中包名为main。
import关键字导入需要的包
func关键字声明函数
当运行一个Go程序，总是从main包的main函数开始
fmt包：format之缩写，提供格式化输入输出函数
此外，大括号有其唯一的制定格式
2，基本知识
package main
import "fmt"
func main()
//声明常量
const days = 365
//声明变量
var (
dream = "I have a dream"
new_dream = "I had a dream"
)
//格式化输出
fmt.Println("One year has",days,"days")
fmt.Print("One year has ")
fmt.Print(days)
fmt.Print(" days\\n")
fmt.Printf("One year has %d days\\n",days)
fmt.Println(dream,"\\n",new_dream)
Println会自动补换行符
Go中运算符和C中大抵相同，但没有++count这种前置增量操作
3，基本控制结构
在go中，true是唯一真值，false是唯一假值
比较运算符：==,!=,<=,<,>=,>
Go不允许文本和数值直接比较
func demo()
if 判断语句
//do sth.
else if 判断语句
//do sth.
else 判断语句
//do sth.
逻辑与：&&
逻辑或：||
逻辑非：！
Switch实现分支判断：
package main
import "fmt"
func main()
const days = 365
switch days
case 100:
fmt.Println(100,"days")
case 200,365://使用逗号分隔多个可选值
fmt.Println("hhhh")
fallthrough
default:
fmt.Println("23333333")
for实现循环结构
关于range关键字：
//假设array_cut是一个数组或切片
//index和value分别对应了下标和值
for index,value := range array_cut
//do sth.
4，作用域
go作用域：以大括号分界
虽然没有用到大括号，但default和case都i引入了新的作用域
简短声明：
//两方法等价
var name = 'ubuntu'
name := 'ubuntu'
简短声明作用：
以下三种情况，变量作用域都在大括号内
这种使用方法无法用var声明替代
for count := 10; count > 0;count--
//do sth.
if count := rand.Intn(3); count == 0
//do sth.
switch num := rand(10); num
//do sth.
二，类型
1，浮点数
//双精度浮点数
age := 19.2
var age =19.2
var age float64 = 19.2
//单精度浮点数
var age float32 = 19.2
//默认零值
var age
2，整数
year := 2021
var year = 2021
var year int 2021
//e12表示10的12次方
var distance int64 = 2.33e12
3，big包
big包提供3种类型：
- 存储大整数big.Int
- 存储任意精度浮点数big.Float
- 存储分数big.Rat
//创建int64类型
hhhhh := big.NewInt(2333333)
//创建很大很大的数
hhhhhhh := new(big.Int)
hhhhhhh.SetString("23333333333333333",10)
//Go语言不会为常量推断类型，而是默认无类型（untyped）
//由big包提供底层支持
const distance = 23333333333333333333333333
4，多语言文本
//go语言推断双引号内字面值为string类型
peace := "peace"
var peace = "peace"
var peace string = "peace"
//声明零值
var peace string
//反引号包围的文本不考虑转义字符
var peace 'hhhhhhh\\n'//不会输出换行符，而是输出/n
//反引号可跨越多行，打印时将包含这些行
var peace 'hhhhh
hhhhhhhh
hhhhh'
//可以独立访问字符串中的单个字符，但无法单独修改
hhhh = 'laugh'
h = laugh[4]
//非法操作：
laugh[4] = 'd'
5，类型转换
类型转换：
转换一个变量，只需用与目标类型同名的函数来包裹该变量
//字符串拼接
hhhh = 'laugh ' + 'is the power of birth.'
//非法：
hhh ='laugh ' + 'is the power of birth.' + 10
//合法
hhh = 'laugh ' + 'is the power of birth.' + '10'
这部分与c语言大致相同
浮点数转换为整数，没有任何舍入，而是直接截断
关于字符串转换
//根据代码点转换
fmt.Println(string(960),string(940),string(969),string(33))
//输出π ά ω !
//转换为字符串方法：
//使用strconv包的Itoa函数
hhh ='laugh ' + 'is the power of birth.' + strconv.Itoa(10)
//字符串转换为整数
//使用strconv包的Atoi函数
const hhh string = '23333'
number := strconv.Atoi(hhh)
代码点：
一个数字对应一个特殊字符
如：π ά ω !分别对应960 940 969 33
三，构建块
1，函数
基本格式：
func function_name( [parameter list] ) [return_types] 函数体
func Add(number1 int,number2 int)(sum int)
sum = number1 + number2
return sum
func Add(number1 int,number2 int)(sum int)
sum = number1 + number2
return //省略了返回值的名字
func Calculate(number1 ,number2 int)(sum,multitude int)//减少了int的使用次数
sum = number1 + number2
multitude = number2*number1
return sum,multitude
func Calculate(number1 ,number2 int)(sum,multitude int)
sum = number1 + number2
multitude = number2*number1
return
2，方法
声明新类型：
格式：
type 新类型名称 底层类型
注意：
type type1 float64
type type2 float64
var number1 type1 := 10
var number2 type2 := 15
var number3 float64 = 20
//以下操作非法.尽管底层相同，他们仍为不同的类型
numebr1 = number2
number2 = number3
在go语言中，没有类和对象
格式：
func (接受者) 方法名(形参列表) （返回值列表）
//do sth.
接受者是某种非内置类型的变量
用于建立类型和方法之间的关联
实例：
package main
import "fmt"
type myInt int
func (number1 myInt) calculate(number2 int) (sum int,multitude int)
return int(number1)+number2,int(number1)*number2
func main()
var number1 myInt = 10
var number2 =20
var sum int
var multitude int
sum,multitude = number1.calculate(number2)
fmt.Println(sum,multitude)
3，一等函数
在go中，函数是 一等 值，可以把函数赋值给变量，可以把函数传递给函数，也可以编写创建并返回函数的函数。
将函数赋值给变量
package main
import "fmt"
type myInt int64
func Add(number1,number2 int) myInt
return myInt(number1+number2)
func Multitude(number1,number2 int) myInt
return myInt(number1*number2)
func main()
//将函数赋值给变量方法一：
func1 := Add
//将函数赋值给变量方法二
var func2 func(int,int) myInt = Multitude
var number1 int = 10
var number2 int = 20
var result myInt
result = func1(number1,number2)
fmt.Println(result)
result = func2(number1,number2)
fmt.Println(result)
func1 = func2
result = func1(number1,number2)
fmt.Println(result)
func2 = Add
result = func2(number1,number2)
fmt.Println(result)
将函数传递给其他函数
type myInt int64
//声明函数类型
type myFunc func(int,int) myInt
func Add(number1,number2 int) myInt
return myInt(number1+number2)
func Multitude(number1,number2 int) myInt
return myInt(number1*number2)
func Add_Multitude(number1,number2 int, func1,func2 myFunc) (sum,multitude myInt)
sum = func1(number1,number2)
multitude = func2(number1,number2)
return sum,multitude
闭包和匿名函数
匿名函数在Go中也称为函数字面量
闭包函数：声明在一个函数内部的函数
闭包：内部函数总是可以访问其所在外部函数中的变量，即使它所在的外部函数已返回（寿命终结）
package main
import "fmt"
type myFunc func() int
func func1(func2 myFunc,offset int) myFunc
return func() int
return func2() + offset
func func2() int
return 10
func main()
//匿名函数赋值给变量
func4 := func(message string)
fmt.Println(message)
func4("hhhhhhhhhhhhhhhhhhhhhhh")
//同时声明和调用匿名函数
func()
fmt.Println("hhhhhhhhh")
()
//从函数里返回另一个函数
func3 := func1(func2,20)
fmt.Println(func3())
可变参数函数
声明放在函数形参的最后一位
可以传入多个参数或不传参数
func f(name...string)
//do sth.
cut_test := []string"sss","hhh","2333"
//将cut_test的多个元素传递给函数
cut = f(cut_test..)
四，收集器
1，数组
var planests [8]string
planest[0] = "Mercury"
mercury := planets[0]
fmt.Println(len(planest))//输出8
//未赋值的元素将默认为零值
var numbers = [5]int1,2,3
//也可以不用指定数组长度
var numbers = [...]int
1,
2,
3,
//结尾逗号是必需的
数组用于赋值或传递给参数时会产生一个副本
故函数内部对数组的修改不会影响原数组
数组嵌套定义即形成所谓的多维数组
2，切片
切片数组不会导致数组被修改，只是创建了指向数组的视图，把该视图称为切片类型
格外注意的是，切片或切片的切片都是数组的视图，对他们进行修改会导致原数组的修改
package main
import (
"fmt"
"sort"
)
func main()
numbers := [5]int1,2,3,4,5
cut1 := numbers[0:3]
cut2 := numbers[0:2]
fmt.Println(numbers,cut1,cut2)
cut2[1] = 100
fmt.Println(numbers)
//可以切割string类型，将创建另一个字符串，两个字符串相互独立
name := "yangzi"
name1 := name[:4]
fmt.Println(name,name1)
name = "hhhhh"
fmt.Println(name,name1)
//创建完全切片方法一：
//numbers2 := numebrs[:]
//创建完全切片方法二：
numbers3 := []string"11","40","ann","ccc","bbbb"
//切片可以带有方法
sort.StringSlice(numbers3).Sort()
fmt.Println(numbers3)
关于sort：
标准库sort包声明了一种StringSlice类型：
type StringSlice []string
该类型还有关联的Sort方法：
func (p StringSlice) Sort()
Go语言通过切片和append函数来实现这一点
切片长度：切片中可见元素的数量
切片容量：切片的底层数组决定了切片的容量
package main
import "fmt"
func main()
//切片的底层数组长度为5
//切片长度为5,容量为5
vocabulary := []string"terminally","visible","lethal","legally","prescribe"
//此时，append函数将切片元素复制到新创建的数组里面并将新创建的数组作为切片的底层数组，该数组长度为原底层数组的两倍
//切片长度为8,容量为10
vocabulary = append(vocabulary,"partnership","compassion","publication")
//三索引切片操作：
//三索引操作旨在避免对底层数组的修改
arry_vocabulary := [...]string"candidness","dose","medication","constitutionally","uphold","legislation",
//切片长度为4,容量为4
cut_vocabulary := arry_vocabulary[0:4:4]
fmt.Println(cut_vocabulary)
cut_vocabulary = append(cut_vocabulary,"spark")
fmt.Println(cut_vocabulary)
fmt.Println(arry_vocabulary)
//两索引
//长度为2,容量为6（与底层数组相同）
cut_vocabulary2 := arry_vocabulary[0:4]
cut_vocabulary2 = append(cut_vocabulary,"notable")
fmt.Println(cut_vocabulary2)
fmt.Println(arry_vocabulary)
//三索引但容量大于长度
cut_vocabulary3 := arry_vocabulary[0:4:5]
cut_vocabulary3 = append(cut_vocabulary,"spark")
fmt.Println(cut_vocabulary3)
fmt.Printpackage main
import "fmt"
func main()
//声明map方法一：
map1 := map[string]int
"key1":1,
"key2":2,
//声明map方法二
map2 := make(map[string]int)
map2["New_York"] = 1
map2["San_Franscisco"] = 2
map2["Tokyo"] = 3
//数组或一些基本类型在赋值给新变量或传递至函数/方法时都会创建相应的副本，但映射不会
map3 := map1
map3["key1"]=2
fmt.Println(map3)
fmt.Println(map1)
//遍历映射
//遍历键
for key := range map2
fmt.Print(key)
fmt.Print("\\n")
//遍历值
for _,value := range map2
fmt.Print(value)
fmt.Print("\\n")
//遍历键值
for key,value := range map2
fmt.Println(key,value)
//删除键值对
//delete(map_name,key_name)
delete(map2,"New_York")
//判断某一个键值对是否存在
//当键值对不存在，输出对应数据类型的零值
fmt.Println(map2["New_York"])
//使用value, ok := map[key]的写法判断
map2["Shenzheng"] = 0
if value,ok := map2["Shenzheng"]; ok
fmt.Println(value," is exited.")
else
fmt.Println("not exited")
ln(arry_vocabulary)
//使用make函数对切片容量实行预分配
//切片长度为0,容量为10
test_cut1 := make([]string,0,10)
test_cut1 = append(test_cut1,"hhhhhhhhhhhhhh")
//切片长度为10,容量为10,元素默认为零值
test_cut2 := make([]string,10)
//此时将向切片中追加第11个元素
test_cut2 = append(test_cut2,"hhhhhhhhh")
3，映射
映射（map）：可将键映射到值
与数组和切片使用序列整数作为索引不同的是，映射的键几乎可以是任何类型
可以理解为Python中的字典
Go语言必须为映射的键和值指定类型
格式：
map[键的类型]值的类型
示例：
package main
import &#以上是关于Golang.Go语言基础的主要内容，如果未能解决你的问题，请参考以下文章