原创

Go初步使用

Go简介

Go是一种开源编程语言,可以轻松构建简单可靠高效的软件。

Go有什么优势

  • 可直接编译成机器码,不依赖其他库,glibc的版本有一定要求,部署就是扔一个文件上去就完成了。
  • 静态类型语言,但是有动态语言的感觉,静态类型的语言就是可以在编译的时候检查出来隐藏的大多数问题,动态语言的感觉就是有很多的包可以使用,写起来的效率很高。
  • 语言层面支持并发,这个就是Go最大的特色,天生的支持并发,我曾经说过一句话,天生的基因和整容是有区别的,大家一样美丽,但是你喜欢整容的还是天生基因的美丽呢?Go就是基因里面支持的并发,可以充分的利用多核,很容易的使用并发。
  • 内置runtime,支持垃圾回收,这属于动态语言的特性之一吧,虽然目前来说GC不算完美,但是足以应付我们所能遇到的大多数情况,特别是Go1.1之后的GC。
  • 简单易学,Go语言的作者都有C的基因,那么Go自然而然就有了C的基因,那么Go关键字是25个,但是表达能力很强大,几乎支持大多数你在其他语言见过的特性:继承、重载、对象等。
  • 丰富的标准库,Go目前已经内置了大量的库,特别是网络库非常强大,我最爱的也是这部分。
  • 内置强大的工具,Go语言里面内置了很多工具链,最好的应该是gofmt工具,自动化格式化代码,能够让团队review变得如此的简单,代码格式一模一样,想不一样都很困难。
  • 跨平台编译,如果你写的Go代码不包含cgo,那么就可以做到window系统编译linux的应用,如何做到的呢?Go引用了plan9的代码,这就是不依赖系统的信息。
  • 内嵌C支持,前面说了作者是C的作者,所以Go里面也可以直接包含c代码,利用现有的丰富的C库。

Go适合用来做什么

  • 服务器编程,以前你如果使用C或者C++做的那些事情,用Go来做很合适,例如处理日志、数据打包、虚拟机处理、文件系统等。
  • 分布式系统,数据库代理器等
  • 网络编程,这一块目前应用最广,包括Web应用、API应用、下载应用、
  • 内存数据库,前一段时间google开发的groupcache,couchbase的部分组建
  • 云平台,目前国外很多云平台在采用Go开发,CloudFoundy的部分组建,前VMare的技术总监自己出来搞的apcera云平台。

Go成功的项目

nsq:bitly开源的消息队列系统,性能非常高,目前他们每天处理数十亿条的消息
docker:基于lxc的一个虚拟打包工具,能够实现PAAS平台的组建。
packer:用来生成不同平台的镜像文件,例如VM、vbox、AWS等,作者是vagrant的作者
skynet:分布式调度框架
Doozer:分布式同步工具,类似ZooKeeper
Heka:mazila开源的日志处理系统
cbfs:couchbase开源的分布式文件系统
tsuru:开源的PAAS平台,和SAE实现的功能一模一样
groupcache:memcahe作者写的用于Google下载系统的缓存系统
god:类似redis的缓存系统,但是支持分布式和扩展性
gor:网络流量抓包和重放工具

初步使用Go以及其特性

package main

//导入fmt库
import "fmt"

/**
Main函数入口
@Author:lzhpo
@Description:

func:go中的函数以func开头。

fmt就是一个库。


GoLang特性

1. 垃圾回收:
        a. 内存自动回收,再也不需要开发人员管理内存。
        b. 开发人员专注业务实现,降低了心智负担。
        c. 只需要new分配内存,不需要释放。

2. 天然并发:
        a. 从语言层面支持并发,非常简单。
        b. goroute,轻量级线程,创建成千上万个goroute成为可能。
        c. 基于CSP(Communicating Sequential Process)模型实现。
            for i := 0 ; i < 100; i++ {    //i := 0,省略自己定义类型,会自动帮你加上类型。
                go fmt.Println(i) //发现并不是按顺序输出的,这就是go的天然并发。
            }

3. channel:
        a. 管道,类似unix/linux中的pipe。
        b. 多个goroute之间通过channel进行通信。
        c. 支持任何类型。
            func main() {
                pipe := make(chan int,3)
                pipe <- 1
                pipe <- 2
            }

4. 多返回值
        a. 一个函数返回多个值。
            func calc(a int, b int)(int,int) {
                sum := a + b
                avg := (a+b)/2
                return sum, avg
            }

*/
func main() {
    //演示Hello World
    fmt.Println("====================演示Hello World====================")
    fmt.Println("Hello World")

    //演示加法操作
    fmt.Println("====================演示加法操作====================")
    //var c int
    //c = add(100, 200) //如果c没有被使用,将不通过编译,这样子减少了多余的代码
    c := add(100, 200)
    fmt.Println(c)

    //演示多个返回值
    fmt.Println("====================多个返回值====================")
    testReturnMany(100, 200)

    //演示管道操作
    fmt.Println("====================管道操作====================")
    testPipe()

    //演示非并发
    fmt.Println("====================非并发====================")
    testNotGoroute()
    //演示并发操作
    fmt.Println("====================Go并发====================")
    testGoroute()

}


/**
多个返回值
 */
func testReturnMany(a int, b int) (int, int) {
    sum := a + b
    avg := (a + b) / 2
    fmt.Println(sum)
    fmt.Println(avg)
    return sum, avg //多个返回值
}

/**
管道操作

var pipe chan int
pipe = make(chan int, 3)
和
pipe := make(chan int, 3)
是一样的,下面的更简洁,Go会自动转换类型。
 */
func testPipe() {

    pipe := make(chan int, 3) //pipe管道,make和Java的new类似;类型为int,长度为3

    pipe <- 1
    pipe <- 2
    pipe <- 3

    //取出一个数据(先取出最先放进去的那个)
    var t1 int
    t1 =<- pipe
    fmt.Println("取出管道一个数据:", t1)

    //打印管道的长度
    fmt.Println("管道长度为:", len(pipe))
}

/**
并发操作,乱序输出,只需要在前面加上一个关键字go即可。
*/
func testGoroute() {
    for i := 0 ; i < 100; i++ {    //i := 0,省略自己定义类型,会自动帮你加上类型。
        go fmt.Println(i) //发现并不是按顺序输出的,这就是go的天然并发。
    }
}

/**
非并发,顺序输出,为了和并发对比,看效果。
 */
func testNotGoroute() {
    for i := 0; i < 100 ; i++ {
        fmt.Println(i)
    }
}

/**
加法操作
 */
func add(a int, b int) int{ //第一个和第二个是传入的类型(先写变量名字,再写变量类型),第三个是返回的变量类型。
    var sum int //go定义变量,先var,后变量名,最后变量类型。
    sum = a + b
    return sum
}
↓↓↓ 打开微信关注我的微信公众号 ↓↓↓

会打篮球的程序猿

领取精品免费学习资料哦~
正文到此结束
相关文章
本文目录