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