golang-day01

一、Go定义变量、fmt包、Println和Printf的区别

1. 一次输入多个值的时候Println中间有空格但Print没有

package main

import "fmt"

func main() {
	// Print和Println区别
	// 一次输入多个值的时候Println中间有空格但Print没有
	fmt.Print("go", "python", "php", "javascript")
	
}

运行结果：

package main

import "fmt"

func main() {
	// Print和Println区别
	// 一次输入多个值的时候Println中间有空格但Print没有
	fmt.Println("go", "python", "php", "javascript")
}

 运行结果：

2. Println会自动换行，Print不会

package main

import "fmt"

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

  运行结果：

3. go语言中变量定义了必须使用

package main

func main() {
	var a = "aaa" //go语言中变量定义了必须使用
}

运行结果 

二、Go变量、常量声明、变量命名规则

1. var定义变量

var 变量名称 类型 = 表达式

var name string = "zhangsan"

2. 类型推导方式定义变量

a在函数内部，可以使用更简略的:=方式声明并初始化变量。

注意：短变量只能用于声明局部变量，不能用于全局变量的声明。

package main

import "fmt"

func main() {
	var a int = 3
	var b int = 8
	var c int = 5
	fmt.Println("a=", a, "b=", b, "c=", c)
    fmt.Printf("a=%v, b=%v, c=%v\n", a, b, c)
}

运行结果：

3. 利用短变量来定义变量

package main

import "fmt"

func main() {
	a := 10
	b := 20
	c := 30
	fmt.Printf("a=%v b=%v c=%v\n", a, b, c)
	//使用Printf打印一个变量的类型
	fmt.Printf("a=%v a的类型是%T\n", a, a)
}

 运行结果：

4. var定义多变量 

package main

import "fmt"

func main() {
	var a,b,c string
	c = "aaa"
	a = c
	b = a + c
	fmt.Println(a, b, c)
}

运行结果：

定义多变量的另外一种方式

package main

import "fmt"

func main() {
	var (
		a string
		b int
		c bool
	)
	a = "张三"
	b = 1
	c = true
	fmt.Print(a, b, c)
}

 运行结果：

5. Go语言中变量的命名规则

 Go语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。

 Go语言中关键字和保留字都不能用作变量名。

 Go语言中的变量需要声明后才能使用，同一作用域内不支持重复声明。并且Go语言的变量声明后必须使用。

  Go语言中变量的名字是区分大小写的，如age和Age是不同的变量。在实际的运用中，也建议不要用一个单词大小写区分两个变量。

  Go语言中变量命名一般采用驼峰式，当遇到特有名词(缩写或简称，如DNS)的时候，特有名词根据是否私有全部大写或者小写。

6. 匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量。匿名变量用一个下划线_表示。

package main

import "fmt"

func getUserinfo() (string, int) {
	return "zhang", 10
}

func main() {
	var a, _ = getUserinfo()
	fmt.Printf("a=%v", a)
}

7. 使用const定义常量

 相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。常量的声明和变量声明非常类似，只是把var换成了const，常量在定义的时候必须赋值

package main

import "fmt"

func main() {
	
	const pi = 3.1415926
	var r_dis float64 = 3.0
	var s_red float64 = pi * r_dis
	fmt.Println(s_red)
}

const同时声明多个常量时，如果省略了值则表示和上面一行的值相同 

package main

import "fmt"

func main() {
	const (
		pi = 3.1415926
		pl
		pd
	)
	var pi_dis float64 = pi * pl * pd
	fmt.Println(pi_dis)
}

8. const常量结合iota的使用

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

iota在const关键字出现时将被重置为0(const内部的第一行之前)，const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引) 

package main

import "fmt"

func main() {
	const (
		A = iota // A = 0
		B        // B = 1
		C        // C = 2
	)

	const (
		X = iota + 10 // X = 10
		Y             // Y = 11
		Z             // Z = 12
		N = iota
	)
	fmt.Println("A", A)
	fmt.Println("B", B)
	fmt.Println("C", C)
	fmt.Println("X", X)
	fmt.Println("Y", Y)
	fmt.Println("Z", Z)
	fmt.Println("N", N)
}

运行结果：
const结合iota定义多常量 

package main

import "fmt"

func main() {
	const (
		n1, n2 = iota + 1, iota + 2
		n3, n4
		n5, n6
	)
	fmt.Println(n1, n2, n3, n4, n5, n6)
}

运行结果：

三、Go语言基本数据类型

1. Golang数据类型介绍

基本数据类型有：整型、浮点型、布尔型、字符型

复合数据类型有：数组、切片、结构体、函数、map、通道(channel)、接口等。

2. 布尔类型

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

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

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

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

package main

import "fmt"

func main() {
	var flag = true
	fmt.Printf("%v的类型是%T\n", flag, flag)
}

3. 字符串类型 

Go语言中要定义一个多行字符串时，就必须使用反引号字符:

package main

import "fmt"

func main() {
	str1 := `this is str1
	this is str2
	this is str3
	`
	fmt.Println(str1)
}

运行结果：

 4. 字符串的常用操作

方法	介绍
len(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.index(),strings.LastIndex()	子串出现的位置
strings.Join(a[]string, sep string)	join操作
strings.Index(s, sep)	查找子串 sep 首次出现的位置（从左向右搜索）
strings.LastIndex(s, sep)	查找子串 sep 最后一次出现的位置（从右向左搜索

package main

import (
	"fmt"
	"strings"
)

func main() {
	str1 := "123-456-789"
	arr := strings.Split(str1, "-")
	fmt.Printf("%v 的类型是 %T\n", arr, arr)
	arr_len := len(str1)
	fmt.Printf("str1 的长度为%v\n", arr_len)
	is_contain := strings.Contains(str1, "123")
	fmt.Printf("is_contain是否包含123为%v\n", is_contain)
	front_contain := strings.HasPrefix(str1, "123")
	behind_contain := strings.HasSuffix(str1, "789")
	fmt.Printf("front_contain前缀是否包含123为%v\nbehind_contain后缀是否包含789为%v\n", front_contain, behind_contain)
	str2 := strings.Join(arr, "*")
	fmt.Printf("切片数组合成字符串%v\n", str2)
	front_index := strings.Index(str1, "-")
	behind_index := strings.LastIndex(str1, "-")
	fmt.Printf("获取str1中-的索引值为front_index为%v,获取str1中-的索引值为behind_index为%v\n", front_index, behind_index)
}

运行结果：

5. byte类型和rune类型

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

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

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

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var str = "this"
	fmt.Printf("值：%v 原样输出%c 类型：%T 占用多少字节：%v\n", str[2], str[2], str[2], unsafe.Sizeof(str))
}

运行结果：

通过循环输出字符串里的字符

package main

import "fmt"

// 通过循环输出字符串里面的字符
func main() {
	str1 := "hello golang!"
	for i := 0; i < len(str1); i++ {
		fmt.Printf("输出的字符为：%c\n", str1[i])
	}
}

 6. 修改字符串

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

package main

import "fmt"

// 通过循环输出字符串里面的字符
func main() {
	s1 := "bin"
	// 强制类型转换
	byteS1 := []byte(s1)
	byteS1[0] = 'p'
	fmt.Println(string(byteS1))

	s2 := "白萝卜"
	runeS2 := []rune(s2)
	runeS2[0] = '红'
	fmt.Println(string(runeS2))
}

运行结果：