总结Go的一些特性

1、变量定义的几种方式 如：

    //方式一：普通定义
    var a int = 1
    fmt.Println("a = ", a)
    //方式二：类型推导
    var b = 10
    fmt.Println("b = ", b)
    //方式三：省略var
    name := "tom"
    fmt.Println("name = ", name)
    //多变量声明
    var n1, n2, n3 int
    fmt.Println("n1 = ",n1 ,"n2 = ", n2,"n3 = ",n3)

    var n4, name1, n5 = 100, "tom", 888
    fmt.Println("n4 = ",n4 ,"name1 = ", name1,"n5 = ",n5)

    n6, name2, n7 := 100, "tom", 888
    fmt.Println("n6 = ",n6 ,"name2 = ", name2,"n7 = ",n7

2、go语言定义的变量或引入的必须使用否则报错，可以使用忽略保留定义和包引入

如：

package main

  import (
    "fmt"
    _ "bytes" //忽略bytes包
    )


  func main () {

    var num1 int = 10
    _ = num1  //忽略变量
    fmt.Println("hello world")

  }

3、花括号换行报错

//正确的
func main () {
    fmt.Println("hello world")
}

//错误的
func main ()
{
    fmt.Println("hello world")
}

4、函数可以返回多个值

package main
import (
    "fmt"
    )

func main () {
    var num1 int = 10
    var num2 int = 1  
    //接收两个值
    sum , sub := getSumAndSub(num1, num2)
    fmt.Println("sum =",sum, "sub =", sub)
    //只接收一个值
    sum0 , _ := getSumAndSub(num1, num2)
    fmt.Println("sum =",sum0)
}
//返回两个值
func getSumAndSub(num1 int, num2 int) (int, int) {
    sum := num1 + num2
    sub := num1 - num2
    return sum, sub
}

5、go没有字符类型（char）,一般用byte类型来表示，并且go中的编码是统一使用utf8，每个字符都会有一个固定的码值

    //go没有字符类型
    var c1 byte = 'a'
    var c2 byte = '1'
    //输出的都是码值
    fmt.Println("c1", c1, "c2", c2)
    //输出对应的字符
    fmt.Printf("c1=%c c2=%c", c1, c2)
    //汉字
    var c3 byte = '被'//溢出
    fmt.Printf("c3=%c c3码值=%d", c3, c3)

    var c4 int = '被'
    fmt.Printf("c4=%c c4码值=%d", c4, c4)

    //输出码值对应的字符
    var c5 int = 22269
    fmt.Printf("c5=%c", c5)

6、字符串（string）一旦赋值就不能通过下标来修改

var str2 = "hello"
//str2[0] = 'a'  //报错

7、以字符串原生方式输出

var str string = `每个生命的方式是自然界一种力的方式。
有些人的生命像沉静的湖，有些像白云飘荡的一望无际的天空，
有些像丰腴富饶的平原，有些像断断续续的山峰。
我觉得约翰·克利斯朵夫的生命像一条河。
        ——罗曼.罗兰《约翰·克利斯朵夫》`
fmt.Println(str)

8、字符串+号拼接

//加号放在上一行末尾
str4 := "hello" +
    "world"
fmt.Println("str4 = ", str4)

9、与Java、c相比go的不同类型数据之间转换需要强制转换（显示转换）

   var i int32 = 10
    var f1 float32 = float32(i)
    fmt.Println("f1 = ", f1)

    var n1 int32 = 1
    var n2 int8
    var n3 int8

    n2 = int8(n1) + 127 //编译能过，但结果溢出
    //n3 = int(n1) + 128 //n3是int8 报错
    fmt.Println("n1 =", n1, "n2 =", n2," n3 =",n3)

10、string类型与其他基本类型之间的互相转换

    其他基本数据类型转string
    //第一种方式 fmt.Sprintf
    str = fmt.Sprintf("%d", num1)
    fmt.Printf("str type %T str=%v\n", str, str)

    str = fmt.Sprintf("%f", num2)
    fmt.Printf("str type %T str=%v\n", str, str)

    str = fmt.Sprintf("%t", b)
    fmt.Printf("str type %T str=%v\n", str, str)

    str = fmt.Sprintf("%c", ch)
    fmt.Printf("str type %T str=%v\n", str, str)

    //第二种方式 strconv
    str = strconv.FormatInt(int64(num1), 10)
    fmt.Printf("str type %T str=%v\n", str, str)
    string类型转其他基本数据类型
    var str1 string = "true"
    var b bool

    b, _ = strconv.ParseBool(str1)
    fmt.Printf("b type %T b=%v\n", b, b)

    var str2 string = "123456"
    var n1 int64
    n1, _ = strconv.ParseInt(str2, 10, 64)
    fmt.Printf("n1 type %T n1=%v\n", n1, n1)


    var str3 string = "123dd456"
    var n2 int64
    n2, _ = strconv.ParseInt(str3, 10, 64)
    fmt.Printf("n1 type %T n1=%v\n", n2, n2)

    var str4 string = "123"
    var n3 int64
    n3, _ = strconv.ParseInt(str4, 10, 64)
    n5 := int(n3)
    fmt.Printf("n3 type %T n1=%v\n", n3, n3)
    fmt.Printf("n5 type %T n1=%v\n", n5, n5)

    var str5 string = "123.456"
    var n4 float64
    n4, _ = strconv.ParseFloat(str5, 64)
    fmt.Printf("n1 type %T n1=%v\n", n4, n4)

11、包内变量名和函数名以及常量名，首字母大写为public，其他包可使用；首字母小写为私有方法，其他包不能使用

var HeroName string = "张飞" //公共 public
var ambitiousName string = "曹操" //私有 private

12、只有i++和i–,并且只能单独使用不能赋值

    //++  -- 只能独立使用
    var i = 8
    i++
    fmt.Println("i =",i)
    i--
    fmt.Println("i =",i)

    //错误使用
    ++i //错误
    --i //错误
    var j int;
    j = i++ //错误
    if i++ > 10 {  //错误
        return
    }

13、GOPATH的意义：

环境变量 GOPATH 的值可以是一个目录的路径，也可以包含多个目录路径，
每个目录都代表 Go  语言的一个工作区（workspace）。
这些工作区用于放置 Go 语言的源码文件（source file），
也就是以“.a”为扩展名的文件）和可执行文件（executable file）。
Go 语言项目在其生命周期内的所有操作
（编码、依赖管理、构建、测试、安装等）
基本上都是围绕着 GOPATH 和工作区进行的。