2.go语言入门----变量类型、声明变量、数组、切片

基本变量类型

介绍几种基本的变量类型：字符串、int、float、bool

package main

import (
	"fmt"
)

// 列举几种非常基本的数据类型
func main() {
	fmt.Println("go" + "lang")    // 允许使用“+”来连接字符串
	fmt.Println("1+1=", 1+1)
	fmt.Println("7.0/3.0=", 7.0/3.0)
	fmt.Println(true && false)    // 需要注意的是，go中不允许将整形强制转换成布尔型
	fmt.Println(true || false)
	fmt.Println(!true)
}

字符串

1. 可以使用反引号来定义多行字符串

   var (
   	str string = `aaa
       aaa
       aaa
       aaa
   aaa `
   )
   
   stdOut:
   aaa
       aaa
       aaa
       aaa
   aaa
   

定义变量

package main

import "fmt"

func main() {

	var a = "initial"    // 使用关键字var来定义变量，可以不显示指定变量类型，go会自动判断
	fmt.Println(a)

	var b, c int = 1, 2    // 指定变量类型时，类型要放在变量名的后面
	fmt.Println(b, c)

	var d = true
	fmt.Println(d)

	var e int    // int的默认值为0
	fmt.Println(e)

    f := "apple"    // 可以使用“:=”来省略关键字var，这种方式一般用的比较多，这里也不用显示的指定变量类型
	fmt.Println(f)
}

要点总结

1. go是一门强类型的语言，但是定义变量的时候却可以省略变量类型，由go自己推导出来

2. 定义变量的几种方式

   var =

   var =

   :=

3. 在go语言中，通常是使用var关键字来定义全局变量，使用":="来定义局部变量

数组

数组是一种数据类型的固定长度序列

package main

import "fmt"

func main() {

    var a [5]int    // 这里初始化了一个变量，发现默认值是数组中变量类型的默认值
    fmt.Println("emp:", a)

    a[4] = 100    // 可以通过索引对数组中的指定元素赋值
    fmt.Println("set:", a)
    fmt.Println("get:", a[4])

    fmt.Println("len:", len(a))

    b := [5]int{1, 2, 3, 4, 5}    // 初始化数组的同时赋值
    fmt.Println("dcl:", b)

    var twoD [2][3]int    // 定义多维数组
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

stdOut:
emp: [0 0 0 0 0]
set: [0 0 0 0 100]
get: 100
len: 5
dcl: [1 2 3 4 5]
2d:  [[0 1 2] [1 2 3]]

要点总结

1. 数组中元素的默认值为元素类型的默认值
2. 数组中的元素类型要一致
3. 可以通过索引对数组指定元素进行操作
4. 可以定义多维数组
5. var [n] = [n]{1,2,3,4.....}

切片

切片类似于数组，但其长度可变

package main

import "fmt"

func main() {

    s := make([]string, 3)    // 定义了一个长度为3的切片
    fmt.Println("emp:", s)    // 这里打印一下发现其中的值为空的，如果是数组的话会是3个0

    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])

    fmt.Println("len:", len(s))    // 使用起来也和数组一样，可以通过索引使用

    s = append(s, "d")    // 通过append函数来拓展切片，但要注意这里需要重新赋值，否则原来的是不会变得
    s = append(s, "e", "f")    // 可以一次拓展多个值
    fmt.Println("apd:", s)

    c := make([]string, len(s))
    copy(c, s)    // 使用copy可以复制切片
    fmt.Println("cpy:", c)

    l := s[2:5]    // 类似python，通过 “:” 来限制索引
    fmt.Println("sl1:", l)

    l = s[:5]
    fmt.Println("sl2:", l)

    l = s[2:]
    fmt.Println("sl3:", l)

    t := []string{"g", "h", "i"}    // 定义的同时初始化
    fmt.Println("dcl:", t)

    twoD := make([][]int, 3)    // 二维切片
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

stdOut:
emp: [  ]
set: [a b c]
get: c
len: 3
apd: [a b c d e f]
cpy: [a b c d e f]
sl1: [c d e]
sl2: [a b c d e]
sl3: [c d e f]
dcl: [g h i]
2d:  [[0] [1 2] [2 3 4]]

常用方法

1. 长度 len()

   使用len(切片名) 来得到切片长度

2. append()和copy()

   append(numbers, 1) // 将1添加到numbers的末尾

   copy(numbers1, numbers2) //将numbers2复制到numbers1