golang 数组学习

package main

import (
	"fmt"
	"math"
	"reflect"
)

//将数组传递给函数
//go不允许不同类型之间的混合使用，但是对于常量的类型限制非常少，因此允许常量之间的混合使用

/*
	%g 格式化浮点数 %f输出浮点数 %e输出科学计数表示法

	数字值转换
	a32bitInt = int32(a32Float) 小数点后面的数将被丢弃

	int是根据编译器来确定是int32或int64
*/

func getAverage(arr []float32, size int) float32 {
	var sum float32
	fmt.Println(arr, size)
	for i := 0; i < size; i++ {
		sum += arr[i]
	}
	//这里编译不过 sum / size
	return sum / float32(size)
}

func Uint8FromInt(n int) (uint8, error) {
	if 0 <= n && n <= math.MaxUint8 {
		return uint8(n), nil
	}
	return 0, fmt.Errorf("%d is out of the uint8", n)
}

func IntFromFloat64(x float64) int {
	if math.MinInt32 <= x && x <= math.MaxInt32 {
		whole, fraction := math.Modf(x)
		if fraction >= 0.5 {
			whole++
		}
		return int(whole)
	}
	panic(fmt.Sprintf("%g is out of the int32 range", x))
}

func main() {

	//静态类型声明: 在编译的时候已经知道变量类型
	var x float64
	x = 2.0
	fmt.Printf("x is type of %T\n", x)

	//动态类型声明: 在编译时要求编译器根据传递给她的值来解析变量类型
	y := "hello"
	fmt.Printf("y is type of %T\n", y)

	a, b := 10, 11.2
	//这里我们可以看到动态类型声明后，编译器默认分配的的类型，通常来说区分c语言中的int和float（在go中没有float类型）
	//如果是动态类型的小数和整数，会根据编译器来解析
	//int 		64位 int64    32位 int32
	//float 	64位 float64  32位 float32

	fmt.Printf("type of a is: %v\n", reflect.TypeOf(a))
	fmt.Printf("type of b is: %v\n", reflect.TypeOf(b))
	fmt.Printf("a + b = %g\n", float64(a)+b)

	var n [10]int
	var i, j int
	var balance = []float32{1000.0, 2.0, 63.02, 52.0}
	for i = 0; i < 10; i++ {
		n[i] = i + 100
	}

	for j = 0; j < 10; j++ {
		fmt.Printf("element[%d] = %d\n", j, n[j])
	}

	fmt.Printf("%g\n", getAverage(balance, len(balance)))

	var salary float32
	salary = balance[0]

	fmt.Println(salary)
	fmt.Println(balance)
}