Go基础知识入门

news2025/1/10 20:28:34

1、go语言介绍

 

2、go开发环境搭建

2.1、go的安装

  • go下载地址：All releases - The Go Programming Language，windows选择下载go1.20.2.windows-amd64.msi文件。

  • 双击go1.20.2.windows-amd64.msi，点击"Next"，然后勾选同意，再点击"Next"。

  • 选择Go的安装位置，这里我选择了"D:\0-software\0-develop\10-GO\1-go1.20.2"。再点击"Next"。

  • 点击"Install"进行安装。然后点击"Finish"就安装完成了。

 

2.2、go的环境变量配置 

  • 此电脑->右键"属性"->"高级系统设置"->"环境变量"

  • 在系统变量里面添加：

  • 变量名：GOPATH

    变量值：D:\0-software\0-develop\10-GO\1-go1.20.2

  • 在Path里面添加：%GOPATH%\bin

  • 然后打开cmd，输入"go version"，打印下图所示，说明环境变量配置成功。

goLand的安装、配置

  • goLand下载地址：GoLand by JetBrains: More than just a Go IDE，安装过程省略。

  • 新建go工程时，选择Go，不要选择Go(GOPATH)，早期的GoLand比如2020版本的才选择Go(GOPATH)。

2.3、go开发之hello-world

  • 点击"File"->"new"->"Go File"，编辑文件名为"Hello"

  • 可以看到默认会有一个package包名。每一个go的源码文件都要指定包名。并且只有package是main的代码才会运行。

  • func表示函数的意思。

  • 注意：Go语言的Hello World你想要运行的话要注意：

    1. 包名必须叫main

    2. 函数名也必须叫main

    3. 同一个目录下只能有一个func main()

  • 点击绿色的三角按钮执行。

  • 还可以通过另外一种方式运行：

    1. 进入到Hello.go所在目录文件夹

    2. 然后执行go build .\Hello.go，这样可以将Hello.go编译成可执行文件。

    3. 然后执行：.\Hello.exe，就可以执行了。

    4. 如果想省略编译过程直接执行，可以输入：

      go run .\Hello.go

      这样就不会编译生成Hello.exe文件，而且还会执行。

3、变量和常量

3.1、如何定义变量

package main
​
import "fmt"
​
// 全局变量和局部变量(定义在main外面的变量都是全局变量)
//var sex = "male"
//var ok bool = true
​
// 简洁方式定义全局变量
var (
    sex = "male"
    ok  = true
)
​
//局部变量定义了就必须使用，不使用会报错；全局变量定义了之后可以不使用，不会报错。
​
func main() {
    //go是静态语言，静态语言和动态语言相比，定义变量差异很大
    //1、变量必须想定义后使用 2、变量必须有类型 3、变量类型定下来之后不能改变
    //定义变量的方式
    //方式一：var variableName variableType
    var name string
    name = "旺财"
    //演示：变量类型定下来之后不能改变
    //name = 1
​
    fmt.Print(name)
​
    /*
        方式二：var variableName = variableValue
        可以通过variableType，因为go可以通过variableValue进行类型推断。
    */
​
    var name2 = "小强"
    fmt.Print(name2)
​
    /*
        方式三：variableName := variableValue
        这种平时用的比较多
    */
​
    var age = 1
    fmt.Print(age)
​
    //go语言中局部变量定义了但是不使用，是不行的。
​
    //2、多变量定义
    var user1, user2, user3 = "小强", "旺财", 1
    fmt.Print(user1, user2, user3)
​
    /*
        注意：
            变量必须先定义再使用
            go语言是静态语言，要求变量的类型和肤质类型一致
            局部变量名不能冲突；全局变量和局部变量的变量名可以重复，这种情况下，局部变量的优先级高。
            简洁变量定义不能用于全局变量(方式三：variableName := variableValue)
            变量是有零值的
            局部变量定义了就必须使用，不使用会报错；全局变量定义了之后可以不使用，不会报错。
    */
​
}
​

3.2、常量的定义和使用

package main
​
import "fmt"
​
func main() {
    //常量，定义的时候就指定的值，不能修改。
    //常量定义的时候全部大写。多个单词中间加下划线。
    const PI1 float32 = 3.1415926535897932384626 //显式定义
    const PI2 = 3.1415926535897932384626         //隐式定义
​
    const (
        UNKNOWN = 1
        FEMALE  = 2
        MALE    = 3
    )
​
    const (
        X int = 1
        Y
        S = "abc"
        Z
        M
    )
    fmt.Print(X, Y, S, Z, M)
​
    /*
        1、常量类型只可以定义bool、数值(整数、浮点数和复数) 和 字符串；
        2、不曾使用的常量，没有强制使用的要求；
        3、显式指定类型的时候，必须确保常量 左右值类型一致。
        4、常量在定义的时候如果没有设置类型和值的话，它就用前面的类型和值。
    */
​
}
​

3.3、iota的使用细节

package main
​
import "fmt"
​
func main() {
    //iota，特殊常量，可以认为是一个可以被编译器修改的常量。
    const (
        ERR1 = iota + 1
        ERR2
        ERR3
        ERR4 = "abc"
        ERR5
        ERR6 = 100
        ERR7 = iota
    )
​
    const (
        ERRNEW1 = iota
    )
​
    fmt.Print(ERR7)
    fmt.Print(ERRNEW1)
    /*
        如果中断了iota那么必须显式的恢复，后续会自动递增。
        自增类型默认是int类型
        iota能简化const类型的定义
        每次出现const的时候，iota初始化为0
    */
​
}
​

3.4、匿名变量的定义和用途

package main
​
func a() (int, bool) {
    return 0, false
}
​
func main() {
    //匿名变量：就是一个下划线
    var _ int
    //r1, ok := a()
    _, ok := a()
    /*
        如果我接下来只想使用ok，不想使用r1，根据Go的局部变量定义规定的，定义了就必须使用，那我就必须在下面被迫的加一个多余的打印r1的代码。
        有什么好办法吗？
        这时，匿名变量就登场了。可以使用"_"代替r1，这样在下面可以不用也不会报错了。
    */
    if ok {
        //打印
        
    }
}
​

3.5、变量的作用域

package main
​
import "fmt"
​
// 全局变量：任何一个函数都可以使用这个变量
var globalVariable = "旺财"
​
func main() {
    //变量的作用域
​
    //局部变量
    localVariable := "小强"
    fmt.Print(localVariable)
​
    {
        //局部变量
        localVariable2 := "张三"
        fmt.Print(localVariable2)
    }
    //在局部变量作用域外部打印该变量会报错
    //fmt.Print(localVariable2)
​
}
​

4、go的基础数据类型

4.1、数值、浮点数和字符类型

package main
​
import "fmt"
​
func main() {
    //基础数据类型
    //var a int8
    //var b int16
    //var c int32
    //var d int64
    //var ua uint8
    //var ub uint16
    //var uc uint32
    //var ud uint64
    动态类型，用的时候就会知道，用起来挺麻烦的
    //var e int
    //
    类型转换需要强转才行
    //a = int8(b)
    //
    //var f1 float32
    //var f2 float64
    //
    //f1 = 3
    //f2 = 3.14
​
    //主要是用来存放字符的
    var c byte
    c = 'a' + 1
    fmt.Print(c)          //值是98
    fmt.Printf("c=%c", c) //打印的是 c=b
​
    c1 := 97
    fmt.Printf("c=%c", c1) //打印的是 c=a
​
    //也是字符
    var c2 rune
    c2 = '旺'
    fmt.Printf("c=%c", c2) //打印的是 c=旺
​
    //字符串
    var name string
    name = "My name is Peter Parker,I am a Super Hero. I don't like the Criminals."
    fmt.Print(name)
}
​

bool类型

布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true

数值型

  1. 整数型

可以简单讲解一下二进制和位数的关系，以及int和uint的关系

  • int8 有符号 8 位整型 (-128 到 127) 长度：8bit

  • int16 有符号 16 位整型 (-32768 到 32767)

  • int32 有符号 32 位整型 (-2147483648 到 2147483647)

  • int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

  • uint8 无符号 8 位整型 (0 到 255) 8位都用于表示数值：

  • uint16 无符号 16 位整型 (0 到 65535)

  • uint32 无符号 32 位整型 (0 到 4294967295)

  • uint64 无符号 64 位整型 (0 到 18446744073709551615)

  1. 浮点型

  • float32 32位浮点型数

  • float64 64位浮点型数

其他

  • byte 等于 uint8

  • rune 等于 int32

  • uint 32 或 64 位

字符

Golang中没有专门的字符类型，如果要存储单个字符(字母)，一般使用byte来保存。 ​ 字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，而Go的字符串不同，它是由字节组成的。

package main
​
import (
    "fmt"
)
​
func main() {
​
    var a byte
    a = 'a'
    //输出ascii对应码值 。。 这里说明一下什么是ascii码
    fmt.Println(a)
    fmt.Printf("a=%c", a)
}
代码块1234567891011121314

字符常量只能使用单引号括起来，例如：var a byte = ‘a’ var a int = ‘a’

package main
​
import (
    "fmt"
)
​
func main() {
​
    var a byte
    a = "a"
    //输出ascii对应码值 。。 这里说明一下什么是ascii码
    fmt.Println(a)
    fmt.Printf("a=%c", a)
}
代码块1234567891011121314

字符本质是一个数字， 可以进行加减乘除

package main
​
import (
    "fmt"
    "reflect"
)
​
func main() {
​
    a := 'a'
​
    //这里注意一下 1. a+1可以和数字计算 2.a+1的类型是32 3. int类型可以直接变成字符
​
    fmt.Println(reflect.TypeOf(a+1))
    fmt.Printf("a+1=%c", a+1)
}
代码块12345678910111213141516

字符串

字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。

4.2、基本类型的转换

package main
​
import (
    "fmt"
    "strconv"
)
​
func main() {
    //基本类型转换
    //int和int相互转换
    var a int8 = 12
    //var b = uint8(a)
    //fmt.Print(b)
​
    //float转int
    //var f float32 = 3.14
    //var c = int32(f)
    //fmt.Print(c) //打印的是3
​
    //int转float
    //var f64 = float64(a)
    //fmt.Print(f64) //打印的是12
​
    //定义别名
    type IT int //类型要求很严格
    var c = IT(a)
    fmt.Print(c)
​
    //字符串转数字
    var istr = "12"
    myint, err := strconv.Atoi(istr)
    if err != nil {
        fmt.Print("convert erro")
    }
    fmt.Print(myint)
​
    //数字转字符串
    var myi = 32
    fmt.Print(strconv.Itoa(myi))
    
}
​

type 关键字：

在 Go 语言中，type 关键字常被我们用来创建新的结构体。同样的，type 也可以用来创建其它的用户自定义类型。在创建新类型时，有类型别名和类型定义两种方式，你知道它们的区别吗？

1、type 关键字

对于使用过 Go 语言的人，相信对type关键字都不陌生，它可以帮助我们定义结构体或接口：

type Student struct{
​
}
​
type Man interface {
    Name()
}

在使用 type 定义结构体时，我们可以把它看作是基于struct{}类型定义了一个新的类型Student。

其实，除了用于创建新类型，type还有创建类型别名的作用。

2、类型别名 vs 类型定义

基于一个类型创建一个别名，称之为类型别名 (alias)。

基于一个类型创建一个新类型，称之为类型定义 (definition)。

type Int1 = int // 类型别名，Int1 是 int 类型的别名
type Int2 int // 类型定义，Int2 是新类型

它们之间的区别是什么呢？

以上述定义的Int1和Int2为例，我们可以用int类型的变量初始化Int1类型，因为Int1只是int类型的一个别名。

但如果我们用一个int类型的变量初始化Int2类型时，对Int2类型的初始化会报错，因为Int2是一个新的类型。

type Int1 = int // 类型别名，Int1 是 int 类型的别名
type Int2 int // 类型定义，Int2 是新类型
​
var i int = 0
​
var i1 Int1 = i
var i2 Int2 = i // error

不过，Int1类型和Int2类型都可以用相应类型的字面量来初始化。

type Int1 = int // 类型别名，Int1 是 int 类型的别名
type Int2 int // 类型定义，Int2 是新类型
​
var i1 Int1 = 0
var i2 Int2 = 0

4.2.1、简单的转换操作

valueOfTypeB = typeB(valueOfTypeA)
代码块1
// 浮点数
a := 5.0
​
// 转换为int类型
b := int(a)
​
//Go允许在底层结构相同的两个类型之间互转。例如：
// IT类型的底层是int类型
type IT int
​
// a的类型为IT，底层是int
var a IT = 5
​
// 将a(IT)转换为int，b现在是int类型
b := int(5)
​
// 将b(int)转换为IT，c现在是IT类型
c := IT(b)
​
var a int32 = 1
var b int64 = 3
b = int64(a)
fmt.Println(a, b)
​
/*
    不是所有数据类型都能转换的，例如字母格式的string类型"abcd"转换为int肯定会失败
    低精度转换为高精度时是安全的，高精度的值转换为低精度时会丢失精度。例如int32转换为int16，float32转换为int
    这种简单的转换方式不能对int(float)和string进行互转，要跨大类型转换，可以使用strconv包提供的函数
*/
代码块1234567891011121314151617181920212223242526272829

4.2.2、strconv

Itoa和Atoi

int转换为字符串：Itoa()

println("a" + strconv.Itoa(32))  // a32
代码块1

string转换为int：Atoi()(表示 alphanumeric to integer)是把字符串转换成整型数的一个函数

i,_ := strconv.Atoi("3")
println(3 + i)   // 6
​
// Atoi()转换失败
i,err := strconv.Atoi("a")
if err != nil {
    println("converted failed")
}
//由于string可能无法转换为int，所以这个函数有两个返回值：第一个返回值是转换成int的值，第二个返回值判断是否转换成功。
代码块123456789

4.3、format进行格式化转换

Parse类函数

Parse类函数用于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()。

b, err := strconv.ParseBool("true")
f, err := strconv.ParseFloat("3.1415", 64)
i, err := strconv.ParseInt("-42", 10, 64)
u, err := strconv.ParseUint("42", 10, 64)

ParseInt()和ParseUint()有3个参数：

func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (uint64, error)

说明：

  1. bitSize参数表示转换为什么位的int/uint，有效值为0、8、16、32、64。当bitSize=0的时候，表示转换为int或uint类型。例如bitSize=8表示转换后的值的类型为int8或uint8。

  2. base参数表示以什么进制的方式去解析给定的字符串，有效值为0、2-36。当base=0的时候，表示根据string的前缀来判断以什么进制去解析：0x开头的以16进制的方式去解析，0开头的以8进制方式去解析，其它的以10进制方式解析。

Format类函数

将给定类型格式化为string类型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。

s := strconv.FormatBool(true)
s := strconv.FormatFloat(3.1415, 'E', -1, 64)
s := strconv.FormatInt(-42, 16) //表示将-42转换为16进制数，转换的结果为-2a。
s := strconv.FormatUint(42, 16)
代码块1234

第二个参数base指定将第一个参数转换为多少进制，有效值为2<=base<=36。当指定的进制位大于10的时候，超出10的数值以a-z字母表示。例如16进制时，10-15的数字分别使用a-f表示，17进制时，10-16的数值分别使用a-g表示。

FormatFloat()参数众多：

func FormatFloat(f float64, fmt byte, prec, bitSize int) string
代码块1

bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。 ​ fmt表示格式：‘f’（-ddd.dddd）、‘b’（-ddddp±ddd，指数为二进制）、‘e’（-d.dddde±dd，十进制指数）、‘E’（-d.ddddE±dd，十进制指数）、‘g’（指数很大时用’e’格式，否则’f’格式）、‘G’（指数很大时用’E’格式，否则’f’格式）。 ​ prec控制精度（排除指数部分）：对’f’、‘e’、‘E’，它表示小数点后的数字个数；对’g’、‘G’，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。

4.4、运算符和表达式

4.4.1、算数运算符

      • / %(求余) ++ –

4.4.2、关系运算符

== != > < >= <=

4.4.3、逻辑运算符

&&所谓逻辑与运算符。如果两个操作数都非零，则条件变为真
||所谓的逻辑或操作。如果任何两个操作数是非零，则条件变为真
!所谓逻辑非运算符。使用反转操作数的逻辑状态。如果条件为真，那么逻辑非操后结果为假

这个和python不一样，python中使用 and or来连接

package main
​
import "fmt"
​
func main() {
   var a bool = true
   var b bool = false
   if ( a && b ) {
      fmt.Printf("第一行 - 条件为 true\n" )
   }
   if ( a || b ) {
      fmt.Printf("第二行 - 条件为 true\n" )
   }
   /* 修改 a 和 b 的值 */
   a = false
   b = true
   if ( a && b ) {
      fmt.Printf("第三行 - 条件为 true\n" )
   } else {
      fmt.Printf("第三行 - 条件为 false\n" )
   }
   if ( !(a && b) ) {
      fmt.Printf("第四行 - 条件为 true\n" )
   }
}
代码块12345678910111213141516171819202122232425

4.4.4、位运算符

位运算符对整数在内存中的二进制位进行操作。 ​ 下表列出了位运算符 &, |, 和 ^ 的计算：

PQP & QP | QP ^ Q
00000
01011
11110
10011

假定 A = 60; B = 13; 其二进制数转换为： A = 0011 1100 B = 0000 1101

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001 Go 语言支持的位运算符如下表所示。假定 A 为60，B 为13：

运算符描述实例
&按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。(A & B) 结果为 12, 二进制为 0000 1100
|按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或(A | B) 结果为 61, 二进制为 0011 1101
^按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。(A ^ B) 结果为 49, 二进制为 0011 0001
<<左移运算符"<<“是双目运算符。左移n位就是乘以2的n次方。 其功能把”<<“左边的运算数的各二进位全部左移若干位，由”<<"右边的数指定移动的位数，高位丢弃，低位补0。A << 2 结果为 240 ，二进制为 1111 0000
>>右移运算符">>"是双目运算符。右移n位就是除以2的n次方。
其功能是把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数。A >> 2 结果为 15 ，二进制为 0000 1111
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 )
}
代码块12345678910111213141516171819202122232425

4.4.5、赋值运算符

下表列出了所有Go语言的赋值运算符。

运算符描述实例
=简单的赋值运算符，将一个表达式的值赋给一个左值C = A + B 将 A + B 表达式结果赋值给 C
+=相加后再赋值C += A 等于 C = C + A
-=相减后再赋值C -= A 等于 C = C - A
*=相乘后再赋值C *= A 等于 C = C * A
/=相除后再赋值C /= A 等于 C = C / A
%=求余后再赋值C %= A 等于 C = C % A
<<=左移后赋值C <<= 2 等于 C = C << 2
>>=右移后赋值C >>= 2 等于 C = C >> 2
&=按位与后赋值C &= 2 等于 C = C & 2
^=按位异或后赋值C ^= 2 等于 C = C ^ 2
|=按位或后赋值C |= 2 等于 C = C | 2
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 )
​
}
代码块1234567891011121314151617181920212223242526272829303132333435363738394041

4.4.6、其他运算符

此处讲解一下什么是地址

运算符描述实例
&返回变量存储地址&a; 将给出变量的实际地址。
*指针变量。*a; 是一个指针变量
package main
​
import "fmt"
​
func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int
​
   /* 运算符实例 */
   fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
   fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b );
   fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c );
​
   /*  & 和 * 运算符实例 */
   ptr = &a     /* 'ptr' 包含了 'a' 变量的地址 */
   fmt.Printf("a 的值为  %d\n", a);
   fmt.Printf("*ptr 为 %d\n", *ptr);
}
代码块1234567891011121314151617181920

4.4.7、运算符优先级

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低

优先级分类运算符结合性
1逗号运算符,从左到右
2赋值运算符=、+=、-=、*=、/=、 %=、 >=、 <<=、&=、^=、|=从右到左
3逻辑或||从左到右
4逻辑与&&从左到右
5按位或|从左到右
6按位异或^从左到右
7按位与&从左到右
8相等/不等==、!=从左到右
9关系运算符<、<=、>、>=从左到右
10位移运算符<<、>>从左到右
11加法/减法+、-从左到右
12乘法/除法/取余*（乘号）、/、%从左到右
13单目运算符!、*（指针）、& 、++、–、+（正号）、-（负号）从右到左
14后缀运算符( )、[ ]、->从左到右

当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。

package main
​
import "fmt"
​
func main() {
   var a int = 20
   var b int = 10
   var c int = 15
   var d int = 5
   var e int;
​
   e = (a + b) * c / d;      // ( 30 * 15 ) / 5
   fmt.Printf("(a + b) * c / d 的值为 : %d\n",  e );
​
   e = ((a + b) * c) / d;    // (30 * 15 ) / 5
   fmt.Printf("((a + b) * c) / d 的值为  : %d\n" ,  e );
​
   e = (a + b) * (c / d);   // (30) * (15/5)
   fmt.Printf("(a + b) * (c / d) 的值为  : %d\n",  e );
​
   e = a + (b * c) / d;     //  20 + (150/5)
   fmt.Printf("a + (b * c) / d 的值为  : %d\n" ,  e );  
}
​

5、字符串基本操作

5-1、rune和字符串长度

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/515109.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Linux——进程信号1

Linux——进程信号1

信号和信号量是俩个东西&#xff0c;俩者无关系。 信号 信号本质是一种通知机制&#xff0c;用户or操作系统通过发送一定的信号&#xff0c;通知进程&#xff0c;某些事件已经发送&#xff0c;让进程进行后续处理。 结合进程&#xff0c;信号结论&#xff1a; 进程要处理信号&a…
阅读更多...
【Windows线程开发】线程基础

【Windows线程开发】线程基础

本篇文章来带领大家了解Windows线程&#xff0c;了解线程的基本概念&#xff0c;了解线程的创建方式&#xff0c;以及一些简单的线程操作。 文章目录 一.线程基本概念二.创建线程三.线程实例&#xff08;单线程&#xff0c;多线程&#xff09;单线程执行多线程执行 四.挂起&am…
阅读更多...
ElasticSeach 集成 springboot

ElasticSeach 集成 springboot

声明是ElasticSearch? ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎&#xff0c; 基于RESTful web接口。Elasticsearch是用Java开发的&#xff0c;并作为Apache许可条款下的开放源码发布&#xff0c;是 当前流行的企业级搜索引擎…
阅读更多...
大数据 | （五）通过Sqoop实现从MySQL导入数据到HDFS

大数据 | （五）通过Sqoop实现从MySQL导入数据到HDFS

知识目录 一、前言二、导入前的准备2.1 Hadoop集群搭建2.2 Hadoop启停脚本 三、docker安装MySQL四、安装Sqoop4.1 Sqoop准备4.2 Sqoop连接Mysql数据测试 五、导入MySQL数据到hdfs5.1 准备MySQL数据5.2 导入数据 六、Sqoop现状七、结语 一、前言 各位CSDN的朋友们大家好&#x…
阅读更多...
5.11组会衍生总结：train/eval/BN、CNN与特征图、极大似然与EM、方差n与n-1（有偏估计/无偏估计）

5.11组会衍生总结：train/eval/BN、CNN与特征图、极大似然与EM、方差n与n-1（有偏估计/无偏估计）

目录组会问题：1.关于模型的train/eval与batchnorm1-1.理论1-2.实际运用（包含loss反向传播）2.CNN详解，特征图是什么CNN处理过程特征图（也叫通道）(num_features)总结（包含CNN图片的规律分析）：3.极大似然估计与EM最大期望4.方差的n与n-1（有偏估计与无偏估计） 组会问题：…
阅读更多...
企业文化和品牌文化是两回事

企业文化和品牌文化是两回事

商业通常谈两类文化&#xff1a;企业文化&#xff0c;品牌文化 1&#xff09;组织内部的文化 2&#xff09;品牌以产品为依托&#xff0c;给消费群体营造的文化 “积极稳定”的文化氛围打造是个慢活 企业文化&#xff0c;既要挂在墙上&#xff0c;又要挂在嘴上&#xff0c;最终…
阅读更多...
二叉查找树和平衡二叉树

二叉查找树和平衡二叉树

二叉查找树 下面是一张数据库的表,有两列,分别是 Col1 和 Col2 我们来查找一下col289的这行数据,SQL语句如下: select * from a where col2 87没有用索引时执行上面的查询 , 数据从磁盘一条一条拿来对比最终找到结果&#xff0c;如果数据表很大,数据又在表尾的话,需要花费非…
阅读更多...
Open3D点云数据处理（一）：VSCode配置python，并安装open3d教程

Open3D点云数据处理（一）：VSCode配置python，并安装open3d教程

文章目录 1 python下载与安装1.1 python下载1.2 python安装1.3 验证python是否安装成功 2 VSCode下载与安装2.1 下载2.2 安装2.3 安装汉化插件2.4 vscode安装python扩展2.5 编写一个简单的python程序并运行2.6 在外部终端中打印运行结果2.7 测试代码&#xff1a;使用python画一…
阅读更多...
常用的网页设计工具，有哪些比较推荐

常用的网页设计工具，有哪些比较推荐

网页设计并不容易&#xff0c;易于使用的网页设计工具更难找到。随着网络的快速发展&#xff0c;网站迅速崛起&#xff0c;网页设计也很流行。本文收集了7款易于使用的网页设计工具&#xff0c;每一种近年来都受到网页设计师的广泛欢迎&#xff0c;以确保实用和易于使用。我希望…
阅读更多...
背包九讲（dp问题详解）

背包九讲（dp问题详解）

一、01背包问题 首先了解一下题目&#xff1a; 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi&#xff0c;价值是 wi。 求解将哪些物品装入背包&#xff0c;可使这些物品的总体积不超过背包容量&#xff0c;且总价值最大。 输出最大价值。…
阅读更多...
Java中的抽象类介绍

Java中的抽象类介绍

Java中的抽象类介绍 抽象类可以包含普通类的成员&#xff0c;它可以包含普通的属性、方法和内部类等成员。这些成员既可以被抽象类的子类继承和使用&#xff0c;也可以被抽象类自身使用。抽象类中的非抽象方法必须要有具体实现&#xff0c;否则无法通过编译。抽象类中也可以拥…
阅读更多...
Leetcode2379. 得到 K 个黑块的最少涂色次数

Leetcode2379. 得到 K 个黑块的最少涂色次数

Every day a Leetcode 题目来源&#xff1a;2379. 得到 K 个黑块的最少涂色次数 解法1&#xff1a;滑动窗口 首先题目给出一个下标从 0 开始长度为 n 的字符串 blocks&#xff0c;其中 blocks[i] 是 ‘W’ 或者 ‘B’ &#xff0c;分别表示白色块要么是黑色块。 现在我们可…
阅读更多...
抗体偶联药物都有哪些？（详细名单）

抗体偶联药物都有哪些？（详细名单）

抗体偶联药物ADC简介 抗体-药物偶联物或ADC是一类生物制药药物&#xff0c;设计用于治疗癌症的靶向疗法。与化学疗法不同&#xff0c;ADC 旨在靶向并杀死肿瘤细胞&#xff0c;同时保留健康细胞。截至 2023 年5月&#xff0c;约有 433 家制药公司正在开发 ADC。 ADC 是由与具有…
阅读更多...
SPI基础

SPI基础

SPI硬件接口 SPI协议使用3条总线以及片选线。3条总线分别是SCK、MOSI、MISO&#xff0c;片选线为SS(NSS、CS) SPI基础属性 主从模式&#xff1a;主机模式&#xff0c;从机模式 通讯频率&#xff1a;不定&#xff0c;根据设备速率确定 数据位数&#xff1a;4位、7位&#xff…
阅读更多...
基于狮群算法优化的核极限学习机(KELM)分类算法-附代码

基于狮群算法优化的核极限学习机(KELM)分类算法-附代码

基于狮群算法优化的核极限学习机(KELM)分类算法 文章目录 基于狮群算法优化的核极限学习机(KELM)分类算法1.KELM理论基础2.分类问题3.基于狮群算法优化的KELM4.测试结果5.Matlab代码 摘要&#xff1a;本文利用狮群算法对核极限学习机(KELM)进行优化&#xff0c;并用于分类 1.KE…
阅读更多...
【华为机试】——每日刷题经验分享

【华为机试】——每日刷题经验分享

【华为机试】——每日刷题经验分享&#x1f60e; 前言&#x1f64c;题目&#xff1a;HJ9 提取不重复的整数 总结撒花&#x1f49e; &#x1f60e;博客昵称&#xff1a;博客小梦 &#x1f60a;最喜欢的座右铭&#xff1a;全神贯注的上吧&#xff01;&#xff01;&#xff01; &a…
阅读更多...
被ChatGPT“抢饭碗”的人

被ChatGPT“抢饭碗”的人

ChatGPT问世至今&#xff0c;互联上讨论声绵延不绝。有人说&#xff0c;AI会替代基础性工作。 一名金融从业者对《橡果商业评论》表示&#xff0c;这实际上是对人类经验的替代&#xff0c;那些引以为傲的经验&#xff0c;来源于对历史的总结&#xff0c;AI出现后&#xff0c;“…
阅读更多...
【C++STL】红黑树（更新中）

【C++STL】红黑树（更新中）

前言 上篇博客学习了平衡二叉搜索树(AVLTree)&#xff0c;了解到AVL树的性质&#xff0c;二叉搜索树因为其独特的结构&#xff0c;查找、插入和删除在平均和最坏情况下都是O(logn)。AVL树的效率就是高在这个地方。 但是在AVL树中插入或者删除结点&#xff0c;使得高度差的绝对…
阅读更多...
【GO 编程语言】数组

【GO 编程语言】数组

数组 文章目录 数组一、数组是什么二、初始化数组三、数组的遍历四、数组类型五、数组排序 一、数组是什么 Go 语言提供了数组类型的 数据结构。 数组是具有相同唯一类型的一组已编号且长度固定的数据项序列,这种类型可以是任意的原始类型。例如整型、字符串或者自定义类型。 …
阅读更多...
HTTP第八讲——请求方法

HTTP第八讲——请求方法

目前 HTTP/1.1 规定了八种方法&#xff0c;单词都必须是大写的形式 GET&#xff1a;获取资源&#xff0c;可以理解为读取或者下载数据&#xff1b;HEAD&#xff1a;获取资源的元信息&#xff1b;POST&#xff1a;向资源提交数据&#xff0c;相当于写入或上传数据&#xff1b;P…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023