go语言部分函数用法

package main

import (
    "fmt"
    "math/rand"
    "strconv"
    "strings"
    "time"
)

func A1() {

    //变量声明，变量必须用到，不然报错。
    var a,b int

    //常量的定义
    const c int = 10

    //通过键盘赋值
    //&是取地址运算符,空格或回车表示一个输入接收结束
    fmt.Scan(&a,&b)
}

func A2()  {
    a:=1
    b:=2

    //a与b的值交换
    a,b=b,a

    fmt.Println(a)
    fmt.Println(b)
}

func A3()  {
    var a int
    var b string

    //在接收字符串时要使用空格作为分割
    fmt.Scanf("%d%s",&a,&b)
}

func A4()  {

    /*
     * iota枚举格式如果写在一行中值相等
     * 如果换行iota值加一
     */
    const(
        a = iota
        b,c = iota,iota

        /*
         * a = iota
         * b
         * c
         * 只需要对第一个进行赋值，后面会依次增长
         *
         * a = iota
         * b = 10
         * c = 20
         * d
         * e
         * f = iota
         * 在定义枚举的时可以自定义赋值
         *  打印后 a=0, d=20,e=20,f=5
         */
    )

    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

func A5()  {

    var a  float32 = 12.34

    //类型转化,()里是变量
    fmt.Printf("%.2f",float64(a))

}

func A6()  {

    var score int

    //从键盘接收score的值
    fmt.Scan(&score)

    //若score>90打印A
    //若score>80打印B
    //若score>70打印C
    //其他同理，相当与if
    switch  {
    case score>=90:
        fmt.Println("A")
    case score>=80:
        fmt.Println("B")
    case score>=70:
        fmt.Println("C")
    case score>=60:
        fmt.Println("D")
    default:
        fmt.Println("E")
    }
}

func A7()  {

    var a int

    //从键盘接收a的值
    fmt.Scan(&a)

    //a为1，3，5输出“单”，a为2，4输出“双”
    switch a {
    case 1:
        fallthrough//读下一行
    case 3:
        fallthrough//读下一行
    case 5:
        fmt.Println("单")
    case 2:
        fallthrough//读下一行
    default:
        fmt.Println("双")

        //优点
        //if 可以进行区间判断，嵌套使用
        //switch 执行效率高 可以将多个满足相同条件的值放在一起

        //缺点
        //if执行效率低
        //switch 不建议嵌套使用
    }
}


//函数定义
//在整个项目中函数名是唯一的，不能重名
//...不定参，在函数调用时可以传递不定量的参数
//如果不定参函数调用时传递的参数为多个，不定参要写在后面
func A8(arr ...int)  {
    //arr可以通过下标调用，比如arr[0]
    fmt.Println(arr)

    //for 循环的 range 形式可遍历切片或映射。
    //当使用 for 循环遍历切片时，每次迭代都会返回两个值。
    // 第一个值为当前元素的下标，
    // 第二个值为该下标所对应元素的一份副本。
    //可以将下标或值赋予 _ 来忽略它。(例：_,v)
    for i, v := range arr {
        fmt.Printf("下标:%d\t值:%d\n", i, v)
    }

    //不能将不定参名称传递给另一个不定参
    //将arr[0:2]：arr[0],arr[1]
    A8(arr[0:2]...)
}

//定义函数类型，为已存在的数据类型起别名
type NB func()

//函数可以有多个返回值
//调用方还要一一对应接收
//函数的名字表示一个地址，函数在代码区
func A9(A,B int) (a,b int)  {

    //f是func()函数类型定义的变量
    var f func()

    f = A5

    //通过f调用函数
    f()

    return a,b
}

func A10()  {

    a,b:=10,20

    //在函数内部定义一个匿名函数
    //f 函数类型变量 接收函数
    //如果定义匿名函数后在{}后面如果有（）表示函数的调用
    var f func(a,b int)
    f = func(a,b int){
        fmt.Println(a+b)
    }

    f(a,b)
    //相当于 
    /*  func(a,b int){
     *      fmt.Println(a+b)
     *  }(a,b)
     */
}

func A11()  {

    //数组定义
    //定义了10个整形变量的数组元素
    var arr [10]int
    //定义的时候同时赋值
    //var arr [10]int=[10] int{1,2,3,4,5,6,7,8,9,10}

    arr[0]=666

    fmt.Println(arr)
}

func A12()  {

    //创建随机数种子
    rand.Seed(time.Now().UnixNano())

    fmt.Println(rand.Intn(10))//得到0-9之一

    //二位数组定义和赋值
    var arr[2][2] int = [2][2] int {{1,2},{1,2}}

    fmt.Println(arr)
    
}

func A13()  {

    //var 切片名 []数据类型
    //使用切片是不能超过切片的范围 下标越界
    var abc [] int = [] int {1,2,3,4,5,6,7,8,9,10}

    //在定义切片时可以指定长度 make(切片类型，长度)
    //make(数据类型，长度，容量)
    var ab []int = make([]int,10)

    ab1 :=[]int{1,2,3,4}

    //创建空切片 指向内存地址编号为0的空间或<nil>
    var ab2 []int

    //切片截取
    //切片名[起始位置:结束位置+1] 切片名[low:high]
    //ab3:=abc[3:7]
    //或：切片名[起始位置:结束位置+1:容量] 切片名[low:high:max]
    //ab3:=abc[3:7:7]
    //切片名[起始位置:] 从起始位置到结束
    //ab3:=anc[2:]
    //切片名[:结束位置+1] 从开始到结束位置
    //ab3:=anc[2:]
    // 全部
    //ab3:=anc[:]
    //容量=max-low
    ab3:=abc[3:7]

    fmt.Println(ab,ab1,ab2,ab3)

    //切片添加数据
    //当使用append追加数据时，切片地址可能会发生改变
    //没超过容量地址就不会改变
    abc =append(abc,1,2,3,4,5,6)

    //拷贝切片
    // 与“=”不同，因为切片名是地址，
    // “=”之后指向的还是同一片内存
    //拷贝是重新开辟一片内存存放
    //copy()拷贝函数
    s:=make([]int,20)
    copy(s,abc)

    //len()长度截取，cap()容量截取
    fmt.Println(len(abc),cap(abc))
    //建议：以后开发用切片代替数组
}

func A14()  {

    str1:="hello world"
    str2:="llo"
    //查找一个字符串在另一个字符串中是否出现，返回true或false
    b:=strings.Contains(str1,str2)

    //字符串切片
    ab1:=[]string{"1234","4567","7890","abcd"}
    //字符串连接
    ab2:=strings.Join(ab1,",")
    //字符串切割
    ab3:=strings.Split(ab2,",")
    //字符串替换，后面是替换次数，如果小于0，全部替换
    ab4:=strings.Replace(str1,"l","*",-1)
    //去掉字符串头尾内容
    str3:="===*666*==="
    ab5:=strings.Trim(str3,"=")

    //将字符串转换为字符切片 强制类型转换
    ab6:=[]byte(ab2)
    //将其他类型转换为字符串
    b1:=false
    ab7:=strconv.FormatBool(b1)
    //整形进制转换
    ab8:=strconv.FormatInt(123,4)

    //将字符串转换为其他类型,err:错误类型的转换处理
    ab9,err:=strconv.ParseBool("true")

    ab10:=make([]byte,0,1024)
    //将其他类型转换为字符串添加到字符切片里
    ab10=strconv.AppendBool(ab10,false)

    //map[键类型][值类型]


    fmt.Println(b,ab2,ab3,ab4,ab5)
    fmt.Println(ab6,ab7,ab8)
    fmt.Println(ab9,err)
    fmt.Println(string(ab10))


}

type NB1 struct {
    id int
}

//结构体定义在函数外部
//两个结构体比较，是比较所有成员（只能是等于或不等于）
type 结构体名 struct {
    //父结构体
    NB1

    score int
}

func A15()  {

    var abc 结构体名

    //结构体数组|切片
    var ab[] 结构体名 = [] 结构体名{{NB1{1},2},{NB1{10},20}}

    fmt.Println(ab)

    abc.score = 1
}

func A16()  {

    //声明指针变量 默认值为0x0（nil）
    //内存地址编号为0 0-255的空间为系统占用 不允许用户访问(读写)
    var p *int  = nil//开辟一个int类型的指针，但没有内存空间
    fmt.Println(p)
    //new(数据类型)开辟数据类型对应的内存空间 返回值为数据类型指针
    p=new(int)
    fmt.Println(p)
}

//对象不同方法名相同 不会冲突
//func (对象)方法名(参数列表)(返回值列表)  {
//  代码体
//}

func main()  {
    A15()
}