go 基础

go 入门 hello world  仪式感还是要有的

package main

func main() {
	println("hello world")
}

print系列主要用于输出，主要包含了三个方法：

package main

import "fmt"

func main() {
	// 一次输入多个值的时候 Println 中间有空格,能自动换行
	fmt.Println("Hello", "Println")

	// 一次输入多个值的时候 Print 没有中间空格,Print 不会自动换行；
	fmt.Print("Hello", "Print")

	// Printf 是格式化输出，在很多场景下比 Println 更方便，Printf也不会换行
	fmt.Printf("Hello Printf %s", "AAA")
}

区别在于：

• print 直接输出内容，不会换行，不能格式化输出
• printf 能够通过占位符输出格式化内容
• println 能够在输出内容后面加上换行符

Scan：在交互式界面中获取输入：

package main

import "fmt"

func main() {
	var name string
	fmt.Print("输入你的姓名:")
	fmt.Scan(&name)
	fmt.Printf("你输入的姓名是：%s", name)
}

关键字

go 只有25个关键字

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

go 还有37个保留字：

Constants:    true  false  iota  nil

Types:    int  int8  int16  int32  int64  
          uint  uint8  uint16  uint32  uint64  uintptr
          float32  float64  complex128  complex64
          bool  byte  rune  string  error

Functions:   make  len  cap  new  append  copy  close  delete
             complex  real  imag
             panic  recover

标识符：

  标识符用来变量，类型等程序实体 一个表示符实际上是由一个或者多个字母（大写或者小写），数字（0~9）下划线_ 所组成的序列，但是第一个字符必须是字母或者下划线不能是数字

例：有效的标识符

mahesh   kumar   abc   move_name   a_123
myname50   _temp   j   a23b9   retVal

无效的标识符：

1. 1ab（以数字开头）
2. case（Go 语言的关键字）
3. a+b（运算符是不允许的）

Go的函数、变量、常量、自定义类型、包(package)的命名方式遵循以下规则：

1. 首字符可以是任意的Unicode字符或者下划线
2. 剩余字符可以是Unicode字符、下划线、数字
3. 字符长度不限

Go语言声明：

有四种注意声明方式：

var（声明变量）, const（声明常量）, type（声明类型） ,func（声明函数）

Go程序保存在多个.go文件中，文件的第一行就是 package XXX 声明，用来说明 该文件属于哪个包(package)，package声明下来就是import声明（导入哪些包），再下来是类型，变量，常量，函数的声明。

声明的位置决定其作用域：

1. 声明在函数内部，是函数的本地值，类似 private
2. 声明在函数外部，是对当前包可见(包内所有.go文件都可见)的全局值，类似 protect
3. 声明在函数外部且首字母大写是所有包可见的全局值，类似 public

{ 不能单独放在一行：

表示函数体开始的前花括号“ { ” 不能单独放在一行

package main

import "fmt"

func main()  
{  // 错误，{ 不能在单独的行上
    fmt.Println("Hello, World!")
}

实现字符串连接：+

package main
import "fmt"
func main() {
    fmt.Println("Google" + "Runoob")
}

空格的 使用

1. Go 语言中变量的声明必须使用空格隔开，如： 

   var age int;

格式化字符串：

Go 语言中可以使用 fmt.Sprintf 格式化字符串并赋值给新串：

package main

import (
    "fmt"
)

func main() {
   // %d 表示整型数字，%s 表示字符串
    var stockcode=123
    var enddate="2020-12-31"
    var url="Code=%d&endDate=%s"
    var target_url=fmt.Sprintf(url,stockcode,enddate)
    fmt.Println(target_url)
}

fmt.Sprintf 格式化字符串的格式如下：

fmt.Sprintf(格式化样式, 参数列表…)

格式化样式：字符串形式，格式化符号以 % 开头， %s 字符串格式，%d 十进制的整数格式。Go 字符串格式化符号:

1. 参数列表：多个参数以逗号分隔，个数必须与格式化样式中的个数一一对应，否则运行时会报错。

go语言定义变量

关于变量：程序运行过程中的数据都是保存在内存中，我们想要在代码中操作某个数据时就需要去内存上找到这个变量，但是如果我们直接在代码中通过内存地址去操作变量的话，代码的可读性会非常差而且还容易出错，所以我们就利用变量将这个数据的内存地址保存起来，以后直接通过这个变量就能找到内存上对应的数据了。

go 中常见的变量定义方法如下：

// var 定义变量
var 变量名 类型 = 表达式
var name string = "sunlixin"

// 类型推到方式定义变量
// a 在函数内部，可以使用简略的 := 方式声明并初始化变量
// 注意： 短变量只能用于声明局部变量，不能用于全局变量的声明
变量名 := 表达式
n := 10

go的fmt包，print，Println printf

// go 中主要打印一个值需要引入fmt包
improt "fmt"
//  fmt包里面给我们提供了常见的打印数据的方法：比如：Print println  printf 在我们实际应用中println 和printf 用的非常多

1、print和println和printf的区别

// 一次输入多个值的时候，println中间有空格，print没有
// printf 是格式化输出，在很多场景下，比println更方便
//例：
a := 10
b := 20
c := 30
fmt.Println("a=", a, ",b=", b, ",c=", c) //a= 10 ,b= 20 ,c= 30
fmt.Printf("a=%d,b=%d,c=%d", a, b, c) //a=10,b=20,c=30

// %d 是占位符，表示数字的十进制表示，printf中的占位符与后面的数字变量一一对应。
// 更多的占位符参考：http://docscn.studygolang.com/pkg/fmt/

 GO 语言中的注释

// win 下面 ctrl+/ 可以快速的注释一样，mac 下面 command+/ 也可以快速的注释一样
/* 这是一个注释
*/
//这是一个注释

GO 变量，常量，变量命令规则

go语言中变量的声明

go 语言变量名 由字母，数字，下划线组成，其中首个字符不能为数字，go 语言中关键字和保留字都不能用作变量名
go 语言中的变量需要声明后才能使用，同一左右域内不支持重复声明，并且go语言的变量声明后必须使用

1，var 声明变量

var 变量名称 type

var name string 
var gae int 
var isOK bool


package main
import "fmt"
func main() {
	var (
		username string = "sunlixin"
		age      int    = 27
	)
	println(username, age)
}

// 一次定义多个变量
var identifier1 ，identifier2 type

package main

func main() {
	var username, sex string
	username = "zhangsan"
	sex = "男"
	println(username, sex)
}

// 申请变量的时候赋值
var a,b,c,d = 1,2,3,false



// 批量声明的时候指定类型
var (
a string
b int
c bool
)
a = "张三" b = 10
c = true
fmt.Println(a,b,c)


// 批量声明并赋值
var (
a string = "张三" b int = 20
c bool = true
)
fmt.Println(a, b, c)
fmt.Println(a,b,c)

2.变量初始化

// go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作，每个变量会被初始化成其类型的默认值，例如：整型和浮点型变量的默认值为0，字符串变量的默认值为空字符串，布尔型变量默认为false，切边，函数，指针变量默认为nil


//当我们也可在声明变量的时候为其指定初始值，变量初始化的标准格式如下：
var 变量名 类型 = 表达式

//例:
var name string = "slx"
var age int = 18

// 或者一次初始化多个变量并赋值
var name,age = "slx",20

3.类型推到

在甘薯内部，可以使用更简略的 := 声明式并初始化变量，注意：短变量只能永辉声明局部变量，不能用于全局变量的声明

变量名 := 表达式

package main
import "fmt"
// 全局变量 m
    var m = 100
func main() {
    n := 10
    m := 200 // 此处声明局部变量 m
    fmt.Println(m, n)
}

// 使用变量一次声明多个变量，并初始化变量
m1, m2, m3 := 10, 20, 30
fmt.Println(m1, m2, m3)

4.匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量，匿名变量用一个下划线_表示。如

func getInfo() (int, string) {
    return 10, "张三"
}
func main() { _, username := getInfo()
    fmt.Println(username)
}

//匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明
//注意：
// 1. 函数外的每个语句都必须以关键字开始（var const func等）
// 2. := 不能使用在函数外
// 3._多用于占位，表示忽略值

 GO语言中的常量

相对应变量，常量是恒定不变的值，多用于定义程勋运行期间不会改变的哪些值，常量的声明和变量的声明非常类似，只是把var 换成看const，常量在定义的时候必须献值

1.使用const定义常量

const pi = 3.145
const e = 2.677
// 声明了pi 和e 两个常量之后，在整个程勋运行期间，他们的值都不能发生变化了

// 多个常量也可以一起声明
const (
    pi = 3.1415
    e = 2.7182
)

// 同时声明多个常量时，如果省略了值则表示和上面一行的值相同，例：
const (
    n1 = 100
    n2
    n3
)
// 表示常量n1 n2 n3 的值都是100

// 打印pi的值
package main

import (
	"fmt"
	"math"
)

func main() {
	const pi = math.Pi
	fmt.Println(pi)
}

2. const常量结合iota的使用

// iota是go语言中的常量计数器，只能在常量的表达式中使用
// iota在const 关键字出现时将要表重置0（const内部的第一行之前） connst中每新增一行常量声明将使用iota计数一次（iota可以理解为const语句中的行索引）

// 1.iota 只能在常量的表达式中使用
fmt.Println(iota)
编译错误： undefined: iota

// 2.每次const出现时，都会让iota初始化为0.【自增长】
const a = iota // a=0
const (
    b = iota //b=0
    c //c=1
)

// 3.const iota使用_跳过某些值
const（
    n1 = iota // 0
    n2 =  // 1
    -
    n4 = //3
）

// 4.iota声明中间插队
const (
    n1 = iota //0
    n2 = 100 //100
    n3 = iota //2
    n4 //3
)
const n5 = iota //0

// 5.多个iota定义在一行
const (
    a, b = iota + 1, iota + 2 //1,2
    c, d //2,3
    e, f //3,4
)

 GO语言变量，常量命令规则

1、变量名称必须由数字、字母、下划线组成。
2、标识符开头不能是数字
3、标识符不能是保留字和关键字。
4、变量的名字是区分大小写的如: age 和 Age 是不同的变量。在实际的运用中,也建议,不要用一个单词大小写区分两个变量。
5、标识符(变量名称)一定要见名思意 ：变量名称建议用名词，方法名称建议用动词
6、变量命名一般采用驼峰式，当遇到特有名词（缩写或简称，如 DNS）的时候，特有名词根据是否私有全部大写或小写。

GO语言代码风格

1、代码每一行结束后不用写分号（ ;）
2、运算符左右建议各加一个空格 var username string = "itying" 3、Go 语言程序员推荐使用驼峰式命名当名字有几个单词组成的时优先使用大小写分隔
4、强制的代码风格左括号必须紧接着语句不换行，这个特性刚开始会使开发者不习惯，但随着对 Go 语言的不断熟悉，就会发现风格统一让大家在阅读代码时把注意力集中到了解决问题上，而不是代码风格上
5、go fmt 主要用于格式化文档，让所有人的代码风格保持一致
D:\golang\src\demo01>go fmt main.go
main.go

GO语言的基本数据类型

go语言中数据类型分为：基本数据和复合数据类型

基本数据类型：

  整型，浮点型，布尔型，字符串

复合数据类型有：

  数组，切片，结构体，函数，map，通道，接口等

1.整型

  整型分为以下两大类：

    有符号整型长度为：int8 int16 int32 int64

    对应的无符号整型：uint8 uint16 uint32 uint64

关于字节：

  字节也叫byte，8bit(位)=1Byte(字节) 1024Byte(字节)=1KB 1024KB=1MB 1024MB=1GB 1024GB=1TB 。在电脑里一个中文字是占两个字节的

特殊整型：

注意：在使用int和uint类型是不能假定它是32位或者64位的整形，而是考虑int和uint可能在不同的平台上的差异

注意事项：实际项目中整数类型、切片、 map 的元素数量等都可以用 int 来表示。在涉及 到二进制传输、为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使 用 int 和 uint。

package main
import ( "fmt"
)
func main() {
    var num int64
    num = 123
    fmt.Printf("值:%v 类型%T", num, num)
}

unsafe.Sizeof

unsafe.Sizeof(n1)是unsafe包的一个函数，可以返回n1变量占用的字节数

package main
import ( 
    "fmt"
    "unsafe"
)
func main() {
    var a int8 = 120
    fmt.Printf("%T\n", a)
    fmt.Println(unsafe.Sizeof(a))
}

 int 不同长度直接的装换

package main
import ( 
    "fmt"
)
func main() {
    var num1 int8    
    num1 = 127
    num2 := int32(num1)
    fmt.Printf("值:%v 类型%T", num2, num2) //值:127 类型 int32
}

浮点型

go 语言支持两种浮点型数：float32和float64 这两种浮点类型数据格式遵循IEEE754标准：

  float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32。float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64。

打印浮点数是，可以使用fmt包配合动词%f，如：

package main
import ( 
    "fmt"
    "math"
)
func main() {
    fmt.Printf("%f\n", math.Pi) //默认保留 6 位小数
    fmt.Printf("%.2f\n", math.Pi) //保留 2 位小数
}

GO语言中浮点数是默认是float64

num := 1.1
fmt.Printf("值：%v--类型:%T", num, num) //值：1.1--类型:float64

go中float精度丢失问题

几乎所有的编程语言都有精度丢失这个问题，这是典型的二进制浮点数精度损失问题，在定长条件下，二进制小数和十进制小数互转可能有精度丢失

d := 1129.6
fmt.Println((d * 100)) //输出：112959.99999999999

var d float64 = 1129.6
fmt.Println((d * 100)) //输出：112959.99999999999

m1 := 8.2
m2 := 3.8
fmt.Println(m1 - m2) // 期望是 4.4，结果打印出了 4.399999999999999

使用第三方包来解决精度损失问题：https://github.com/shopspring/decimal

go科学计算法表示浮点型

num8 := 5.1234e2 // ? 5.1234 * 10 的 2 次方
num9 := 5.1234E2 // ? 5.1234 * 10 的 2 次方 shift+alt+向下的箭头
num10 := 5.1234E-2 // ? 5.1234 / 10 的 2 次方 0.051234
fmt.Println("num8=", num8, "num9=", num9, "num10=",num10）

布尔值

go中布尔类型数据只有true和false两个值

注意：

1. 布尔类型变量的默认值为false
2. go中不允许将整型强制转换为布尔型
3. 布尔型无法参与数值运算，也无法与其他类型进行转换

package main
import ( "fmt"
"unsafe"
)
func main() {
    var b = true
    fmt.Println(b, "占用字节：", unsafe.Sizeof(b))
}

字符串

go中字符串内部使用使用UTF-8编码，字符串的值为双引号，可以在go中直接添加ASll码字符

s1 := "hello"
s2 := "你好

go中字符串常见转义符包含回车，换行，单双引号，制表符等

如，打印一个文件的路径：

package main
import (
    "fmt"
)
    func main() {
    fmt.Println("str := \"c:\\Code\\demo\\go.exe\"")
}

多行字符串

Go 语言中要定义一个多行字符串时，就必须使用反引号字符：
s1 := `第一行
第二行
第三行
`fmt.Println(s1)
反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出

字符串的常用操作

len(str)求字符串的长度

var str = "this is str"
fmt.Println(len(str))

string.Split 分割字符串

	var str = "123-456-789"
	var arr = strings.Split(str, "-")
	fmt.Println(arr)

拼接字符串

	var str = "this is golang"
	var flag = strings.Contains(str, "golang")
	fmt.Println(flag)

// 返回的结果是true或false

判断首字符字母是否包含指定字符

	var stra = "this is golang"
	var flagc = strings.HasPrefix(stra, "this")
	fmt.Println(flagc)
	var stre = "this is golang"
	var flage = strings.HasSuffix(stre, "go")
	fmt.Println(flage)

判断字符串出现的

	var str1 = "this is golang"
	var index1 = strings.Index(str1, "is") //从前往后
	fmt.Println(index1)
	var str = "this is golang"
	var index = strings.LastIndex(str, "is") //从后网前
	fmt.Println(index)

 join拼接字符串

	var str = "123-456-789"
	var arr = strings.Split(str, "-")
	var str2 = strings.Join(arr, "*")
	fmt.Println(str2)

byte和rune类型

组成每个字符串的元组叫做“字符”，可以通过遍历字符串获取元素获得字符。字符用单引号包裹起来，如：

package main
import "fmt"
func main() {
    a := 'a' b := '0' //当我们直接输出 byte（字符）的时候输出的是这个字符对应的码值
    fmt.Println(a)
    fmt.Println(b)
//如果我们要输出这个字符，需要格式化输出
    fmt.Printf("%c--%c", a, b) //%c 相应 Unicode 码点所表示的字符
}

一汉字占用3个字节，一个字母占用一个字节

a := "m"
fmt.Println(len(a)) //1
b := "张"
fmt.Println(len(b)) //3

Go语言的字符有以下两种：

  1，uint8类型，或者代表byte型，代表了ASCll码的一个字符

  2. rune 类型。代表一个UTF-8字符

当需要处理中文，日文或者其他复合字符时，则需要用到rune类型，rune类型实际是一个int32，go使用了特殊的rune类型来处理Unicode，让基于Unicode的文本处理更为方便，也可以使用byte型进行默认字符串处理，性能和扩展性都有照顾

修改字符串

要修改字符串，需要先将其转换成[]rune或者[]byte,完成之后再转换为string。无论那种转换。都会重新分配内存，并复制字节数组

package main

import "fmt"

func main() {
	s1 := "big"
	// 强制类型转换
	byteS1 := []byte(s1)
	byteS1[0] = 'p'
	fmt.Println(string(byteS1))
	s2 := "白萝卜"
	runeS2 := []rune(s2)
	runeS2[0] = '红'
	fmt.Println(string(runeS2))
}

数据整型转换

go中只有强制类型转换，没有隐式类型转换

1，数据整型之间的相互转换

数值类型包括：整型和浮点型

package main
import "fmt"
func main() {
    var a int8 = 20
    var b int16 = 40
    var c = int16(a) + b //要转换成相同类型才能运行
    fmt.Printf("值：%v--类型%T", c, c) //值：60--类型 int16
}

package main
import "fmt"
func main() {
    var a float32 = 3.2
    var b int16 = 6
    var c = a + float32(b)
    fmt.Printf("值：%v--类型%T", c, c) //值：9.2--类型 float32
}

// 转换的时候建议从低位转换成高位，高位转换成低位的时候如果转换不成功就会溢出，和我们想的结果不一样。如：

package main

func main() {
	var a int16 = 129
	var b = int8(a)  // 范围 -128 到 127
	println("b=", b) //b= -127 //错误
}



// 比如计算直角三角形的斜边长时使用 math 包的 Sqrt()函数，该函数接收的是 float64 类型的参数，而变量 a 和 b 都是 int 类型的，这个时候就需要将 a 和 b 强制类型转换为 float64 类型。
var a, b = 3, 4
var c int
// math.Sqrt()接收的参数是 float64 类型，需要强制转换
c = int(math.Sqrt(float64(a*a + b*b)))
fmt.Println(c)

 2. 其他类型转换成string类型

sprintf 把其他来学转换成string类型

注意：sprintf 使用中需要注意转换的格式 int为%d  float为%f  bool为%t   byte为%c

package main

import "fmt"

func main() {
	var i int = 20
	var f float64 = 12.456
	var t bool = true
	var b byte = 'a'
	var strs string
	strs = fmt.Sprintf("%d", i)
	fmt.Printf("str type %T ,strs=%v \n", strs, strs)
	strs = fmt.Sprintf("%f", f)
	fmt.Printf("str type %T ,strs=%v \n", strs, strs)
	strs = fmt.Sprintf("%t", t)
	fmt.Printf("str type %T ,strs=%v \n", strs, strs)
	strs = fmt.Sprintf("%c", b)
	fmt.Printf("str type %T ,strs=%v \n", strs, strs)
}

3，使用strconv包里面的几种转换方法禁止转换

package main

import (
	"fmt"
	"strconv"
)

func main() {
	//1、int 转换成 string
	var num1 int = 20
	s1 := strconv.Itoa(num1)
	fmt.Printf("str type %T ,strs=%v \n", s1, s1)
	// 2、float 转 string
	var num2 float64 = 20.113123
	/* 参数 1：要转换的值
	   参数 2：格式化类型
	   'f'（-ddd.dddd）、
	   'b'（-ddddp±ddd，指数为二进制）、
	   'e'（-d.dddde±dd，十进制指数）、
	   'E'（-d.ddddE±dd，十进制指数）、
	   'g'（指数很大时用'e'格式，否则'f'格式）、
	   'G'（指数很大时用'E'格式，否则'f'格式）。
	   参数 3: 保留的小数点 -1（不对小数点格式化）
	   参数 4：格式化的类型
	*/
	s2 := strconv.FormatFloat(num2, 'f', 2, 64)
	fmt.Printf("str type %T ,strs=%v \n", s2, s2)
	// 3、bool 转 string
	s3 := strconv.FormatBool(true)
	fmt.Printf("str type %T ,strs=%v \n", s3, s3)
	//4、int64 转 string
	var num3 int64 = 20
	/*第二个参数为 进制
	 */
	s4 := strconv.FormatInt(num3, 10)
	fmt.Printf("类型 %T ,strs=%v \n", s4, s4)
}

string类型转换成数值类型

1，string类型转换成int类型

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var s = "1234"
	i64, _ := strconv.ParseInt(s, 10, 64)
	fmt.Printf("值：%v 类型：%T", i64, i64)
}

2，string类型转换成float类型

package main

import (
	"fmt"
	"strconv"
)

func main() {
	str := "3.1415926535"
	v1, _ := strconv.ParseFloat(str, 32)
	v2, _ := strconv.ParseFloat(str, 64)
	fmt.Printf("值：%v 类型：%T\n", v1, v1)
	fmt.Printf("值：%v 类型：%T", v2, v2)
}

3，string类型转换成bool类型

package main

import (
	"fmt"
	"strconv"
)

func main() {
	b, _ := strconv.ParseBool("true") // string 转 bool
	fmt.Printf("值：%v 类型：%T", b, b)
}

4，string转字符

package main

import "fmt"

func main() {
	s := "hello 张三"
	for _, r := range s { //rune
		fmt.Printf("%v(%c) ", r, r)
	}
	fmt.Println()
}

注意：数值类型没法和bool类型进行转换

Go中的运算符

一，go内置运算符

1. 算术运算符
2. 关系运算符
3. 逻辑运算符
4. 位运算符
5. 赋值运算符

二，算术运算符

注意：++自增 和--自减  在go中是单独的语句，并不是运算符

package main

import (
	"fmt"
)

func main() {
	fmt.Println("10+3=", 10+3) // =13
	fmt.Println("10-3=", 10-3) // =7
	fmt.Println("10*3=", 10*3) // =30
	//除法注意：如果运算的数都是整数，那么除后，去掉小数部分，保留整数部分
	fmt.Println("10/3=", 10/3)     //3
	fmt.Println("10.0/3=", 10.0/3) //3.3333333333333335
	// 取余注意 余数=被除数-（被除数/除数）*除数
	fmt.Println("10%3=", 10%3)     // =1
	fmt.Println("-10%3=", -10%3)   // -1
	fmt.Println("10%-3=", 10%-3)   // =1
	fmt.Println("-10%-3=", -10%-3) // =-1
}


// 注意：在go中 ++ 和 -- 只能独立使用，错误写法如下：
var i int = 8
var a int
a = i++ //错误，i++只能独立使用
a = i-- //错误, i--只能独立使用
// 注意：在go中没有前++ 错误写法如下：
var i int = 1
++i // 错误，在 golang 没有 前++
--i // 错误，在 golang 没有 前--
fmt.Println("i=", i)


// ++ -- 正确写法：
package main

import "fmt"

func main() {
	var i int = 1
	i++
	fmt.Println("i=", i)
}

 三，关系运算符

package main

import (
	"fmt"
)

func main() {
	//演示关系运算符的使用
	var n1 int = 9
	var n2 int = 8
	fmt.Println(n1 == n2) //false
	fmt.Println(n1 != n2) //true
	fmt.Println(n1 > n2)  //true
	fmt.Println(n1 >= n2) //true
	fmt.Println(n1 < n2)  //flase
	fmt.Println(n1 <= n2) //flase
	flag := n1 > n2
	fmt.Println("flag=", flag)
}

四，逻辑运算符

package main

import (
	"fmt"
)

func main() {
	//演示逻辑运算符的使用 &&
	var age int = 40
	if age > 30 && age < 50 {
		fmt.Println("ok1")
	}
	if age > 30 && age < 40 {
		fmt.Println("ok2")
	}
	//演示逻辑运算符的使用 ||
	if age > 30 || age < 50 {
		fmt.Println("ok3")
	}
	if age > 30 || age < 40 {
		fmt.Println("ok4")
	}
	//演示逻辑运算符的使用 !
	if age > 30 {
		fmt.Println("ok5")
	}
	if !(age > 30) {
		fmt.Println("ok6")
	}
}

// 逻辑运算符短路演示
package main

import (
	"fmt"
)

func test() bool {
	fmt.Println("test...")
	return true
}
func main() {
	var i int = 10
	if i < 9 && test() {
		fmt.Println("ok...")
	}
	if i > 9 || test() {
		fmt.Println("hello...")
	}
}

五，赋值运算符

package main

import "fmt"

func main() {
	d := 8 + 2*8 // 赋值运算从右向左
	fmt.Println(d)
	x := 10
	x += 5 //x=x+5
	fmt.Println("x += 5 的值:", x)
	x1 := 10
	x1 -= 5 //x=x-5
	fmt.Println("x1 -= 5 的值:", x1)
	x2 := 10
	x2 *= 5 //x=x*5
	fmt.Println("x *= 5 的值:", x2)
	x3 := 10.0
	x3 /= 5
	fmt.Println("x /= 5 的值:", x3)
	x4 := 10
	x4 %= 3
	fmt.Println("x %= 3 的值:", x4)
}

 六，运算符练习

//1，有两个变量,a和b，要求将其进行交换，最终打印结果
package main

func main() {
	a := 5
	b := 10
	var t = a
	a = b
	b = t
	println(a, b)
}

// 2,假如还有100放假，问：xx个星期零几天
package main

import "fmt"

func main() {
	xingqi := 100 / 7
	day := 100 % 7
	fmt.Printf("如果还有100天放假，还有%v星期零%v天", xingqi, day)
}

// 定义一个变量保存华氏温度，华氏温度转换成摄氏稳定的公式为：；5/9*(华氏温度-100)，求出花式温度对应的摄氏温度
package main

import "fmt"

func main() {
	var huashi float64 = 188.4
	var sheshi float64 = 5.0 / 9 * (huashi - 100)
	fmt.Printf("%v,对应的摄制温度=%v", huashi, sheshi)
}

七，位运算符（了解）

位运算符对整数在内存中的二进制位进行操作。

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