Go 语言程序设计——布尔与数字类型（2）

数值类型

• Go 语言提供了大量的内置类型
• big.Int 类型的整型和 big.Rat 类型的有理数，这些都是大小不限的(只限于机器的内存)
• 每一种数值类型不同，意味着不能在不同类型之间进行二进制运算或者比较操作
• 无类型的数值常量可以兼容表达式中任何（必须内置的）类型的数值
• 如果需要在不同类型间进行数值运算或者比较操作，必须进行类型转换
• 类型转化采用 type(value) 的形式，只要合法，就能转化成功，即使导致数据丢失

整型

• Go 语言提供 11 种类型，包括 5 种有符号和 5 种无符号的，再加上 1 种用户存储指针的整形类型
• 多数情况下，使用 int 类型即可，它可以用于循环计数器、数组、切片索引等，并且该类型的处理速度是最快的
  
  

  11 种整数类型
• 将一个更小类型的整数转换为一个更大类型的整数总是安全的
• Go 语言对 64 位整数的支持让使用大规格的整数进行高精度计算成为可能，可以使在数十亿美元之间的计算还保持足够的精度

大整型

• Go 语言提供了超过了 int64 和 uint64 位的数字的整数类型， big.Int 和 big.Rat 型，只要机器内存足够大，但是处理速度远比内置的整型慢

浮点类型

• Go 语言提供了两种类型的浮点类型和两种类型的复数类型

  
  
  

  浮点类型和复数类型
• 浮点数以近似值表示，用它们来做相等和不相等比较时不能总得到预期的结果

复数类型

• 复数可以使用内置的 complex() 函数或者包含虚部数的常量来创建
• 复数的各部分可以使用内置的 real() 和 imag() 函数来获得，则两个函数返回的都是 float64 型数

例子

package main

import (
    "fmt"
    "log"
    "net/http"
    "sort"
    "strconv"
    "strings"
)

type statistics struct {
    numbers []float64
    mean float64
    median float64
}

const (
    pageTop    = `

Statistics
Computes basic statistics for a given list of numbers
`
    form       = `

Numbers (comma or space-separated):




`
    pageBottom = ``
    anError    = `
%s
`
)

func getStats(numbers []float64) (stats statistics)  {
    stats.numbers = numbers
    sort.Float64s(stats.numbers)
    stats.mean = sum(numbers) / float64(len(numbers))
    stats.median = median(numbers)
    return stats
}

func sum(numbers []float64) (total float64)  {
    for _, x := range numbers {
        total += x
    }
    return total
}

func median(numbers []float64) float64  {
    middle := len(numbers) / 2
    result := numbers[middle]
    if len(numbers) % 2 == 0 {
        result = (result + numbers[middle - 1]) / 2
    }
    return result
}

func homePage(writer http.ResponseWriter, request *http.Request)  {
    err := request.ParseForm()
    fmt.Fprint(writer, pageTop, form)
    if err != nil {
        fmt.Fprintf(writer, anError, err)
    } else {
        if numbers, message, ok := processRequest(request); ok {
            stats := getStats(numbers)
            fmt.Fprint(writer, formatStats(stats))
        } else if message != "" {
            fmt.Fprintf(writer, anError, message)
        }
    }
    fmt.Fprintf(writer, pageBottom)
}

func processRequest(request *http.Request) ([]float64, string, bool)  {
    var numbers [] float64
    if slice, found := request.Form["numbers"]; found && len(slice) > 0 {
        text := strings.Replace(slice[0], ",", " ", -1)
        for _, field := range strings.Fields(text) {
            if x, err := strconv.ParseFloat(field, 64); err != nil {
                return numbers, "'" + field + "' is invalid", false
            } else {
                numbers = append(numbers, x)
            }
        }
    }
    if len(numbers) == 0 {
        return numbers, "", false
    }
    return numbers, "", true
}

func formatStats(stats statistics) string  {
    return fmt.Sprintf(`

        
Results
        
Numbers
%v
        
Count
%d
        
Mean
%f
        
Median
%f
        
`, stats.numbers, len(stats.numbers), stats.mean, stats.median)
}

func main()  {
    http.HandleFunc("/", homePage)
    if err := http.ListenAndServe(":9001", nil); err != nil {
        log.Fatal("failed to start server", err)
    }
}