第二章 变量 常量 字符串 匿名变量 iota 条件判断和for

目录

1.1变量

1.1.1 变量的定义

1.1.1.1 整形：

1.1.1.2 浮点数

1.1.2 变量的作用

1.4 常量

1.5 匿名变量

1.6 iota

1.7 类型转换

1.7.1 基本数据类型相互转换

1.7.2 和 string 的转换

1.7.2.1 字符串类型转化

1.7.2.2 比较

1.7.2.3 转义字符串

1.8 条件判断和for

1.8.1 if

1.8.2 for

1.8.2.1 for range

1.8.3 goto

1.8.4 switch

---

---

1.1变量

1.1.1 变量的定义

① 变量=变量名+值+数据类型

② Golang 的变量如果没有赋初值，编译器会使用默认值, 比如 int 默认值 0
        string 默认值为空串，小数默认为 0

③ 分类： ①全局变量         ②局部变量

④ 程序中 +号的使用：

        1) 当左右两边都是数值型时，则做加法运算
        2) 当左右两边都是字符串，则做字符串拼接

1.1.1.1 整形：

⑤ 整形的类型：

        1) 有符号和无符号

         2)Golang 的整型默认声明为 int 型

         3)bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。[二进制再详细说] 1byte = 8             bit

1.1.1.2 浮点数

 ① 浮点数都是有符号的

② Golang 的浮点型默认声明为 float64 类型

1.1.2 变量的作用

静态语言对于局部变量和全局变量的范围有着严格的限制

1.1.2.1 短变量声明法

username :=”张三”

短变量只能用于局部变量（在函数内部），不能用于全局变量声明

package main

import "fmt"

var name = "张三"
func main(){
	if name == "张三" {
		newname := "李四"
		fmt.Println(newname)
	}
	//fmt.Println(newname)
}

1.3 字符串

① Go 语 言 的 字 符 使 用 UTF-8 编 码， 如 果 想 查 询 字 符 对 应 的 utf8 码 值
        http://www.mytju.com/classcode/tools/encode_utf8.asp

② 英文字母-1 个字节汉字-3 个字节

③ 字符串拼接方式 用+号

package main
import "fmt"

func main(){
	var c byte //byte用于存放字符
	c = 'a'
	fmt.Printf("c=%c\n",c)

	var c2 rune //rune用于存放字符
	c2 = '慕'
	fmt.Printf("c2=%c\n\n",c2)

}

1.4 常量

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

package main

import "fmt"
//常量可以不用
func main(){
	const PI float32 = 3.1415926 //显示定义
	const PI2 = 3.1415926        //隐式定义
	const(
		a = 10
		a1=10
		b = "abc"
		b1 = "abc"
	)
	fmt.Println(a,a1,b,b1)
}

1.5 匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量

匿名用_表示

package main

import "fmt"

//匿名变量不能用于全局变量的定义
func a() (int,bool){
	return 0,false
}
func main(){
	var _ int //_为匿名变量。不想用就这样写
	_, ok := a()
	fmt.Println(ok)
}

1.6 iota

package main
import "fmt"

func main(){
	const (
		ERROR1 = iota
		ERROR2
		ERROR3
		ERROR4
		ERROR5 = "HH"
		ERROR6
		ERROR7 = 100
		ERROR8 = iota

	)
	const (
		err = iota
	)
	fmt.Println(ERROR1,ERROR2,ERROR3,ERROR4,ERROR5,ERROR6,ERROR7,ERROR8)
	fmt.Println(err)
}

1.7 类型转换

1.7.1 基本数据类型相互转换

   表达式 T(v) 将值 v 转换为类型 T
        T: 就是数据类型，比如 int32，int64，float32等等
        v: 就是需要转换的变量

	//int32=>float32
	var c int32 = 55
	var b =float32(c)

1.7.2 和 string 的转换

1.7.2.1 字符串类型转化

① int和字符串转换：

        strconv.Itoa         strconv.Atoi        

② 字符串转XX类型：（有bool类型返回值）

（s:字符串本身， base：为几进制，bitsize：一共多少位）

        strconv.ParseFloat        strconv.ParseInt        strconv.ParseBool

③ 基本类型转字符串：

（f为float参数（f不能加引号）， fmt为格式，prec = -1 选择最小的数据量,64位）

        strconv.FormatBool        strconv.FormatFloat        strconv.FormatInt

package main
import (
	"fmt"
	"strconv"
)

func main(){
//字符串转基本类型

	//int类型转为字符串类型
	var a int
	a = 12
	float0 := strconv.Itoa(a)
	fmt.Println(float0)

	//字符串类型转为int类型
	d, err :=strconv.Atoi("12")
	if err != nil {
		fmt.Println("失败")
	}
	fmt.Println(d)

	//字符串转换为float32
	float1, err :=strconv.ParseFloat("3.1415926", 32)
	if err != nil {
		fmt.Println("失败")
	}
	fmt.Println(float1)

	//字符串转换为int
	int1, err :=strconv.ParseInt("123", 10, 8)//(s:字符串本身， base：为几进制   bitsize：一共多少位)
	if err != nil {
		fmt.Println("失败")
	}
	fmt.Println(int1)

	//字符串转化为布尔类型
	bool1, err := strconv.ParseBool("true")
	if err != nil {
		fmt.Println("失败")
	}
	fmt.Println(bool1)
/*_______________________________________________
基本类型转字符串
_______________________________________________*/
	//布尔类型转化为字符串
	bool2 := strconv.FormatBool(true)
	fmt.Println(bool2)

	//float转化为字符串
	string2 := strconv.FormatFloat(3.1415926, 'f', -1, 64)
	//f为float参数（f不能加引号）， fmt为格式，prec = -1 选择最小的数据量,64位
	fmt.Println(string2)

	//int转化为字符串
	string3 := strconv.FormatInt(64, 16)
	fmt.Println(string3)
}

1.7.2.2 比较

package main
import (
	"fmt"
	"strings"
)

func main(){
	//字符串比较
	a := "hello"
	b := "bello"
	fmt.Println(a == b)
	fmt.Println(a > b)

	fmt.Println("-----------------------------")

	//关于字符串的操作
	str := "imooc-go工程师"
	//判断是否包含在str语句中
	fmt.Println(strings.Contains(str,"go"))

	//打印出该字符出现在该字符串多少次
	fmt.Println(strings.Count(str,"o"))

	//切掉该字符串并返回bool
	fmt.Println(strings.CutPrefix(str,"imooc"))

	//判断首尾
	fmt.Println(strings.HasPrefix(str,"imooc"))
	fmt.Println(strings.HasSuffix(str,"工程师"))

	//通过字符串分割
	fmt.Println(strings.Split(str,"-")) //拆分成切片，以-为条件进行拆分
	//Split用法：
	var str1 = "how do you do"
	var strSlice = strings.Split(str1," ")
	fmt.Println(strSlice) //[how do you do]

	//查找子串出现的位置
	fmt.Println(strings.Index(str,"go"))

	//子串替换
	fmt.Println(strings.Replace(str, "go","java",-1))//n=-1 指全部替换

	//大小写转换
	fmt.Println(strings.ToLower("HELLO WORLD"))
	fmt.Println(strings.ToUpper("abc"))

	//去掉首尾特殊字符（中间的去不掉）
	fmt.Println(strings.Trim("#hello # world#","#"))
}

1.7.2.3 转义字符串

字符串遍历，同时处理有中文的问题 r := []rune(str)

性能高：通过string.Builder进行拼接

        var SSS strings.Builder

        SSS.WriteString(XXX)

package main
import (
	"fmt"
	"strconv"
	"strings"
)

func main(){
//输出长度
	name := "imooc慕课"
	bytes := []rune(name) //
	fmt.Println(len(bytes)) //实际打印
	fmt.Println(len(name))
	name1 := "abcdef"
	fmt.Println(len(name1))
	name2 := "今天吃什么"
	fmt.Println(name2)
	bytes2 := []rune(name2)
	fmt.Println(len(bytes2))
//打印"号
	fmt.Println("hello\r\nworld")
	fmt.Println("go\"体系课\"")
	fmt.Println(`go"体系课"`) //这种用的多

//格式化输出
	var age = 18
	var address = "天津"
	var name3 = "张三"
	//①格式整齐
	fmt.Printf("姓名：%s，年龄：%d，地址：%s\r\n",name3, age, address)
	zong := fmt.Sprintf("姓名：%s，年龄：%d，地址：%s\r\n",name3, age, address)
	fmt.Println(zong)
	//②性能高
	//通过string的builder进行拼接
	var bulider strings.Builder
	bulider.WriteString("姓名：")
	bulider.WriteString(name3)
	bulider.WriteString("，年龄：")
	bulider.WriteString(name3)
	bulider.WriteString(strconv.Itoa(age))
	bulider.WriteString("，地址：")
	bulider.WriteString(address)
	//整体转化为字符串并赋值
	re := bulider.String()
	fmt.Println(re)
}

1.8 条件判断和for

1.8.1 if

package main
import ("fmt")

func main(){
	//if条件判断
	age :=16
	if age < 18 {
		fmt.Println("未成年")
	}else if age == 18{
		fmt.Println("刚好成年")
	}else{
		fmt.Println("成年")
	}
}

1.8.2 for

go 语言没有 while 和 do...while 语法，这一点需要同学们注意一下，如果我们需要使用类似其它语
言(比如 java / c 的 while 和 do...while )，可以通过 for 循环来实现其使用效果。

1.8.2.1 for range

for index, value :=range 名字 { e.g. 打印}     index为序号 不要就用_

package main

import (
	"fmt"
)

func main(){

	//乘法表
	for y := 1; y <= 9; y++ { // 先安排行列
		for x := 1; x <= y; x++ { //每一行几个元素
			fmt.Printf("%d×%d=%d ",x,y,x*y)
		}
		fmt.Println()
	}

	//100以内数相加
	var sum int
	for i :=1; i<=100; i++ {
		sum += i
	}
	fmt.Println(sum)

	//for range
	str := "imooc go"
	for index, value :=range str {
		fmt.Printf("%d ",index)
		fmt.Printf("%c\n", value)
	}

	不要序号
	//str4 := "imooc go"
	//for _, value3 :=range str4 {
	//	fmt.Printf("%c\n", value3)
	//}

	str2 := "慕课"
	str3 := []rune(str2)
	for i := 0; i < len(str3); i++ {
		fmt.Printf("%c\n", str3[i])
	}

}

1.8.3 goto

① goto尽量少用

② goto语句可以实现程序的跳转，使用场景最多的是程序错误的处理，也就是说当程序出现错误的时候统一跳转到相应的标签处

package main
import (
	"fmt"
	"time"
)

func main(){
	round :=0;
	for {
		time.Sleep(1*time.Second)
		round ++
		if round ==5 {
			continue //5这个数字不要了
		}
		fmt.Println(round)
		if round >10 {
			break
		}
	}
	for i := 0; i < 5; i++{
		for j := 0; j < 4; j++{
			if i == 2 {
				goto over
			}
			fmt.Println(i, j)
		}
	}
over:
	fmt.Println("over")
}

1.8.4 switch

golang 中的 case 语句块不需要写 break , 因为默认会有,即在默认情况下，当程序执行完 case 语
句块后，就直接退出该 switch 控制结构

package main
import "fmt"

func main(){
	day := "星期八"
	switch day {
	case "星期一": fmt.Println("day1")
	case "星期二": fmt.Println("day2")
	case "星期三": fmt.Println("day3")
	case "星期四": fmt.Println("day4")
	case "星期五": fmt.Println("day5")
	case "星期六": fmt.Println("day6")
	case "星期日": fmt.Println("day7")
	default: fmt.Println("出错")
	}

	score := 70
	switch score{
	case 60, 70, 80: fmt.Println("WOW")
	default:fmt.Println("出错")
	}
}

Type Switch：switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际指向的
变量类型(下面伪代码）

func add (a, b interface{}) interface{} {
switch a.(type) {
	case string:
		as, _ := a.(string)
		bs, _ := b.(string)
		return as + bs
	case int:
		ai, _ :=a.(int)
		bi, _ :=b.(int)
		return ai + bi
	case float64:
		af, _ :=a.(float64)
		bf, _ :=b.(float64)
		return af + bf
	default:
		panic("not supported type")

}