2.go基础语法

smile_pbb

于 2023-04-20 09:22:26 发布

阅读量246

点赞数

分类专栏： go学习文章标签： golang

本文链接：https://blog.csdn.net/smile_pbb/article/details/130258608

版权

go学习专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一、环境安装

windows 下载安装版本就可以了，例如：

go1.20.2.windows-386.msi

安装好后，环境变量自动会设置好，全局可以使用go命令

C:\Users\pangbb>go version
go version go1.20.2 windows/386

配置goproxy,配置好goproxy 在vscode中安装go的扩展插件

go env -w GOPROXY=https://goproxy.cn,direct

输出一个hello world

package main
import "fmt"

func main(){
	fmt.Print("hello world")
}

二、变量

1.变量声明

var name string

2.先声明在赋值

package main
import "fmt"

func main(){
	var name string
	name = "zhangsan"
	fmt.Println("name的值为:" + name)
}

3.变量声明并赋值

package main
import "fmt"

func main(){
	var name string = "zhangsan"
	fmt.Println("name的值为:" + name)
}

省略var 和 “数据类型关键字” 的写法. string这个数据类型可以省略， var的关键字用 :代替

package main
import "fmt"

func main(){
	name := "zhangsan"
	fmt.Println("name的值为:" + name)
}

4.声明多个相同类型变量

package main
import "fmt"

func main(){
	var name,gender string
	name = "zhangsan"
	gender = "boy"
	fmt.Println("name的值为:" + name,"gender的值为:" + gender)
}

5.声明多个不同类型变量

package main
import "fmt"

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


结果如下：
E:\code\project\后端项目\go_project\hello>go run main.go
 0 false

//这里可以看到 三个不同类型的变量是有默认值的

声明并赋值：

package main
import "fmt"

func main(){
	var(
		name string
		age int
		ismarrid bool
	)
	name = "zhangsan"
	age = 20 
	ismarrid = true
	fmt.Println(name,age,ismarrid)
}

6.简便写法

package main
import "fmt"

func main(){
	name,age,ismarrid := "zhangsan",20,true
	fmt.Println(name,age,ismarrid)
}

7.注意

:= 的用法仅限于在函数内使用

8.匿名变量

匿名变量只能用来接受值，不能打印，和占位符作用差不多

匿名变量使用 _ 来表示

实例：

a,_  := "zhangsan","lisi"

9.语句分隔符

在go中是使用 ; 和换行来区分不同的语句。也就是说;的使用场景只有这种场景

var a  = 1;var b = 2;

三、数据类型

主要数据类型是：

1.整形

类型	取值范围
uint8：无符号8位整数	0-255
uint16：无符号16位整数	0-65535
uint32：无符号32位整数
uint64：无符号64位整数
int8：有符号8位整数	-128 - 127
int16：有符号16位整数	-32768 - 32767
int32：有符号32位整数
int64：有符号64位整数

2.浮点型

float32 和float64

3.布尔型

true 和 flase

4.字符串儿

4.1 索引

索引的开始也是从0开始的，注意的是在go中打印单个字符的时候不会直接显示字符，而是显示字符对应额ASIC码，所以需要转义一下。

package main
import "fmt"

func main(){
	s := "hello world"
	fmt.Println(string(s[0]))
}

4.2 切片

切换和python的一样切片一样，但是不支持负数。

package main
import "fmt"

func main(){
	s := "hello world"
	fmt.Println(s[2:])
	fmt.Println(s[2:6])
	fmt.Println(s[:6])
}

结果如下：

E:\code\project\后端项目\go_project\hello>go run main.go
llo world
llo
hello

4.3 字符串拼接

package main
import "fmt"

func main(){
	name := "zhangsan"
	age := " 200"
	fmt.Print(name + age)
}

4.4 转大写字符

package main

import (
	"fmt"
	"strings"
)

func main() {
	name := "zhangsan"
	newname := strings.ToUpper(name)
	fmt.Print(newname)
}

4.5 判断某字符开头

func main() {
	var name string = "zhangsan"
	fmt.Print(strings.HasPrefix(name, "li"))
}
结果如下：
E:\code\project\后端项目\go_project\hello>go run main.go
false

4.6 判断某字符结尾

import (
	"fmt"
	"strings"
)

func main() {
	var name string = "zhangsan"
	fmt.Print(strings.HasSuffix(name, "san"))
}

4.7 检索字符串

func main() {
	name := "zhangsan  lisi wangwu"
	fmt.Print(strings.Contains(name, "zhang"))
}

结果如下：
E:\code\project\后端项目\go_project\hello>go run main.go
true

4.8 去空格

strings.TrimSpace 只能去除字符串前后的空格

package main

import (
	"fmt"
	"strings"
)

func main() {
	var name string = "   zhang san   "
	fmt.Print(strings.TrimSpace(name))
	fmt.Println("lisi")
}

结果如下：
E:\code\project\后端项目\go_project\hello>go run main.go
zhang sanlisi

4.9 索引

import (
	"fmt"
	"strings"
)

func main() {
	name := "zhangsan  lisi wangwu"
	newname := strings.Index(name, "hangsan")
	fmt.Println(newname)
}

4.10 分割

import (
	"fmt"
	"strings"
)

func main() {
	name := "zhangsan lisi wangwu"
	newname := strings.Split(name, " ")
	fmt.Println(newname)
}

结果如下：
E:\code\project\后端项目\go_project\hello>go run main.go
[zhangsan lisi wangwu]

4.11 拼接

package main

import (
	"fmt"
	"strings"
)

func main() {
	name := "zhangsan lisi wangwu"
	newname := strings.Split(name, " ")
	newname1 := strings.Join(newname, ",")
	fmt.Println(newname1)
}

结果如下：
E:\code\project\后端项目\go_project\hello>go run main.go
zhangsan,lisi,wangwu

5.数据类型转换

5.1 字符串转数字

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	ageStr := "10"
	age, _ := strconv.Atoi(ageStr)
	fmt.Println(age, reflect.TypeOf(age))
}


结果如下：
E:\code\project\后端项目\go_project\hello>go run main.go
10 int

5.2 数字转字符串

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	age := 10
	newage := strconv.Itoa(age)
	fmt.Println(newage, reflect.TypeOf(newage))
}

6.值拷贝

6.1 python

首先在python中,变量在传递值的时候，是传递的地址.a和b变量指向的是同一地址

a = 10
b = a
print("a address is {}".format(id(a)))
print("b address is {}".format(id(b)))
print("-"*100)
a = 20
print("a address is {}".format(id(a)))
print("b address is {}".format(id(b))

结果如下：


[root@node1 ~]# python a.py 
a address is 7090304
b address is 7090304
----------------------------------------------------------------------------------------------------
a address is 7090064
b address is 7090304

6.2 go

在go中不是这样的，在变量传递的时候，是直接传递的值，b是直接开辟了一块新空间

a := 100
b := a
fmt.Println("a的地址是:", &a)
fmt.Println("b的地址是:", &b)
a = 200
fmt.Println("a的地址是:", &a)
fmt.Println("b的地址是:", &b)

结果如下：

a的地址是: 0xc00000c098
b的地址是: 0xc00000c0b0
a的地址是: 0xc00000c098
b的地址是: 0xc00000c0b0

四、判断和循环

1.if语句

注意点:
判断条件可以不加（），一般编辑器一保存也会帮你（）去掉
if和else关键字后边的{ 必须和if和else在同义行，不能换行

package main

import "fmt"

func main() {
	var username = "root"
	var passworwd = "123"
	if username == "root1" && passworwd == "123" {
		fmt.Println("登陆成功")
	} else {
		fmt.Print("登陆失败")
	}
}

2.if多分支语句

package main

import (
	"fmt"
)

func main() {
	var a string
	fmt.Println("请输入一种颜色:")
	fmt.Scan(&a)
	if a == "red" {
		fmt.Println("这是爱情的颜色")
	} else if a == "pink" {
		fmt.Println("这是年轻的颜色")
	} else {
		fmt.Println("这个颜色可不怎么样")
	}
}

3.for循环

3.1.死循环

func main() {
	var num = 0
	for {
		num++
		fmt.Println(num)
	}
}

3.2 判断循环

func main() {
	var num = 0
	for num < 10 {
		fmt.Println(num)
		num++
	}
}

3.3 类C写法

for i := 0; i <= 10; i++ {
		fmt.Println(i)
}

五、指针

1.定义指针变量

var num = 100
var p *int
p = &num
fmt.Println(p)

2.打印指针变量的值

fmt.Println(*p)

3.通过指针修改变量的值

	var num = 100
	var p *int
	p = &num
	fmt.Println(num)
	fmt.Println("-------------------------")
	*p = 200
	fmt.Println(num)

结果如下：

100
-------------------------
200

六、数组和切片

1.定义数组并且赋值数组

数组定义好后，是不能追加元素的

#一开始就定义了数组的长度为3，只能放3个元素
var name = [3]string{"zhangsan", "lisi", "wangwu"}

#在初始化的时候，不限定数组内存放几个元素，但是一但存放了元素，就固定下来了
var num = [...]int{10, 11, 12, 13, 14, 15}
fmt.Println(name)
fmt.Println(num)

查看数组显示的类型

fmt.Println(reflect.TypeOf(name))
fmt.Println(reflect.TypeOf(num))

结果如下：
[3]string
[6]int

2.切片

切片是对数组的一个连续片段的引用,切片不会对数组进行复制操作。
切片是引用类型数据，必须要初始化才能使用，否则会报索引越界的错

切片的定义有两种：

2.1 切片的定义

1.直接定义切片

var num = []int{0, 1, 2, 3, 4, 5}
fmt.Println(reflect.TypeOf(num))

结果是：
[]int

2.对数组进行切片操作得到切片对象

var num = [...]int{10, 11, 12, 13, 14, 15}
var num1 = num[0:4]
fmt.Println(num1)
fmt.Println(reflect.TypeOf(num1))

结果如下：

[10 11 12 13]
[]int

在类型显示上切片的类型是[]里不显示数组中的元素个数

2.2 通过切片修改数组

var num = [...]int{10, 11, 12, 13, 14, 15}
var num1 = num[0:4]
fmt.Println(num)
fmt.Println(num1)
fmt.Println("---------------------------")
num1[0] = 100
fmt.Println(num)
fmt.Println(num1)

结果如下：

[10 11 12 13 14 15]
[10 11 12 13]
---------------------------
[100 11 12 13 14 15]
[100 11 12 13]

2.3 快速将数组进行全部切片

var num = [...]int{10, 11, 12, 13, 14, 15}

#省略切片的开始和结尾，就对数组进行切片，内容和数组一致
var num1 = num[:]
fmt.Println(num, reflect.TypeOf(num))
fmt.Println(num1, reflect.TypeOf(num1))

结果如下：
[10 11 12 13 14 15] [6]int
[10 11 12 13 14 15] []int

3.切片的长度和容量

3.1.切片的长度就是切片中有几个元素
3.2.切片的容量是"数组"的长度减去切片的开始位置： len(数组) - 切片开始的索引

实例验证：

var num = [...]int{10, 11, 12, 13, 14, 15}
var a1 = num[0:1] 
var a2 = num[0:2] 
var a3 = num[1:2] 
var a4 = num[2:3] 
fmt.Println(a1, len(a1), cap(a1))
fmt.Println(a2, len(a2), cap(a2))
fmt.Println(a3, len(a3), cap(a3))
fmt.Println(a4, len(a4), cap(a4))


结果如下：
[10] 1 6
[10 11] 2 6
[11] 1 5
[12] 1 4

4.切片的追加

4.1 切片的追加不会对数组造成影响

var num = [...]int{10, 11, 12, 13, 14, 15}
var a = num[:]
a = append(a, 20)
a = append(a, 21)
fmt.Println(num)
fmt.Println(a)

结果如下：
[10 11 12 13 14 15]
[10 11 12 13 14 15 20 21]

4.2定义切片在追加

num := []int{}
fmt.Println(num)
num = append(num, 10)
num = append(num, 20)
num = append(num, 30)
fmt.Println(num)


结果如下：
[]
[10 20 30]

5.vscode使用append小技巧

给哪个切片朱家元素、只要使用

切片名.append      会自动生成       切片名 = append(切片名，要追加的值) 的表达式

6.切片追加另外一个切片

使用 “切片名…” 解构

var num = []int{0, 1, 2, 3, 4, 5}
var num1 = []int{10, 11, 12, 13}
num = append(num, num1...)
fmt.Println(num)

7.切片和数组的遍历

var num = []int{10, 11, 12, 13, 14, 15}
for i, v := range num {
	fmt.Println(i, v)
}

七、map

1.定义

map就是python的字典
解释：
第一个string: key的类型
第二个string: value的类型

var list = map[string]string{"name": "zhangsan", "age": "20"}
fmt.Println(list)

2.修改map值

修改值和插入语法一致

var list = map[string]string{"name": "zhangsan", "age": "20"}
fmt.Println(list)
list["name"] = "lisi"
fmt.Println(list)

3.遍历map

var list = map[string]string{"name": "zhangsan", "age": "20"}
	for _, v := range list {
		// fmt.Println(i, v)
		fmt.Println(v)
	}

smile_pbb

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2.go基础语法

数组定义好后，是不能追加元素的#一开始就定义了数组的长度为 3 ，只能放 3 个元素 var name = [ 3 ] string {"zhangsan" , "lisi" , "wangwu" } #在初始化的时候，不限定数组内存放几个元素，但是一但存放了元素，就固定下来了 var num = [ ... ] int {查看数组显示的类型。
复制链接

扫一扫