Go全栈第2节：Go基础语法

package main
import "fmt"
/*
main函数，go言的启动入口
*/
func main(){
  // name 是变量
  var name string = "kuangshen"
  var age int = 19
  name = "zhangsan"
  fmt.Println(name,age)
}

var name type

// 定义变量
var {
  name string  // 默认值空字符串
  age int // 默认值 0
  add string
}

var a,b int

var 变量名 类型 = 值 （表达式） // 赋值

var name string = "kuangshen"
var age int = 18
// 变量是可以重复赋值的
age = 20
// 格式化输出
fmt.Printf("name:%s,age:%d",name,age)

func main() {
  // := 编译器根据变量的值自动推导变量类型，这种写法叫短变量声明并初始化
  // 短变量赋值只能用在局部变量中
  name := "kuangshen"
  age := 18
  fmt.Printf("name:%s,age:%d",name,age)
  fmt.Printf("%T,%T",name,age)  // %T输出变量的类型
}

package main

import "fmt"

func main() {
	var num int
	num = 100
	fmt.Printf("num:%d,内存地址：%p", num, &num) // 取地址符号 &变量名
	
	// 重新赋值，发现内存地址不变，说明变量名代表着一个内存地址，是编译器分配的
	num = 200
  // 格式化输出
	fmt.Printf("num:%d,内存地址：%p", num, &num) // 取地址符号 &变量名
}

package main

import "fmt"

func main() {
	var a int = 100
	var b int = 200

	// go语言中，可以直接这样实现换值，不需要中间变量
  // 把a,b 赋值给b,a
	b, a = a, b
	fmt.Println(a, b)
}

package main

import "fmt"

func test() (int, int) {
	return 100,200
}
func main(){
	a,_ := test() // 只需要第一个返回值，所以第二个变量定义为匿名变量
	_,b := test() // 只需要第二个返回值，所以第一个变量定义为匿名变量
	fmt.Println(a,b)
}

// 场景
// 登录之后，返回用户信息，有60个字段

// 全局变量必须使用var关键字，不能使用:=短变量声明
var name string = "kuangsheng"
func main(){
	var name string = "lisu"
	fmt.Println(name) // 打印局部变量
}
func aa(){
	fmt.Println(name) // 打印全局变量
}
// 就近原则，自上而下

const identifier [type] = value

// 显示类型定义
const b string = "abc"
// 隐式类型定义
const b = "abc"
const URL = "www.baidu.com"
const c_name1,c_name2 = value1,value2 // 多个相同类型的常量声明

package main

import "fmt"
func main(){
  // 建议大家使用大写字母来定义常量，区分于普通变量
	const URL ="www.baidu.com"
	const a,b,c = 3.14,"kuangshen",false

	fmt.Println(URL)
  // 常量声明后，可以不使用
	// fmt.Println(a,b,c)
  // 常量不能获取内存地址
	// fmt.Printf("%p",&URL)
}

const(
  a = iota
  b = iota
  c = iota
)

const(
  a = iota
  b
  c
)

package main

import "fmt"

func main()  {
	var isFlag bool // 默认值为false
	isFlag = true
  isFlag = 1 // 会报错
	fmt.Println(isFlag)
  // 格式化输出，占位符：%d整数，%s字符串，%p内存地址，%t 布尔值  %T 数据类型
	fmt.Printf("%T,%t\n",isFlag,isFlag) // %T 输出变量的数据类型
}

package main

import "fmt"

func main() {
	var age int = 18 // 默认int不指定就是使用int64
	fmt.Printf("%T,%d\n", age, age)

	// 定义一个浮点数
	var money float32 = 3.14 // 32位浮点数容易造成精度丢失，一般使用float64
  // 浮点数，%f 默认保留6为小数
	fmt.Printf("%T,%f\n", money, money)   // 默认打印6位小数
	fmt.Printf("%T,%.2f\n", money, money) // 打印2位小数
	fmt.Printf("%T,%.1f\n", money, money) // 打印1位小数，四舍五入
}

package main

import "fmt"

func main() {
	//var i2 uint8
	//i2 = -100
	// 浮点数： 符号位 + 指数位 + 尾数位（存储过程中，可能会丢失，造成精度损失）
	// float64的空间 》 float32
	var num1 float32 = -123.0000901
	var num2 float64 = -123.0000901
	fmt.Println(num1)
	fmt.Println(num2)
	// 结论：使用float来计算，可能导致数据不精确

}

func main() {
		var num3 byte = 255
	fmt.Printf("%T\n", num3)

	var num4 rune = 1000000000
	fmt.Printf("%T\n", num4)

	// int 根据系统的大小32位默认int32, 64位默认int64
	var num5 int = 130483405804804850
	fmt.Printf("%T\n", num5)
}

import "fmt"

func main() {
	// 单引号 字符
	v1 := 'A'
	v2 := "A"
	fmt.Printf("%T,%s\n", v1, v1) 
	fmt.Printf("%T,%s\n", v2, v2)
}

func main() {
	// 单引号 字符
	v1 := 'A'
	v2 := "A"
	fmt.Printf("%T,%d\n", v1, v1) // 字符A打印的ASCII码表的值，大写字母A的值是65
	fmt.Printf("%T,%s\n", v2, v2)
}

func main() {
	// 单引号 字符
  // 扩展
  // 所有的中国字的编码表：GBK
  // 全世界的文字s编码表：Unicode编码表
	v3 := '中'
	fmt.Printf("%T,%d\n", v3, v3)
}

	// 字符串连接 +
	fmt.Println("hello " + ",kuangshen")
	// 转义字符 \
	fmt.Println("hello\"kuangshen")
	fmt.Println("hello\nkuangshen") // n 换行
	fmt.Println("hello\tkuangshen") // t 制表符，4个空格=tab
··

import "fmt"

func main() {
	a := 10
	b := 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() {
	// 二进制 0 1 逢二进1 ，1~20的二进制表示如下
    // 0 1 电路问题
	// 1, 1
	// 2, 10
	// 3，11
	// 4，100
	// 5，101
	// 6, 110
	// 7, 111
	// 8, 1000
	// 9, 1001
	// 10, 1010
	// 11, 1011
	// 12, 1100
	// 13, 1101
	// 14, 1110
	// 15, 1111
	// 16, 10000
	// 17, 10001
	// 18, 10010
	// 19, 10011
	// 20, 10100
	// 位运算： 二进制的0 false, 1 true
	// & 我和你 1 1 结果才是1，否则 0
	// | 或运算符 都是0结果为0，否则1
  // ^ 不同为1，相同为0
	// 60  0011 1100
	// 13  0000 1101
	// -------------
	// &   0000 1100
  // |   0011 1101
  // ^   0011 0001 
	// 结果 12
}

var a uint = 60
var b uint = 13
var c uint = 0
c = a & b
fmt.Printf("%d,二进制%b\n", c, c)  // 00001100
c = a | b
	fmt.Printf("%d,二进制%b\n", c, c) // 61,二进制111101

	c = a << 2
	fmt.Printf("%d,二进制%b\n", c, c) // 240,二进制11110000
	fmt.Printf("%d,二进制%b\n", a, a) // 60,二进制111100
	c = a >> 2
	fmt.Printf("%d,二进制%b\n", c, c) // 15,二进制1111

12,二进制1100
61,二进制111101
240,二进制11110000
60,二进制111100
15,二进制1111

	var x int
	var y float64

	// 定义两个变量，键盘录入这两个变量值
	fmt.Println("请输入两个数，1、整数，2、浮点数")
	// 变量取内存地址  &变量
	// Scanln阻塞等待你的键盘输入，然后换行
fmt.Scanf() // 接收格式化输入
	fmt.Scanln(&x, &y) // 把输入值保存到内存地址指向的内存空间
	fmt.Println("x:", x)
	fmt.Println("y:", y)