Go_day01

Go基础语法

注释

注释是为了增强代码的可读性，不会参与程序的一切功能，

go语言注释分为单行注释与多行注释

单行注释

//双斜杠 每行都要添加 //

多行注释

/* */ 一次标记多行注释输入

package main

import "fmt"

// 我是一个单行注释
// 不能换行，换行就会出错
func main() {
   /*
      我是多行注释
   可以换行哦
   */
   fmt.Println("hello,world")
   fmt.Println("hello world")
   fmt.Println("hello,world")
}

变量

变量即会变化的量

变量的定义

var name type

• var是声明变量的关键字，固定写法 必需
• name是变量的名字，命名规则：驼峰原则
• type变量的数据类型

func main() {
   //name 变量
   var name string = "xue"
   var age int = 20

   name = "evan"
   //定义的变量不被使用会报错哦
   fmt.Println(name, age)
   //这里解释一下  当name被定义出来是 会为其开启一个内存空间 假设地址是001   那么 xue就是空间中存储的字符串
   // 当name重新赋值是 九八xue从空间中拿出，把evan放进去 打印name变量是指向地址001输出其中的值
}

• 任何变量类型在不初始化下 都有自己的默认值

*
定义多个变量
*/
func main() {
   var (
      name string //默认值为空
      age  int    //默认值为0
      addr string
   )
   fmt.Println(name, age, addr)
}

变量的初始化

• 一般通过=进行赋值

//沿用上面的代码
name = "xue"
age = 20
addr = "china"
fmt.Println(name, age, addr)

• 也有:=的推导声明写法，编译器会自动根据右侧数据类型推断出变得的数据类型，但只能用在函数内部，不能随便到处定义

  // := 会自动推导 数据的类型
  name2 := "evan"
  age2 := "23"
  fmt.Println(name2, age2)
  //printf打印一些变量的参数 如数据类型，变量地址
  fmt.Printf("%T,%T", name2, age2)
  

打印变量参数

fmt.Printf("%T,%T", name2, age2)
//prinf打印变量参数，%T数据类型、%d数值类型的值、%p变量地址 另需要配饰使用&取出地址
fmt.Printf("%d,%p", age, &age)

变量交换

意为两个变量值的交换

func main() {
   var a int = 100
   var b int = 200
   fmt.Println(a, b)
   //交换后
   a, b = b, a //不需要再定义一个临时变量存放值
   fmt.Println(a, b)
}

匿名变量

• 使用下划线"_" 代替变量名 称为空白标识符
• 一旦使用此变量赋值，值都将被排期
• 不会占用空间，也不会分配内存，可以多次使用

func test() (int, int) {
   return 100, 200
}

func main() {
   a, _ := test()
   _, b := test()
   fmt.Println(a,b)
}

这里对变量的作用域做一个简单说明：全局变量、局部变量；调用时就近原则

常量

使用const来定义常量

func main() {
   const USL string = "www.baidu.com" //显示定义
   const ADDR = "China of World"      //隐式定义，自动识别数据类型

   fmt.Println(USL, ADDR)

   const a, b, c = 23, "34", false //可以同时定义多个
   fmt.Println(a, b, c)
}

iota

一个常量计数器，特殊的常量用来给常量计数

func main() {
   //iote 只在这一组常量中有效，重新定义从0考试
   const (
      a = iota // iota 0
      b        // iota 1
      c = 23   // iota 2
      d        // iota 3
      e = "你好" // iota 4
      f        // iota 5
      g = iota // iota 6
      h        // iota 7
   )

   const (
      k = iota // iota 0
      l        // iota 1
   )

   fmt.Println(a, b, c, d, e, f, g, h, k, l)

}

打印结果
0 1 23 23 你好 你好 6 7 0 1

基本数据类型

func main() {
   //var name string'
   //bool 布尔类型 要么true 要么false
   var isFlag bool = false
   fmt.Println(isFlag)
   fmt.Printf("%T,%t\n", isFlag, isFlag) //%t 当前的值

   // byte==uint8
   // rune==uint32
   // int==uint64
   var age int = 18
   //尽量使用float64来定义浮点数
   var money float64 = 3.14
   fmt.Printf("%T,%d\n", age, age)
   fmt.Printf("%T,%f\n", money, money) //默认保留6位小数，四舍五入保留小数

   var str string
   str = "nihao,world"
   fmt.Printf("%T,%s\n", str, str)
   //单引号字符
   v1 := 'A'
   fmt.Printf("%T,%d\n", v1, v1) //打印的时ASCII编码表上十进制的值

   fmt.Println("nihao," + "shijie")
   fmt.Println("nihao,\"shijie")
}

数据类型转换

typeA = (typeA)typeB //go语言没有隐式转换 所以都要显示声明

func main() {
   a := 6
   b := 5.00
   //将int类型转换位float64类型
   c := float64(a)
   d := int(b)

   

   fmt.Printf("%T\n", a)
   fmt.Printf("%T\n", b)
   fmt.Printf("%T\n", c)
   fmt.Printf("%T\n", d)

   //整型是不能转换位bool类型的
   str := false
   num := int(str)
   fmt.Printf("%T", num)

}

运算符

算数运算符

+，-，*，/,%(也成为取模)

func main() {
   var a int = 10
   var b int = 3

   // + - * / %
   fmt.Println(a + b)
   fmt.Println(a - b)
   fmt.Println(a * b)
   fmt.Println(a / b) //只取整哦
   fmt.Println(a % b) //取模

   a++
   fmt.Println(a)
   a--
   fmt.Println(a)

}

关系运算符

==，!=，>，<，>=，<=

一般用来判断是与不是

逻辑运算符

&&，||，！

func main() {
   var a int = 10
   var b int = 3

   // + - * / %
   fmt.Println(a + b)
   fmt.Println(a - b)
   fmt.Println(a * b)
   fmt.Println(a / b) //只取整哦
   fmt.Println(a % b) //取模
   a++
   fmt.Println(a)
   a--
   fmt.Println(a)

   var c bool = true
   var d bool = false

   //&& c与d都要满足条件才会为真
   if c == true && d == true {
      fmt.Println(c && d)
   }

   // || c与d 只要一个满足就为真
   if c == true || d == true {
      fmt.Println(c || d)
   }

   // ！取反
   fmt.Println(!c) //false

}

位运算符

二进制的 0是false 1是true

& 都是1 结果才为1

| 其中一个是1 就是1

^两个相同为0 不同为1

/>> 右移 如 0010 右移1位 0001

/<< 左移 如 0010 左移1位 0100

比如 0011 1100

​ 0000 1101

&： 0000 1100 12

|： 0011 1101 61

^: 0011 0001 48

func main() {
   var a uint = 60
   var b uint = 13

   var c uint
   c = a & b
   fmt.Printf("%d,二进制%b\n", c, c)

   c = a | b
   fmt.Printf("%d,二进制%b\n", c, c)

   c = a ^ b
   fmt.Printf("%d,二进制%b\n", c, c)

   fmt.Println(a >> 2)
   a = 60
   fmt.Println(a << 2)

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