go实战基础（一）-go实战运算（二）-《GO开发知识笔记》

2025-11-04 01:16:21 编程来源：ZONE.CI 全球网 0 阅读模式

package main
import "fmt"
func main() {
    /*
        +    相加
        -    相减
        *    相乘
        /    相除
        %    求余=被除数-（被除数/除数）*除数
        1、除法注意：如果运算的数都是整数，那么除后，去掉小数部分，保留整数部分
        2、取余注意  余数=被除数-（被除数/除数）*除数
        3、注意： ++（自增）和--（自减）在Go语言中是单独的语句，并不是运算符。
    */
    // var a = 6
    // var b = 3
    // fmt.Println(a + b)
    // fmt.Println(a - b)
    // fmt.Println(a * b)
    // var c = a * b
    // fmt.Println(c)
    // 1、除法注意：如果运算的数都是整数，那么除后，去掉小数部分，保留整数部分
    // var a = 10
    // var b = 3
    // fmt.Println(a / b) //3
    // var a = 10.0
    // var b = 3.0
    // fmt.Println(a / b) //3.3333333333333335
    // 2、取余注意    余数=被除数-（被除数/除数）*除数
    // var a = 10
    // var b = 3
    // fmt.Println(a % b) //1
    // fmt.Println(-10 % 3) // - 10 - (-10/3)*3  =-1
    // fmt.Println(10 % -3) // 10-(10/-3)*-3=1
    //3、注意： ++（自增）和--（自减）在Go语言中是单独的语句，并不是运算符。
    //1、注意：在 golang 中，++ 和 -- 只能独立使用 错误写法如下：
    /*
        var i int = 8
        var a int
        a = i++ //错误，i++只能独立使用
        a = i-- //错误, i--只能独立使用
        fmt.Ptintln(a)
    */
    //2、注意：在 golang 中没有前++ 错误写法如下：
    // var a = 12
    // ++a  //错误写法
    // fmt.Println(a)
    //3、正确的写法
    var a = 12
    a++
    a--
    fmt.Println(a)
}

//关系运算
package main
import "fmt"
func main() {
    /*
        ==    检查两个值是否相等，如果相等返回 True 否则返回 False。
        !=    检查两个值是否不相等，如果不相等返回 True 否则返回 False。
        >    检查左边值是否大于右边值，如果是返回 True 否则返回 False。
        >=    检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
        <    检查左边值是否小于右边值，如果是返回 True 否则返回 False。
        <=    检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。
    */
    //演示关系运算符的使用
    // var a1 = 9
    // var a2 = 8
    // fmt.Println(a1 == a2) //false
    // fmt.Println(a1 != a2) //true
    // fmt.Println(a1 > a2)  //true
    // fmt.Println(a1 >= a2) //true
    // fmt.Println(a1 < a2)  //flase
    // fmt.Println(a1 <= a2) //flase
    // flag := a1 > a2
    // fmt.Println("flag=", flag)
    // var a1 = 9
    // var a2 = 14
    // flag := a1 > a2
    // if flag {
    //     fmt.Println("a1>a2")
    // }
    var a1 = 9
    var a2 = 8
    if a1 == a2 {
        fmt.Println("a1=a2")
    } else {
        fmt.Println("a1!=a2")
    }
}

//逻辑运算
package main
import "fmt"
//定义一个方法
func test() bool {
    fmt.Println("test...")
    return true
}
func main() {
    /*
        &&    逻辑 AND 运算符。 如果两边的操作数都是 True，则为 True，否则为 False。
        ||    逻辑 OR 运算符。 如果两边的操作数有一个 True，则为 True，否则为 False。
        !    逻辑 NOT 运算符。 如果条件为 True，则为 False，否则为 True。
    */
    // var a = 23
    // var b = 8
    // fmt.Println(a > 10 && b < 10) //true
    // fmt.Println(a > 24 && b < 10) //false
    // fmt.Println(a > 5 && b < 6)   //false
    // fmt.Println(a == 5 && b < 6) //false
    // var a = 23
    // var b = 8
    // fmt.Println(a > 10 || b < 10) //true
    // fmt.Println(a > 24 || b < 10) //true
    // fmt.Println(a > 5 || b < 6)   //true
    // fmt.Println(a == 5 || b < 6)  //false
    // flag := false
    // fmt.Println(!flag)
    //逻辑与和逻辑或短路
    //逻辑与：前面是false后面就不会执行  逻辑或：前面是true后面就不会执行
    /*
        test...
        执行
    */
    // var a = 10
    // if a > 9 && test() {
    //     fmt.Println("执行")
    // }
    /*
        输出：
        空
    */
    // var a = 10
    // if a > 11 && test() {
    //     fmt.Println("执行")
    // }
    /*
        输出：
        test...
        执行
    */
    // var a = 10
    // if a > 11 || test() {
    //     fmt.Println("执行")
    // }
    /*
        输出：执行
    */
    var a = 10
    if a < 11 || test() {
        fmt.Println("执行")
    }
}

//赋值运算
package main
import "fmt"
func main() {
    /*
        =    简单的赋值运算符，将一个表达式的值赋给一个左值
        +=    相加后再赋值
        -=    相减后再赋值
        *=    相乘后再赋值
        /=    相除后再赋值
        %=    求余后再赋值
    */
    // var a = 20
    // a = 21
    // fmt.Println(a)
    // var a = 23 + 2
    // fmt.Println(a)
    // var a = 10
    // b := a
    // fmt.Println(b)
    // var a = 10
    // b := a + 2
    // fmt.Println(b)
    // var a = 10
    // a += 3 // 等价于a=a+3
    // fmt.Println(a)
    // var a = 10
    // a = a + 3
    // fmt.Println(a)
    // var a = 10
    // a -= 3 //a=a-3
    // fmt.Println(a)
    // var a = 10
    // a *= 3 //a=a*3
    // fmt.Println(a)
    // var a = 10
    // a /= 3         // a=a/3
    // fmt.Println(a) //结果：3
    // var a float64 = 10
    // a /= 3         // a=a/3
    // fmt.Println(a) //结果：3.3333333333333335
    var a = 10
    a %= 3         // a=a%3
    fmt.Println(a) //1
}

//位运算符
package main
import "fmt"
func main() {
    /*
        & 两位均为1才为1
        | 两位有一个为1就为1
        ^ 相异或  两位不一样则为1
        <<  左移n位就是乘以2的n次方。  “a<<b”是把a的各二进位全部左移b位，高位丢弃，低位补0。
        >> 右移n位就是除以2的n次方。
    */
    var a = 5 //  101
    var b = 2 //  010
    fmt.Println("a&b=", a&b)   // 000   值0
    fmt.Println("a|b=", a|b)   // 111  值7
    fmt.Println("a^b=", a^b)   // 111  值7
    fmt.Println("a<<b=", a<<b) // 10100  值20   5*2的2次方
    fmt.Println("a>>b=", a>>b) // 值1    5/2的2次方
}

//位运算符
package main
func main() {
    //练习1：有两个变量，a和b，要求将其进行交换，最终打印结果
    // var a = 34
    // var b = 10
    // t := a //t=34
    // a = b  //a=10
    // b = t  //b=34
    // fmt.Printf("a=%v b=%v", a, b)
    //练习2：有两个变量，a和b，要求将其进行交换(不能使用中间变量)，最终打印结果
    // var a = 34
    // var b = 10
    // a = a + b //a=34+10
    // b = a - b //b=34+10-10  34
    // a = a - b //a=(34+10)-(34+10-10)   10
    // fmt.Printf("a=%v b=%v", a, b)
    // 练习3：假如还有100天放假，问：xx个星期零xx天
    // var days = 100
    // var week = days / 7
    // var day = days % 7
    // fmt.Printf("距离放假还有%v周零%v天", week, day)
    /*
     练习4：定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：
     C=(F-32)÷1.8,摄氏温标（°C）和华氏温标（°F），请求出华氏温度对应的摄氏温度
    */
    // var F float32 = 100 //华氏温度
    // C := (F - 32) / 1.8
    // fmt.Printf("华氏温度对应的摄氏温度是%.2f", C)
}

package main
import "fmt"
func main() {
    /*
        Go 语言中 if 条件判断的格式如下：
        if 表达式1 {
            分支 1
        }else if 表达式2 {
            分支 2
        }else{
            分支 3
        }
    */
    //1、最简单的if语句
    // flag := true
    // if flag {
    //     fmt.Println("flag=true")
    // }
    // age := 30
    // if age > 20 {
    //     fmt.Println("成年人")
    // }
    //2、if语句的另一种写法
    // if age := 34; age > 20 {
    //     fmt.Println("成年人")
    // }
    //3、探讨上面两种写法的区别
    // age := 30 //当前区域内是全局变量
    // if age > 20 {
    //     fmt.Println("成年人", age)
    // }
    // fmt.Println(age)
    // if age := 34; age > 20 { //局部变量
    //     fmt.Println("成年人", age)
    // }
    // fmt.Println(age) // undefined: age
    //4、输入一个人的成绩，如果成绩大于等于90输出A，如果小于90大于75输出B,否则输出C
    // var score = 75
    // if score >= 90 {
    //     fmt.Println("A")
    // } else if score > 75 {
    //     fmt.Println("B")
    // } else {
    //     fmt.Println("C")
    // }
    // if score := 85; score >= 90 {
    //     fmt.Println("A")
    // } else if score > 75 {
    //     fmt.Println("B")
    // } else {
    //     fmt.Println("C")
    // }
    //5、if else要注意的细节
    //1、if{}不能省略掉
    // age := 30
    // if age > 20
    //     fmt.Println("成年人")
    //2、 { 必须紧挨着条件
    // var age = 23
    // if age > 20 {
    //     fmt.Println("成年人")
    // } else {
    //     fmt.Println("未成年")
    // }
    //6、求两个数的最大值
    var a = 34
    var b = 65
    var max int
    if a > b {
        max = a
    } else {
        max = b
    }
    fmt.Println("a和b的最大值是", max)
}

package main
func main() {
    /*
        for 初始语句;条件表达式;结束语句{
            循环体语句
        }
    */
    // 1、打印1-10的所有数据
    /*
        for循环的执行流程
            1、i := 1
            2、i <= 10
            3、执行花括号里面的语句
            4、i++
            5、i <= 10
            6、执行花括号里面的语句
            7、i++
            8、i <= 10
    */
    // for i := 1; i <= 10; i++ {
    //     fmt.Println(i)
    // }
    // 2、打印1-10的所有数据    for 循环的初始语句可以被忽略，但是初始语句后的分号必须要写
    // i := 1
    // for ; i <= 10; i++ {
    //     fmt.Println(i)
    // }
    /*
        3、打印1-10的所有数据
        写for循环的时候要注意死循环
        for 条件 {
            循环体语句
        }
        for 循环的初始语句和结束语句都可以省略，例如
    */
    // i := 1
    // for i <= 10 {
    //     fmt.Println(i)
    //     i++
    // }
    /*
        4、打印1-10的所有数据
        for {
            循环体语句
        }
        注意：Go 语言中是没有 while 语句的，我们可以通过 for 代替
    */
    // i := 1
    // for {
    //     if i <= 10 {
    //         fmt.Println(i)
    //     } else {
    //         break //跳出循环
    //     }
    //     i++
    // }
}

package main
import "fmt"
func main() {
    //1、练习：打印 0-50 所有的偶数
    // for i := 0; i <= 50; i++ {
    //     if i%2 == 0 {
    //         fmt.Println(i)
    //     }
    // }
    //2、练习：求 1+2+3+4 +...100 的和
    /*
        sum += sum+1   0+1
        sum += sum+2   0+1+2
        sum += sum+3   0+1+2+3
        sum += sum+4   0+1+2+3+4
    */
    // sum := 0
    // for i := 1; i <= 100; i++ {
    //     sum += i
    // }
    // fmt.Println(sum) //5050
    //3、练习：打印 1~100 之间所有是 9 的倍数的整数的个数及总和
    // var sum = 0
    // var count = 0
    // for i := 1; i <= 100; i++ {
    //     if i%9 == 0 {
    //         fmt.Println(i)
    //         sum += i
    //         count++
    //     }
    // }
    // fmt.Println(sum)
    // fmt.Println(count)
    //4、练习：计算 5 的阶乘 (12345 n 的阶乘 12……n)   1*2*3*4*5
    /*
        1、sum=1*1
        2、sum=sum*2   1*1*2
        3、sum=sum*3   1*1*2*3
        4、sum=sum*4   1*1*2*3*4
        5、sum=sum*5   1*1*2*3*4*5
    */
    // var sum = 1
    // for i := 1; i <= 5; i++ {
    //     sum *= i
    // }
    // fmt.Println(sum)
    //5、练习： 打印一个矩形 (for循环的嵌套)
    /*
    ****
    ****
    ****
     */
    // for i := 1; i <= 12; i++ {
    //     fmt.Print("*")
    //     if i%4 == 0 {
    //         fmt.Println("")
    //     }
    // }
    //6、for循环的嵌套
    /*
        for循环嵌套的一个执行流程
        1、i=0   打印4个*   一个换行
        2、i=1   打印4个*   一个换行
        3、i=2   打印4个*   一个换行
        4、i=3  跳出循环
    */
    // var row = 3
    // var column = 4
    // for i := 0; i < row; i++ {
    //     for j := 0; j < column; j++ {
    //         fmt.Print("*")
    //     }
    //     fmt.Println("")
    // }
    //7、练习： 打印一个三角形
    /*
    *
    **
    ***
    ****
    *****
     */
    // var row = 5
    // for i := 1; i <= row; i++ {
    //     for j := 1; j <= i; j++ {
    //         fmt.Print("*")
    //     }
    //     fmt.Println("")
    // }
    // 8、练习：打印出九九乘法表
    for i := 1; i <= 9; i++ {
        for j := 1; j <= i; j++ {
            fmt.Printf("%v*%v=%v \t", j, i, i*j)
        }
        fmt.Println("")
    }
}

package main
import "fmt"
func main() {
    // var str = "你好golang"
    // for k, v := range str {
    //     fmt.Printf("key=%v val=%c\n", k, v)
    // }
    // var arr = []string{"php", "java", "node", "golang"}
    // for i := 0; i < len(arr); i++ {
    //     fmt.Println(arr[i])
    // }
    var arr = []string{"php", "java", "node", "golang"}
    for _, val := range arr {
        fmt.Println(val)
    }
}

package main
import "fmt"
func main() {
    /*
        switch expression {
        case condition:
        }
    */
    // 练习：判断文件类型,如果后缀名是.html 输入 text/html, 如果后缀名.css 输出 text/css ,如果 后缀名是.js 输出 text/javascript
    // var ext = ".sss"
    // if ext == ".html" {
    //     fmt.Println("text/html")
    // } else if ext == ".css" {
    //     fmt.Println("text/css")
    // } else if ext == ".js" {
    //     fmt.Println("text/javascript")
    // } else {
    //     fmt.Println("找不到此后缀")
    // }
    // 1、switch case的基本使用
    // var extname = ".css"
    // switch extname {
    // case ".html":
    //     fmt.Println("text/html")
    //     break
    // case ".css":
    //     fmt.Println("text/css")
    //     break
    // case ".js":
    //     fmt.Println("text/javascript")
    //     break
    // default:
    //     fmt.Println("找不到此后缀")
    // }
    // 2、switch case的另一种写法
    // switch extname := ".html"; extname {
    // case ".html":
    //     fmt.Println("text/html")
    //     break
    // case ".css":
    //     fmt.Println("text/css")
    //     break
    // case ".js":
    //     fmt.Println("text/javascript")
    //     break
    // default:
    //     fmt.Println("找不到此后缀")
    // }
    // fmt.Println(extname)  //undefined: extname
    // 3、一个分支可以有多个值，多个 case 值中间使用英文逗号分隔
    // 判断一个数是不是偶数
    // var n = 8
    // switch n {
    // case 1, 3, 5, 7, 9:
    //     fmt.Println("奇数")
    //     break //golang中break可以写也可以不写
    // case 2, 4, 6, 8, 10:
    //     fmt.Println("偶数")
    //     break
    // }
    // var score = "D" //ABC及格  D不及格
    // switch score {
    // case "A", "B", "C":
    //     fmt.Println("及格")
    // case "D":
    //     fmt.Println("不及格")
    // }
    //ABC及格  D不及格
    // switch score := "D"; score {
    // case "A", "B", "C":
    //     fmt.Println("及格")
    // case "D":
    //     fmt.Println("不及格")
    // }
    //4、分支还可以使用表达式，这时候 switch 语句后面不需要再跟判断变量。例如 
    // var age = 18
    // switch {
    // case age < 24:
    //     fmt.Println("好好学习")
    // case age >= 24 && age <= 60:
    //     fmt.Println("好好赚钱")
    // case age > 60:
    //     fmt.Println("注意身体")
    // default:
    //     fmt.Println("输入错误")
    // }
    //5、 switch 的穿透 fallthrought
    //fallthrough`语法可以执行满足条件的 case 的下一个 case，是为了兼容 C 语言中的 case 设计 的
    var age = 30
    switch {
    case age < 24:
        fmt.Println("好好学习")
    case age >= 24 && age <= 60:
        fmt.Println("好好赚钱")
        fallthrough
    case age > 60:
        fmt.Println("注意身体")
    default:
        fmt.Println("输入错误")
    }
}

package main
import "fmt"
func main() {
    /*
        Go 语言中 break 语句用于以下几个方面：
            • 用于循环语句中跳出循环，并开始执行循环之后的语句。
            • break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。
            • 在多重循环中，可以用标号 label 标出想 break 的循环。
    */
    //1、表示当i=2的时候跳出当前循环
    // for i := 1; i <= 10; i++ {
    //     if i == 2 {
    //         break
    //     }
    //     fmt.Println(i)
    // }
    // fmt.Println("继续执行")
    /*
        i=0
            i=0 j=0
            i=0 j=1
            i=0 j=2
        i=1
            i=1 j=0
            i=1 j=1
            i=1 j=2
    */
    // for i := 0; i < 2; i++ {
    //     for j := 0; j < 10; j++ {
    //         if j == 3 {
    //             break
    //         }
    //         fmt.Printf("i=%v j=%v\n", i, j)
    //     }
    // }
    //2、 break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。
    // var extname = ".html"
    // switch extname {
    // case ".html":
    //     fmt.Println("text/html")
    //     fmt.Println("text/html")
    //     break
    // case ".css":
    //     fmt.Println("text/css")
    //     break
    // case ".js":
    //     fmt.Println("text/javascript")
    //     break
    // default:
    //     fmt.Println("找不到此后缀")
    // }
    //3、在多重循环中，可以用标号 label 标出想 break 的循环。
    /*
        i=0 j=0
        i=0 j=1
        i=0 j=2
    */
lable1:
    for i := 0; i < 2; i++ {
        for j := 0; j < 10; j++ {
            if j == 3 {
                break lable1
            }
            fmt.Printf("i=%v j=%v\n", i, j)
        }
    }
}

package main
import "fmt"
func main() {
    // continue 语句可以结束当前循环，开始下一次的循环迭代过程，仅限在 for 循环内使用。
    // for i := 1; i <= 10; i++ {
    //     if i == 3 {
    //         continue
    //     }
    //     fmt.Println(i)
    // }
    // 在 continue 语句后添加标签时，表示开始标签对应的循环
    // for i := 0; i < 2; i++ {
    //     for j := 0; j < 10; j++ {
    //         if j == 3 {
    //             continue
    //         }
    //         fmt.Printf("i=%v j=%v\n", i, j)
    //     }
    // }
    /*
       i=0 j=0
       i=0 j=1
       i=0 j=2
       i=1 j=0
       i=1 j=1
       i=1 j=2
    */
lable2:
    for i := 0; i < 2; i++ {
        for j := 0; j < 10; j++ {
            if j == 3 {
                continue lable2
            }
            fmt.Printf("i=%v j=%v\n", i, j)
        }
    }
}

package main
import "fmt"
func main() {
    // goto 语句通过标签进行代码间的无条件跳转。goto 语句可以在快速跳出循环、避免重复退 出上有一定的帮助。Go 语言中使用 goto 语句能简化一些代码的实现过程
    var n = 30
    if n > 24 {
        fmt.Println("成年人")
        goto lable3
    }
    fmt.Println("aaa")
    fmt.Println("bbb")
lable3:
    fmt.Println("ccc")
    fmt.Println("ddd")
}

package main
import "fmt"
func main() {
    //1、数组的长度是类型的一部分
    // var arr1 [3]int
    // var arr2 [4]int
    // var strArr [3]string
    // fmt.Printf("arr1:%T  arr2:%T strArr:%T", arr1, arr2, strArr)
    //2、数组的初始化 第一种方法
    // var arr1 [3]int
    // arr1[0] = 23
    // arr1[1] = 10
    // arr1[2] = 24
    // fmt.Println(arr1)
    // var strArr [3]string
    // strArr[0] = "php"
    // strArr[1] = "java"
    // strArr[2] = "golang"
    // // strArr[3] = "js" //out of bounds for 3-element array
    // fmt.Println(strArr)
    //2、数组的初始化 第二种方法
    // var arr1 = [3]int{23, 34, 5}
    // fmt.Println(arr1)
    // var arr1 = [3]string{"php", "nodejs", "golnag"}
    // fmt.Println(arr1)
    // arr1 := [3]string{"php", "nodejs", "golnag"}
    // fmt.Println(arr1)
    //3、数组的初始化 第三种方法  一般情况下我们可以让编译器 根据初始值的个数自行推断数组的长度
    // var arr1 = [...]int{12, 2324, 32435, 353, 535, 3535}
    // fmt.Println(arr1)
    // fmt.Println(len(arr1)) //len()打印数组的长度
    //注意数组的长度
    // arr1 := [...]string{"php", "nodejs", "golnag", "js"}
    // arr1[4] = "java" //: invalid array index 4 (out of bounds for 4-element array)
    // fmt.Println(arr1)
    //改变数组里面的值
    // arr1 := [...]string{"php", "nodejs", "golnag", "js"}
    // arr1[0] = "phper"
    // fmt.Println(arr1)
    // 4、数组的初始化 第四种方法   我们还可以使用指定索引值的方式来初始化数组
    // arr := [...]int{0: 1, 1: 10, 2: 20, 5: 50}
    // fmt.Println(len(arr)) //6
    // fmt.Println(arr) //[1 10 20 0 0 50]
    //5、数组的循环遍历 for  for range
    // var arr = [3]int{23, 34, 5}
    // for i := 0; i < len(arr); i++ {
    //     fmt.Println(arr[i])
    // }
    // arr1 := [...]string{"php", "nodejs", "golnag", "js"}
    // for i := 0; i < len(arr1); i++ {
    //     fmt.Println(arr1[i])
    // }
    arr1 := [...]string{"php", "nodejs", "golnag", "js"}
    for k, v := range arr1 {
        fmt.Printf("key:%v value:%v\n", k, v)
    }
}

package main
import "fmt"
func main() {
    // 1、请求出一个数组里面元素的和以及这些元素的平均值。分别用for和for-range实现
    // var arr = [...]int{12, 23, 45, 67, 2, 5}
    // var sum = 0
    // for i := 0; i < len(arr); i++ {
    //     sum += arr[i]
    // }
    // fmt.Printf("arr数组元素的和是:%v 平均值：%.2f", sum, float64(sum)/float64(len(arr)))
    /*
        2、请求出一个数组的最大值，并得到对应的下标
                思路
                    1、 声明一个数组 var intArr = [...]int {1, -1, 12, 65, 11}
                    2、假定第一个元素就是最大值，下标就 0
                    3、然后从第二个元素开始循环比较，如果发现有更大，则交换
    */
    // var arr = [...]int{1, -1, 12, 65, 11}
    // var max = arr[0]
    // var index = 0
    // for i := 0; i < len(arr); i++ {
    //     if max < arr[i] {
    //         max = arr[i]
    //         index = i
    //     }
    // }
    // fmt.Printf("最大值:%v  最大值对应的索引值:%v", max, index)
    //3、从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0,3)和(1,2)。
    var arr = [...]int{1, 3, 5, 7, 8}
    for i := 0; i < len(arr); i++ {
        for j := i + 1; j < len(arr); j++ {
            if arr[i]+arr[j] == 8 {
                fmt.Printf("(%v,%v)", i, j)
            }
        }
    }
}

package main
import "fmt"
func main() {
    /*
        值类型 ：改变变量副本值的时候，不会改变变量本身的值
        引用类型：改变变量副本值的时候，会改变变量本身的值
    */
    //值类型:基本数据类型 和 数组都是值类型
    // var a = 10
    // b := a
    // a = 20
    // fmt.Println(a, b)
    // var arr1 = [...]int{1, 2, 3}
    // arr2 := arr1
    // arr1[0] = 11
    // fmt.Println(arr1)
    // fmt.Println(arr2)
    //引用类型: 切片
    // var arr1 = []int{1, 2, 3}
    // arr2 := arr1
    // arr1[0] = 11
    // fmt.Println(arr1)
    // fmt.Println(arr2)
    var arr1 = []int{1, 2, 3, 4}
    arr2 := arr1
    arr2[0] = 111
    fmt.Println(arr1)
    fmt.Println(arr2)
}

package main
import "fmt"
func main() {
    //1、二维数组的定义
    // var arr = [3]int{1, 2, 3}  一维数组
    // var arr = [3][2]string{
    //     {"北京", "上海"},
    //     {"广州", "深圳"},
    //     {"成都", "重庆"},
    // }
    // // fmt.Println(arr[0])
    // fmt.Println(arr[0][1])
    // var arr = [3][2]string{
    //     {"北京", "上海"},
    //     {"广州", "深圳"},
    //     {"成都", "重庆"},
    // }
    // for _, v1 := range arr {
    //     for _, v2 := range v1 {
    //         fmt.Println(v2)
    //     }
    // }
    // var arr = [3][2]string{
    //     {"北京", "上海"},
    //     {"广州", "深圳"},
    //     {"成都", "重庆"},
    // }
    // for i := 0; i < len(arr); i++ {
    //     for j := 0; j < len(arr[i]); j++ {
    //         fmt.Println(arr[i][j])
    //     }
    // }
    //定义二维数组的另一种方式
    var arr = [...][2]string{
        {"北京", "上海"},
        {"广州", "深圳"},
        {"成都", "重庆"},
        {"成都", "重庆"},
        {"成都", "重庆"},
    }
    fmt.Println(arr)
}