Go语言基础 - 变量

  • 时间:
  • 分类: Golang

注释

package main

import "fmt"

// 我是单行注释

/*
    我是多行注释
    这是main函数，是程序的入口
*/
func main() {
    fmt.Println("Hello,World!")
}

变量

package main

import "fmt"

func main() {
    //name 就是变量
    var name string = "giles.wang"
    name = "giles"
    fmt.Println(name)
}

变量的定义

Go语言是静态类型语言，就是所有的类型我们都需要明确的去定义

我们声明一个变量一般是使用var关键字

var name type
  • 第一个var是声明变量的关键字，是固定的写法
  • 第二个name 是我们变量的名字，你可以按着自己的需求给它一个名字
  • 第三个type 是用来代表变量的类型
//定义一个字符串变量 name
var name String

//定义一个数字类型变量 int
var age int

Go语言可以批量定义变量

package main

import "fmt"

func main() {
    var (
        name string
        age  int
        addr string
    )
    fmt.Println(name, age, addr)
}

如果没有显式的给变量赋值，系统自动赋予它该类型的默认值

  • 整形和浮点型变量的默认值为0和0.0
  • 字符换变量的默认值为空字符串
  • 布尔型变量默认值为false
  • 切片、函数、指针变量的默认值nil

变量的初始化

变量初始化的标准格式

// = 是赋值，将右边的值赋给左边的变量
var name string = "ss"

短变量声明并初始化

package main

import "fmt"

func main() {
    name := "kuangshen"
    age := 3
    fmt.Printf("name:%s,age:%d",name,age)
}

这是Go语言的推导声明写法，编译器会自动根据右边的类型推断出左边值的类型

因为简洁和灵活的特点，简短变量声明被广泛用于大部分的局部变量的声明和初始化

注意

由于使用了:=，而不是赋值的=，因此推导声明写法的左值必须是没有被定义过的，若定义过，将会发生编译错误

打印变量类型

fmt.Printf("%T,%T", name, age)
// string,int

打印内存地址

func main() {
    var num int = 5
    fmt.Printf("num:%d的内存地址为:%p\n", num, &num)

    num = 100
    fmt.Printf("num:%d的内存地址为:%p\n", num, &num)
}

/*
    num:5的内存地址为:0xc0000a6058
    num:100的内存地址为:0xc0000a6058
*/

变量交换

func main() {

    /*
        传统交换
        a = 100;
        b = 200
        temp = 0;
        temp = a;
        a = b;
        b = temp;
    */

    var a int = 100
    var b int = 200

    b, a = a, b
    fmt.Println(a, b)

}

/*
    200 100
*/

匿名变量

匿名变量的特点是一个下画线"__"，本身就是一个特殊的标识符，被称为空白标识符。它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它)，但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用这
个标识符作为变量对其它变量进行赋值或运算。使用匿名变量时，只需要在变量声明的地方使用下画线替换即可。

func main() {
    a, _ := test()
    fmt.Println(a)
}

func test() (int, int) {
    return 100, 200
}

假如在未来我们需要接收一个对象的某个属性，其他属性就使用匿名变量接收。

匿名变量不占用内存空间，不会分配内存，且匿名变量与匿名变量之间也不会因为多次声明而无法使用。

变量的作用域

一个变量（常量、类型或函数）在程序中都要一定的作用范围，称之为作用域。

了解变量的作用域对我们学习Go语言来说是比较重要的，因为Go语言会在编译时检查每个变量是否使用过，一旦出现未使用的变量，就会报编译错误。如果不能理解变量的作用域，就有可能会带来一些不明所以的编译错误。

局部变量

在函数内声明的变量称之为局部变量，作用域只在函数体内。

func main() {
    // a就是局部变量
    a, _ := test()
    fmt.Println(a)
}

全局变量

在函数体外声明的变量称之为全局变量，全局变量只需要在一个源文件中定义，就可以在所有的源文件中使用，当然，不包含这个全局变量的源文件需要使用『import』关键字引入全局变量所在的源文件只有才能使用这个全局变量。

全局变量声明必须以var关键字开头，如果想要在外部包中使用全局变量的首字母必须大写。

var name string = "s"

func main() {
    var name string = "a"
    fmt.Println(name)
}

/*
    a     //就近原则
*/

常量

在Go语言中，我们使用const关键字来定义常量，常量的值不允许改变，一般用大写表示。

func main() {
    const URL string = "192.168.1.1"    //显式定义
    const URL2 = "192.168.1.1"            //隐式定义
    const a, b, c = 3.14, "www.giles.wang", true        //同时定义
    fmt.Println(a, b, c)
}

iota，特殊常量，可以认为是一个可以被编译器修改的常量。iota是go语言的常量计数器
iota在const关键字出现时将被重置为0(const内部的第一行之前)，const 中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。

iota可以被用作枚举值:

func main() {
    const (
        a = iota
        b = iota
        c = iota
    )
    fmt.Println(a, b, c)
}

/*
    0 1 2
*/

只要在同一组里，iota的值都会从0开始增加。

func main() {
    const (
        a = iota
        b
        c
        d = "haha"
        e
        f = 100
        g
        h = iota
        i
    )
    const (
        j = iota
        k
    )
    fmt.Println(a, b, c, d, e, f, g, h, i)
}

/*
    0 1 2 haha haha 100 100 7 8 0 1
*/

标签: 无

发表评论：