E:\project\GOproject\code.oldboyedu.com\day1>SET CGO_ENABLE=0

E:\project\GOproject\code.oldboyedu.com\day1>SET GOOS=linux

E:\project\GOproject\code.oldboyedu.com\day1>SET GOARCH=amd64

E:\project\GOproject\code.oldboyedu.com\day1>go build

package main

//导入的包
import "fmt"

//程序的入口函数
//函数外部只能放置标识符（变量、常量、函数、类型）的声明
func main() {
   fmt.Println("hello world")
}

package main

import "fmt"

var name string
var age int
var isOk bool

//批量声明
var (
	name1 string
	age1 int
	isOk1 bool
)
func main() {
	fmt.Println(name1)
	fmt.Println(age1)
	fmt.Println(isOk1)

	name1 = "linjianshu"
	age1 = 16
	isOk1 = true

	//go语言中推荐使用驼峰命名
	//go语言中非全局变量声明必须使用，不用就编译不过去
	fmt.Println(name1)
	fmt.Println(age1)
	fmt.Println(isOk1)
	fmt.Printf("name:%s",name1)  //%s占位符，使用name1这个变量去替换这个占位符

	//声明变量同时赋值
	var studentName string = "ljs"
	//类型推导
	var studentName1  = "ljs"
	fmt.Println(studentName)
	fmt.Println(studentName1)
	//简短变量声明 :=  只能在函数里面使用
	studentName2 := "jwt"
	fmt.Println(studentName2)

	x,_ :=foo()
	fmt.Println(x)

	x1 := 0
	x1,_ =foo()
	fmt.Println(x1)

}

func foo() (int, string) {
	return 10,"ljs"
}

package main

import "fmt"

//常量
const pi = 3.1415926
//常量定义了之后不能修改
//在程序运行期间不会改变

//批量声明常量时，如果某一行没有赋值，默认就和上一行一致
const (
	pi1 = pi
	pi2
	pi3
)

const (
	i1 = iota
	i2
	i3
)

const (
	n1 = iota
	n2
	_
	n3
)

//插队
const (
	k1 = iota
	k2 = 100
	k3
	k4 =iota
	k5
)

const (
	p1,p2 = iota+1,iota+2
	p3,p4 = iota+1,iota+2
)

//定义数量级
const (
	_ = iota
	KB = 1<<(10 * iota)
	MB = 1<<(10 * iota)
	GB = 1<<(10 * iota)
	TB = 1<<(10 * iota)
)

func main() {
	// 不可以 pi = 12.3
	fmt.Println("pi2:",pi2)

	fmt.Println("i1:",i1)
	fmt.Println("i2:",i2)
	fmt.Println("i3:",i3)

	fmt.Println("n1:",n1)
	fmt.Println("n2:",n2)
	fmt.Println("n3:",n3)

	fmt.Println("k1:",k1)
	fmt.Println("k2:",k2)
	fmt.Println("k3:",k3)
	fmt.Println("k4:",k4)
	fmt.Println("k5:",k5)

	fmt.Println("p1:",p1)
	fmt.Println("p2:",p2)
	fmt.Println("p3:",p3)
	fmt.Println("p4:",p4)

	fmt.Println("kb:",KB)
	fmt.Println("mb:",MB)
	fmt.Println("gb:",GB)
	fmt.Println("tb:",TB)
}

package main

import "fmt"

func main() {
	 i1  := 10
	fmt.Printf("%d\n",i1)
	fmt.Printf("%o\n",i1)   //把十进制转成8进制
	fmt.Printf("%b\n",i1)   //把十进制转成2进制
	fmt.Printf("%x\n",i1)   //把十进制转成16进制

	 //八进制
	 i2 := 077
	 fmt.Printf("%d\n",i2)
	 //十六进制
	 i3:= 0x123
	 fmt.Printf("%d\n",i3)

	 fmt.Printf("%T\n",i1)

	 //声明一个int8类型的 要明确指定类型，都则就是int类型
	 i4:= int8(9)
	 fmt.Println(i4)
}

package main

import "fmt"

//float
func main() {
	//maxFloat32 := math.MaxFloat32 最大值
	f1:=1.23
	//默认go语言中的小数都是float64类型
	fmt.Printf("%T\n",f1)

	//显式声明float32类型
	f2:=float32(1.23)
	fmt.Printf("%T\n",f2)

	f1 = float64(f2) //不能隐式转换

}

package main

import "fmt"

func main() {
	//布尔值
	b:=true
	var b1 bool = false
	fmt.Printf("%v",b)
	fmt.Println()
	fmt.Printf("%v",b1)
	fmt.Println()
	fmt.Printf("Type:%T,Value:%v",b,b)
}

package main

import "fmt"

func main() {
	//fmt占位符 %s %d %x %o %b %T %v

	i :=2
	fmt.Printf("%T\t",i)
	fmt.Printf("%v\t",i)
	fmt.Printf("%b\t",i)
	fmt.Printf("%d\t",i)
	fmt.Printf("%o\t",i)
	fmt.Printf("%x\t",i)

	s:="linjianshu"
	fmt.Printf("%s\t",s)
	fmt.Printf("%v\t",s)
	fmt.Printf("%#v\t",s)
}

//字符串
s:="hello ljs"
//单独的字母、汉字、符号表示一个字符
c1 := 'h'
c2 := '1'
c3 := '啥'
//字节：1字节=8Bit（8个二进制位）
//一个字符 'A' = 1个字节
//一个utf8编码的汉字‘啥’ = 一般占3个字节

package main

import "fmt"

func main() {
	//fmt占位符 %s %d %x %o %b %T %v

	i :=2
	fmt.Printf("%T\t",i)
	fmt.Printf("%v\t",i)
	fmt.Printf("%b\t",i)
	fmt.Printf("%d\t",i)
	fmt.Printf("%o\t",i)
	fmt.Printf("%x\t",i)

	s:="linjianshu"
	fmt.Printf("%s\t",s)
	fmt.Printf("%v\t",s)
	fmt.Printf("%#v\t",s)
}

s:= `
	a
	b
	c
`

len(str) 求长度
+或者fmt.Strintf  拼接字符串
strings.Split  分割
strings.contains  判断是否包含
strings.HasPrefix, strings.HasSuffx  前缀、后缀判断
strings.Index(), strings.LastIndex  子串出现的位置
strings.Join(a[] string , sep string)  join操作

package main

import (
	fmt "fmt"
	"strings"
)

func main() {
	path := "\"C:\\Users\\Sweetie\\Desktop\\车间级MES\""
	fmt.Printf("%s\t" , path)

	s := `
	世情薄
	人情恶
	雨送黄昏花易落
`
	fmt.Printf("%s\r",s)
	s3:=`C:\Users\Sweetie\Desktop\车间级MES`
	fmt.Printf("%s\n",s3)

	//字符串相关操作
	fmt.Printf("%d\n",len(s3))

	//字符串拼接
	name := "ljs"
	world := "shuaibi"
	describtion := name+world
	fmt.Printf("%v\n",describtion)
	describtion1 := fmt.Sprintf("%s%s",name,world)
	fmt.Printf("%s\n",describtion1)

	//分割
	s1 := strings.Split(s3,"\\")
	fmt.Println(s1)
	for i := 0; i < len(s1); i++ {
		fmt.Println(s1[i])
	}

	//包含
	fmt.Println(strings.Contains(describtion, name))
	fmt.Printf(" '%s' Contains '%s' ? result:%v",describtion1,name,strings.Contains(describtion, name))
	fmt.Println()
	//前缀、后缀
	fmt.Println(strings.HasPrefix(describtion, "ljs"))
	fmt.Println(strings.HasSuffix(describtion, "shuaibi"))

	//索引 查找
	s4:="abcdeb"
	fmt.Println(strings.Index(s4,"b"))
	fmt.Println(strings.LastIndex(s4,"b"))

	//拼接
	var sJoin = strings.Join(s1,"+")
	fmt.Println(sJoin)
}

package main

import (
	"fmt"
	"strings"
)

func main() {

	//if 条件判断
	age:=19
	if age>18 {
		fmt.Println("性感荷官在线发牌")
	}else {
		fmt.Println("好好学习，以后赌博")
	}

	if age >= 35 && age < 80 {
		fmt.Println("人到中年，不得不服")
	}else if age > 18 {
		fmt.Println("年轻力壮，不怕困难")
	}else {
		fmt.Println("好好学习，少吃点苦")
	}

	if name := "linjianshu"; strings.Contains(name, "lin") {
	fmt.Println("确实确实")
}else {
	fmt.Println("不敢不敢")
	}	
}

if 条件 {
    
}
else if 条件{
    
}
else
{
    
}

	for i := 0; i < 10; i++ {
		fmt.Println(i)
	}

	i:=5
	for ; i <10 ; i++ {
		fmt.Println(i)
	}
	fmt.Println(i)

	var i1 = 3
	for i1<10  {
		fmt.Println(i1)
		i1++
	}

	for	{
		fmt.Println("hello world")
		break
	}

	for i, v := range "hello world" {
		fmt.Printf("index:%d\t,value:%c\n",i,v)
	}

	s:="hello world"
	for i, _ := range s {
		fmt.Printf("index:%d\t,value:%c\n",i,s[i])
	}

	//哑元变量，不想用到的都直接给_
	for _, v := range s {
		fmt.Printf("%c\n",v)
	}

	for i := 1; i <10 ; i++ {
		for j := 1; j <=10-i ; j++ {
			fmt.Printf("%d x %d = %d\t" , i , j , i*j)
		}
		fmt.Println()
	}

	for i := 1; i < 10; i++ {
		for j := i; j >0; j-- {
			fmt.Printf("%d x %d = %d\t" , i,j,i*j)
		}
		fmt.Println()
	}

package main

import (
	"fmt"
)

func main() {
	score:=68
	switch score {
	case 68:
		fmt.Println("及格")
	default:
		fmt.Println("未知")
	}

	//简化代码 作用域问题
	switch  i:=3 ;i{
	case 1:
		fmt.Println("wumingzhi")
	case 2:
		fmt.Println("zhongzhi")
	case 3:
		fmt.Println("damuzhi")
	}

	//同时声明几种情况
	switch i:=10;i{
	case 1, 3, 5, 7, 9:
		fmt.Println("this is 奇数")
	case 2, 4, 6, 8, 10:
		fmt.Println("this is 偶数")
	}

	score1:=68
	switch  {
	case score1>60&&score1<=100:
		fmt.Println("及格")
	case score1<60:
		fmt.Println("挂了呀")
	}
}

package main

import "fmt"

func main() {
	flag:=false
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j==2 {
				flag = true
				break
			}
			fmt.Printf("%d-%d\n",i,j)
		}
		if flag {
			break
		}
	}


	//for i := 0; i < 10; i++ {
	//	for j := 0; j < 10; j++ {
	//		if j == 2 {
	//			goto breakTag
	//		}
	//		fmt.Printf("%v-%v\n",i,j)
	//	}
	//}
	//return

	//breakTag:
	//	fmt.Println("结束for循环")
}

package main

import "fmt"

func main() {

	//运算符
	var(
		a=5
		b=2
	)

	//算术运算符
	fmt.Println(a+b)
	fmt.Println(a-b)
	fmt.Println(a*b)
	fmt.Println(a/b)
	fmt.Println(a%b)
	a++ //单独的语句，不能放在=的右边赋值
	b++


	//关系运算符
	fmt.Println(a==b) //go语言是强类型，相同类型的变量才能比较
	fmt.Println(a!=b)
	fmt.Println(a>b)
	fmt.Println(a<b)

	age:=22
	if age > 18 && age < 60 {
		fmt.Println("上班族")
	}else {
		fmt.Println("不用上班")
	}

	if age > 60 || age < 18 {
		fmt.Println("不用上班")
	}else  {
		fmt.Println("上班族")
	}


	//not取反
	b2:=true
	fmt.Println(!b2)

	//位运算：针对的是二进制数
	//5的二进制表示 101
	//2的二进制表示 010
	//按位与
	fmt.Println(101&010)
	fmt.Println(5&2)
	//按位或
	fmt.Println(101|10)
	fmt.Println(5|2)
	//^按位异或
	fmt.Println(101^010)  //这个有点奇怪 这个是109答案？？？
	fmt.Println(5^2)

	//左移右移运算 *2 和 \2
	fmt.Println(5<<2)  //101=>10100
	fmt.Println(1<<10)
	fmt.Println(5>>1) //101=>10

	//注意别溢出了
	m:=int8(1)
	fmt.Println(m<<10)
	fmt.Println(1<<2+1)

	//192.168.1.1
	//权限 文件操作会将位运算实际的应用
	//0644
	//赋值运算符，用来给变量赋值的
	var x int
	x = 10
	fmt.Println(x)
	x+=1
	fmt.Println(x)
	x-=1
	fmt.Println(x)
	x*=2
	fmt.Println(x)
	x/=2
	fmt.Println(x)
	x<<=2
	fmt.Println(x)
	x>>=2
	fmt.Println(x)
	fmt.Printf("%b",x)
	fmt.Println()
	x&=2
	fmt.Println(x)
	fmt.Printf("%b",x)
	x|=2
	x<<=2
	x>>=2
	x^=2
}

package main

import "fmt"

func main() {
	//数组
	//存放元素的容器
	//必须指定存放的元素的类型和容量（长度）
	//数组的长度是数组类型的一部分 也就是尽管类型一致但是长度不一致也不是同一个数组类型
	var a1 [3]bool
	var a2 [4]bool
	fmt.Printf("a1:type%T, a2:type%T",a1,a2)
	fmt.Println()

	//数组的初始化
	//如果不初始化：默认元素都是零值(布尔值就是false，整型和浮点型都是0，字符串就是“”)
	fmt.Println(a1,a2)
	//1.初始化方式1
	b1 :=[3]bool{true,true,true}
	fmt.Println(b1)
	//2.初始化方式2 根据初始值自动推断数组的长度是多少
	b2 :=[...]int{1,3,4,2,6,2,73,12}
	fmt.Println(b2)
	fmt.Println(len(b2))
	//3.初始化方式3 根据索引初始化
	b3:=[5]int{1,2}
	fmt.Println(b3)
	b3=[5]int{0:1,4:2}
	fmt.Println(b3)

	//数组的遍历
	citys :=[...]string{"北京","上海","深圳"}
	//1.for range
	for _, v := range citys {
		fmt.Println(v)
	}

	for i, _ := range citys {
		fmt.Println(citys[i])
	}

	//2.根据索引遍历
	for i := 0; i < len(citys); i++ {
		fmt.Println(citys[i])
	}

	//多维数组
	c1:=[3][2]int{0:[2]int{2,3},1:[2]int{4,5}}
	fmt.Println(c1)
	c2:=[3][2]int {{1,2},{3,4}}
	fmt.Println(c2)

	//多维数组的遍历
	//var b11:=[2][3]string{{"a","b","c"},{"d","e","f"}}
	//可以这么记 go语言中 实际数组展示使用空格来区分的，但是声明的时候需要用逗号隔开
	for _, v := range c1 {
		fmt.Println(v)
		for _, v1 := range v {
			fmt.Printf("%d ",v1)
		}
		fmt.Println()
	}

	for i := 0; i < len(c2); i++ {
		fmt.Println(c2[i])
		for j := 0; j < len(c2[j]); j++ {
			fmt.Printf("%d ",c2[i][j])
		}
		fmt.Println()
	}

	//数组是值类型
	d1:=[...]int{1,2,3}
	d2:=d1
	d2[0]=100
	fmt.Println(d1)
	fmt.Println(d2)

	//练习
	e:=[...]int{1,3,5,7,8}
	sum:=0
	for _, v := range e {
		sum+=v
	}
	fmt.Println(sum)

	for i, _ := range e {
		for j := i+1; j < len(e); j++ {
			if e[i]+e[j] == 8 {
				fmt.Printf("(%d %d)",i,j)
				break
			}
		}
		fmt.Println()
	}
}

var name []T 

package main

import "fmt"

func main() {
	//切片的定义
	var s1 []int //定义一个存放int类型元素的切片
	var s2 []string
	fmt.Println(s1,s2)
	fmt.Println(s1==nil)
	fmt.Println(s2==nil)
	//初始化
	s1 = []int{1,2,3}
	s2 = []string{"沙河","张江","平山村"}
	fmt.Println(s1,s2)
	fmt.Println(s1==nil)
	fmt.Println(s2==nil)
	//长度和容量
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1))
	fmt.Printf("len:%d,cap:%d\n", len(s2), cap(s2))

	//2.由数组定义切片
	a :=[]int{1,3,5,7,9,11,13}
	fmt.Println(cap(a))
	b :=a[1:4]  //[3 5 7] 左闭右开 基于一个数组进行切割
	fmt.Println(b)
	b1 :=a[:4]  //0-4
	fmt.Println(b1)
	b2 :=a[2:]  //
	fmt.Println(b2)
	b3 :=a[:]
	fmt.Println(b3)

	//切片的长度就是元素的个数，切片的容量就是底层数组从切片第一个元素到最后一个元素的数量
	fmt.Println(len(b),cap(b))
	//3.切片再切片
	b4:=b[1:2] //[5 7] 但是b的容量已经是6了 这时候切的b从第一位切起 那么容量应该是5
	fmt.Println(b4, len(b4), cap(b4))
	fmt.Println(b)
	a[2] = 10
	//这里说明了切片是引用类型，都指向了底层的数组，修改了底层数组，那么上层的切片值肯定会变化
	fmt.Println(b)
	fmt.Println(b4)
}

make([]T , size ,cap)

package main

import "fmt"

func main() {
	//make函数创造切片
	s1:=make([]int,3,10)
	fmt.Printf("s1=%v,len(s1)=%d,cap(s1)=%d,s1==nil?:%v\n",s1,len(s1),cap(s1),s1==nil)

	var s2 []int
	fmt.Printf("s2=%v,len(s2)=%d,cap(s2)=%d,s2==nil?:%v\n",s2,len(s2),cap(s2),s2==nil)

	s3:=[]int{}
	fmt.Printf("s3=%v,len(s3)=%d,cap(s3)=%d,s3==nil?:%v\n",s3,len(s3),cap(s3),s3==nil)

	s4:=make([]int,0)
	fmt.Printf("s4=%v,len(s4)=%d,cap(s4)=%d,s4==nil?:%v\n",s4,len(s4),cap(s4),s4==nil)

	//切片的赋值
	s5:=[]int {1,3,5,7}
	s6:=s5 //s5 和 s6都指向了同一个底层数组
	fmt.Println(s5,s6)
	s5[0]=100
	fmt.Println(s5,s6)

	//切片的遍历
	//1.索引遍历
	for i := 0; i < len(s5); i++ {
		fmt.Printf("%d ",s5[i])
	}
	fmt.Println()
	//2.forrange遍历
	for _, v := range s5 {
		fmt.Printf("%d ",v)
	}
}

package main

import "fmt"

func main() {
	//append 为切片追加元素
	s1:=[]string{"北京","上海","深圳"}
	fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n",s1,len(s1),cap(s1))
	//s1[3] = "广州" //错误的写法 会导致编译错误：索引越界

	//调用append函数必须使用原来的切片变量接收返回值
	s1= append(s1, "广州") //append追加元素 原来的底层数组放不下的时候 go底层就会把底层数组换一个
	//必须用变量接收append的返回值
	fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n",s1,len(s1),cap(s1))
	s1 = append(s1,"杭州","成都")
	fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n",s1, len(s1), cap(s1))
	s2:=[]string{"武汉","西安","苏州"}
	s1 = append(s1,s2...) //...表示拆开
	fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n",s1, len(s1), cap(s1))
}

copy (destSlice , srcSlice[] T)

package main

import (
	"fmt"
)

func main() {
	a1:=[]int {1,3,5}
	a2:=a1
	var a3=[]int{}  //这样声明没办法复制进去
	var a4 []int	//这样声明也没办法复制进去
	var a5=make([]int,len(a1), cap(a1))
	copy(a3,a1)
	copy(a4,a1)
	copy(a5,a1)
	fmt.Println(a1,a2,a3,a4,a5)

	a1[0] = 100
	fmt.Println(a1,a2,a3,a4,a5)

	//删除第二个元素
	a5 = append(a5[:1],a5[2:]...)
	fmt.Println(a5)
	fmt.Println(cap(a5))


	//验证
	//1.切片不保存具体的值
	//2.切片对应一个底层数组
	//3.底层数组都是占用一块连续的内存
	x1:=[...]int{1,3,5}  //数组
	x2:=x1[:]   //切片 切片指向底层数组
	fmt.Println(x2,len(x2),cap(x2))
	fmt.Printf("%p\n",&x1[0])
	x2 = append(x1[:1],x1[2:]...) //切片截取底层数组 重新定义了底层数组的索引的值
	fmt.Printf("%p\n",&x2[0]) //说明指向的底层数组地址没变 变了的是地址里的值
	fmt.Println(x2)  //切片的索引的值
	fmt.Println(x1)  //被修改后的底层数组的索引和值
}

package main

import "fmt"

func main() {
	a1:=[...]int{1,3,5,7,9,11,13,15,17}
	a2:=a1[:]

	a2=append(a1[:1],a1[2:]...)
	fmt.Println(a2)
	fmt.Println(a1)
}

package main

import "fmt"

func main() {
   //1.&取地址
   //2.*根据地址取值
   n:=18
   fmt.Println(&n)
   p:=&n
   fmt.Printf("%T\n",p)  //*int表示int类型的指针
   m:=*p
   fmt.Printf("%v\n",m)
   fmt.Printf("%T\n",m)

   var a *int
   fmt.Println(a)  //nil 赋值会报错 空指针异常
   var a1 = new(int)  //使用new关键字会分配内存块 不会造成空指针
   fmt.Println(a1)
   fmt.Println(*a1)
   *a1 = 100
   fmt.Println(*a1)
}

func make (t Type,size ... IntergerType) Type

map[KeyType]valueType

make(map[keyType] valueType,[cap])

value,ok:=map[key] 

package main
import "fmt"

func main() {
	//map和slice的组合
	a:=[]map[string]int{}
	//元素类型为map的切片
	var a1 = make([]map[string]int,10,10)
	//没有对内部的map做初始化
	a1[0] = make(map[string]int,10)
	a1[0]["ljs"] = 9
	a1[0]["jwt"] = 8
	fmt.Println(a)
	fmt.Println(a1)

	//值为切片类型的map
	var a2 = make(map[string][]string,10)
	a2["ljs"] = make([]string,10,10)
	a2["ljs"] = []string{"giegie"}
	fmt.Println(a2)
	a2["ljs"] = append(a2["ljs"],[]string{"jiejie","didi"}...)
	fmt.Println(a2)
}

package main

import "fmt"

func main() {
	var name string
	name = "ljs"
	fmt.Println(name)
	var ages [30]int
	ages[0] = 1
	ages = [30]int{2,3,5}
	fmt.Println(ages)
	ages1:=[...]int{2,3,6,8,9}
	fmt.Println(ages1)
	ages2:=[...]int{1:1,99:99}
	fmt.Println(ages2)

	//二维数组
	a:=[3][2]string{}
	a[0][1] = "ljs"
	a[0][0] = "jwt"
	fmt.Println(a)

	//多维数组是值类型
	a1:=[3][2]string{{"ljs","jwt"},{"fyz","lje"}}
	fmt.Println(a1)

	var a2 =[3][2]int{[2]int{1,2},[2]int{3,4}}
	fmt.Println(a2)

	//数组是值类型
	a3:=[3]int{1,2,3}
	fmt.Println(a3)
	f1(a3)
	fmt.Println(a3)

	a4:=[]int{1,2,3}
	fmt.Println(a4)
	f2(a4)
	fmt.Println(a4)
}
func f1(a [3]int)  {
	//go语言中函数传递的都是值 ctrl+c ctrl+v 
	a[1] = 100
}

func f2(a []int) {
	a[1] =100
}

	a4:=[]int{1,2,3}
	fmt.Println(a4)
	f2(a4)
	fmt.Println(a4)

	//切片
	a5:=[]int{}
	fmt.Println(a5)
	fmt.Println(a5==nil)
	//没有分配内存 零切片声明 nil
	var a6 []int
	fmt.Println(a6)
	fmt.Println(a6==nil)
	//make初始化 分配内存
	a7 := make([]int, 5, 5)
	fmt.Println(a7)
	fmt.Println(a7==nil)

	s1 :=[]int{1,2,3}
	s2:=s1
	fmt.Println(s1)
	s2[1] = 100
	fmt.Println(s2)
	fmt.Println(s1) //切片不存值 指向同一个数组

	var s3 []int
	//append将自动初始化分配内存+扩容
	s3 = append(s3,1)
	fmt.Println(s3)

	var s4 []int
	s4 = make([]int,1,1)
	copy(s4,s3) //copy函数必须先将dest切片声明好并且初始化好分配好内存和长度
	fmt.Println(s4)

	//指针
	//go里面的指针只能读不能修改
	addr:="沙河"
	addrpointer:=&addr
	fmt.Println(addrpointer)
	fmt.Printf("%T\n",addrpointer)
	fmt.Printf(*addrpointer)

//map
	var m map[string]int
	m = make(map[string]int,5)
	m["ljs"] = 99
	m["jwt"] = 98
	fmt.Println(m)
	fmt.Println(m["jiwuming"]) //如果不存在key ，返回的将是value类型的默认值
	score,ok:=m["jiwuming"]
	if ok {
		println(score)
	}else{
		println("查无此人")
	}

	delete(m,"lalala")  //如果没有的话，什么都不干，不报错
	delete(m, "jwt")
	fmt.Println(m)

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	s1:="hello沙河"
	sum:=0
	for _, v := range s1 {
		//if v >= 128 {
		//	sum++
		//}

		if unicode.In(v, unicode.Han) {
			sum++
		}
	}
	fmt.Println(sum)

	s2:="how do you do"
	s3:= strings.Split(s2," ")
	fmt.Println(s3)

	m:= make(map[string]int, 5)
	for _, v := range s3 {
		//if m[v] == 0 {
		//	m[v] =1
		//}	else {
		//	m[v] ++
		//}
		if _,ok := m[v];!ok{
			m[v]=1
		}else {
			m[v]++
		}
	}
	fmt.Println(m)

	//回文判断
	//字符串从左往右读和从右往左读是一样的，就是回文
	//黄山落叶松叶落山黄
	s4:="黄山落叶松叶落山黄"
	s5:= make([]string, len(s4))
	for i, v:= range s4 {
		s5[len(s4)-i-1]=string(v)
		//fmt.Println(i, string(v))
		fmt.Println(s5)
	}
	var s6 string
	s6 = strings.Join(s5,"")
	fmt.Println(s6)
	fmt.Println(s6==s4)

	runes:= make([]rune, 0, len(s4))
	for _, rune := range s4 {
		runes =append(runes, rune)
	}
	fmt.Println("rune[] :",runes)
	for i := 0; i < len(runes)/2; i++ {
		if runes[i]!=runes[len(runes)-i-1] {
			return
		}
	}
	println("回文")
}

package main

import "fmt"

func main() {
   println(f4(1, 2, 3, 4))
}

func f1() {
   fmt.Println("hello 沙河")
}

func f2(name string) {
   fmt.Println("hello",name)
}

func f3(x, y int) int {
   return x+y  //y是一个可变长度的切片类型
}

func f4(x int, y ...int) int {
   sum:=x
   for _, v := range y {
      sum+=v
   }
   return sum
}

func f5(x, y int) (sum int) {
   sum = x+y
   return 
}

func f6(x, y int) (x1, y1 int) {
   x1=x
   y1=y
   return
}

package main

import "fmt"

//go语言中的函数的return不是原子操作，在底层是分为两步来执行
//第一步：返回值赋值
//第二步：真正的return返回
//函数中如果存在defer，那么defer执行的时机是在第一步和第二步之间
func main() {
	fmt.Println(f1())  //5
	fmt.Println(f2())  //6
	fmt.Println(f3())  //5
	fmt.Println(f3_1())  //[100 2]
}

func f1() int {
	x :=5
	defer func() {
		x++  //修改的是x不是返回值
	}()
	return x
}

func f2() (x int) {
	defer func() {
		x++
	}()
	return 5  //返回值是x x又++了 所以返回6
}

func f3() (y int) {
	x:=5
	defer func() {
		x++  //是因为int是值类型 所以y是拷贝值而不是拷贝地址的原因吗
	}()
	return x
}

func f3_1() (y []int) {
	x:=[]int{1,2}
	defer func() {
		x[0]=100   //因为[]int 切片是引用类型 所以y拷贝的是地址而不是值
	}()
	return x
}

func f4() (x int) {
	defer func(x int) {
		x++  //改变的是函数的副本
	}(x)  //(x)代表的是传入参数
	return 5
}

type calculation func(int,int) int

package main

import "fmt"

func main() {
	fmt.Printf("%T \n",f1)
	fmt.Printf("%T \n",f2)
	fmt.Printf("%T \n",f3)
	f3(f2)

	a := f4(f2)
	fmt.Printf("%T\n",a)
}

func f1() {
	fmt.Println("hello 沙河")
}

func f2() int {
	return 5
}
//函数也可以作为参数的类型
func f3(x func() int) {
	fmt.Println(x())
}

//函数还可以作为返回值的类型
func f4(x func() int)  func(int,int) int {
	return f5
}

func f5(x, y int) int {
	return x+y
}