go 语言 基础知识点一

更多干货

• 分布式实战（干货）

• spring cloud 实战（干货）

• mybatis 实战（干货）

• spring boot 实战（干货）

• React 入门实战（干货）

• 构建中小型互联网企业架构（干货）

• python 学习持续更新

• ElasticSearch 笔记

• kafka storm 实战 (干货)

• scala 学习持续更新

• RPC

• 深度学习

• GO 语言 持续更新

• Android 学习

• nginx 相关文章

 

---

一、数组

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")
	}