Go起步:3、变量、常量和基础类型

在此之前,搭建了Go的开发环境,并且了解的Go程序的基本结构。选择了一款Go的开发工具。有了这些,现在可以继续探索Go的魅力了。

变量

声明、初始化

在Go中对于变量的声明使用关键字var,这和JavaScript,Pascal一样。在Swift 中var 也用来定义变量,似乎新的语言都倾向使用特别关键字声明变量了。不过变量声明的格式和JavaScript还是有很大的区别,到是有些类似Pascal和Swift–都是类型信息放在变量名之后,区别在于不需要使用:分割。

var v1 int          //定义类型为int的变量v1
var v2 string       //定义类型为string的变量v2

还可以看出,变量声明语句不需要使用分号作为结束符。现在很多语言在语句结束都摒弃了分号,像Python,Swift,R等等。这点不知道是什么趋势。
Go作为一个比较新的语言,在一些写法上还是有一些比较特殊的做法。像var关键字的另一种用法是可以将若干个需要声明的变量放置在一起。
比如像上面,同时声明v1和v2可以这么写:

var(      
    v1 int      
    v2 string 
)

在变量声明时可以直接初始化的,这时var关键字甚至可以省略。

var v1 int = 100 //  
var v2 = 100    // 编译器可以自动推导出v2的类型 
v3 := 100       // 编译器可以自动推导出v3的类型 

这里写图片描述
这里可以看出,第一种方式给出一条警告,鼠标放上去是提示警告信息是“should omit type int from declaration of var v1; it will be inferred from the right-hand side”。意思是应该省略VAR V1的类型为int;它将从右侧来推断。可以看出指定类型已不再是必需的,Go可以从初始化表达式的右值推导出该变量类型,这让Go看起来有点像JavaScript这样的动态类型语言,但Go实际上是一种像java一样的静态类型语言。
第三种引入了一种“:=”符号。这在初始化变量是可以省略var关键字。这个符号应该是Go的独创吧。需要注意的是函数外的每个语句都必须以关键字开始( var 、 func 等等), 因此 := 结构不能在函数外使用。
以上三种方式都是Go支持的,具体使用哪种可以自己选择。

赋值

在Go语法中,变量初始化和变量赋值是两个不同的概念。就像:

var v1 int //定义类型为int的变量v1
v1 = 100   //给v1赋值100

Go语言的变量赋值与其他的编程语言一致,但Go语言中提供多重赋值功能,如要实现交换v1和v2变量的语句。一般做法是需要一个中间变量来完成。temp=v1,v1=v2,v2=temp。但Go可以向下面这样操作。

package main

import "fmt"

func main() {
    var v1 int //定义类型为int的变量v1
    v1 = 100
    var v2 = 200

    fmt.Println("v1:", v1)
    fmt.Println("v2:", v2)

    fmt.Println("交换v1,v2")
    v2, v1 = v1, v2
    fmt.Println("v1:", v1)
    fmt.Println("v2:", v2)
}

这里写图片描述

常量

定义、声明

常量是指编译期间就已知且不可改变的值。常量的声明与变量类似,只不过是使用 const 关键字。
常量可以是字符、字符串、布尔值或数值。
常量不能用 := 语法声明。

package main
import "fmt"

const Pi = 3.14
func main() {
    const World = "世界"
    fmt.Println("Hello", World)
    fmt.Println("Happy", Pi, "Day")
    const Truth = true
    fmt.Println("Go rules?", Truth)
}

这里写图片描述

预定义常量

Go语言预定义了这些常量:true、false和iota。
iota比较特殊,可以被认为是一个可被编译器修改的常量,在每一个const关键字出现时被重置为0,然后在下一个const出现之前,每出现一次iota,其所代表的数字会自动增1。

package main

import "fmt"

func main() {
    const ( // iota被重设为0
        c0 = iota // c0 == 0
        c1 = iota // c1 == 1
        c2 = iota // c2 == 2
    )
    fmt.Println("c0", c0)
    fmt.Println("c1", c1)
    fmt.Println("c2", c2)
}

这里写图片描述
如果两个const的赋值语句的表达式是一样的,那么可以省略后一个赋值表达式。因此,上面的前两个const语句可简写为

const (         // iota被重设为0     
c0 = iota       // c0 == 0     
c1              // c1 == 1     
c2              // c2 == 2 )

上面两个返回的结果是一样的。

类型

我开始接触Go首先就是先了解Go有哪些类型。
Go语言内置以下这些基础类型:

  • 布尔类型:bool
  • 整型:int8、byte、int16、int、uint、uintptr等
  • 浮点类型:float32、float64
  • 复数类型:complex64、complex128
  • 字符串:string
  • 字符类型:rune

此外,Go语言也支持以下这些复合类型:

  • 指针(pointer)
  • 数组(array)
  • 切片(slice)
  • 字典(map)
  • 通道(chan)
  • 结构体(struct)
  • 接口(interface)
  • 错误类型:error

布尔类型

在Go语言中的布尔类型与其他语言基本是一致的,关键字为bool,值必须为true或false,不支持自动或强制的类型转换。

整型

整形基本是所有编程语言最基础的类型了。
这里写图片描述
需要注意的是上图中,像int和int32在Go语言里被认为是两种不同的类型,编译器也不会帮你自动做类型转换。如果要转换需要自己手动做强制转换,强制转换时精度会损失。
对于整型的操作主要有数值计算(+、-、*、/、%),比较运算(>、<、==、>=、<=、!=)。这一点与大多数其他语言相 同,与C、java等完全一致。 而且Go的整型也支持位运算
这里写图片描述

浮点型

浮点型用于表示有小数位的数据,Go语言中的浮点类型 采用IEEE-754标准的表达方式。 包括float32和float64两个类型。其中float32等价于C语言的float类型, float64等价于C语言的double类型。

复数类型

复数实际上由两个实数构成,在计算机中用浮点数表示,一个表示实部(real),一个表示 虚部(imag)。 对于一个复数z = complex(x, y),就可以通过Go语言内置函数real(z)获得该复数的实 部,也就是x,通过imag(z)获得该复数的虚部,也就是y。

字符串

字符串是所有编程语言的一种基本类型,Go也不例外。

package main
import "fmt"

func main() {
    var str1 string    //定义
    str1 = "hello"     //赋值
    char := str1[0]    //取得第一个字符
    fmt.Printf("字符串%s长度%d\n", str1, len(str1))  //取得第一个字符
    fmt.Printf("c字符串%s第一个字符%c\n", str1, char)

    str2 := "world"  //初始化
    fmt.Println(str1 + str2)  //字符串连接操作
}

上面对字符串的操作有定义,初始化,赋值,计算长度,取得第一个字符,字符串连接操作。其中取字符串的长度使用了一个Go语言内置的函数len()。还可以看出,Go取字符串字节可以向数组一样,直接通过下标就可以。

字符类型

在Go语言中支持两个字符类型,一个是byte(实际上是uint8的别名),代表UTF-8字符串的单个字节的值;另一个是rune,代表单个Unicode字符。出于简化语言的考虑,Go语言的多数API都假设字符串为UTF-8编码。尽管Unicode字符在标 准库中有支持,但实际上较少使用。
在Go当中 string底层是用byte数组存的,并且是不可以改变的。用string存储unicode的话,即如果有中文,按下标是访问不到的,因为你只能得到一个byte,而汉字需要3个byte。

package main

import "fmt"

func main() {
    var str1 string
    str1 = "Go语言"
    char := str1[2]
    fmt.Printf("字符串%s长度%d\n", str1, len(str1))
    fmt.Printf("c字符串%s第3个字符%c\n", str1, char)

}

这里写图片描述
通过输出结果看出,“Go语言”长度是8,因为汉字是按3字节存储的。通过下标取到的也不是想要的“语”字。
这是要想取到想要的结果,就需要使用rune。rune是字节组合。

package main

import "fmt"

func main() {
    var str1 string
    str1 = "Go语言"
    r := []rune(str1)
    fmt.Printf("字符串%s长度%d\n", str1, len([]rune(str1)))
    fmt.Printf("c字符串%s第3个字符%c\n", str1, r[2])

}

这里写图片描述
这样就取到了想要的结果。

这里就先到这里,上面是Go支持的一些基础类型。关于复合类型下次见。通过到目前的了解,可以发现,Go里还是有很多语法糖的,很多写法都和java这样的语言不同,似乎借鉴了很多像python之类的语言,尽量简单。有时间要去了解一下Go语言的设计哲学。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值