lua 打印一段内存 打印内存地址

10.打印内存地址

先定义变量类型，再赋值，选择函数方法输出

package main

import "fmt"

func main() {
	var num int
	num = 100
	fmt.Printf("num:%d,内存地址：num:%p", num, &num)     //取地址符&+变量名

	num = 200
	fmt.Printf("num:%d,内存地址：num:%p", num, &num)    //%d是数字类型，%p是内存地址

}

输出结果为：
num:100,num:0xc00001c098num:200,num:0xc00001c098
不管变量怎么变化，内存地址保持不变

11. 变量交换

先定义变量，再交换

package main

import "fmt"

func main() {
	var a int = 100
	var b int = 200
	a, b = b, a
	fmt.Println(a, b)

}

输出结果为
200  100

12. 匿名变量

**匿名变量就是下划线"_",称为空白标识符， 任何赋给这个标识符的值都将被抛弃

定义一个test函数，返回两个int类型的值，每次调用都将返回100和200的值

package main

import "fmt"

func test() (int, int) {
	return 100, 200

}
func main() {
	a, _ := test()      //第一个值为返回值，第二个值为匿名变量

	fmt.Println(a)
}

输出结果为
100

13. 变量的作用域

一个变量在程序中都有一定的作用范围，称为作用域

1. 局部变量
   在函数方法里面作用
2. 全局变量
   在函数方法外面作用

输出时，根据就近原则，优先考虑局部变量进行输出

package main

import "fmt"

var name string = "world"			//这是全局变量，处于函数方法外

func main() {
	var name string = "hello"		//这是局部变量，处于函数方法内
	var age int = 18

	fmt.Println(name, age)			//输出根据就近原则，选择局部变量
}

输出结果为
hello 18

14. 常量

常量是一个简单值的标识符，在程序运行中，不会被改变的量
常量中的类型只可以是：布尔型，数字型（整数型，浮点型和复数型，字符串型）

package main

import "fmt"

func main() {
	const name string = "hello" //显示定义
	const name = "hello"        //隐式定义（可省略类型）
				//常量不可修改变化，否则会报错
	const age int = 18

	const a, b, c = 18, "hello", false
	fmt.Println(a, b, c)
}

输出结果为：
18 hello false

15. 常量iota

iota，是一个特殊常量，是一个可以被编译器修改的常量，是go语言的常量计数器
第一个iota值为0，每新增一行iota，值就增加1

package main
import (
	"fmt"
)
func main() {
	const (
		a = iota   			//0		iota0
		b				//1
		c				//2
		d				//3
		e = 100				//100		iota4
		f				//100		iota5
		g = "hello"			//"hello"	iota6
		h				//"hello"	iota7
		i = iota			//iota8
		j				//iota9
	)
	fmt.Println(a, b, c, d, e, f, g, h, i, j)
}

输出结果为：
0 1 2 3 100 100 hello hello 8 9

16.布尔类型

布尔型的值只可以是常量true或者false，bool是数据类型
例如：var flag bool

package main

import "fmt"

func main() {
	var flag bool = true				//布尔型的默认值为false
	fmt.Printf("%T,%t\n", flag, flag)		//%T是变量类型，%t\n是变量值
}

输出结果为：
bool,true

17. 数字类型

1. 整型

• 分为无符号uint（≥0），有符号int
• 主要类型有uint8（类似于byte,0-255），int64

package main

import "fmt"

func main() {
	var age byte = 1

	fmt.Printf("%T,%d\n", age, age)
	fmt.Println(age)

}

输出结果为 ：
uint8,1
1

2. 浮点型

• 主要类型有float64,float32

package main

import "fmt"

func main() {
	var money1 float64 = -129.0000091
	var money2 float32 = -129.0000091

	fmt.Printf("%T,%f\n", money1, money1) 		//在f前面加0.x可以限制小数
	fmt.Printf("%T,%f\n", money2, money2)

	fmt.Println("money1=", money1, "money2=", money2)
}

输出结果为：
float64,-129.000009
float32,-129.000015
money1= -129.0000091 money2= -129.00002

18.字符与字符串

1. 字符串

package main

import "fmt"

func main() {
	var name string
	name = "hello"
	fmt.Printf("%T,%s\n", name, name)		//%s\n表示字符串的值
}

输出结果为：
string,hello

2. 字符

package main

import "fmt"

func main() {
	name := 'A'						//单引号表示字符
	fmt.Printf("%T,%s\n", name, name)
}

输出结果为：
int32,%!s(int32=65)

显示结果为int32表示数字类型，而不是字符串，所以打印输出应为"%d\n"
输出结果应为：
int32,65

查询编码表
ASCII字符码√
中国字编码表GBK
全世界编码表Unicode编码表

65表示十进制

3. 字符串连接

package main

import "fmt"

func main() {
	fmt.Println("hello" + "world")
}

输出结果为：
helloworld

转义字符
\" \n \t 注意反斜杠

package main

import "fmt"

func main() {
	fmt.Println("hello\"world")

	fmt.Println("hello\nworld") 		//  \n表示换行

	fmt.Println("hello\tworld") 		//  \t表示制表符，就是间隔
}

输出结果为：
hello"world

hello
world

hello   world