Go 语言基础语法 (一) | 豆包MarsCode AI 刷题

三三两两_coding
79 阅读8分钟

GO背景简介

Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，并最终于2009年11月开源，现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。

GO语言特色

  • 高性能、高并发
  • 语法简单、学习曲线平缓
  • 丰富的标准库
  • 完善的工具链
  • 静态链接
  • 快速编译
  • 跨平台
  • 垃圾回收

Go 语言用途

Go 被设计成一门应用于搭载 Web 服务器，存储集群或类似用途的巨型中央服务器的系统编程语言。
在高性能分布式系统领域，Go 语言比大多数其它语言有着更高的开发效率，它提供了海量并行的支持。

经典———Hello World！

一般情况下，Go 语言的基础组成有以下几个部分：

  • 包声明

  • 引入包

  • 函数

  • 变量

  • 语句 & 表达式

  • 注释

    package main

import "fmt"

func main() {
   /* 这是我的第一个简单的程序 */
   fmt.Println("Hello, World!")
}
上述程序的各个部分：
  • 第一行代码 package main 定义了包名。必须在源文件中的第一行指明这个文件属于哪个包，如：package main。
    package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。
  • 第二行 import "fmt"  告诉 Go 编译器这个程序需要使用 fmt 包中的函数或元素——fmt 包实现了格式化 IO（输入/输出）的函数。
  • 第三行 func main()  是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数，但如果有 init() 函数则会先执行该函数。
  • 第四行 /*...*/ 是注释。单行注释—— //。多行注释也叫块注释，以 /* 开头，并以 */ 结尾，且不可以嵌套使用。
  • 第五行 fmt.Println(...)  可以将字符串输出到控制台，并在最后自动增加换行字符 \n。（使用 fmt.Print("hello, world\n") 可以得到相同的结果。 ）

GO数据类型

Go 是 静态类型的，一旦定义了变量类型，它就只能存储该类型的数据。 Go 有三种基本的数据类型

  • bool 类型：表示布尔值，只有 true 或 false 两个取值

  • 数值：、 整数类型、浮点类型、复数类型 和 字符类型

  • string：字符串值

    1. 布尔类型 bool

    package main

import "fmt"

func main() {
    var b1 bool = true //带有初始值的 类型声明
    var b2 = true      // 带初始值的 无类型声明
    var b3 bool        // 不带初始值的类型声明  默认为 false
    b4 := true         // 自动类型推断

    fmt.Println(b1) // true
    fmt.Println(b2) // true
    fmt.Println(b3) // false
    fmt.Println(b4) // true
}

    布尔类型的变量 使用 bool 关键字声明，并且 只能采用值 true 或 false，一般默认值为 false Go 中 bool 类型仅仅是布尔类型，不再是其他语言中那样 bool 类型是 int 的子类型

    2. 整数

    Go 语言提供了两种类型的整数

    有符号整数存储正负两种值[−2n−1,2n−1−1-2^{n-1},2^{n-1}-1],其中n表示位模式的长度
    无符号整数只能存储非负值[0,2n−10,2^n-1]

    2.1 有符号整数 int ——声明的有符号整数可以存储正数和负数。

    序号类型描述
    1int取决于平台 32 位平台占 32 3232 位；64 6464 位平台占 64位
    2int8有符号 8 位整型 (-128 到 127)
    3int16有符号 16 位整型 (-32768 到 32767)
    4int32有符号 32 位整型 (-2147483648 到 2147483647)
    5int64有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
    6rune是 int32 的别名，用于处理 Unicode字符
      package main  

  import "fmt"  

  func main() {  
        var x int = 500  
        var y int = -4500  
        fmt.Printf("Type: %T, value: %v\n", x, x)  
        fmt.Printf("Type: %T, value: %v\n", y, y)  
 }

    2.2 无符号的 uint—声明的无符号整数只能存储非负值

    序号类型描述
    1uint8取决于平台 32 位平台占 32 3232 位；64 位平台占 64位
    2uint8无符号 8 位整型 (0 到 255)
    3uint16无符号 16 位整型 (0 到 65535)
    4uint32无符号 32 位整型 (0 到 4294967295)
    5uint64无符号 64 位整型 (0 到 18446744073709551615)
    6byte无符号 8 位整型 它是 uint8 的一个 别名
    7uintptr取决于平台 表示指针类型
    package main  

import "fmt"  

func main() {  
    var binary uint8 = 0b10100101  
    fmt.Printf("Type: %T, value: %#b\n", binary, binary)  
    var octal uint8 = 0337 // 0o337 0O337  
    fmt.Printf("Type: %T, value: %#o\n", octal, octal)  
    var hex uint8 = 0xaf  
    fmt.Printf("Type: %T, value: %#x\n", hex, hex)  
}

    整数字面值的默认类型是 int。如果未指定类型，则该类型为 int

    3. 浮点数——用于存储带小数点的正数和负数

    Go 语言提供了两种类型的浮点数，这两种浮点型数据格式 遵循 IEEE 754 标准:

    类型大小范围说明
    float3232 位[−3.4∗1038,3.4∗1038-3.4*10^{38},3.4*10^{38}]最大值定义在 math.MaxFloat32
    float64只能存储非负值[−1.8∗10308,1.8∗10308-1.8*10^{308},1.8*10^{308}]最大值定义在 math.MaxFloat64
    package main  

import {
    "fmt"  
    "math"
}    

func main() {  
    var x float32 = 123.78  
    var y float32 = 3.4e+38  
    var max_flaot32 = math.MaxFloat32  
    fmt.Printf("Type: %T, value: %v\n", x, x)  
    fmt.Printf("Type: %T, value: %v\n", y, y)  
    fmt.Printf("Type: %T, value: %v", max_flaot32, max_flaot32)  
}
浮点类型的 **默认类型是 `float64`**。如果不指定类型，则类型为 `float64`

    float32 与 float64 类型的变量不能相互赋值。是两个不同的数据类型

    4. 复数——其包括实部和虚部

    Go 提供了两种复数类型：complex64 和 complex128。

    • complex64的实部和虚部为 32 位

    • complex128的实部和虚部为 64 位

      package main

import "fmt"

func main(){
    // 复数
    var c1 complex64  // 实部和虚部均为32为
    c1 = 1 + 2i
    fmt.Println(c1)  // (1+2i)
    var c2 complex128  // 实部和虚部均为64为
    c2 = 2 + 3i
    fmt.Println(c2)  // (2+3i)
}

    5. 字符类型——Go 对字符的处理和C，都是把字符当作整数进行处理。

    Go 提供了两种类型表示字符——字符默认的类型为 rune

    • byte 类型，它是uint8的一个类型别名，用于处理8位编码的字符集。例如,ASCII和Latin-1
    • rune 类型，它是 int32 的类型别名，用于处理 Unicode。由于 Go 对 Unicode 字符的处理采用 UTF-8 编码方式，因此，可以是 rune 类型处理 UTF-8 字符

    Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有均衡

    package main  

import "fmt"  

func main() {  
    var ch rune = '你'  
    fmt.Println(ch)                            // 20320  
    fmt.Printf("Type: %T value: %c\n", ch, ch) // Type: int32 value: 你  
    var as byte = 'a'  
    fmt.Println(as)                            // 97  
    fmt.Printf("Type: %T value: %c\n", as, as) // Type: uint8 value: a  
}

    6. 字符串类型——string 类型的默认值位空字符串("")

    string 数据类型 用于 存储字符（文本）序列。字符串值必须用 双引号 引起来 package main

    import "fmt"

func main() {
      var txt1 string = "Hello!"
      var txt2 string
      txt3 := "你好"  // 非 ASCII 字符

      fmt.Printf("Type: %T, value: %v\n", txt1, txt1)
      fmt.Printf("Type: %T, value: %v\n", txt2, txt2)
      fmt.Printf("Type: %T, value: %v\n", txt3, txt3)
}

    原生类型：内建的基本类型
    Go语言中的字符串以 原生数据类型 出现，使用字符串就像使用其他原生数据类型一样
    Go语言里的字符串的 内部实现使用UTF-8编码。 字符串的值为 双引号 ("....") 中的内容， 可以在 Go 语言的源码中直接添加非 ASCII 码字符

    字符串占用的字节数
内置函数 len 可以计算字符串占用的总字节数
字节: 1 byte = 8 bit (八位二进制表示一个字节)
package main  

import "fmt"  

func main() {    
        /* 内置函数 len */    
        var str string = "hello小飞"
        fmt.Printf("Type: %T, value: %v, len: %v\n", str, str, len(str)) 
        // Type: string, value: hello小飞, len: 11
}

    显然，我们的字符串并没有 11 个字符。因为 UTF-8 编码下一个中文汉字由 3~4 个字节组成

    7. 强制类型转换

    Go只提供了 强制类型转换。该语法只能在 两个类型之间支持相互转换 的时候使用
    强制类型转换的基本语法如下：object_type(expr)

    • object_type 表示目标数据类型

    • expr 表达式包括 变量，复杂的表达式和函数的返回值等

      package main  

import "fmt"  

func main() {  
       var a int8 = 0x7f  
       var b int16 = int16(a) // 不能直接用 int8 的变量赋值给 int16    
       fmt.Println(a)  
       fmt.Println(b)  
}
avatar
文章
阅读
粉丝