golang（一） | 易学教程

开篇先来个Go语言的吉祥物-金花鼠Gordon。

golang是谷歌2009年发布的开源编程语言，截止目前go的release版本已经到了1.10。go语言的开发人员都是计算机界大神一般的存在：

Thompson：1983年图灵奖（Turing Award）和1998年美国国家技术奖（National Medal of Technology）得主。他与Dennis Ritchie是Unix的原创者。Thompson也发明了后来衍生出C语言的B程序语言。
Pike：曾是贝尔实验室（Bell Labs）的Unix团队，和Plan 9操作系统计划的成员。他与Thompson共事多年，并共创出广泛使用的UTF-8字元编码。
Robert Griesemer：曾协助制作Java的HotSpot编译器，和Chrome浏览器的JavaScript引擎V8。
Russ Cox：Plan 9开发者
Ian Taylor：曾改善已广泛使用之开源码编译器GCC

主要的开发者：

    肯.汤姆逊(Ken Thompson)：图灵奖得主，Uinx发明人，B语言作者(C语言前身)，还做飞行员，后来被谷歌挖走。
    罗布.派克(Rob Pike)：Unix团队和Plan 9操作系统计划的成员，与Ken老爷子共事多年，并共创出广泛使用的UTF-8 字元编码。
    罗伯特.格里泽默(Robert Griesemer)：曾协助制作Java的HotSpot编译器，和Chrome浏览器的JavaScript引擎V8。
　　　　

go语言目前可以达到c/c++80%的性能，远快于c/c++的编译速度，目前很火的开源软件docker、kubernetes、lxd等软件都是使用go语言编写的，而且2016年Go语言被评为年度编程语言，可见go的应用场景非同一般。

Go语言的特点

   Go语言保证了既能到达静态编译语言的安全和性能，又达到了动态语言开发速度和易维护性，有人形容Go语言：Go = C + Python , 说明Go语言既有C静态语言程序的运行速度，又能达到Python动态语言的快速开发。
Go语言有以下特性：

1.自动垃圾回收

    C/C++最头疼的就是指针问题，一不小心就野指针了或者又越界了。在Go语言里再也不用担心，也不用考虑delete或者free，系统自动会回收。

2.函数可以返回多个值

    这个很神奇，大多数语言只能返回一个值，Go语言可以返回多个值。这个功能使得开发者再不用绞尽脑汁的想到底怎么返回值的设计，也不用为了传值专门定义一个结构体。

3.并发编程

    Go语言天然并发，只需要关键字“go”就可以让函数并发执行，使得并发编程变得更为简单，这也是Go语言最大的优势。

golang支持多变量同时定义：

package main

import (
    "fmt"
)
func main()  {
    //演示如何一次性声明多个变量
    //方式一
    var n1, n2, n3 int
    fmt.Println("n1=", n1, "n2=", n2, "n3=", n3)
    //方式二
    var m1 , name, m2 = 1, "tom", 3
    fmt.Println("m1=", m1, "name=", name, "m2=", m2)
    //方式三
    a1, char, a2 := 1, "jack", 2
    fmt.Println("a1=", a1, "char=", char, "a2=", a2)
    //soeasy！
}

数据类型的相互转换：

golang和java/c 不同 ，GO在不同的类型的变量之间赋值是需要显示转换，也就是说golang中的数据类型不能自动转换。
    表达式 T（v）将值v转换为类型T
       T：就是数据类型，比如 int32， int64， float32等等
        v:就是需要转换的变量
package main

import (
    "fmt"
    _"reflect"
)
func main()  {
    var(
        i int32 = 100
        n1 float32 = float32(i)
        n2 int8 = int8(i)
        n3 int64 = int64(i)
        
    )
    fmt.Printf("i=%v n1=%v n2=%v n3=%v\n", i, n1, n2, n3)
   // fmt.Println(reflect.TypeOf(i),
   //             reflect.TypeOf(n1),
   //             reflect.TypeOf(n2),
   //             reflect.TypeOf(n3))

　　　　　　　fmt.Printf("%T %T %T %T", i, n1, n2, n3)

结果：

溢出处理：
func main()  {
    var(
        i int32 = 200
        n1 float32 = float32(i)
        n2 int8 = int8(i)
        n3 int64 = int64(i)
        
    )
    fmt.Printf("i=%v n1=%v n2=%v n3=%v\n", i, n1, n2, n3)
    //fmt.Println(reflect.TypeOf(i), reflect.TypeOf(n1), reflect.TypeOf(n2), reflect.TypeOf(n3))
    fmt.Printf("%T %T %T %T", i, n1, n2, n3)

如下：int32 转成 int8（-128 -- 127），编译时不会出错，只是转换的结果是按溢出

处理，和我们开始想象的结果不一样，因此在住转换是，需要考虑范围问题！

三元运算：

在一些语言中：
 var int a = 10
 var int b = 20
    a = a + b
    a = a - b
    b = a - b

官方FAQ的说明在这里：
 http://golang.org/doc/faq#Does_Go_have_a_ternary_form
官方FAQ推荐的做法是用 if 代替：
if expr {
    n = trueVal
} else {
    n = falseVal
}
不过用 if 的问题是变量 n 有作用域问题. 我们需要在 if 之前先定义变量 n，这样才可以在 if 语句之后使用变量 n。

var n int
if expr {
    n = trueVal
} else {
    n = falseVal
}
println(n)

本来一个简单的 n := expr? trueVal: falseVal 就能够表达的问题，变的复杂了很多。 这和Go所追求的简单思路是有冲突的。

类似的有 max/min 等函数。因为这类函数使用频度比较高，在很多pkg的内部都定义了私有的实现。

func max(a, b int) int {
    if a < b {
        return b
    }
    return a
}

golang中的三元运算

golang支持在if语句中设置一个变量

if a := 10 ; a > 5{
    fmt.Println("IG")
}

字符串遍历：

package main
import(
    "fmt"
)
    //字符串遍历方式--传统方式
func main()  {
        //一般的遍历方式
    var str string = "hello,world"
　　//str2 := []rune(str)　　把str转成 []rune（切片）
    for i := 0; i < len(str); i++{ 
        fmt.Printf("%c\n", str[i])　　//　 fmt.Printf("%c", str2[i])  
} 
//for-range遍历方式
    str = "adc*ok"
    for index, val := range str {
        fmt.Printf("index=%d, val=%c \n", index, val)
}
//对应for-range遍历方式而言，是按照字符来遍历的，就不是按照字节来遍历的！
}

如何用for循环实现while/do...while

//golang）没有do...while/while
//while循环的实现
func main()  {
    var i int = 1
    for {
        if i > 10 {  ///循环条件
            break  //跳出循环
        }
        fmt.Println("i=", i)
        i++  //循环迭代
    }
    fmt.Println(i)
}
//do...while循环的实现
func main()  {
        var j int = 1
        
        
        for {
        fmt.Println("j=", j)
        j++
            if j > 10 {
                break
            }
        fmt.Println(i)    
            
        }
}

break指定标签：

//break指定标签lable2:
for i := 0; i < 4; i++{　　lable1:
    for j := 0; j < 10; j++{
        if j == 2{
           // break  //break 默认跳出最近的for循环
          //  break lable1
         break lable2  // j = 0   j = 1
        }
        fmt.Println("j = ", j)
    }
}
break默认跳出最近的for循环
break 后面可以有指定的标签，跳出标签的对面for循环

将数字输出为unicode码值：

package main

import (
    "fmt"
)
func main()  {
    
     var(
        c1 = 73
        c2 = 71
        c3 = 29275
        c4 = 36924
     )
    
    fmt.Printf("%c", c1)
    fmt.Printf("%c", c2)
    fmt.Printf("%c", c3)
    fmt.Printf("%c", c4)
}

结果：

//内存四区模型
//低地址

代码区：计算机指令

数据区：{
    初始化数据区
    未初始化数据区
    常量区
}

堆区：一个很大的空间在使用是开辟空间结束的释放

栈区：存放函数信息函数内部定义的常量
//高地址

内存四区

来源：https://www.cnblogs.com/zeroLJ/p/11753858.html

标签

golang

go语言

main函数

printf

typeof