Go语言Let's Go!

linux安装

https://golang.google.cn/dl/
linux 64位

解压包

tar -C /usr/local -xzf go1.4.linux-amd64.tar.gz

写入配置文件

vi .bashrc

export PATH=$PATH:/usr/local/go/bin

激活

source .bashrc

第一横代码

/* 多横注释 */
// 单横注释

// 包声明 
package main
// 引入包
import "fmt"
// func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的
func main() {
    fmt.Println("Hello World")
}

运行

go run test.go

关键字

下面列举了 Go 代码中会使用到的 25 个关键字或保留字：

break	default	  func	interface	select
case	defer	go	map	  struct
chan	else	  goto	package	switch
const	fallthrough	 if	 range	 type
continue	 for	import	 return	 var

除了以上介绍的这些关键字，Go 语言还有 36 个预定义标识符：

append	bool	byte	cap	close	complex	complex64	complex128	uint16
copy	false	float32	float64	imag	int	int8	int16	uint32
int32	int64	iota	len	make	new	nil	panic	uint64
print	println	real	recover	string	true	uint	uint8	uintptr

声明

声明变量的一般形式是使用 var 关键字：

var identifier type

可以一次声明多个变量：

var identifier1, identifier2 type

声明实例

package main
import "fmt"
func main() {
    var a string = "Runoob"
    fmt.Println(a)

package main
import "fmt"
func main() {
    var number int = 1+1
    fmt.Println(number)
}

指定变量类型，如果没有初始化，则变量默认为零值。

第三种，省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误，格式：

v_name := value

var intVal int 

intVal :=1 // 这时候会产生编译错误

intVal,intVal1 := 1,2 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句

可以将 var f string = “Runoob” 简写为 f := “Runoob”：

package main
import "fmt"
func main() {
    f := "Runoob" // var f string = "Runoob"

    fmt.Println(f)
}

package mian
import "fmt"
func main() {
    number := 1+1
    fmt.Println(number)
}

以下实例演示了常量的应用：

package main

import "fmt"

func main() {
   const LENGTH int = 10
   const WIDTH int = 5  
   var area int
   const a, b, c = 1, false, "str" //多重赋值

   area = LENGTH * WIDTH
   fmt.Printf("面积为 : %d", area)
   println()
   println(a, b, c)  
}

iota 用法

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

运算符优先级

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：

5	* / % << >> & &^
4	+ - | ^
3	== != < <= > >=
2	&&
1	||

无限循环

如果循环中条件语句永远不为 false 则会进行无限循环，我们可以通过 for 循环语句中只设置一个条件表达式来执行无限循环：

package main

import "fmt"

func main() {
    for true  {
        fmt.Printf("这是无限循环。\n");
    }
}

取出不为空的{“red”,"",“green”,“yellow”,"",“black”}

package main

import "fmt"

func noEmpty(data []string)  []string{
	out := data[:0]
	for _, str := range data {
		if str != "" {
			out = append(out,str)
		}
	}
	return out
}

func main()  {
	data := []string{"red","","green","yellow","","black"}
	afterDate := noEmpty(data)
	fmt.Println(afterDate)
}

copy的用法

func main()  {
	data := []string{"red","","green","yellow","","black"}
	afterDate := noEmpty(data)
	fmt.Println(afterDate)
	
	// cory的用法
	//-----------------------------
	data2 := [...]int{0,1,2,3,4,5,6,7,8,9}
	data3 := data2[8:]
	data4 := data2[0:5]
	fmt.Println(data4)
	fmt.Println(data3)
	copy(data4,data3)
	fmt.Println("data4=",data4)
}

>>> data4= [8 9 2 3 4]