Go基础1

Posted 2022-06-20 骑着哈哥去旅行

目录

变量

声明变量

有名变量

匿名变量

常量

常量的声明及基本使用

iota

关于iota的面试题及使

基本数据类型

整形

特殊整形

数字字面量语法

浮点数

布尔型

 字符串

字符串转义

定义多行字符串

byte和rune类型

修改字符串

类型转换

fmt.Printf中的占位符

输出类型

---

Go是静态编译型语言 。Go和C语言类似，要先编译再执行，即编译型语言。Python、JavaScript等是动态解释型语言。 Go最大的优势：天生支持并发。

变量

Go语言中的变量必须先声明再使用，并且在此变量的整个生命周期内，此变量的类型不可以改变。

声明变量

Go语言中推荐使用驼峰式命名规范。

有名变量

单个变量的声明：

var s1 string  // 单个变量声明

多个变量同时的声明：

var (
	name string
	age int
	sex bool
)

package main

import "fmt"

// 单独声明变量(全局变量)
/*
var name string
var age int
var isOk bool
*/

// 批量声明变量类型(全局变量)
var (
	name string // ""
	age  int    // 0
	sex bool   // false
)

func main() 
	name = "hepengli"
	age = 18
	sex = true

	fmt.Print("You are young \\n")        // 打印完成直接结束（\\n表示换行）
	fmt.Printf("You are young:%s\\n", name) // %s表示格式化输出
	fmt.Println(age, sex)               // 打印完成自带换行


You are young 
You are young:hepengli
18 true

其他声明变量的方式:

package main

import "fmt"

func main() 
	var hobby string = "eating" // 声明变量同时赋值
	fmt.Println(hobby)

	var like = "sleeping" // 推导型声明变量（根据值判断该变量是什么类型）
	fmt.Println(like)

	st1 := "hpl" // 简短型声明变量(只能在函数中使用)
	fmt.Println(st1)



eating
sleeping
hpl

匿名变量

_(下划线)表示匿名变量，不会占用命名空间，不会为其分配内存地址

package main

import "fmt"

func foo() (int, string) 
	return 18, "hpl"


func main() 
	x, _ := foo() // _表示匿名变量，不会占用命名1空间，不会为其分配内存地址
	_, y := foo()

	fmt.Println("x =", x)
	fmt.Println("y =", y)

注意事项：

1. 函数外的每个语句都必须以关键字开始（var、const、func等）

2. :=不能在函数外面使用

3. _多表示占位，表示忽略值

4. 同一个作用域不能声明同名的变量名

注意：

Go语言中声明的局部变量必须要被使用，否则编译就会报错。

 例如错误如下：

package main

func main() 
	var hobby string



.\\变量.go:4:6: hobby declared but not used

常量

常量的声明及基本使用

package main

import "fmt"

// 常量，定义了常量之后就是不能变化的
const num = 3.14

// 批量的声明常量
const (
	num1 = 10
	num2 = 20
)

// 假如批量声明的常量后面没有赋值，则表示等于上一行变量值
const (
	num3 = 30
	num4
	num5
)

func main() 
	fmt.Println(num3, num4, num5)

	num6 := 666
	fmt.Println(num6)


30 30 30
666

iota

iota是Go语言中的常量计数器，只能在常量的表达式中使用。

iota在const关键字出现时将被重置为0，const中每新增一行常量声明将使iota计数一次（iota可以理解为const语句中的索引）。使用iota能简化定义，在定义枚举时很有用。

package main

import "fmt"

const (
	a1 = iota // 表示a1为0
	a2        // 1
	a3        // 2
	a4        // 3
)

func main() 
	fmt.Println(a1, a2, a3, a4)



0 1 2 3

关于iota的面试题及使

1. package main
   
   import "fmt"
   
   const (
   	a1 = iota // 表示a1为0
   	a2        // 1
   	_         // 2
   	a4        // 3
   )
   
   func main() 
   	fmt.Println(a1, a2, a4)
   
   

2. package main
   
   import "fmt"
   
   const (
   	a1 = iota // 表示a1为0
   	a2 = 100
   	a3 // 100
   	a4 // 100
   	a5 = iota
   	a6
   )
   
   func main() 
   	fmt.Println(a1, a3, a4, a5, a6)
   
   

3. package main
   
   import "fmt"
   
   // 多个常量声明在一行
   const (
   	a1, a2 = iota + 1, iota + 2
   	a3, a4 = iota + 1, iota + 2
   )
   
   func main() 
   	fmt.Println(a1, a2, a3, a4)
   
   

4. package main
   
   import "fmt"
   
   // 定义数量级
   const (
   	_  = iota             // 扔掉
   	KB = 1 << (10 * iota) // 左移（1*2^10）
   	MB = 1 << (10 * iota) // 1*2^20
   	GB = 1 << (10 * iota) // 1*2^30
   	TB = 1 << (10 * iota) // 1*2^40
   	PB = 1 << (10 * iota) // 1*2^50
   )
   
   func main() 
   	fmt.Println(KB, MB, GB, TB, PB)
   
   

基本数据类型

Go语言中有丰富的数据类型，整形、浮点型、布尔型、字符串、数组、切片、结构体、map、通道（channel）等。Go语言的基本数据类型和其他的语言基本大同小异。

整形

类型	描述
uint8	无符号的8位整型（0~255）
uint16	无符号的16位整型（0~65535）
uint32	无符号的32位整型（0~4294967295）
uint64	无符号的64位整型（0~18446744073709551615）
int8	有符号的8位整型（-128~127）
int16	有符号的16位整型（-32768~32767）
int32	有符号的32位整型（-2147483648~2147483647）
int64	有符号的64位整型（-92233720368644775808~92233720368644775807）

特殊整形

类型	描述
uint	32位操作系统上就是uint32，64位操作系统上就是uint64
int	32位操作系统上就是int32，64位操作系统上就是int64
uintptr	无符号整型，用于存放一个指针

注意： 在使用int和 uint类型时，不能假定它是32位或64位的整型，而是考虑int和uint可能在不同平台上的差异。

数字字面量语法

Go1.13版本之后引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字，例如：v := 0b00101101， 代表二进制的 101101，相当于十进制的 45。 v := 0o377，代表八进制的 377，相当于十进制的 255。 v := 0xff，代表十六进制的ff，也就是十进制的255。

package main

import "fmt"

func main() 
	a1 := 0b111 // 1*2^0 + 1*2^1 + 1*2^2 = 7
	a2 := 0o637 // 7*8^0 + 3*8^1 + 6*8^2 = 415
	a3 := 0xff  // 0b 1111 1111  ==> 255
	fmt.Println(a1)
	fmt.Println(a2)
	fmt.Println(a3)

浮点数

Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准： float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32。 float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64。

package main

import (
	"fmt"
	"reflect"
)

func main() 
	// math.MaxFloat32 // 浮点数32位1最大值
	f1 := 1.23 // Go中默认定义的是float64类型
	fmt.Print(f1, reflect.TypeOf(f1))


1.23 float64

注意：Go中默认定义的是float64类型 。

布尔型

Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。

注意：

1. 布尔类型变量的默认值为false。

2. Go 语言中不允许将整型强制转换为布尔型.

3. 布尔型无法参与数值运算，也无法与其他类型进行转换。

package main

import "fmt"

func main() 
	a1 := true
	var a2 bool // 布尔值默认为false

	fmt.Println(a1, a2)


true false

 字符串

注意：Go中的字符串必须用双引号，Go语言中的单引号表示为字符。

s := "hpl"  // 字符串

// 单独的字符、汉字、符号等就是一个字符
s1 := 'a'  // 字符
s2 := '和'  // 字符

字符串转义

转义符	含义
\\r	回车符（返回行首）
\\n	换行符（直接跳到下一行的同列位置）
\\t	制表符
\\'	单引号
\\"	双引号
\\\\	反斜杠

package main

import "fmt"

func main() 
	str1 := "D:\\\\Learning_notes\\\\note\\\\GO\\\\go基础"
	fmt.Printf("%#v\\n", str1)
	str2 := "'D:\\\\Learning_notes\\\\note\\\\GO\\\\go基础'"
	fmt.Println(str2)

     
"D:\\\\Learning_notes\\\\note\\\\GO\\\\go基础"
'D:\\Learning_notes\\note\\GO\\go基础'

定义多行字符串

package main

import "fmt"

func main() 
	s2 := `
		   静夜思
		   唐 李白
		  床前明月光，
		  疑似地上霜。
		  举头望明月，
		  低头思故乡。`
	fmt.Printf(s2)



		   静夜思
		   唐 李白
		  床前明月光，
		  疑似地上霜。
		  举头望明月，
		  低头思故乡。

注意：反引号中写什么就输出什么，不用担心转义问题。

方法	介绍
len(str)，len([]rune(str))，utf8.RuneCountInString(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.Index(),strings.LastIndex()	子串出现的位置
strings.Join(a[]string, sep string)	join操作

package main

import (
	"fmt"
	"strings"
)

func main() 
	name := "hepengli"
	hobby := "sleeping"
	fmt.Println(len(name)) // len()输出长度
	fmt.Println("xxx" + "yyy")
	s1 := fmt.Sprintf("%s%s", name, hobby) // 拼接并返回
	fmt.Println(s1)

	web := "www.baidu.com"
	ret := strings.Split(web, ".") // 切割 [www baidu com]
	fmt.Println(ret)

	res := strings.Contains(web, "ww")   // 判断web字符串中是否包含ww，包含返回true，不包含返回false
	res1 := strings.Contains(web, "xxx") // 判断web字符串中是否包含xxx，包含返回true，不包含返回false
	fmt.Println(res, res1)

	res2 := strings.HasPrefix(web, "ww")  // 判断字符串web是否是以ww开始的，是返回true，否则返回false
	res3 := strings.HasSuffix(web, "sss") // 判断字符串web是否是以sss结尾的，是返回true，否则返回false
	fmt.Println(res2, res3)

	sss := "Nice to meet you!"
	res4 := strings.Index(sss, "t") // 默认只获取第一个t所在的索引位置
	fmt.Println(res4)

	res5 := strings.LastIndex(sss, "t") // 返回最后一个t所在的索引位置
	fmt.Println(res5)

	res6 := strings.Join(ret, "+") // 用某种字符进行拼接
	fmt.Println(res6)


8
xxxyyy
hepenglisleeping
[www baidu com]
true false
true false
5
11
www+baidu+com

byte和rune类型

Go 语言的字符有以下两种：

1. uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。

2. rune类型，代表一个 UTF-8字符。

当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。

Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。

package main

import "fmt"

func main() 
	str1 := "Nice to meet you, 遇见你我也很高兴！"
	for i := 0; i < len(str1); i++ 
        fmt.Printf("%c", str1[i]) // 中文会乱码(%c输出单个字符)
	

	fmt.Println()

	for _, s := range str1 
		fmt.Printf("%c", s) // 中文不乱码
	


Nice to meet you, éè§ä½ æä¹å¾é«å´ï¼
Nice to meet you, 遇见你我也很高兴！

修改字符串

要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

package main

import "fmt"

func main() 
	s1 := "hepengli"
	bytes1 := []byte(s1) // 要先转换为[]byte
	bytes1[0] = 's'
	fmt.Println(string(bytes1))

	s2 := "hello你好"
	runes2 := []rune(s2) // 先转换为[]rune类型
	runes2[5] = '擦'
	fmt.Println(string(runes2))


sepengli
hello擦好

类型转换

Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

package main

import (
	"fmt"
	"reflect"
)

func main() 
	a1 := 222
	fmt.Println(reflect.TypeOf(a1))

	a2 := float64(a1)
	fmt.Println(reflect.TypeOf(a2))


int
float64

fmt.Printf中的占位符

package main

import "fmt"

// fmt中的占位符
func main() 
	num := 666
	str1 := "hpl"
	fmt.Printf("%T:输出数据类型\\n", num)
	fmt.Printf("%v:输出任何类型的值\\n", num)
	fmt.Printf("%b:输出二进制数据\\n", num)
	fmt.Printf("%o:输出八进制数据\\n", num)
	fmt.Printf("%d:输出十进制数据\\n", num)
	fmt.Printf("%x:输出十六进制数据\\n", num)
	fmt.Printf("%s:输出字符串\\n", str1)
	fmt.Printf("%#v:输出带描述符", str1)


int:输出数据类型
666:输出任何类型的值
1010011010:输出二进制数据
1232:输出八进制数据
666:输出十进制数据
29a:输出十六进制数据
hpl:输出字符串
"hpl":输出带描述符

输出类型

package main

import (
	"fmt"
	"reflect"
)

const a3 = 666

func main() 
	fmt.Println(reflect.TypeOf(a3))
    fmt.Printf("%T", a3)


int
int