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)
}