go语言的学习之基础语法

变量定义

1> 使用var关键词声明变量，不赋值

func main() {
	var a int 
	var s string
	var t bool
	fmt.Println(a, s, t)
}
// int的默认值为0 string的默认值为空串 bool的默认值为false

2> 使用var关键词声明变量，赋值

func main() {
	var a, b int = 3, 4
	var s string = "abc"
	var t bool = true
	// 编译器可以自动识别类型
	var r, f, v = 1, "a", false
	fmt.Println(a, s, t, r, f, v)
}

3> 使用 := 声明变量并赋值

func variable() {
	a := 3
	s := "hello"
	i, j := true, 2
	fmt.Println(a, s, i, j)
}

4> 在函数外部定义变量

package main

import "fmt"

var (
	a = 2
	b = 3
	t = true
)

func main() {
	fmt.Println(a, b, t)
}
// 在函数外部定义变量，只能使用var关键字来定义
// 函数外部定义的变量，属于包内变量

总结：

• 变量的声明有两种方式，使用关键词var和使用:=
• 声明变量的时候可以不写变量类型，编译器会自动推导
• 在函数外部定义关键词的时候只能使用var来声明

常量与枚举

1> 常量的定义

package main

import "fmt"

const (
	i, j = true, "kk"
)

func main() {
	const (
		a, b = 1, 2
	)
	// a = 10  // 这里会报错，常量的值不允许改变
	fmt.Println(a, b, i, j)
}
// 1 2 true kk

2> 枚举：iota

package main

import "fmt"

func main() {
	const (
		a = iota
		b, c = iota, iota
		d = iota
	)
	fmt.Println(a, b, c, d)
	
	const i = iota
	fmt.Println(i)
}
// 1 2 2 3
// 0

总结

• 常量的声明需要使用关键词const
• 常量可以声明在函数的内部和外部
• iota是每隔一行值增加1
• 当iota碰到const的时候，重置为0

基础数据类型分类

1. byte：默认值0
2. string：默认值空串
3. int：默认值0
4. flot：默认值0
5. bool：默认值false

条件语句

1> if

package main

import (
	"fmt"
	"io/ioutil"
)

func main() {
	const filename = "abc.txt"
	contents, err := ioutil.ReadFile(filename)
	if err != nil {
		panic(err)
		// fmt.Println(err)
	} else {
		fmt.Printf("%s", contents)
	}
}

2> swich

package main

import "fmt"

var g string

func grade(score int) string {
	switch {
	case score < 60:
		g = "C"
	case score < 80:
		g = "B"
	case score <= 100:
		g = "A"
	default:
		fmt.Printf("Wrong score %d", score)
	}
	return g
}

func main() {
	s := grade(100)
	fmt.Println(s)
}

循环

package main

import "fmt"

func main() {
	sum := 0
	for i := 0; i <= 100; i++ {
		sum += i
	}
	fmt.Println(sum)
}

package main

import "fmt"
// 死循环
func main() {
	for {
		fmt.Println("abc")
	}
}