golang array conversion

Golang array conversion refers to converting an array of one type into an array of another type. Golang provides some built-in functions and methods that can easily implement array conversion.

1. Array type conversion

1. Numeric type array conversion

In Golang, different numerical type arrays can be converted to each other, such as int Type arrays can be converted to float32 or float64 type arrays, and float32 type arrays can be converted to int type arrays. This array type conversion is mainly achieved through type assertions, for example:

var a = [5]int{1, 2, 3, 4, 5}
var b = [5]float64{1.1, 2.2, 3.3, 4.4, 5.5}

// 将a转换为float64类型数组
c := make([]float64, len(a))
for i, v := range a {
    c[i] = float64(v)
}

// 将b转换为int类型数组
d := make([]int, len(b))
for i, v := range b {
    d[i] = int(v)
}

The make() function is used here to create a new array, and each element of the original array is converted to the target array through a loop. Elements. It should be noted that this type conversion can only be performed between numeric types and cannot directly convert a string type array into a numeric type array.

2. String type array conversion

Conversion of string type array is relatively complicated, because the string type does not support type assertion. In Golang, you can use the functions provided by the strconv package to convert a string array into a numeric type array, for example:

var s = [5]string{"1", "2", "3", "4", "5"}

// 将s转换为int类型数组
e := make([]int, len(s))
for i, v := range s {
    e[i], _ = strconv.Atoi(v)
}

// 将s转换为float64类型数组
f := make([]float64, len(s))
for i, v := range s {
    f[i], _ = strconv.ParseFloat(v, 64)
}

Here, the Atoi() and ParseFloat() functions provided by the strconv package are used to convert the string into Numeric type. It should be noted that these functions also have limitations. For example, if the string is not in a legal numeric format, the conversion will fail.

2. Array element conversion

In addition to the overall array type conversion, sometimes it is also necessary to convert a single element in the array. In Golang, you can traverse the array through a for loop and convert the array elements to the target type one by one. For example:

var g = [5]int{1, 2, 3, 4, 5}

// 将g中所有元素转换为float64类型
for i := 0; i < len(g); i++ {
    g[i] = int(float64(g[i]) * 1.5)
}

Here, floating point multiplication is used to multiply the array elements by 1.5, and then the type is cast to int. type. It should be noted that this approach will directly modify the original array. If you need to retain the original array, you can store the elements into a new array one by one. For example:

var h = [5]int{1, 2, 3, 4, 5}

// 将g中所有元素转换为float64类型
j := make([]float64, len(h))
for i, v := range h {
    j[i] = float64(v) * 1.5
}

Here a new array j is created, and each element in g is converted to float64 type, then multiplied by 1.5, and the result is stored in the target array.

Summary:

Array conversion is a common operation in Golang. Conversion between different types of arrays can be achieved through type assertions and type conversions, and arrays can also be traversed through for loops. Convert array elements one by one. It should be noted that the conversion of array elements will directly affect the original array, so you need to pay attention to data security when performing array conversion.

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