golang学习之路1-初始学习

开始翻看菜鸟教程学习golang了，现在从最初的hello world开始学起，期间学到几个问题。按道理应该一一记录下来

 

1.包引入问题

一般来说开头这几行代码最常见，对我自己基本次次都在

package main

import (
	"fmt"
	"strconv"
)

注意事项，如果只有一个go文件，想要运行的话必须包含package main，如果换成其他包名则无法运行

另外fmt是一个格式输出到控制台的，里面包含了类似python3的print方法

strconv是一个通用数据类型转换工具，可以整数与字符串转换等等

2.一个文件想要运行必须包含主函数，跟c语言入库类似，比起python来说，python的主函数也是只在自身调用时生效，自己调用自己可以不写主函数。但是golang必须写。类似下面的:

func main() {
	fmt.Println("Hello, World!")
}

3.golang的func后面定义方法名字后，花括号左边必须是在方法名行尾部，不能换行写，这一点跟js随便放是不一样的

4.golang定义全局变量并不支持 :=的形式，亲测的，必须用var。也就是写在func外面的变量。在func里面的变量可以用:=的方式初始化值和自动推断，但是已经有初始化的值只需要直接写=就好了，不然会报错

5.关于golang的整数类型，分为很多个，不像python就一个int，但是千万不要被他唬住了。

1	uint8 无符号 8 位整型 (0 到 255)
2	uint16 无符号 16 位整型 (0 到 65535)
3	uint32 无符号 32 位整型 (0 到 4294967295)
4	uint64 无符号 64 位整型 (0 到 18446744073709551615)
5	int8 有符号 8 位整型 (-128 到 127)
6	int16 有符号 16 位整型 (-32768 到 32767)
7	int32 有符号 32 位整型 (-2147483648 到 2147483647)
8	int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

菜鸟教程废了这么多话，其实简而言之就是，int从8位到64位，每次翻倍，8，16，32，64

前面带了u的证明是正整数，没带u的代表正负各一半

 

6.关于定义字符串变量或者常量的奇葩问题，不支持单引号

自己亲测，定义的字符串必须用双引号，单引号系统不认，这个不知道go怎么想的，我按规矩来就行

7.fmt.println不支持字符串格式化，只是换行打印，如果需要字符串格式话得用fmt.printf的方法，例子:

func test()  {
	c:=7
	d:=5
	area:= area_count(c,d)
	//printf可以格式和字符串
	fmt.Printf("面积为 : %d\n", area)
	//println不行
	fmt.Println("计算所得的面积是 %d \n",area)
	//也可以用类型转换来相加
	fmt.Println("面积: "+strconv.Itoa(c))
	println(url_index)
}

8. var与const，变量与常量定义时因式分解写法

var (
	g1 int = 1
	g2 int = 2
	g3  string = "4"
)

const (
	author = "道长"
	qq = "123456"
	sex = "男"
)

9.golang里面取字符串的长度也跟python一样有一个len()函数，但是他取出的是里面的字节位长度，比如两个中文的字符串占6位，len()后得到的返回值就是6，python里面是2

10.

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

iota 可以被用作枚举值：

const (
    a = iota
    b = iota
    c = iota
)

11.与或非逻辑运算符同js，跟python不一样，用的是 && || !。其中&和|都是两个，单个的话表示位运算 

12.变量与指针。用的 &变量，*指针，千万别弄反了

func ptr()  {
	a:=4
	b:=&a
	*b = 7
	println(a)
}

&变量得到的是变量的地址，*指针得到是该变量，*指针赋值会改变原变量的值

13.  switch case用法:

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var grade string = "B"
   var marks int = 90

   switch marks {
      case 90: grade = "A"
      case 80: grade = "B"
      case 50,60,70 : grade = "C"
      default: grade = "D"  
   }

   switch {
      case grade == "A" :
         fmt.Printf("优秀!\n" )    
      case grade == "B", grade == "C" :
         fmt.Printf("良好\n" )      
      case grade == "D" :
         fmt.Printf("及格\n" )      
      case grade == "F":
         fmt.Printf("不及格\n" )
      default:
         fmt.Printf("差\n" );
   }
   fmt.Printf("你的等级是 %s\n", grade );      
}

package main

import "fmt"

func main() {
   var x interface{}
     
   switch i := x.(type) {
      case nil:  
         fmt.Printf(" x 的类型 :%T",i)                
      case int:  
         fmt.Printf("x 是 int 型")                      
      case float64:
         fmt.Printf("x 是 float64 型")          
      case func(int) float64:
         fmt.Printf("x 是 func(int) 型")                      
      case bool, string:
         fmt.Printf("x 是 bool 或 string 型" )      
      default:
         fmt.Printf("未知型")    
   }  
}

fallthrough
使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。

实例
package main

import "fmt"

func main() {

    switch {
    case false:
            fmt.Println("1、case 条件语句为 false")
            fallthrough
    case true:
            fmt.Println("2、case 条件语句为 true")
            fallthrough
    case false:
            fmt.Println("3、case 条件语句为 false")
            fallthrough
    case true:
            fmt.Println("4、case 条件语句为 true")
    case false:
            fmt.Println("5、case 条件语句为 false")
            fallthrough
    default:
            fmt.Println("6、默认 case")
    }
}

从以上代码输出的结果可以看出：switch 从第一个判断表达式为 true 的 case 开始执行，如果 case 带有 fallthrough，程序会继续执行下一条 case，且它不会去判断下一个 case 的表达式是否为 true。

 

贴了这么多代码，要说明的东西也很简单，跟js比起来，不需要每case结尾写break，相当于是默认带了break，但是为了实现不进行break的想法，go多了一个fallthrough。等于跟js的switch case思路相反。js是默认可以挨个判断，需要终止时自己写的break.go是默认break，需要挨个进行是自己在 下面加上fallthrough