zoukankan      html  css  js  c++  java
  • Go(1)

    中文文档
    
    https://studygolang.com/pkgdoc
    
    
    hello world
    
    // 必须要有个main包
    package main
    
    // 导入包,必须使用
    import "fmt"
    
    func main() {
       // 变量定义了,必须使用
       // 只是声明,而没有初始化的变量,默认值为0
       // 函数体里的变量名是唯一的,可以使用多次赋值
       var a, b int = 999, 9999
       fmt.Println(a)
       fmt.Printf("%d
    ", b)
    
       // 自动推导类型,必须初始化,通过初始化的值确定类型
       // 此类型的变量不能再新建重名的变量名,只能使用一次,用于初始化那次
       // 同类型只可以赋值同类型的
       c := 10
       fmt.Printf("c type is %T
    ", c)
       c = 99
       fmt.Println(c)
       d := "hello"
       fmt.Printf("d type is %T
    ", d)
    }
    
    匿名变量
    
    func test(a, b, c int) (int, int, int) {
       a, b, c = 1, 2, 3
       return a, b, c
    }
    func main() {
       var temp int
       // 交换两个变量
       i, j := 10, 20
       i, j = j, i
       fmt.Println(i, j)
    
       // _匿名变量,丢弃数据不处理,_匿名变量配合函数返回值使用,才有优势
       temp, _, _ = test(1, 3, 5)
       fmt.Printf("%d", temp)
    }
    
    常量
    
    func main() {
       // 变量声明需要用var
       // 常量是const,不允许修改 但是可以自动推导类型
       const a int = 10
       const b = 10.6
       fmt.Printf("%T
    ", b)
       fmt.Println(b)
    }
    
    多个变量定义
    
    var (
       a int
       b float64
    )
    a, b = 10, 3.14
    
    // 自动推导类型
    const (
       i = 10
       j = 3.14
    )
    
    枚举
    
    func main() {
       // iota常量自动生成器,每行一个,自动累加1
       // iota给常量赋值使用
       const (
          a = iota
          b
          c
       )
       fmt.Printf("%T
    ", a)
       fmt.Printf("a=%d   b=%d   c=%d
    ", a, b, c)
    
       // iota遇到const,重置为0
       const d = iota
       fmt.Printf("d=%d
    ", d)
    
       //如果是同一行,值都一样
       const (
          i          = iota
          j1, j2, j3 = iota, iota, iota
          k          = iota
       )
       fmt.Printf("i=%d
    ", i)
       fmt.Printf("j1=%d  j2=%d  j3=%d
    ", j1, j2, j3)
       fmt.Printf("k=%d
    ", k)
    }
    
    布尔
    
    // 声明变量
    var a bool
    a = true
    fmt.Println("a=", a)
    
    // 自动推导类型
    var b = false
    fmt.Println("b=", b)
    
    c := false
    fmt.Println("c=", c)
    
    
    字符串
    
    str1 := "abcdefg"
    // 字符串长度
    fmt.Println(len(str1))
    
    // 字符
    ch1 := 'a'
    fmt.Println(ch1)
    // 操作字符串的某个字符,从0开始
    fmt.Printf("%c", str1[0])
    
    复数类型
    
    // 复数类型
    var t complex128
    t = 2.1 + 3.14i
    fmt.Println(t)
    
    //自动推导
    t2 := 3.3 + 4.4i
    fmt.Printf("%T
    ", t2)
    
    // 通过内建函数,取实部和虚部
    fmt.Println(real(t2), imag(t2))
    
    格式化输出
    
    a := 10
    b := "a"
    c := 'a'
    d := 3.14
    // 变量所属类型 %T
    fmt.Printf("%T  %T  %T  %T
    ", a, b, c, d)
    // %d 整数
    // %s 字符串
    // %c 字符
    // %f 浮点型
    fmt.Printf("a=%d b=%s c=%c d=%f
    ", a, b, c, d)
    // 自动匹配格式输出 %v
    fmt.Printf("a=%v b=%v c=%v d=%v
    ", a, b, c, d)
    
    
    输入
    
    var a int
    fmt.Println("请输入:")
    fmt.Scan(&a)
    fmt.Println("a=", a)
    
    可转换类型
    
    // 不能转换的类型,叫不兼容类型
    // var flag bool
    // flag = true
    // bool不能转为int型
    // int不能转为bool型
    // fmt.Printf("flag=%d
    ", flag)
    
    // 可转类型
    // 字符本身就是整数型
    var ch byte
    ch = 'a'
    var t int
    t = int(ch)
    fmt.Println(t)
    
    类型别名
    
    // 类型别名 给int64起一个别名bigint
    type bigint int64
    var a bigint
    fmt.Printf("a type is %T
    ", a)
    
    type (
       long int64
       char byte
    )
    var b long = 11
    var ch char ='a'
    fmt.Printf("b type is %T
    ",b)
    fmt.Printf("c type is %T",ch)
    
    
    流程控制
    
    s := 10
    if s == 10 {
       fmt.Println("true")
    }
    // if支持一个初始化语句
    if a := 10; a == 10 {
       fmt.Println("a==10")
    }
    
    
    var num int
    fmt.Println("请输入:")
    fmt.Scan(&num)
    switch num {
    case 1:
       fmt.Println("1")
    case 2:
       fmt.Println("2")
    case 3:
       fmt.Println("3")
    case 4:
       fmt.Println("4")
    default:
       fmt.Println("不在范围")
    }
    
    
    // 支持一个初始化语句
    switch num := 10; num {
    case 1:
       fmt.Println("1")
       fallthrough
    case 2:
       fmt.Println("2")
       fallthrough
    // 多条件满足
    case 3,4,5,6:
       fmt.Println("3")
       fallthrough
    default:
       fmt.Println("不在范围")
    }
    
    // 可以没有条件
    num := 10
    switch {
    case num > 5:
       fmt.Println("1")
    case num < 50:
       fmt.Println("2")
    default:
       fmt.Println("不在范围")
    }
    
    fallthrough
    
    var num int
    fmt.Println("请输入:")
    fmt.Scan(&num)
    // fallthrough 不跳出switch,后面的无条件执行
    switch num {
    case 1:
       fmt.Println("1")
       fallthrough
    case 2:
       fmt.Println("2")
       fallthrough
    case 3:
       fmt.Println("3")
       fallthrough
    case 4:
       fmt.Println("4")
       fallthrough
    default:
       fmt.Println("不在范围")
    }
    
    循环
    
    sum := 0
    // 初始条件;判断条件;条件变化
    for i := 0; i <= 100; i++ {
       sum += i
    }
    fmt.Println(sum)
    
    迭代
    
    str1 := "abc"
    // 传统写法
    for i := 0; i < len(str1); i++ {
       fmt.Printf("str[%d]=%c
    ", i, str1[i])
    }
    // 迭代
    for i, data := range str1 {
       fmt.Printf("str[%d]=%c
    ", i, data)
    }
    // 第二个参数默认丢弃,返回元素的位置下标
    for i, _ := range str1 {
       fmt.Printf("str[%d]=%c
    ", i, str1[i])
    }
    
    跳出循环与中止循环
    
    i := 0
    // 不写任何条件即为无限循环
    for {
       if i == 5 {
          // 跳出循环
          break
          // 跳过本次循环,下一次继续
          //continue
       }
       fmt.Println(i)
       i++
    }
    
    goto
    
        fmt.Println("111111111111111")
       // goto关键字,End是用户起的名字,跳过指定位置执行
       goto End
       fmt.Println("222222222222222")
    End:
       fmt.Println("333333333333333")
  • 相关阅读:
    ASP.NET编程的十大技巧
    C#学习心得(转)
    POJ 1177 Picture (线段树)
    POJ 3067 Japan (树状数组)
    POJ 2828 Buy Tickets (线段树)
    POJ 1195 Mobile phones (二维树状数组)
    HDU 4235 Flowers (线段树)
    POJ 2886 Who Gets the Most Candies? (线段树)
    POJ 2418 Cows (树状数组)
    HDU 4339 Query (线段树)
  • 原文地址:https://www.cnblogs.com/ronle/p/12416747.html
Copyright © 2011-2022 走看看