blocks|key|272214|text|Go中的所有东西都是通过值传递的，切片也是如此。但是，切片值是一个头部，它描述支持数组的一个连续部分，而一个切片值只包含一个指向实际存储元素的数组的指针。切片值不包括其元素(与数组不同)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|272215|因此，当您将一个切片传递给一个函数时，将从这个标头(包括指针)复制一个副本，该指针将指向相同的支持数组。修改切片的元素意味着修改支持数组的元素，因此所有共享相同支持数组的切片都将“观察”更改。|272216|要查看片头中的内容，请查看reflect.SliceHeader类型：|offset|length|style|CODE|272217|type+SliceHeader+struct+{
++++Data+uintptr
++++Len++int
++++Cap++int
}|code-block|syntax|javascript|272218|见相关/可能重复的问题：函数切片参数与全局变量的性能？|272219|阅读博客文章：Go切片:使用和内部|272220|请注意，当您将切片传递给函数时，如果函数修改了片的“现有”元素，调用方将看到/观察更改。如果函数向切片添加新元素，则需要更改片头(长度最小，但也可能涉及分配一个新的支持数组)，调用方将不会看到(除非返回新的片头)。|272221|不使用映射，因为映射是遮挡下的指针，如果将映射传递给函数，并且函数向映射添加了一个新条目，则映射指针不会更改，因此调用方将在更改后不返回映射就可以看到已更改的映射(新条目)。|272222|关于切片和映射，请参见Go中的地图初始化和为什么切片值有时会过时，但从不映射值？|272223|entityMap|0|LINK|mutability|MUTABLE|url|https://golang.org/pkg/reflect/#SliceHeader|1|https://stackoverflow.com/questions/33995634/are-golang-function-parameter-passed-as-copy-on-write|2|https://blog.golang.org/go-slices-usage-and-internals|3|https://stackoverflow.com/questions/54124439/map-initialization-in-go/54125031#54125031|4|https://stackoverflow.com/questions/55520624/why-slice-values-can-sometimes-go-stale-but-never-map-values/55521138#55521138^0|0|0|D|J|D|J|0|0|0|C|F|1|0|7|A|2|0|0|0|B|9|3|L|J|4|0^^$0|@$1|2|3|4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1F|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1G|8|@$F|1H|G|1I|H|I]]|9|@$F|1J|G|1K|1|1L]]|A|$]]|$1|J|3|K|5|L|7|1M|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1N|8|@]|9|@$F|1O|G|1P|1|1Q]]|A|$]]|$1|Q|3|R|5|6|7|1R|8|@]|9|@$F|1S|G|1T|1|1U]]|A|$]]|$1|S|3|T|5|6|7|1V|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1W|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1X|8|@]|9|@$F|1Y|G|1Z|1|20]|$F|21|G|22|1|23]]|A|$]]|$1|Y|3|-4|5|6|7|24|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]|16|$5|11|12|13|A|$14|17]]|18|$5|11|12|13|A|$14|19]]|1A|$5|11|12|13|A|$14|1B]]|1C|$5|11|12|13|A|$14|1D]]]]

Everything in Go is passed by value, slices too. But a slice value is a header, describing a contiguous section of a backing array, and a slice value only contains a pointer to the array where the elements are actually stored. The slice value does not include its elements (unlike arrays).
So when you pass a slice to a function, a copy will be made from this header, including the pointer, which will point to the same backing array. Modifying the elements of the slice implies modifying the elements of the backing array, and so all slices which share the same backing array will &quot;observe&quot; the change.
To see what's in a slice header, check out the <a href="https://golang.org/pkg/reflect/#SliceHeader" rel="noreferrer"><code>reflect.SliceHeader</code></a> type:
<pre><code>type SliceHeader struct {
 Data uintptr
 Len int
 Cap int
}
</code></pre>
See related / possible duplicate question:
<a href="https://stackoverflow.com/questions/33995634/are-golang-function-parameter-passed-as-copy-on-write">Performance of function slice parameter vs global variable?</a>
Read blog post: <a href="https://blog.golang.org/go-slices-usage-and-internals" rel="noreferrer">Go Slices: usage and internals</a>
Please note that when you pass a slice to a function, if the function modifies the &quot;existing&quot; elements of the slice, the caller will see / observe the changes. If the function adds new elements to the slice, that requires changing the slice header (the length at a minimum, but may also involve allocating a new backing array), which the caller will not see (not without returning the new slice header).
Not with maps, because maps are pointers under the hood, and if you pass a map to a function and the function adds a new entry to the map, the map pointer will not change so the caller will see the changed map (the new entry) without returning the map after change.
Also regarding slices and maps, see <a href="https://stackoverflow.com/questions/54124439/map-initialization-in-go/54125031#54125031">Map initialization in Go</a> and <a href="https://stackoverflow.com/questions/55520624/why-slice-values-can-sometimes-go-stale-but-never-map-values/55521138#55521138">why slice values can sometimes go stale but never map values?</a>

blocks|key|272262|text|当它传递的时候，它是通过指向基础数组的指针传递的，所以切片是一个指向底层数组的小结构。小结构被复制，但仍然指向相同的基础数组。包含片元素的内存块通过“引用”传递。存储容量、元素数和指向元素的指针的片信息三重态通过值传递。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|272263|处理传递到函数的切片的最佳方法(如果将切片的元素操作到函数中，并且我们不希望在元素内存块中反映这一点)是使用copy(s,+*c)将它们复制为：|style|CODE|272264|package+main

import+"fmt"

type+Team+[]Person
type+Person+struct+{
++++Name+string
++++Age++int
}

func+main()+{
++++team+:=+Team{
++++++++Person{"Hasan",+34},+Person{"Karam",+32},
++++}
++++fmt.Printf("original+before+clonning:+%25v\n",+team)
++++team_cloned+:=+team.Clone()
++++fmt.Printf("original+after+clonning:+%25v\n",+team)
++++fmt.Printf("clones+slice:+%25v\n",+team_cloned)
}

func+(c+*Team)+Clone()+Team+{
++++var+s+=+make(Team,+len(*c))
++++copy(s,+*c)
++++for+index,+_+:=+range+s+{
++++++++s[index].Name+=+"change+name"
++++}
++++return+s
}|code-block|syntax|javascript|272265|但是要小心，如果这个切片包含一个sub+slice，那么需要进一步复制，因为我们仍然会让子片元素共享指向相同的内存块元素，一个例子是：|272266|type+Inventories+[]Inventory
type+Inventory+struct+{+//instead+of:+map[string]map[string]Pairs
++++Warehouse+string
++++Item++++++string
++++Batches+++Lots
}
type+Lots+[]Lot
type+Lot+struct+{
++++Date++time.Time
++++Key+++string
++++Value+float64
}

func+main()+{
ins+:=+Inventory{
++++++++Warehouse:+"DMM",
++++++++Item:++++++"Gloves",
++++++++Batches:+Lots{
++++++++++++Lot{mustTime(time.Parse(custom,+"1/7/2020")),+"Jan",+50},
++++++++++++Lot{mustTime(time.Parse(custom,+"2/1/2020")),+"Feb",+70},
++++++++},
++++}

+++inv2+:=+CloneFrom(c+Inventories)
}

func+(i+*Inventories)+CloneFrom(c+Inventories)+{
++++inv+:=+new(Inventories)
++++for+_,+v+:=+range+c+{
++++++++batches+:=+Lots{}
++++++++for+_,+b+:=+range+v.Batches+{
++++++++++++batches+=+append(batches,+Lot{
++++++++++++++++Date:++b.Date,
++++++++++++++++Key:+++b.Key,
++++++++++++++++Value:+b.Value,
++++++++++++})
++++++++}

++++++++*inv+=+append(*inv,+Inventory{
++++++++++++Warehouse:+v.Warehouse,
++++++++++++Item:++++++v.Item,
++++++++++++Batches:+++batches,
++++++++})
++++}
++++(*i).ReplaceBy(inv)
}

func+(i+*Inventories)+ReplaceBy(x+*Inventories)+{
++++*i+=+*x
}|272267|entityMap|0|LINK|mutability|MUTABLE|url|https://blog.golang.org/slices-intro^0|R|2|0|0|1I|B|0|0|G|9|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@$A|13|B|14|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|15|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|16|8|@$A|17|B|18|F|G]]|9|@]|C|$]]|$1|O|3|P|5|J|7|19|8|@]|9|@]|C|$K|L]]|$1|Q|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

Slices when its passed it’s passed with the pointer to underlying array, so a <a href="https://blog.golang.org/slices-intro" rel="nofollow noreferrer">slice</a> is a small structure that points to an underlying array. The small structure is copied, but it still points to the same underlying array. the memory block containing the slice elements is passed by "reference". The slice information triplet holding the capacity, the number of element and the pointer to the elements is passed by value.

The best way to handle slices passing to function (if the elements of the slice are manipulated into the function, and we do not want this to be reflected at the elements memory block is to copy them using <code>copy(s, *c)</code> as:

<pre><code>package main

import "fmt"

type Team []Person
type Person struct {
 Name string
 Age int
}

func main() {
 team := Team{
 Person{"Hasan", 34}, Person{"Karam", 32},
 }
 fmt.Printf("original before clonning: %v\n", team)
 team_cloned := team.Clone()
 fmt.Printf("original after clonning: %v\n", team)
 fmt.Printf("clones slice: %v\n", team_cloned)
}

func (c *Team) Clone() Team {
 var s = make(Team, len(*c))
 copy(s, *c)
 for index, _ := range s {
 s[index].Name = "change name"
 }
 return s
}
</code></pre>

But be careful, if this slice is containing a <code>sub slice</code> further copying is required, as we'll still have the sub slice elements sharing pointing to the same memory block elements, an example is:

<pre class="lang-golang prettyprint-override"><code>type Inventories []Inventory
type Inventory struct { //instead of: map[string]map[string]Pairs
 Warehouse string
 Item string
 Batches Lots
}
type Lots []Lot
type Lot struct {
 Date time.Time
 Key string
 Value float64
}

func main() {
ins := Inventory{
 Warehouse: "DMM",
 Item: "Gloves",
 Batches: Lots{
 Lot{mustTime(time.Parse(custom, "1/7/2020")), "Jan", 50},
 Lot{mustTime(time.Parse(custom, "2/1/2020")), "Feb", 70},
 },
 }

 inv2 := CloneFrom(c Inventories)
}

func (i *Inventories) CloneFrom(c Inventories) {
 inv := new(Inventories)
 for _, v := range c {
 batches := Lots{}
 for _, b := range v.Batches {
 batches = append(batches, Lot{
 Date: b.Date,
 Key: b.Key,
 Value: b.Value,
 })
 }

 *inv = append(*inv, Inventory{
 Warehouse: v.Warehouse,
 Item: v.Item,
 Batches: batches,
 })
 }
 (*i).ReplaceBy(inv)
}

func (i *Inventories) ReplaceBy(x *Inventories) {
 *i = *x
}
</code></pre>

blocks|key|463369|text|你可以在下面找到一个例子。简单地说，切片也是通过值传递的，但是原始的切片和复制的切片被链接到相同的基础数组。如果其中一个切片发生了更改，那么基础数组就会发生变化，那么另一个切片就会发生更改。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|463370|package+main

import+"fmt"

func+main()+{
++++x+:=+[]int{1,+10,+100,+1000}
++++double(x)
++++fmt.Println(x)+//+---->+3+will+print+[2,+20,+200,+2000]+(original+slice+changed)
}

func+double(y+[]int)+{
++++fmt.Println(y)+//+---->+1+will+print+[1,+10,+100,+1000]
++++for+i+:=+0;+i+<+len(y);+i%2B%2B+{
++++++++y[i]+*=+2
++++}
++++fmt.Println(y)+//+---->+2+will+print+[2,+20,+200,+2000]+(copy+slice+%2B+under+array+changed)
}|code-block|syntax|javascript|463371|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can find an example below. Briefly slices is also passed by value but original slice and copied slice are linked to the same underlying array. If one of this slice changes, then underlying array changes, then other slice changes.
<pre><code>package main

import &quot;fmt&quot;

func main() {
 x := []int{1, 10, 100, 1000}
 double(x)
 fmt.Println(x) // ----&gt; 3 will print [2, 20, 200, 2000] (original slice changed)
}

func double(y []int) {
 fmt.Println(y) // ----&gt; 1 will print [1, 10, 100, 1000]
 for i := 0; i &lt; len(y); i++ {
 y[i] *= 2
 }
 fmt.Println(y) // ----&gt; 2 will print [2, 20, 200, 2000] (copy slice + under array changed)
}
</code></pre>

blocks|key|2192115|text|为了补充这篇文章，下面是您共享的Golang+PlayGround的引用传递示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2192116|type+point+struct+{
++++x+int
++++y+int
}

func+main()+{
++++data+:=+[]point{{1,+2},+{3,+4},+{5,+6},+{7,+8}}
++++makeRandomDatas(&data)
}

func+makeRandomDatas(dataPoints+*[]point)+{
++++for+i+:=+0;+i+<+10;+i%2B%2B+{
++++++++if+len(*dataPoints)+>+0+{
++++++++++++fmt.Println(makeRandomData(dataPoints))
++++++++}+else+{
++++++++++++fmt.Println("no+more+elements")
++++++++}
++++}

}

func+makeRandomData(cities+*[]point)+[]point+{
++++solution+:=+[]point{(*cities)[0]}+++++++++++++++++//create+a+new+slice+with+the+first+item+from+the+old+slice
++++*cities+=+append((*cities)[:0],+(*cities)[1:]...)+//remove+the+first+item+from+the+old+slice
++++return+solution

}|code-block|syntax|javascript|2192117|entityMap|0|LINK|mutability|MUTABLE|url|https://play.golang.org/p/mMivoH0TuV^0|G|H|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

To complement this post, here is an example of passing by reference for the <a href="https://play.golang.org/p/mMivoH0TuV" rel="nofollow noreferrer">Golang PlayGround</a> you shared:
<pre><code>type point struct {
 x int
 y int
}

func main() {
 data := []point{{1, 2}, {3, 4}, {5, 6}, {7, 8}}
 makeRandomDatas(&amp;data)
}

func makeRandomDatas(dataPoints *[]point) {
 for i := 0; i &lt; 10; i++ {
 if len(*dataPoints) &gt; 0 {
 fmt.Println(makeRandomData(dataPoints))
 } else {
 fmt.Println(&quot;no more elements&quot;)
 }
 }

}

func makeRandomData(cities *[]point) []point {
 solution := []point{(*cities)[0]} //create a new slice with the first item from the old slice
 *cities = append((*cities)[:0], (*cities)[1:]...) //remove the first item from the old slice
 return solution

}
</code></pre>

blocks|key|272364|text|Slice将使用传递到函数的值，但是我们不应该使用附加值在函数中添加值，而是应该直接使用赋值。原因是附加将创建新的内存并将值复制到该内存中。这是一个例子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|272365|去操场|offset|length|272366|+++++//+Go+program+to+illustrate+how+to
++++++++//+pass+a+slice+to+the+function
++++++++package+main
++++++++
++++++++import+"fmt"
++++++++
++++++++//+Function+in+which+slice
++++++++//+is+passed+by+value
++++++++func+myfun(element+[]string)+{
++++++++
++++++++++++//+Here+we+only+modify+the+slice
++++++++++++//+Using+append+function
++++++++++++//+Here,+this+function+only+modifies
++++++++++++//+the+copy+of+the+slice+present+in
++++++++++++//+the+function+not+the+original+slice
++++++++++++element+=+append(element,+"blackhole")
++++++++++++fmt.Println("Modified+slice:+",+element)
++++++++}
++++++++
++++++++func+main()+{
++++++++
++++++++++++//+Creating+a+slice
++++++++++++slc+:=+[]string{"rocket",+"galaxy",+"stars",+"milkyway"}
++++++++++++fmt.Println("Initial+slice:+",+slc)
++++++++++++//slice+pass+by+value
++++++++++++myfun(slc)
++++++++++++fmt.Println("Final+slice:+",+slc)
++++++++}
Output-
++++Initial+slice:++[rocket+galaxy+stars+milkyway]
++++Modified+slice:++[rocket+galaxy+stars+milkyway+blackhole]
++++Final+slice:++[rocket+galaxy+stars+milkyway]|code-block|syntax|javascript|272367|围棋游乐场|272368|++++//+Go+program+to+illustrate+how+to
++++++++//+pass+a+slice+to+the+function
++++++++package+main
++++++++import+"fmt"
++++++++
++++++++//+Function+in+which+slice
++++++++//+is+passed+by+value
++++++++func+myfun(element+[]string)+{
++++++++
++++++++++++//+Here+we+only+modify+the+slice
++++++++++++//+Using+append+function
++++++++++++//+Here,+this+function+only+modifies
++++++++++++//+the+copy+of+the+slice+present+in
++++++++++++//+the+function+not+the+original+slice
++++++++++++element[0]+=+"Spaceship"
++++++++++++element[4]+=+"blackhole"
++++++++++++element[5]+=+"cosmos"
++++++++++++fmt.Println("Modified+slice:+",+element)
++++++++}
++++++++
++++++++func+main()+{
++++++++
++++++++++++//+Creating+a+slice
++++++++++++slc+:=+[]string{"rocket",+"galaxy",+"stars",+"milkyway",+"",+""}
++++++++++++fmt.Println("Initial+slice:+",+slc)
++++++++++++//slice+pass+by+value
++++++++++++myfun(slc)
++++++++++++fmt.Println("Final+slice:+",+slc)
++++++++}
Output-
++++Initial+slice:++[rocket+galaxy+stars+milkyway++]
++++Modified+slice:++[Spaceship+galaxy+stars+milkyway+blackhole+cosmos]
++++Final+slice:++[Spaceship+galaxy+stars+milkyway+blackhole+cosmos]|272369|entityMap|0|LINK|mutability|MUTABLE|url|https://go.dev/play/p/jIbx8JPu-02|1|https://go.dev/play/p/NsPjjBw9cH_E^0|0|0|3|0|0|0|0|5|1|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@$D|10|E|11|1|12]]|A|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@$D|15|E|16|1|17]]|A|$]]|$1|M|3|N|5|H|7|18|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

Slice will work with pass by value to the function, But we should not use append to add values to slice in the function, instead we should use the assignment directly. Reason being that append will create new memory and copy values to that. Here is the example.
<a href="https://go.dev/play/p/jIbx8JPu-02" rel="nofollow noreferrer">Go playground</a>
<pre><code> // Go program to illustrate how to
 // pass a slice to the function
 package main
 
 import &quot;fmt&quot;
 
 // Function in which slice
 // is passed by value
 func myfun(element []string) {
 
 // Here we only modify the slice
 // Using append function
 // Here, this function only modifies
 // the copy of the slice present in
 // the function not the original slice
 element = append(element, &quot;blackhole&quot;)
 fmt.Println(&quot;Modified slice: &quot;, element)
 }
 
 func main() {
 
 // Creating a slice
 slc := []string{&quot;rocket&quot;, &quot;galaxy&quot;, &quot;stars&quot;, &quot;milkyway&quot;}
 fmt.Println(&quot;Initial slice: &quot;, slc)
 //slice pass by value
 myfun(slc)
 fmt.Println(&quot;Final slice: &quot;, slc)
 }
Output-
 Initial slice: [rocket galaxy stars milkyway]
 Modified slice: [rocket galaxy stars milkyway blackhole]
 Final slice: [rocket galaxy stars milkyway]
</code></pre>
<a href="https://go.dev/play/p/NsPjjBw9cH_E" rel="nofollow noreferrer">Go Playground</a>
<pre><code> // Go program to illustrate how to
 // pass a slice to the function
 package main
 import &quot;fmt&quot;
 
 // Function in which slice
 // is passed by value
 func myfun(element []string) {
 
 // Here we only modify the slice
 // Using append function
 // Here, this function only modifies
 // the copy of the slice present in
 // the function not the original slice
 element[0] = &quot;Spaceship&quot;
 element[4] = &quot;blackhole&quot;
 element[5] = &quot;cosmos&quot;
 fmt.Println(&quot;Modified slice: &quot;, element)
 }
 
 func main() {
 
 // Creating a slice
 slc := []string{&quot;rocket&quot;, &quot;galaxy&quot;, &quot;stars&quot;, &quot;milkyway&quot;, &quot;&quot;, &quot;&quot;}
 fmt.Println(&quot;Initial slice: &quot;, slc)
 //slice pass by value
 myfun(slc)
 fmt.Println(&quot;Final slice: &quot;, slc)
 }
Output-
 Initial slice: [rocket galaxy stars milkyway ]
 Modified slice: [Spaceship galaxy stars milkyway blackhole cosmos]
 Final slice: [Spaceship galaxy stars milkyway blackhole cosmos]
</code></pre>

In Go, I am trying to make a scramble slice function for my traveling salesman problem. While doing this I noticed when I started editing the slice I gave the scramble function was different every time I passed it in.
After some debugging I found out it was due to me editing the slice inside the function. But since Go is supposed to be a &quot;pass by value&quot; language, how is this possible?
<a href="https://play.golang.org/p/mMivoH0TuV" rel="noreferrer">https://play.golang.org/p/mMivoH0TuV</a>
I have provided a playground link to show what I mean.
By removing line 27 you get a different output than leaving it in, this should not make a difference since the function is supposed to make its own copy of the slice when passed in as an argument. 
Can someone explain the phenomenon?

Are slices passed by value?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在Go中，我试图为我的旅行推销员问题做一个混乱的切片函数。在这样做的时候，我注意到当我开始编辑切片时，我给出的扰码函数在每次传入时都是不同的。经过一些调试，我发现这是因为我编辑了函数中的切片。但既然围棋被认为是一种“通过价值传递”的语言，这怎么可能呢？我提供了一个操场链接来展示我的意思。通过删除第27行，您将得到一个与...

问切片是通过值传递的吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问切片是通过值传递的吗？EN