GO从入门到进阶教程系列 - 研发高性能ORM框架入门

2019-03-16 10:52:02 496

        随着GO语言市场占比越来越高,我也开始转向使用GO开发项目;因为GO有好几大优点,比如容并发与协程,消息通讯,丰富的数据类型,函数多返回值,defer延迟处理机制,高性能易用的http服务,编程规范等等;也存在一些弱点,由于自身语言机制问题,导致GO不能像JAVA一样使用异常捕获机制,以及本身GO的异常处理机制让开发者倍感别扭;

技术版权归属 广州市金狮网络科技有限公司 (https://kingc.cn/) ,如需商用请联系公司

基本介绍已经完毕我们开始进入开发主题,开发一个我们常用的高性能ORM框架,首先我们先熟悉下GO的语法

1. 基础的hello world

package main

import "fmt"

func main() {
   /* 这是我的第一个简单的程序 */
   fmt.Println("Hello, World!")
}
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

2. 基础的变量声明和函数声明

package main

import "fmt"

func main() {
  _,numb,strs := numbers() //只获取函数返回值的后两个
  fmt.Println(numb,strs)
}

//一个可以返回多个值的函数
func numbers()(int,int,string){
  a , b , c := 1 , 2 , "str"
  return a,b,c
}
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

3. 基础常用的数组声明

package main

import "fmt"

func main() {
   var n [10]int /* n 是一个长度为 10 的数组 */
   var i,j int

   /* 为数组 n 初始化元素 */         
   for i = 0; i < 10; i++ {
      n[i] = i + 100 /* 设置元素为 i + 100 */
   }

   /* 输出每个数组元素的值 */
   for j = 0; j < 10; j++ {
      fmt.Printf("Element[%d] = %d\n", j, n[j] )
   }
}
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

4. 基础指针声明(类似C语言指针,必会)

package main

import "fmt"

func main() {
   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &a  /* 指针变量的存储地址 */

   fmt.Printf("a 变量的地址是: %x\n", &a  )

   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量储存的指针地址: %x\n", ip )

   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )
}
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

5. 基础结构体声明(类似JAVA的实体,必会)

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}


func main() {

    // 创建一个新的结构体
    fmt.Println(Books{"Go 语言", "kingc.cn", "Go 语言教程", 6495407})

    // 也可以使用 key => value 格式
    fmt.Println(Books{title: "Go 语言", author: "kingc.cn", subject: "Go 语言教程", book_id: 6495407})

    // 忽略的字段为 0 或 空
   fmt.Println(Books{title: "Go 语言", author: "kingc.cn"})
}
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

6. 常用的map集合声明

package main

import "fmt"

func main() {
    var countryCapitalMap map[string]string /*创建集合 */
    countryCapitalMap = make(map[string]string)

    /* map插入key - value对,各个国家对应的首都 */
    countryCapitalMap [ "France" ] = "Paris"
    countryCapitalMap [ "Italy" ] = "罗马"
    countryCapitalMap [ "Japan" ] = "东京"
    countryCapitalMap [ "India " ] = "新德里"

    /*使用键输出地图值 */ for country := range countryCapitalMap {
        fmt.Println(country, "首都是", countryCapitalMap [country])
    }

    /*查看元素在集合中是否存在 */
    captial, ok := countryCapitalMap [ "美国" ] /*如果确定是真实的,则存在,否则不存在 */
    /*fmt.Println(captial) */
    /*fmt.Println(ok) */
    if (ok) {
        fmt.Println("美国的首都是", captial)
    } else {
        fmt.Println("美国的首都不存在")
    }
}
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

7. 接口与实现类声明(类似JAVA接口实现类,必会)

package main

import (
    "fmt"
)

type Phone interface {
    call()
}

type NokiaPhone struct {
}

func (nokiaPhone NokiaPhone) call() {
    fmt.Println("I am Nokia, I can call you!")
}

type IPhone struct {
}

func (iPhone IPhone) call() {
    fmt.Println("I am iPhone, I can call you!")
}

func main() {
    var phone Phone

    phone = new(NokiaPhone)
    phone.call()

    phone = new(IPhone)
    phone.call()

}
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

8. 错误异常声明(异常机制,必会)

package main

import (
    "fmt"
)

// 定义一个 DivideError 结构
type DivideError struct {
    dividee int
    divider int
}

// 实现 `error` 接口
func (de *DivideError) Error() string {
    strFormat := `
    Cannot proceed, the divider is zero.
    dividee: %d
    divider: 0
`
    return fmt.Sprintf(strFormat, de.dividee)
}

// 定义 `int` 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
    if varDivider == 0 {
        dData := DivideError{
            dividee: varDividee,
            divider: varDivider,
        }
        errorMsg = dData.Error()
        return
    } else {
        return varDividee / varDivider, ""
    }

}

func main() {

    // 正常情况
    if result, errorMsg := Divide(100, 10); errorMsg == "" {
        fmt.Println("100/10 = ", result)
    }
    // 当被除数为零的时候会返回错误信息
    if _, errorMsg := Divide(100, 0); errorMsg != "" {
        fmt.Println("errorMsg is: ", errorMsg)
    }

}
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

9. 基础并发与通道使用示例(多线程并发与通道,必会)

package main

import "fmt"

func sum(s []int, c chan int) {
        sum := 0
        for _, v := range s {
                sum += v
        }
        c <- sum // 把 sum 发送到通道 c
}

func main() {
        s := []int{7, 2, 8, -9, 4, 0}

        c := make(chan int)
        go sum(s[:len(s)/2], c)
        go sum(s[len(s)/2:], c)
        x, y := <-c, <-c // 从通道 c 中接收

        fmt.Println(x, y, x+y)
}
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

上面的几个示例基本涵盖GO入门所需的语法与特性,下一篇文章我会讲解如何实际通过对象获取mysql数据,敬请期待!

编程语言 网络与数据通信 开发框架与中间件 gc 函数 string 高性能 type 数组

作者

aielves
TA的文章

相关文章