一、数组
package main
import (
"fmt"
)
func main() {
x := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
var y []int
y = x[1:3]
fmt.Printf("%v\n", y)
y = x[:3] //左边不写 代表从0开始
fmt.Printf("%v\n", y)
y = x[7:] //右边不写代表一直到最后
fmt.Printf("%v\n", y)
}
package main
import (
"fmt"
)
func main() {
x := make([]int, 3, 5)
x = append(x, 4, 5, 6, 7, 8)
fmt.Printf("%v\n", x)
fmt.Printf("%v\n", len(x)) //代表现在slice中元素的个数
fmt.Printf("%v\n", cap(x)) //代表现在slice底层的分配的空间是多大 当append加入的元素个数超过此值时 底层会自动扩充
}
package main
import (
"fmt"
)
func main() {
/*
var x map[string]float32
x["zhangsan"] = 64.2
fmt.Printf("%v", x)
上述程序会报错 因为map使用前必须make分配内存 否则会报 nil map错误
*/
//正确用法如下
//正常声明
var x map[string]float32
x = make(map[string]float32)
x["zhangsan"] = 64.2
fmt.Printf("%v\n", x)
//或者直接使用简短声明符号
y := make(map[string]float32)
y["lisi"] = 76.5
fmt.Printf("%v\n", y)
}
二、流程控制
package main
import (
"fmt"
)
func main() {
x := "zhangsan"
for _, v := range x {
fmt.Printf("%c\n", v)
}
}
package main
import (
"fmt"
)
func main() {
x := 2
switch x {
case 1:
fmt.Print("beifeng 1")
case 2:
fallthrough
case 3:
fmt.Print("beifeng 2")
default:
fmt.Print("beifeng 3")
}
}
函数
package main
import (
"fmt"
)
func swap(a, b int) (int, int) {
return b, a
}
func add(a *int) *int {
*a = *a + 1
return a
}
func main() {
a := 1
add(&a)
fmt.Printf("%d", a)
}
package main
import (
"fmt"
)
func main() {
type sum func(x, y int) int
var f sum = func(x, y int) int {
return x + y
}
fmt.Println(f(3, 4))
}
defer(延迟执行)语句,是在函数结束前执行,而如果在函数中有多个defer语句时,会像一个堆栈一样,先进后出,后进先出。
package main
import (
"fmt"
)
func main() {
for i := 1; i <= 5; i++ {
defer fmt.Println(i)
}
}
因为panic(错误)而到导致程序终止挂掉。错误被recover 函数接收,转化为error类型的错误,最后输出“ recover后的错误: “panic 错误” ” 而且后面 afterErrorfunc()执行。
func main() {
testError()
afterErrorfunc()
}
func testError() {
defer func() {
if r := recover(); r != nil {
fmt.Println("testError() 遇到错误:", r)
}
}()
panic(" \"panic 错误\"")
fmt.Println("抛出一个错误后继续执行代码")
}
func catch(err error) {
if r := recover(); r != nil {
fmt.Println("testError() 遇到错误:", r)
switch x := r.(type) {
case string:
err = errors.New(x)
case error:
err = x
default:
err = errors.New("")
}
}
}
func afterErrorfunc() {
fmt.Println("遇到错误之后 func ")
}
三、Struct
package main
import (
"fmt"
)
type Person struct {
name string
age int
}
type Student struct {
Person
age int
speciality string
}
func main() {
student := Student{Person{"zhangsan", 25}, 30, "maths"}
fmt.Printf("%v", student.Person.age)
}
四、go类的初始化
用 new 分配内存 , new(T) 分配了零值填充的 T 类型的内存空间,并且返回其地址,一个 *T 类型的值
type Rect struct {
x, y float64
width, height float64
}
初始化方法:
rect1 := new(Rect)
rect2 := &Rect{}
rect3 := &Rect{0, 0, 100, 200}
rect4 := &Rect{width:100, height:200}
注意这几个变量全部为指向Rect结构的指针(指针变量),因为使用了new()函数和&操作符
a := Rect{}
则表示这个是一个Rect{}类型.
在Go语言中,未进行初始化的变量都会被初始化为该类型的零值,例如bool类型的零值为false, int类型的零值为0, string类型的零值为空字符串
在Go语言中没有构造函数的概念,对象的创建通常交由一个全局的创建函数来完成,以NewXXX来命令,表示"构造函数":
func NewRect(x ,y ,width, height float64) {
return &Rect{x, y, width, height}
}
五、GO继承
方法的继承
import (
"fmt"
)
type Engine interface {
Start()
Stop()
}
type Car struct {
Engine
}
func (this *Car) Start() {
fmt.Println("Car->Start()")
}
func main() {
fmt.Println("Start Main func()")
car := new(Car)
car.Start()
}
成员变量的继承
type Person struct {
Name string
Age int
}
type Man struct {
Person
}
func main() {
man := Man{Person{Name: "xiaoming"}}
fmt.Printf("My Name is %s", man.Name)
}
六、创建和实现interface
package main
import (
"fmt"
)
//定义interface
type VowelsFinder interface {
FindVowels() []rune
}
type MyString string
//实现接口
func (ms MyString) FindVowels() []rune {
var vowels []rune
for _, rune := range ms {
if rune == 'a' || rune == 'e' || rune == 'i' || rune == 'o' || rune == 'u' {
vowels = append(vowels, rune)
}
}
return vowels
}
func main() {
name := MyString("Sam Anderson") // 类型转换
var v VowelsFinder // 定义一个接口类型的变量
v = name
fmt.Printf("Vowels are %c", v.FindVowels())
}
七、golang 接口类型的判断
if varName2, ok := varName1.(interface2|typeName); ok {
//此时 varName2 的类型由 interface1 转为 interface2,或者 varName1 不是 typeName 类型的变量
} else {
//不能转换 interface,或者 varName1 不是 typeName 类型的变量
}
var v1 interface{}
v1 = "zhangsan"
switch v1.(type) {
case int:
case float32:
case float64:
fmt.Println("this is float64")
case string:
fmt.Println("this is string")
}