golang slice总结

Byte-Coder2024-04-11 8:07

目录

概述

一、什么是slice

二、slice的声明

三、slice的初始化、创建

make方式创建

创建一个包含指定长度的切片

创建一个指定长度和容量的切片

创建一个空切片

[创建一个长度和容量都为 0 的切片](#创建一个长度和容量都为 0 的切片)

new方式创建

短声明初始化切片

通过一个数组来创建切片

[声明一个 nil 切片](#声明一个 nil 切片)

四、nil切片和空切片的区别

[空切片（Empty Slice）](#空切片（Empty Slice）)

[nil 切片（nil Slice）](#nil 切片（nil Slice）)

共同点

注意事项和易错点

五、常见导致panic的slice操作

索引越界

切片越界

小结

六、slice的相关操作

slice底层数组指针的获取方式

方式1、unsafe.SliceData

方式2、%p

方式3、reflect

slice的长度

slice的容量

slice的遍历

基于索引的遍历

使用range实现遍历

slice的截取

slice的追加

内置append函数

append不扩容的情况

append扩容的情况

append的返回值很重要

slice的拷贝

浅拷贝

深拷贝

内置copy函数

内置copy函数实现深拷贝

内置append函数实现深拷贝

七、slice在函数调用时是header传递

总结

概述

本文主要是对slice的总结，从slice的基本概念、创建方式、常用操作，自己经历过的坑点易错点，以及append的机制，slice的header传递，尽可能用最简单的代码说明问题，本文的代码是基于golang 1.22.1版本验证。

一、什么是slice

切片是用来描述底层数组的连续片段的数据结构，本身并不保存数组数据，而只是保存数组连续片段的描述信息，通过结构体里的array段指针引用底层数组，长度和容量属性限制底层数组的读写片段。

Go 复制代码 
type slice struct { 
    array unsafe.Pointer 
    len int 
    cap int 
}

描述切片的数据结构由指向数组的指针、长度和容量三部分组成：

  • array 指针指向通过slice访问底层数组的的的第一个元素的指针，这里的被指位置不一定是数组的第一个元素，在对slice进行切片操作时，会移动这个指针。
  • len 长度代表切片当前包含的元素数量，len的大小不能超过cap的大小。
  • cap 容量表示底层数组从切片开始位置到数组末尾的元素个数,即当前切片的容量，cap总是大于或者等于len。

为什么指针的类型是 unsafe.Pointer 呢？

这是因为在底层实现中，Go 语言的切片并不直接指向底层数组的数据，而是通过指针间接引用。unsafe.Pointer 类型是 Go 语言中用于处理底层指针的一种特殊类型，它可以指向任意类型的数据，包括未导出的结构体和数组。这种设计的目的是为了支持切片的动态扩展和收缩。当切片需要扩容时，底层的数组可能会被重新分配内存，新的数组可能位于内存的不同位置。使用指针可以更灵活地引用底层数组，而不受具体类型的限制。需要注意的是，由于 unsafe之所以叫unsafe包，是因为这里面的大部分操作绕开里golang的data type system的约束，直接操作内存单元，是比较危险，容易引起程序运行安全的操作，unsafe.Pointer 类型可以指向任意类型的数据，因此在使用时需要特别小心，避免造成内存访问越界或者类型不匹配的问题。通常情况下，开发者应该尽量避免直接使用 unsafe.Pointer，除非是在必要的情况下进行底层操作。

二、slice的声明

Go 复制代码 
var slicename []T //slicevar slicename []T //slice

其中，slicename是切片的变量名，T 是切片中元素的类型 ,注意中括号里并没有数值n。

区分数组的声明

Go 复制代码 
var arrayname [n]T //array

三、slice的初始化、创建

make方式创建

golang提供了内置的函数make创建

Go 复制代码 
func make([]T, len, cap) []T
  • T 表示切片中元素的类型。
  • len 表示切片的长度，即切片中包含的元素个数。
  • cap 表示切片的容量，即底层数组的长度,这个参数可选

make函数调用后，它其实分配了一个T类型的数组， 并返回一个slice指向该数组

创建一个包含指定长度的切片

当cap参数未指定时cap的值与len的值相同

Go 复制代码 
s := make([]int, 5) // 创建一个包含 5 个整数的切片，初始值为对应类型的零值 
//[0 0 0 0 0] cap(s)= 5 len(s)= 5

创建一个指定长度和容量的切片

Go 复制代码 
s := make([]int, 5, 10) // 创建一个包含 5 个整数的切片，并且底层数组的长度为 10 
//[0 0 0 0 0] cap(s)= 10 len(s)= 5

创建一个空切片

Go 复制代码 
s :=make([]int, 0) // 创建一个空切片，长度为 0
//[] cap(s)= 0 len(s)= 0

创建一个长度和容量都为 0 的切片

Go 复制代码 
s := make([]int, 0, 0) // 创建一个长度和容量都为 0 的切片 
//[] cap(s)= 0 len(s)= 0

new方式创建

golang的内置函数new是用来分配内存，并返回指向该类型的零值的指针，而slice本身是一个包含指针、长度和容量的复合类型，使用new来创建slice不是很合适，这种方式还会涉及到unsafe包的使用，它绕过了Go的类型安全，并且需要手动管理内存，这很容易引发错误和内存泄漏。因此，在实际开发中，最好避免使用这种方法，而是使用make函数来创建slice，对于new不展开介绍

短声明初始化切片

Go 复制代码 
s := []int{1, 2, 3, 4, 5} //[1 2 3 4 5] cap(s)= 5 len(s)= 5

通过一个数组来创建切片

Go 复制代码 
arr := [5]int{1, 2, 3, 4, 5}
s := arr[:]
//[1 2 3 4 5]     cap(s)= 5  len(s)= 5

s1 := arr[:]
s2 := arr[0:]
s3 := arr[:5]
// 以上 s s1 s2 s3都是相等的 都是[1 2 3 4 5]

s4 := arr[:0]
//而s4是创建一个空的slice

声明一个 nil 切片

Go 复制代码 
var s []int // 这是一个 nil 切片 //[] cap(s)= 0 len(s)= 0

四、nil切片和空切片的区别

在 Go 中，空切片（empty slice）和 nil 切片（nil slice）是两种不同的概念，

它们有着共同点和某些不同的含义和用途：

空切片（Empty Slice）

  • 空切片是一个长度为 0 的切片，但其底层数组已经被分配了。
  • 可以通过 make 函数创建一个空切片，也可以通过切片字面量 \[\]T{} 创建。
  • 空切片可以被使用，可以进行追加元素、遍历等操作，但不会引发 panic，因为底层数组已经被分配。
  • 通常用于表示一个空的集合或者没有元素的情况。
  • encoding/json编码时空切片会被编码为 JSON 数组 \[\]，表示一个空的数组。当你有一个空的切片时，你期望它在 JSON 中被表示为一个空数组，这与空的集合或序列的语义一致。

示例：

Go 复制代码 
// 使用 make 函数创建空切片
emptySlice := make([]int, 0)

// 使用切片字面量创建空切片
emptySlice2 := []int{}

fmt.Println("emptySlice ", emptySlice, " address of underlying array:", unsafe.SliceData(emptySlice), "\nlen=", len(emptySlice), "\ncap=", cap(emptySlice))
fmt.Println("emptySlice2 ", emptySlice2, " address of underlying array:", unsafe.SliceData(emptySlice2), "\nlen=", len(emptySlice2), "\ncap=", cap(emptySlice2))

运行结果：

nil 切片（nil Slice）

  • nil 切片是一个指向 nil 的切片引用，即没有指向任何底层数组。
  • 一个 nil 切片的长度和容量都是 0，并且它的指针为 nil。
  • 可以将一个切片赋值为 nil，或者声明一个没有初始化的切片，它们都会被视为 nil 切片。
  • encoding/json编码时nil 切片会被编码为 JSON 的 null 值，表示不存在的值。当你有一个 nil 切片时，JSON 编码将把它解释为一个缺失值，这在某些情况下可能会引起问题，特别是在期望一个数组而不是 null 值的情况下

示例：

Go 复制代码 
// 声明一个未初始化的切片，会被初始化为 nil 切片
var nilSlice []int
fmt.Println("nilSlice ", nilSlice, " address of underlying array:", unsafe.SliceData(nilSlice), "\nlen=", len(nilSlice), "\ncap=", cap(nilSlice))

运行结果：

共同点

nil切片和空切片在进行如下操作：len(), cap(), append(), and for .. range loop时的行为和结果都是一致,都不会引发panic，都表示空的集合或序列（有的地方说对nil进行这些操作会引发panic，应该是跟go的版本不同）但是对nil slice的索引还是会抛出panic的，多一嘴：对nil map进行append操作会引发panic

注意事项和易错点

  • 使用空切片和 nil 切片的场景不同，需要根据实际情况进行选择。如果需要表示一个空的集合或者没有元素的情况，应该使用空切片；如果需要表示一个未初始化或者未指定的切片，可以使用 nil 切片。
  • 在函数返回值中，通常使用 nil 切片来表示某些特定条件下的空值。
  • 当需要传递一个切片作为函数参数，并且可能为空时，建议使用 nil 切片而不是空切片，以便明确表明该切片是未初始化的。
  • 在判断切片是否为空时，应该使用 len(slice) == 0 来判断，而不是 slice == nil，因为后者只能用于判断切片是否为 nil。
  • 对于 JSON 编码，需要注意的是:
  • 当你希望表示一个空的切片时，使用空切片 \[\];
  • 当你希望表示一个不存在的切片时，使用nil切片nil。

五、常见导致panic的slice操作

索引越界

当访问slice的元素时，如果使用的索引超出了slice的有效范围（即小于0或大于等于slice的长度）,程序会触发运行时panic，常见的是因为忽略slice或者array的起始索引是0，最后一个是len(slice)-1导致的。

这种panic提示一般是这样的：

panic: runtime error: index out of range ** with length **

Go 复制代码 
fruits := []string{"apple", "orange", "grape"} 
fmt.Println("my favorite fruit is:", fruits[len(fruits)]) 
// panic: runtime error: index out of range [3] with length 3

注意索引index是小于等于len(slice)-1，而不是容量cap(slice)-1

Go 复制代码 
numbers := make([]int, 3, 5) 
numbers[3] = 5 
//panic: runtime error: index out of range [3] with length 3

切片越界

在通过切片操作（slicelow:high）创建新的slice时，如果low或high超出了原slice的界限，也会触发panic。

这样panic提示一般是这样的：

panic: runtime error: slice bounds out of range **

Go 复制代码 
slice := []int{1, 2, 3} 
newSlice := slice[4:] 
// low超出原slice的界限，会触发panic

小结

在某些情况下，对slice的底层数组进行不安全的操作（比如直接修改slice的结构体字段或使用unsafe包进行底层操作），可能会导致slice处于不一致的状态，进而引发panic。这种情况较为罕见，通常发生在底层编程或处理复杂数据结构的场景中，Go语言本身对slice操作有严格的类型检查和边界检查，因此大多数常见的错误在编译时就能被捕获。然而，由于运行时动态分配内存和扩展slice的特性，上述提到的几种情况仍可能导致运行时panic。为了避免这些问题，需要仔细检查slice的索引和切片操作，确保它们始终在有效范围内。

六、slice的相关操作

slice底层数组指针的获取方式

为了调试方面、以及更好地说明slice的操作机制，有时候需要看到slice底层数组的位置

这里有三种方式可提供：

方式1、unsafe.SliceData

golang的标准库src\unsafe\unsafe.go里提供了一个很好的获取slice底层数组地址的函数

Go 复制代码 
s0 := make([]int, 2, 3)
fmt.Println("\n\n", s0, "\n address :", unsafe.SliceData(s0), "\n len:", len(s0), "\n cap:", cap(s0))

输出结果：

方式2、%p

slice是个包含底层数组指针，len,cap的值，是个值，和其他变量一样，获取slice的地址可以用&，同时%p在fmt文档中介绍，也有着特殊的作用，参考fmt的the documentation，可以看到

%p可以打印slice底层数组的第一个元素的地址，也就是slice底层数组的地址

示例：

Go 复制代码 
s0 := make([]int, 2, 3)

fmt.Printf("the address of the 0th element of the slice s0 :%p\n", s0)

输出结果：

方式3、reflect

示例：

Go 复制代码 
s0 := make([]int, 2, 3)

fmt.Printf("underlying array of slice addr=%#v\n", *((*reflect.SliceHeader)(unsafe.Pointer(&s0))))

输出结果：

slice的长度

内置的len函数

示例：

Go 复制代码 
s0 := []int{10, 20, 30, 40, 50}
fmt.Println("length of s0:", len(s0))

运行结果：

slice的容量

内置的cap函数

示例：

Go 复制代码 
s0 := []int{10, 20, 30, 40, 50}
fmt.Println("capcity of s0:", cap(s0))

运行结果：

slice的遍历

基于索引的遍历

Go 复制代码 
s0 := []int{10, 20, 30, 40, 50}

for i := 0; i < len(s0); i++ {
	fmt.Println(i, s0[i])
}

使用range实现遍历

Go 复制代码 
s0 := []int{10, 20, 30, 40, 50}

for index, value := range s0 {
	fmt.Println(index, value)
}

slice的截取

如图，通过对slice的截取运算，并不会重新分配内存片段，而是通过指针的移动实现，新旧切片指向底层数组的指针仍然指向同一个内存片段

示例：

Go 复制代码 
var ptr *int // 声明一个int类型的指针 
fmt.Printf("\n pointer occupy size: %d bytes\n", unsafe.Sizeof(ptr)) 

s0 := []int{10, 20, 30, 40, 50} 
fmt.Println("\n\n", s0, "\n address :", unsafe.SliceData(s0), "\n len:", len(s0), "\n cap:", cap(s0)) 

s1 := s0[2:4] 
fmt.Println("\n\n", s1, "\n address :", unsafe.SliceData(s1), "\n len:", len(s1), "\n cap:", cap(s1))

运行结果：

slice的追加

内置append函数

Go 复制代码 
func append(slice []Type, elems ...Type) []Type
  • slice 是Type类型的目标切片
  • elems 是要追加到切片末尾的元素，也是Type类型
  • append() 函数返回一个新的切片，依然是Type类型，其中包含了原始切片的所有元素以及追加的元素
append不扩容的情况

示例：

Go 复制代码 
s0 := make([]int, 3, 5)

fmt.Println("before append:s0 slice:", s0, " address of of the underlying array:", unsafe.SliceData(s0), " len(s0):", len(s0), "cap(s0):", cap(s0))

s0 = append(s0, 1, 2)

fmt.Println("after append:s0 slice:", s0, " address of of the underlying array:", unsafe.SliceData(s0), " len(s0):", len(s0), "cap(s0):", cap(s0))

运行结果：

追加前后underlying array没有变化，还是指向同一个底层数组

append扩容的情况

示例：

Go 复制代码 
s0 := make([]int, 3, 5)

fmt.Println("before append:s0 slice:", s0, " address of of the underlying array:", unsafe.SliceData(s0), " len(s0)=", len(s0), "cap(s0)=", cap(s0))

s0 = append(s0, 1, 2, 3)

fmt.Println("after append:s0 slice:", s0, " address of of the underlying array:", unsafe.SliceData(s0), " len(s0)=", len(s0), "cap(s0)=", cap(s0))

运行结果：

append的返回值很重要

一个slice传递给append函数，append会接受这个slice的一个副本，然后append内部对这个副本操作，注意这个副本包含了跟原始slice实参同一个底层数组的引用，

  • 如果不扩容，append返回这个副本的值，依然指向同原始slice实参同一个底层数组，容量没变，如果只是更改值，长度不变，如果是追加元素不扩容，则长度会变化，容量不变

  • 如果需要扩容，append函数内部会先算出一个合理的新的容量值，新建一个这个容量值的数组，然后将老元素拷贝到这个数组里，再将新元素追加到这个数组的后面，然后将计算后新的长度和新的容量作为新slice的len和cap，然后将这个新数组的地址作为slice的指针段，然后返回新的slice，之前的副本的slice里的指针被GC收回

  • 注意如果append内部在需要扩容的情况下，不返回这个新的slice，append的操作可能就被阉割隐匿了，是无效的；如果返回了，需要注意的是这个新的切片是否重新赋值给原始的切片变量，如果赋值给一个新的切片变量值，则是两个变量如下面的情况：

    复制代码 
    slice := make([]init,3,5)

slice = append(slice,1,2,3)
//返回给调用者的同一个变量


sliceNew := append(slice,1,2,3)
//返回给新的切片变量

//上面两种情况是两个不同的切片

append扩容依据及实现步骤：

  1. 检测切片容量：切片的扩容与不扩容的依据主要取决于当前切片的长度（len）和容量（cap）以及要追加的元素数量，当向切片追加元素时，如果追加后的长度（len(slice) + 追加元素数量）超过了当前容量（cap(slice)），切片就会发生扩容；如果追加后的长度不超过当前容量，切片就不会发生扩容，而是直接将新元素添加到切片的末尾，然后更新切片长度。
  2. 如果容量不够： 如果切片的容量不足以容纳新元素，append 将会执行扩容操作：
  3. 选择新容量：Go 将根据一定的策略选择一个新的容量。一般来说，新容量会比当前容量大，并且通常会选择一个相对较大的值，以减少后续的扩容次数，现有的选择新容量的依据是：原 slice 的容量小于 1024，则新 slice 的容量将扩大为原来的 2 倍；如果原 slice 的容量大于 1024，则新的 slice 的容量将扩大为原来的 1.25 倍；但不同版本可能会有不同的扩容策略，具体可参考src\runtime\slice.go里的growslice函数
  4. 分配新内存：一旦确定了新的容量，Go 将分配一个新的数组，其长度为新容量，然后将当前切片的所有元素复制到新的数组中，将新元素追加到新数组的末尾。
  5. 更新切片：最后，Go 更新原始切片的指向新数组的指针，并更新切片的长度，
  6. 返回更新后的切片。

注：

由于底层数组的更改，append 操作可能会导致原始切片的引用失效，因此通常情况下，我们会将结果分配给原始切片变量，以确保更新后的切片引用得到正确的处理。

Go 复制代码 
slice =append(slice,10)

直接调用slice =append(slice,10)的时候也许会记得，将结果返回给原始变量，但是append在某个如change函数内部调用，而调用change函数时，往往忘记返回而造成错误，如

Go 复制代码 
func addItemToSlice(s []int) {
	s = append(s, 10)
}

slice的拷贝

浅拷贝

简单地将一个切片赋值给另一个变量并不会创建一个新的、独立的副本。相反，两个变量引用同一个底层数组，这意味着一个切片中的更改会反映在另一个切片中，

如果只是将src slice新赋值给一个新的dst变量，并不会创建一个新的，独立的副本，尽管两个变量都有这个各自的slice header，但是这两个值保存的内容是一样的，所以两个slice的array pointer是一样的，指向了一个底层数组，这种方式，修改一个 slice 的元素会影响到另一个 slice。

示例：

Go 复制代码 
src := []int{10, 20, 30, 40, 50}
dst := src

fmt.Println("src slice:", src, " address of of the underlying array:", unsafe.SliceData(src), " len(src):", len(src), "cap(src):", cap(src))
fmt.Println("dst slice:", dst, " address of of the underlying array:", unsafe.SliceData(dst), " len(dst):", len(dst), "cap(dst):", cap(dst)

运行结果：

深拷贝

深拷贝后源切片和目的切片的指针部分指向了独立的两个underlying array，修改其中一个切片，不会对另一个切片产生影响

内置copy函数

func copy(dst, src \[\]Type) int

  • dst 是目标 slice

  • src 是源 slice

  • Type 是 slice 中元素的类型。

  • int是返回的实际复制的元素

这个函数copy多少元素取决于源切片和目的切片长度的较小的值min(len(dst), len(src))，

如果目标切片为空或nil，则不会进行任何复制，需要注意的反而是src为nil的情况。

示例：

Go 复制代码 
var src []int
dst := make([]int, len(src))

copy(dst, src)
fmt.Println(src == nil, dst == nil) // true false

fmt.Println("src slice:", src, " address of of the underlying array:", unsafe.SliceData(src), " len(src):", len(src), "cap(src):", cap(src))
fmt.Println("dst slice:", dst, " address of of the underlying array:", unsafe.SliceData(dst), " len(dst):", len(dst), "cap(dst):", cap(dst))

运行结果：

想实现src=nil的时候，拷贝后dst=nil

则可以加个判断

Go 复制代码 
var src []int
dst := make([]int, len(src))

if src == nil {
    dst = nil
} else {
	copy(dst, src)
}
fmt.Println(src == nil, dst == nil) // true false
内置copy函数实现深拷贝

我们想用内置copy函数实现深拷贝的话，需要新建目的切片的时候要用dst := make(\[\]int, len(src))这种方式。

示例：

复制代码 
src := []int{10, 20, 30, 40, 50}
dst := make([]int, len(src))

copy(dst, src)

fmt.Println("src slice:", src, " address of of the underlying array:", unsafe.SliceData(src), " len(src):", len(src), "cap(src):", cap(src))
fmt.Println("dst slice:", dst, " address of of the underlying array:", unsafe.SliceData(dst), " len(dst):", len(dst), "cap(dst):", cap(dst))

运行结果：

内置append函数实现深拷贝

示例：

Go 复制代码 
src := []int{10, 20, 30, 40, 50}
dst := append([]int{}, src...)

fmt.Println("src slice:", src, " address of of the underlying array:", unsafe.SliceData(src), " len(src):", len(src), "cap(src):", cap(src))
fmt.Println("dst slice:", dst, " address of of the underlying array:", unsafe.SliceData(dst), " len(dst):", len(dst), "cap(dst):", cap(dst))
}

运行结果

七、slice在函数调用时是header传递

我们平时在开发中遇到的值传递和引用传递的特点是：

  • 值传递的特点是：当使用值传递时，函数会接收参数的副本，而不是参数本身，意味着函数内部对参数的修改不会影响到原始实参的值
  • 引用传递的特点是：函数会接收参数的引用（即内存地址），而不是参数的副本，意味着在函数内部对参数的修改会影响到原始数据

严格意义上将golang的函数传递是值传递，参数在传递给函数时，会复制一份副本传递给函数，只不过有的是普通的变量的副本，有的是包含了指针的变量的副本，而golang语言内部的、自动的、隐式的、引用或者解引用的对调用者不可见，往往给调用者造成困扰。

在我们给slice的函数传递方式定义为值传递或者引用传递之前，不妨先看两个示例：

change示例：

Go 复制代码 
func change(s []int) {
	s[0] = 1
	fmt.Println("in change ", s)
}

func main() {

	s0 := []int{10, 20, 30, 40, 50}

	fmt.Println("before change ", s0)
	change(s0)
	fmt.Println("after chang ", s0)

}

运行结果：

上述的change示例，似乎slice是引用传递的结果，然后再看一个示例：

addItemToSlice示例

Go 复制代码 
func addItemToSlice(s []int) {
	s = append(s, 10)

}

func main() {

	s0 := []int{10, 20, 30, 40, 50}

	fmt.Println("before change ", s0)
	addItemToSlice(s0)
	fmt.Println("after chang ", s0)

}

运行结果：

上述addItemToSlice示例，似乎是值传递的结果

分析：

slice的传递机制是这样的：前面说过slice是一个特殊的结构体

Go 复制代码 
type slice struct {
    array unsafe.Pointer
    len int
    cap int
}

change函数接收了slice s0的一个副本，这个change内部对副本里指向的底层数组里元素更改，然后长度和容量没变化，函数返回，副本回收，原始实参s0的底层数组与副本指向是一样的，所以更改有效了。

addItemToSlice函数接收了slice s0的一个副本，这个addItemToSlice内部调用了append函数，并append函数对s0进行了扩容,新建了一个更大容量的slice,但是这个append并没有将这个新的slice f返回，而传递给addItemToSlice的slice副本，在函数调用完也就被GC回收了，所以更改是无效的。具体解释也可以参考本文章的append返回值很重要这一节对append函数的解释

总结

slice的函数传递时究竟是值传递还是引用传递，都是受限制，从语义上很容易误导，不能只从语义上简单归类于是值传递或者引用传递，否则会造成值传递不更改Slice，引用传递更改slice的错误结论，关键的是append函数是否将新的slice作为返回值返回给调用者，并且注意是否将这个新的切片返回给原来的切片变量，还是返回给了一个新的切片变量。

规避这种误导的最好方式slice在函数传递时是header传递或者是slice header传递，在channel的传递时亦是如此。

相关推荐
kfaino15 分钟前
码农的AI翻身（六）你好，我叫 Parameter
后端·aigc
掘金者阿豪17 分钟前
把业务数据变成共享仪表盘：Metabase可视化与远程访问实践
前端·后端
猪猪拆迁队1 小时前
虚拟工厂仿真引擎的架构设计:让一条产线可编程、可观测、可干预
后端·ai编程
字节跳动数据库2 小时前
文章分享——相似函数处理方法
人工智能·后端·程序员
云技纵横2 小时前
@Transactional 失效的 7 种场景：第 5 种最难排查
后端
用户6757049885022 小时前
你知道 Go 结构体和结构体指针调用的区别吗？一文带你彻底搞懂！
后端·go
程序员cxuan2 小时前
读懂 Claude Code 架构分析系列，第一篇，开始！
人工智能·后端·架构
用户6757049885022 小时前
面试官问“装饰器模式”，这样回答薪资多要 3000！
后端
tntxia2 小时前
Geo Scene域名修改引起的一些问题
后端
用户298698530142 小时前
Java 实现 Word 文档加密与权限解除
java·后端
热门推荐
012026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？022026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？032026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf04飞书长连接_事件订阅（接收消息，审批任务状态变更）05Trae国际版与国内版深度测评：AI原生IDE的双生花06【AI】2026 年具身智能模型和世界模型总结07GitHub 镜像站点08Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析092026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？102026年AI架构实战：彻底解决OpenAI接口超时与封号，Python调用GPT-5.2/Sora2企业级架构详解（附源码+压测报告）