golang学习笔记1——基础知识

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/yubo_725/article/details/89512644

golang变量的声明

声明变量有两种方式:

使用var声明变量

// 声明一个整型数据
var a int

// 声明一个字符串
var s string

// 声明一个浮点数组
var c [2]float32

// 声明一个函数
var d func(int) bool

// 声明一个结构体
var e struct {
	x int
}

使用:=声明变量并赋值

例如:

age := 20
name := "zhangsan"

golang变量的初始化

使用var声明并初始化

初始化变量的格式一般为:

var 变量名 变量类型 = 表达式或值

例如:

var name string = "xiaoming"

由于编译器会自动推断数据类型,所以上面的赋值语句可以省略变量类型:

var name = "xiaoming"

使用:=声明并初始化

另外,golang中还有一种短变量的声明并初始化方式,即使用:=,例子如下:

name := "zhangsan"

需要注意的是,如果一个变量已经声明,则不能再使用:=为变量赋值,否则编译器会报错,如下代码:

var name string

name := "zhangsan" // 编译报错:no new variables on left side of :=

短变量可以一次声明多个变量并同时赋值,如下代码:

// 同时声明name和age变量并分别赋值为"zhangsan", 20
name, age := "zhangsan", 20

这种一次赋值多个变量的方式,还能轻松完成两个变量的交换,如下代码:

a := 1
b := 2
// 将a, b的值交换,交换后a = 2, b = 1
a, b = b, a

匿名变量

使用_可以表示一个匿名变量,假如有一个函数返回两个整型值,我们只需要接收第一个值,可以用如下代码:

func Test() (int, int) {
	return 1, 2
}

func main() {
	// 使用_表示匿名变量
	a, _ := Test()
	fmt.Println(a)
}

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

golang基本数据类型

整型

golang中的整数分为两个大类:

  1. 按长度分:int8, int16, int32, int64
  2. 无符号整型:uint8, uint16, uint32, uint64

uint8对应byte类型,int16对应C语言中的short类型,int64对应C语言中的long类型

浮点型

golang支持两种浮点型数:float32, float64

bool类型

golang中的布尔类型有true false两个值,如下代码:

var b = false
success := true

注意:整型无法强转成bool类型,比如下面的代码会报错:

var a bool = 1 // 错误,整型无法强转为bool类型 

字符串

golang中的字符串必须用双引号包裹起来,如下代码:

var like string = "swimming"

var name = "zhangsan"

major := "math"

定义多行字符串可以使用反引号:

func main() {
	s := `hello,
	my name is zhangsan,
	nice to meet you!`
	fmt.Println(s)
}

字符串在任何一种编程语言中都是最常用的数据类型之一,关于golang中的字符串,需要知道如下一些基本操作:

  • 字符串长度
  • 字符串拼接
  • 字符串查找
  • 字符串格式化输出
  • 字符串截取

字符串长度

golang中获取字符串长度分两种:ASCII字符串长度和Unicode字符串长度,如下代码所示:

s := "hello world"
// 字符串长度
fmt.Println(len(s)) // 11

dog := "王大锤"
// ASCII 字符串长度使用 len() 函数
fmt.Println(len(dog)) // 9
// Unicode 字符串长度使用 utf8.RuneCountInString() 函数
fmt.Println(utf8.RuneCountInString(dog)) // 3

字符串拼接

示例代码:

s := "hello world"
name := ", zhangsan"
// 字符串拼接, += 操作仅限字符串与字符串
s += name
fmt.Println(s)

// 字符串与非字符串类型的拼接
var str string = fmt.Sprintf("I am %d years old.", 20)
fmt.Println(str) // I am 20 years old.

字符串查找

示例代码:

s := "hello world"
// 查找d在s中的索引
fmt.Println(strings.Index(s, "d")) // 10

strings.Index()是正向搜索,strings.LastIndex()是反向搜索

字符串格式化输出

使用fmt.Printf()格式化输出字符串,示例代码如下:

name := "zhangsan"
age := 20
job := "teacher"
// hello, this is zhangsan, I'm 20 years old and I'm a teacher
fmt.Printf("hello, this is %v, I'm %v years old and I'm a %v", name, age, job)

格式化字符串时,有如下一些占位符:

占位符 功能
%v 按值的本来值输出
%f 浮点数
%d 整型以十进制方式显示
%b 整型以二进制方式显示
%o 整型以八进制方式显示
%x 整型以十六进制方式显示
%X 整型以十六进制、字母大写方式显示
%U Unicode 字符
%p 指针,十六进制方式显示
%+v 在 %v 基础上,对结构体字段名和值进行展开
%#v 输出 Go 语言语法格式的值
%T 输出 Go 语言语法格式的类型和值
%% 输出%

字符串截取

s := "hello world"
fmt.Println(s[:5]) // hello
fmt.Println(s[6:]) // world

字符类型

golang中的字符类型分两种:ASCII字符和UTF-8字符,分别称为byte类型和rune类型,如下代码:

var b byte = 'a'
var c rune = '你'
// b: uint8, c: int32
fmt.Printf("b: %T, c: %T", b, c)

byte类型实际就是uint8,rune类型实际就是int32

常量

使用const定义常量:

const name = "zhangsan"
fmt.Println(name)
name = "lisi" // 报错:cannot assign to name

枚举

目前golang中没有枚举这个类型,可以使用const + iota的方式模拟枚举,如下代码:

package main

import "fmt"

type Color int

const (
	BLUE = iota
	RED
	GREEN
	BLACK
	WHITE
)

func main() {
	// 0 1 2 3 4
	fmt.Println(BLUE, RED, GREEN, BLACK, WHITE)
}

golang指针

golang中的指针与C语言中的指针类似,也是使用&操作符对某个变量取地址,如下代码所示:

a := "hello"
var ptr = &a // ptr是指向字符串a的指针
fmt.Println(ptr) // 打印出ptr指针的地址

获取某个指针的值,使用*操作,如下代码所示:

name := "zhangsan"
ptr := &name
// my name is zhangsan
fmt.Printf("my name is %s", *ptr)

取地址操作符&和取指针值操作符*是一对互补的操作符,&取某个变量的地址,*取某个指针的值

使用new也可以创建指针,如下代码:

str := new(string)
*str = "hello world"
// 打印出*string,表示str是一个字符串指针
fmt.Printf("%T", str)
// 打印出hello world
fmt.Printf("\n%s", *str)

golang类型定义与类型别名

golang中使用type可以定义类型别名,但是有两种不同的方式,下面说明区别:

type NewInt int

这种方式表示将NewInt定义为一个int类型,那么后面再定义整型数据时,可以使用NewInt,如下代码:

var a NewInt = 1

定义类型别名使用下面这种方式:

type IntAlias = int

这种方式表示将int类型取一个别名为IntAlias,后面也可以用IntAlias代替整型类型,如下代码所示:

var b IntAlias = 3

综上来看,在golang中,类型定义与类型别名都是用type关键字,且都可以为某中数据类型定义一个新的名称,但是这两者是有区别的:

  • 类型定义是定义了一种新的数据类型
  • 类型别名是将某中数据类型取别名

下面的代码显示了类型定义与类型别名的区别:

type NewInt int

type IntAlias = int

func main() {

	var a NewInt = 1

	var b IntAlias = 2

	fmt.Printf("%T \n %T", a, b)
}

以上代码输出结果为:

main.NewInt 
 int

这表示main.NewInt是一种新的数据类型,只不过这种类型与int是同一种类型,而使用type IntAlias = int定义类型别名时,IntAlias就是int类型的数据。

展开阅读全文

没有更多推荐了,返回首页