GO语言基本语法（学习笔记）

1.标准输入输出包（fmt）

package main

import "fmt"

func main() {

	fmt.Println("输出并且换行")
	fmt.Print("输出但是不换行")
	fmt.Printf("格式化输出")

    //严格按照指定的格式输入
	//fmt.Scanf("a=%d,b=%s", &a, &b)
    //fmt.Scan(&a)  
    //fmt.Scaning(&a) 遇到enter就结束
}

2.一个项目只能有一个main包，但是一个目录下面可以有多个main包

3.注释

单行注释： //

多行注释：/*  */

4.go语言的代码都由函数来组织，将编码风格写进语法

5.声明变量：

全局变量：在主函数外定义，在全局生效 (全局变量只能声明一次)

var a int   （没给变量赋值的情况下整型变量的默认值是0）
var b string （没给变量赋值的情况下，字符串型变量的值是空字符串）

局部变量：只在函数体内生效  （局部变量声明了就必须使用）

func main() {

c := 123

}

常量：一旦定义后就不能修改

const d = 30

// 声明多个常量

const （

    a = 10
    b = 20
    c
    // 我们没有给c赋值，但是系统会将上一个常量的值赋给c，所以我们这里c的值是20

）

// 特殊的常量  iota（计数常量）

const （

    m = 1
    n = 2
    k = iota
    // k是第三个被定义的常量，所以k的值是2
）

6.基本数据类型 

//基本数据类型：int float boolea char byte rune

/*

强调空间管理

uint 8:八位二进制来表示一个整数，没有符号（0-255）
uint 16：0-65535
int 8 : 有符号位（-127-127）
int 16
int 32   rune
...
*/

7.统计类

字符串的长度统计

//统计字符串占用的字节长度   len()
len_str := len("xxyyzz中")
fmt.Println(len_str)

8.转义字符 

	//   \t  表示一个table键
	str1 := "a\tb"
	fmt.Println(str1)
	str2 := "a\\tb"
	fmt.Println(str2)
	字符串原样输出不转译
	str3 := `a\tb`
	fmt.Println(str3)

9.字符串的转换 --strconv

	num1 := 10
	str1 := strconv.Itoa(num1)
	fmt.Printf("str1 is:%s, type is %T \n", str1, str1)
	//返回两个值
	v, e := strconv.Atoi("10")
	//如果不能转换成功e就会拿到作物信息
	//将v转换成int型
	fmt.Println(v,e)

10.字符串的常用方法

替换

	处理字符串的常用方法： 替换 strings
	str1 := "xxhh"
	if strings.HasPrefix(str1, "x"){
		fmt.Println("str1 start with x")
	}
	fmt.Println(strings.Count(str1, "h"))
	fmt.Println(strings.Clone(str1))
	//n=-1 表示将所有的x替换成*
	//n=1  :将第一个x换成*
	fmt.Println(strings.Replace(str1, "x", "*", 1))

切片

	字符串的切片,左闭右开，没有负下标
	str[start:end]
	str2 := "abcdefg"
	fmt.Println(str2[1:5])
    //bcde

11.算数运算符  + - * / %

	a := 1
	b := 2
	fmt.Println(a+b)
	fmt.Println(a-b)
	fmt.Println(a*b)
	fmt.Println(a/b)
	fmt.Println(a%b)

/*
3
-1
2
0
1
*/

12.逻辑运算符  &&    ||

	a := 3
	b := 2
	c := 0
	if (a<b) && (a/c>0){
		fmt.Println("短路运算")
	}else{
		fmt.Println("非短路运算")
	}
//非短路运算

13.比较运算符

	a := 1
	b := 2
	if a>b {
		fmt.Println("a大于b")
	}else{
		fmt.Println("a小于b")
	}
// a小于b

14.赋值运算符

	a := 1

（算数运算符、逻辑运算符、比较运算符、赋值运算符不能连用）

15. go语言只有for循环没有while和do...while，只能用for循环来模拟

	// go语言用for循环，模拟while循环
	//for init ; condition ; post {}
	//用for循环输出0-10
	for i:=0 ; i<=10 ; i++{
		fmt.Println(i)
	}
	fmt.Println("****************")
	//再用for循环模拟while循环实现
	j := 0
	for j<=10 {
		fmt.Println(j)
		j++
	}

16. go语言的strings包

func main() {
	str := "abcdefghijk"
	//16.1 求字符串长度
	fmt.Println(len(str))
	//16.2 求字符串的字串  --切片
	fmt.Println(str[1:5])
	//16.3 求字符串是否存在某个字串或者字符
	fmt.Println(strings.Contains(str, "a"))
	//16.4 求字符串中字串出现的次数
	fmt.Println(strings.Count(str, "b"))
	//16.5 字符串分割
	fmt.Println(strings.Split(str, "c"))
	//16.7 字符串的某个字符或者字串第一次出现的位置或者最后一次时出现的位置
	fmt.Println(strings.Index(str, "c"))
	fmt.Println(strings.LastIndex("abcd", "c"))
	//16.10字符串中的字串替换
	fmt.Println(strings.Replace(str, "c", "d", 3))
	//16.11字符串 大小写转换
	fmt.Println(strings.ToLower(str))
	fmt.Println(strings.ToUpper(str))
}

11
bcde
true
1
[ab defghijk]
2
2
abddefghijk
abcdefghijk
ABCDEFGHIJK

17.函数：(自定义函数，匿名函数)

17.1.支持可变长参数（...三个练习的点表示）（每次可以不传递参数，可以传递一个参数或者更多参数）

func main() {
	//	可变长参数传递
		myargs()
		myargs(1)
		myargs(1,2)
}
//num 接受可变长的int类型的传入
func myargs(num... int){
	fmt.Printf("%T-->%v \n", num, num)
}

/*
[]int-->[] 
[]int-->[1] 
[]int-->[1 2] 
*/

17.2支持把函数作为参数传递，函数是一种数据类型

在函数体内，不能直接嵌套函数，但是可以嵌套匿名函数（没有名字的函数）

func main() {
	sum(1,2)
}


func sum(a , b int) func(a int){
	fmt.Println(a+b)
	return func (a int) {
		fmt.Println("sum函数内调用了匿名函数成功，将匿名函数作为返回值")
	}

}

17.3支持匿名函数，闭包

闭包：一般情况下变调调用完以后就会在内存空间释放它所占用的资源，但是如果形成了闭包就不会释放它所占用的内存，变量会一直保存下去，并且占用系统资源

闭包形成的条件：

1.有内外函数

2.外函数要返回内函数

3.内函数要调用外函数的变量

// 闭包会把局部变量永久存下去
func closure(x int) func(int) int {
	fmt.Println(x)
	//x本来会在return后释放，但由于内函数的引用，会一直保存下来
	return func(y int ) int {
		fmt.Println("x is :", x)
		fmt.Println("y is :", y)
		return x+y
	}
}

func main()  {
	inner := closure(100)
	fmt.Println(inner)
	reult := inner(100)
	fmt.Println(reult)
}

/*
100
0xc9e520
x is : 100
y is : 100
200
*/

17.4函数支持多个返回值

func main() {
	x, y := add(1,2)
	fmt.Println(x, y)
}

func add(num1 int,num2 int) (int, int) {
	result1 := num1 +num2
	result2 := num1 +num2
	return result1, result2
}

//  3  3

17.5支持命名参数返回

func main() {
	x, y := add(1,2)
	fmt.Println(x, y)
}

func add(num1 int,num2 int) (result3 ,result4 int) {
	result1 := num1 +num2
	result2 := num1 +num2
	return result1, result2
}

17.7一般情况下，不支持函数的嵌套（但是可以嵌套匿名函数），不支持重载，不支持默认参数