127-Golang复习（一）

 

 

 

 

Go语言
Golang

特点
1.Google开源

2.编译型语言
这里就要说一下编译型语言和解释型语言的区别

解释型语言的源代码不是直接翻译成机器语言，而是先翻译成中间代码，然后再由解释器对中间代码进行解释运行
比如Python,Java等

编译型语言
直接把源代码编译成二进制的可执行文件，然后就交给处理器
比如C，Go

 

 

 

计算机语言的发展
简单说一下一些语言的诞生年代
C    1972年
C++    1979年
Python    1991年
Java    1995年
Ruby    1995年
PHP    1995年
JavaScript    1995年
Go    2007年

 

 

 

配置GOPATH
gopath就是go的项目的路径，也就是工作目录
所有的项目都放在gopath的src目录下面

 

 

 

编译
go build就可以把项目代码编译成可执行文件
在windows就是exe文件

-o指定名字
go build -o hello

 

 

跨平台编译
比如现在是在windows上编译，那么出来的是exe的windows的程序
那么如果要编译出linux系统下的可执行文件
就可以设置
set GOOS=linux
set GOARCH=amd64

在其他系统内也是一样的道理，先设置好想要的系统，然后再进行编译

 

 

 

 

语句的位置
Java的所有语句都是在Class的函数下面
Go的所有语句都是在函数里面
Python就可以直接写语句
js也可以直接写语句

 

 

 

关键字
go中有25个关键字
break    default    func    interface    select
case    defer    go    map    struct
chan    else    goto    package    switch
const    fth(缩写）    if    range    type
continue    for    import    return    var

还有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

这里有一个比较有意思的点就是 保留字是可以被设置成变量名的，比如
true:="123"

但是呢，不要用这些保留字作为变量名
以后如果某些保留字被更新成关键字，那么程序就不兼容了

 

 

 

变量
比如现在内存是这样的
00000001  000000002 00000003
然后如果分成字节的话，依次下来内存地址为
0x01，0x02，0x03

然后在栈内存中保存变量，比如a,b,c
然后a指向0x01,
b指向0x02,
c指向0x03

 

 

 

声明变量
var abc

var是什么意思，就是variable变量

那么直接var abc是不行的
因为没有给他类型

这里就有一个概念了，叫静态语言和动态语言
像go，java就是静态语言，比如给出类型

像python,php,js就是动态语言，不用给类型

所以声明要这样
var name string
var age uint
var ok bool

也可以批量声明
var(
  name string
  age uint
)

另外，如果变量声明了，但是没有使用
那么就会编译失败

 

 

 

print打印
Print
Printf
Println
%s占位符，替换打印
fmt.Printf("name:%s",name)

 

 

 

类型推导
var name string="abc"
这种情况可以直接写成
var name="abc"
因为根据后面的值直接可以推导出是什么类型
就不用写类型了

快速变量声明（简短变量声明）
name:="abc"
这个只能在函数里面用
不能在函数外面用

所以函数外面只能是
var name="abc"

 

 

 

 

匿名变量
直接用_下划线来表示
x,_:=function()
_,y:=function()

 

 

 

批量常量
const(
  n1=100
  n2
  n3=200
  n4
)

全局的变量和常量，声明了没用也没关系

 

 

 

 

iota
常量计数器

const(
  n1=iota
  n2
  n3
)

n1是0，n2是1，n3是2

 

 

 

 

整型
int8    -128到127
int16    -32768到32767
int32    -2^31到2^31-1
int64    -2^63到2^63-1

uint8    0到255
uint16    0到65535
uint32    0到2^32-1
uint64    0到2^64-1

uint    32位系统是uint32,64位系统是uint64
int    32,64
uintptr    无符号整型，存放一个指针

 

 

 

 

八进制，十六进制
var a int =10
var b int =077
var c int =0xb

fmt.Printf()
%d    十进制
%o    八进制
%x    十六进制
%b    二进制

 

 

 

浮点数
float32,float64

我们可以看一下浮点数最大是多少
可以打开go的math包下面的const包
/math/const

// Floating-point limit values.
// Max is the largest finite value representable by the type.
// SmallestNonzero is the smallest positive, non-zero value representable by the type.
const (
    MaxFloat32             = 3.40282346638528859811704183484516925440e+38  // 2**127 * (2**24 - 1) / 2**23
    SmallestNonzeroFloat32 = 1.401298464324817070923729583289916131280e-45 // 1 / 2**(127 - 1 + 23)

    MaxFloat64             = 1.797693134862315708145274237317043567981e+308 // 2**1023 * (2**53 - 1) / 2**52
    SmallestNonzeroFloat64 = 4.940656458412465441765687928682213723651e-324 // 1 / 2**(1023 - 1 + 52)
)

我们可以看到这一段
就是float32和float64的范围

 

 

 

 

浮点数赋值
默认的话就是float64
f1:=1.23
f2:=float32(f1)

然后互相的话是不能赋值的

 

 

 

 

复数（用的很少）
complex64,,complex128
实部和虚部32，实部和虚部64

 

 

 

布尔值bool
go语言中不允许将整型转成bool
bool无法参与数值运算，也无法与其他类型转换

 

 

 

字符串
字符串只能用双引号""
字符才是单引号''

 

字符
英文数字都是1个字节
utf8的汉字一般是3-4个字节

这里有一个非常关键的点

s:= "一二三四五"
fmt.Println(len(s))
这里输出的是15
因为len方法实际上返回的是字节长度
中文字符在utf8编码中是3-4个字节
所以这里的长度len是15

如果想要字符的长度，那么
s:= "一二三四五"
fmt.Println(len(s))
fmt.Println(utf8.RuneCountInString(s))

这里输出的是5
这个事情其实是非常非常关键的

 

 

byte和rune
byte实际上是uint8类型，代表了ascii码的一个字符
rune是一个utf-8字符
rune实际上是int32

byte是uint8,所以只能是0-255
'a'，'1'和‘一’都是rune类型，都是int32

 

 

 

for循环的几种格式

第一种，基本格式
for i:=0;i<10;i++{
}

第二种，
var i=5
for ;i<10;i++{
}

第三种
var i=5
for i<10{
  i++
}

第四种 range
s:="Hello"
for k,v := range s{

}

 

 

 

fallthrough
在switch当中
如果满足了a，然后fallthrough
会执行下一个case

 

 

 

 

跳出外层for循环

    for i := 0; i < 5; i++ {
        for j := 0; j < 5; j++ {
            if i == 2 {
                break
            }
            fmt.Printf("%d === %d \n", i, j)
        }
    }

在这个例子中，我们用break
但是只是跳出了内层循环
那么如果我们想要跳出外层循环
可以用flag，也可以用goto

func main() {

    for i := 0; i < 5; i++ {
        for j := 0; j < 5; j++ {
            if i == 2 {
                goto end
            }
            fmt.Printf("%d === %d \n", i, j)
        }
    }

end:
    end()
}

func end() {
    fmt.Println("end")
}

这里的end是label标签
label标签定义了没有使用的话也会报错的
所以定义了label也要使用

 

 

或者我们可以直接把for循环加一个label
然后直接break这个label

myloop:
    for i := 0; i < 5; i++ {
        for j := 0; j < 5; j++ {
            if i == 2 {
                break myloop
            }
            fmt.Printf("%d === %d \n", i, j)
        }
    }

 

 

 

 

 

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

1.算术
+,-,*,/,%

2.关系
==
!=
>=
<=

3.逻辑
&&
||
!
与或非

4.位运算符
&    按位与，2个1才是1
|    按位或，2个0才是0
^    异或，不一样就是1
<<    左移，x*2^n    8<<1=16
>>    右移，x/2^n    16>>1=8

5.赋值运算符
+=
-=
等等