Explore the conversion of golang arrays

In Golang, an array is a collection of elements of the same type. The length of an array is determined when it is created and cannot be changed once determined. Arrays in Golang are value types, so when an array is assigned to a variable, the variable will hold a copy of the entire array. In this article, we will explore array conversion techniques, i.e. how to convert one array to another array.

Basic knowledge of array conversion

In Golang, there are two types of array conversion:

1. Conversion between arrays with the same format but different types (for example : int array and float64 array).

2. Conversion between arrays with different formats and types (for example: int array and string array).

For the first case, array conversion is very simple, just use the type conversion operator to convert an array of one type to an array of another type. For example:

func main() {
    intArr := [3]int{1, 2, 3}
    var floatArr [3]float64

    for i, v := range intArr {
        floatArr[i] = float64(v) //类型转换
    }

    fmt.Println(floatArr) //输出 [1.0 2.0 3.0]
}

The above code converts the int type array intArr to the float64 type array floatArr. You only need to convert the int type to the float64 type.

For the second case, the technical requirements for array conversion are higher. Because it involves converting different data types into different data types. In this case, we need to resort to other transformation techniques, such as slicing, mapping, etc.

1. Slice conversion

Slice is one of the more commonly used data structures in Golang because it can be used as a mutable array. In this case, we can use slicing to convert arrays with different formats. We need to add each array element to a slice and then convert the slice to an array in another format.

func main() {
    intArr := []int{1, 2, 3}
    var floatArr []float64

    for _, v := range intArr {
        floatArr = append(floatArr, float64(v)) //转换并添加到切片中
    }

    fmt.Println(floatArr) //[1.0 2.0 3.0]
    fmt.Println(reflect.TypeOf(floatArr).Kind()) //输出： slice -- 切片类型
}

The above code converts the int type slice intArr to the float64 type slice floatArr. You only need to convert the int type to the float64 type. The append() function is used here to add the converted elements to the slice. Finally, the reflect.TypeOf() function is used to check whether the type of floatArr is slice type.

2. Mapping conversion

In addition to using slices, we can also use mapping (map) for array conversion. This method requires us to define a key-value map, convert each element in the input array into a value in a specified format, and add this key-value pair to the map.

func main() {
    intArr := [3]int{1, 2, 3}
    var floatArr [3]float64

    conversionMap := map[int]float64{
        0: 1.0,
        1: 2.0,
        2: 3.0,
    }

    for i, v := range intArr {
        floatArr[i] = conversionMap[v] //转换并添加到映射中
    }

    fmt.Println(floatArr) //[1.0 2.0 3.0]
}

In the above code, we define a key-value pair mapping conversionMap to map int type array elements to float64 type values. We can then use this mapping to convert the int array to a float64 array. Note that here we only converted the value of the int array, so the length of the int array must be the same as the length of the float64 array.

Summary

In this article, we explored array conversion techniques: conversion between arrays of the same format but different types and conversion between arrays of different formats and types. Among them, the first case is very simple, we only need to use the type conversion operator to convert an array of one type to an array of another type.

For the second case, we introduced two methods: slicing transformation and mapping transformation. When using slices for conversion, we need to add each array element to a slice and then convert the slice to an array in another format. When using mapping for conversion, we need to define a key-value pair mapping, map each element in the input array to a value in a specified format, and add this key-value pair to the mapping.

The above is the detailed content of Explore the conversion of golang arrays. For more information, please follow other related articles on the PHP Chinese website!