golang学习笔记-3
package main
import "fmt"
//编一个可执行的程序，必须 func main， main()入门函数
// go语言函数外的语句只能以关键字开头
var name = "哪吒"
var age int
//流程控制是一门语言的经脉
func main() {
//函数内部定义的变量必须使用
// age := 19
// if age > 18{
// fmt.Println("澳门首家线上赌场开业了")
// }else{
// fmt.Println("该写暑假作业了")
// }
if age := 19; age > 35 { //局部变量，作用域
fmt.Println("人到中年")
} else if age > 18 {
fmt.Println("青年")
} else {
fmt.Println("好好学习")
}
//golang只有for循环
for i := 0; i < 10; i++ {
fmt.Println(i)
}
//变种1
var i = 5
for ; i < 10; i++ {
fmt.Print(i)
}
//无限循环
// for {
// }
//for range 数组，切片，管道，map，字符串
//数组、切片、字符串返回索引和值， map返回键和值 3 通道 channel返回通道内的值
//Switch case
s := "hello 沙河"
for i, v := range s {
fmt.Printf("%d, %c\n", i, v)
}
for i := 1; i < 10; i++ {
for j := 1; j <= i; j++ {
fmt.Printf("%d*%d=%d\t", i, j, i*j)
}
fmt.Println()
}
//go install 先编译，后拷贝
//go语言文件基础语法
//.go 。go build -o "xxx.exe"
//多行注释
/*asdf*/
//变量，三种方式，1 var name string 2 name := 3 var name="沙河哪吒"
// 函数内部专属： name3 := "沙河小王子"
//匿名变量，哑元变量。 当有些数据必须有变量接收，又不使用它，用 _ 接收
//常量
const PI2 = 3.1415926
//两个要点
//1 iota在const关键字出现时将被重置为0 2 const中每新增一行常量声明，iota累加1
//整型，无符号整形 uint8,uint16,uint32,uint64
// 带符号整形 int8,int16,int32,int64
// int 具体是32 还是64 看操作系统
//upintptr 无符号整形，存放一个指针
//go语言中无法直接定义二进制数
var f1 = 1.214
fmt.Printf("%T\n", f1)
var f2 = float32(1.233)
fmt.Printf("%T\n", f2)
//浮点数 默认 float64
//byte rune 类型都是类型别名
for i := 0; i < 10; i++ {
if i == 5 {
break
}
fmt.Println(i)
}
fmt.Println("over")
for i := 0; i < 10; i++ {
if i == 5 {
continue
}
fmt.Println(i)
}
finger := 3
switch finger {
case 1:
fmt.Println("大拇指")
fallthrough
case 2:
fmt.Println("食指")
case 3:
fmt.Println("中指")
goto breakTag
case 4:
fmt.Println("无名指")
case 5:
fmt.Println("小拇指")
default:
fmt.Println("无效")
}
fmt.Println("sssssssssssssss")
breakTag:
fmt.Println("safdds")
//算术运算符
var (
a = 5
b = 2
)
fmt.Println(a+b, a*b, a-b, a%b, a/b)
a++ //单独的语句，不能放在=的右边赋值
b--
fmt.Println(a, b)
//关系运算符
fmt.Println(a == b, a > b, a < b, a != b, a<
var name, age = "jack", 22
if age > 18 && name != "jack" {
fmt.Println("苦逼上班的")
} else if age > 18 && name == "jack" {
fmt.Println("家里有矿")
} else {
fmt.Println("真羡慕他么爽，不用上班")
}
//not 取反，
var isMarried = false
fmt.Println(isMarried, !isMarried)
// 5: 101 2:10
fmt.Println(5&2, 5|2, 5^2, 5<<1, 1<<10, (1<<10)<<10)
var m = int8(1)
fmt.Println(m << 5)
// 192.168.1.1
//权限，
//赋值运算符，用来给变量赋值
var x int
x = 10
x += 1
x -= 1
x *= 2
x /= 2
x %= 2
x <<= 2
x &= 2
x |= 2
fmt.Println(x)
//复合数据类型，数组，类似容器，同一数据类型元素的集合，声明时确定，运行时可修改数组成员，数组大小不可变
//必须指定存放元素的类型和长度,数组的长度是数组类型的一部分
//var a1 [3]bool
//a1[0],a1[1],a1[2]=false,true,false
var a1 = [3]bool{true, true, false}
for i, v := range a1 {
fmt.Printf("%T,%v,%d\n", i, v, len(a1))
}
//数组的初始化,默认元素都是零值(false, 0, "")
fmt.Println(a1)
//初始值自动推断数组的长度
a100 := [...]int{0, 1, 2, 4, 12, 13, 14}
fmt.Println(len(a100))
//根据索引来初始化
a3 := [5]int{0: 1, 4: 2}
fmt.Println(a3)
city := [...]string{"北京", "上海", "深圳"}
for i := 0; i < len(city); i++ {
fmt.Println(city[i])
}
for i, v := range city {
fmt.Println(i, v)
}
//多维数组
//[[1,2,3],[2,3]]
//var a4 [3][2]int //三个元素，每个元素有2个数组
//**问题：**碰到golint 提示redundant type from array, slice, or map composite literal。
// 数组、切片或映射复合文字中的冗余类型。
a4 := [3][2]int{
// [2]int{1, 2},
// [2]int{3, 4},
// [2]int{5, 6},
0: {1, 2},
1: {3, 4},
2: {5, 6},
}
var foo = map[int][]int{
0: {1, 2},
1: {1, 2},
}
fmt.Println(a4)
//多维数组的遍历
for _, v1 := range a4 {
fmt.Println(v1)
for _, v2 := range v1 {
fmt.Println(v2)
}
}
for k, v := range foo {
fmt.Println("map", k, v)
}
//数组是值类型
b1 := [3]int{1, 2, 3}
b2 := b1 //ctrl+c, ctrl+v
b2[2] = 100
fmt.Println(b1, b2)
//数组支持 == != 操作符，因为内存总是被初始化过的
// [n]*T 表示指针数组， *[n]T表示数组指针
b3 := [...]int{1, 3, 5, 7, 8}
var count int = 0
for _, v := range b3 {
count += v
}
fmt.Println("count==", count)
valueI := 8
for i := 0; i < len(b3); i++ {
for j := i + 1; j < len(b3); j++ {
if b3[i]+b3[j] == valueI {
fmt.Printf("(%d,%d)\n", i, j)
}
}
}
//切片，slice
//数组的长度是固定的，是类型的一部分，有很多局限性。
//是一个拥有相同类型元素的可变长度的序列，属于数组类型做的一组封装，非常灵活，自动扩容
//引用类型，内部结构包含地址，长度，容量，用于快速的操作一块数据集合
var s1 []int //定义一个存放int类型元素的切片
var s2 []string
fmt.Println(s1, s2)
var c = []bool{false, true}
var s3 = []int{1, 2, 3}
var s4 = []string{"沙河", "张江", "平山村"}
fmt.Println(c, s3, s4, len(s4), cap(s4))
fmt.Println(s1 == nil, s2 == nil)
// s4=append(s4,"hello")
s5 := [...]int{1, 3, 5, 7, 9, 11, 13}
s6 := s5[:4] //基于一个数组切割，左闭右开
fmt.Println(s6)
fmt.Println(s5[1:], s5[:])
//切片的容量是指底层数组的容量
s7 := s5[:5]
s8 := s5[2:5]
//切片的容量底层数组从切片的第一个元素到最后的元素数量
fmt.Printf("len(s7):%d,cap(s7):%d,%v\n", len(s7), cap(s7), s7)
fmt.Printf("len(s8):%d,cap(s8):%d\n", len(s8), cap(s8))
//切片再切片
s9 := s7[4:]
fmt.Printf("len(s9):%d,cap(s9):%d,%v\n", len(s9), cap(s9), s9)
s10 := s5[3:]
s11 := s10[2:]
fmt.Printf("len(s11):%d,cap(s11):%d,%v\n", len(s11), cap(s11), s11)
//切片是个引用类型，都指向了底层的具体的一个数组
s5[6] = 1300 //修改了底层数组的值
fmt.Println("s10:", s10, "s11", s11)
fmt.Println("s")
//make函数创建切片
}
func arraySum(s [3]int) int {
sum := 0
for _, v := range s {
sum += v
}
return sum
}