go 基础
变量的定义
注意：
变量必须先定义后使用
go 语言是静态语言，要求变量的类型和赋值类型一致
局部变量名字不能冲突；局部变量可以和全局变量重名优先级局部变量高
简洁变量定义必须是在函数内
定义变量后未赋值都有默认值（零值）
局部变量定义后一定要使用否则报错
package main
import "fmt"
//全局变量
var t = "s"
var (
s = 8
o = false
)
func main() {
//go定义
var a int = 1
a1 := "string"
var a2 string
a2 = "s"
fmt.Println(a)
fmt.Println(a1)
fmt.Println(a2)
var w1,w2,w3 ="r",5,"t"
fmt.Println(w1,w2,w3)
/*
注意：
变量必须先定义后使用
go 语言是静态语言，要求变量的类型和赋值类型一致
局部变量名字不能冲突；局部变量可以和全局变量重名优先级局部变量高
简洁变量定义必须是在函数内
定义变量后未赋值都有默认值（零值）
局部变量定义后一定要使用否则报错
*/
}
执行结果
PS D:\golang\goproject\src\lnhgo> go run d:\golang\goproject\src\lnhgo\day01\main.go
1
string
s
r 5 t
常量定义
常量类型可以定义为bool、数值、和字符串
不曾使用的常量没有强制使用的要求
显示指定类型的时候，必须保证常量左右值类型一致
如果常量没有定义值，那会沿用它场面常量的值
package main
import (
"fmt"
)
func main(){
//常量：定义的时候指定值，不能修改，常量全部大写
const PI float32 = 3.1415926//显示定义
// 定义一组
const (
UNKNOWN = 1
FMMALE=2
MALE= 3
)
const(
X int = 6
C //如果常量没有定义值，那会沿用它场面常量的值
S = "sa"
D
)
fmt.Println(X,C,S,D)
/*
常量类型可以定义为bool、数值、和字符串
不曾使用的常量没有强制使用的要求
显示指定类型的时候，必须保证常量左右值类型一致
如果常量没有定义值，那会沿用它场面常量的值
*/
}
执行结果
PS D:\golang\goproject\src\lnhgo> go run d:\golang\goproject\src\lnhgo\day01\demo02\main.go
6 6 sa sa
iota 的介绍
package main
import(
"fmt"
)
func main() {
/* iota，特色常量可以被编译器修改的常量
| 常量名 | iota值 | 表达式 | 结果 |
| ----- | ----- | ------ | ---- |
| ERR1 | 0 | iota+1 | 1 |
| ERR2 | 1 | iota+1 | 2 |
| ERR25 | 2 | "ha" | "ha" |
| ERR4 | 3 | "ha" | "ha" |
| ERR42 | 4 | "ha" | "ha" |
| ERR5 | 5 | iota | 5 |
显示恢复后续自增；自增类型默认int类型
iota能简化const类型的变量
每次出现const 的时候iota 就归0
*/
const (
ERR1 = iota+1//iota=0 -> 1
ERR2 //iota=0 -> 1
ERR25 = "ha"//iota=2
ERR4 //复制上一行表达式
ERR42//复制上一行表达式
ERR45=100//iota5
ERR5 = iota//显示恢复后续自增
)
const (
ERRNEW1=iota //从0开始
)
fmt.Println(ERR1,ERR2,ERR25,ERR4,ERR5)
fmt.Println(ERRNEW1)
}
执行结果
1 2 ha ha 6
0
匿名变量
package main
import "fmt"
func a() (int, bool) {
return 0, true
}
func main() {
//
var _ int
_, r := a()//匿名变量使用场景；占位符_
if r {
fmt.Println("a")
}
}
变量的作用域
1. 局部变量（Local Variable）定义在函数内部，只能在函数内使用。下面变量只能在 main() 里使用。
package main
import "fmt"
func main() {
age := 18
fmt.Println(age)
}
结果
18
2. 全局变量（Global Variable）定义在函数外面。整个包(package)内都可以访问。
var age = 18
func main() {
fmt.Println(age)
}
func test() {
fmt.Println(age)
}
3.块作用域（Block Scope）由 {} 形成。
func main() {
x := 10
if true {
y := 20
fmt.Println(x)
fmt.Println(y)
}
fmt.Println(x)
// fmt.Println(y) // 报错
}
Go 最容易踩坑的地方：变量遮蔽（Shadowing）
func main() {
x := 10
{
x := 20
fmt.Println(x)
}
fmt.Println(x)
}
执行结果
20
10
go基本数据类型
go 基本数据类型
bool(布尔)：布尔型的值只有true和false。例子：var b bool = true
数值型：
(1)整数：
int8:有符号8位整型（-128~127）长度8bit
int16:有符号16位整型（-32768~32767）
int32：有符号32位整型（-2147483648~2147483647）
int64：有符号64位整型（-9223372036854775808~-9223372036854775807）
uint8: 无符号8位整型（0~255）
uint16：无符号16位整型（0~65535）
uint32: 无符号32位整型（0~4294967295）
uint64: 无符号64位整型(0~18446744073709551615)
(2)浮点数：
float32： 32位浮点型
float64： 64位浮点型
(3)复数：
(4)byte字节：等于uint8
(5)rune型：等于uint32
(6)字符和string
package main
import(
"fmt"
)
func main(){
var c byte//只要存英文字符
c = 'a'+1 //也是字符可以汉字
fmt.Printf("c=%c\n",c)
var c2 rune
c2 = '熙'
fmt.Printf("c2=%c\n",c2)
var name string
name = "亚马逊"
fmt.Println(name)
}
执行结果
PS D:\golang\goproject\src\lnhgo> go run d:\golang\goproject\src\lnhgo\day01\demo06\main.go
c=b
c2=熙
亚马逊
数据类型转换
package main
import (
"fmt"
"strconv"
//"main"
)
func main(){
//浮点数
a:=5.5
//转换为int
b:=int(a)//5
//Go允许在底层结构相同的两个数据类型之间互转，例如：
//IT类型的底层是int类型
type IT int
var a3 IT = 5
//将a(IT)转换为int，b现在是int类型
c := int(a)
var a1 int32 = 1
var a2 int64 = 1
b1 := int64(a1)
fmt.Println(a,a1,a2,a3,b,b1,c)
//字符串转数字
var istr="12"
t,_:=strconv.Atoi(istr)//有可能错误
fmt.Println(t)
var my= 32
d:=strconv.Itoa(my)
fmt.Println(d)
//字符串转flaot32类型。字符串转bool类型
f1,_:=strconv.ParseFloat("3.14567",32)//参数里填写64或32返回的值都是float64，参数作用是按照64或32为格式转换；返回两个值
fmt.Println(f1)
//字符串转数字方式2
i1,_:=strconv.ParseInt("-45",10,64)//参数字符串:指定转换的进制（这里指定为10进制）；转为多少位
fmt.Println(i1)
i2,_:=strconv.ParseInt("54",8,16)
fmt.Println(i2)
//字符串转布尔;ParseBool 函数返回字符串所表示的布尔值。它接受的值包括 1、t、T、TRUE、true、True、0、f、F、FALSE、false 和 False。任何其他值都会返回错误。
b2,err := strconv.ParseBool("t")
if err !=nil{
fmt.Println("转换失败")
return
}
fmt.Println(b2)
//基本数据类型转字符串
b3:=strconv.FormatBool(true)
fmt.Println(b3)
f2:=strconv.FormatFloat(3.1415926,'E',-1,64)
fmt.Println(f2)
i3:=strconv.FormatInt(-42,16)//16表示16进制
fmt.Println(i3)
}
执行结果
5.5 1 1 5 5 1 5
12
32
3.145669937133789
-45
44
true
true
3.1415926E+00
-2a
运算符表达式
package main
import (
"fmt"
//"runtime/trace"
)
func main(){
var a,b = 2,3
var astr,bstr = "hello","bobby"
fmt.Println(a+b)
fmt.Println(astr+bstr)
fmt.Println(3%2)
var abool,bbool = true,false
if abool&&bbool{
fmt.Println("a")
}
if abool||bbool{
fmt.Println("b")
}
if !abool{
fmt.Println("s")
}
//位运算符，性能要求高考虑
var A = 60
var B = 13
fmt.Println(A&B)
}
执行结果
5
hellobobby
1
b
12
转义符
转义符 \n:换行，将当前位置移到下一行开头 010 \r:回车，将当前位置移到本行开头 013 \t:水平制表符 009 \\:代码一个反斜线 092 \':代表一个单引号字符 039 \":代表一个双引号 034 \?:代表一个问号 043
格式化输出
转义符
\n:换行，将当前位置移到下一行开头 010
\r:回车，将当前位置移到本行开头 013
\t:水平制表符 009
\\:代码一个反斜线 092
\':代表一个单引号字符 039
\":代表一个双引号 034
\?:代表一个问号 043
缺省格式和类型
格式化后的效果 动词 描述
[0 1] %v 缺型格式
[]int{0,1} %#v go语法打印
[]int64 %T 类型打印
整型缩进(缩进，进制类型，正负符号)
格式化后的效果 动词 描述
15 %d 十进制
+15 %+d 必须显示正负符号
_15 %4d pad空格（宽度为4，右对齐）
15_ %-4d pad空格（宽度为4，左对齐）
1111 %b 二进制
17 %o 八进制
f %x 16进制，小写
字符(有引号，Unicode)
value：65(Unicode)
格式化后的效果 动词 描述
A %c 字符
'A' %q 有引号字符
U+0041 %U Unicode
U+0041'A' %#U Unicode引号
浮点(缩进，精度，科学计数)
格式化后的效果 动词 描述
1.234560e+02 %e 科学计数
123.456000 %f 十进制小数
字符串or字节slice(引号，缩进，十六进制)
格式化后的效果 动词 描述
cafe %s 字符串原样输出
_cafe %6s 宽度为6，右对齐
字符串格式化输出性能最高的方式：strings.Builder
package main
import (
"fmt"
"strconv"
"strings"
)
func main(){
name := "imooc体系"
bytes := []rune(name)
fmt.Println(len(bytes))
//格式化输出
username:="bobby"
age := 18
address :="北京"
mobile := "1857656899"
fmt.Printf("用户名:%s,年龄:%d,地址:%s,电话:%s\n",username,age,address,mobile)//极难维护
usrMsg:=fmt.Sprintf("用户名:%s,年龄:%d,地址:%s,电话:%s",username,age,address,mobile)//
fmt.Println(usrMsg)
//通过string的builder进行字符串拼接，高性能
var builder strings.Builder
builder.WriteString("用户名:")
builder.WriteString(username)
builder.WriteString(",年龄:")
builder.WriteString(strconv.Itoa(age))
builder.WriteString(",地址:")
builder.WriteString(address)
builder.WriteString(",电话:")
builder.WriteString(mobile)
fmt.Println(builder.String())
}
执行结果
7
用户名:bobby,年龄:18,地址:北京,电话:1857656899
用户名:bobby,年龄:18,地址:北京,电话:1857656899
用户名:bobby,年龄:18,地址:北京,电话:1857656899
字符串比较
package main
import (
"fmt"
)
func main(){
//字符串比较
a:="hello"
b:="bello"
fmt.Println(a==b)
fmt.Println(a!=b)
//字符串大小比较
fmt.Println(a>b)
}
执行结果
PS D:\golang\goproject\src\lnhgo> go run day01\demo10\main.go
false
true
true
字符串常用方法
package main
import (
"fmt"
"strings"
"unicode/utf8"
)
func main(){
name:="imooc体系课-go工程师go"
//是否包含
fmt.Println(strings.Contains(name,"go"))
//字符串长度
//len() 统计的是：字节数（byte）而不是字符数。汉字使用UTF-8编码，UTF-8 占 3 个字节
fmt.Println(len(name))
//统计字符个数（包含汉字）使用 utf8.RuneCountInString
fmt.Println(utf8.RuneCountInString(name))
//查询子串出现的次数
fmt.Println(strings.Count(name,"o"))
//分隔
fmt.Println(strings.Split(name,"-"))
//字符串是否指定的前缀开头
fmt.Println(strings.HasPrefix(name,"im"))
//字符串是否以指定的内容结尾
fmt.Println(strings.HasSuffix(name,"师"))
//查询子串出现的位置
fmt.Println(strings.Index(name,"go"))
//查询子串出现的位置
fmt.Println(strings.IndexRune(name,[]rune(name)[8]))
//子串替换-1表示全部替换整数表示替换几个
fmt.Println(strings.Replace(name,"go","python",-1))
//转换成小写
fmt.Println(strings.ToLower("GO"))
//转换成大写
fmt.Println(strings.ToUpper(name))
//去掉字符串左右两边特舒字符
fmt.Println(strings.Trim("*$hello *go*","*$"))
}
执行结果
true
28
16
4
[imooc体系课 go工程师go]
true
false
15
14
imooc体系课-python工程师python
go
IMOOC体系课-GO工程师GO
hello *go
if 条件判断
package main
import (
"fmt"
)
func main(){
//if判断
age:=22
if age<18{
fmt.Println("未成年")
}else{
fmt.Println("成年")
}
if age<18{
fmt.Println("未成年")
}else if age>60{
fmt.Println("老年人")
}else{
fmt.Println("青年")
}
}
执行结果
成年
青年
for 循环与for 死循环
package main
import (
"fmt"
//"path"
"time"
)
func main(){
for i:=0;i<3;i++{
fmt.Println(i)
}
var i int
for {//死循环
time.Sleep(2*time.Second)
fmt.Println(i)
i++
}
}
用循环求1~100的和
package main
import(
"fmt"
)
func main(){
var sun int
for i:=1;i<=100;i++{
sun+=i
//fmt.Println(i,sun)
}
fmt.Println(sun)
}
执行结果
5050
九九乘法表
package main
import(
"fmt"
)
func main(){
for i:=1;i<10;i++{
for x:=1;x<=i;x++{
fmt.Printf("%d * %d = %d\t",x,i,x*i)
}
fmt.Println()
}
}
执行结果
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
forrange 循环
package main
import(
"fmt"
)
func main(){
//字符串遍历
name :="imooc go python 课程"
for v,k:=range name{
fmt.Printf("%d=%c\t",v,k)
}
}
执行结果
PS D:\golang\goproject\src\lnhgo> go run day01\demo13\main.go
0=i 1=m 2=o 3=o 4=c 5= 6=g 7=o 8= 9=p 10=y 11=t 12=h 13=o 14=n 15= 16=课 19=程
continue：跳出此次循环开启下次循环；break：结束循环
package main
import(
"fmt"
)
func main(){
r:=10
for {
r--
if r == 5{
continue// 接收本次循环；继续下次循环
}else if r==0{
fmt.Println(r)
break //退出循环
}
fmt.Println(r)
}
}
执行
9
8
7
6
4
3
2
1
0
goto 语句
package main
import(
"fmt"
)
func main(){
r:=10
for {
r--
if r == 5{
goto t1//直接跳转到t1标签语句哪里
}else if r==0{
fmt.Println(r)
break //退出循环
}
fmt.Println(r)
}
t1://标签
fmt.Println("goto 标签")
}
执行结果
PS D:\golang\goproject\src\lnhgo> go run day01\demo13\main.go
9
8
7
6
goto 标签
switch 语法
package main
import(
"fmt"
)
func main(){
var n int
fmt.Printf("输入选择")
fmt.Scanln(&n)
switch n{
case 1:
fmt.Println("大拇指")
case 2:
fmt.Println("食指")
case 3:
fmt.Println("中指")
case 4:
fmt.Println("无名指")
case 5:
fmt.Println("小拇指")
default:
fmt.Println("输入不正确")
}
}
执行结果
PS D:\golang\goproject\src\lnhgo> go run day01\demo13\main.go
输入选择3
中指
PS D:\golang\goproject\src\lnhgo> go run day01\demo13\main.go
输入选择4
无名指
PS D:\golang\goproject\src\lnhgo> go run day01\demo13\main.go
输入选择6
输入不正确
示例2
package main
import(
"fmt"
)
func main(){
var t int
fmt.Printf("输入分数：")
fmt.Scanln(&t)
switch {
case t==100:
fmt.Println("卓越")
case t>90:
fmt.Println("优秀")
case t>80:
fmt.Println("好")
case t>70:
fmt.Println("良")
case t>60 && t==60:
fmt.Println("及格")
default:
fmt.Println("不及格，继续努力")
}
}
执行结果
PS D:\golang\goproject\src\lnhgo> go run day01\demo13\main.go
输入分数：60
不及格，继续努力
PS D:\golang\goproject\src\lnhgo> go run day01\demo13\main.go
输入分数：78
良
PS D:\golang\goproject\src\lnhgo> go run day01\demo13\main.go
输入分数：95
优秀
PS D:\golang\goproject\src\lnhgo> go run day01\demo13\main.go
输入分数：100
卓越
草都可以从石头缝隙中长出来更可况你呢
浙公网安备 33010602011771号