go语言学习-基础知识

命名：
函数名、变量名、常量名、类型名、包名等所有的命名，都遵循一个简单的命名规则：一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线。
大写字母和小写字母是不同的：heapSort和Heapsort是两个不同的名字。
关键字不可用于命名
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
推荐驼峰式命名
名字的开头字母的大小写决定了名字在包外的可见性。如果一个名字是大写字母开头的，那么它可以被外部的包访问，包本身的名字一般总是用小写字母。
声明：
Go语言主要有四种类型的声明语句：var、const、type和func，分别对应变量、常量、类型和函数。
变量：
var声明语句可以创建一个特定类型的变量，然后给变量附加一个名字，并且设置变量的初始值。变量声明的一般语法如下：
var 变量名字 类型 = 表达式
其中“类型”或“= 表达式”两个部分可以省略其中的一个。如果省略的是类型信息，那么将 根据初始化表达式来推导变量的类型信息。如果初始化表达式被省略，那么将用零值初始化该变量。数值类型变量对应的零值是0，布尔类型变量对应的零值是false，字符串类型对应的零值是空字符串，接口或引用类型（包括slice、map、chan和函数）变量对应的零值是nil。数组或结构体等聚合类型对应的零值是每个元素或字段都是对应该类型的零值。
零值初始化机制可以确保每个声明的变量总是有一个良好定义的值，因此在Go语言中不存在未初始化的变量。这个特性可以简化很多代码，而且可以在没有增加额外工作的前提下确保边界条件下的合理行为。例如：
var s string
fmt.Println(s) // ""
，每个 Go 文件都属于且仅属于一个包。一个包可以由许多以 .go 为扩展名的源文件组成，因此文件名和包名一般来说都是不相同的
常量使用关键字 const 定义，用于存储不会改变的数据。

存储在常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

常量的定义格式：const identifier [type] = value
常量的值必须是能够在编译时就能够确定的；你可以在其赋值表达式中涉及计算过程，但是所有用于计算的值必须在编译期间就能获得。因为在编译期间自定义函数均属于未知，因此无法用于常量的赋值，但内置函数可以使用，如：len ()
全局变量是允许声明但不使用
1。变量

import (
	"fmt"
	"math"
	"math/cmplx"
)
//在函数外面不能用:=，为包内部变量

var (
	aa = 3
	bb = 4
)
func variableZeroValue()  {
	var a int
	var s string
	fmt.Printf("%d %q\n",a,s)
}

func variableInitialValue()  {
	var a,b int = 3, 4
	var s string = "abc"
	fmt.Println(a, b, s)
}

func variableType()  {
	var a, b, c, s = 3, 4, true, "def"
	fmt.Println(a, b, c, s)
}

func variableShorter()  {
	//变量作用域为函数里面
	a, b, c, s := 3, 4, true, "def"
	b = 5
	fmt.Println(a, b, c, s)
}
func euler()  {
	c := 3+4i
	fmt.Println(cmplx.Abs(c))
	b := cmplx.Pow(math.E,1i*math.Pi) + 1
	d := cmplx.Exp(1i*math.Pi) + 1
	fmt.Println(b)
	fmt.Println(d)
}

func triangle()  {
	var a, b int  = 3, 4
	var c int
	c = int(math.Sqrt(float64(a * a + b * b)))
	fmt.Println(c)
}

func consts()  {
//const为常量
	const a, b  = 3, 4
	const filename  = "abc.txt"
	var c int
	c = int(math.Sqrt(a * a + b * b))
	fmt.Println(c)
	fmt.Println(filename)
}
func enums()  {
//iota 可以被用作枚举值，第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1
	const (
		cpp = iota
		java
		python
		golang
	)

	const (
		b = 1 << (10 * iota)
		kb
		mb
		gb
	)

	fmt.Println(cpp,java)
	fmt.Println(b,kb)
}

func main() {
	fmt.Println("Hello World")
	variableZeroValue()
	variableInitialValue()
	variableType()
	variableShorter()
	fmt.Println(aa,bb)
	euler()
	triangle()
	consts()
	enums()
}

　　

内建变量
bool,string
int,int8,int16,int32,int64,uintprt(前面加u为无符号整数),uinptr指针
byte,rune(char)
float32,float64,complex64
类型转换为强制转换
2.条件语句

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


func main() {
	const filename = "F:\\GoWorkSpace\\LearnGO\\day1\\abc.txt"
//简略写法if条件里也可以定义变量
	if contens, err := ioutil.ReadFile(filename); err != nil{
		fmt.Println(err)
	} else {
		fmt.Printf("%s\n", contens)
	}
	fmt.Println(
		grade(0),
		grade(59),
		grade(69),
		grade(82),
		grade(99),
	)

}//switch 后可以没有表达式

3.循环

for,if后面的条件没有括号
没有while
switch不需要break,也可以直接switch多个条件

一个可以最简单的可运行的go程序需要满足下面两个条件:

• 有一个main()函数
• main()函数在main包中

例如: 在go语言中的 hello world 程序如下:

// main.go
package main

func main() {
    println("hello world");
}

程序中的 package 关键字，用来声明文件所属的包(文件所属的包跟文件名是没有关系的)，每一个go文件都需要有一个包声明； 而 func 关键字用来定义函数, 这里我们定义了一个main函数(main函数的形式是固定的)。println 函数是用来向标准输出打印数据的，不过我们一般情况下是不使用它的。

go在编译程序时，会自动在语句的结尾加上分号，所有这里函数的第一的大括号，必须与()在同一行，否则返回就会加在()之后，就会出现错误，后面的一些流程控制语句也是如此

运行程序:

go build main.go  // 编译程序
./main         // 运行程序

我们可以将两步合成一步:

go run main.go    // 不会生成中间文件

在运行go程序时的入口就是 main 包下的 main 函数。

变量

go语言使用 var 声明或者定义变量，它可以用在函数之外定义，此时就是全局变量；而在函数内声明时，就是局部变量。

还有一种简略的定义方式，使用 := 来定义，这种方式只能用在函数中，即定义局部变量

且局部变量声明之后必须使用

package main

import "fmt"

var age int = 10   // 显式的声明变量的类型 int
var name = "Tom"    // go也可以自动推断处变量类型,这里是 string

func main() {
    var sex = "man"

    hello := "hello"   // 简略声明方式

    fmt.Println(sex)
    fmt.Println(hello + "world")
}

这里我们定义了两个全局变量 name 和 age, 还定义了两个局部变量 sex 和 hello, 在 go 语言中，全局变量可以声明之后不是有，但是局部变量一旦声明必须使用，否则编译器会报错;

注意: 这里我们使用 import 关键字引入了一个 fmt 的包，在go程序中我们一般都应该使用 fmt 包中的函数来打印数据，而不是前面的println

基本数据类型:

类型	含义	默认值
bool	布尔值	false
byte	字节,uint8	0
rune	Unicode码点,int32	0
int,uint	与系统相关的有/无符号整数	0
int8,uint8	8位有/无符号整数	0
int16,uint16	16位有/无符号整数	0
int32,uint32	32位有/无符号整数	0
int64,uint64	64位有/无符号整数	0
float32	32位浮点数	0.0
float64	64位浮点数	0.0
complex64	64位复数	0+0i
complex128	128位复数	0+0i
string	字符串	“”

这些是比较基本的类型，还有一些类型，后面用到了再说

常量

常量的定义方式与变量类型，不过使用的是 const 关键字:

const PI float32 = 3.14159   
const USERNAME = "root"    // 自动类型推断

常量必须在定义时，就初始化，并且一经定义便不可更改。

流程控制语句

if语句

package main

import "fmt"

func main() {
    a := 10
    if a > 5 {
        fmt.Println("a 大于 5")
    } else {
        fmt.Println("a 小于 5")
    }
}

同样的这里的 左大括号“{”必须与 if 或者 else 在同一行, 且这里 else 必须与 if 的右大括号“}”在同一行。

go语言中没有三元运算符

switch语句

switch (n){

    case 1:
        fmt.Println("n == 1")
    case 2:
        fmt.Println("n == 2")
    default:
        fmt.Println("n is default")
}

go中的 switch 是不需要 break 语句的,默认自动终止一个case; 如果需要继续执行下一个，使用fallthrough，此时不会判断条件

这里switch语句还可以包含初始化语句，使用分号”;”分隔,且case的条件，不仅仅可以是常量值，还可以是比较表达式;

for循环

go语言支持三种循环方式:

// 1. 常见的for循环,类似于C语言的循环，不过条件可以不用括号
for i := 0; i < 10; i++ {
    fmt.Println(i);
}

// 2. 类while语法
i := 10
for i > 0 {
    fmt.Println(i)
    i--
}

// 同样的,无限循环是这样,省略条件
for {
    //...
}

// 3. for .. range,可以用来循环字符串，数组，map,channel等等
// range返回 (索引值, 值)或者(键, 值); 如果只有一个接收参数，则会忽略第二个返回值
s := "hello"

for i := range s {   // 这里循环的是string的索引
    fmt.Println(s[i])  
}

标签，goto, break, continue

go还支持标签(区分大小写)，可以使用goto跳转到标签，break 可⽤于 for、 switch、 select，⽽ continue 仅能⽤于 for 循环。