golang学习笔记之--Go语言基本语法

肯定不少猿问，为啥要学习Go语言，答案很简单，市场上Go语言工程师需求量远大于供应量，一句话，学会Go语言能找到好工作~ O(∩_∩)O哈哈~ 其实只要自身本来强，都可以找到心仪的工作的

废话不多说，开始我的表演~

如果各位童鞋想要获得下面的源码，请搜索gzh：隔壁王小猿，关注后回复“Go语言基本语法”即可获得

变量的定义

使用var关键字

• var a,b,c bool

• var s1,s2 string = “hello”,”world”

• 可以放在函数内，或者直接放在包内

• 使用var()集中定义变量，函数内和包内都可以用

让编译器自动决定类型

• var a,b,i,s1,s2 = true,false,3, “hello”,”world”

使用:=定义变量

• a,b,i,s1,s2 := true,false,3, “hello”,”world”

• 只能在函数内使用，包内不能使用

内建变量类型

• bool string

• (u)int (u)int8 (u)int16 (u)int32 (u)int64 intptr

  • u代表无符号

  • 8、16、32、64代表长度

  • 无长度的整形，根据操作系统的位数

  • Intptr是整数指针

• byte rune

  • byte是2^3 = 8位

  • rune长度是 32，类似char类型

• float32 float64 complex64 complex128

  • float浮点型，32/64代表位数

  • complex复数，64位复数（float32实部，float32虚部），128位类型

常量的定义

• const filename = “abc.txt”

• const数值可以作为各种类型使用，变量不可以

• const a,b = 3,4

• var c int = int(math.Sqrt(a*a+b*b))

枚举类型

• 使用常量定义枚举类型

  • 普通枚举类型

  • 自增值枚举类型 iota

• 变量常量总结

  • 变量类型写在变量名之后

  • 编译器可推测变量的类型

  • 没有char，只有rune

  • 原生支持复数类型

先来看一下这部分的源码说明：

package basic
import (
	"bytes"
	"fmt"
	"math"
	"math/cmplx"
)
//包变量- 包里面是可用的，并不是全局变量
var (
	a_pkg = 123
	b_pkg = true
	c_pkg = "kkk"
)
//包内不能用 := 声明变量
//abc, bcd := 123, false
func variableZeroValue() {
	//函数局部变量
	var a int
	var s string
	fmt.Printf("%d    %q", a, s)
	fmt.Println()
}
func variableInitialValue() {
	var a, b int = 1, 2
	var s string = "abd"
	fmt.Println(a, b, s)
}
func euler() {
	fmt.Printf("%.3f\n",
		cmplx.Exp(1i*math.Pi)+1)
	fmt.Println(cmplx.Exp(1i*math.Pi) + 1)
}
func triangle() {
	var a, b int = 30, 40
	var c int
	c = int(math.Sqrt(float64(a*a + b*b)))
	fmt.Println(c)
	////var a, b  = 30, 40
	//var a, b  float64 = 30, 40
	////var c int
	//c = int(math.Sqrt(a*a + b*b))
	////fmt.Println(c)
}
func variableTypeDeduction() {
	var a, b, c, s = 3, 4, false, "def"
	fmt.Println(a, b, c, s)
}
func variableShortor() {
	abc, bcd := 123, false
	fmt.Println(abc, bcd)
	ss := "abs"
	fmt.Println(ss)
	ss = "abcd"
	fmt.Println(ss)
	var (
		s_a = 2
		s_d = 3
	)
	fmt.Println(s_a, s_d)
}
const fileName = "abc.txt"
const (
	file1 = "file1"
	file2 = "file2"
)
func consts() {
	const a, b = 3, 4
	var c int
	c = int(math.Sqrt(a*a + b*b))
	fmt.Println(c)
	//fmt.Println(fileName, file1, file2)
}
func hello(abc ...interface{}) {

	//fmt.Println(abc)

	for argNum, arg := range abc {
		if argNum > 0 {
			fmt.Println(argNum, arg)
		}
	}
}
func enums() {
	const (
		cpp = iota
		java
		python
		c
		golang
		javascript = 100
		_
		csharp = iota
	)
	fmt.Println(cpp, java, python, c, golang, javascript, csharp)

	const (
		b = 1 << (10 * iota)
		kb
		mb
		gb
		tb
		pb
	)
	fmt.Println(b, kb, mb, gb, tb, pb)
}
func main() {
	//fmt.Println("Hello world!")
	//variableZeroValue()
	//variableInitialValue()
	//variableTypeDeduction()
	//variableShortor()
	//
	//fmt.Println(a_pkg, b_pkg, c_pkg)
	//euler()
	//triangle()
	//var str string
	//str = "anc"
	//fmt.Println(str)
	//consts()
	//hello(fileName, file1, file2, 123)
	enums()
	var bufabc bytes.Buffer
	fmt.Println(bufabc)

}

条件循环

If：用法1

	contents, err := ioutil.ReadFile(filename)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Printf("%s\n", contents)
	}
	fmt.Println()

If：用法2

	if contents, err := ioutil.ReadFile(filename); err != nil {
		fmt.Println(err)
	} else{
		fmt.Printf("%s\n", contents)
	}

If：总结

• If的条件里可以赋值

• If的条件里赋值的变量作用域就在if语句里，其他地方访问不到

Switch：用法1

func eval(a, b int, op string) int {
	var result int
	switch op {
	case "+":
		result = a + b
	case "-":
		result = a - b
	case "*":
		result = a * b
	case "/":
		result = a / b
	default:
		panic("unsupported operator:" + op)
	}
	return result
}

Switch：用法2-switch后可以没有表达式

func grade(score int) string {
	g := ""
	switch {
	case score < 0 || score > 100:
		panic(fmt.Sprintf("Wrong score: %d", score))
	case score < 60:
		g = "F"
	case score < 80:
		g = "C"
	case score < 90:
		g = "B"
	case score <= 100:
		g = "A"
	}
	return g
}

循环-for

    sum := 0
	for i := 1; i <= 100; i++ {
		sum += i
	}

• for的条件里不需要括号

• for的条件里可以圣罗初始条件，结束条件，递增表达式

• 省略初始条件

func convertToBin(n int) string {
	result := ""
	for ; n > 0; n /= 2 {
		lsb := n % 2
		result = strconv.Itoa(lsb) + result
	}
	return result
}

• 省略递增表达式

func printfile(filename string) {
	if file, err := os.Open(filename); err != nil {
		panic(err)
	} else {
		scanner := bufio.NewScanner(file)
		for scanner.Scan() {
			fmt.Println(scanner.Text())
		}
	}
}

• 省略结束条件-死循环

func forever() {
	for {
		fmt.Println("abc")
	}
}

条件与循环总结

• for 、 if 后面的条件每一天括号

• if条件里也可以定义变量

• 没有while

• switch不需要break，也可以直接switch多个条件

函数

• 函数可以返回多个值，并且可以起名字

func div(a, b int) (q, r int) {
	q, r = a/b, a%b
	return q, r
}

• 函数可以作为参数传递

func apply(op func(int, int) int, a, b int) int {
	fmt.Println("Calling function %s with args "+
		"(%d,%d)", runtime.FuncForPC(reflect.ValueOf(op).Pointer()), a, b)
	return op(a, b)
}

• 匿名函数

	i2 := apply(func(a int, b int) int {
		return int(math.Pow(float64(a), float64(b)))
	}, a, b)

• 可变参数列表

func sumcan(numbers ...int) int {
	sum := 0
	for i := range numbers {
		sum += numbers[i]
	}
	return sum
}

函数总结

• 返回值类型写在最前面

• 可返回多个值

• 函数作为参数，

• 没有默认参数，没有可选参数，有可变参数

• 没有函数重载

指针

示例

    var a int = 2
	fmt.Println(a)
	var pa *int = &a
	fmt.Printf("*** before *** pa = %s, *pa = %d, &a = %s, a = %d.\n", pa, *pa, &a, a)
	*pa = 3
	fmt.Printf("*** after ***  pa = %s, *pa = %d, &a = %s, a = %d. \n", pa, *pa, &a, a

输出：

2
*** before *** pa = %!s(*int=0xc00000a0c8), *pa = 2, &a = %!s(*int=0xc00000a0c8), a = 2.
*** after ***  pa = %!s(*int=0xc00000a0c8), *pa = 3, &a = %!s(*int=0xc00000a0c8), a = 3.

参数传递：Go语言只有值传递，没有引用传递

func swap(a, b int) {
	a, b = b, a
}
func swappointer(a, b *int) {
	*a, *b = *b, *a
}
func swapreturn(a, b int) (int, int) {
	return b, a
}
func main() {
	a, b := 3, 4
	fmt.Println(a, b)
	swap(a, b)
	fmt.Println(a, b)
	swappointer(&a, &b)
	fmt.Println(a, b)
	a, b = swapreturn(a, b)
	fmt.Println(a, b)
}

输出

3 4
3 4
4 3
3 4

后续小猿还会提供内建容器、面向对象、面向接口、函数式编程、资源管理和错误处理、测试与性能优化、channel等go语言基础文章，敬请期待~

更多精彩请关注小猿gzh