Arrays (hier bezogen auf den List-Typ) und ihre Slices sind in Python grundsätzlich gleich, in der Go-Sprache unterscheiden sie sich jedoch stark.
1 Array
Ein Array in der Go-Sprache speichert eine Reihe von Elementen mit fester Länge (kann nicht wachsen oder schrumpfen), festem Typ und kontinuierlichem Speicherort.
1.1 Erstellen
So erstellen Sie Arrays in der Go-Sprache:
arr1 := [5]string{
"a", "b", "c", "d", "e"}
arr2 := [...]string{
"g", "h", "i"} //自动推导出数组长度,省略号不可忽略。如果省略了...,arr2的类型就变成了切片
arr3 := [5]string{
1: "j", 2: "k"} //指定索引为1和2的元素值，其余默认为空
arr4 := [100]int{
} //创建一个保存1到100的整数的数组
for i := 0; i < len(arr4); i++ {
arr4[i] = i + 1
}
//二维数组初始化
arr5 :=[5][2]int{
{
1,2},{
2,3}}
fmt.Println(arr5)
Bei der Deklaration von Arrays sind einige Dinge zu beachten:
- Wenn ein Array erstellt wird, werden Array-Elemente, die nicht mit einem Literal initialisiert werden, auf den Nullwert des Typs initialisiert, in dem das Array gespeichert ist.
- Die Länge des Arrays muss eine Konstante sein und darf keine Variable sein (dies ist dasselbe wie in der Sprache C). Die folgende Schreibweise ist falsch.
a:=[5]int{1,2,3,4,5}
b:=[len(a)]int //编译不通过
1.2 Durchquerung
Range kann zum Durchlaufen von Arrays in der Go-Sprache verwendet werden. Einzelheiten wie folgt:
package main
import (
"fmt"
"strconv"
)
func main() {
arr0 := [3]string{
"hello", "nihao", "dajiahao"}
for i, v := range arr0 {
fmt.Println("数组arr0的第" + strconv.Itoa(i) + "个元素为:" + v)
}
arr1 := [100]int{
} //创建一个保存1到100的整数的数组
for i := 0; i < len(arr1); i++ {
arr1[i] = i + 1
}
sum1 := 0 //计算1+2+3+……+100
//range arr1返回两个数据，第一个为元素索引，对于后续计算无用，用_接收
for _, v := range arr1 {
sum1 += v
}
fmt.Println("1到100的相加总和为：" + strconv.Itoa(sum1))
}
2 Scheiben
Das zugrunde liegende Slice der Go-Sprache wird mithilfe von Arrays implementiert, sodass Slices auch aus mehreren Elementen desselben Typs bestehen. Sie können sich Slices als Ansichten entsprechender Arrays vorstellen.
2.1 Erstellen
Die in der Go-Sprache häufig verwendeten Methoden zur Slice-Erstellung sind wie folgt:
package main
import (
"fmt"
"strconv"
)
func main() {
array := [7]int{
1, 2, 3, 4, 5, 6, 7}
slice0 := array[2:6] //利用数组生成切片
fmt.Println("slice0更改前:", slice0)
slice0[1] = 10
fmt.Println("slice0更改后:", slice0)
fmt.Println("slice0更改后的array:", array)
slice1 := []string{
"a", "b", "c"} //中括号里面不要加...
fmt.Println("切片slice1:", slice1)
slice2 := make([]string, 4, 8) //声明一个长度为4，容量为8的空切片
fmt.Println("切片slice2:", slice2)
fmt.Println("切片slice2,长度为:" + strconv.Itoa(len(slice2)) + ",容量为:" + strconv.Itoa(cap(slice2)))
slice3 := make([]int, 4, 8)
fmt.Println("切片slice3:",slice3)}
Die Ausführungsergebnisse sind wie folgt:
Vor dem Ändern von Slice0: [3 4 5 6]
Nach dem Ändern von Slice0: [3 10 5 6]
Array nach dem Ändern von Slice0: [ 1 2 3 10 5 6 7]
Slice Slice1: [a b c]
Slice Slice2: [ ]
Slice Slice2, Länge ist : 4, Kapazität ist: 8
Slice Slice3: [0 0 0 0]
Hier ein paar Hinweise zum Schneiden:
- Der von einem Array generierte Slice verweist auf denselben Speicherplatz wie das ursprüngliche Array. Wenn also die Daten im Slice geändert werden, wird auch der Wert des zugrunde liegenden Arrays geändert.
- Scheibenlänge und Kapazität sind nicht dasselbe. Die Go-Sprache weist Slice2 einen Speicherplatz mit einer Kapazität von 8 zu, derzeit verfügen jedoch nur 4 Speicherplätze über Elemente („“).
- Die Schleifendurchlaufmethode von Slices ist dieselbe wie die von Arrays und wird hier nicht im Detail beschrieben.
- Wenn die Funktion make() ein Slice deklariert und die Länge angegeben wird, wird der Variablen an der entsprechenden Position der Anfangswert des Typs zugewiesen.
2.2 Funktion anhängen
Ein Slice in der Go-Sprache kann als Array variabler Länge betrachtet werden. Sie können dem Slice über die Append-Funktion Elemente hinzufügen und ein neues Slice zurückgeben .
package main
import "fmt"
func main() {
slice2 := []string{
"2", "3", "3"}
slice3 := make([]string, 4, 8)
fmt.Println("slice3的内存地址：", &slice3[0])
slice4 := []string{
"f", "g"}
slice3 = append(slice3, slice4...)
fmt.Println("slice3的内存地址：", &slice3[0])
slice3 = append(slice3, slice2...)
fmt.Println("slice3的内存地址：", &slice3[0])
fmt.Println(slice3)
}
Die Ausführungsergebnisse sind wie folgt:
Speicheradresse von Slice3: 0xc00011c000
Speicheradresse von Slice3: 0xc00011c000
Speicheradresse von Slice3: 0xc000122000
[ f g 2 3 3]
Dabei sind folgende Punkte zu beachten:
- Der Parameter in append() kann ein einzelnes Zeichen oder ein Slice-Typ sein, aber kein Array.
- Wenn die Kapazität des Slice nicht voll ist und dem Slice ein neues Element hinzugefügt wird, wird das neue Element an das Ende des ursprünglichen Slice-Elements angehängt. Wenn die Slice-Kapazität voll ist, wird ein neuer Speicherplatz geöffnet.
- Wenn mehrere Slices dasselbe zugrunde liegende Array verwenden, ändern sich alle Slice-Variablen entsprechend, solange ein Slice geändert wird.
- Wenn Sie die Append-Funktion aufrufen, weisen Sie normalerweise den Rückgabewert der Funktion der von Ihnen übergebenen Slice-Variablen zu, sodass die beiden Slices nicht dasselbe zugrunde liegende Array verwenden.
Ergänzung 1: Ellipsen…
- Fügen Sie vor dem letzten oder einzigen Parametertyp in der Funktionsdeklaration eine Ellipse hinzu, um anzugeben, dass die Parameter der Funktion variable Länge haben. Gleichzeitig wenn mehrere Elemente in Form von Slices an Parameter variabler Länge übergeben werden müssen, muss nach der Slice-Variablen ein Auslassungszeichen hinzugefügt werden. Hier sind einige Beispiele:
package main
import (
"bufio"
"fmt"
"log"
"os"
"strconv"
"strings"
)
func computer_average(numArray ...int) float64 {
sum := 0
for _, item := range numArray {
sum += item
}
return float64(sum) / float64(len(numArray))
}
func readIntArray(input string) []int {
input = strings.Trim(input, "\n")
inputList := strings.Split(input, " ")
numArray := make([]int, 0, len(inputList))
for _, item := range inputList {
item, err := strconv.Atoi(item)
if err == nil {
numArray = append(numArray, item)
}
}
return numArray
}
func main() {
fmt.Println("输入一个Int型整数:")
reader := bufio.NewReader(os.Stdin)
input, err := reader.ReadString('\n')
if err != nil {
log.Fatal(err)
}
numArray := readIntArray(input)
//computer_average只接收一个参数
fmt.Printf("平均值为：%.2f\n", computer_average(numArray[0]))
fmt.Println("输入多个Int型整数:")
reader = bufio.NewReader(os.Stdin)
input, err = reader.ReadString('\n')
if err != nil {
log.Fatal(err)
}
numArray = readIntArray(input)
//computer_average接收多个参数
fmt.Printf("平均值为：%.2f\n", computer_average(numArray...))
}
Die Ergebnisse der Codeausführung lauten wie folgt:
Wenn numList nur einen Parameter empfängt:
Geben Sie eine Ganzzahl vom Typ Int ein:
12
[12] < /span> Der Durchschnitt ist: 23,00 46 readintarray [12 34] [12 34] 12 34 Geben Sie mehrere Ganzzahlen vom Typ Int ein: Wenn numList nur empfängt Ein Parameter: Der Durchschnittswert beträgt: 12,00 12
readintarray [12]
Ergänzung 2: Arrays/Slices mehrerer Typen empfangen
Wie oben erwähnt, sind die Elementtypen in Slices und Arrays in der Go-Sprache festgelegt, aber wenn dieser Typ eine Schnittstelle istinterface, kann er ein Multityp-Element-A-Slice bilden oder Array bestehend aus. Hier sind einige Beispiele:
func main() {
a := []interface{
}{
1, "hello", 4.5}
fmt.Println(a)
}