导语|这是一篇go根本语法疾速入门文章,学习该文章时,默认读者已装置胜利Golang环境,若环境未装置胜利,可自行百度。
原文地址:https://mp.weixin.qq.com/s/zvVzP0juPb4xk-GSuTNlOA
目录
- 环境装置
- 输入语句
- Go语言关键字
-
类型
- 数据类型
-
变量定义
- var关键字定义
- 简短模式
- 多变量赋值
- 常量
- iota关键字
- 运算符
- 函数
-
条件语句和循环语句
- 条件语句
- 循环语句
-
数据
- 数组
- 字符串
-
切片
- 初始化slice
- 示例
- map字典
- 构造体struct
-
接口
- 语法
- 示例
- 总结
环境装置
装置地址:[https://www.cnblogs.com/aaron…
](https://www.cnblogs.com/aaron…
输入语句
无论学那一门语言,首先先学该语言的输入语句。俗话说得好,输入”Hello, World!”,代表你入门胜利!!!
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
接下来,一起学习go的根本语法,十分钟解决完战斗,走起!!!
Go语言关键字
首先先认识一下Go语言中关键字,心里有个印象,让初学者有个眼生就行。记不住没关系,我会在上面语法重复提到。在这里之所以提出来,就是让你们看一下,看的看的就记住了。
类型
数据类型
在 Go 编程语言中,数据类型用于申明函数和变量。
数据类型的呈现是为了把数据分成所需内存大小不同的数据,编程的时候须要用大数据的时候才须要申请大内存,就能够充分利用内存。
Go 语言按类别有以下几种数据类型:
变量定义
在数学概念中,变量示意没有固定值且可扭转的数。但从计算机系统实现角度来看,变量是一段或多段用来存储数据的内存。
作为动态类型语言,go变量总是有固定的数据类型,类型决定了变量内存的长度和存储格局。咱们只能批改变量值,无奈扭转类型。
var关键字定义
关键字var用于定义变量,和C不同,类型被放在变量前面。若显式提供初始值,可省略变量类型,由编译器推断。
var X int // 主动初始化为零
var y = false // 主动推断为bool的类型
可一次性定义多个变量,类型可雷同也可不雷同。
var x,y int
var a,b = 100, "abc"
简短模式
变量定义时,除var关键字外,还可应用更加简短的变量定义和初始化语法。
package main
import "fmt"
func main() {
x := 10 // 应用 := 进行定义并初始化
fmt.Println(x) // 输入语句 10
}
应用简短模式的一些限度:
- 定义变量,同时显式初始化。
- 不能提供数据类型。
- 只能用在函数外部,不能用在全局变量中。
多变量赋值
进行多变量赋值操作时,首先计算出等号左边值,而后再顺次实现赋值操作。
package main
import "fmt"
func main(){
x, y := 10, 20
x, y = y+3, x+2 // 先计算等号左边值,而后再对x、y变量赋值
fmt.Println(x, y) // 输入语句 后果为:23 12
}
常量
常量示意运行时恒定不可扭转的值,通常是一些字面量。应用常量就可用一个易于浏览了解的标识符号来代替”魔法数字”,也使得在调整常量值时,毋庸批改所有援用代码。
常量值必须是编译期可确定的字符、字符串、数字或布尔值。可指定常量类型,或由编译器通过初始化推断。
在go语言中,应用关键字const来定义常量。
const x, y int = 10, 20
const a,b = "迈莫coding", "欢送小伙伴"
示例:
package main
import "fmt"
const (
a, b string = "迈莫coding", "欢送小伙伴"
)
func main() {
fmt.Println(a,b) // 迈莫coding 欢送小伙伴
}
iota关键字
Go中没有明确意思上的enum(枚举)定义,不过能够借用iota标识符实现一组自增常量值来实现枚举类型。
const (
a = iota // 0
b // 1
c // 2
)
变量a、b、c的值别离为0、1、2,起因是因为应用iota进行自增时,后续自增值依照序递增。艰深点是每新增一行,iota值加一。
若在中途中断iota自增,则必须显示复原,如下所示:
const (
a = iota // 0
b // 1
c = 100 // 100
d // 100 (与上一行常量值表达式统一)
e = iota // 4 (复原iota自增,计数包含c、d)
f // 5
)
运算符
运算符应用形式和其余语言根本一样,在这里就不一一介绍了。
package main
import "fmt"
func main() {
var a int = 21
var b int = 10
var c int
c = a + b
fmt.Println(c) // 31
c = a - b
fmt.Println(c) // 11
c = a / b
fmt.Println(c) // 2
c = a % b
fmt.Println(c) // 1
a++
fmt.Println(a) // 22
a=21 // 为了不便测试,a 这里从新赋值为 21
a--
fmt.Println(a) // 20
}
函数
函数就是将简单的算法过程合成为若干较小工作,进行拆分,易于保护。函数被设计成绝对独立,通过接管输出参数实现一段算法指令,输入或存储相干后果。因而,函数还是代码复用和测试的根本单元。
关键字func用于定义函数。
package main
import "fmt"
// 定义 Write函数 返回值有两个,一个为name,一个age为
func Write() (name string, age int) {
return "迈莫coding", 1
}
// 定义 Read函数
func Read(name string, age int) {
fmt.Println(name, " 曾经 ", age, " 岁了")
}
func main() {
Read(Write()) // 迈莫coding 曾经 1 岁了
}
条件语句和循环语句
条件语句
条件语句须要开发者通过指定一个或多个条件,并通过测试条件是否为 true 来决定是否执行指定语句,并在条件为 false 的状况在执行另外的语句。
下图展现了程序语言中条件语句的构造:
package main
import "fmt"
func main() {
x := 3
if x > 5 {
fmt.Println("a")
} else if x < 5 && x > 0 {
fmt.Println("b")
} else {
fmt.Println("c")
}
}
循环语句
在不少理论问题中有许多具备规律性的反复操作,因而在程序中就须要反复执行某些语句。
以下为大多编程语言循环程序的流程图:
package main
import "fmt"
func main() {
for i := 0; i < 5; i++ {
if i == 4 {
continue
} else if i == 5 {
break
}
fmt.Println(i)
}
}
数据
数组
Go 语言提供了数组类型的数据结构。
数组是具备雷同惟一类型的一组已编号且长度固定的数据项序列,这种类型能够是任意的原始类型例如整型、字符串或者自定义类型。
package main
import "fmt"
func main() {
var arr1 [4]int // 元素主动初始化为零
fmt.Println(arr1) // [0 0 0 0]
arr2 := [4]int{1,2} // 其余未初始化的元素为零
fmt.Println(arr2) // [1 2 0 0]
arr3 := [4]int{5, 3:10} // 可指定索引地位初始化
fmt.Println(arr3) // [5 0 0 10]
arr4 := [...]int{1,2,3} // 编译器依照初始化值数量确定数组长度
fmt.Println(arr4) // [1 2 3]
t := len(arr4) // 内置函数len(数组名称)示意数组的长度
fmt.Println(t) // 3
}
字符串
字符串默认值不是nil,而是””。
package main
import "fmt"
func main() {
var str string
str = "迈莫coding欢送小伙伴"
fmt.Println(str)
}
切片
切片(slice)自身不是动静数组或动静指针。只是它外部采纳数组存储数据,当数组长度达到数组容量时,会进行动静扩容。
大白话就是切片性能和Java中的List汇合相似,动静增加数据。不像数组(array)长度是固定的,须要当时晓得数据长度。
初始化slice
x := make([]int, 1) // 通过make关键字进行slice初始化
示例
package main
import "fmt"
func main() {
// 形式一
a := make([]int,5) // 初始化长度为5的slice,默认值为零
for i := 0; i <5; i++ {
a = append(a, i)
}
a = append(a, 6)
fmt.Println(a) // [0 0 0 0 0 0 1 2 3 4 6]
// 形式二
var a []int
for i := 0; i < 5; i++ {
a = append(a, i)
}
fmt.Println(a) // [0 1 2 3 4]
}
map字典
map字典也是应用频率比拟高的数据结构。将其作为语言内置类型,从运行时层面进行优化,可取得更高效类型。
作为无序键值对汇合,字典key值必须是反对相等运算符的数据类型,比方数字、字符串、指针、数组、构造体,以及对应接口类型。
map字典性能和Java中的map汇合性能相似。
字典是利用类型,应用make函数或初始化表白语句来创立。
package main
import "fmt"
func main() {
// 定义 变量strMap
var strMap map[int]string
// 进行初始化
strMap = make(map[int]string)
// 给map 赋值
for i := 0; i < 5; i++ {
strMap[i] = "迈莫coding"
}
// 打印出map值
for k, v := range strMap{
fmt.Println(k, ":", v)
}
// 打印出map 长度
fmt.Println(len(strMap))
}
构造体struct
构造体(struct)将多个不同类型命名字段(field)序列打包成一个复合类型。
字段名必须惟一,可用”_”补位,反对应用本身指针类型成员。字段属性为根本数据类型。
学过Java就能够进行类比,构造体struct能够类比为Java中的类,构造体struct中字段属性能够类比为Java中类成员变量,构造体struct的办法能够类比为Java中类成员办法。
构造体(struct)语法如下:
type user struct {
name string // 字段name 其数据类型为string
age int // 字段age 其数据类型为int
}
示例:
package main
import "fmt"
type user struct {
name string
age int
}
// 构造体user Read办法
func (u *user) Read() string {
return fmt.Sprintf("%s 曾经 %d 岁了", u.name, u.age)
}
func main() {
// 初始化
u := &user{
name: "迈莫coding",
age: 1,
}
fmt.Println(u.name, "曾经", u.age, "岁了")
// 调用构造体user的 Read办法
fmt.Println(u.Read()) // 迈莫coding 曾经 1 岁了
}
接口
接口代表一个调用契约,是多个办法申明的汇合。
接口解除了类型依赖,有助于缩小用户可视办法,屏蔽内部结构和实现细节。在Go语言中,只有指标类型办法集内蕴含接口申明的全副办法,就被视为实现了该接口,毋庸做显示申明。当然,指标类型可实现多个接口。
大白话,接口是多个办法申明的汇合,若一个struct类实现接口中所有办法,即示意该类实现了指定接口。
语法
type user interface{
}
示例
package main
import "fmt"
// 定义接口 蕴含公共办法
type user interface{
talking()
}
// 定义一个struct类
type memo struct{
}
// 实现接口user中办法talking
func (m *memo) talking() {
fmt.Println("迈莫coding欢迎您...")
}
func main() {
mm := memo{}
mm.talking()
}
总结
文章介绍了Go语言的根本语法,适宜零小白查看,使其疾速上手Go语言我的项目开发,但文章毕竟是疾速入门,有许多没讲过的知识点,需读者自行学习,也可关注我,和我一起学习Go语言。
文章也会继续更新,能够微信搜寻「 迈莫coding 」第一工夫浏览。每天分享优质文章、大厂教训、大厂面经,助力面试,是每个程序员值得关注的平台。