Go 知识点

Go 知识点

定义变量自动赋类型

var v1 int
var v2 string
var v3 [10]int  // 数组
var v4 []int // 数组切片
var v5 struct {
f  int
}
var v6 *int // 指针
var v7 map[string]int  // map，key为string类型，value为int类型
var v8 func(a int) int
v_name := value
name, age := "naveen", 29 // 简短声明

字符串和数字相互转化

//字符串转数字,要做错误处理
start, err := strconv.Atoi(page)
if err != nil {
  return
}
end, err := strconv.Atoi(size)
if err != nil {
 return
}
//数字转字符串 
//page_start := strconv.Itoa(start)
//page_end := strconv.Itoa(end)

循环

  numbers := [6]int{1, 2, 3, 5} 

   /* for 循环 */
   for a := 0; a < 10; a++ {
      fmt.Printf("a 的值为: %d\n", a)
   }

   for a < b {
      a++
      fmt.Printf("a 的值为: %d\n", a)
   }

   for i,x:= range numbers {
      fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)

函数

func cal(price, num int) int {
   total := price * num
   return total
}

func rectProps(length, width float64)(area, perimeter float64) {  
    area = length * width
    perimeter = (length + width) * 2
    return // 不需要明确指定返回值，默认返回 area, perimeter 的值
}

空白符

_ 代替未用到的变量
 area, _ := rectProps(10.8, 5.6) 

if else
if condition {  
} else if condition {
} else {
}

### 常量 const
switch case
 finger := 4
    switch finger {
    case 1:
        fmt.Println("Thumb")
fallthrough   //继续执行case
    case finger >= 2:
        fmt.Println("Index")
case finger >= 2:
        fmt.Println("Index")
default:
fmt.Println("Defalut")

数组 [n]T

Go 语言中不允许混合不同类型的元素
interface{} 类型数组，可以包含任意类型
 var a [3]int
 a := [3]int{12, 78, 50}
 a := [3]int{12}
 num := [...]int{5, 6, 7, 8, 8}
 for i, v := range a {//range returns both the index and value  //_,v 
        fmt.Printf("%d the element of a is %.2f\n", i, v)
        sum += v

多维数组

a := [3][2]string{
   {"lion", "tiger"},
   {"cat", "dog"},
   {"pigeon", "peacock"}, // this comma is necessary. The compiler will complain if you omit this comma
}

切片

fruitslice := fruitarray[1:3]
//make切片  
i := make([]int, 5, 5)
//添加
car = append(car,"Toyata")
### 长度和容量
len(cars)   和  cap(cars)
### 数组相加
veggies := []string{"potatoes", "tomatoes", "brinjal"}
fruits := []string{"oranges", "apples"}
food := append(veggies, fruits...)

字典

personSalary := make(map[string]int)

指针

b := 255
var a *int = &b

结构体

type Employee struct {  
    firstName, lastName string
    age, salary         int
}

匿名结构体

var employee struct {
    firstName, lastName string
    age int
}

方法

func (e Employee) displaySalary() {       //e Employee 接收器 e
    fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)
}

func main() {
    emp1 := Employee {
        name:     "Sam Adolf",
        salary:   5000,
        currency: "$",
    }
    emp1.displaySalary() // 调用 Employee 类型的 displaySalary() 方法
}

信道

a := make(chan int)
data := <- a // 读取信道 a  
a <- data // 写入信道 

类型断言与选择

• 类型断言

package main

import "fmt"

func assert(i interface{}) {
   v,ok := i.(int)
   fmt.Println(v,ok)
}
func main() {
   var s interface{} = "hello"
   assert(s)
   var i interface{}  = 56
   assert(i)
}

• 类型选择（Type Switch）

package main

import (
   "fmt"
)

func findType(i interface{}) {
   switch i.(type) {
   case string:
      fmt.Printf("I am a string and my value is %s\n", i.(string))
   case int:
      fmt.Printf("I am an int and my value is %d\n", i.(int))
   default:
      fmt.Printf("Unknown type\n")
   }
}
func main() {
   findType("Naveen")
   findType(77)
   findType(89.98)
}

接口与空接口

• 接口

package main

import "fmt"

//创建VowelsFinder的接口  该接口有一个 FindVowels 的 方法
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 == 'u'|| rune == 'o'{
         vowels =append(vowels,rune)
      }
   }
   return vowels
}

func main() {
   name := MyString("sam Anderson")
   var v VowelsFinder
   v = name
   fmt.Printf("Vowels are %c",v.FindVowels())
}

• 空接口

package main

import (
   "fmt"
)

func describe(i interface{}) {
   fmt.Printf("Type = %T, value = %v\n", i, i)
}

func main() {
   s := "Hello World"
   describe(s)
   i := 55
   describe(i)
   strt := struct {
      name string
   }{
      name: "Naveen R",
   }
   describe(strt)
}
}

接口用途

package main

import "fmt"

type SalaryCal interface {
   Cal() int
}

// 长期员工 薪资是 basicpay 与 pf 相加之和
type Parmanent struct {
   empId int
   basicpay int
   pf int
}

//合同员工 只有基本工资 basicpay
type Contract struct {
   empId int
   basicpay int
}

func (p Parmanent) Cal() int {
   return p.basicpay +  p.pf
}

func (c Contract) Cal() int {
   return c.basicpay
}

//接收一个 SalaryCalculator 接口的切片（[]SalaryCalculator）作为参数
func totalExpense(s []SalaryCal){
   expense := 0
   for _,v := range s{
      expense += v.Cal()
   }
   fmt.Printf("Total Expense Per Month $%d",expense)
}

func main() {
   pemp1 := Parmanent{1,5000,20}
   pemp2 := Parmanent{2,6000,30}
   cemp1 := Contract{3,3000}
   employees := []SalaryCal{pemp1,pemp2,cemp1}
   totalExpense(employees)
}

指针

指针
尽管 Go 语言没有提供继承机制，但可以通过嵌套其他的接口，创建一个新接口。
和 & 可以互相抵消,同时注意，&可以抵消掉，但&是不可以抵消的 a和&a是一样的，都是a的值，值为1 (因为&互相抵消掉了) 同理，a和&&&&a是一样的，都是1 (因为4个&互相抵消掉了)