Day01 Go语言基础 变量 字符串 运算符
上午01 Go语言基础
Go介绍
Go语言： 有C语言的执行性能 和 Python的开发效率
Go语言的诞生
起源于2007年 多核时代
Rob Pike（罗伯.派克）： 和Ken Thompson以及 Dennis M. Ritche（C语言之父） 开发Unix，UTF-8的设计人。 Ken Thompson（肯.汤普森）： B语言的作者，与Dennis Ritchie是Unix的原创者。 Robert Griesemer（罗伯特.格利茨默）： 参与制作Java的HotSpot编译器以及Chrome浏览器的javascript的搜索引擎V8。
Go语言的版本
Go 1.0 — 2012 年 3 月：Go 的第一个版本，带着一份兼容性说明文档来保证与未来发布版本的兼容性，进而不会破坏已有的程序。 Go 1.1 — 2013 年 5 月：这个 Go 版本专注于优化语言（编译器，gc，map，go 调度器）和提升它的性能。 Go 1.3 — 2014 年 6 月：这个版本对栈管理做了重要的改进。栈可以申请[连续的内存片段，提高了分配的效率 Go 1.4 — 2014 年 12 月：此版本带来了官方对 Android 的支持，让我们可以只用 Go 代码就能写出简单的 Android 程序。 Go 1.7 — 2016 年 8 月: 这个版本发布了context 包，为用户提供了处理超时和任务取消的方法。 Go 1.11 — 2018 年 8 月: Go 1.11 带来了一个重要的新功能：Go modules。
Go语言的优势
Go的核心优势 极致效率 静态编译 强大的标准库 为并发而生 部署简单
Go语言的应用领域
Go应用领域
云服务docker和k8s web开发 微服务开发 爬虫 游戏开发 存储 区块链
使用go的大型公司
Google 滴滴 京东 bilibili 小米 知乎 百度 腾讯、七牛
计算机的硬件组成
计算机组成部分
CPU：运算器+控制器 存储器：内存、磁盘 输入、输出
编译型语言和解释型语言
什么是编程语言
人与计算机之间进行沟通需要一门语言作为介质，即编程语言。
编程语言的发展经历了机器语言（指令系统）=>汇编语言=>高级语言（`C、java、Go`等）。
编译型与解释型语言
编译型语言（C C++ GO）
一次性的编译多次执行
运行效率高
跨平台差
解释型语言(Python JS)
一边编译一边执行
执行效率差
跨平台性能好
Go的环境安装和配置
1下载SDK
官网：https://golang.google.cn/
go中文网：https://studygolang.com/dl
2 安装
下载安装即可
安装路径C:\Go
执行命令 go version // 查看安装go的版本 C:\Users\zhu>go version go version go1.17.6 windows/amd64
3 配置环境变量
go env -w GOPATH=D:\GoWork
此电脑--属性 -- 高级系统设置 -- 环境变量
创建工作目录 D:\GoWork\bin D:\GoWork\pkg D:\GoWork\src\s9\day01
Go的第一个程序
D:\GoWork\src\s9\day01\hello\hi.go
package main
import "fmt"
func main() {
fmt.Println("hello world!!!")
}
导入多个包
import (
"p1"
"p2"
)
程序编译执行
1 编译命令： go build -o 可执行文件名?
执行可执行文件名
go build -o hi.exe hello.go
hi.exe
2 编译执行命令： go run Go代码文件
go run hello.go
下午01 变量
goland的安装和使用
go语言的注释
package main
import "fmt"
func main() {
//这是终端打印字符串“hello world的功能”
//单行注释
/*
这是一个多行注释
注释的部分不被编译器所运行
*/
fmt.Println("hello yuan!")
}
Go语言的变量
变量声明5种方式
package main
import "fmt"
func main() {
// 方式1：先声明
var x int
//再执行
x=10
// 方式2：声明再赋值
var y=100
// 方法3：声明赋值精简版
z:=30
fmt.Println(x)
fmt.Println(y)
fmt.Println(z)
// 方式4：多重赋值
var a,b int
a = 1
b = 2
fmt.Println(a)
fmt.Println(b)
// 方式5：一行赋值多个变量
var s,i,b2= "hello",100,true
fmt.Println(s,i,b2)
}
变量命名规范和匿名变量
变量的命名规范
1 变量名必须数字 字母 下划线组成
2 标识符开头不能是数字
3 标识符不能是保留字和关键字
4 建议使用驼峰命名
5 变量名见名知意
6 变量命名区分大小写
//关于变量的命名规范 // 不能数字开头 // 见名知义 // 驼峰 // 区分大小写 // var u = 10声明切片 不同 var U = 10声明切片 var a1 = 1000 var name = "测试" var firstName = "试" var secondName = "测" fmt.Println(a1) fmt.Println(name) fmt.Println(firstName) fmt.Println(secondName)
匿名变量
// 关于匿名变量 //var _,b,c = 100,"hello",true // 不能使用关键字
语言分隔符
package main
import "fmt"
func main() {
//go语句支持两种分隔符: 换行符合分号
var x=10 ; var y=20
fmt.Println(x,y)
}
下午02 基本数据类型
基本数据类型整型和浮点型
基本数据类型
1 整型和浮点型
2 字符串
3 布尔型
package main
import (
"fmt"
"reflect"
)
func main() {
// 一 整型
var x=100
fmt.Println(x,reflect.TypeOf(x))
// var y int8
// y = -128
// 二 浮点型
var f float32
f = 3.1415
//var f = 3.1415 //默认float64
fmt.Println(f,reflect.TypeOf(f))
}
Bytes = 8b
KB = 1024B
MB = 1024KB
科学计数法
var f = 2e16 fmt.Println(f,reflect.TypeOf(f))
基本数据类型布尔型
package main
import "fmt"
func main() {
//布尔类型：true false
fmt.Println(2>1)
}
下午03 字符串基本操作
字符串的索引切片操作
1 索引
package main
import (
"fmt"
"reflect"
)
func main() {
var s string
s = "A welcome to learn golang!"
fmt.Println(s,reflect.TypeOf(s))
//索引 字符串[索引]
fmt.Println(string(s[4]))
fmt.Println(string(s[0]))
}
2 切片
package main
import (
"fmt"
"reflect"
)
func main() {
var s string
s = "A welcome to learn golang!"
fmt.Println(s,reflect.TypeOf(s))
//切片 取连续字符串 字符串[开始索引:结束索引]
//特点：左闭右开
fmt.Println(s[2:9])
fmt.Println(s[2:]) //右边缺省，默认渠道最后一个值
fmt.Println(s[:9]) //左边缺省，默认从索引0取
}
字符串的转义功能
3 转义符
功能1 赋予某些普通符号 以特殊的功能
功能2 取消某些特殊符号的特殊功能
package main
import (
"fmt"
"reflect"
)
func main() {
var s string
s = "A welcome to learn golang!"
fmt.Println(s,reflect.TypeOf(s))
//索引 字符串[索引]
fmt.Println(string(s[4]))
fmt.Println(string(s[0]))
//切片 取连续字符串 字符串[开始索引:结束索引]
//特点：左闭右开
fmt.Println(s[2:9])
fmt.Println(s[2:]) //右边缺省，默认渠道最后一个值
fmt.Println(s[:9]) //左边缺省，默认从索引0取
//转义符 \
//功能1 赋予某些普通符号以特殊的功能 \n
//功能2 取消某些特殊符号的特殊功能
fmt.Println("i am yuan\nmy age is 22!")
fmt.Println("D:\\next")
fmt.Println("my name is \"yuan\"")
}
字符串的多行显示
4 反引号 多行打印
package main
import (
"fmt"
"reflect"
)
func main() {
var s string
//4 反引号: 多行打印
s= `
1. 添加学生
2. 查看学生
3. 删除学生
4. 更新学生
`
fmt.Println(s)
}
字符串类型--内置方法
1 大小写 strings.Upper ToLower
package main
import (
"fmt"
"strings"
)
func main() {
var name = "Yuan"
// 转大小写 string.ToUpper，strings.ToLower
var uppserName = strings.ToUpper(name)
var lowerName = strings.ToLower(name)
fmt.Println(uppserName)
fmt.Println(lowerName)
}
2.1 判断存在Contains
package main
import (
"fmt"
"strings"
)
func main() {
var name = "Yuan"
// 转大小写 string
var uppserName = strings.ToUpper(name)
var lowerName = strings.ToLower(name)
fmt.Println(uppserName)
fmt.Println(lowerName)
//Contains
var s = "hello yuan"
var b = strings.Contains(s, "yuan")
fmt.Println(b) //true
}
2.2判断开头HasPrefix 结尾HasSuffix
package main
import (
"fmt"
"strings"
)
func main() {
//判断 strings.Contains
var s = "hello yuan;hello rain;hello alvin!"
var b1 = strings.Contains(s, "yuan")
fmt.Println(b1)
var b2 = strings.HasPrefix(s,"hello")
fmt.Println(b2)
var b3 = strings.HasSuffix(s,"alivin")
fmt.Println(b3)
}
3 Trim 去除行首和行尾字符
Scan
func main() {
// 3 Trim
//var username string
//fmt.Scan(&username)
var username = " yuan "
fmt.Println("username",username)
var newName =strings.Trim(username," ")
fmt.Println("newName",newName)
fmt.Println(newName=="yuan")
}
字符串类型--内置方法2
4 split，join
split 返回切片，join输入切片
func main() {
//strings.Split
//len
var citys = "北京 上海 广州 深圳"
fmt.Println(len(citys))
var citysSli = strings.Split(citys," ")
fmt.Println(citysSli,reflect.TypeOf(citysSli))
}
len() 求容器元素个数
fmt.Println(len(citysSli))
注意：split 输入字符串，返回一个切片， Join 输入切片返回字符串
func main() {
var name = "Yuan"
//strings.Split
//len
var citys = "北京-上海-广州-深圳"
fmt.Println(len(citys))
var citysSli = strings.Split(citys,"-") //[北京 上海 广州 深圳] []string
fmt.Println(citysSli,reflect.TypeOf(citysSli))
fmt.Println(len(citysSli))
var cityNewStr=strings.Join(citysSli,";")
fmt.Println(cityNewStr,reflect.TypeOf(cityNewStr))
}
打印结果
[北京 上海 广州 深圳] []string
4
北京;上海;广州;深圳 string
5 查询方法index
匹配不成功，返回 -1
func main() {
//查询方法
var s2 = "yuan rain alvin"
var i = strings.Index(s2,"alvin")
fmt.Println(i)
}
打印结果
10
下午04 类型转换
简单回顾：
1、整型和浮点型
2、字符串
1 创建方式
2 索引切片
3 转义符号
4 反引号
5 内置方法
Toupper Tolower
Contains HasPrefix Has
Trim
Split join
index
类型转换
1 整型之间转换int64(a)
func main() {
//Go语言不支持隐式转换
//fmt.Println("100">20)
//1 显示转换
var a int8
a=100
fmt.Println(a,reflect.TypeOf(a))
//1 整型之间转换
b:=int64(a)
fmt.Println(b,reflect.TypeOf(b))
}
打印结果
100 int8
100 int64
2 整型转换为字符串 strconv.Itoa
注意：int8 int64等 一定要先转为int型
func main() {
//2 整型转换为字符串 strconv.Itoa
var age = 22 //"22"
fmt.Println(age,reflect.TypeOf(age))
//将整型转换为字符串型
var ageStr=strconv.Itoa(age)
fmt.Println(ageStr,reflect.TypeOf(ageStr))
}
打印结果
22 int
22 string
3 字符串转换为整型 strconv.Atoi
func main() {
//3 将字符串转换为整型
var money = "100"
moneyNum,err:=strconv.Atoi(money)
fmt.Println("err:",err)
fmt.Println("moneyNum:",moneyNum,reflect.TypeOf(moneyNum))
}
打印结果：
err:
moneyNum: 100 int
4 字符串转换为浮点型，ParseFloat
func main() {
//4 字符串转换为浮点型
var f = "3.1415"
f2,_:= strconv.ParseFloat(f,64)
fmt.Println(f2,reflect.TypeOf(f2))
}
打印结果
3.1415 float64
运算符
1 科学运算符
科学运算符和拼接
package main
import "fmt"
func main() {
//判断奇数、偶数
fmt.Println(1+1)
fmt.Println(2*5)
fmt.Println("hello"+"yuan")
fmt.Println(5%4)
}
判断奇数、偶数
package main
import "fmt"
func main() {
//判断奇数、偶数
var x=67
fmt.Println(x%2 == 0)
}
取值符
package main
import "fmt"
func main() {
var a int8 = 10
fmt.Println(&a) //取值符
a = 100
fmt.Println(&a)
fmt.Println(a)
}
打印结果
0xc00000a0ca
0xc00000a0ca
100
自加1
var a int8 = 10
//自加1操作
a = a+1
fmt.Println(a)
a+=1 // a = a + 1
2 关系运算符
package main
import "fmt"
func main() {
var a int8 = 10
//2 关系运算符
fmt.Println(2 == 2)
fmt.Println(2<=3)
}
3 逻辑运算符
package main
import "fmt"
func main() {
//3 逻辑运算符 与&& 或|| 非！
fmt.Println(2==2 || 2>3) //true
fmt.Println(2==2 && 2>3) //false
fmt.Println(!(2==2 && 2>3)) //true
username :="yuan"
password :=123
fmt.Println(username=="yuan" && password==123) //true
}