go语言学习(一):基本语法

go语言是静态语言，但不需要依赖库，且支持并发，支持垃圾回收，内置大量的库，
一.helloworld

//定义包名，在源文件中的第一行指明这个文件属于哪个包
//程序必须要有一个main包
package main

import "fmt"  //这个程序需要使用fmt包（的函数或其他元素），fmt包实现了格式化IO函数

func main() {  //func main（）是程序开始执行的函数
    /* 这是我的第一个简单的程序 Println()会自动换行,*/
    //调用函数，大部分需要导入包
    fmt.Println("Hello, World!") //go语句结尾没有分号
}

注：每个工程（文件夹）只能有一个main函数
解决办法：
1.//go build xxx.go,编译go代码，生成一个可执行程序
//然后运行这个可执行程序 ./hello
2.直接go run xxx.go
二.变量声明

package main

import "fmt"  //导入包比需要使用

func main() {  //func main（）是程序开始执行的函数
    //1.声明了变量，必须要使用
    //只声明没有初始化的变量，默认值为0
    //同一个{}里，声明的变量名唯一
    var a int
    fmt.Println("a = ", a) //go语句结尾没有分号

    //可同时声明多个变量
    var b, c int
    a = 10   //变量赋值
    fmt.Println("a = ", a)
    fmt.Println(b,c)

    //2.声明变量时同时赋值
    var d int = 10
    fmt.Println(d)

    //3.自动推导类型，必须初始化，通过初始化的值确定类型,同一变量名只能使用一次，用于初始化，但赋值可以使用多从
    f := 30
    //%T打印变量所属的类型
    fmt.Printf(" f type is %T\n",f)
}

printf和println区别

package main

import "fmt" //导入包比需要使用

func main() {  //func main（）是程序开始执行的函数
   a :=10
   //一段一段处理，自动加换行
   fmt.Println("a =",a)

   //格式化输出，把a的内容放在%d的位置
   fmt.Printf("a = %d\n", a)

   b := 10
   c := 20
   fmt.Printf("a = %d, b= %d, c= %d",a, b, c)
}

匿名变量

package main

import "fmt" //导入包比需要使用

func test()(a, b, c int){
    return 1, 2, 3
}

func main() {  //func main（）是程序开始执行的函数
   //多重赋值
   a, b := 10, 20
   //传统交换赋值
   var tmp int
   tmp = a
   a = b
   b = tmp
   fmt.Printf("a = %d, b = %d\n",a,b)

   //go语言交换赋值
   i := 10
   j := 20
   i, j = j, i
    fmt.Printf("i = %d, j = %d\n",i,j)

   //匿名变量，丢弃数据不处理, 匿名变量配合函数返回值使用
   tmp, _ = i, j
   fmt.Println(tmp)


   var c, d, e int
   c, d, e =test() //return 1,2,3
   fmt.Printf("a=%d,b=%d,a=%d\n",c,d,e)

    _, d, e =test() //return 1,2,3
    fmt.Printf("a=%d,b=%d,a=%d\n",c,d,e)
}

常量定义

package main

import "fmt" //导入包比需要使用

func main() {  //func main（）是程序开始执行的函数
  //变量：程序运行期间，可以改变的量，变量声明需要var
  //常量，程序运行期间，不可以改变的量，变量声明需要const

    const a int = 10
    //a=20 err,常量不允许修改
    fmt.Println("a = ",a)

    const b = 10 //没有使用：=
    fmt.Println("b = ",b)

}

package main

import "fmt" 

func main() { 
   //不同类型变量的声明（定义）
   //var a int = 10
   //var b float64 = 3.14
   //a,b=10,3.14
   var (
      a int
      b float64
   )



   fmt.Println("a =",a)
   fmt.Println("b =",b)

   //const i int =10
   //const j float64 = 3.14
   const (
      i int =10
      j float64 = 3.14
   )
   //也可以自动推导类型
   //const (
   //   i =10
   //   j = 3.14
   //)
   fmt.Println("i =",i)
   fmt.Println("j =",j)

}

iota枚举

package main

import "fmt"

func main() {
   //1. iota常量自动生成器，每生成一行，自动累加1
   //2。iota给常量赋值时使用
   const(
      a=iota
      b=iota
      c=iota
   )
   fmt.Printf("a=%d, b=%d, c=%d\n", a, b, c)

   //3.iota遇到const，重置为0
   const d= iota
   fmt.Printf("d =%d\n",d)

   //4.可以只写一个iota
   const(
      a1=iota
      b1
      c1
   )
   fmt.Printf("a1=%d, b1=%d, c1=%d\n", a1, b1, c1)

   //5.如果是同一行，值都一样
   const(
      i=iota
      j1, j2 = iota, iota
      k= iota
   )
   fmt.Printf("i=%d,j1=%d,j2=%d, k=%d", i, j1, j2, k)
}

bool

package main

import "fmt"

func main() {
   var a bool
   a = true
   fmt.Println("a =", a)

   var b= true
   fmt.Println("b =", b)

   c := true
   fmt.Println("c =", c)
}

浮点型

package main

import "fmt"

func main() {
    var f1 float32
    f1 = 3.14
    fmt.Println("f1 =",f1)

    f2 := 3.14
    //f2 type is float64
     fmt.Printf("f2 type is %T\n",f2)
}

字符型

package main

import "fmt"

func main() {
    var ch byte
    //ch = 97
    ch = 'a'
    fmt.Printf("ch = %c,%d\n",ch,ch)

    //大写转小写，小写转大写,大小写相差32，小写大
    fmt.Printf("大写：%d, 小写：%d\n", 'A', 'a')
    fmt.Printf("大写转小写： %c\n", 'A'+32)
    fmt.Printf("小写转大写： %c\n", 'a'-32)

}

字符串型

func main() {
    var str1 string
    str1 = "abc"
    fmt.Println("str1 =",str1)

    //自动推导类型
    str2 := "mike"
    fmt.Printf("str2 类型是 %T\n", str2)

    //内建函数，len()可以测字符串的长度，有多少字符
    fmt.Println(len(str2))
    
   //字符单引号，字符串双引号
   //字符往往只有一个字符，转义字符除外；
   //字符串由一个或多个组成，字符串都隐藏了一个结束符，'\0'
   //var ch byte = 'a'
   var str string = "hello go"
   //只想操作字符串的某一个字符
   fmt.Printf("str[0] = %c,str[1] = %c\n", str[0], str[1])
}

输入

func main() {
   var a float32
   fmt.Printf("请输入变量a：")

   //阻塞等待用户的输入
   //fmt.Scanf("%f", &a)
   fmt.Scan(&a)
   fmt.Println("a =",a)
}

if判断

func main() {
   //if支持一个初始化语句，用分号与条件相隔
   if a := 21;a == 10{
      fmt.Println("a == 10")
   } else if a < 10{
      fmt.Println("a < 10")
   } else if a > 10 {
      fmt.Println("a > 10")
   } else {
      fmt.Println("这是不可能的")
   }
}

switch语句

func main() {
   var num int
   //默认包含break；fallthrough与break相反，不跳出switch
   fmt.Scan(&num)
   switch num {
   case 1:
      fmt.Println("1111111")
      fallthrough
   case 2:
      fmt.Println("222222")
      fallthrough
   case 3:
      fmt.Println("33333")
      fallthrough
   case 4:
      fmt.Println("44444")
      fallthrough

   default:
      fmt.Println("55555")
   }
}

score :=85
   switch{  //可以没有条件
   case score >60:
      fmt.Println("及格")
   default:
      fmt.Println("不及格")
   }

for循环

func main() {
   //sum := 0
   //for i:=1;i<=100;i++{
   //   sum++
   //}
   //fmt.Println(sum)
   //
   //str := "abc"
   //for i:=0;i<len(str);i++{
   //   fmt.Printf("%c",str[i])
   //}

   //迭代打印每个元素，默认返回两个值
   str := "abc"
   for i,data := range str{
       fmt.Printf("str[%d]=%c\n", i, data)
   }

   numbers := [6]int{1, 2, 3, 5}
   for i,x:= range numbers {
      fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
   }
}