golang 语言基础一

访问量:1248 创建时间:2021-01-06

教程参照：https://www.bilibili.com/video/BV14T4y1g7h9

Go Win环境搭建、Go语言开发工具Vscode配置

Go环境win环境搭建

下载地址：https://golang.google.cn/dl/ ；安装默认安装即可，安装后使用go version或者go env命令验证是否成功。go1.11版本后无需手动配置环境变量，使用go mod管理项目，也无需把项目放到GOPATH指定目录下。

Go语言开发工具Vscode配置

中文简体：

go插件:

重启vscode!

使用vscode 编写demo01

在demo01目录创建文件main.go

package main
import "fmt"

func main(){
  fmt.Println("hello")
}

终端通过ctrl+`调出

插件安装

第一步：通过快捷键【ctrl+shift+p】调出安装界面。第二步：输入或者点击【GO:install/Update Tools】,全选大概17个左右插件，到此步骤时，部分插件会安装失败。

安装插件失败的处理方法,在windows的powershell中，设置代理，重启vscode,再次安装

go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.io,direct

GoLang 定义变量\fmt包、Println、Printf、Go语言注释

1、 Go语言定义变量 2、 fmt包、Print、Println、Printf的使用与区别 3、 Go语言中的注释 4、占位符的简单使用

package main
import "fmt"

func main() {
    // ctrl+/    快速注释 或者取消注释
    //println换行，输出中间有空格
    fmt.Println("hello", "world!")
    //print 不换行,输出中间无空格
    fmt.Print("hello", "world!")
    var msg = "world!"
    //prinf格式化输出
    fmt.Printf("hello %v", msg)
    // 类型推导定义变量
    a := 10
    var b = 20
    var c int = 30
    fmt.Println("a=", a, "b=", b, "c=", c)
    fmt.Print("a=", a, "b=", b, "c=", c)
    fmt.Printf("a=%d b=%d c=%d\n", a, b, c)
    // %v 占位符相应值的默认格式。
    // %d 整数占位符十进制表示
    //还有很多其他类型的占位符
    fmt.Printf("a=%v a的类型是%T", a, a)
}

运行结果如下：

C:\Users\Administrator\Desktop\go_demo\demo02>go run main.go
hello world!
helloworld!hello world!a= 10 b= 20 c= 30
a=10b=20c=30a=10 b=20 c=30
a=10 a的类型是int

GoLang变量常量变量命名规则(上)

GO语言中变量的声明: 变量名称由字母、数字、下划线组成，首字符不能为数字，关键字和保留字不能作为变量名，格式如下：

var 变量名称类型

package main

import "fmt"

var g = "全局变量"

func getUserinfo() (string, int) {
    return "zhangsan", 10
}

func main() {
    var username string
    fmt.Println(username) // 未初始化值为空
    var a1 = "张三"
    var m_ = "李四"
    var username1 string
    username1 = "王五"
    fmt.Println(a1, m_, username1)
    // var 变量名,变量名 类型 一次声明多个变量
    var a2, a3 string
    a2 = "aa"
    a3 = "ss"
    fmt.Println(a2, a3)
    var (
        // 这里也可以直接赋值
        a string
        b int
        c string
    )
    a = "张三"
    b = 20
    c = "男"
    // :=短变量声明法只能在函数内部数用，不能作为全局变量使用
    asd, sdf := 1, "string"
    fmt.Println(a, b, c, asd, sdf, g)

    // 匿名变量
    var username3, age3 = getUserinfo()
    fmt.Println(username3, age3)
    // _ 就是匿名变量，不会分配内存，不存在变量重复声明问题
    var username4, _ = getUserinfo()
    fmt.Println(username4)
}

GoLang变量常量变量命名规则代码风格(下)

常量，用const定义，常量是恒定不变的，定以后无法改变。常量定义与变量类似，将var换成const,定义时必须赋值。
iota 是golang的常量计数器，只能在常量表达式中使用，iota在const关键字出现时被重置为0（const内部的第一行之前），const中每增加一行常量声明，将使iota计数一次（iota可以理解为const语句块的索引行）

package main

import "fmt"

func main() {
    var username1 = "lisi"
    username1 = "王五"
    const username = "zhangsan"
    const pi = 3.14159
    fmt.Println(username1, username, pi)
    //定义多个常量时，省略值则与上面值相同
    const (
        A = "A"
        B = "B"
        C
    )
    fmt.Println(A, B, C)
    const a1 = iota
    fmt.Println(a1)
    const (
        n1 = iota
        n2
        n3
        n4
        _ //调过4
        n5
    )
    fmt.Println(n1, n2, n3, n4, n5)
    const (
        b1 = iota
        b2 = 100
        b3 = iota
        b4
    )
    fmt.Println(b1, b2, b3, b4)
    //多个iota定义在一行
    const (
        s1, s2 = iota + 1, iota + 2 //1,2
        s3, s4                      //2,3
        s5, s6                      //3,4
    )
    fmt.Println(s1, s2, s3, s4, s5, s6)
}

输出如下：

D:\go_demo\demo01>go run main.go
王五 zhangsan 3.14159
A B B
0
0 1 2 3 5
0 100 2 3
1 2 2 3 3 4

Go语言代码风格,代码每一行结束不需要使用分号，运算符左右建议加一个空格，建议使用驼峰命名规则maxAge,可以使用go fmt main.go格式化代码风格。

GoLang语言基本数据类型-整型详解

go数据类型分为：基本数据类型和复合数据类型
基本数据类型有：整型、浮点型、布尔型、字符串
复合数据类型：数组、切片、结构体、函数、map、通道channel、接口等
整型

有符号整形 : int8、int16、int32、int64 无符号整型：uint8、uint16、uint32、uint64 特殊整型： uint（跟系统位数有关）、int（跟系统位数有关）、uintptr （无符号整型，用于存放一个指针）

有符号整型第一位是符号位，0表示-，1表示+

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    //定义int
    var num int = 10
    var num1 int8 = 100
    var num2 int16 = 200
    var num3 uint8 = 200
    fmt.Printf("num=%v 类型： %T  num1=%v 类型:%T ,num2=%v 类型:%T  num3=%v 类型:%T\n", num, num, num1, num1, num2, num2, num3, num3)
    //unsafe.Sizeof 查看内存的存储空间
    fmt.Println(unsafe.Sizeof(num2))
    // int 类型转换 ;int64()   int32()
    // 高位转低位可能溢出
    var a1 int32 = 10
    var a2 int64 = 20
    fmt.Println(int64(a1) + a2)
    //数字字面量,默认是int类型，int类型在32机器是32位，在64位机器是64位
    // %d 表示10进制输出，%b表示二进制输出，%o 八进制输出 %x 表示16进制输出
    testn := 30
    fmt.Printf("num=%b 类型： %T \n", testn, testn)
    fmt.Println(unsafe.Sizeof(testn))
}

基本数据类型-浮点型布尔型详解

1、Float32 最大范围3.4e38,可以使用常量定义：math.MaxFloat32 2、Float64 最大范围约1.8e308,可以使用一个常量定义math.MaxFloat64 3、Golang 浮点型精度损失 4、布尔型详解

package main

import (
    "fmt"
    "unsafe"
    "github.com/shopspring/decimal"
)

func main() {
    var a float32 = 3.12
    fmt.Printf("值: %v--%f,类型%T\n", a, a, a)
    fmt.Println(unsafe.Sizeof(a))
    var b float64 = 3.1234523231
    fmt.Printf("值: %v--%f--%.2f,类型%T\n", b, b, b, b)
    fmt.Println(unsafe.Sizeof(b))
    //默认浮点数与系统位数有关
    f1 := 3.1415
    fmt.Printf("值: %f--%T\n", f1, f1)
    //科学计数法表示e2 *10的二次方，e-2表示除以10的2次方
    f2 := 3.14e2
    f3 := 3.14e-2
    fmt.Printf("值: %f--%f\n", f2, f3)
    //精度丢失问题,使用decimal包解决
    var f4 float64 = 1129.6
    fmt.Println(f4 * 100)
    var num1 float64 = 3.1
    var num2 float64 = 4.2
    d1 := decimal.NewFromFloat(num1).Add(decimal.NewFromFloat(num2))
    fmt.Println(d1)
    //类型转换
    a1 := 10
    b1 := float64(a1)
    fmt.Printf("值: %f--%T\n", b1, b1)
    // 布尔类型无法参与数值运算，也无法与其他类型转换，布尔类型变量默认值是false,string变量默认是空，int默认是0，float默认是0
    var flag = true
    var b2 bool
    fmt.Printf("值: %f--%T\n", flag, flag)
    fmt.Printf("值: %f--%T\n", b2, b2)
}

基本数据类型-字符串字符串方法详解

1、字符串转义符

转义符	含义
\r	回车（返回行首）
\n	换行符（直接跳到下一行的同列位置）
\t	制表符
\'	单引号
\"	双引号
\	反斜杠

2、多行字符串 3、字符串的常用操作函数

package main

import (
    "fmt"
    "strings"
)

func main() {
    //定义字符串
    var str1 string = "1sdad"
    var str2 = "hi go"
    str3 := "world"
    fmt.Println(str1, str2, str3)
    //转义字符串
    str4 := "this \n is str"
    fmt.Println(str4)
    str5 := "C:\\Go\\bin"
    fmt.Println(str5)
    //多行字符串定义
    str6 := `hi go
    hi go hi go
    hi go  hi go
    hi go
    `
    fmt.Println(str6)
    //len(str)求字符串长度
    //拼接字符串+号 或者fmt.Sprintf
    fmt.Println(str2 + str3)
    str7 := fmt.Sprintf("%v %v", str2, str3)
    fmt.Println(str4, str7)
    //分割字符串
    var s1 = "123-234-345"
    arr := strings.Split(s1, "-")
    fmt.Println(arr)
    //连接字符串
    s2 := strings.Join(arr, "*")
    fmt.Println(s2)
    // strings.contains(s1,s2) 判断s1是否包含s2
    // strings.HasPrefix,strings.HasSuffix 判断前后缀
    st1 := "abc"
    st2 := "a"
    flag := strings.HasPrefix(st1, st2)
    fmt.Println(flag)
    // 判断子字符串出现的位置 strings.Index() , strings.LastIndex(),查找不到返回-1，查找到返回下标位置，下标从0开始
}

GoLang byte 和 rune 类型

1、Byte类型 2、rune类型 3、字符串和Byte类型 rune类型的转换

组成每个字符串的元素叫做"字符"，可以通过遍历字符串元素获得字符。定义字符用单引号''把裹起来。字符与字符串不通。

package main

import "fmt"

func main() {
    // 1、golang中定义字符  字符属于int类型;原样输出:%c
    var a = 'a'
    fmt.Printf("值:%v ，原样输出:%c 类型:%T", a, a, a) // %v 直接输出byte的是字符对应的asc码值
    //定义字符串，输出里面的字符
    var str = "this" //占用4个字节
    fmt.Printf("值:%v 类型%T\n", str[2], str[3])
    //一个汉字（utf-8编码）占用3个字节，一个字母占用1个字节
    //unsafe.Sizeof()没法查看string类型占用的存储空间，使用len可以
    str = "你好go"
    fmt.Println(len(str))
    var a1 = '中'
    fmt.Printf("值:%v 类型 %T", a1, a1) //值:20013 类型 int32
    //循环输出
    a2 := "你好 golang"
    for i := 0; i < len(a2); i++ {
        fmt.Printf("%v(%c)\n", a2[i], a2[i])
    }
    // range方法，用rune类型遍历
    for _, v := range a2 {
        fmt.Printf("%v(%c)", v, v)
    }
    //修改字符串:要将字符串先转成[]rune 或[]byte类型，完成后再转换为string。无论哪种转换,都会重新分配内存，并复制字节数组。
    s1 := "yellow"
    byteS1 := []byte(s1)
    byteS1[0] = 'l'
    fmt.Printf(string(byteS1))
    s2 := "饺子"
    runeS2 := []rune(s2)
    runeS2[0] = '包'
    fmt.Printf(string(runeS2))
}

Go语言中的两种字符类型： uint8 ,或者叫byte,代表ASCII码的一个字符。 rune,代表一个UTF-8字符。

基本数据类型之间的转换

1、关于golang中的数据类型转换 2、数值类型之间的相互转换

package main

import "fmt"

func main() {
    //数制转换建议从低位转高位，防止溢出
    //整型转整型
    var a int8 = 20
    var b int16 = 40
    fmt.Println(int16(a) + b)
    //浮点型
    var a1 float32 = 11.1
    var b1 float64 = 22.2
    fmt.Println(float64(a1) + b1 + float64(a))
    //fmt.Sprintf() 转换其他类型到字符串
}

3、其他类型转换成String类型

package main

import "fmt"

func main() {
    //fmt.Sprintf() 转换其他类型到字符串

    //strconv 包转换其他类型
    var i int = 20
    var f float64 = 12.34567
    var t bool = true
    var b byte = 'a'

    str1 := fmt.Sprintf("%d", i)
    fmt.Printf("%v %T\n", str1, str1)
    str2 := fmt.Sprintf("%.2f", f)
    fmt.Printf("%v %T\n", str2, str2)
    str3 := fmt.Sprintf("%t", t)
    fmt.Printf("%v %T\n", str3, str3)
    str4 := fmt.Sprintf("%c", b)
    fmt.Printf("%v %T\n", str4, str4)
}

使用strconv

package main

import (
    "fmt"
    "strconv"
)

func main() {

    //strconv 包转换其他类型到string
    var i int = 20
    var f float64 = 12.3233
    var t bool = true
    var b byte = 'a'

    str1 := strconv.FormatInt(int64(i), 10) //2个参数，一个是要转换的int64值，一个是第一个参数的进制
    fmt.Printf("%v %T\n", str1, str1)
    str2 := strconv.FormatFloat(float64(f), 'f', 2, 64) //参数一要转换的对象，参数二格式化类型，参数三，保留的小数点，参数四格式化的类型（64或32）
    fmt.Printf("%v %T\n", str2, str2)
    str3 := strconv.FormatBool(t)
    fmt.Printf("%v %T\n", str3, str3)
    str4 := strconv.FormatUint(uint64(b), 10)
    fmt.Printf("%v %T\n", str4, str4)
}

4、String类型转换成数值类型

package main

import (
    "fmt"
    "strconv"
)

func main() {

    //strconv 包转换其他类型到string
    str := "123234"
    str1 := "1.2123"
    num, _ := strconv.ParseInt(str, 10, 64)
    num1, _ := strconv.ParseFloat(str1, 64)
    fmt.Println(num)
    fmt.Println(num1)
}

5、数值类型没法和bool类型进行转换

运算符-算术运算符、关系运算符、逻辑运算符、赋值运算符

1、算术运算符

运算符	描述
+	加
-	减
*	乘
/	除（如果运算的数都是整数，那么除之后，去除小数部分，保留整数部分）
%	求余数=被除数-商*除数

++ 自增和-- 自减在go语言中是单独的语句，并不是运算符，只能单独使用不能赋值操作。

package main
import "fmt"

func main() {
    var a = 10
    var b = 3
    fmt.Println(a + b)
    fmt.Println(a - b)
    fmt.Println(a * b)
    fmt.Println(a / b)
    var c = 10.0
    var d = 3.0
    fmt.Println(c / d)
    fmt.Println(a % b)
    fmt.Println(-10 % 3)
    i := 1
    i++
    fmt.Println(i)
}

2、关系运算符

关系运算符	描述
==	检查2个值是否相等，相等返回true, 否则返回false
!=	检查2个值是否不相等，不相等返回true, 否则返回false
>	左边大于右边返回true, 否则返回false
>=	左边大于等于右边返回true, 否则返回false
<	左边小于右边返回true, 否则返回false
<=	左边小于等于右边返回true, 否则返回false

package main
import "fmt"

func main() {
    var a = 10
    var b = 3
    fmt.Println(a == b)
    fmt.Println(a != b)
    fmt.Println(a > b)
    fmt.Println(a <= b)
    flag := a >= b
    fmt.Println(flag)
}

3、逻辑运算符

逻辑运算符	描述
&&	逻辑与运算
\|\|	逻辑或运算
！	逻辑非运算

package main
import "fmt"

//自定义一个方法
func test() bool {
    fmt.Println("test....")
    return true
}

func main() {
    var a = 10
    var b = 3
    fmt.Println(a > 20 || b < 10)
    fmt.Println(a > b && b < 10)
    fmt.Println(!(a > 10))
    //逻辑与前面不成立后面test()不执行
    if a > 9 && test() {
        fmt.Println("执行")
    }
    //逻辑或前面成立后面test()不执行
    if a > 9 || test() {
        fmt.Println("执行")
    }
}

4、位运算符

位运算符是对整数在内存中的二进制位进行操作。

位运算符	描述
&	参与运算的两数对应的二进制位相或与
\|	参与运算的两数对应的二进制位相或
^	参与运算的两数对应的二进制位相异或（不同为1，相同为0）
<<	左移n位，就是乘以2的n次方，a<<b ，把a各二进制位左移b位，高位丢弃，低位补0
>>	右移n位

package main
import "fmt"

func main() {
    var a = 5
    var 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)
}

5、赋值运算符

赋值运算符	描述
=	将表达式的值赋值给左值
+=	相加再赋值
-=	相减再赋值
*=	相乘再赋值
/=	相除再赋值
%=	求余再赋值

package main
import "fmt"

func main() {
    var a = 10 + 1
    fmt.Println(a)
    var b = 5
    b += a //b=b+a
    a += 3 // a=a+3
    a -= 3
    fmt.Println(b)
}

<< 上一章节

下一章节 >>

登陆评论: 使用GITHUB登陆