go语言输出hello word go语言输出数据类型

package main

import (
	"fmt"
	"math"
	"strings"
	"unsafe"
)

func main() {
	/*	Golang数据类型分为基本数据类型和复合数据类型
			基本数据类型有：整形、浮点型、布尔型、字符串类型
			复合数据类型有：数组、切片、结构体、函数、map、通道、接口等
			Go 语言支持两种浮点型：float32和float64,打印浮点数时使用%f进行格式化输出
			%f 默认保留6位小数；%.2f 表示保留2位小数。
			Go 语言中浮点数默认是float64类型。
			Go 语言中要定义一个多行字符串时，就必须使用反引号字符``这样可以按照你现有的格式进行输出。
			Go 字符串的常用操作：
			len(str) ：求长度
			+ 或 fmt.Sprintf : 都是拼接字符串
			strings.Split : 分割
			strings.contains : 判断是否包含
			strings.HasPrefix, strings.HasSuffix : 前缀/后缀判断
			strings.Index(), strings.LastIndex() : 子串出现的位置
			strings.Join(a[]string,sep string)	: join 操作
			byte 和 rune 类型：
			组成每个字符串的元素叫做字符，可以通过遍历字符串元素获得字符。字符用单引号包裹起来，如下所示：
			a := 'a'
			// 当我们直接输出byte字符的时候输出的是这个字符对应的码值。
			fmt.Println(a) // 97
			byte字符输出时使用 %c 进行格式化输出。
			fmt.Printf("%c---", a)
		字节byte：是计算机中数据处理的基本单位，习惯上用大写B来表示，1B(byte字节)=8bit（位）
		字符：是指计算机中使用的字母、数字、字和符号。
		一个汉字占用3个字节，一个字母占用一个字节。
		Go 语言的字符有以下两种：
		1. uint8 类型，或者叫byte 类型，代表了ASCII码的一个字符。
		2. rune 类型，代表一个UTF-8字符。
		当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。
		Go 使用了特殊的rune 类型来处理Unicode，让基于Unicode 的文本处理更为方便，也可以使用byte类型进行默认字符串处理，性能和扩展性都有照顾。
		3. rune类型实际是一个int32
		4. 修改字符串
		要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并赋值字节数组。实例如下：
		s1 := "big"
		// 强制类型转换
		byteS1 := []byte(s1)
		byteS1[0] = 'p'
		fmt.PrintLn(string(byteS1))









	*/
	var num int64
	num = 123
	num2 := int32(num)
	fmt.Printf("值：%v, 类型%T\n", num, num)
	fmt.Printf("值：%v, 类型%T\n", num2, num2)
	fmt.Printf("%f\n", math.Pi)
	fmt.Printf("%.2f\n", math.Pi)
	num3 := 1.1
	fmt.Printf("值：%v, 类型%T\n", num3, num3)
	d1 := 1129.6
	fmt.Println((d1 * 100))
	var d2 float64 = 1229.6
	fmt.Println((d2 * 100))
	fmt.Println((d2 - d1))
	var d3 = true
	fmt.Println(d3, "占用字节：", unsafe.Sizeof(d3)) // 结果是： true 占用字节： 1
	str := `中国万岁，
世界万岁，
家人万岁，
教育万岁。
`
	// len(str) 求字符串的长度
	var str2 = "This is str2 ******      "
	fmt.Println("长度是： ", len(str2))
	// strings.Split() 切割字符串
	fmt.Println(str)
	fmt.Println(strings.Split(str, "万岁"))
	// 拼接字符串
	str3 := "This is str3  拼接字符串"
	fmt.Println(str2 + str3)
	// 判断字符串是否包含
	var flag = strings.Contains(str3, "字符串")
	fmt.Println("判断1", flag) // true
	// 判断首字符和尾字母是否包含指定字符串
	var str4 = "this is golang"
	var flag2 = strings.HasPrefix(str4, "this")
	var flag3 = strings.HasSuffix(str4, "lang")
	fmt.Println("判断2", flag2)
	fmt.Println("判断3", flag3)
	// 判断字符串出现的位置
	var HeadIndex = strings.Index(str4, "is") // 从前往后判断
	fmt.Println("从前往后判断 is 出现的位置： ", HeadIndex)
	var EndIndex = strings.LastIndex(str4, "is") // 从后往前判断
	fmt.Println("从后往前判单 is 出现的位置： ", EndIndex)
	// Join 拼接字符串
	var str5 = "123-456-789"
	var arr1 = strings.Split(str5, "-")
	fmt.Println(arr1) // [123 456 789]
	var str6 = strings.Join(arr1, "*")
	fmt.Println(str6) // 123*456*789

	// 字符的输出
	// 组成每个字符串的元素叫做字符，可以通过遍历字符串元素获得字符。字符用单引号包裹起来，如下所示：
	a := 'a'
	b := 'o'
	// 当我们直接输出byte字符的时候输出的是这个字符对应的码值。
	fmt.Println(a) // 97
	fmt.Println(b) // 111
	fmt.Printf("%c--%c\n", a, b)
	// 一个汉字占用3个字节，一个字母占用一个字节
	color := "m"
	fmt.Println("长度是：", len(color)) // 长度是： 1
	rest := "张"
	fmt.Println("长度是：", len(rest)) // 长度是： 3

	// // 遍历字符串
	s := "hello 你好"
	// byte类型处理
	for i := 0; i < len(s); i++ {
		fmt.Printf("%v (%c) \n", s[i], s[i])
	}
	fmt.Println("***************************")

	s2 := "world 世界"
	// rune类型处理
	// 当需要处理中文、日文或者其他复合字符时，则需要用到rune 类型来处理，非常推荐。
	// rune类型，代表一个UTF-8字符。rune类型来处理Unicode，让基于Unicode的文本处理更为方便，
	// 也可以使用byte类型进行默认字符串的处理。
	for _, r := range s2 {
		fmt.Printf("%v (%c) \n", r, r)
	}
	// rune 类型实际是一个 int32
	C3 := "营"
	C4 := '营'
	fmt.Printf("C3 的类型%T------C4 的类型%T\n", C3, C4) // C3 的类型string------C4 的类型int32

	// 修改字符串的步骤：1. 先强制类型转换 （转换成[]byte()类型或者[]rune()类型）； 2.转换后根据下标重新赋值
	s1 := "big"
	// 强制类型转换
	byteS1 := []byte(s1)
	fmt.Printf("%v --- %c \n", byteS1, byteS1) // [98 105 103] --- [b i g]
	fmt.Println(byteS1)                        // 字符串转成byte后的结果： [98 105 103]
	byteS1[0] = 'p'
	fmt.Println("字符串转换后的结果： ", string(byteS1)) // 字符串转换后的结果：  pig

	S2 := "白萝卜"
	runeS2 := []rune(S2)
	//runeS2[0] = "红"	// 用这个双引号字符串类型的 "红" 就会直接报错 。
	runeS2[0] = '红' // 需要用这个单引号的字符类型的 '红' 。
	fmt.Println("字符串转换后的结果： ", string(runeS2))

	/*	上面执行的所有结果如下所示：

		PS C:\Users\Zhaoshan.lu\go\DaDi> go run .\05.go
		值：123, 类型int64
		值：123, 类型int32
		3.141593
		3.14
		值：1.1, 类型float64
		112959.99999999999
		122959.99999999999
		100
		true 占用字节： 1
		长度是：  25
		中国万岁，
		世界万岁，
		家人万岁，
		教育万岁。

		[中国 ，
		世界 ，
		家人 ，
		教育 。
		]
		This is str2 ******      This is str3  拼接字符串
		判断1 true
		判断2 true
		判断3 true
		从前往后判断 is 出现的位置：  2
		从后往前判单 is 出现的位置：  5
		[123 456 789]
		123*456*789
		97
		111
		a--o
		长度是： 1
		189 (½)
		***************************
		119 (w)
		111 (o)
		114 (r)
		108 (l)
		100 (d)
		32 ( )
		19990 (世)
		30028 (界)
		C3 的类型string------C4 的类型int32
		[98 105 103] --- [b i g]
		[98 105 103]
		字符串转换后的结果：  pig
		字符串转换后的结果：  红萝卜
		PS C:\Users\Zhaoshan.lu\go\DaDi>

	*/

}