Go语言学习第一天

Go语言简介

1. go语言的特性：

   • 一个目录下的同级文件属于同一个包。

   • 包名可以与其目录名不同 ？。

   • main包是Go语言程序的入口包，一个Go语言程序必须有且仅有一个main包，如果一个程序没有main包，那么编译事就会出错，无法生成可执行文件。(main函数只能声明在main包中)

2. 导入的包中不能含有代码中没有使用的包，否则Go编译器会出错。

   import(

   "name1"

   "name2"

   )

3. func 函数名 (参数列表) (返回值列表) {

   函数体

   }

4. • go build 命令可以将Go语言程序代码编译成二进制的可执行文件，但是需要我们手动运行该二进制文件；

   • go run 命令则更加方便，它会在编译后直接运行Go语言程序，编译过程中会产生一个临时文件，但不会生成可执行文件，这个特点很适合用来调试程序

Go语言基本语法

1. • var 变量名 变量类型

   • 当一个变量被声明之后，系统自动赋予它该类型的零值：int 为 0，float 为 0.0，bool 为 false，string 为空字符串，指针为 nil 等。所有的内存在 Go 中都是经过初始化的

   • var (
         a int
         b string
         c []float32
         d func() bool
         e struct {
             x int
         }
     )

   • 名字 := 表达式 (简短变量声明被广泛用于大部分的局部变量的声明和初始化。var 形式的声明语句往往是用于需要显式指定变量类型地方，或者因为变量稍后会被重新赋值而初始值无关紧要的地方)

     • 定义变量，同时显式初始化

     • 不能提供数据类型

     • 只能用在函数内部

   • 匿名变量 _ 将被抛弃

   • 作用域 （Go语言会在编译时检查每个变量是否使用过，一旦出现未使用的变量，就会报编译错误。如果不能理解变量的作用域，就有可能会带来一些不明所以的编译错误。）

     • 函数内定义的变量称为局部变量

     • 函数外定义的变量称为全局变量 （在函数体外声明的变量称之为全局变量，全局变量只需要在一个源文件中定义，就可以在所有源文件中使用，当然，不包含这个全局变量的源文件需要使用“import”关键字引入全局变量所在的源文件之后才能使用这个全局变量。）（全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写）

     • 函数定义中的变量称为形式参数

   • Go语言同时提供了有符号和无符号的整数类型，其中包括 int8、int16、int32 和 int64 四种大小截然不同的有符号整数类型，分别对应 8、16、32、64 bit（二进制位）大小的有符号整数，与此对应的是 uint8、uint16、uint32 和 uint64 四种无符号整数类型。

   • 浮点类型

     • 常量 math.MaxFloat32 表示 float32 能取到的最大数值，大约是 3.4e38；

     • 常量 math.MaxFloat64 表示 float64 能取到的最大数值，大约是 1.8e308；

     • float32 和 float64 能表示的最小值分别为 1.4e-45 和 4.9e-324

     • 一个 float32 类型的浮点数可以提供大约 6 个十进制数的精度，而 float64 则可以提供约 15 个十进制数的精度，通常应该优先使用 float64 类型，因为 float32 类型的累计计算误差很容易扩散，并且 float32 能精确表示的正整数并不是很大。

       • var f float32 = 16777216 // 1 << 24
         fmt.Println(f == f+1)    // "true"!

     • 浮点数在声明的时候可以只写整数部分或者小数部分

       • const e = .71828 // 0.71828
         const f = 1.     // 1

     • 很小或很大的数最好用科学计数法书写，通过 e 或 E 来指定指数部分

       • const Avogadro = 6.02214129e23  // 阿伏伽德罗常数
         const Planck   = 6.62606957e-34 // 普朗克常数
         ​

     • 用 Printf 函数打印浮点数时可以使用“%f”来控制保留几位小数

   • 复数 Go语言中复数的类型有两种，分别是 complex128（64 位实数和虚数）和 complex64（32 位实数和虚数），其中 complex128 为复数的默认类型

     • var name complex128 = complex(x, y)

     • name := complex(x, y)

     • 对于一个复数z := complex(x, y)，可以通过Go语言的内置函数real(z)来获得该复数的实部，也就是 x；通过imag(z)获得该复数的虚部，也就是 y

     • 复数也可以用==和!=进行相等比较，只有两个复数的实部和虚部都相等的时候它们才是相等的

   • Go语言中不允许将整型强制转换为布尔型

   • 定义字符串

     • 可以使用双引号""来定义字符串，字符串中可以使用转义字符来实现换行、缩进等效果，常用的转义字符包括：

       • \n：换行符

       • \r：回车符

       • \t：tab 键

       • \u 或 \U：Unicode 字符

       • \：反斜杠自身

     • 在Go语言中，使用双引号书写字符串的方式是字符串常见表达方式之一，被称为字符串字面量（string literal），这种双引号字面量不能跨行，如果想要在源码中嵌入一个多行字符串时，就必须使用```反引号

       • const str = `第一行
         第二行
         第三行
         \r\n
         `
         fmt.Println(str)

   • Go语言的字符有以下两种:

     • 一种是 uint8 类型，或者叫 byte 型，代表了 ASCII 码的一个字符。

       • 在 ASCII 码表中，A 的值是 65，使用 16 进制表示则为 41，所以下面的写法是等效的：

         var ch byte = 65 或 var ch byte = '\x41' //（\x 总是紧跟着长度为 2 的 16 进制数）

         另外一种可能的写法是\后面紧跟着长度为 3 的八进制数，例如 \377

     • 另一种是 rune 类型，代表一个 UTF-8 字符，当需要处理中文、日文或者其他复合字符时，则需要用到 rune 类型。rune 类型等价于 int32 类型

       • Go语言同样支持 Unicode（UTF-8），因此字符同样称为 Unicode 代码点或者 runes，并在内存中使用 int 来表示。在文档中，一般使用格式 U+hhhh 来表示，其中 h 表示一个 16 进制数。

       • 在书写 Unicode 字符时，需要在 16 进制数之前加上前缀\u或者\U。因为 Unicode 至少占用 2 个字节，所以我们使用 int16 或者 int 类型来表示。如果需要使用到 4 字节，则使用\u前缀，如果需要使用到 8 个字节，则使用\U前缀。

     • var ch int = '\u0041'
       var ch2 int = '\u03B2'
       var ch3 int = '\U00101234'
       fmt.Printf("%d - %d - %d\n", ch, ch2, ch3) // integer
       fmt.Printf("%c - %c - %c\n", ch, ch2, ch3) // character
       fmt.Printf("%X - %X - %X\n", ch, ch2, ch3) // UTF-8 bytes
       fmt.Printf("%U - %U - %U", ch, ch2, ch3)   // UTF-8 code point

       • 格式化说明符%c用于表示字符，当和字符配合使用时，%v或%d会输出用于表示该字符的整数，%U输出格式为 U+hhhh 的字符串

       • Unicode 包中内置了一些用于测试字符的函数，这些函数的返回值都是一个布尔值，如下所示（其中 ch 代表字符）：

         • 判断是否为字母：unicode.IsLetter(ch)

         • 判断是否为数字：unicode.IsDigit(ch)

         • 判断是否为空白符号：unicode.IsSpace(ch)

   • 类型 B 的值 = 类型 B(类型 A 的值)

     • valueOfTypeB = typeB(valueOfTypeA)

   • 指针（pointer）在Go语言中可以被拆分为两个核心概念：

     • 类型指针，允许对这个指针类型的数据进行修改，传递数据可以直接使用指针，而无须拷贝数据，类型指针不能进行偏移和运算。

     • 切片，由指向起始元素的原始指针、元素数量和容量组成

     • 每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。Go语言中使用在变量名前面添加&操作符（前缀）来获取变量的内存地址（取地址操作）

       • ptr := &v // v 的类型为 T

         • 其中 v 代表被取地址的变量，变量 v 的地址使用变量 ptr 进行接收，ptr 的类型为*T，称做 T 的指针类型，*代表指针

       • 量、指针和地址三者的关系是，每个变量都拥有地址，指针的值就是地址

       • 取地址操作符&和取值操作符*是一对互补操作符，&取出地址，*根据地址取出地址指向的值

       • 变量、指针地址、指针变量、取地址、取值的相互关系和特性如下：

         • 对变量进行取地址操作使用&操作符，可以获得这个变量的指针变量。

         • 指针变量的值是指针地址。

         • 对指针变量进行取值操作使用*操作符，可以获得指针变量指向的原变量的值。

       • Go语言还提供了另外一种方法来创建指针变量

         • new(类型)

       • 堆（heap）：堆是用于存放进程执行中被动态分配的内存段。它的大小并不固定，可动态扩张或缩减。当进程调用 malloc 等函数分配内存时，新分配的内存就被动态加入到堆上（堆被扩张）。当利用 free 等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）；

       • 栈(stack)：栈又称堆栈， 用来存放程序暂时创建的局部变量，也就是我们函数的大括号{ }中定义的局部变量。

       • 在Go语言中，你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

         • 显式类型定义： const b string = "abc"

         • 隐式类型定义： const b = "abc"