Go语言入门系列一

为什么要学Go语言？

1. 开发效率和运行效率二者的完美融合，天生的并发编程支持。
2. 完善的标准库包括互联网应用、系统编程和网络编程。
3. 部署起来非常的方便
4. 拥有强大的编译检查、严格的编码规范和完整的软件生命周期工具

编译方式

方式一：直接运行

go run xxxx.go

方式二：build方式

go build xxx.go

变量声明

Go 语言的变量的声明都是类型信息放在变量之后

/// 如下：
var v1 int 
var v2 string
var v3 [10]int  //数组
var v4 []int  //数组切片
var v5 struct {
 f int
}
var v6 * int
var v7 map[string] int  // map 类型 key 为string value 为int类型
var v8 func(a int) int

// var 可以把var 关键词使用花括号括起来 这样可以不用重复写var
var {
    v1 int
    v2 string
}

变量的初始化方式

var v1 int = 10
var v2 = 10  //可以自动推断类型
v3 := 10   // 可以是这样初始化一个变量  
//缺点：不能提供数据类型、只能在函数内部

三种类型声明的变量都不应该声明过 否则会出现编译错误

避免想修改全局变量结果不小心定义了一个新的局部变量。

变量赋值

// 新式的赋值方式
i , j = j , i   //可以用来交换两个变量

// 在接受函数的返回值的时候可以提供匿名变量

func GetName() (firstName, lastName, nickName string){
 return "MAy" , "Chan" , "Chibi Maruko"
}

//此时如果只想获得nickName的话可以
_, _, nickName := GetName

退化赋值

前提：最少有一个新变量被定义，且必须是同一作用域

func main(){
 x := 100

 ···

 x := 200  //不满足至少一个新变量被定义，不会出现退化赋值

    //x,y :=200, 300  //满足条件，会出现退化赋值
    {
       //x,y := 200, 300  //不在同一作用域，不会出现退化赋值
    }

}

通常err变量利用退化赋值，来实现重复使用

常量

Go 中常量类型可以是数值类型等

//使用const 可以用来定义常量
const pi float64 = 3.1415
cosnt zero = 0.0
const  {
 size int64 = 10
 eof = -1
}

const u , v  float32 = 0.3
const a, b , c = 3 , 4 , "foo"

cosnt mask = 1 << 3  // 这样是可以的因为这在编译期间是可以确定的

//预定义常量 true false iota
//iota是一个每次出现都会自增1 的值  其在每个const的开头都被重置为0

cosnt {
    c0 = iota //0
    c1 = iota   //1
    c3 = iota //2
}
//或者
const{
    c0 = iota //0
    c1   //1 
    c3   //2
}

cosnt x = iota //0
const y = iota //0

布尔类型不能够转换为其它类型

两种不同类型的整数是不能进行比较的

取反在C语言中是 ~x ,在go 中是 ^x

浮点数不是一种精确的表示方式所以不要直接比较可以使用函数 IsEqual() 函数来比较

复数类型

var value complex64  // 实际是由float32构成的复数类型

//三种赋值形式
value = 3.2 + 12i
value := 3.2 + 12i
value := complex(3.2, 12)

//可以使用real(value) 来获取实部
//可以使用imag(value)获取虚部 

字符串类型

**字符串可以用来初始化 ，但是和数组不同 不可以再次改变否则会编译错误，不过可以向数组一样进行下表的字符取值 **

我们常常使用len函数来对字符串进行长度的获取

Go语言支持UTF-8编码 因此可以中英文混在一起，源文件注意保存为UTF-8形式

我们常常使用iconv库来处理文本文档

每个中文字符在UTF-8中占3个字节

//两种遍历方式

//以字符数组方式进行遍历
str := "Hello,世界"
n := len(str)
for i := 0 , i < n , i++ {
 ch := str[i]
}
//以Unicode方式遍历
for i , ch := range str{
 fmt.Println(i, ch)
}

引用类型

包含：silice、map、channel这三种预定义类型

引用类型除分配内存外，还须初始化一系列属性，诸如指针、长度、甚至包括哈希分布和数据队列

new 函数可为引用类型分配内存，但是这不是完整创建的。仅分配了数据类型本身(指针包装)所需的内存，并没有分配键值存储的内存，也没有初始化一些内部属性

类型转换要求：显式类型转换

自定义类型

使用关键字type定义用户自定义类型，包括基于现有基础类型创建，或者是结构体、函数类型等

注意：即便指定了基础类型，也只表面它们有相同的底层数据结构，两者间不存在任何关系，属于完全不同的两种类型。除操作符外，自定义类型不会继承基础类型的其他信息(包括方法)。不能视为别名，不能隐式转换，不能直接用于比较表达式

type flags byte
const {
    read flags = 1 << itoa
    write
    exec
}
func main() {
    f := read | exec 
    fmt.Printf("%b\n",f)   //输出二进制标记位
}

未完待续...