golang

Go的基本设计理念是：编译效率，运行效率和开发效率要三者兼顾。

【特性】
1、并行机制\协程-多核应用、网络应用
2、结构化类型-弹性模块化程序
3、机器码编译、GC、反射
4、静态类型语言-运行效率
编译器: GCCgo\6g\8g

【环境变量】
a.添加系统变量GOROOT = C:\Go
b.修改环境变量PATH = %GOROOT%\bin
c.添加系统变量GOPATH：用来设置包加载路径的重要变量，可设置多个路径，设置项目路径可下载各种依赖关系。

【关键词】
var const func type struct map interface
select defer chan fallthrough range 

【数据类型】
布尔类型
数字类型
字符串类型
派生类型：
(a) 指针类型（Pointer）
(b) 数组类型
(c) 结构化类型 (struct)
(d) 联合体类型 (union)
(e) 函数类型
(f) 切片类型
(g) 接口类型（interface）
(h) Map 类型
(i) Channel 类型
& 返回地址变量
* 返回指针变量

有符号整数 
int (位数随系统，默认) 
int8 (-128~127) 
int16 (-32768~32767) 
int32 (-2147483648~2147483647)(类似rune) 
int64 
无符号整数 
uint (位数随系统) 
uint8 (0~255)(类似byte)
uint16 (0~65535)
uint32 (0~4294967295)
uint64 
uintptr 用于存放指针
浮点 float32 float64 (默认)
复数 complex64 complex128

【变量定义】并行赋值
var vname1, vname2 type //声明后若不赋值使用默认值
var vname1, vname2 = val1, val2 //根据值自行判定变量类型
vname1, vname2 := val1, val2 //:=格式只能用在函数体内，注意 :=左侧变量不能是已经声明过的，否则编译错误
var ( 
    vname1 v_type1
    vname2 v_type2
)
交换两个变量的值，可以简单地使用 a, b = b, a
val1, val2 = ReturnVals() //一个函数多个返回值

var a int=1
var b, c, d = -1, 2.0, true
e:="foo"
const MAX int = 100
var ptr *int=&a //指针初始化为nil,值为0,ptr==nil
var ptr2 **int=&ptr//指针的指针
fmt.Println("Hello World!")
fmt.Println("a=",a,", b=",b)
fmt.Println("a=%d, b=%d",a,b)
fmt.Println(a,b,c,d,e,ptr,ptr2) //int int float64 bool string *int **int
fmt.Printf("val: %d %f %s %d %d %x \n", a,c,e,*ptr,ptr) //格式输出

常量可用作枚举
const ( 
    Female = 1
    Male = 2
)
常量可用len(), cap(), unsafe.Sizeof() 计算表达式，函数必须是内置函数
import "unsafe"
const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)
iota 特殊常量，每出现一次iota自动加1，在每次const关键字出现时被重置为0
const (
    a = iota   //0
    b              //1
    c = "ha"   //独立值，iota += 1
    d              //"ha"   iota += 1
    e = iota   //4,恢复计数
    f                  //5
)
const (
    i=1<<iota  //i=1<<0
    j=3<<iota  //j=3<<1
    k                //k=3<<2
    l                //l=3<<3
)

【switch有两种类型】
switch var1 可以是任何类型
switch 语句不需加break
表达式Switch
   var grade string = "B"
   var marks int = 90
   switch marks { //对值分支
      case 90: grade = "A"
      case 80: grade = "B"
      case 60,70 : grade = "C"
      default: grade = "D"  
   }
   switch { //对表达式分支
      case grade == "A" :
         fmt.Printf("Excellent!\n" )     
      case grade == "B", grade == "C" :
         fmt.Printf("Well done\n" )      
      case grade == "D" :
         fmt.Printf("You passed\n" )      
      case grade == "F":
         fmt.Printf("Better try again\n" )
      default:
         fmt.Printf("Invalid grade\n" );
   }
类型Switch
switch x.(type){
    case type:
       statement(s);      
    default:
       statement(s);
}
   var x interface{} //必须有接口的变量表达式{}输入
   switch i := x.(type) {
      case nil:      
         fmt.Printf("%T",i)                
      case int:      
         fmt.Printf("x is int")                       
      case float64:
         fmt.Printf("x is float64")           
      case func(int) float64:
         fmt.Printf("x is func(int)")                      
      case bool, string:
         fmt.Printf("x is bool or string")       
      default:
         fmt.Printf("don't know the type")     
   }

select是一个控制结构，类似于用于通信的switch语句。每个case必须是一个通信操作，要么是发送要么是接收。
如果有多个case都可以运行，Select会随机执行一个，其他不会执行。
如果没有case可运行（没有default），它将阻塞，直到有case可运行。
func main() {
   var c1, c2, c3 chan int
   var i1, i2 int
   select {
      case i1 = <-c1:
          fmt.Printf("received ", i1, " from c1n")
       case c2 <- i2:
          fmt.Printf("sent ", i2, " to c2n")
       case i3, ok := (<-c3):  // same as: i3, ok := <-c3
          if ok {
             fmt.Printf("received ", i3, " from c3n")
          } else {
             fmt.Printf("c3 is closedn")
          }
       default:
          fmt.Printf("no communicationn")
    }    
 }
 
【for循环有三种】
for [condition |  ( init; condition; increment ) | Range] { }
for a := 0; a < 10; a++ { }
for a < b { } //while
for { } //for(;;)  for true {}
for 循环的 range 可以对 数组、切片、字符串、集合等进行迭代循环
for index, value := range numbers1 { } //数组
for _, value := range slice1 { } //切片不需索引使用_占位
for key, value := range map1 { }
for i, c := range "go" { } //枚举Unicode字符串

//goto跳转-避免使用
var a int = 10
LOOP: for a < 20 {
  if a == 15 {
     a = a + 1
     goto LOOP
  }
  fmt.Printf("%d\n", a)
  a++     
}

【数组】-定长
var numbers1 [5] int //[0 0 0 0 0]
var numbers2 = [5]int{1, 2, 3, 4} //[1 2 3 4 0]
var numbers3 = []int{1, 2, 3, 4} //[1 2 3 4]
var numbers4 [5][5]  int
fmt.Println(numbers1)

var ptr [5] *int //指针数组，不是指向数组的指针
for  i := 0; i < 5; i++ {
  ptr[i] = &numbers2[i]
  fmt.Println(*ptr[i])
}

for i:= range numbers2 {
  fmt.Println(i,"=",numbers2[i])
}

//数组参数必须定义一致才能传递
void myFunction(param [5]int) //param := [5]int{1, 2, 3, 4}
void myFunction(param []int) //param := []int{1, 2, 3, 4}
   
【切片】-抽象数组-不定长
var numbers1 [] int //未初始化前默认为 nil，长度容量为零
printSlice(numbers1) //len=0 cap=0 slice=[]
numbers1 = []int{0,1,2,3,4,5,6,7,8}
printSlice(numbers1) //len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
printSlice(numbers1[:]) //同上
printSlice(numbers1[1:5]) //len=4 cap=8 slice=[1 2 3 4]
printSlice(numbers1[5:]) //len=4 cap=4 slice=[5 6 7 8]
printSlice(numbers1[:5]) //len=5 cap=9 slice=[0 1 2 3 4]

numbers1 = make([]int,3,5) //创建切片
printSlice(numbers1) //len=3 cap=5 slice=[0 0 0]
//想增加切片的容量，必须创建一个新的更大的切片并把原分片的内容都拷贝过来
numbers2 := make([]int, len(numbers1), (cap(numbers1))*2)
copy(numbers2,numbers1) //numbers1复制到numbers2
printSlice(numbers2) //len=3 cap=10 slice=[0 0 0]

numbers1 = append(numbers1, 9,10)
printSlice(numbers1) //len=11 cap=18 slice=[0 1 2 3 4 5 6 7 8 9 10]

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
【管道】

【集合】
var map1 map[string]string = make(map[string]string) //make定义
map1 = map[string] string {"a":"A","b":"B"} //定义
map1["c"]="C"
delete(map1,"b");
for k,v := range map1 {
   fmt.Println(k,"=",v)
}
v, ok := map1["a"]
if(ok){
  fmt.Println("a present", v)  
}

【结构体】
type Books struct {
   title string
   author string
   book_id int
}
var book1 Books
book1.title = "Go语言"
book2 := Books{"Go语言第2版", "xx","B01"}
book1=book2 //副本
var book3 *Books //结构体指针
book3=&book2 //引用
book3.title = "Go语言第3版" //访问成员跟变量一样

【函数】
func function_name( [parameter list] ) [return_types] {
   /* 函数实现 */
}

func getSum(num1, num2 int) int {
  return num1+num2
}
getSum := func(num1, num2 int) int { //定义函数变量，函数作值
  return num1+num2
}
func swap(x, y int)(int, int){ //函数返回多个值
    return y,x
}
func swap1(x, y int){
    temp := x
    x = y
    y = temp
}
func swap2(x, y *int){ //指针参数
    temp := *x
    *x = *y
    *y = temp
}
func main() {
    a, b :=1,2
    fmt.Println(getSum(1, 2))
    swap(a,b)
    fmt.Println(a, b)    //1,2
    swap2(&a,&b)
    fmt.Println(a, b)    //2,1
}

【函数作闭包-匿名函数】
匿名函数的优越性在于可以直接使用函数内的变量，不必申明
//函数getSequence() 返回另外一个函数，该函数的目的是在闭包中递增 i 变量
func getSequence() func() int {
   i:=0
   return func() int {
      i++
      return i  
   }
}
func main(){
   nextNumber := getSequence()  
   fmt.Println(nextNumber(),nextNumber())//1,2
   nextNumber1 := getSequence() //重新返回函数i从0开始 
   fmt.Println(nextNumber1(),nextNumber1())//1,2
}

【函数方法】
func (v_name v_type) function_name() [return_type] {}

【接口】
/* 定义接口 */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
}
/* 定义结构体 */
type struct_name struct {
   /* variables */
}
/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* 方法实现 */
}

// 定义结构体(子类)，实现接口方法
type Phone interface { //定义接口
    call()
}
type NokiaPhone struct { //定义结构体(子类)
}
func (nokiaPhone NokiaPhone) call() { //实现接口方法
    fmt.Println("I am Nokia, I can call you!")
}
type IPhone struct { //定义结构体(子类)
}
func (iPhone IPhone) call() { //实现接口方法
    fmt.Println("I am iPhone, I can call you!")
}
func main() {
    var phone Phone
    phone = new(NokiaPhone)
    phone.call()
    phone = new(IPhone)
    phone.call()
}

type Shape interface {
   area() float64
}
type Rectangle struct {
   x,y float64
}
//属于Rectangle对象的方法、实现接口Shape.area()
func(rectangle Rectangle) area() float64 { 
   return rectangle.x * rectangle.y
}
//给Shape定义方法
func getArea(shape Shape) float64 { 
   return shape.area()
}
func printRectangle(rectangle1 Rectangle,rectangle2 *Rectangle){
   fmt.Println(rectangle1,rectangle2)
   rectangle1.x=2
   rectangle2.x=2//改变了参数值
}
func main(){
   //传参数值变化
   var rectangle1,rectangle2 Rectangle
   rectangle1.x=1
   rectangle2.x=1
   printRectangle(rectangle1,&rectangle2) 
   fmt.Println(rectangle1,rectangle2)
   
   //接口方法调用
   rectangle3 := Rectangle{x:1,y:2} //指定参数赋值不受顺序、数量限制
   fmt.Println(rectangle3,rectangle3.area(),getArea(rectangle3))
}

【特性】
package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包
func main() 是每一个可执行程序所必须包含的，在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）
当标识符（包括常量、变量、类型、函数名、结构字段等等）以大写字母开头，如Group1，那么对象就可以被外部包的代码所使用（需要先导入这个包），这被称为导出（像面向对象语言中的 public）；
标识符如果以小写字母开头，则对包外是不可见的，但在包内部可见（像面向对象语言中的 private ）
一行代表一个语句结束，如果多个语句写在一行则必须使用 ; 区分
包、局部变量不允许声明不使用，全局变量允许声明不使用
全局变量可以在整个包甚至外部包（被导出后）使用
全局变量与局部变量名称可以相同，局部变量会被优先考虑
字符串的字节使用UTF-8编码标识Unicode文本
不带var声明格式的变量定义只能用在函数体内
空指针nil默认值为0

【异常】
error类型是一个接口类型
type error interface {
Error() string
}

// 使用error接口输出异常信息
import "errors"
func add(value int) (int, error) {
if(value < 0){
return 0, errors.New("this is an error")
}
return value+1,nil
}
func main() {
result, err:= add(-1)
if err != nil {
fmt.Println(err)
}else {
fmt.Println(result)
}
}

// 定义一个DivideError结构，实现error接口输出异常信息
type DivideError struct {
  dividee int
  divider int
}
// 实现error接口
func (de *DivideError) Error() string {
  strFormat := `
  Cannot proceed, the divider is zero.
  dividee: %d
  divider: 0
`
  return fmt.Sprintf(strFormat, de.dividee)
}
// 定义int类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
  if varDivider == 0 {
    dData := DivideError{
      dividee: varDividee,
      divider: varDivider,
    }
    errorMsg = dData.Error()
    return
  } else {
    return varDividee / varDivider, ""
  }
}
func main() {
  // 正常情况
  if result, errorMsg := Divide(100, 10); errorMsg == "" {
    fmt.Println("100/10 = ", result)
  }
  // 当被除数为零的时候会返回错误信息
  if _, errorMsg := Divide(100, 0); errorMsg != "" {
    fmt.Println("errorMsg is: ", errorMsg)
  }
}

https://shifei.me/gopl-zh/ch0/ch0-01.html

转载于:https://my.oschina.net/u/3248336/blog/834217