Go开发连接MYSQL、Go取得随机字符串的三种方法代码 以及使用Go实现冒泡排序和快速递归

一、Go语言开发中连接MYSQL数据库

最近闲余时间接触了一点GO，真不知道它好用在哪，在Go语言中没有类（Class）的概念，然而编程又离不开面向对象，于是GO说我没有类的概念，但我也能实现面向对象编程。在Go中使用结构体（Structs）对属性进行封装，结构体就像是类的一种简化形式。然后再在Go中定义一些方法并且作用在接收者（receiver）上的一个函数，简单描述就是GO中没有类的概念，但你可以定义一个Struct结构，当作类。这个结构中的属性当做类的属性，然后单独定义一些方法挂载到这个结构上，模拟出了一个类。但感觉还是挺别扭的。

而在使用GO语言连接数据库查询数据时，又感觉到好繁琐。连接MYSQL查出数据，然后使用GO进行循环迭代都不是一个容易的事，实现如下：

#GO中的控制器
package controllers
import (
    "database/sql"
    "fmt"
    "github.com/astaxie/beego"
    _ "github.com/go-sql-driver/mysql"
)

type MainController struct {
    beego.Controller
}

#连接MYSQL读取数据
func (c *MainController) Get() {
    #连接MYSQL
    db, err := sql.Open("mysql", "test:test@tcp(10.15.80.74:3307)/database_name?charset=utf8")
    #查询数据库
    rows, _ := db.Query("SELECT id,title,updateTime FROM article")

    #第一种方式把数据处理好用的二维map
    cols, _ := rows.Columns()
    vals := make([][]byte, len(cols))
    scans := make([]interface{}, len(cols))
    for k, _ := range vals {
        scans[k] = &vals[k]
    }

    i := 0
    result := make(map[int]map[string]string)
    for rows.Next() {
        rows.Scan(scans...)
        row := make(map[string]string)
        for k, v := range vals {
            key := cols[k]
            row[key] = string(v)
        }
        result[i] = row
        i++
    }
    fmt.Println(result)
    
    #第二种方式直接scan数据中的字段，但字段必须一一对应，不能疏漏。
    id := 0
    title := ""
    updateTime := 0
    var enterprise []type = make([]type, 15)
    for rows.Next() {
         rows.Scan(&id, &title, &updateTime)
         fmt.Println(id, title, updateTime)
    }

    db.Close()
}

第一种方式的实现应该是我们需要的普遍好用的方式，但GO实现起来感觉有点费力，取某一行的数据时必须来指定列名，且和查出来的数据要一一对应，所以要做成通用的取数据办法就必须需要先扫出列名，然后循环根据列名scan取得一行记录的各个值。

第二种方式比较快，但在scan的时候必须先要定义好变量，并且指定变量来取得值，这个时候如果数据表中增加一个字段，整个都需要改动，感觉有点麻烦啊。

二、使用Go取得随机字符串的三种方法代码示例

使用GO取得随机字符串的代码方法示例，用了三种方法，差异也不是很大，不过可以在使用中熟悉GO的string库中的一些函数方法，三种方法包括使用字符串拼接的方法；将字符写入slice通过join连接的方法，比第一种方法看起来好些;第三种是通过先打乱slice然后从slice中截取字符串。

1. 第一种方法：使用字符串拼接

使用字符串拼接取得随机字符串代码示例：

#取得随机字符串:使用字符串拼接
func getRandstring(length int) string {
    if length < 1 {
        return ""
    }
    char := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    charArr := strings.Split(char, "")
    charlen := len(charArr)
    ran := rand.New(rand.NewSource(time.Now().Unix()))

    var rchar string = ""
    for i := 1; i <= length; i++ {
        rchar = rchar + charArr[ran.Intn(charlen)]
    }
    return rchar
}

2. 第二种方法：写入slice通过join连接

写入slice通过join连接取得随机字符串代码示例：

#取得随机字符串：写入slice通过join连接
func getRandstring2(length int) string {
    if length < 1 {
        return ""
    }
    char := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    charArr := strings.Split(char, "")
    charlen := len(charArr)
    ran := rand.New(rand.NewSource(time.Now().Unix()))

    rchar := make([]string, 0, length)
    for i := 1; i <= length; i++ {
        rchar = append(rchar, charArr[ran.Intn(charlen)])
    }
    return strings.Join(rchar, "")
}

3. 第三种方法：通过打乱slice来操作

通过打乱slice来操作取得随机字符串代码示例：

#取得随机字符串：通过打乱slice来操作
func getRandstring3(length int) string {
    if length < 1 {
        return ""
    }
    char := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    charArr := strings.Split(char, "")
    ran := rand.New(rand.NewSource(time.Now().Unix()))

    l := len(charArr)
    for i := l - 1; i > 0; i-- {
        r := ran.Intn(i)
        charArr[r], charArr[i] = charArr[i], charArr[r]
    }
    rchar := charArr[:length]
    return strings.Join(rchar, "")
}

三、使用Go实现冒泡排序和快速递归

 偶尔有空的时候，了解一下GO也挺有意思的，刚开始使用GO编程还不是很熟练，今天尝试着使用GO实现了一下冒泡排序,快速排序算法。在期间也发现GO语言有几个小的区别，一是字符串不能使用单引号，一开始没意识到这个区别，编译的时候总是报错。二是函数function如果有返回值，在定义的时候一定要在后面加上返回类型定义，不然不会有返回值的。而

如果定义了返回值类型，在函数体中又没有返回值，这时也会报错误，GO控制得很严谨。更严谨的是你定义了一个变量，如果在后面的代码中没有使用这个变量，GO也会报错提示变量未使用、或者import导入的类未使用等，这会让我们去检查很多垃圾代码和垃圾导入。

调用方法的代码部分：

package main

import (
    "fmt"
)

//使用GO语言实现冒泡排序算法和快速递归算法
func main() {
    var arr = []int{10, 5, 6, 34, 99, 1, 24, 56, 16, 33, 77, 9, 24}
    fmt.Println("排序前数组")
    fmt.Println(arr)
    fmt.Println("冒泡排序：后")
    fmt.Println(BubbleSort(arr))
    fmt.Println("快速排序：后")
    fmt.Println(quickSort(arr))
}

1. 使用GO语言实现冒泡排序算法：

//Go语言实现冒泡排序
func BubbleSort(arr []int) []int {
    var length = len(arr)
    var temp int
    for i := 0; i < length; i++ {
        for j := i + 1; j < length; j++ {
            if arr[i] > arr[j] {
                temp = arr[i]
                arr[i] = arr[j]
                arr[j] = temp
            }
        }
    }
    return arr
}

2. 使用Go语言实现快速排序算法：

//Go语言实现快速排序
func quickSort(arr []int) []int {
    length := len(arr)
    if length <= 1 {
        return arr
    }
    flag := arr[0]
    var sleft = make([]int, 0, length)
    var sright = make([]int, 0, length)
    for i := 1; i < length; i++ {
        if flag > arr[i] {
            sleft = append(sleft, arr[i])
        } else {
            sright = append(sright, arr[i])
        }
    }

    sleft = quickSort(sleft)
    sright = quickSort(sright)
    returnArr := append(sleft, flag)
    returnArr = append(returnArr, sright...)

    return returnArr
}