go语言常见的知识点核心点

Go 语言中的常见数据类型包括：

基本类型
- 整型：int、int8、int16、int32、int64、uint、uint8、uint16、uint32、uint64
- 浮点型：float32、float64
- 复数类型：complex64、complex128
- 字符型：byte（等价于 uint8）、rune（等价于 int32，用于表示 Unicode 字符）
- 布尔型：bool
- 字符串型：string
复合类型
- 数组（array）
- 切片（slice）
- 结构体（struct）
- 指针（pointer）
- 映射（map）
- 通道（chan）
- 接口（interface）
- 函数（function）

每种类型都有其用途和特点。如果你需要某种类型的详细用法或示例，可以告诉我！

Go 语言中的数组是固定长度、同类型元素的集合。定义方式如下：

var arr [5]int // 定义一个长度为5的int数组
arr[0] = 10    // 赋值
fmt.Println(arr[0]) // 访问元素

// 声明并初始化
arr2 := [3]string{"Go", "Python", "Java"}
fmt.Println(arr2)

数组长度是类型的一部分，不能改变。遍历数组可以用 for 循环：

for i, v := range arr2 {
    fmt.Println(i, v)
}

如果需要动态长度，请使用切片（slice）。如需更多数组操作示例，请告知！

go 语言 range

Go 语言中的 range 用于遍历数组、切片、字符串、map、通道等集合类型。常见用法如下：

遍历数组或切片：

nums := []int{1, 2, 3}
for i, v := range nums {
    fmt.Println(i, v) // i是索引，v是元素值
}

遍历字符串（按 Unicode 字符）：

str := "你好Go"
for i, ch := range str {
    fmt.Printf("index=%d, char=%c\n", i, ch)
}

遍历 map：

m := map[string]int{"a": 1, "b": 2}
for k, v := range m {
    fmt.Println(k, v) // k是键，v是值
}

只要值或只要索引时可用 _ 占位：
```
for _, v := range nums { // 只要值
    fmt.Println(v)
}
```
range 是 Go 常用的遍历语法，简洁高效。如需更详细示例或特殊用法请告知！go语言切片

go语言切片

Go 语言中的切片（slice）是动态数组，比数组更灵活。切片可以自动扩容，常用操作如下：

定义切片

var s []int // 声明一个int类型切片
s = append(s, 1, 2, 3) // 添加元素

初始化切片

s := []string{"Go", "Python", "Java"}

从数组创建切片

arr := [5]int{1, 2, 3, 4, 5}
s := arr[1:4] // 包含索引1到3的元素

遍历切片

for i, v := range s {
    fmt.Println(i, v)
}

切片长度和容量
```
fmt.Println(len(s)) // 长度
fmt.Println(cap(s)) // 容量
```
　　切片是 Go 最常用的数据结构之一，适合存储和操作动态数据。如需更多用法或示例请告知！go语言切片和数组的区别
go语言切片和数组的区别
Go 语言切片（slice）和数组（array）的主要区别如下：
1. 长度是否固定
- 数组长度固定，声明后不可变。
- 切片长度可变，可动态添加、删除元素。
1. 定义方式
- 数组：var arr [5]int
- 切片：var s []int 或 s := []int{1,2,3}
1. 内存结构
- 数组是值类型，赋值或传参会复制全部内容。
- 切片是引用类型，赋值或传参只复制引用，指向同一底层数组。
1. 灵活性
- 数组不支持自动扩容。
- 切片支持自动扩容（append），更适合动态数据。
1. 使用场景
- 数组适合存储固定长度的数据。
- 切片适合存储和操作动态长度的数据，是实际开发中更常用的数据结构。
总结：切片更灵活，实际开发中几乎都用切片，数组多用于底层实现或特殊场景。
go语言结构体
Go 语言结构体（struct）是一种复合数据类型，用于将不同类型的数据组合在一起。常用于描述对象或实体。基本用法如下：
1. 定义结构体
```
type Person struct {
    Name string
    Age  int
}
```
1. 创建结构体变量
```
var p Person
p.Name = "张三"
p.Age = 20
```
  1. 结构体字面量初始化
    p2 := Person{Name: "李四", Age: 25}
    1. 结构体指针
      
      p3 := &Person{Name: "王五", Age: 30} fmt.Println(p3.Name)
      
      结构体嵌套
      
      type Student struct { Person Score int }
      
      结构体常用于描述复杂数据和面向对象编程。如需更多示例或高级用法请告知！
      go 语言中的指针
      
      Go 语言中的指针用于存储变量的内存地址，可以实现引用传递。常见用法如下：
      
      定义指针
      
      var p *int // p是一个指向int类型的指针
      
      获取变量地址
      
      a := 10 p = &a // p指向a的地址
      
      通过指针访问和修改值
      
      *p = 20 // 修改a的值为20 fmt.Println(a) // 输出20
      
      指针作为函数参数，实现引用传递
      
      func addOne(x *int) { *x = *x + 1 } addOne(&a) // a变为21
      
      Go 不支持指针运算（如C语言的++p），也没有指针的安全隐患。指针常用于结构体、函数参数等场景，提升性能和灵活性。如需更多示例请告知！
      
      go 语言中的映射
      
      Go 语言中的映射（map）是一种键值对集合，类似于其他语言的字典或哈希表。常用方法如下：
      
      定义和初始化 map
      
      var m map[string]int // 声明 m = make(map[string]int) // 初始化 // 直接初始化 m2 := map[string]int{"a": 1, "b": 2}
      
      添加和访问元素
      
      m["key"] = 100 value := m["key"]
      
      判断键是否存在
      
      v, ok := m["key"] if ok { fmt.Println("存在，值为", v) } else { fmt.Println("不存在") }
      
      删除元素
      
      delete(m, "key")
      
      遍历 map
      
      for k, v := range m { fmt.Println(k, v) }
      
      map 是引用类型，适合存储和查找大量数据。如需更多用法或示例请告知！

posted on 2025-09-12 18:43 漫思阅读(12) 评论(0) 收藏举报

刷新页面返回顶部

漫思

go语言常见的知识点核心点

导航

公告