golang学习笔记（有Java基础）

变量

Golang使用变量的三种方式：

1. 指定变量类型，声明后若不赋值，使用默认值

2. 根据值自行判定变量类型（类型推导）

3. 省略var，注意 :=左侧的变量不应该是已经声明过的（=是赋值）

等价于

var name string
​
name = "tom"

多变量声明：

• 变量类型一样：var n1, n2, n3 int

• 变量类型不一样：var n1, name, n3 = 100, "tom", 888

• 全局变量：

  var (
  ​
  n1 = 100
  ​
  name = "tom"
  ​
  n3 = 888
  ​
  )

  程序中+号的使用

  1. 都是数值型的时候，做加法运算

  2. 都是字符串的时候，做字符串拼接

数据类型的基本介绍

整数的类型

小数的类型

复数类型

complex64和complex128就是用来表示我们数学中的复数，复数实部和虚部，complex64的实部和虚部都是32位float，complex128的实部和虚部都是64位float。

字符类型细节

Golang当中没有专门的字符类型（java中是char类型），一般用byte来保存，如果byte不够存，可以用int来存。

所以说java当中字符类型是固定占两个字节的，go语言中就要自己看着办了

String类型细节

• 字符串一旦赋值了，就不能修改。

var str = "hello"
//str[0] = 'a'  这里不能修改“hello”这个字符串
str = "world"   //str这个字符串变量还是可以修改的

• 字符串的两种表示形式

1. 双引号

2. 反引号（`），会以字符串的原生形式输出，比如可以用这个输出源代码

   import "fmt"
   ​
   func main() {
       str2 := `
   var str = "hello"
       //str[0] = 'a'  //这里不能修改“hello”这个字符串
       str = "world" //str这个字符串变量还是可以修改的
       fmt.Print(str)
   `
       fmt.Print(str2)
   }

   输出结果：

   var str = "hello"
           //str[0] = 'a'  //这里不能修改“hello”这个字符串
           str = "world" //str这个字符串变量还是可以修改的
           fmt.Print(str)
   ​

   拼接字符串的时候可以不写成一行，但是注意+要保留到上一行（要不然编译器会以为结束了）

package main
​
import "fmt"
​
func main() {
    str2 := "he" + "te" +
        "gf" + "gr" +
        "gfre"
    fmt.Print(str2)
}

注意事项

• Golang中没有double类型，小数类型只有float32和float64

基本数据类型的相互转换

基本介绍

和其他语言不同，Go语言在不同类型的变量之间赋值时需要显式转换，也就是说Golang中数据类型不能自动转换。

转换方法

1.     var i int32 = 100   //类似java中的强制类型转换
       var n1 = float32(i) //将int32类型转换为float32

注意事项

1. Golang中，数据类型的转换可以从小到大，也可以从大到小（类似java中的强制类型转换），但是从大到小可能会溢出

2. 被转换的是变量存储的数据（即对应值），变量本身的数据类型并没有变化。

    var i int32 = 100
    var n1 = float32(i)
    fmt.Printf("%T\n", n1)
    fmt.Printf("%T", i)
    
    //输出结果
    float32
    int32
​

基本数据类型和String的转换

基本类型转string类型

1. fmt.Sprintf("格式化样式", 参数列表…)

   这个函数就是将指定类型的参数转化为string类型。

   var i int32 = 100
   var n1 = float32(i)
   var str string
   ​
   str = fmt.Sprintf("%d", i)
   //将int32类型的100转为string，"%d"是指i的类型
   fmt.Println(str)    //输出str
   str = fmt.Sprintf("%f", n1)
   //将float32类型的100转为string，"%d"是指i的类型
   //***这里要注意float（包括32和64）转为string的时候会默认保留6位小数***
   fmt.Println(str)  //输出结果为100.000000
   str = fmt.Sprintf("%.2f", n1) //保留2位小数转换n1
   str += "geg" //拼接100.00和geg
   fmt.Println(str) //输出结果为100.00geg
   fmt.Println(n1)  //直接输出n1，结果是100

2. 使用strconv包的函数

func FormatBool(b bool) string
// 将bool类型的数值转化为string
func FormatFloat(f float64, fmt byte, prec, bitSize int) string
//**将float64类型的数值转化为string**
//第一个参数是要转化的float64变量，第二个是目标格式
//第三个是精度（保留小数点后几位）
//第四个是转化后的位数（32或者64）
func FormatInt(i int64, base int) string
// 将int类型的数值转化为指定进制string
// base表示进制
func FormatUint(i uint64, base int) string
//和上面一样，只是参数是无符号int
func Itoa(i int) string
//等同于 FormatInt(int64(i), 10)，注意参数类型是int

//func FormatInt(i int64, base int) string
var num int = 44
var str = strconv.FormatInt(int64(num), 16)
fmt.Println(str)
​
//输出结果：2c

注意事项

1. 被转化的数据一定要是float64，而不能是float32.

2. 目标格式可以参考Golang官方文档

3. 注意float32的精度为7位（表示成科学计数法后，小数点后6

   位），float64的精度为15位（表示成科学计数法后，小数点后14位）。精度仅仅是精确程度，不同于实际显示的位数。

   var num2 float64 = 66.6
   var str string
   var str2 string
   str = strconv.FormatFloat(num2, 'f', 20, 64)
   str2 = strconv.FormatFloat(num2, 'f', 20, 32)
   fmt.Println(str)   //66.59999999999999431566
   fmt.Println(str2)  //66.59999847412109375000
       
   //输出结果：
   //66.59999999999999431566   //66.59999847412109375000

   这个例子中float32只能精确到66.59999，float64只能精确到66.59999999999999，所以说同一个数字的输出结果会不一样。

4. bool类型的默认值是false

string类型转基本类型

使用strconv包的函数

func ParseBool(str string) (bool, error)
//返回值有两个
func ParseComplex(s string, bitSize int) (complex128, error)
func ParseFloat(s string, bitSize int) (float64, error)
func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (uint64, error) 

ParseBool函数

当接收变量为1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False返回true或者false，其他情况都是返回error。这里的error可以用“_”忽略

    
var str string = "ge"
var b bool
var c error
b, c = strconv.ParseBool(str)   //此时返回error
fmt.Println(b)
fmt.Println(c)
​
输出结果：
false
strconv.ParseBool: parsing "ge": invalid syntax

var str string = "ge"
var b bool
b, _ = strconv.ParseBool(str)
fmt.Println(b)
​
输出结果：false

剩余几个函数用法和上面类似

注意事项

• 如果转化失败了，golang会直接转化为默认值。

var str string = "ge"
var b int64 = 20
b, _ = strconv.ParseInt(str, 10, 64)
fmt.Println(b)
​
输出结果：
0

指针

使用细节

值类型都有对应的指针类型，形式为 *数据类型，例如 int对应*int，float32对应*float32.

值类型： int系列，float系列，bool，string，数组，结构体

值类型和引用类型

值类型和引用类型的基本说明

值类型： int系列，float系列，bool，string，数组，结构体

引用类型：指针、slice切片、map、管道 chan、interface等都是引用类型

值类型和引用类型的使用特点

1. 值类型：变量直接存储值，内存通常在栈中分配。

示意图：

2.引用类型：变量存储的是一个地址，这个地址对应的空间才是真正的存储数据（值），内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由GC来回收。

示意图：

标识符的命名规范

标识符的概念

1. golang对各种变量、方法、函数等命名时使用的字符序列称为标识符

2. 凡是自己可以起名字的地方都叫标识符

标识符的命名规则

1. 由26个英文字母大小写，0-9，_组成

2. 数组不可以开头，例如 var 4num int 是错误的

3. Golang中严格区分大小写，例如 num和Num是两个不一样的变量

4. 标识符不能包含空格，例如var ab c int是错误的

5. 下划线“_”在Go中是一个特殊的标识符，称为空标识符。可以代表任何其他的标识符，但是它对应的值会被忽略。所以仅能被作为占位符使用，而不能作为标识符使用 。

6. 不能以系统保留关键字作为标识符（一共有25个）

Golang中的系统关键字

标识符命名注意事项

1. 包名：保持package的名字和目录保持一致（和Java一样）

2. 变量名、函数名、常量名：采用驼峰法（xxxYyyyZzzz）

3. 如果变量名、函数名、常量名首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用（可以理解为首字母大写是public，首字母小写是private，不过在Golang中没有public，private等关键字）