1. package main
    3. import "fmt"
    5. func main() {
    7.     /*
    8.         +    相加
    9.         -    相减
    10.         *    相乘
    11.         /    相除
    12.         %    求余=被除数-（被除数/除数）*除数
    14.         1、除法注意：如果运算的数都是整数，那么除后，去掉小数部分，保留整数部分
    15.         2、取余注意  余数=被除数-（被除数/除数）*除数
    16.         3、注意： ++（自增）和--（自减）在Go语言中是单独的语句，并不是运算符。
    17.     */
    19.     // var a = 6
    20.     // var b = 3
    21.     // fmt.Println(a + b)
    22.     // fmt.Println(a - b)
    23.     // fmt.Println(a * b)
    24.     // var c = a * b
    25.     // fmt.Println(c)
    27.     // 1、除法注意：如果运算的数都是整数，那么除后，去掉小数部分，保留整数部分
    29.     // var a = 10
    30.     // var b = 3
    31.     // fmt.Println(a / b) //3
    33.     // var a = 10.0
    34.     // var b = 3.0
    35.     // fmt.Println(a / b) //3.3333333333333335
    37.     // 2、取余注意    余数=被除数-（被除数/除数）*除数
    38.     // var a = 10
    39.     // var b = 3
    40.     // fmt.Println(a % b) //1
    42.     // fmt.Println(-10 % 3) // - 10 - (-10/3)*3  =-1
    44.     // fmt.Println(10 % -3) // 10-(10/-3)*-3=1
    46.     //3、注意： ++（自增）和--（自减）在Go语言中是单独的语句，并不是运算符。
    48.     //1、注意：在 golang 中，++ 和 -- 只能独立使用 错误写法如下：
    50.     /*
    51.         var i int = 8
    52.         var a int
    53.         a = i++ //错误，i++只能独立使用
    54.         a = i-- //错误, i--只能独立使用
    55.         fmt.Ptintln(a)
    56.     */
    58.     //2、注意：在 golang 中没有前++ 错误写法如下：
    60.     // var a = 12
    61.     // ++a  //错误写法
    62.     // fmt.Println(a)
    64.     //3、正确的写法
    66.     var a = 12
    67.     a++
    68.     a--
    69.     fmt.Println(a)
    71. }
    1. //关系运算
    2. package main
    4. import "fmt"
    6. func main() {
    8.     /*
    9.         ==    检查两个值是否相等，如果相等返回 True 否则返回 False。
    10.         !=    检查两个值是否不相等，如果不相等返回 True 否则返回 False。
    11.         >    检查左边值是否大于右边值，如果是返回 True 否则返回 False。
    12.         >=    检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
    13.         <    检查左边值是否小于右边值，如果是返回 True 否则返回 False。
    14.         <=    检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。
    15.     */
    16.     //演示关系运算符的使用
    17.     // var a1 = 9
    18.     // var a2 = 8
    19.     // fmt.Println(a1 == a2) //false
    20.     // fmt.Println(a1 != a2) //true
    21.     // fmt.Println(a1 > a2)  //true
    22.     // fmt.Println(a1 >= a2) //true
    23.     // fmt.Println(a1 < a2)  //flase
    24.     // fmt.Println(a1 <= a2) //flase
    25.     // flag := a1 > a2
    26.     // fmt.Println("flag=", flag)
    28.     // var a1 = 9
    29.     // var a2 = 14
    30.     // flag := a1 > a2
    31.     // if flag {
    32.     //     fmt.Println("a1>a2")
    33.     // }
    35.     var a1 = 9
    36.     var a2 = 8
    38.     if a1 == a2 {
    39.         fmt.Println("a1=a2")
    40.     } else {
    41.         fmt.Println("a1!=a2")
    42.     }
    43. }
    1. //逻辑运算
    2. package main
    4. import "fmt"
    6. //定义一个方法
    7. func test() bool {
    8.     fmt.Println("test...")
    9.     return true
    10. }
    11. func main() {
    13.     /*
    14.         &&    逻辑 AND 运算符。 如果两边的操作数都是 True，则为 True，否则为 False。
    15.         ||    逻辑 OR 运算符。 如果两边的操作数有一个 True，则为 True，否则为 False。
    16.         !    逻辑 NOT 运算符。 如果条件为 True，则为 False，否则为 True。
    17.     */
    19.     // var a = 23
    20.     // var b = 8
    21.     // fmt.Println(a > 10 && b < 10) //true
    22.     // fmt.Println(a > 24 && b < 10) //false
    23.     // fmt.Println(a > 5 && b < 6)   //false
    24.     // fmt.Println(a == 5 && b < 6) //false
    26.     // var a = 23
    27.     // var b = 8
    28.     // fmt.Println(a > 10 || b < 10) //true
    29.     // fmt.Println(a > 24 || b < 10) //true
    30.     // fmt.Println(a > 5 || b < 6)   //true
    31.     // fmt.Println(a == 5 || b < 6)  //false
    33.     // flag := false
    34.     // fmt.Println(!flag)
    36.     //逻辑与和逻辑或短路
    37.     //逻辑与：前面是false后面就不会执行  逻辑或：前面是true后面就不会执行
    39.     /*
    40.         test...
    41.         执行
    42.     */
    43.     // var a = 10
    44.     // if a > 9 && test() {
    45.     //     fmt.Println("执行")
    46.     // }
    48.     /*
    49.         输出：
    50.         空
    51.     */
    52.     // var a = 10
    53.     // if a > 11 && test() {
    54.     //     fmt.Println("执行")
    55.     // }
    57.     /*
    58.         输出：
    59.         test...
    60.         执行
    61.     */
    62.     // var a = 10
    63.     // if a > 11 || test() {
    64.     //     fmt.Println("执行")
    65.     // }
    67.     /*
    68.         输出：执行
    69.     */
    70.     var a = 10
    71.     if a < 11 || test() {
    72.         fmt.Println("执行")
    73.     }
    75. }
    1. //赋值运算
    2. package main
    4. import "fmt"
    6. func main() {
    7.     /*
    8.         =    简单的赋值运算符，将一个表达式的值赋给一个左值
    9.         +=    相加后再赋值
    10.         -=    相减后再赋值
    11.         *=    相乘后再赋值
    12.         /=    相除后再赋值
    13.         %=    求余后再赋值
    14.     */
    16.     // var a = 20
    17.     // a = 21
    18.     // fmt.Println(a)
    20.     // var a = 23 + 2
    21.     // fmt.Println(a)
    23.     // var a = 10
    24.     // b := a
    25.     // fmt.Println(b)
    27.     // var a = 10
    28.     // b := a + 2
    29.     // fmt.Println(b)
    31.     // var a = 10
    32.     // a += 3 // 等价于a=a+3
    33.     // fmt.Println(a)
    35.     // var a = 10
    36.     // a = a + 3
    37.     // fmt.Println(a)
    39.     // var a = 10
    40.     // a -= 3 //a=a-3
    41.     // fmt.Println(a)
    43.     // var a = 10
    44.     // a *= 3 //a=a*3
    45.     // fmt.Println(a)
    47.     // var a = 10
    48.     // a /= 3         // a=a/3
    49.     // fmt.Println(a) //结果：3
    51.     // var a float64 = 10
    52.     // a /= 3         // a=a/3
    53.     // fmt.Println(a) //结果：3.3333333333333335
    55.     var a = 10
    56.     a %= 3         // a=a%3
    57.     fmt.Println(a) //1
    58. }
    1. //位运算符
    2. package main
    4. import "fmt"
    6. func main() {
    7.     /*
    8.         & 两位均为1才为1
    9.         | 两位有一个为1就为1
    10.         ^ 相异或  两位不一样则为1
    11.         <<  左移n位就是乘以2的n次方。  “a<<b”是把a的各二进位全部左移b位，高位丢弃，低位补0。
    12.         >> 右移n位就是除以2的n次方。
    13.     */
    15.     var a = 5 //  101
    16.     var b = 2 //  010
    18.     fmt.Println("a&b=", a&b)   // 000   值0
    19.     fmt.Println("a|b=", a|b)   // 111  值7
    20.     fmt.Println("a^b=", a^b)   // 111  值7
    21.     fmt.Println("a<<b=", a<<b) // 10100  值20   5*2的2次方
    22.     fmt.Println("a>>b=", a>>b) // 值1    5/2的2次方
    24. }
    1. //位运算符
    2. package main
    4. func main() {
    5.     //练习1：有两个变量，a和b，要求将其进行交换，最终打印结果
    7.     // var a = 34
    8.     // var b = 10
    9.     // t := a //t=34
    10.     // a = b  //a=10
    11.     // b = t  //b=34
    12.     // fmt.Printf("a=%v b=%v", a, b)
    14.     //练习2：有两个变量，a和b，要求将其进行交换(不能使用中间变量)，最终打印结果
    16.     // var a = 34
    17.     // var b = 10
    19.     // a = a + b //a=34+10
    20.     // b = a - b //b=34+10-10  34
    21.     // a = a - b //a=(34+10)-(34+10-10)   10
    22.     // fmt.Printf("a=%v b=%v", a, b)
    24.     // 练习3：假如还有100天放假，问：xx个星期零xx天
    26.     // var days = 100
    27.     // var week = days / 7
    28.     // var day = days % 7
    29.     // fmt.Printf("距离放假还有%v周零%v天", week, day)
    31.     /*
    32.      练习4：定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：
    33.      C=(F-32)÷1.8,摄氏温标（°C）和华氏温标（°F），请求出华氏温度对应的摄氏温度
    34.     */
    36.     // var F float32 = 100 //华氏温度
    38.     // C := (F - 32) / 1.8
    40.     // fmt.Printf("华氏温度对应的摄氏温度是%.2f", C)
    42. }
    1. package main
    3. import "fmt"
    5. func main() {
    6.     /*
    7.         Go 语言中 if 条件判断的格式如下：
    8.         if 表达式1 {
    9.             分支 1
    10.         }else if 表达式2 {
    11.             分支 2
    12.         }else{
    13.             分支 3
    14.         }
    15.     */
    17.     //1、最简单的if语句
    19.     // flag := true
    20.     // if flag {
    21.     //     fmt.Println("flag=true")
    22.     // }
    24.     // age := 30
    25.     // if age > 20 {
    26.     //     fmt.Println("成年人")
    27.     // }
    29.     //2、if语句的另一种写法
    31.     // if age := 34; age > 20 {
    32.     //     fmt.Println("成年人")
    33.     // }
    35.     //3、探讨上面两种写法的区别
    37.     // age := 30 //当前区域内是全局变量
    38.     // if age > 20 {
    39.     //     fmt.Println("成年人", age)
    40.     // }
    41.     // fmt.Println(age)
    43.     // if age := 34; age > 20 { //局部变量
    44.     //     fmt.Println("成年人", age)
    45.     // }
    46.     // fmt.Println(age) // undefined: age
    48.     //4、输入一个人的成绩，如果成绩大于等于90输出A，如果小于90大于75输出B,否则输出C
    50.     // var score = 75
    51.     // if score >= 90 {
    52.     //     fmt.Println("A")
    53.     // } else if score > 75 {
    54.     //     fmt.Println("B")
    55.     // } else {
    56.     //     fmt.Println("C")
    57.     // }
    59.     // if score := 85; score >= 90 {
    60.     //     fmt.Println("A")
    61.     // } else if score > 75 {
    62.     //     fmt.Println("B")
    63.     // } else {
    64.     //     fmt.Println("C")
    65.     // }
    67.     //5、if else要注意的细节
    69.     //1、if{}不能省略掉
    70.     // age := 30
    71.     // if age > 20
    72.     //     fmt.Println("成年人")
    74.     //2、 { 必须紧挨着条件
    76.     // var age = 23
    77.     // if age > 20 {
    78.     //     fmt.Println("成年人")
    79.     // } else {
    80.     //     fmt.Println("未成年")
    81.     // }
    83.     //6、求两个数的最大值
    85.     var a = 34
    86.     var b = 65
    87.     var max int
    88.     if a > b {
    89.         max = a
    90.     } else {
    91.         max = b
    92.     }
    93.     fmt.Println("a和b的最大值是", max)
    95. }
    1. package main
    3. func main() {
    5.     /*
    6.         for 初始语句;条件表达式;结束语句{
    7.             循环体语句
    8.         }
    9.     */
    11.     // 1、打印1-10的所有数据
    13.     /*
    14.         for循环的执行流程
    15.             1、i := 1
    16.             2、i <= 10
    17.             3、执行花括号里面的语句
    18.             4、i++
    19.             5、i <= 10
    20.             6、执行花括号里面的语句
    21.             7、i++
    22.             8、i <= 10
    23.     */
    25.     // for i := 1; i <= 10; i++ {
    26.     //     fmt.Println(i)
    27.     // }
    29.     // 2、打印1-10的所有数据    for 循环的初始语句可以被忽略，但是初始语句后的分号必须要写
    31.     // i := 1
    32.     // for ; i <= 10; i++ {
    33.     //     fmt.Println(i)
    34.     // }
    36.     /*
    37.         3、打印1-10的所有数据
    39.         写for循环的时候要注意死循环
    41.         for 条件 {
    42.             循环体语句
    43.         }
    45.         for 循环的初始语句和结束语句都可以省略，例如
    46.     */
    48.     // i := 1
    49.     // for i <= 10 {
    50.     //     fmt.Println(i)
    51.     //     i++
    52.     // }
    54.     /*
    55.         4、打印1-10的所有数据
    57.         for {
    58.             循环体语句
    59.         }
    60.         注意：Go 语言中是没有 while 语句的，我们可以通过 for 代替
    61.     */
    63.     // i := 1
    64.     // for {
    65.     //     if i <= 10 {
    66.     //         fmt.Println(i)
    67.     //     } else {
    68.     //         break //跳出循环
    69.     //     }
    70.     //     i++
    71.     // }
    73. }
    1. package main
    3. import "fmt"
    5. func main() {
    6.     //1、练习：打印 0-50 所有的偶数
    8.     // for i := 0; i <= 50; i++ {
    9.     //     if i%2 == 0 {
    10.     //         fmt.Println(i)
    11.     //     }
    12.     // }
    14.     //2、练习：求 1+2+3+4 +...100 的和
    15.     /*
    16.         sum += sum+1   0+1
    18.         sum += sum+2   0+1+2
    20.         sum += sum+3   0+1+2+3
    22.         sum += sum+4   0+1+2+3+4
    23.     */
    25.     // sum := 0
    26.     // for i := 1; i <= 100; i++ {
    27.     //     sum += i
    28.     // }
    29.     // fmt.Println(sum) //5050
    31.     //3、练习：打印 1~100 之间所有是 9 的倍数的整数的个数及总和
    33.     // var sum = 0
    34.     // var count = 0
    35.     // for i := 1; i <= 100; i++ {
    36.     //     if i%9 == 0 {
    37.     //         fmt.Println(i)
    38.     //         sum += i
    39.     //         count++
    40.     //     }
    41.     // }
    43.     // fmt.Println(sum)
    44.     // fmt.Println(count)
    46.     //4、练习：计算 5 的阶乘 (12345 n 的阶乘 12……n)   1*2*3*4*5
    48.     /*
    49.         1、sum=1*1
    50.         2、sum=sum*2   1*1*2
    51.         3、sum=sum*3   1*1*2*3
    52.         4、sum=sum*4   1*1*2*3*4
    53.         5、sum=sum*5   1*1*2*3*4*5
    54.     */
    56.     // var sum = 1
    57.     // for i := 1; i <= 5; i++ {
    58.     //     sum *= i
    59.     // }
    60.     // fmt.Println(sum)
    62.     //5、练习： 打印一个矩形 (for循环的嵌套)
    64.     /*
    66.     ****
    67.     ****
    68.     ****
    70.      */
    72.     // for i := 1; i <= 12; i++ {
    73.     //     fmt.Print("*")
    74.     //     if i%4 == 0 {
    75.     //         fmt.Println("")
    76.     //     }
    77.     // }
    79.     //6、for循环的嵌套
    81.     /*
    82.         for循环嵌套的一个执行流程
    83.         1、i=0   打印4个*   一个换行
    84.         2、i=1   打印4个*   一个换行
    85.         3、i=2   打印4个*   一个换行
    86.         4、i=3  跳出循环
    87.     */
    89.     // var row = 3
    90.     // var column = 4
    91.     // for i := 0; i < row; i++ {
    92.     //     for j := 0; j < column; j++ {
    93.     //         fmt.Print("*")
    94.     //     }
    95.     //     fmt.Println("")
    96.     // }
    98.     //7、练习： 打印一个三角形
    99.     /*
    101.     *
    102.     **
    103.     ***
    104.     ****
    105.     *****
    107.      */
    109.     // var row = 5
    110.     // for i := 1; i <= row; i++ {
    111.     //     for j := 1; j <= i; j++ {
    112.     //         fmt.Print("*")
    113.     //     }
    114.     //     fmt.Println("")
    115.     // }
    117.     // 8、练习：打印出九九乘法表
    119.     for i := 1; i <= 9; i++ {
    120.         for j := 1; j <= i; j++ {
    121.             fmt.Printf("%v*%v=%v \t", j, i, i*j)
    122.         }
    123.         fmt.Println("")
    124.     }
    126. }
    1. package main
    3. import "fmt"
    5. func main() {
    7.     // var str = "你好golang"
    8.     // for k, v := range str {
    9.     //     fmt.Printf("key=%v val=%c\n", k, v)
    10.     // }
    12.     // var arr = []string{"php", "java", "node", "golang"}
    13.     // for i := 0; i < len(arr); i++ {
    14.     //     fmt.Println(arr[i])
    15.     // }
    17.     var arr = []string{"php", "java", "node", "golang"}
    19.     for _, val := range arr {
    21.         fmt.Println(val)
    22.     }
    24. }
    1. package main
    3. import "fmt"
    5. func main() {
    7.     /*
    9.         switch expression {
    10.         case condition:
    13.         }
    14.     */
    16.     // 练习：判断文件类型,如果后缀名是.html 输入 text/html, 如果后缀名.css 输出 text/css ,如果 后缀名是.js 输出 text/javascript
    18.     // var ext = ".sss"
    19.     // if ext == ".html" {
    20.     //     fmt.Println("text/html")
    21.     // } else if ext == ".css" {
    22.     //     fmt.Println("text/css")
    23.     // } else if ext == ".js" {
    24.     //     fmt.Println("text/javascript")
    25.     // } else {
    26.     //     fmt.Println("找不到此后缀")
    27.     // }
    29.     // 1、switch case的基本使用
    30.     // var extname = ".css"
    31.     // switch extname {
    32.     // case ".html":
    33.     //     fmt.Println("text/html")
    34.     //     break
    35.     // case ".css":
    36.     //     fmt.Println("text/css")
    37.     //     break
    38.     // case ".js":
    39.     //     fmt.Println("text/javascript")
    40.     //     break
    41.     // default:
    42.     //     fmt.Println("找不到此后缀")
    43.     // }
    45.     // 2、switch case的另一种写法
    47.     // switch extname := ".html"; extname {
    48.     // case ".html":
    49.     //     fmt.Println("text/html")
    50.     //     break
    51.     // case ".css":
    52.     //     fmt.Println("text/css")
    53.     //     break
    54.     // case ".js":
    55.     //     fmt.Println("text/javascript")
    56.     //     break
    57.     // default:
    58.     //     fmt.Println("找不到此后缀")
    59.     // }
    60.     // fmt.Println(extname)  //undefined: extname
    62.     // 3、一个分支可以有多个值，多个 case 值中间使用英文逗号分隔
    64.     // 判断一个数是不是偶数
    66.     // var n = 8
    67.     // switch n {
    68.     // case 1, 3, 5, 7, 9:
    69.     //     fmt.Println("奇数")
    70.     //     break //golang中break可以写也可以不写
    71.     // case 2, 4, 6, 8, 10:
    72.     //     fmt.Println("偶数")
    73.     //     break
    74.     // }
    76.     // var score = "D" //ABC及格  D不及格
    77.     // switch score {
    78.     // case "A", "B", "C":
    79.     //     fmt.Println("及格")
    80.     // case "D":
    81.     //     fmt.Println("不及格")
    82.     // }
    84.     //ABC及格  D不及格
    85.     // switch score := "D"; score {
    86.     // case "A", "B", "C":
    87.     //     fmt.Println("及格")
    88.     // case "D":
    89.     //     fmt.Println("不及格")
    90.     // }
    92.     //4、分支还可以使用表达式，这时候 switch 语句后面不需要再跟判断变量。例如 
    94.     // var age = 18
    95.     // switch {
    96.     // case age < 24:
    97.     //     fmt.Println("好好学习")
    98.     // case age >= 24 && age <= 60:
    99.     //     fmt.Println("好好赚钱")
    100.     // case age > 60:
    101.     //     fmt.Println("注意身体")
    102.     // default:
    103.     //     fmt.Println("输入错误")
    104.     // }
    106.     //5、 switch 的穿透 fallthrought
    108.     //fallthrough`语法可以执行满足条件的 case 的下一个 case，是为了兼容 C 语言中的 case 设计 的
    110.     var age = 30
    111.     switch {
    112.     case age < 24:
    113.         fmt.Println("好好学习")
    114.     case age >= 24 && age <= 60:
    115.         fmt.Println("好好赚钱")
    116.         fallthrough
    117.     case age > 60:
    118.         fmt.Println("注意身体")
    119.     default:
    120.         fmt.Println("输入错误")
    121.     }
    122. }
    1. package main
    3. import "fmt"
    5. func main() {
    6.     /*
    7.         Go 语言中 break 语句用于以下几个方面：
    8.             • 用于循环语句中跳出循环，并开始执行循环之后的语句。
    9.             • break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。
    10.             • 在多重循环中，可以用标号 label 标出想 break 的循环。
    11.     */
    13.     //1、表示当i=2的时候跳出当前循环
    14.     // for i := 1; i <= 10; i++ {
    15.     //     if i == 2 {
    16.     //         break
    17.     //     }
    18.     //     fmt.Println(i)
    19.     // }
    20.     // fmt.Println("继续执行")
    22.     /*
    23.         i=0
    25.             i=0 j=0
    26.             i=0 j=1
    27.             i=0 j=2
    29.         i=1
    30.             i=1 j=0
    31.             i=1 j=1
    32.             i=1 j=2
    33.     */
    35.     // for i := 0; i < 2; i++ {
    36.     //     for j := 0; j < 10; j++ {
    37.     //         if j == 3 {
    38.     //             break
    39.     //         }
    40.     //         fmt.Printf("i=%v j=%v\n", i, j)
    41.     //     }
    42.     // }
    44.     //2、 break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。
    46.     // var extname = ".html"
    47.     // switch extname {
    48.     // case ".html":
    49.     //     fmt.Println("text/html")
    50.     //     fmt.Println("text/html")
    51.     //     break
    52.     // case ".css":
    53.     //     fmt.Println("text/css")
    54.     //     break
    55.     // case ".js":
    56.     //     fmt.Println("text/javascript")
    57.     //     break
    58.     // default:
    59.     //     fmt.Println("找不到此后缀")
    60.     // }
    62.     //3、在多重循环中，可以用标号 label 标出想 break 的循环。
    64.     /*
    65.         i=0 j=0
    66.         i=0 j=1
    67.         i=0 j=2
    68.     */
    69. lable1:
    70.     for i := 0; i < 2; i++ {
    71.         for j := 0; j < 10; j++ {
    72.             if j == 3 {
    73.                 break lable1
    74.             }
    75.             fmt.Printf("i=%v j=%v\n", i, j)
    76.         }
    77.     }
    78. }
    1. package main
    3. import "fmt"
    5. func main() {
    7.     // continue 语句可以结束当前循环，开始下一次的循环迭代过程，仅限在 for 循环内使用。
    9.     // for i := 1; i <= 10; i++ {
    11.     //     if i == 3 {
    12.     //         continue
    13.     //     }
    14.     //     fmt.Println(i)
    15.     // }
    17.     // 在 continue 语句后添加标签时，表示开始标签对应的循环
    19.     // for i := 0; i < 2; i++ {
    20.     //     for j := 0; j < 10; j++ {
    21.     //         if j == 3 {
    22.     //             continue
    23.     //         }
    24.     //         fmt.Printf("i=%v j=%v\n", i, j)
    25.     //     }
    26.     // }
    28.     /*
    29.        i=0 j=0
    30.        i=0 j=1
    31.        i=0 j=2
    32.        i=1 j=0
    33.        i=1 j=1
    34.        i=1 j=2
    35.     */
    37. lable2:
    38.     for i := 0; i < 2; i++ {
    39.         for j := 0; j < 10; j++ {
    40.             if j == 3 {
    41.                 continue lable2
    42.             }
    43.             fmt.Printf("i=%v j=%v\n", i, j)
    44.         }
    45.     }
    46. }
    1. package main
    3. import "fmt"
    5. func main() {
    6.     // goto 语句通过标签进行代码间的无条件跳转。goto 语句可以在快速跳出循环、避免重复退 出上有一定的帮助。Go 语言中使用 goto 语句能简化一些代码的实现过程
    8.     var n = 30
    9.     if n > 24 {
    10.         fmt.Println("成年人")
    11.         goto lable3
    13.     }
    15.     fmt.Println("aaa")
    16.     fmt.Println("bbb")
    17. lable3:
    18.     fmt.Println("ccc")
    19.     fmt.Println("ddd")
    20. }
    1. package main
    3. import "fmt"
    5. func main() {
    7.     //1、数组的长度是类型的一部分
    8.     // var arr1 [3]int
    9.     // var arr2 [4]int
    10.     // var strArr [3]string
    12.     // fmt.Printf("arr1:%T  arr2:%T strArr:%T", arr1, arr2, strArr)
    14.     //2、数组的初始化 第一种方法
    16.     // var arr1 [3]int
    18.     // arr1[0] = 23
    19.     // arr1[1] = 10
    20.     // arr1[2] = 24
    21.     // fmt.Println(arr1)
    23.     // var strArr [3]string
    24.     // strArr[0] = "php"
    25.     // strArr[1] = "java"
    26.     // strArr[2] = "golang"
    27.     // // strArr[3] = "js" //out of bounds for 3-element array
    28.     // fmt.Println(strArr)
    30.     //2、数组的初始化 第二种方法
    32.     // var arr1 = [3]int{23, 34, 5}
    33.     // fmt.Println(arr1)
    35.     // var arr1 = [3]string{"php", "nodejs", "golnag"}
    36.     // fmt.Println(arr1)
    38.     // arr1 := [3]string{"php", "nodejs", "golnag"}
    40.     // fmt.Println(arr1)
    42.     //3、数组的初始化 第三种方法  一般情况下我们可以让编译器 根据初始值的个数自行推断数组的长度
    44.     // var arr1 = [...]int{12, 2324, 32435, 353, 535, 3535}
    46.     // fmt.Println(arr1)
    48.     // fmt.Println(len(arr1)) //len()打印数组的长度
    50.     //注意数组的长度
    52.     // arr1 := [...]string{"php", "nodejs", "golnag", "js"}
    53.     // arr1[4] = "java" //: invalid array index 4 (out of bounds for 4-element array)
    54.     // fmt.Println(arr1)
    56.     //改变数组里面的值
    57.     // arr1 := [...]string{"php", "nodejs", "golnag", "js"}
    58.     // arr1[0] = "phper"
    59.     // fmt.Println(arr1)
    61.     // 4、数组的初始化 第四种方法   我们还可以使用指定索引值的方式来初始化数组
    63.     // arr := [...]int{0: 1, 1: 10, 2: 20, 5: 50}
    65.     // fmt.Println(len(arr)) //6
    67.     // fmt.Println(arr) //[1 10 20 0 0 50]
    69.     //5、数组的循环遍历 for  for range
    71.     // var arr = [3]int{23, 34, 5}
    72.     // for i := 0; i < len(arr); i++ {
    73.     //     fmt.Println(arr[i])
    74.     // }
    76.     // arr1 := [...]string{"php", "nodejs", "golnag", "js"}
    77.     // for i := 0; i < len(arr1); i++ {
    78.     //     fmt.Println(arr1[i])
    79.     // }
    81.     arr1 := [...]string{"php", "nodejs", "golnag", "js"}
    83.     for k, v := range arr1 {
    84.         fmt.Printf("key:%v value:%v\n", k, v)
    85.     }
    87. }
    1. package main
    3. import "fmt"
    5. func main() {
    7.     // 1、请求出一个数组里面元素的和以及这些元素的平均值。分别用for和for-range实现
    9.     // var arr = [...]int{12, 23, 45, 67, 2, 5}
    10.     // var sum = 0
    11.     // for i := 0; i < len(arr); i++ {
    12.     //     sum += arr[i]
    13.     // }
    14.     // fmt.Printf("arr数组元素的和是:%v 平均值：%.2f", sum, float64(sum)/float64(len(arr)))
    16.     /*
    17.         2、请求出一个数组的最大值，并得到对应的下标
    19.                 思路
    20.                     1、 声明一个数组 var intArr = [...]int {1, -1, 12, 65, 11}
    21.                     2、假定第一个元素就是最大值，下标就 0
    22.                     3、然后从第二个元素开始循环比较，如果发现有更大，则交换
    23.     */
    25.     // var arr = [...]int{1, -1, 12, 65, 11}
    26.     // var max = arr[0]
    27.     // var index = 0
    28.     // for i := 0; i < len(arr); i++ {
    29.     //     if max < arr[i] {
    30.     //         max = arr[i]
    31.     //         index = i
    32.     //     }
    33.     // }
    34.     // fmt.Printf("最大值:%v  最大值对应的索引值:%v", max, index)
    36.     //3、从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0,3)和(1,2)。
    38.     var arr = [...]int{1, 3, 5, 7, 8}
    40.     for i := 0; i < len(arr); i++ {
    41.         for j := i + 1; j < len(arr); j++ {
    42.             if arr[i]+arr[j] == 8 {
    43.                 fmt.Printf("(%v,%v)", i, j)
    44.             }
    45.         }
    46.     }
    48. }
    1. package main
    3. import "fmt"
    5. func main() {
    7.     /*
    8.         值类型 ：改变变量副本值的时候，不会改变变量本身的值
    9.         引用类型：改变变量副本值的时候，会改变变量本身的值
    10.     */
    12.     //值类型:基本数据类型 和 数组都是值类型
    13.     // var a = 10
    14.     // b := a
    15.     // a = 20
    16.     // fmt.Println(a, b)
    18.     // var arr1 = [...]int{1, 2, 3}
    19.     // arr2 := arr1
    20.     // arr1[0] = 11
    21.     // fmt.Println(arr1)
    22.     // fmt.Println(arr2)
    24.     //引用类型: 切片
    26.     // var arr1 = []int{1, 2, 3}
    27.     // arr2 := arr1
    28.     // arr1[0] = 11
    29.     // fmt.Println(arr1)
    30.     // fmt.Println(arr2)
    32.     var arr1 = []int{1, 2, 3, 4}
    33.     arr2 := arr1
    34.     arr2[0] = 111
    35.     fmt.Println(arr1)
    36.     fmt.Println(arr2)
    38. }
    1. package main
    3. import "fmt"
    5. func main() {
    7.     //1、二维数组的定义
    8.     // var arr = [3]int{1, 2, 3}  一维数组
    10.     // var arr = [3][2]string{
    11.     //     {"北京", "上海"},
    12.     //     {"广州", "深圳"},
    13.     //     {"成都", "重庆"},
    14.     // }
    16.     // // fmt.Println(arr[0])
    17.     // fmt.Println(arr[0][1])
    19.     // var arr = [3][2]string{
    20.     //     {"北京", "上海"},
    21.     //     {"广州", "深圳"},
    22.     //     {"成都", "重庆"},
    23.     // }
    25.     // for _, v1 := range arr {
    26.     //     for _, v2 := range v1 {
    27.     //         fmt.Println(v2)
    28.     //     }
    29.     // }
    31.     // var arr = [3][2]string{
    32.     //     {"北京", "上海"},
    33.     //     {"广州", "深圳"},
    34.     //     {"成都", "重庆"},
    35.     // }
    37.     // for i := 0; i < len(arr); i++ {
    39.     //     for j := 0; j < len(arr[i]); j++ {
    40.     //         fmt.Println(arr[i][j])
    41.     //     }
    42.     // }
    44.     //定义二维数组的另一种方式
    45.     var arr = [...][2]string{
    46.         {"北京", "上海"},
    47.         {"广州", "深圳"},
    48.         {"成都", "重庆"},
    49.         {"成都", "重庆"},
    50.         {"成都", "重庆"},
    51.     }
    53.     fmt.Println(arr)
    55. }