Golang.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