Go学习笔记day01

最新推荐文章于 2022-11-14 09:42:49 发布

虾泥泥泥泥

最新推荐文章于 2022-11-14 09:42:49 发布

阅读量128

点赞数 1

分类专栏： go 文章标签： go 编程语言

本文链接：https://blog.csdn.net/weixin_44179269/article/details/108688289

版权

go 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

变量

单变量声明

第一种，指定变量类型，声明后若不赋值，使用默认值

var name type
name = value

第二种，类型推断

var name = value
//也可以写作
var name type = value

第三种，简短声明，省略var

注意 :=左侧的变量至少保证一个是新变量，否则会导致编译错误

name := value

// 例如
var a int = 10
var b = 10
c : = 10

这种方式它只能被用在函数体内，而不可以用于全局变量的声明与赋值

多变量声明

第一种，相同类型的变量。以逗号分隔，声明与赋值分开，若不赋值，存在默认值

var name1, name2, name3 type
name1, name2, name3 = v1, v2, v3

第二种，直接赋值，下面的变量类型可以是不同的类型

var name1, name2, name3 = v1, v2, v3

第三种，集合类型，这种因式分解关键字的写法一般用于声明全局变量

var (
    name1 type1
    name2 type2
)

注意事项

1、如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明，例如：a := 20 就是不被允许的，编译器会提示错误 no new variables on left side of :=，但是 a = 20 是可以的，因为这是给相同的变量赋予一个新的值。

2、局部变量定义了就要使用，否则无法通过编译，但是全局变量是允许声明但不使用的。

3、变量的默认值：

整型：默认值是0

浮点类型：默认是0

字符串：默认值""

布尔：false

其他：
以下几种类型为 nil：

var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口

4、如果你想要交换两个变量的值，则可以简单地使用 a, b = b, a，两个变量的类型必须是相同。

5、空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃。

_ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。

6、多变量可以在同一行进行赋值，如：

a, b, c := 5, 7, "abc"

//或
var a, b int
var c string
a, b, c = 5, 7, "abc"

常量

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

常量可以作为枚举，常量组

const (
    Unknown = 0
    Female = 1
    Male = 2
)

常量组中如不指定类型和初始化值，则与上一行非空常量右值相同

package main

import (
	"fmt"
)

func main() {
	const (
		x uint16 = 16
		y
		s = "abc"
		z
	)
	fmt.Printf("%T,%v\n", y, y)
	fmt.Printf("%T,%v\n", z, z)
}

运行结果：

uint16,16
string,abc

常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：

package main

import "unsafe"
const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)

func main(){
    println(a, b, c)
}

//输出
abc 3 16

注意事项

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型
不曾使用的常量，在编译的时候，是不会报错的
显示指定类型的时候，必须确保常量左右值类型一致，需要时可做显示类型转换。这与变量就不一样了，变量是可以是不同的类型值

iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1。

iota 用法

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

运行结果：

0 1 2 ha ha 100 100 7 8

如果中断iota自增，则必须显式恢复。且后续自增值按行序递增

自增默认是int类型，可以自行进行显示指定类型

另起一个const()，iota依旧从零递增

数字常量不会分配存储空间，无须像变量那样通过内存寻址来取值，因此无法获取地址

有趣的的 iota 实例

package main

import "fmt"
const (
  i=1<<iota
  j=3<<iota
  k
  l
)

func main() {
  fmt.Println("i=",i)
  fmt.Println("j=",j)
  fmt.Println("k=",k)
  fmt.Println("l=",l)
}

以上实例运行结果为：

i= 1
j= 6
k= 12
l= 24

iota 表示从 0 开始自动加 1，所以 i=1<<0, j=3<<1（<< 表示左移的意思），即：i=1, j=6，这没问题，关键在 k 和 l，从输出结果看 k=3<<2，l=3<<3。

简单表述:

i=1：左移 0 位,不变仍为 1;
j=3：左移 1 位,变为二进制 110, 即 6;
k=3：左移 2 位,变为二进制 1100, 即 12;
l=3：左移 3 位,变为二进制 11000,即 24。

注：<<n==*(2^n)。

基本数据类型

1.1 布尔型bool

布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true

1.2 数值型

1、整数型

int8 有符号 8 位整型 (-128 到 127) 长度：8bit
int16 有符号 16 位整型 (-32768 到 32767)
int32 有符号 32 位整型 (-2147483648 到 2147483647)
int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
uint8 无符号 8 位整型 (0 到 255) 8位都用于表示数值：
uint16 无符号 16 位整型 (0 到 65535)
uint32 无符号 32 位整型 (0 到 4294967295)
uint64 无符号 64 位整型 (0 到 18446744073709551615)

int和uint:根据底层平台，表示32或64位整数。除非需要使用特定大小的整数，否则通常应该使用int来表示整数。大小:32位系统32位，64位系统64位。范围:-2147483648到2147483647的32位系统和-9223372036854775808到9223372036854775807的64位系统。

2、浮点型

float32

IEEE-754 32位浮点型数
float64

IEEE-754 64位浮点型数
complex64

32 位实数和虚数
complex128

64 位实数和虚数

3、其他

byte

类似 uint8
rune

类似 int32
uint

32 或 64 位
int

与 uint 一样大小
uintptr

无符号整型，用于存放一个指针

1.3 字符串型

字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本

	var str string
	str = "Hello World"

注意事项

1、即使是64位机，int与int64不认为是同一种类型，也不能相互赋值。

2、64位机，整数默认类型int，浮点数默认类型float64

var a = 100
var b = 29.0
fmt.Printf("%T\n",a)
fmt.Printf("%T\n",b)

//输出
int
float64

数据类型转换

语法格式：Type(Value)

注意点：兼容类型可以转换

常数：在有需要的时候，自动转型

变量：需要手动转型

虾泥泥泥泥

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Go学习笔记day01

变量单变量声明第一种，指定变量类型，声明后若不赋值，使用默认值var name typename = value第二种，类型推断var name = value//也可以写作var name type = value第三种，简短声明，省略var注意 :=左侧的变量至少保证一个是新变量，否则会导致编译错误name := value// 例如var a int = 10var b = 10c : = 10这种方式它只能被用在函数体内，而不可以用于全局变量的声明与赋值
复制链接

扫一扫

专栏目录