从例子中学习 go 语言 —— 基本语法

go 语言或是 golang 官网上有个 tour。从例子中学习一门语言虽然具有片面性，但是往往是一个入门的好方法；如果一开始就去是看手册的话，有些凌乱，摸不着头脑，有点看字典的味道。所以，先从例子中学习，然后再系统的学习，应该是个不错的方法。

本篇文章基本按照 tour 的步骤，跑跑例子，从例子中去猜测/分析 go 的语法以及结构等，一定程度上可以锻炼一下，观察和分析能力。

1. hello,world：
   
   1. package main
   2.  
   3. import  "fmt"
   4.  
   5. func main ()  {
   6.         fmt .Println ( "hello,world" )     // 输出 hello,world
   7. }

   1). package 将程序打包；
   2). import 导入其他包，包名用双引号引住；fmt 包 —— 应该是 format 格式化输入/输出的包；
   3). func 声明函数，main 函数，不带参数，不返回值，函数体用 { } 括号括住；左大括号 { 与声明在同一行（必须！）；
   4). fmt.Println 向控制台输出，包名小写，函数名首字母大写；
   5). 语句不带分号； // 试验发现，分号可有可无；实际上 go 是自动插入分号；
   6). package 必须写在前面；必须先 import 包，然后才能使用包中的东西；
   7). // 行注释，/* */ 块注释，都是常用的方法；

2. 导入多个包：
   
   1. package main
   2.  
   3. import  (
   4.          "fmt"
   5.          "math"
   6. )
   7.  
   8. func main ()  {
   9.         fmt .Println ( "Happy" , math . Pi ,  "Day" )
   10. }

   1). import 导入多个包的简单写法；小括号括住，包名换行写；或是用分号将它们隔开；
   2). 新的包 math，应该是数学包；
   3). math.Pi 圆周率；// 小数点后有十五位 math.Pi == 3.141592653589793；math.E == 2.718281828459045；
   4). fmt.Println 多个参数多个输出，从左到有一一输出；
   5). 程序从 main 包的 main 函数开始执行；

3. 格式化输出：
   
   1. package main
   2.  
   3. import  (
   4.          "fmt"
   5.          "math"
   6. )
   7.  
   8. func main ()  {
   9.         fmt .Printf ( "Now you have %g problems." ,
   10.                 math .Nextafter ( 2 ,  3 ))
   11. }

   1). 一条语句可以换行写，不过是在逗号处隔开；
   2). fmt.Printf 格式化输出函数，类似于 c 语言的 printf ，第一参数是格式化字符串；函数输出不自动换行；
   3). fmt.Printf 名字类似于 fmt.Println；包的名字一般小写；包中的函数 Printf/Println 和 值 Pi/E 首字母看来是大写；
   4). math.Nextafter 方法，暂时不纠结到底什么意思；// Nextafter(2,2) == 2；Nextafter(2,3) == 2.0000000000000004；Nextafter(2,1) == 1.9999999999999998

4. 函数定义和使用：
   
   1. package main
   2.  
   3. import  "fmt"
   4.  
   5. func add (x  int , y  int )  int  {
   6.          return x  + y
   7. }
   8.  
   9. func main ()  {
   10.         fmt .Println (add ( 42 ,  13 ))
   11. }

   1). func 进行函数声明，func 函数名(参数列表) 返回值类型；参数以及返回值的类型向后写，而不是像 c、c++ 和 Java 等写在前面；
   2). 函数调用都一样，函数名后面跟上参数，参数之间逗号隔开，小括号括住；
   3). int 是整数类型，两个 int 相加，结果是 int；貌似是废话；

5. 函数声明时类型省略：
   
   1. package main
   2.  
   3. import  "fmt"
   4.  
   5. func add (x , y  int , z  int )  int  {
   6.          return x  + y  + z
   7. }
   8.  
   9. func main ()  {
   10.         fmt .Println (add ( 42 ,  13 ,  12 ))
   11. }

   1). 这里 x 类型么有指定，认为和后面的 y 的类型一致；因为 x、y、z 都是 int 型，所以实际上可以只留 z 的 int 就可以，y 的也可以省略；
   2). 省略了认为是和后面的重复，也就是只有类型重复的时候，偶们才可以省略；

6. 函数多返回值的用法：
   
   1. package main
   2.  
   3. import  "fmt"
   4.  
   5. func swap (x , y  string )  ( string ,  string )  {
   6.          return y , x
   7. }
   8.  
   9. func main ()  {
   10.         a , b  := swap ( "hello" ,  "world" )
   11.          // var a, b := swap("hello", "world")
   12.         fmt . Println (a , b )    // world hello
   13. }

   1). c 类的语言(c/c++/java等) 一般函数只有一个返回值，如果想返回多个，一般都要进行封装称结构体或是类，F# 引入元组类型，就是简单的用小括号一括，就可以把若干个值放在一块；这里的用法是类似的，函数返回值用括号一括就表明一下子返回多个值，简单易用；
   2). 至此，貌似都嚒见过怎么声明变量，只是用了函数中的变量以及将函数返回值简单返回；这个例子中有两种声明方法，一种不需要借助 var关键字进行隐式声明，一种需要算式显式声明——明白滴告诉你这就是个变量 variable，至于类型，看后面；
   3). 如此交换两个变量甚好，以前见过的交换，一般都需要借助于辅助变量或是其他运算；

7. 声明函数的返回值，不仅仅是类型：
   
   1. package main
   2.  
   3. import  "fmt"
   4.  
   5. func split (sum  int )  (x , y  int )  {
   6.         x  = sum  *  4 / 9
   7.         y  = sum  - x
   8.          return
   9. }
   10.  
   11. func main ()  {
   12.         fmt .Println (split ( 36 ))
   13.          // fmt.Println(split(17))
   14. }

   1). 看函数声明，直接把返回值 x、y声明出来了，函数内部可以直接使用参数和返回值变量，而且 return 不需要显式地返回 x、y；
   2). 声明的返回值变量，不赋值就用的话，默认值是 0 或是 false 等；
   3). 可能你奇怪，如果 return x+2,y+2 会怎么样，实际上是将 x、y 各加 2 的结果返回，不报警告也不报错；也就是所如果有 return 值那就是返回值，没有的话，才将声明的返回值返回；
   4). int * int 结果是 int ； int / int 结果也是 int，不是浮点数 —— 这也是 c 语言的一贯传统；

8. 变量声明：
   
   1. package main
   2.  
   3. import  "fmt"
   4.  
   5. var x , y , z  int
   6. var c , python , java  bool
   7.  
   8. func main ()  {
   9.         fmt .Println (x , y , z , c , python , java )
   10. }

   1). 用 var 进行变量声明，和函数声明时参数的声明一样，类型向后写，也就是先写变量名，再写类型；
   2). 多个变量类型一样的话，可以合在一起写；int 和 bool 是目前见过的整数和布尔类型；
   3). 声明变量如果么有显式的初始化，都有默认值，int 为 0，bool 为 false ；
   4). 没有初始化的变量声明，类型不同不能连在一起写；

9. 变量声明和类型推断：
   
   1. package main
   2.  
   3. import  "fmt"
   4.  
   5. var x , y , z  int  =  1 ,  2 ,  3
   6. var c , python , java  =  true ,  false ,  "no!"
   7.  
   8. func main ()  {
   9.         fmt .Println (x , y , z , c , python , java )
   10. }

   1). 变量声明的同时可以初始化；
   2). 如果有初始化的话，变量类型可以不写，类型靠推断而得；
   3). 变量声明可以连着写；
   4). "hello"、"yes" 这是 string —— 字符串类型；

10. 两种变量声明方法：
    
    1. package main
    2.  
    3. import  "fmt"
    4.  
    5. func main ()  {
    6.          var x , y , z  int  =  1 ,  2 ,  3
    7.         c , python , java  :=  true ,  false ,  "no!"
    8.  
    9.         fmt . Println (x , y , z , c , python , java )
    10. }

    1). 隐式变量声明和显式变量声明，也就是不使用和使用 var 关键字，同时两种运算符也不相同；
    2). 函数外不能使用隐式变量声明，也就是 a : = 3 这种；

11. 常量声明：
    
    1. package main
    2.  
    3. import  "fmt"
    4.  
    5. const Pi  =  3 . 14
    6.  
    7. func main ()  {
    8.          const World  =  "世界"
    9.         fmt . Println ( "Hello" , World )
    10.         fmt . Println ( "Happy" , Pi ,  "Day" )
    11.  
    12.          const Truth  =  true
    13.         fmt .Println ( "Go rules?" , Truth )
    14. }

    1). const 用来声明常量，const 浮点数、const 整数、const 字符串、const 布尔值；

12. 接触浮点数 / 实数：
    
    1. package main
    2.  
    3. import  "fmt"
    4.  
    5. func add (x  int , y  float64 )  int  {
    6.          return x  +  int (y )
    7. }
    8.  
    9. func main ()  {
    10.         fmt .Println (add ( 42 ,  13 ))
    11. }

    1). float64 是 64 位的浮点数，还有 float32；总之现在简单滴看，就是 —— 实数 或是 小数；
    2). int + float64 不合法，也就是 int 不能直接和 float64 相加；
    3). int(y) 将 y 转化为 int 值；
    4). 函数传参数的时候，可以将 int 传给 float64；

13. 大整数常量以及浮点数：
    
    1. package main
    2.  
    3. import  "fmt"
    4.  
    5. const  (
    6.         Big  =  1<< 100
    7.         Small  = Big>> 99   // 2
    8. )
    9.  
    10. func needInt (x  int )  int  {  return x * 10  +  1  }
    11. func needFloat (x  float64 )  float64  {
    12.          return x * 0 . 1
    13. }
    14.  
    15. func main ()  {
    16.          // fmt.Println(Big)  // overflow int
    17.         fmt .Println ( float64 (Big ))
    18.         fmt .Println (Small )              // 2
    19.         fmt . Println (needInt (Small ))     // 21
    20.         fmt . Println (needFloat (Small ))   // 0.2
    21.         fmt . Println (needFloat (Big ))
    22. }

    1). 声明多个 const 可以简写；小括号括起来，然后换行写，和 import 包类似；
    2). 参数传递，可以将 int 传给 float64；
    3). int 有表示范围一说，数值太大，会溢出；

14. for 循环结构：
    
    1. package main
    2.  
    3. import  "fmt"
    4.  
    5. func main ()  {
    6.         sum  :=  0
    7.          for  i  :=  0 ;  i <  10 ;  i ++  {
    8.                 sum  +=  i
    9.          }
    10.         fmt .Println (sum )
    11. }

    1). 相对于 c 的 for 循环结构来说，去掉了两侧的小括号；

15. for 循环结构简化版：
    
    1. package main
    2.  
    3. import  "fmt"
    4.  
    5. func main ()  {
    6.         sum  :=  1
    7.          for  ; sum <  1000 ;  {
    8.                 sum  += sum
    9.          }
    10.         fmt .Println (sum )
    11. }

    1). for 去掉了前置和后置语句，但是分号还在；

16. for 循环结构再次简化：
    
    1. package main
    2.  
    3. import  "fmt"
    4.  
    5. func main ()  {
    6.         sum  :=  1
    7.          //for ; sum < 1000; {
    8.          for sum <  1000  {
    9.                 sum  += sum
    10.          }
    11.         fmt .Println (sum )
    12. }

    1). for 去掉了前置和后置语句，但是分号还在；
    2). for 去掉了前置和后置语句，分号也可以去掉，这样就相当于 c 的while 结构；

17. 死循环结构：
    
    1. package main
    2.  
    3. func main ()  {
    4.          for  ;  ;  {
    5.          //for {
    6.          }
    7. }

    1). for 没有判断条件，默认为 true，也就是死循环；
    2). for 没有判断条件，也没有前置和后置语句，去掉所有的分号，就有了 for 的最简化形式；

18. if 选择结构：
    
    1. package main
    2.  
    3. import  (
    4.          "fmt"
    5.          "math"
    6. )
    7.  
    8. func sqrt (x  float64 )  string  {
    9.          if x <  0  {
    10.                  return sqrt ( -x )  +  "i"
    11.          }
    12.          return fmt .Sprint (math .Sqrt (x ))
    13. }
    14.  
    15. func main ()  {
    16.         fmt .Println (sqrt ( 2 ), sqrt ( - 4 ))
    17. }

    1). if 选择结构，相对于 c 来说，去掉了两边的小括号；
    2). math.Sqrt 求实数的平方根；
    3). 递归调用啊，有木有！ sqrt 函数！
    3). 将 float64 值字符串化的方法 fmt.Sprint；Sprint 名字类似于 Print/Println/Printf/Fprintf ，可以略猜出来，S 应该是 string 的意思；

19. if 选择结构加强版：
    
    1. package main
    2.  
    3. import  (
    4.          "fmt"
    5.          "math"
    6. )
    7.  
    8. func pow (x , n , lim  float64 )  float64  {
    9.          if v  := math .Pow (x , n ); v < lim  {
    10.                  return v
    11.          }
    12.          return lim
    13. }
    14.  
    15. func main ()  {
    16.         fmt .Println (
    17.                 pow ( 3 ,  2 ,  10 ),
    18.                 pow ( 3 ,  3 ,  20 ),
    19.          )
    20. }

    1). if 选择结构可以加前置语句，类似于 for ；如果嚒有前置语句为空，可以留下分号，也可以去掉分号；
    2). 前置语句引入的变量的作用域仅限于 if 结构；
    3). math.Pow 求幂指数；

20. if - else 选择结构
    
    1. package main
    2.  
    3. import  (
    4.          "fmt"
    5.          "math"
    6. )
    7.  
    8. func pow (x , n , lim  float64 )  float64  {
    9.          if v  := math .Pow (x , n ); v < lim  {
    10.                  return v
    11.          }  else  {
    12.                 fmt .Printf ( "%g >= %g\n" , v , lim )
    13.  
    14.          }
    15.          // can't use v here, though
    16.          return lim
    17. }
    18.  
    19. func main ()  {
    20.         fmt .Println (
    21.                 pow ( 3 ,  2 ,  10 ),
    22.                 pow ( 3 ,  3 ,  20 ),
    23.          )
    24. }

    1). if - else 结构
    2). if 前置语句引入的变量作用域也可以用于 else ；
    3). 这个运行结果有些比较奇怪！

21. 复数运算：
    
    1. package main
    2.  
    3. import  (
    4.          "math/cmplx"
    5.          "fmt"
    6. )
    7.  
    8. var  (
    9.         ToBe  bool  =  false
    10.         MaxInt  uint64  =  1<< 64  -  1
    11.         z  complex128  =  cmplx .Sqrt ( - 5 + 12i )
    12. )
    13.  
    14. func main ()  {
    15.          const f  =  "%T(%v)\n"
    16.         fmt . Printf (f , ToBe , ToBe )
    17.         fmt . Printf (f , MaxInt , MaxInt )
    18.         fmt . Printf (f , z , z )
    19. }

    1). go 内置复数运算，使用 math/cmplx 包；
    2). const 常量字符串可以用于 fmt.Printf 的第一个参数，见过的格式化有 %T %v %g 几种；
    3). 换行符，都熟悉的；
    4). math/cmplex 复数包；cmplx.Sqrt 复数开根号
    5). go 的基本类型：

    bool
    string
    int int8 int16 int32 int64
    uint uint8 uint16 uint32 uint64 uintptr
    byte // uint8
    rune // int32
    float32 float64
    complex64 complex128

    原文地址：http://ilovers.sinaapp.com/drupal/node/32

    本系列的博客为本人学习收藏