Day01 Go语言基础

2023-11-05 20:46:52

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

变量

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)
}

基本数据类型

基本数据类型整型和浮点型

基本数据类型

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)
}

字符串基本操作

字符串的索引切片操作

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

类型转换

简单回顾：

　　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: <nil>
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
}

码农公寓

Go语言基础

Go介绍

Go语言的诞生

Go语言的版本

Go语言的优势

Go语言的应用领域

使用go的大型公司

计算机的硬件组成

计算机组成部分

编译型语言和解释型语言

什么是编程语言

编译型与解释型语言

Go的环境安装和配置

1下载SDK

2 安装

3 配置环境变量

Go的第一个程序

导入多个包

程序编译执行

变量

goland的安装和使用

go语言的注释

Go语言的变量

变量声明5种方式

变量命名规范和匿名变量

变量的命名规范

语言分隔符

基本数据类型

基本数据类型整型和浮点型

基本数据类型

科学计数法

基本数据类型布尔型

字符串基本操作

字符串的索引切片操作

1 索引

2 切片

字符串的转义功能

3 转义符

字符串的多行显示

4 反引号 多行打印

字符串类型--内置方法

1 大小写 strings.Upper ToLower

2.1 判断存在Contains

2.2判断开头HasPrefix 结尾HasSuffix

3 Trim 去除行首和行尾字符

Scan

字符串类型--内置方法2

4 split，join

5 查询方法index

类型转换

类型转换

1 整型之间转换int64(a)

2 整型转换为字符串 strconv.Itoa

3 字符串转换为整型 strconv.Atoi

4 字符串转换为浮点型，ParseFloat

运算符

1 科学运算符

判断奇数、偶数

取值符

自加1

2 关系运算符

3 逻辑运算符

相关文章

4 反引号多行打印