Go的基础语法学好后,对后面项目的进行有极大的帮助!
如果还没安装好环境的童鞋,可以先参照博主的这篇文章进行搭建
Go 语言的基础组成有以下几个部分:
打印 Hello World 程序实例
package main //包声明
import ( //引入包
"fmt"
)
/*
* 多行注释
*/
func main() { //main函数,主程序入口
fmt.Println("Hello World") //语句&表达式
}
注意点
需要注意的是 { 不能单独放在一行,所以以下代码在运行时会产生错误:(Go在代码风格上强制约束受到许多开发者的厌恶,但那又怎样,Go还是强的一匹)
package main
import "fmt"
func main()
{ // 错误,{ 不能在单独的行上
fmt.Println("Hello, World!")
}
行分隔符
在 Go 程序中,一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾,因为这些工作都将由 Go 编译器自动完成。
如果你打算将多个语句写在同一行,它们则必须使用 ; 人为区分,但在实际开发中我们并不鼓励这种做法。
以下为两个语句:
fmt.Println("Hello, World!") //不需要加分号
fmt.Println("菜鸟教程:runoob.com")
标识符
标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(AZ和az)数字(0~9)、下划线_组成的序列,但是第一个字符必须是字母或下划线而不能是数字。
以下是有效的标识符:
mahesh kumar abc move_name a_123
myname50 _temp j a23b9 retVal
以下是无效的标识符:
1ab(以数字开头)
case(Go 语言的关键字)
a+b(运算符是不允许的)
字符串连接
Go 语言的字符串可以通过 + 实现:
package main
import "fmt"
func main() {
fmt.Println("Google" + "Runoob") //打印结果为 GoogleRunoob
}
Go语言的保留关键字
break | default | func | interface | select |
---|---|---|---|---|
case | defer | go | map | struct |
chan | else | goto | package | switch |
const | fallthrough | if | range | type |
continue | for | import | return | var |
Go 语言的空格
Go 语言中变量的声明必须使用空格隔开,如:
var age int;
语句中适当使用空格能让程序更易阅读。
无空格:
son=father+monther
在变量与运算符间加入空格,程序看起来更加美观,如:
son = father + monther
数据类型的出现是为了把数据分成所需内存大小不同的数据,编程的时候需要用大数据的时候才需要申请大内存,就可以充分利用内存。
布尔型
布尔型的值只可以是常量 true 或者 false。
一个简单的例子: var b bool = true。
数字类型
整型 int 和浮点型 float32、float64,Go 语言支持整型和浮点型数字,并且支持复数,其中位的运算采用补码。
字符串类型:
字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
派生类型:
Go 语言变量名由字母、数字、下划线组成,其中首个字符不能为数字。
声明变量的一般形式是使用 var 关键字:
var identifier type
可以一次声明多个变量:
var identifier1, identifier2 type
实例
package main
import "fmt"
func main() {
var a string = "CSDN"
fmt.Println(a)
var b, c int = 1, 2
fmt.Println(b, c)
}
变量声明
第一种,指定变量类型,如果没有初始化,则变量默认为零值。
var v_name v_type
v_name = value
零值就是变量没有做初始化时系统默认设置的值。
package main
import "fmt"
func main() {
// 声明一个变量并初始化
var a = "RUNOOB"
fmt.Println(a)
// 没有初始化就为零值
var b int
fmt.Println(b)
// bool 零值为 false
var c bool
fmt.Println(c)
}
字符串的零值为 “”(空字符串)
以下几种类型的零值为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 是接口
第二种,根据值自行判定变量类型。
var v_name = value
package main
import "fmt"
func main() {
var d = true // var b bool = true 简写为 var b = true
fmt.Println(d)
}
第三种,省略 var, 注意 := 左侧如果没有声明新的变量,就产生编译错误,格式:
v_name := value
例如:
var intVal int
intVal :=1 // 这时候会产生编译错误
intVal,intVal1 := 1,2 // 此时不会产生编译错误,因为有声明新的变量,因为 := 是一个声明语句
可以将 var f string = “Runoob” 简写为 f := “Runoob”:
package main
import "fmt"
func main() {
f := "Runoob" // var f string = "Runoob"
fmt.Println(f)
}
多变量声明
//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3
var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型,自动推断
vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的,否则会导致编译错误
// 这种因式分解关键字的写法一般用于声明全局变量
var (
vname1 v_type1
vname2 v_type2
)
实例
package main
var x, y int
var ( // 这种因式分解关键字的写法一般用于声明全局变量
a int
b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"
//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"
func main(){
g, h := 123, "hello"
println(x, y, a, b, c, d, e, f, g, h)
}
Go 语言常量
常量是一个简单值的标识符,在程序运行时,不会被修改的量。
常量中的数据类型只可以是布尔型、数字型(整数型、浮点型和复数)和字符串型。
常量的定义格式:
const identifier [type] = value
你可以省略类型说明符 [type],因为编译器可以根据变量的值来推断其类型。
多个相同类型的声明可以简写为:
const c_name1, c_name2 = value1, value2
实例
package main
import "fmt"
func main() {
const LENGTH int = 10
const WIDTH int = 5
var area int
const a, b, c = 1, false, "str" //多重赋值
area = LENGTH * WIDTH
fmt.Printf("面积为 : %d", area)
println()
println(a, b, c)
}
if 语句
Go 编程语言中 if 语句的语法如下:
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
}
实例
package main
import "fmt"
func main() {
var a int = 6
if a <= 6 {
fmt.Print(a)
} else {
fmt.Println(a + 1)
}
}
Switch语句
switch 语句用于基于不同条件执行不同动作,每一个 case 分支都是唯一的,从上至下逐一测试,直到匹配为止。
switch 语句执行的过程从上至下,直到找到匹配项,匹配项后面也不需要再加 break。
switch 默认情况下 case 最后自带 break 语句,匹配成功后就不会执行其他 case,如果我们需要执行后面的 case,可以使用 fallthrough 。
Switch实例
package main
import "fmt"
func main() {
var a int = 6
switch a {
case 6:
fmt.Print(a)
case 7:
fmt.Println(a + 1)
default:
fmt.Println("default")
}
}
for key, value := range oldMap {
newMap[key] = value
}
实例
package main
import "fmt"
func main() {
var sum int = 0
for i := 1; i <= 10; i++ {
sum += i
}
fmt.Print(sum)
}
For-each range 循环
这种格式的循环可以对字符串、数组、切片等进行迭代输出元素。
package main
import "fmt"
func main() {
strings := []string{"google", "runoob"}
//i 代表遍历时候的数组下标,s代表数组每一项的值
for i, s := range strings {
fmt.Println(i, s)
}
//i 代表遍历时候的数组下标,number代表数组每一项的值
numbers := []int{1, 2, 3, 4}
for i, number := range numbers {
fmt.Println(i, number)
}
}
函数是基本的代码块,用于执行一个任务。
Go 语言最少有个 main() 函数。
你可以通过函数来划分不同功能,逻辑上每个函数执行的是指定的任务。
函数声明告诉了编译器函数的名称,返回类型,和参数。
Go 语言标准库提供了多种可动用的内置的函数。例如,len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度,如果传入的是数组,则返回数组中包含的元素个数。
函数定义
func function_name( [parameter list] ) [return_types] {
函数体
}
函数定义解析:
实例
以下实例为 max() 函数的代码,该函数传入两个整型参数 num1 和 num2,并返回这两个参数的最大值:
package main
import "fmt"
func max(num1, num2 int) int {
var result int
if num1 > num2 {
result = num1
} else {
result = num2
}
return result
}
func main() {
fmt.Print(max(1, 2))
}
函数返回多个值
比如交换函数
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("A", "B")
fmt.Println(a, b)
}
Go默认采用的函数传值是值传递方式
Go的引用传递实例
package main
import "fmt"
func swap(x *int, y *int) {
var tmp int
tmp = *x
*x = *y
*y = tmp
}
func main() {
var a, b int = 1, 2
//因为要引用传递,所以用 & 符号将变量的地址值传递过去
swap(&a, &b)
fmt.Println(a, b)
}
Go 语言提供了数组类型的数据结构。
数组是具有相同唯一类型的一组已编号且长度固定的数据项序列,这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。
相对于去声明 number0, number1, …, number99 的变量,使用数组形式 numbers[0], numbers[1] …, numbers[99] 更加方便且易于扩展。
数组元素可以通过索引(位置)来读取(或者修改),索引从 0 开始,第一个元素索引为 0,第二个索引为 1,以此类推。
声明数组
Go 语言数组声明需要指定元素类型及元素个数,语法格式如下:
var variable_name [SIZE] variable_type
定义数组实例
package main
import "fmt"
func main() {
var nums [10]int
var sum int = 0
for i := 0; i <= 9; i++ {
nums[i] = i
}
for i := 1; i <= 9; i++ {
sum += nums[i]
}
fmt.Println("数组的和为 = ", sum)
}
我们也可以通过字面量在声明数组的同时快速初始化数组:
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
如果数组长度不确定,可以使用 … 代替数组的长度,编译器会根据元素个数自行推断数组的长度:
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
如果设置了数组的长度,我们还可以通过指定下标来初始化元素:
// 将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}
初始化数组中 {} 中的元素个数不能大于 [] 中的数字。
如果忽略 [] 中的数字不设置数组大小,Go 语言会根据元素的个数来设置数组的大小:
数组程序实例
package main
import "fmt"
func main() {
var i, j, k int
// 声明数组的同时快速初始化数组
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
/* 输出数组元素 */
for i = 0; i < 5; i++ {
fmt.Printf("balance[%d] = %f\n", i, balance[i])
}
balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
/* 输出每个数组元素的值 */
for j = 0; j < 5; j++ {
fmt.Printf("balance2[%d] = %f\n", j, balance2[j])
}
// 将索引为 1 和 3 的元素初始化
balance3 := [5]float32{1: 2.0, 3: 7.0}
for k = 0; k < 5; k++ {
fmt.Printf("balance3[%d] = %f\n", k, balance3[k])
}
}
从一些基础的语法上看,与C语言和Python语言会更接近一些,学习要保证持续性,加油!
看到这的童鞋给博主点个赞呗!
坚持分享,坚持原创,喜欢博主的靓仔靓女们可以看看博主的首页博客!
您的点赞与收藏是我分享博客的最大赞赏!
博主博客地址: https://blog.csdn.net/weixin_43967679