烟台做网站优化哪家好,西安工程建设信息网,北京十大室内设计公司排名,wordpress二维码活码#x1f60b; 大家好#xff0c;我是YAy_17#xff0c;是一枚爱好网安的小白。本人水平有限#xff0c;欢迎各位大佬指点#xff0c;欢迎关注 #x1f601;#xff0c;一起学习 #x1f497; #xff0c;一起进步 ⭐ 。⭐ 此后如竟没有炬火#xff0c;我便是唯一的光… 大家好我是YAy_17是一枚爱好网安的小白。本人水平有限欢迎各位大佬指点欢迎关注 一起学习 一起进步 ⭐ 。⭐ 此后如竟没有炬火我便是唯一的光。 ⭐Go语言学习Day1package main
//表示hello.go文件所在的包是main在GO中每一个文件都归属于一个包
import fmt
//导入一个包“fmt”之后便可以使用fmt中的函数例如fmt.Println()
func main() {//func是一个关键字main是函数名同时也是主函数是整个程序的入口fmt.Println(hello world)//使用fmt包中的函数Println()来输出hello world
}GO语言的两种执行流程先编译go build *.go文件生成可执行文件*.exe之后再运行可执行文件可以生成自己命名的可执行程序go build -o myhello.exe hello.go直接使用go run *.go文件进行运行两种执行流程的区别和优缺点如果我们先编译生成可执行文件再运行可执行文件那么我们可以将生成的可执行文件移植到一台没有go开发环境的机器上进行执行如果我们是直接使用 go run *.go文件那么就需要运行的机器必须具备go语言的开发环境在编译的时候编译器会将程序运行所依赖的库文件全部包含到可执行文件中因此生成的可执行文件比较大Go语言的开发注意事项Go语言常用的转义字符// Go语言中的常用转移字符
package main
import fmtfunc main() {fmt.Println(hello\nworld!)fmt.Println(hello\tY4y17)fmt.Println(D:\\Microsoft VS Code\\GO\\Gocode\\src\\go_code)fmt.Println(Y4y17说\Golang yyds\)fmt.Println(小黑子露出鸡脚了吧\r我是ikun)
}需要注意的是最后面的\r其他的都比较的熟悉\r代表着输出当前行的内容然后从\r后面开始的地方覆盖掉最前面的内容标识符、关键字和命名规则标识符的组成标识符只能由数字、字母和下划线组成标识符的开头只能是字母和下划线标识符是区分大小写的package main
import fmt
func main(){var name string //定义变量的时候要写上var 然后是变量的名字 最后是变量的类型var age int var _sys int
}关键字GO语言提供了25个关键字Golang变量声明声明变量的语法var idetifier type var声明变量的关键字identifier变量的名称type变量的类型PS定义变量之后必须要使用不使用就会出错批量声明package main
var(name stringage int b bool
)尝试打印输出变量初始化逐个变量进行初始化func main() {var name string Y4y17var age int 21var b bool truefmt.Printf(name:%v\n, name)fmt.Printf(age:%v\n, age)fmt.Printf(b:%v, b)
}多个变量初始化func main() {var name,age,b Y4y17,21,truefmt.Printf(name:%v\n, name)fmt.Printf(age:%v\n, age)fmt.Printf(b:%v, b)
}类型推断var name Y4y17 //不需要后面的数据类型短变量声明在函数内部可以使用运算符对变量进行声明和初始化package main
func main(){name : Y4y17age : 21
}这种方法只适合在函数内部函数外部不能使用匿名变量package main
import fmt
func GetNameAndAge() (string, int) {return Y4y17, 21
}func main() {name, age : GetNameAndAge()fmt.Printf(name:%v\tage:%v, name, age)
}package main
import fmt
func GetNameAndAge() (string, int) {return Y4y17, 21
}func main() {name, age : GetNameAndAge()fmt.Printf(name:%v\tage:%v, name, age)
}//有的时候比如name没有用到我们还可以用下划线替换掉name
func GetNameAndAge() (string, int) {return Y4y17, 21
}func main() {_,age : GetNameAndAge()fmt.Printf(age:%v,age)
}常量的初始化有一个比较特殊的常量他是可以更改值的iota默认开始值为0每调用一次加1遇到const关键字的时候被重置为0package mainimport (fmt
)
func main() {const (a1 iotaa2 iotaa3 iota)fmt.Printf(a1: %v\n, a1)fmt.Printf(a2: %v\n, a2)fmt.Printf(a3: %v\n, a3)
}
//输出的结果为0 1 2使用”_“来跳过某一些值package mainimport (fmt
)
func main() {const (a1 iota_a3 iota)fmt.Printf(a1: %v\n, a1)fmt.Printf(a3: %v\n, a3)
}
//输出的结果为0 2iota中间插队package mainimport (fmt
)
func main() {const (a1 iota_a3 iota)fmt.Printf(a1: %v\n, a1)fmt.Printf(a3: %v\n, a3)
}
//输出的结果为0 2Go语言的数据类型package main
import (fmt
)func main() {var name string zhangsanage : 20b : truefmt.Printf(%T\n%T\n%T\n, name, age, b)inter : agefmt.Printf(%T\n, inter)a : [2]int{1, 2}efmt.Printf(%T\n, a)c : []int{1,2,3}fmt.Printf(%T\n,c)
}分别输出最后面的c : []int{1,2,3} 他不是数组它叫做切片也是个动态的数组就是当长度不指定的时候便是切片数字类型Go语言字符串字面量在Go语言中字符串字面量使用双引号”“或者是反引号来创建。在Go语言中没有char类型单行的字符串用双引号多行的字符串用的是反引号package mainimport fmtfunc main() {var str string hellostr2 : line 1line 2line 3fmt.Printf(str: %v\n, str)fmt.Printf(str2: %v\n, str2)
}字符串的连接”“号package main
import (fmt
)
func main() {name : Y4y17age : 20s : name agefmt.Printf(s: %v\n, s)}fmt.Sprintf()package main
import (fmt
)
func main() {name : Y4y17age : 20s1 : fmt.Sprintf(%v,%v, name, age)fmt.Printf(s1: %v\n, s1)
}strings.Join()package main
import (fmtstrings
)
func main() {name : Y4y17age : 20s2 : strings.Join([]string{name, age}, ,)fmt.Printf(s2: %v\n, s2)
}
//strings.Join这种方式两个参数第一个参数是一个用来连接的空的数组第二个参数是
//用来连接时的中间的分隔符write.bufferpackage mainimport (bytesfmt
)func main() {var buffer bytes.Bufferbuffer.WriteString(Y4y17)buffer.WriteString(,)buffer.WriteString(20)fmt.Printf(buffer.String(): %v\n, buffer.String())
}Go语言中的切片操作package mainimport fmt
func main() {s : hello worldn : 3m : 5fmt.Printf(s[n]: %v\n, s[n])fmt.Printf(s[n:m]: %v\n, s[n:m]) //前闭后开区间 [)fmt.Printf(s[n:]: %v\n, s[n:])fmt.Printf(s[:m]: %v\n, s[:m])
}Go语言中的字符串函数package mainimport (fmtstrings
)func main() {s : hello World//返回字符串的长度fmt.Printf(len(s): %v\n, len(s))//字符串的分割函数fmt.Printf(strings.Split(s, \ \): %v\n, strings.Split(s, ))//判断字符串中是否包含另一个字符串fmt.Printf(strings.Contains(s, \hello\): %v\n, strings.Contains(s, hello))//转换小写fmt.Printf(strings.ToLower(s): %v\n, strings.ToLower(s))//转化大写fmt.Printf(strings.ToUpper(s): %v\n, strings.ToUpper(s))//判断字符串中是否含有某个前缀fmt.Println(strings.CutPrefix(s, hello))//判断字符串中时候含有某个后缀fmt.Println(strings.CutSuffix(s, World))}Go格式化输出package mainimport fmttype website struct {name string
}func main() {site : website{name: Y4y17.com}fmt.Printf(site: %v\n, site) //%v 代表的就是varfmt.Printf(site: %#v\n, site) //%#v 会将详细内容输出fmt.Printf(site: %T\n, site) //%T代表的是type
}Go语言的运算符与其他的语言一样 - * / %的用法都是一样的当然还有自增和自减的运算符 --package main
import fmt
func main() {a : 10b : 21fmt.Printf(a: %v\n, a)fmt.Printf(b: %v\n, b)fmt.Printf((a b): %v\n, (a b))fmt.Printf((a - b): %v\n, (a - b))fmt.Printf((a / b): %v\n, (a / b))fmt.Printf((a * b): %v\n, (a * b))//fmt.Printf((b % a): %v\n, (b % a))c : b % 10fmt.Printf(c: %v\n, c)// --afmt.Printf(a: %v\n, a)b--fmt.Printf(b: %v\n, b)
}
/*
a: 10
b: 21
(a b): 31
(a - b): -11
(a / b): 0
(a * b): 210
c: 1
a: 11
b: 20
*/Golang中的选择结构if else语句package mainimport fmtfunc main() {a : 18if a 18 {fmt.Println(成年)} else {fmt.Println(未成年)}
}Go语言不同于其他的语言它可以在if语句中定义变量package mainimport fmtfunc main() {if a : 18; a 18 {fmt.Println(成年)} else {fmt.Println(未成年)}
}if else if语句package mainimport fmtfunc main() {if a : 18; a 18 {fmt.Println(成年)} else if a 18 {fmt.Println(未成年)} else {fmt.Println(18岁) }
}switch结构package main
import fmt
func f1() {var day intfmt.Scan(day)switch day {case 1, 2, 3, 4, 5: //只要匹配到一个值就可以fmt.Println(work day)case 6, 7:fmt.Println(relax)default:fmt.Println(输入出错)}
}func main() {f1()
}
在Go语言中不需要使用break
package mainimport fmtfunc f1() {score : 60//当switch后面什么都不写的时候默认为trueswitch {case score 60:fmt.Println(及格)case score 70 score 100:fmt.Println(优秀)default:fmt.Println(不及格)}
}func main() {f1()
}fallthrough(穿漏)package mainimport fmtfunc f1() {score : 100switch score {case 100:fmt.Println(100)fallthrough //加上fallthrough的时候会继续向下执行case 200:fmt.Println(200)case 300:fmt.Println(300)}
}
func main() {f1()
}Go语言中switch语句的注意事项支持多条件匹配不同的case之间不使用break分割默认只会执行一个case如果想要执行多个case需要使用fallthrough关键字也可以用break终止分支还可以使用表达式例如a10Go语言中的for循环//格式还是和其他的语言是一样的只不过不需要加上括号
package mainimport fmtfunc f1() {// i : 1// for i 10 {// fmt.Printf(i: %v\n, i)// i// }for i : 1; i 10; i {fmt.Printf(i: %v\n, i)}
}
func main() {f1()
}for range循环Go语言中可以使用for range遍历数组、切片、字符串、map以及通道。通过for range遍历的返回值具有以下的规律:数组、切片、字符串返回索引和值map返回键和值通道只返回通道内的值package mainimport fmtfunc f() {var a [...]int{1, 2, 3, 4, 5, 6} //当[]内什么都不写的时候就是切片// for i, v : range a {// fmt.Printf(i: %v\tv: %v\n, i, v)// }//还可以直接输入forr快捷键for _, v : range a {fmt.Printf(v: %v\n, v)}
}
func main() {f()
}
package mainimport fmtfunc f() {m : make(map[string]string, 0)m[name] Y4y17m[age] 23m[email] Y4y17email.comfor key, value : range m {fmt.Printf(key: %v\tvaule: %v\n, key, value)}
}
func main() {f()
}Go语言中的跳转语句breakbreak除了在switch 和 for循环中去使用还可以在标签中使用package mainimport fmtfunc f() {
MYLABEL:for i : 0; i 10; i {fmt.Printf(i: %v\n, i)if i 5 {break MYLABEL}}fmt.Println(END)
}func main() {f()
}continuepackage mainimport (fmt
)func f1() {for i : 0; i 10; i {MYLABLE:for j : 0; j 10; j {if i 2 j 2 { //跳过i2 j2的情况continue MYLABLE}fmt.Printf(%v:%v\n, i, j)}}
}
func f() {for i : 0; i 10; i {if i 2 {continue} else {fmt.Printf(i: %v\n, i)}}
}func main() {// f()f1()
}gotogoto语句常用于跳出多层循环package mainimport (fmt
)func f2() {for i : 0; i 10; i {for j : 0; j 10; j {if i 2 j 2 { //当i2 j2的时候直接跳出两个循环跳到END继续运行goto END}fmt.Printf(%v:%v\n, i, j)}}
END:fmt.Printf(end...)
}
func main() {f2()
}Go语言中的数组定义和初始化package mainimport fmtfunc test1() {//数组的定义var a1 [2]intvar a2 [3]stringvar a3 [2]boolfmt.Printf(a1: %T\n, a1)fmt.Printf(a2: %T\n, a2)fmt.Printf(a3: %T\n, a3)//数组的初始化var a4 [2]int{3, 4}var a5 [2]string{Y4y17, hello}var a6 [2]bool{true, false}fmt.Printf(a4: %v\n, a4)fmt.Printf(a5: %v\n, a5)fmt.Printf(a6: %v\n, a6)var a7 [...]int{7, 8, 9}fmt.Printf(len(a7): %v\n, len(a7))//根据索引进行赋值var a8 []int{0: 1, 5: 9}var a9 []string{1: Y4y17, 8: hello}fmt.Printf(a8: %v\n, a8)fmt.Printf(a9: %v\n, a9)
}
func main() {test1()
}数组的遍历package mainimport fmtfunc test1() {var a [5]int{1, 2, 3, 4, 6}for i : 0; i len(a); i {fmt.Printf(a[%v]: %v\n, i, a[i])}
}
func test2() {var str [4]string{Y4y17, hello, world, 7777}for i, v : range str { //其中i代表的是索引值v代表的就是str[i]//如果不想使用i索引值那么我们可以将i修改为下划线(_)fmt.Printf(str[%v]: %v\n, i, v)}
}
func main() {test1()fmt.Printf(-----------\n)test2()
}输出结果如下Go语言中的切片切片的声明package mainimport fmtfunc test1() {//切片的声明var list1 []intfmt.Printf(list1: %v\n, list1)var list2 make([]int, 2)fmt.Printf(list2: %v\n, list2)//切片的初始化var list3 []int{1, 2, 3}fmt.Printf(list3[1]: %v\n, list3[1])//输出list2的长度和容量fmt.Printf(len(list2): %v\n, len(list2))fmt.Printf(cap(list2): %v\n, cap(list2))
}
func main() {test1()
}切片的初始化针对切片的切分遵循左闭右开 即 [ )package mainimport fmtfunc test1() {//第一种初始化var list1 []int{1, 2, 3, 4}fmt.Printf(list1: %v\n, list1)//第二种初始化//利用数组进行初始化var a [...]int{1, 2, 3, 4, 5, 6}list2 : a[2:5]fmt.Printf(list2: %v\n, list2)list3 : a[2:]fmt.Printf(list3: %v\n, list3)list4 : a[:]fmt.Printf(list4: %v\n, list4)list5 : a[:5]fmt.Printf(list5: %v\n, list5)
}
func main() {test1()
}切片的遍历同样切片的遍历和数组的遍历类似存在两种遍历的方式package main
import fmt
func test1() {var list1 []int{1, 2, 3, 4, 5, 6}for i : 0; i len(list1); i {fmt.Printf(list1[%v]: %v\n, i, list1[i])}
}
func test2() {var list1 []int{1, 2, 3, 4, 5, 6}for i, v : range list1 {fmt.Printf(i:%v v: %v\n, i, v)}
}
func main() {// test1()test2()
}切片的增删改查package mainimport fmt//add
func add() {var list []int{1, 3, 2, 5, 99}list append(list, 100)fmt.Printf(list: %v\n, list)
}//delete
func delete() {var list []int{1, 2, 3, 4, 5, 6, 7}list append(list[:3], list[4:]...) //删除索引为3的元素fmt.Printf(list: %v\n, list)
}//update
func update() {var list []int{1, 2, 3, 4, 5, 6, 7}list[4] 777fmt.Printf(list: %v\n, list)
}//query
func query() {var list []int{1, 2, 3, 4, 5, 6, 7}key : 5for _, v : range list {if key v {fmt.Printf(v: %v\n, v)}}
}//copy函数的用法
func test() {var list []int{1, 2, 3, 4}var list2 make([]int, 4)copy(list2, list)// fmt.Printf(list: %v\n, list)fmt.Printf(list2: %v\n, list2)}
func main() {//add()// delete()// update()//query()test()
}Go语言中的mapmap是一种无序的键值对的集合最重要的一点是通过key来快速检索数据key类似于索引指向数据的值两种定义map的方式一种是通过内建函数make另一种是通过map关键字来定义Mappackage mainimport fmt
func test2() {map1 : map[string]string{name: Y4y17, age: 23, email: xxx.com}for _, v : range map1 {fmt.Printf(v: %v\n, v)}
}
func test1() {//map的声明var map1 map[string]string//创建集合map1 make(map[string]string)//map 插入key-value对map1[name] Y4y17map1[age] 23map1[email] xxx.com//使用键来输出map值for site : range map1 {fmt.Println(site, ----, map1[site])}v, ok : map1[name]fmt.Printf(v: %v\n, v)fmt.Printf(ok: %v\n, ok)v, ok map1[ages]fmt.Printf(v: %v\n, v)fmt.Printf(ok: %v\n, ok)
}
func main() {test1()
}
