一、变量定义
变量类型写在变量名之后
使用 var 关键字
var a, b, c bool
var s1, s2 string="hello", "world"
使用 var() 集中定义变量
var (
i = 00
o = 22
)
让编译器自动决定类型
var a, b, i, sl, 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：不加U表示无符号整数
uintptr 指针
byte、rune（相当于 char）
float32、float64、complex64、complex128：原生支持复数类型
①、复数回顾
②、复数例子
var d = 3 + 4i
cmplx.Abs(d)
cmplx.Pow(math.E, 1i * math.Pi)+1
cmplx.Exp(1i * math.Pi) + 1
③、强类型转换
var a, b int = 3, 4
var c int
c = int(math.Sqrt(float64(a * a + b * b)))
三、常量与枚举
3.1、常量
const filename="abc.txt"
const 数值可作为各种类型使用
const a,b = 3,4
var c int = int(math.Sqrt(a*a+b*b))
3.2、枚举
普通枚举类型
const (
a = 0
b = 1
c = 2
d = 3
e = 4
)
自增枚举类型
const (
a = iota
_
c
d
e
)
const (
a = 1 << (10 * iota)
b
c
d
e
)
四、条件语句
4.1、if
if 后面的条件没有括号
if 的条件里可以赋值
if 的条件里赋值的变量作用域就在这个 if 语句里
package main
import (
"fmt"
"io/ioutil"
)
func main() {
const filename = "abc.txt"
contents, err := ioutil.ReadFile(filename)
if err != nil {
fmt.Println(err)
} else {
fmt.Printf("%s\n", contents)
}
}
package main
import (
"fmt"
"io/ioutil"
)
func main() {
const filename = "abc.txt"
if contents, err := ioutil.ReadFile(filename); err != nil {
fmt.Println(err)
} else {
fmt.Printf("%s\n", contents)
}
}
4.2、switch
switch 会自动 break，除非使用 fallthrough
switch 后可以没有表达式
package main
import (
"fmt"
)
func main() {
fmt.Println(
grade(0),
grade(59),
grade(60),
grade(82),
grade(99),
grade(100),
)
}
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 的条件里不需要括号
package main
import (
"fmt"
)
func main() {
fmt.Println(sum())
}
func sum() int {
sum := 0
for i :=1; i <= 100; i++ {
sum += i
}
return sum
}
没有 while
for 的条件里可以省略初始条件（相当于 while），结束条件，递增表达式
package main
import (
"fmt"
"strconv"
)
func main() {
fmt.Println(convertToBin(5))
}
func convertToBin(n int) string {
result := ""
for ; n > 0; n /= 2 {
lsb := n % 2
result = strconv.Itoa(lsb) + result
}
return result
}
package main
import (
"fmt"
"io"
"os"
"bufio"
)
func main() {
printFile("abc.txt")
}
func printFile(filename string) {
file, err := os.Open(filename)
if err != nil {
panic(err)
}
printFileContents(file)
}
func printFileContents(reader io.Reader) {
scanner := bufio.NewScanner(reader)
for scanner.Scan() {
fmt.Println(scanner.Text())
}
}
无限循环
package main
import (
"fmt"
)
func main() {
for{
fmt.Println("abc")
}
}
六、函数
返回值类型写在最后面
可返回多个值
返回多个值时可以起名字，仅用于非常简单的函数
package main
import (
"fmt"
)
func main() {
q,r := div(5, 2)
fmt.Println(q, r)
}
func div(a, b int) (q, r int) {
q = a / b
r = a % b
return
}
函数作为参数
package main
import (
"fmt"
"runtime"
"math"
"reflect"
)
func main() {
fmt.Println("pow(3, 4) is:", apply(
func(a int, b int) int {
return int(math.Pow(
float64(a), float64(b)))
}, 3, 4))
}
func apply(op func(int, int) int, a, b int) int {
p := reflect.ValueOf(op).Pointer()
opName := runtime.FuncForPC(p).Name()
fmt.Printf("Calling function %s with args "+"(%d, %d)\n", opName, a, b)
return op(a, b)
}
可变参数列表
package main
import (
"fmt"
)
func main() {
fmt.Println("1+2+...+5 =", sum(1, 2, 3, 4, 5))
}
func sum(numbers ...int) int {
s := 0
for i := range numbers {
s += numbers[i]
}
return s
}七、指针
指针不能运算
package main
import (
"fmt"
)
func main() {
var a int = 2
var pa *int = &a
*pa = 3
fmt.Println(a)
}
Go 语言只有值传递一种方式
