Go语言基础一

Go语言基础

Go基础

1.变量定义：var 变量名 类型 = 表达式

var a int = 8

• a 在函数内部，可以使用更简略的 := 方式声明并初始化变量。
• **注意：**短变量只能用于声明局部变量，不能用于全局变量的声明

声明变量：快速 := 方式声明并初始化变量

// 变量名 := 表达式 
n := 10
var a = 18

//一次变量多个声明
var a,b,c int
a=1
b=2
c=3
//多变量声明
var(
	a int
	b string
	)
a=1
b="sad"
fmt.Println(a,b)

声明常量：

//const声明
const a = 1
const b = 1.555

//下面两种都可声明多个常量
const(
a=1
b
)
const(
a=1
b=2
)

fmt包

• Println：
  • 一次输入多个值的时候 Println 中间有空格
  • Println 会自动换行，Print 不会
• Print：
  • 一次输入多个值的时候 Print 没有 中间有空格
  • Print 不会自动换行
• Printf
  • Printf 是格式化输出，在很多场景下比 Println 更方便

Init函数和main函数

init函数

• go语言中init函数用于包(package)的初始化，该函数是go语言的一个重要特性。
• 有下面的特征：
  • 1、init函数是用于程序执行前做包的初始化的函数，比如初始化包里的变量等
  • 2、每个包可以拥有多个init函数
  • 3、包的每个源文件也可以拥有多个init函数
  • 4、同一个包中多个init函数的执行顺序go语言没有明确的定义(说明)
  • 5、不同包的init函数按照包导入的依赖关系决定该初始化函数的执行顺序
  • 6、init函数不能被其他函数调用，而是在main函数执行之前，自动被调用

main函数

// Go语言程序的默认入口函数(主函数)：func main()
// 函数体用｛｝一对括号包裹

func main(){
   
   //函数体
}

二者区别：境不要使用。

相同点：
两个函数在定义时不能有任何的参数和返回值，且Go程序自动调用。

不同点：
init可以应用于任意包中，且可以重复定义多个。
main函数只能用于main包中，且只能定义一个。

两个函数的执行顺序：
对同一个go文件的init()调用顺序是从上到下的。
对同一个package中不同文件是按文件名字符串比较“从小到大”顺序调用各文件中的init()函数。

对于不同的package，如果不相互依赖的话，按照main包中"先import的后调用"的顺序调用其包中的init()
如果package存在依赖，则先调用最早被依赖的package中的init()，最后调用main函数。

如果init函数中使用了println()或者print()你会发现在执行过程中这两个不会按照你想象中的顺序执行。
这两个函数官方只推荐在测试环境中使用，对于正式环

go的常用命令

go env用于打印Go语言的环境信息。

go run命令可以编译并运行命令源码文件。

go get可以根据要求和实际情况从互联网上下载或更新指定的代码包及其依赖包，并对它们进行编译和安装。

go build命令用于编译我们指定的源码文件或代码包以及它们的依赖包。

go install用于编译并安装指定的代码包及它们的依赖包。

go clean命令会删除掉执行其它命令时产生的一些文件和目录。

go doc命令可以打印附于Go语言程序实体上的文档。我们可以通过把程序实体的标识符作为该命令的参数来达到查看其文档的目的。

go test命令用于对Go语言编写的程序进行测试。

go list命令的作用是列出指定的代码包的信息。

go fix会把指定代码包的所有Go语言源码文件中的旧版本代码修正为新版本的代码。

go vet是一个用于检查Go语言源码中静态错误的简单工具。

go tool pprof命令来交互式的访问概要文件的内容。

#06.golang中关键字

go==关键字

var和const ：变量和常量的声明
package and import: 导入
func： 用于定义函数和方法
return ：用于从函数返回
defer someCode ：在函数退出之前执行
go : 用于并行
select 用于选择不同类型的通讯
interface 用于定义接口
struct用于定义抽象数据类型
break、case、continue、for、fallthrough、else、if、switch、goto、default 流程控制
chan用于channel通讯
type用于声明自定义类型
map用于声明map类型数据
range用于读取slice、map、channel数据

基本数据类型：

内置类型

值类型：

bool
int(32 or 64), int8, int16, int32, int64
uint(32 or 64), uint8(byte), uint16, uint32, uint64
float32, float64
string
complex64, complex128
array    // 固定长度的数组

引用类型：（指针类型）

slice    // 序列数组(最常用)
map     // 映射
chan     // 管道

内置函数

• Go 语言拥有一些不需要进行导入操作就可以使用的内置函数。
• 它们有时可以针对不同的类型进行操作，例如：len、cap 和 append，或必须用于系统级的操作，例如：panic。
• 因此，它们需要直接获得编译器的支持。

append          // 用来追加元素到数组、slice中,返回修改后的数组、slice
close           // 主要用来关闭channel
delete          // 从map中删除key对应的value
panic           // 停止常规的goroutine  （panic和recover：用来做错误处理）
recover         // 允许程序定义goroutine的panic动作
real           // 返回complex的实部   （complex、real imag：用于创建和操作复数）
imag           // 返回complex的虚部
make           // 用来分配内存，返回Type本身(只能应用于slice, map, channel)
new            // 用来分配内存，主要用来分配值类型，比如int、struct。返回指向Type的指针
cap            // capacity是容量的意思，用于返回某个类型的最大容量（只能用于切片和 map）
copy            // 用于复制和连接slice，返回复制的数目
len            // 来求长度，比如string、array、slice、map、channel ，返回长度
print、println     // 底层打印函数，在部署环境中建议使用 fmt 包

基本类型

​

类型	长度(字节)	默认值	说明
bool	1	false
byte	1	0	uint8
rune	4	0	Unicode Code Point, int32
int, uint	4或8	0	32 或 64 位
int8, uint8	1	0	-128 ~ 127, 0 ~ 255，byte是uint8 的别名
int16, uint16	2	0	-32768 ~ 32767, 0 ~ 65535
int32, uint32	4	0	-21亿~ 21亿, 0 ~ 42亿，rune是int32 的别名
int64, uint64	8	0
float32	4	0.0
float64	8	0.0
complex64	8
complex128	16
uintptr	4或8		以存储指针的 uint32 或 uint64 整数
array			值类型
struct			值类型
string		“”	UTF-8 字符串
slice		nil	引用类型
map		nil	引用类型
channel		nil	引用类型
interface		nil	接口
function		nil	函数

数字类型

go语言数据类型分为：基本数据类型（整形，浮点型，布尔类型，字符串）和复合数据类型（数组，切片，结构体（struct）函数，map,管道，接口(interface)）

整形分类：有符号（int8,int16,int32,int64）无符号（uint8,uint16,uint32,y=uint64）范围例：(in8[-2^7d到27-1])(int8[0到2^8-1])

字节（Byte）[计算机的基本存储单位，8bit位1byte字节,1024byte字节==1KB,一个中文字符为2byte]

unsafe.Sizeof(n1) 是 unsafe 包的一个函数，可以返回 n1 变量占用的字节数

reflect.TypeOf(n1),返回其类型和格式化输出类型(fmt.Printf("%T",n1))

int不同长度之间的转换：num int8==>int16

//package project1
package main

import (
   "fmt"
   "unsafe"
)

func main()  {
   var x int8=124
   fmt.Println(x)
   fmt.Println(unsafe.Sizeof(x))
   var num int8
   num = 124
   num1 := int16(num)
   fmt.Printf("值为%v,类型为%T",num1,num1)
}

int类型与其它类型之间的转换：(STR–INT[ a,_ ])

//字符串到int
func main(){
   
    a,_ := strconv.Atoi("123")
	fmt.Println(a,reflect.TypeOf(a))
}
//字符串到int64
func main()  {
   
	a,_ := strconv.ParseInt("123",10,64)
	fmt.Println(a,reflect.TypeOf(a))
}
//int到字符串

func main(){
   
	s := strconv.Itoa(5)
	fmt.Println(s,reflect.TypeOf(s))
}
//int64到字符串
func main(){
   
	var s int64 = 123
	c := strconv.FormatInt(s,10)
	fmt.Println(c,reflect.TypeOf(c))
}
//int8到int16,int8到float32等
==>var a int8 = 123 ==> int16(a)
==>var a int8 = 123 ==> float32(a)

//math.Sqrt开平方
func main() {
   
	var a, b = 6,8
	var c int
	// math.Sqrt()接收的参数是 float64 类型，需要强制转换
	c = int(math.Sqrt(float64(a*a + b*b)))
	fmt.Println(c)  // 10
}

func main() {
   
	//int64转str
	var num2 int64 = 123456
	str2 := strconv.FormatInt(num2, 10)
	fmt.Printf("%v---%T \n",str2,str2)  // 123456---string

	str转float64
	v1, _ := strconv.ParseFloat(str2, 64)
	fmt.Printf("%v---%T\n",v1,v1)      // 123456---float64
}
//str与int64
	//int--string
	s := 123
	v := strconv.Itoa(s)
	fmt.Println(v)
	//string--int
	s := "123"
	v,_ := strconv.Atoi(s)
	fmt.Println(v,reflect.TypeOf(v))
	//int64--str
	s := int64(123)
	v := strconv.FormatInt(s,10)
	fmt.Println(v,reflect.TypeOf(v))
	//str--float64
	s := "123"
	v,_ := strconv.ParseFloat(s,64)
	fmt.Println(v,reflect.TypeOf(v))

浮点型（指引float32,float64）

//package project1
package main

import (
	"fmt"
	"math"
)

func main()  {
   
	//指定保留两位，默认六位
	fmt.Printf("%.2f",math.Pi )
	fmt.Printf("%f",math.Pi )
}

布尔类型（bool）[bool:True—False(默认为False)]

• Go 语言中不允许将整型强制转换为布尔型.
• 布尔型无法参与数值运算，也无法与其他类型进行转换。

func main() {
   
	var a bool
	fmt.Println(a,reflect.TypeOf(a))
}
//结果：false bool

字符串类型

Go内部实现-UTF8编码

go值不能为ascii编码（s :=“你好”）

转义字符

//转义符 含义
\r---回车符（返回首航）
\n---换行符
\t---指表符
//如果想转义('',"",\)
\",\,\\
func main() {
	fmt.Println("str := \"D:\\go.exe\"")  // str := "D:\go.exe"
}

多行字符串：反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

func main() {
   
	s := `
	adasd
	asdasd
	adsasdasd
	`
	fmt.Println(s)
}

//结果：

	adasd
	asdasd
	adsasdasd
	

go字符类型

1.go字符只有两种：uint8[字节（byte类型：代表了ascii的一个字符）] ，rune[utf-8字符]

2.字符串底层是byte数组所以可以和[]byte类型相互转换

3.字符串时不能修改的，字符串是由byte字节构成所以其长度是byte字节rune长度

4.rune类型代表utf8字符,一个rune字符有1或多个byte组成

func main() {
   
	s := "永远的神语言"
	v := []rune(s)
	fmt.Println("Go"+string(v[4:]))
}
//Go语言

go字符串常见用法

//字符串方法---用法
//len（str）---长度
var str = "ac b"
fmt.Println(len(str))  // 4
//+或fmt.Sprintf()---拼接
var str1 = "as"
var str2 = "df"
fmt.Println(str1 + str2)  // asdf
//strings.Split()---拆分
var s = "abc def"
var arr = strings.Split(s, " ")
fmt.Println(arr)  // [abc def]
//strings.Contains()---判断字符串是否包含
func main(){
   
	s := "qwer"
	c :="q"
    fmt.Println(strings.Contains(s,c))//判断s是否包含c true
}
//strings.HasPrefix,strings.HasSuffix---前后缀判断
func main(){
   
	s := "qwer"
	c :="q"
	fmt.Println(strings.HasPrefix(s,c))//判断是否以c开头
	fmt.Println(strings.HasSuffix(s,c))//判断是否以c结尾
}
//strings.Index(),strings.LastIndex()---字符串索引位置
func main(){
   
	s := "qwer sad"
	fmt.Println(strings.Index(s,"q")) //0
	fmt.Println(strings.LastIndex(s,"q")) //0
}
//strings.Join()---join
func main(){
   
	s := "qwer sad"
	c := strings.Split(s," ")
	fmt.Println(strings.Join(c,"-"))
}//qwer-sad

单引号

字符串有字符组成，字符用单引号表示’ 'font>

uint8类型 byte代表字节，表示ascii码一个字符

rune类型 代表utf8一个字符

func main(){
   
	a := 'C'
	//当我们直接输出 byte（字符）的时候输出的是这个字符对应的码值
	fmt.Println(a)       // 67 这里输出的是 a 字符串的 ASCII值
}

字符串遍历

//第一种
func main(){
   
	str := "abc你好"
	for i:=0;i<len(str);i++{
   
		fmt.Printf("%v=%c ",str[i],str[i])//97=a 98=b 99=c 228=ä 189=½ 160=  229=å 165=¥ 189=½ 
	}
	fmt.Println()
}
//第二种
func main(){
   
	str := "abc你好"
	for _,i := range str{
   
		fmt.Printf("%v=%c ",i,i)//97=a 98=b 99=c 20320=你 22909=好 
	}
}

字符串修改

需先将字符串转成[]rune或[]uint8(byte)，再转string，转换都会重新分配内存，并复制字节数组

func main(){
   
	s := "abc"
	s1 := []byte(s)
	fmt.Println(s1) //[97 98 99]
	fmt.Println(string(s1)) //abc
}

func main(){
   
	s := "你好"
	s1 := []byte(s)
	s2 := []rune(s)
	fmt.Println(s1)
	fmt.Println()
	fmt.Println(s2)
	fmt.Println()
	fmt.Println(string(s1))
	fmt.Println()
	fmt.Println(string(s2))
}
//结果
[228 189 160 229 165 189]

[20320 22909]

你好

你好

sprintf转str

转换需要主要格式：int=%d,float=%f,bool=%t,byte=%c

func main(){
   
	var a int = 5
	var b float32 = 12.12345
	var c bool = true
	var d byte = 'd'
	var f string

	f = fmt.Sprintf("%d",a)
	fmt.Printf("类型：%T,值:%v",f,f)
	fmt.Println()
	f = fmt.Sprintf("%f",b)
	fmt.Printf("类型：%T,值:%v",f,f)
	fmt.Println()
	f = fmt.Sprintf("%t",c)
	fmt.Printf("类型：%T,值:%v",f,f)
	fmt.Println()
	f = fmt.Sprintf("%c",d)
	fmt.Printf("类型：%T,值:%v",f,f)
}
//结果：
类型：string,值:5
类型：string,值:12.123450
类型：string,值