golang基础教程哪家好_golang实战

golang基础教程哪家好_golang实战以下使用goland的IDE演示,包含总计的golang基础功能共20个章节 一、go语言结构: 二、go基础语法: 三、变量: 四、常量: 五、运算符: 六、条件语句: 七、循环: 八、函数: 九、变量作用域: 十、数组: 十一、指针: 十二、结构体: 十三、切片: 十四、范围(Range): 十

以下使用goland的IDE演示,包含总计的golang基础功能共20个章节
 

一、go语言结构:
1.运行Hello World!
package main
 
import "fmt"
 
func main() {
fmt.Println("Hello World!")
}

查看运行结果:
golang基础教程哪家好_golang实战
 
2.语言结构:
1. 第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包,如:package main。package main表示一个可独立执行的程序,每个 Go 应用程序都包含一个名为 main 的包。
2. 下一行 import “fmt” 告诉 Go 编译器这个程序需要使用 fmt 包(的函数,或其他元素),fmt 包实现了格式化 IO(输入/输出)的函数。
3. 下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的,一般来说都是在启动后第一个执行的函数(如果有 init() 函数则会先执行该函数)。
4. 下一行 /*…*/ 是注释,在程序执行时将被忽略。单行注释是最常见的注释形式,你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释,均已以 /* 开头,并以 */ 结尾,且不可以嵌套使用,多行注释一般用于包的文档描述或注释成块的代码片段。
5.下一行 fmt.Println(…) 可以将字符串输出到控制台,并在最后自动增加换行字符 \n。
使用 fmt.Print(“hello, world\n”) 可以得到相同的结果。
Print 和 Println 这两个函数也支持使用变量,如:fmt.Println(arr)。如果没有特别指定,它们会以默认的打印格式将变量 arr 输出到控制台。
6. 当标识符(包括常量、变量、类型、函数名、结构字段等等)以一个大写字母开头,如:Group1,那么使用这种形式的标识符的对象就可以被外部包的代码所使用(客户端程序需要先导入这个包),这被称为导出(像面向对象语言中的 public);标识符如果以小写字母开头,则对包外是不可见的,但是他们在整个包的内部是可见并且可用的(像面向对象语言中的 protected )。
 

二、go基础语法:
1.行分隔符:
Println函数会在行末尾自动加上换行符
package main
 
import "fmt"
 
func main() {
fmt.Println("Hello World!")
fmt.Println("Println函数会在行末尾自动加上换行符")
}

查看运行结果:
golang基础教程哪家好_golang实战
 
2.注释:
单行注释以//开头,多行注释以 /* 开头,并以 */ 结尾
// 单行注释
/*
我说多行注释1
我说多行注释2
我说多行注释3
*/
 
3.标识符:
标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A~Z和a~z)数字(0~9)、下划线_组成的序列,但是第一个字符必须是字母或下划线而不能是数字。
以下是有效的标识符:
mahesh   kumar   abc   move_name   a_123
myname50   _temp   j   a23b9   retVal
以下是无效的标识符:
* 1ab(以数字开头)
* case(Go 语言的关键字)
* a+b(运算符是不允许的)
 
4.字符串连接:
Go 语言的字符串连接可以通过 + 实现:
import "fmt"
 
func main() {
fmt.Println("golang"+"python")
}

查看运行结果:
golang基础教程哪家好_golang实战
 
5.关键字:
下面列举了 Go 代码中会使用到的 25 个关键字或保留字:
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
 
6.格式化字符串:
// 常用的使用%d 表示整型数字,%s 表示字符串

package main
 
import "fmt"
 
func main() {
//fmt.Println("Hello World!")
//fmt.Println("Println函数会在行末尾自动加上换行符")
//fmt.Println("golang" + "python")
var today = "星期六"
var number = 6
fmt.Printf("今天是%s,今天在本周的排号为%d", today, number)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
三、变量
1、申明一个变量值,变量类型,并初始化
(1)两种方式,方式1:使用var声明
package main
 
func main() {
var str string = "hello"
var num int = 123
println(str, num)
}

查看运行结果:
golang基础教程哪家好_golang实战
(2)使用:=声明
package main
 
func main() {
//var str string = "hello"
//var num int = 123
//println(str, num)
mystr := "very good"
mynum := 345
println(mystr, mynum)
 
}

查看运行结果:
golang基础教程哪家好_golang实战
 
2、申请变量未初始化,则会给默认值
数值类型初始值0
布尔类型为fasle
字符串为””
其他类型为nil
func main() {
//var str string = "hello"
//var num int = 123
//println(str, num)
 
//初始值0
var num1 int
fmt.Println("num1初始值为:", num1)
//初始值""
var str1 string
fmt.Println("str1初始值为:", str1)
//布尔类型为 false
var flag bool
fmt.Println("flag初始值为:", flag)
//其他类型为nil
var a *int
var b []int
var c map[string]int
var d chan int
var e func(string) int
var f error
fmt.Println("a,b,c,d,e,f的初始值分别为:", a, b, c, d, e, f)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
3、根据值自行判定变量类型
package main
 
import (
"fmt"
"reflect"
)
 
func main() {
 
var str2 = "hello"
var num2 = 25
var flag2 = true
fmt.Println("str2的类型为:", reflect.TypeOf(str2))
fmt.Println("num2的类型为:", reflect.TypeOf(num2))
fmt.Println("flag2的类型为:", reflect.TypeOf(flag2))
}

查看运行结果:
golang基础教程哪家好_golang实战
 
4、多变量声明:
使用逗号隔开
package main
 
import "fmt"
 
func main() {
 
 
var str3, str4, str5 string = "hello", "World", "ok"
num3, num4, num5 := 2, 3, 4
fmt.Println(str3, str4, str5)
fmt.Println(num3, num4, num5)
 
}

查看运行结果:
golang基础教程哪家好_golang实战
 
5、引用类型变量
&可查看引用变量的地址
package main
 
import "fmt"
 
func main() {
 
var a1 = 10
var b1 = "ok"
fmt.Println("a1=", a1)
fmt.Println("b1=", b1)
fmt.Println("a1=", &a1)
fmt.Println("b1=", &b1)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
四、常量
1.常量定义:
常量是一个简单值的标识符,在程序运行时,不会被修改的量,使用const修饰一个常量
package main
 
func main() {
const a string = "abc" //显示类型定义
const b = "abc" //隐示类型定义
const c, d = "o", "k"
println(a, b, c, d)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
2. 常量还可以用作枚举:
并且常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中,函数必须是内置函数,否则编译不过
package main
 
import "unsafe"
 
func main() {
//const a string = "abc" //显示类型定义
//const b = "abc" //隐示类型定义
//const c, d = "o", "k"
//println(a, b, c, d)
const (
Unknown = 0
Female = 1
Male = 2
)
 
const (
a = "abc"
b = len(a)
c = unsafe.Sizeof(a) //16个字节,返回string结构体的字符与长度各8个字符相加
)
println(Unknown, Female, Male, a, b, c)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
3.特殊常量iota
iota,特殊常量,可以认为是一个可以被编译器修改的常量。
iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前),const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。
package main
 
func main() {
 
const (
a = iota
b
c
)
println(a, b, c)
}

查看运行结果:
golang基础教程哪家好_golang实战
package main
 
import "fmt"
 
func main() {
 
//println(a, b, c)
const (
a = iota //0
b //1
c //2
d = "ha" //独立值,iota += 1
e //"ha" iota += 1
f = 100 //iota +=1
g //100 iota +=1
h = iota //7,恢复计数
i //8
)
fmt.Println(a, b, c, d, e, f, g, h, i)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
五、运算符
1.算数运算符:
package main
 
import "fmt"
 
func main() {
a := 1
b := 2
fmt.Println("a加b等于:", a+b)
fmt.Println("a减b等于:", a-b)
fmt.Println("a剩b等于:", a*b)
fmt.Println("a除b等于:", a/b)
fmt.Println("a除b后取余数等于:", a%b)
a++
fmt.Println("a++后的结果:", a)
b--
fmt.Println("b--后的结果:", b)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
2.关系运算符
关系运算符主要有 =,!=,>,<,>=,<=共6种运算符
package main
 
import "fmt"
 
func main() {
 
var m int = 21
var n int = 10
if m == n {
fmt.Println("第一行返回:a等于b")
} else {
fmt.Println("第一行返回:a不等于b")
}
if m < n {
fmt.Println("第二行返回:a小于b")
} else {
fmt.Println("第二行返回:a不小于b")
}
if m > n {
fmt.Println("第三行返回:a大于b")
} else {
fmt.Println("第三行返回:a不大于b")
}
m, n = n, m //交换m,n的值
if m <= n {
fmt.Println("第四行返回:a小于等于b")
}
if m >= n {
fmt.Println("第四行返回:a不小于b")
}
}

查看运行结果:
golang基础教程哪家好_golang实战
 
3.逻辑运算符
主要有三种逻辑运算符:
&&:逻辑 AND 运算符。 如果两边的操作数都是 True,则条件 True,否则为 False。
||:逻辑 OR 运算符。 如果两边的操作数有一个 True,则条件 True,否则为 False。
!:逻辑 NOT 运算符。 如果条件为 True,则逻辑 NOT 条件 False,否则为 True。
package main
 
import "fmt"
 
func main() {
 
var a bool = true
var b bool = false
if a && b {
fmt.Printf("第一行 - 条件为 true\n")
} else if a || b {
fmt.Printf("第一行 - 条件为 true\n")
}
a, b = b, a //修改a,b的值,对调
if a && b {
fmt.Printf("第二行 - 条件为 true\n")
} else {
fmt.Printf("第二行 - 条件为 false\n")
}
if !(a && b) {
fmt.Printf("第三行 - 条件为 true\n")
} else {
fmt.Printf("第三行 - 条件为 false\n")
}
 
}

查看运行结果:
golang基础教程哪家好_golang实战
 
4.位运算符
位运算符对整数在内存中的二进制位进行操作。
 &, |,  ^ ,<<,>>四种位运算方式
package main
 
import "fmt"
 
func main() {
 
var a uint = 60 /* 60 = 0011 1100 */
var b uint = 13 /* 13 = 0000 1101 */
var c uint = 0
 
c = a & b /* 12 = 0000 1100 */
fmt.Printf("第一行 - c 的值为 %d\n", c)
 
c = a | b /* 61 = 0011 1101 */
fmt.Printf("第二行 - c 的值为 %d\n", c)
 
c = a ^ b /* 49 = 0011 0001 */
fmt.Printf("第三行 - c 的值为 %d\n", c)
 
c = a << 2 /* 240 = 1111 0000 */
fmt.Printf("第四行 - c 的值为 %d\n", c)
 
c = a >> 2 /* 15 = 0000 1111 */
fmt.Printf("第五行 - c 的值为 %d\n", c)
 
}

查看运行结果:
golang基础教程哪家好_golang实战
 
5.赋值运算符
赋值符号为=,将一个表达式的值赋给一个左值,结合之前其他的型号的赋值运算符如下:
package main
 
import "fmt"
 
func main() {
 
var a int = 21
var c int
 
c = a
fmt.Printf("第 1 行 - = 运算符实例,c 值为 = %d\n", c)
 
c += a
fmt.Printf("第 2 行 - += 运算符实例,c 值为 = %d\n", c)
 
c -= a
fmt.Printf("第 3 行 - -= 运算符实例,c 值为 = %d\n", c)
 
c *= a
fmt.Printf("第 4 行 - *= 运算符实例,c 值为 = %d\n", c)
 
c /= a
fmt.Printf("第 5 行 - /= 运算符实例,c 值为 = %d\n", c)
 
c = 200
 
c <<= 2
fmt.Printf("第 6行 - <<= 运算符实例,c 值为 = %d\n", c)
 
c >>= 2
fmt.Printf("第 7 行 - >>= 运算符实例,c 值为 = %d\n", c)
 
c &= 2
fmt.Printf("第 8 行 - &= 运算符实例,c 值为 = %d\n", c)
 
c ^= 2
fmt.Printf("第 9 行 - ^= 运算符实例,c 值为 = %d\n", c)
 
c |= 2
fmt.Printf("第 10 行 - |= 运算符实例,c 值为 = %d\n", c)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
六、条件语句
1.if else语句:
package main
 
import "fmt"
 
func main() {
//if else语句
age := 18
if age < 5 {
fmt.Println("你的age为:", age, ",你太小了无法进入")
} else if age < 18 {
fmt.Println("你的age为:", age, ",你虽然不小了,但是仍然未满18,无法进入")
} else {
fmt.Println("你的age为:", age, ",你已满18岁,可以进入")
}
}

查看运行结果:
golang基础教程哪家好_golang实战
 
2.if嵌套语句
计算可以数字a在0-100内,且是否可以被5整除
package main
 
import "fmt"
 
func main() {
 
a := 100
//if嵌套
if a <= 100 {
fmt.Println("a的值符合条件1:在0~100内,为:", a)
if a%5 == 0 {
fmt.Println("a的值符合条件2:可以被5整除,为:", a)
} else {
fmt.Println("a的值不符合条件2:不可以被5整除,为:", a)
 
}
} else {
fmt.Println("a的值不符合条件1:非在0~100内,为:", a)
 
}
}

查看运行结果:
golang基础教程哪家好_golang实战
 
3.switch语句
(1)switch+case语句:
switch 语句用于基于不同条件执行不同动作,每一个 case 分支都是唯一的,从上至下逐一测试,直到匹配为止。
witch 默认情况下 case 最后自带 break 语句,匹配成功后就不会执行其他 case
package main
 
import "fmt"
 
func main() {
 
//3.switch case语句
score := 75
var grade string
switch {
case score < 60:
grade = "C"
case score >= 60 && score < 80:
grade = "B"
case score >= 80:
grade = "A"
}
fmt.Println(grade)
 
}

查看运行结果:
golang基础教程哪家好_golang实战
(2)switch+case+fallthrough
使用 fallthrough 会强制执行后面的 case 语句,fallthrough 不会判断下一条 case 的表达式结果是否为 true。
package main
 
import "fmt"
 
func main() {
 
score := 95
var grade string
switch {
case score < 60:
grade = "C"
fallthrough
case false:
fmt.Println("使用fallthrough语句跳入到了下一步打印此句,因为您的成绩为:", grade)
case score >= 60 && score < 80:
grade = "B"
fallthrough
case false:
fmt.Println("使用fallthrough语句跳入到了下一步打印此句,因为您的成绩为:", grade)
case score >= 80:
grade = "A"
fallthrough
case false:
fmt.Println("使用fallthrough语句跳入到了下一步打印此句,因为您的成绩为:", grade)
}
fmt.Println(grade)
}

查看运行结果:
golang基础教程哪家好_golang实战
(3)switch+default:
defalut如果放在哪里是会最后执行
package main
 
import "fmt"
 
func main() {
 
score := 200
var grade string
switch {
default:
grade = "Nothing"
fmt.Printf("你的成绩为%d,并不合法,最终grade为%s", score, grade)
case score < 60:
grade = "C"
fallthrough
case false:
fmt.Println("使用fallthrough语句跳入到了下一步打印此句,因为您的成绩为:", grade)
case score >= 60 && score < 80:
grade = "B"
fallthrough
case false:
fmt.Println("使用fallthrough语句跳入到了下一步打印此句,因为您的成绩为:", grade)
case score >= 80 && score <= 100:
grade = "A"
fallthrough
case false:
fmt.Println("使用fallthrough语句跳入到了下一步打印此句,因为您的成绩为:", grade)
}
 
}

查看运行结果:
golang基础教程哪家好_golang实战
 
4.select语句
select 是 Go 中的一个控制结构,类似于用于通信的 switch 语句。每个 case 必须是一个通信操作,要么是发送要么是接收。
select 随机执行一个可运行的 case。如果没有 case 可运行,它将阻塞,直到有 case 可运行。一个默认的子句应该总是可运行的。
package main
 
import "fmt"
 
func main() {
 
var c1, c2, c3 chan int
var i1, i2 int
select {
case i1 = <-c1:
fmt.Printf("received ", i1, " from c1\n")
case c2 <- i2:
fmt.Printf("sent ", i2, " to c2\n")
case i3, ok := (<-c3): // same as: i3, ok := <-c3
if ok {
fmt.Printf("received ", i3, " from c3\n")
} else {
fmt.Printf("c3 is closed\n")
}
default:
fmt.Printf("no communication\n")
}
 
}

查看运行结果:
golang基础教程哪家好_golang实战
 
七、循环
1.for循环
(1)for condition {}
package main
 
import "fmt"
 
func main() {
//1.for condition语句
sum := 0
for i := 1; i <= 10; i++ {
sum += i
}
fmt.Println(sum) //累加1~10
}

查看运行结果:
golang基础教程哪家好_golang实战
(2)for init {}
package main
 
import "fmt"
 
func main() {
 
Strings := []string{"google", "golang"}
for m, n := range Strings {
fmt.Println(m, n)
}
}

查看运行结果:
golang基础教程哪家好_golang实战
 
2.循环嵌套
package main
 
import "fmt"
 
func main() {
 
 
//2.循环嵌套:找到1-30内的素数
var i, j int
for i = 2; i < 30; i++ {
for j = 2; j <= i/j; j++ {
if i%j == 0 {
break
}
}
if j > (i / j) {
fmt.Println(i, "是一个素数")
}
}
}

查看运行结果:
golang基础教程哪家好_golang实战
 
3.break语句
Go 语言中 break 语句用于以下两方面:
(1) 用于循环语句中跳出循环,并开始执行循环之后的语句
//3.1 break跳出循环
var a int = 10
for a < 20 {
fmt.Println("a的值:", a)
a++
if a == 15 {
break
}
}
}

查看运行结果:
golang基础教程哪家好_golang实战
(2) break 在 switch(开关语句)中在执行一条 case 后跳出语句的作用。(此break会隐藏)
(3)在多重循环中,可以用标号 label 标出想 break 的循环。
package main
 
import "fmt"
 
func main() {
 
//3.2 break label标出想break的循环
// 不使用标记
fmt.Println("---- break ----")
for i := 1; i <= 3; i++ {
fmt.Printf("i: %d\n", i)
for i2 := 11; i2 <= 13; i2++ {
fmt.Printf("i2: %d\n", i2)
break
}
}
 
// 使用标记
fmt.Println("---- break label ----")
re:
for i := 1; i <= 3; i++ {
fmt.Printf("i: %d\n", i)
for i2 := 11; i2 <= 13; i2++ {
fmt.Printf("i2: %d\n", i2)
break re
}
}
 
}

查看运行结果:
golang基础教程哪家好_golang实战
 
4.continue 语句
Go 语言的 continue 语句 有点像 break 语句。但是 continue 不是跳出循环,而是跳过当前循环执行下一次循环语句。
(1)for 循环中,执行 continue 语句会触发 for 增量语句的执行。
package main
 
import "fmt"
 
func main() {
 
//4.1 continue语句,不是跳出循环,而是跳过当前循环执行下一次循环语句
a := 10
for a < 20 {
a++
if a == 15 {
continue
}
fmt.Println("a的值为:", a)
}
 
}

查看运行结果:
golang基础教程哪家好_golang实战
(2)在多重循环中,可以用标号 label 标出想 continue 的循环。
package main
 
import "fmt"
 
func main() {
 
//4.2 使用continue+label标出想 continue 的循环
// 不使用标记
fmt.Println("---- continue ---- ")
for i := 1; i <= 3; i++ {
fmt.Printf("i: %d\n", i)
for i2 := 11; i2 <= 13; i2++ {
fmt.Printf("i2: %d\n", i2)
continue
}
}
 
// 使用标记
fmt.Println("---- continue label ----")
re:
for i := 1; i <= 3; i++ {
fmt.Printf("i: %d\n", i)
for i2 := 11; i2 <= 13; i2++ {
fmt.Printf("i2: %d\n", i2)
continue re
}
}
 
}

查看运行结果:
golang基础教程哪家好_golang实战
 
5.goto 语句
Go 语言的 goto 语句可以无条件地转移到过程中指定的行。
goto 语句通常与条件语句配合使用。可用来实现条件转移, 构成循环,跳出循环体等功能。
package main
 
import "fmt"
 
func main() {
 
//5.goto语句可以无条件地转移到过程中指定的行
/* 定义局部变量 */
var a int = 10
 
/* 循环 */
LOOP:
for a < 20 {
if a == 15 {
/* 跳过迭代 */
a = a + 1
goto LOOP
}
fmt.Printf("a的值为 : %d\n", a)
a++
}
}

查看运行结果:
golang基础教程哪家好_golang实战
 
八、函数
1.函数定义与调用
Go 语言最少有个 main() 函数。
你可以通过函数来划分不同功能,逻辑上每个函数执行的是指定的任务。
函数定义解析:
* func:函数由 func 开始声明
* function_name:函数名称,参数列表和返回值类型构成了函数签名。
* parameter list:参数列表,参数就像一个占位符,当函数被调用时,你可以将值传递给参数,这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的,也就是说函数也可以不包含参数。
* return_types:返回类型,函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值,这种情况下 return_types 不是必须的。
* 函数体:函数定义的代码集合。
package main
 
import "fmt"
 
func main() {
var a int = 98
var b int = 99
var c int = max(a, b)
fmt.Println("a,b两个数的最大值为:", c)
}
 
func max(num1, num2 int) int {
/* 声明局部变量 */
var result int
 
if num1 > num2 {
result = num1
} else {
result = num2
}
return result
}

查看运行结果:
golang基础教程哪家好_golang实战
 
2.函数返回多个值
package main
 
import "fmt"
 
func main() {
 
x := "hello"
y := "world"
fmt.Println("交换前的x与y分别为:", x, y)
x, y = swap(x, y)
fmt.Println("交换后的x与y分别为:", x, y)
}
 
func swap(x, y string) (string, string) {
x, y = y, x
return x, y
}

查看运行结果:
golang基础教程哪家好_golang实战
 
3.值传递与引用传递
(1)值传递:
值传递是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。
package main
 
import (
"fmt"
)
 
func main() {
 
x := "hello"
y := "world"
fmt.Println("交换前的x与y分别为:", x, y)
swap(x, y)
fmt.Println("交换后的x与y分别为:", x, y)
}
 
//值传递
func swap(x, y string) string {
var temp string
temp = x
x = y
y = temp
return temp
}

查看运行结果:
golang基础教程哪家好_golang实战
(2)引用传递:
引用传递是指在调用函数时将实际参数的地址传递到函数中,那么在函数中对参数所进行的修改,将影响到实际参数。
package main
 
import (
"fmt"
)
 
func main() {
//var a int = 98
//var b int = 99
//var c int = max(a, b)
//fmt.Println("a,b两个数的最大值为:", c)
 
x := "hello"
y := "world"
fmt.Println("交换前的x与y分别为:", x, y)
swap(&x, &y)
fmt.Println("交换后的x与y分别为:", x, y)
}
 
//func max(num1, num2 int) int {
// /* 声明局部变量 */
// var result int
//
// if num1 > num2 {
// result = num1
// } else {
// result = num2
// }
// return result
//}
 
////值传递
//func swap(x, y string) string {
// var temp string
// temp = x
// x = y
// y = temp
// return temp
//}
 
//引用传递
func swap(x, y *string) string {
var temp string
temp = *x
*x = *y
*y = temp
return temp
}

查看运行结果:
golang基础教程哪家好_golang实战
4.函数作为另外一个函数的实参(进阶ToDo)
5.闭包(进阶ToDo)
6.方法(进阶ToDo)
 
九、变量作用域
1.局部变量:
* 函数内定义的变量称为局部变量,它们的作用域只在函数体内,参数和返回值变量也是局部变量。
package main
 
import "fmt"
 
func main() {
/* 声明局部变量 */
var a, b, c int
 
/* 初始化参数 */
a = 10
b = 20
c = a + b
 
fmt.Printf("结果: a = %d, b = %d and c = %d\n", a, b, c)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
2.全局变量
* 函数外定义的变量称为全局变量,全局变量可以在整个包甚至外部包(被导出后)使用
package main
 
import "fmt"
 
/* 声明全局变量 */
var g int
 
func main() {
 
/* 声明局部变量 */
var a, b int
 
/* 初始化参数 */
a = 10
b = 20
g = a + b
 
fmt.Printf("结果: a = %d, b = %d and g = %d\n", a, b, g)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
3.形式参数
形式参数会作为函数的局部变量来使用。实例如下:
package main
 
import "fmt"
 
///* 声明全局变量 */
//var g int
 
/* 声明全局变量 */
var a int = 20
 
func main() {
 
/* main 函数中声明局部变量 */
var a int = 10
var b int = 20
var c int = 0
 
fmt.Printf("main()函数中 a = %d\n", a)
c = sum(a, b)
fmt.Printf("main()函数中 c = %d\n", c)
}
 
/* 函数定义-两数相加 */
func sum(a, b int) int {
fmt.Printf("sum() 函数中 a = %d\n", a)
fmt.Printf("sum() 函数中 b = %d\n", b)
 
return a + b
}

查看运行结果:
golang基础教程哪家好_golang实战
 
4.初始化局部和全局变量
不同类型的局部和全局变量的默认值为:
int为0
float32为0
pointer为nil
 
十、数组
1.声明数组
例如以下定义了数组 balance 长度为 10 类型为 float32:
var balance [10] float32

 
2.初始化数组
package main
 
import "fmt"
 
func main() {
//1.初始化数组
balance1 := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
fmt.Println(balance1)
//如果数组长度不确定,可以使用 ... 代替数组的长度,编译器会根据元素个数自行推断数组的长度:
balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
fmt.Println(balance2)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
3.访问数组元素
package main
 
import "fmt"
 
func main() {
 
//3.访问列表元素,通过for循环方式遍历
var n [10]int /* n 是一个长度为 10 的数组 */
var i, j int
 
/* 为数组 n 初始化元素 */
for i = 0; i < 10; i++ {
n[i] = i + 100 /* 设置元素为 i + 100 */
}
 
/* 输出每个数组元素的值 */
for j = 0; j < 10; j++ {
fmt.Printf("Element[%d] = %d\n", j, n[j])
}
}

查看运行结果:
golang基础教程哪家好_golang实战
 
4.多维数组(进阶ToDo)
5.向函数传递数组(进阶ToDo)
 
十一、指针
1.指针的使用
一个指针变量指向了一个值的内存地址。
var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */
package main
 
import "fmt"
 
func main() {
var a int = 20 /* 声明实际变量 */
var ip *int /* 声明指针变量 */
 
ip = &a /* 指针变量的存储地址 */
 
fmt.Printf("a 变量的地址是: %x\n", &a)
 
/* 指针变量的存储地址 */
fmt.Printf("ip 变量储存的指针地址: %x\n", ip)
 
/* 使用指针访问值 */
fmt.Printf("*ip 变量的值: %d\n", *ip)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
2.空指针
当一个指针被定义后没有分配到任何变量时,它的值为 nil。
nil 指针也称为空指针。
nil在概念上和其它语言的null、None、nil、NULL一样,都指代零值或空值。
一个指针变量通常缩写为 ptr。
package main
 
import "fmt"
 
func main() {
 
//空指针
var ptr *int
fmt.Printf("ptr 的值为 : %x\n", ptr)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
3.指针数组(进阶ToDo)
4.指向指针的指针(进阶ToDo)
5.指针作为函数参数(进阶ToDo)
 
十二、结构体
1.定义结构体
Go 语言中数组可以存储同一类型的数据,但在结构体中我们可以为不同项定义不同的数据类型。
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。
结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型,结构体中有一个或多个成员。type 语句设定了结构体的名称。
package main
 
import "fmt"
 
//定义结构体
type Books struct {
title string
author string
subject string
bookId int
}
 
func main() {
// 创建一个新的结构体
fmt.Println(Books{"Go 语言", "mr.white", "Go语言教程", 100001})
 
// 也可以使用 key => value 格式
fmt.Println(Books{title: "Go 语言", author: "mr.white", subject: "Go语言教程", bookId: 100002})
 
// 忽略的字段为 0 或 空
fmt.Println(Books{title: "Go 语言", author: "mr.white"})
}

查看运行结果:
golang基础教程哪家好_golang实战
 
2.访问结构体成员
如果要访问结构体成员,需要使用点号 . 操作符。
package main
 
import "fmt"
 
//定义结构体
type Books struct {
title string
author string
subject string
bookId int
}
 
func main() {
 
/* book 1 描述 */
Book1.title = "Go 语言"
Book1.author = "mr.white"
Book1.subject = "Go 语言教程"
Book1.bookId = 100001
 
/* book 2 描述 */
Book2.title = "Python 教程"
Book2.author = "mr.white"
Book2.subject = "Python 语言教程"
Book2.bookId = 100002
 
/* 打印 Book1 信息 */
fmt.Printf("Book 1 title : %s\n", Book1.title)
fmt.Printf("Book 1 author : %s\n", Book1.author)
fmt.Printf("Book 1 subject : %s\n", Book1.subject)
fmt.Printf("Book 1 book_id : %d\n", Book1.bookId)
 
/* 打印 Book2 信息 */
fmt.Printf("Book 2 title : %s\n", Book2.title)
fmt.Printf("Book 2 author : %s\n", Book2.author)
fmt.Printf("Book 2 subject : %s\n", Book2.subject)
fmt.Printf("Book 2 book_id : %d\n", Book2.bookId)
}

查看运行结果:
golang基础教程哪家好_golang实战
3.结构体作为函数参数(进阶ToDo)
4.结构体指针(进阶ToDo)
 
十三、切片
1.定义/切片初始化
Go 数组的长度不可改变,在特定场景中这样的集合就不太适用,Go 中提供了一种灵活,功能强悍的内置类型切片(“动态数组”),与数组相比切片的长度是不固定的,可以追加元素,在追加时可能使切片的容量增大。
package main
 
import "fmt"
 
func main() {
//1.直接初始化切片,[] 表示是切片类型,{1,2,3} 初始化值依次是 1,2,3,其 cap=len=3。
s := []int{1, 2, 3}
fmt.Println("切片s:", s)
//初始化切片 s1,是数组 s 的引用。
s1 := s[:]
fmt.Println("切片s1:", s1)
//初始化切片 s2,是从下标 startIndex 到 endIndex-1 下的元素创建为一个新的切片。
s2 := s[1:3]
fmt.Println("切片s2:", s2)
//使用make初始化切片
s3 := make([]int, 3)
fmt.Println("切片s3:", s3)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
2.len() 和 cap() 函数
len() 方法获取切片的长度
cap()方法 可以测量切片最长可以达到多少
package main
 
import "fmt"
 
func printSlice(x []int) {
fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}
 
func main() {
 
//2调用printSlice方法获取切片的长度与容量
var numbers = make([]int, 3, 5)
printSlice(numbers)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
3.空(nil)切片
package main
 
import "fmt"
 
func printSlice(x []int) {
fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}
 
func main() {
 
//3.空切片
var numbers []int
printSlice(numbers)
if numbers == nil {
fmt.Println("切片是空的呢")
}
}

查看运行结果:
golang基础教程哪家好_golang实战
 
4.切片截取
可以通过设置下限及上限来设置截取切片 [lower-bound:upper-bound],实例如下:
package main
 
import "fmt"
 
func printSlice(x []int) {
fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}
 
func main() {
 
//切片截取举例
/* 创建切片 */
numbers := []int{0, 1, 2, 3, 4, 5, 6, 7, 8}
printSlice(numbers)
 
/* 打印原始切片 */
fmt.Println("numbers ==", numbers)
 
/* 打印子切片从索引1(包含) 到索引4(不包含)*/
fmt.Println("numbers[1:4] ==", numbers[1:4])
 
/* 默认下限为 0*/
fmt.Println("numbers[:3] ==", numbers[:3])
 
/* 默认上限为 len(s)*/
fmt.Println("numbers[4:] ==", numbers[4:])
 
numbers1 := make([]int, 0, 5)
printSlice(numbers1)
 
/* 打印子切片从索引 0(包含) 到索引 2(不包含) */
number2 := numbers[:2]
printSlice(number2)
 
/* 打印子切片从索引 2(包含) 到索引 5(不包含) */
number3 := numbers[2:5]
printSlice(number3)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
5.append() 和 copy() 函数
如果想增加切片的容量,我们必须创建一个新的更大的切片并把原分片的内容都拷贝过来。
下面的代码描述了从拷贝切片的 copy 方法和向切片追加新元素的 append 方法。
package main
 
import "fmt"
 
func printSlice(x []int) {
fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}
 
func main() {
 
//5.append() 和 copy() 函数
var numbers []int
printSlice(numbers)
 
/* 允许追加空切片 */
numbers = append(numbers, 0)
printSlice(numbers)
 
/* 向切片添加一个元素 */
numbers = append(numbers, 1)
printSlice(numbers)
 
/* 同时添加多个元素 */
numbers = append(numbers, 2,3,4)
printSlice(numbers)
 
/* 创建切片 numbers1 是之前切片的两倍容量*/
numbers1 := make([]int, len(numbers), (cap(numbers))*2)
 
/* 拷贝 numbers 的内容到 numbers1 */
copy(numbers1,numbers)
printSlice(numbers1)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
十四、范围(Range)
1.range的作用
range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值,在集合中返回 key-value 对。
for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环
 
2.举例说明
package main
 
import "fmt"
 
func main() {
map1 := make(map[int]float32)
map1[1] = 1.0
map1[2] = 2.0
map1[3] = 3.0
map1[4] = 4.0
 
// 读取 key 和 value
for key, value := range map1 {
fmt.Printf("key is: %d - value is: %f\n", key, value)
}
 
// 读取 key
for key := range map1 {
fmt.Printf("key is: %d\n", key)
}
 
// 读取 value
for _, value := range map1 {
fmt.Printf("value is: %f\n", value)
}
}

查看运行结果:
golang基础教程哪家好_golang实战
 
十五、集合
1.定义 Map
/* 声明变量,默认 map 是 nil */
var map_variable map[key_data_type]value_data_type
 
/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)
 
实例如下:
package main
 
import "fmt"
 
func main() {
var countryCapitalMap map[string]string /*创建集合 */
countryCapitalMap = make(map[string]string)
 
/* map插入key - value对,各个国家对应的首都 */
countryCapitalMap["France"] = "巴黎"
countryCapitalMap["Italy"] = "罗马"
countryCapitalMap["Japan"] = "东京"
countryCapitalMap["India "] = "新德里"
 
/*使用键输出地图值 */
for country := range countryCapitalMap {
fmt.Println(country, "首都是", countryCapitalMap[country])
}
 
/*查看元素在集合中是否存在 */
capital, ok := countryCapitalMap["American"] /*如果确定是真实的,则存在,否则不存在 */
/*fmt.Println(capital) */
/*fmt.Println(ok) */
if ok {
fmt.Println("American 的首都是", capital)
} else {
fmt.Println("American 的首都不存在")
}
}

查看运行结果:
golang基础教程哪家好_golang实战
 
2.delete() 函数
delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key。实例如下:
package main
 
import "fmt"
 
func main() {
//2.delete() 函数
/* 创建map */
countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"}
 
fmt.Println("原始地图")
 
/* 打印地图 */
for country := range countryCapitalMap {
fmt.Println(country, "首都是", countryCapitalMap[country])
}
 
/*删除元素*/
delete(countryCapitalMap, "France")
fmt.Println("法国条目被删除")
 
fmt.Println("删除元素后地图")
 
/*打印地图*/
for country := range countryCapitalMap {
fmt.Println(country, "首都是", countryCapitalMap[country])
}
}

查看运行结果:
golang基础教程哪家好_golang实战
 
十六、递归
Go 语言支持递归。但我们在使用递归时,开发者需要设置退出条件,否则递归将陷入无限循环中。
递归函数对于解决数学上的问题是非常有用的,就像计算阶乘,生成斐波那契数列等
1.阶乘
package main
 
import "fmt"
 
func Factorial(n uint64) (result uint64) {
if n > 0 {
result = n * Factorial(n-1)
return result
}
return 1
}
 
func main() {
//1.阶乘
var i int = 15
fmt.Printf("%d 的阶乘是 %d\n", i, Factorial(uint64(i)))
}

查看运行结果:
golang基础教程哪家好_golang实战
 
2.斐波那契数列
package main
 
import "fmt"
 
func fibonacci(n int) int {
if n < 2 {
return n
}
return fibonacci(n-2) + fibonacci(n-1)
}
 
func main() {
 
//2.斐波那契数列
var i int
for i = 0; i < 10; i++ {
fmt.Printf("%d\t", fibonacci(i))
}
}

查看运行结果:
golang基础教程哪家好_golang实战
 
十七、数据类型转换
1.转换规则
类型转换用于将一种数据类型的变量转换为另外一种类型的变量。Go 语言类型转换基本格式如下:
type_name(expression)
 
2.实例
package main
 
import "fmt"
 
func main() {
var sum int = 17
var count int = 5
var mean float32
 
mean = float32(sum)/float32(count)
fmt.Printf("mean 的值为: %f\n",mean)
}

查看运行结果:
golang基础教程哪家好_golang实战
 
十八、接口
1.接口含义
Go 语言提供了另外一种数据类型即接口,它把所有的具有共性的方法定义在一起,任何其他类型只要实现了这些方法就是实现了这个接口。
 
2.实例
package main
 
import "fmt"
 
type Phone interface {
/* 定义结构体 */
call()
}
 
type NokiaPhone struct {
/* 定义结构体 */
}
 
func (nokiaPhone NokiaPhone) call() {
/* 实现接口方法 */
fmt.Println("I am Nokia, I can call you!")
}
 
type IPhone struct {
/* 定义结构体 */
}
 
func (iPhone IPhone) call() {
/* 实现接口方法 */
fmt.Println("I am iPhone, I can call you!")
}
 
func main() {
var phone Phone
 
phone = new(NokiaPhone)
phone.call()
 
phone = new(IPhone)
phone.call()
}

查看运行结果:
golang基础教程哪家好_golang实战
 
十九、错误处理
1.error简介
Go 语言通过内置的错误接口提供了非常简单的错误处理机制。
type error interface {
Error() string}

我们可以在编码中通过实现 error 接口类型来生成错误信息。
函数通常在最后的返回值中返回错误信息。使用errors.New 可返回一个错误信息:
func Sqrt(f float64) (float64, error) {
if f < 0 {
return 0, errors.New("math: square root of negative number")
}
}

 
在下面的例子中,我们在调用Sqrt的时候传递的一个负数,然后就得到了non-nil的error对象,将此对象与nil比较,结果为true,所以fmt.Println(fmt包在处理error时会调用Error方法)被调用,以输出错误,请看下面调用的示例代码:
result, err:= Sqrt(-1)
 
if err != nil {
fmt.Println(err)
}

 
2.实例
package main
 
import "fmt"
 
// 定义一个 DivideError 结构
type DivideError struct {
dividee int
divider int
}
 
// 实现 `error` 接口
func (de *DivideError) Error() string {
strFormat := `
Cannot proceed, the divider is zero.
dividee: %d
divider: 0
`
return fmt.Sprintf(strFormat, de.dividee)
}
 
// 定义 `int` 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
if varDivider == 0 {
dData := DivideError{
dividee: varDividee,
divider: varDivider,
}
errorMsg = dData.Error()
return
} else {
return varDividee / varDivider, ""
}
 
}
 
func main() {
// 正常情况
if result, errorMsg := Divide(100, 10); errorMsg == "" {
fmt.Println("100/10 = ", result)
}
// 当除数为零的时候会返回错误信息
if _, errorMsg := Divide(100, 0); errorMsg != "" {
fmt.Println("errorMsg is: ", errorMsg)
}
}

查看运行结果:
golang基础教程哪家好_golang实战
 
二十、并发
1.并发介绍
Go 语言支持并发,我们只需要通过 go 关键字来开启 goroutine 即可。
goroutine 是轻量级线程,goroutine 的调度是由 Golang 运行时进行管理的。
语句:go f(x, y, z)
如:开启一个新的 goroutine:
f(x, y, z)
 
2.实例
package main
 
import (
"fmt"
"time"
)
 
func say(s string) {
for i := 0; i < 5; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}
 
func main() {
go say("world")
say("hello")
}

查看运行结果:
golang基础教程哪家好_golang实战
 
 

今天的文章golang基础教程哪家好_golang实战分享到此就结束了,感谢您的阅读,如果确实帮到您,您可以动动手指转发给其他人。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/47967.html

(0)
编程小号编程小号
上一篇 2023-09-04
下一篇 2023-09-04

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注