Golang基础语法学习与速成-CSDN博客

本文链接：https://blog.csdn.net/m0_75262255/article/details/141401353

作者：CSDN-PleaSure乐事

欢迎大家阅读我的博客希望大家喜欢

1.golang介绍

1.1介绍

Go（也称为Golang）是由Google开发的一种静态类型、编译型的编程语言。Go的设计目标是简单、高效、易于学习，并且能够解决现代软件工程中遇到的一些常见问题，如并发编程的复杂性。下图就是经典的有关Go的图：

1.2优势

go具有以下优势：

并发支持：Go通过goroutines和channels提供了轻量级的并发机制，使得编写并发程序变得简单直观。
垃圾回收：Go具有自动内存管理功能，这意味着程序员不需要手动管理内存，从而减少了内存泄漏和其他内存相关错误的可能性。
跨平台编译：Go支持在不同的操作系统和架构上编译程序，使得开发者能够在一台机器上为多平台编译程序。

2.语法

需要注意的是，在进行Go语言的编写前，需要导入相应的包，否则编译可能会失败。

2.1控制台输出

Go语言提供了标准库fmt中的Println, Printf 和 Print 函数来输出文本到标准输出流。

package main
import "fmt"
func main() {
    fmt.Println("Hello, world!")
}

2.2算术运算符

Go支持基本的算术运算符，如加法 +、减法 -、乘法 *、除法 / 和取模 %。

package main
import "fmt"
func main() {
    x := 10
    y := 3
    fmt.Println("Addition:", x+y)
    fmt.Println("Subtraction:", x-y)
    fmt.Println("Multiplication:", x*y)
    fmt.Println("Division:", x/y)
    fmt.Println("Modulus:", x%y)
}

2.3变量常量

Go中的变量声明使用 var 关键字，而常量使用 const 关键字。

package main
import "fmt"
func main() {
    var age int = 25
    const name string = "Alice"
    fmt.Println("Name:", name)
    fmt.Println("Age:", age)
}

2.4for循环

Go支持 for 循环，可以用作无限循环、计数循环或迭代数组/切片等。

package main
import "fmt"
func main() {
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
}

2.5if语句

Go中的条件语句使用 if 关键字。

package main
import "fmt"
func main() {
    x := 10
    if x > 0 {
        fmt.Println("x is positive")
    } else {
        fmt.Println("x is not positive")
    }
}

2.6switch语句

Go中的 switch 语句可以用来比较表达式的值或类型。

package main
import "fmt"
func main() {
    x := 1
    switch x {
    case 1:
        fmt.Println("One")
    case 2:
        fmt.Println("Two")
    default:
        fmt.Println("Unknown")
    }
}

2.7作用域

变量的作用域决定了它可以被访问的区域。全局变量在整个程序中可见，局部变量仅在其声明的块中可见。

package main
import "fmt"
func main() {
    var globalVar int = 10
    func() {
        var localVar int = 20
        fmt.Println("Local variable:", localVar)
    }()
    fmt.Println("Global variable:", globalVar)
}

2.8浮点数和零值

2.8.1浮点数

Go中的浮点数有两种类型：float32 和 float64。

2.8.2零值

未初始化的变量默认为零值，对于浮点数来说就是 0.0。

package main
import "fmt"

func main() {
    var f float64
    fmt.Println("Zero value of float64:", f) // 输出 0.0

    f = 3.14
    fmt.Printf("Formatted float: %.2f\n", f) // 输出 3.14
}

2.9格式化动词

使用 fmt.Printf 或 fmt.Sprintf 可以格式化输出。

package main
import "fmt"
func main() {
    f := 3.14159
    fmt.Printf("Formatted float: %.2f\n", f) // 输出 3.14
}

2.10整数和字符串

Go中的整数类型包括 int, int8, int16, int32, int64 以及无符号整数类型 uint, uint8, uint16, uint32, uint64 和 uintptr。

package main
import "fmt"
func main() {
    var i int = 10
    var s string = "Go"
    fmt.Println("Integer:", i)
    fmt.Println("String:", s)
}

2.11字符串字面值和原始字符串

字符串字面值可以用双引号或反引号包围，后者可以包含换行符等特殊字符。

package main
import "fmt"
func main() {
    s := "Hello, world!"
    r := `Hello,
world!`
    fmt.Println("String literal:", s)
    fmt.Println("Raw string:", r)
}

2.12字符

Go中的字符类型为 rune，实际上是一个32位整数，用于表示Unicode字符。

package main
import "fmt"
func main() {
    c := 'A'
    fmt.Printf("Character: %c\n", c)
}

2.13类型别名

类型别名是为现有类型赋予一个新名称。

package main
import "fmt"
type MyInt int
func main() {
    var x MyInt = 10
    fmt.Println("Type alias value:", x)
}

2.14常用内置函数

2.14.1range

range 可以用来迭代数组、切片、字符串或映射。

2.14.2len

len 返回数组、切片、字符串或映射的长度

package main
import "fmt"
func main() {
    s := "hello"
    fmt.Println("Length of string:", len(s))

    for i, char := range s {
        fmt.Printf("Index %d: %c\n", i, char)
    }
}

2.15环绕行为（溢出）

整数运算如果超过了最大值，会从最大值回到最小值。

package main
import "fmt"
func main() {
    var i int8 = 127
    i++
    fmt.Println("Overflowed int8:", i) // 输出 -128
}

2.16布尔类型转换

布尔类型可以与其他类型进行转换。

package main
import "fmt"
func main() {
    var b bool = true
    var i int = boolToInt(b)
    fmt.Println("Converted to int:", i)

    func() {
        var x int = 0
        fmt.Println("Boolean conversion:", x == 0)
    }()
}

func boolToInt(b bool) int {
    if b {
        return 1
    }
    return 0
}

2.17结构体

结构体是一种组合数据类型，可以将不同类型的数据组合在一起。

package main
import "fmt"
type Person struct {
    Name string
    Age  int
}

func main() {
    alice := Person{"Alice", 30}
    fmt.Println("Person:", alice)
}

2.18接口

接口定义了一组方法的集合，任何实现了这些方法的类型都可以实现该接口。

package main
import "fmt"
type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

func printArea(s Shape) {
    fmt.Println("Area:", s.Area())
}

func main() {
    circle := Circle{Radius: 5}
    printArea(circle)
}