1. package main
    3. import (
    4.     "fmt"
    5.     "math"
    6.     "math/rand"
    7.     "time"
    9.     "example.com/go-demo-01/mascot"
    10. )
    12. /*
    13.     函数外的每个语句都必须用var 或者 func 来开头
    14.     但是在函数体内 可以用  := 在类型明确的地方代替 var 赋值
    15.     用 var 时候，初始化值已存在时可以省略类型
    16. */
    17. var c, java, python bool
    18. var i, j int = 0, 1 //初始化值已存在，可以省略类型  或者可以理解成从右值来推导出来
    20. /*
    21.     Go 的基本数据类型--int,uint,uintptr 看机器来定宽度
    22.         bool
    23.         string
    24.         int int8 16 32(rune,表示一个Unicode码点) 64
    25.         unit unit8(byte) 16 32 64
    26.         unitptr
    27.         float32 64  // 没float这个写法
    28.         complex64 complex128
    29. */
    31. func main() {
    32.     /*
    33.         在其他包下的方法名必须大写才能够调用
    34.     */
    35.     fmt.Println(mascot.BestMasco())
    36.     fmt.Println(rand.Intn(10))
    37.     fmt.Println(mascot.Add(10, 20))
    38.     /*
    39.         多值返回
    40.     */
    41.     a, b := mascot.Exchange("hello", "world")
    42.     fmt.Println(a, b)
    43.     fmt.Println(mascot.Split(10))
    44.     fmt.Println(split(20)) //试了一下该包下的方法
    45.     var i int
    46.     var j int = 5
    47.     k := 1
    49.     /*
    50.         强制转换
    51.     */
    52.     var x, y = 3, 4
    53.     var f float64 = 1.32342
    54.     fmt.Println(float64(f)) //
    55.     fmt.Println(math.Sqrt(float64(x*x + y*y)))
    57.     /*
    58.         for 循环
    59.     */
    60.     for i := 0; i < 3; i++ {
    61.         x += i
    62.     }
    63.     fmt.Println("最后的值为：", x)
    64.     /*
    65.         for循环可以缺省
    66.         缺省的值必然在前面有过定义，所以作用域是全局的
    67.     */
    68.     var sum = 1
    69.     for x < 8 {
    70.         sum += x
    71.         x++
    72.     }
    73.     fmt.Println("缺省for循环的值为：", sum)
    74.     /*
    75.         go中的while循环
    76.     */
    77.     for sum < 100 {
    78.         sum += sum
    79.     }
    80.     fmt.Println("while中的sum", sum)
    82.     /*
    83.         无限循环..
    84.     */
    85.     // for{
    87.     // }
    89.     /*
    90.         条件分支
    91.     */
    92.     if sum == 128 {
    93.         fmt.Println("yes,it is 128.")
    94.     }
    95.     /*
    96.         条件分支还能像for一样定义一个临时变量
    97.     */
    98.     if temp := 1; temp < sum {
    99.         fmt.Println(temp + sum)
    100.     }
    102.     /*
    103.         带else的条件分支
    104.     */
    105.     fmt.Println("test",
    106.         pow(3, 2, 10),
    107.         pow(3, 3, 20),
    108.     )
    110.     /*
    111.         牛顿迭代法的题目
    113.     */
    115.     /*
    116.         关于defer 调用栈
    117.     */
    118.     defer fmt.Println(i, c, java, python, j) // defer 最后调用  且能看出 数值类型，布尔类型，字符串类型的默认赋值
    119.     defer fmt.Println(k + k)                 //倒数第二个被调用，且因为k是形参，所以下面的k*3对其不影响
    120.     defer fmt.Println(k * 3)
    122.     // 测试switch
    123.     t := time.Now()
    124.     switch {
    125.     case t.Hour() < 12:
    126.         fmt.Println("Morning")
    127.     case t.Hour() < 18:
    128.         fmt.Println("Afternoon")
    129.     default:
    130.         fmt.Println("Evening")
    131.     }
    132.     /*
    133.         没有条件的switch
    134.     */
    135.     switch {
    136.     case t.Hour() < 12:
    137.         fmt.Println("上午")
    138.     case t.Hour() < 18:
    139.         fmt.Println("下午")
    140.     default:
    141.         fmt.Println("晚上")
    142.     }
    143. }
    145. func split(sum int) (x, y int) {
    146.     x = sum * 2
    147.     y = x - sum
    148.     return
    149. }
    150. func pow(x, n, lim float64) float64 {
    151.     if v := math.Pow(x, n); v < lim {
    152.         return v
    153.     } else {
    154.         fmt.Printf("%g >= %g \n", v, lim) //这个地方为什么不能放到其他
    155.     }
    156.     return lim
    157. }