golang 基本类型02

淩亂°似流年 2022-12-04 08:34 146阅读 0赞

### 1.常量 ###

const (
    	ca = iota  //一个初始数字的函数，ca自动赋值0，cb=1,cc=2
    	cb
    	cc
    )
    
    func Value() {
    	/*
    		常量
    		const修饰，初始化就必须赋值，只能读不能修改
    		const 只能修饰boolean,number和string
    		用法 const identifer[type] = value //type可以不写
    	*/
    	const name = "helloworld"
    	const Pi = 3.1415926
    	const a = 9 / 3
    
    	//变量
    	fmt.Println(name, Pi, a)
    	fmt.Println(ca, cb, cc)
    
    	{
    		const (
    			c1, c2, c3 = iota, iota, iota //三个都是0
    			c4, c5, c6
    		)
    		fmt.Println(c1, c2, c3, c4, c5, c6) //0 0 0 1 1 1
    	}
    }

### 2.变量（类型转换） ###

package base
    
    import "fmt"
    
    type Player struct {
    	age     int32
    	address string
    }
    
    /*
    结构体的4种创建方式
    */
    func CreateStruct() {
    	//1
    	var player1 = Player{}
    	//2
    	player2 := Player{66, "ssss"}
    	//3
    	var player3 = new(Player)
    	//4
    	var player4 *Player = &Player{88, "mmmmm"}
    
    	fmt.Println(player1, player2, player3, player4)
    }
    
    /*
    %占位符使用（常用）
    */
    func SmShow() {
    	onePlayer := Player{66, "ssss"}
    	//%v	默认格式 {66 ssss}
    	//%+v	会添加字段名 {age:66 address:ssss}
    	//%#v	GO语法标送  base.Player{age:66, address:"ssss"}
    	//%T	值类型 base.Player
    	//%%	百分号
    	t := fmt.Sprintf("%v-%+v-%#v-%T-%%", onePlayer, onePlayer, onePlayer, onePlayer)
    	//%t	true或者false
    	t2 := fmt.Sprintf("%t", false)
    
    	//%s 字符串
    	//%d 十进制
    	//%o 八进制
    	//%x 十六进制 a-f
    	//%X 十六进制 A-F
    	//%f 带小数 （设置了精度会四舍五入） %0.2f 保留2位x小数
    	//%p 指针 十六进制，并在前面加上0x
    	fmt.Println(t, t2)
    	fmt.Printf("nps: %0.2f", 123456.658321) //这里是直接输出控制台
    }
    
    //全局变量（大写可以被其他包使用，小写只能本包使用）
    var (
    	r1 int    = 6
    	r2 string //默认""
    	r3 bool   //默认false
    	r4 string = "ssss"
    )
    
    /*
    局部变量
    */
    func value2() {
    	name := "helloworld"
    	Pi := 3.1415926
    	a := 9 / 3
    
    	//变量 := 只能在函数内使用
    	fmt.Println(name, Pi, a, r4)
    
    	var va int = 66
    	var vb int32 = int32(va)
    	fmt.Println("数字类型转换：", vb)
    
    	//变量交换，不用定义第三个变量
    	m := 1
    	n := 2
    	m, n = n, m
    	fmt.Println(m, n)
    }

### 3.值类型（函数内修改值类型变量） ###

/*
    	值类型：int, float, bool, string, 数组, struct
    	引用类型：指针, slice, map, chan
    	*/
    func value()  {
    	//函数内修改常用变量
    	var(
    		aC = 6
    		bC = 7
    	)
    	swap(aC,bC)
    	fmt.Println("没变",aC,bC)
    	swap2(&aC,&bC)
    	fmt.Println("改变",aC,bC)
    }
    
    func swap(a int, b int)  {
    	tmp := a
    	a = b
    	b = tmp
    }
    
    //可以通过特殊符号，修改传递 值类型变量
    func swap2(a *int, b *int)  {
    	tmp := *a
    	*a = *b
    	*b = tmp
    }

### 4.获取系统环境变量 ###

//获取系统环境变量
    func osValue(){
    	//设置一个环境变量
    	os.Setenv("GOOS","goos is ok!!!")
    
    	var goos = os.Getenv("GOOS")
    	path := os.Getenv("PATH")
    	fmt.Println("环境变量GOOS：",goos)
    	fmt.Println("环境变量PATH：",path)
    }

### 5、整数、浮点数、复数 ###

package base
    
    import (
    	"fmt"
    	"unsafe"
    )
    
    /*
    整数
    */
    func RunType() {
    	/*
    		有符号整数
    		int8	1	-2^7~2^7-1
    		int16	2	-2^16~2^16-1
    		int32	4	-2^31~2^31-1
    		int64	8	-2^63~2^63-1
    
    		无符号整数
    		uint8	0~2^8-1
    		uint16	0~2^16-1
    		uint32	0~2^32-1
    		uint64	0~2^64-1
    	*/
    
    	var num8 int8 = 66
    	//获取字节长度
    	length := unsafe.Sizeof(num8)
    	fmt.Println(num8, length)
    }
    
    /*
    浮点类型
    */
    func FValue() {
    	/*
    		float32	4
    		float64	8 默认类型
    	*/
    	floatValue := 3.1415926
    	floatValue2 := .123456 //会在前面自动补齐0
    	fmt.Printf("floatValue的类型=%T，字节大小%d", floatValue, unsafe.Sizeof(floatValue))
    	fmt.Println(floatValue2)
    
    	floatValue3 := .123456e4 //123456乘以10的4次方
    	floatValue4 := 123456e-4 //123456乘以10的-4次方
    	fmt.Println(floatValue3, floatValue4)
    }
    
    /*
    复数
    就是x轴y轴，x为实数，y为虚数
    */
    func RComplex() {
    	/*
    		complex64	32实数 + 32虚数
    		complex128	64实数 + 64虚数
    	*/
    	//创建
    	var complexValue1 complex64 = 3.14 + 12i
    	complexValue2 := complex(3.14, 12) //128
    	fmt.Printf("complexValue1的类型%T，值=%v\n", complexValue1, complexValue1)
    	fmt.Printf("complexValue2的类型%T，值=%v\n", complexValue2, complexValue2)
    
    	//获取实数，虚数
    	fmt.Println(real(complexValue2), imag(complexValue2))
    }