golang学习记录----Golang变量&基础数据类型

Golang变量&基础数据类型

所有的学习记录都在 https://gitee.com/mslsy/golang_study

package main

import (
	"fmt"
	"strings"
)

var str string = "这是全局变量"

// 全局变量可以只定义不适用

func main() {
	// 变量
	fmt.Println("1.0 变量")

	// 变量分为全局变量个局部变量
	// 在函数外与import处于同级的的是全局变量，其他的都是局部变量
	// 变量可以在声明时赋值
	// var 变量名 类型 = 表达式   变量的定义并初始化的标准格式
	var str1 int8 = 20
	// 这是局部变量
	fmt.Println(str1, "这是局部变量，局部变量定义了必须使用")
	// 变量也可以先定义后赋值，变量定义后就具有初始值
	// 批量声明变量可以用()包裹
	var (
		int1   int8
		float1 float32
		str0   string = "这是声明的同时赋值的变量"
	)
	int1 = 10
	fmt.Println(str0, int1, float1)
	// 变量声明可以使用var关键字声明也可以使用类型推断的方式
	var str00 = "hello" // 这是类型推断的方式，不需要指定类型
	// 也可以使用短变量的方式声明并赋值
	str2 := "这是短变量的方式声明变量"
	fmt.Println(str00, str2)
	// 常量  一经声明后不能改变的变量
	// 常量使用const 关键字声明
	const (
		int2 uint = 100
	)
	fmt.Println(int2)
	// 当批量申明整数型常量时，可以使用iota关键字实现
	// iota 在每个 批量声明常量的 ()中会初始化值为0
	// 之后每行值+1
	// 当变量的类型和赋值不写时，默认和上一行一致
	const (
		int3 uint = iota
		int4
		_ // _ 是匿名变量，匿名变量中不会存储任何内容，在此处可以理解为跳过这次赋值
		int5
		int6
		int7
	)
	fmt.Println(int3, int4, int5, int6, int7) // 0 1 3 4 5
	// 常量 配合 iota 的枚举案例
	const (
		_  = iota
		KB = 1 << (10 * iota)
		MB = 1 << (10 * iota)
		GB = 1 << (10 * iota)
		TB = 1 << (10 * iota)
		PB = 1 << (10 * iota)
	)
	// << 是二进制按位移动
	fmt.Println(KB, MB, GB, TB, PB)

	// 注意: 一个变量只能声明一次
	// 2.0
	fmt.Println("基础数据类型")
	// 字符串 与 字符
	s := 'a' // ASCII

	str3 := "字符串" // 字符串
	fmt.Println(s, str3)
	// 字符 使用单引号包裹
	// 字符串是用双引号包裹
	// golang中，字符型有两种，byte 和 rune ，byte 是指 ASCII 值,rune 是 utf-8
	// byte 其实就是 uint8 类型，rune 其实就是uint32类型
	var s1 rune = '中'
	var s2 byte = 'A'
	fmt.Println(s1, s2)
	// 一个中文占3个位，一个英文占1位
	// 当字符串中存在中文时，需要使用这种方式遍历
	var str4 = "这是一串strings"
	for index, value := range str4 {
		fmt.Printf("索引%v,值%c\n", index, value)
	}
	// 字符串修改其中的某个字，需要将字符串转换成 rune 类型的切片，然后修改对应索引的值
	str_rune := []rune(str4)
	fmt.Println(str_rune)
	str_rune[0] = '那'
	fmt.Println(str_rune)
	fmt.Println(string(str_rune))
	// 字符串的操作
	// 转义
	str5 := "\n-->换行符 \r-->回车 \t-->制表符 \\ -->反斜杠 \"-->双引号"
	fmt.Println(str5)
	// 操作字符串的相关方法
	// 长度
	fmt.Println(len(str4))         // byte 数
	fmt.Println(len([]rune(str4))) // rune
	// 拼接 + 或者 fmt.Sprintf()
	fmt.Println(str4 + "拼接")
	var str4_ = fmt.Sprintf("%v%v%v", str4, "-", "拼接")
	fmt.Println(str4_)
	// 分割字符串
	str4_slice := strings.Split(str4_, "-")
	fmt.Println(str4_slice)
	// 以什么开头 和 以什么结尾
	is_start := strings.HasSuffix(str4, "s") // 以什么结尾
	is_end := strings.HasPrefix(str4, "这")   // 以什么开头
	fmt.Println(is_start, is_end)
	// 包含
	is_contain := strings.Contains(str4, "是")
	fmt.Println(is_contain)
	// 索引 取到的是 byte的索引
	idx := strings.Index(str4, "是")
	idx_byte := strings.IndexByte(str4, 's')
	idx_rune := strings.IndexRune(str4, '是')
	idx_func := strings.IndexFunc(str4, func(r rune) bool {
		if r == '是' {
			return true
		} else {
			return false
		}
	})
	fmt.Println(idx, idx_byte, idx_rune, idx_func)

	// 数字
	// 整型  浮点  复数
	fmt.Println("整型包括 有符号和无符号")
	fmt.Println("无符号 uint 包括uint8 uint16 uint32 uint64")
	fmt.Println("无符号 int 包括int8 int16 int32 int64")
	// int 在32位机器上是 int32 在64位机器上是 int64
	// 字面量语法
	v_2 := 0b101 // ob代表二进制
	v_8 := 0o77  // 0o代表八进制
	v_16 := 0xff // 0x 代表 十六进制
	vv := 20_369 // 允许使用 _ 分割数值
	vvv := 20 * 2
	fmt.Println(v_2, v_8, v_16, vv, vvv)
	// fmt 各个整型的类型 二进制 %b 八进制 %o 十进制 %d 十六进制 %x %x
	fmt.Printf("二进制 %b 八进制 %o 十进制 %d 十六进制 %x %X \n", v_2, v_8, vv, v_16, v_16)
	// 浮点数
	fmt.Println("浮点数只有两种 float32 和 float64")
	var float11 float32 = 20.02
	var float2 float64 = 20.02
	// fmt 中使用%f打印
	fmt.Printf("%f,%f\n", float11, float2)
	fmt.Printf("%.3f,%.10f\n", float11, float2)
	// 复数
	fmt.Println("复数只有两种complex64 和 complex128")
	// 复数有实部和虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。
	// 布尔值
	// 布尔值只有true和false
	var isTrue bool = false
	fmt.Println(isTrue)
	// 类型转换
	// 整型和浮点可以进行类型装换
	// 字符串和切片可以类型转换
	// 字符串和整型、浮点型不能类型转换
	var num = 20
	fmt.Println(float32(num))
	var num2 = 20.2
	fmt.Println(int(num2))
	// 类型转换时，必须是变量才能转

}