golang基本语法

作者: 豆瓣奶茶 | 来源:发表于2018-03-28 20:55 被阅读22次

一、二进制、八进制、十进制、十六进制

1.1 进制

二进制：逢二进一，数值只有0和1。

八进制：逢八进一，数值有0,1,2,3,4,5,6,7

十进制：逢十进一，数值有0,1,2,3,4,5,6,7,8,9

十六进制：逢十六进一，数值有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F

1.2 进制转换

二进制、八进制、十六进制转为十进制

二进制转换为十进制

1011 0101
1*2^7+0*2^6 +1*2^5 +1*2^4 + 0* 2^3 + 1*2^2 + 0* 2^1 +1*2^0

八进制转换为十进制

236
2*8^2 + 3*8^1 +6*8^0

十进制转为二进制、八进制、十六进制
除以进制数

1.3 原码，反码，补码

1.3.1 机器数和真值

机器数：一个数在计算机中的二进制表示形式。叫做这个数的机器数。机器数是带符号的，最高位0表示正数，1表示负数。
    示例：
        比如10进制中的+3，计算机长度为8位。转为二进制是0000 0011。
        比如-3，转为二进制是1000 0011。

真值：因为第一位是符号位，所以机器数的形式值就不等于真正的数值。
    比如1000 0011，
        作为负数可以是-3，作为正数可以说131.
    为了区分，将带符号位的计算数对应的真正的数值称为机器数的真值。

1.3.2 原码，反码，补码

原码：就是符号位加上真值的绝对值，即第一位表示符号位，其余位表示值。
+1 = [0000 0001]原
-1 = [1000 0001]原
原码是人脑最容易理解和计算的表示方式.

反码：正数的反码是其本身，负数的反码是在其原码的基础上，符号位不变，其余各位按位取反。
+1 = [0000 0001]原 = [0000 0001]反
-1 = [1000 0001]原 = [1111 1110]反
一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算。

补码：正数的补码是其本身，负数的补码是在原码的基础上，符号位不变，其余各位取反后+1。
+1 = [0000 0001]原 = [0000 0001]反 = [0000 0001]补
-1 = [1000 0001]原 = [1111 1110]反 = [1111 1111]补
对于负数, 补码表示方式也是人脑无法直观看出其数值的. 通常也需要转换成原码在计算其数值.

于是人们开始探索将符号位参与运算, 并且只保留加法的方法. 首先来看原码。计算十进制的表达式: 1-1=0

1 - 1 = 1 + (-1) = [00000001]原 + [10000001]原 = [10000010]原 = -2

如果用原码表示, 让符号位也参与计算, 显然对于减法来说, 结果是不正确的.这也就是为何计算机内部不使用原码表示一个数.

为了解决原码做减法的问题, 出现了反码。计算十进制的表达式:

1-1=0

1 - 1 = 1 + (-1)
= [0000 0001]原 + [1000 0001]原
= [0000 0001]反 + [1111 1110]反
= [1111 1111]反 = [1000 0000]原
= -0

发现用反码计算减法, 结果的真值部分是正确的. 而唯一的问题其实就出现在”0”这个特殊的数值上. 虽然人们理解上+0和-0是一样的, 但是0带符号是没有任何意义的. 而且会有[0000 0000]原和[1000 0000]原两个编码表示0.

于是补码的出现, 解决了0的符号以及两个编码的问题:

1-1 = 1 + (-1)
= [0000 0001]原 + [1000 0001]原
= [0000 0001]补 + [1111 1111]补
= [0000 0000]补=[0000 0000]原

这样0用[0000 0000]表示, 而以前出现问题的-0则不存在了.而且可以用[1000 0000]表示-128:

二、变量与常量

2.1 什么是变量

变量是为存储特定类型的值而提供给内存位置的名称。在go中声明变量有多种语法。


变量：本质就是一小块内存，专门用于存储数据，在程序运行时，可以被改变
语法：var name type
   name=value
静态语言:就是强类型语言，严格的数据类型。会根据你的数据类型给你分配内存空间
动态语言：就是弱类型语言。你赋什么类型的值，变量就是什么类型

2.2 声明变量

var名称类型是声明单个变量的语法。

以字母或下划线开头，由一个或多个字母、数字、下划线组成

声明一个变量

第一种，指定变量类型，声明后若不赋值，使用默认值

var name type
name = value

第二种，根据值自行判定变量类型(类型推断Type inference)

如果一个变量有一个初始值，Go将自动能够使用初始值来推断该变量的类型。因此，如果变量具有初始值，则可以省略变量声明中的类型。

var name = value

第三种，省略var, 注意 :=左侧的变量不应该是已经声明过的(多个变量同时声明时，至少保证一个是新变量。如果其中有旧变量，则对于旧变量相当于更改数值)，全是旧变量时会导致编译错误(简短声明)

name := value

// 例如
var a int = 10
var b = 10
c : = 10

这种方式它只能被用在函数体内，而不可以用于全局变量的声明与赋值

示例代码：

package main
var a = "Hello"
var b string = "World"
var c bool

func main(){
    println(a, b, c)
}

运行结果：

Hello World false

多变量声明

第一种，以逗号分隔，声明与赋值分开，若不赋值，存在默认值。这种方式的类型必须一致

var name1, name2, name3 type
name1, name2, name3 = v1, v2, v3

第二种，直接赋值，下面的变量类型可以是不同的类型

var name1, name2, name3 = v1, v2, v3

第三种，集合类型

var (
    name1 type1
    name2 type2
)

注意事项

如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明，例如：a := 20 就是不被允许的，编译器会提示错误 no new variables on left side of :=，但是 a = 20 是可以的，因为这是给相同的变量赋予一个新的值。

如果你在定义变量 a 之前使用它，则会得到编译错误 undefined: a。

如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，例如下面这个例子当中的变量 a：

func main() {
   var a string = "abc"
   fmt.Println("hello, world")
}

尝试编译这段代码将得到错误 a declared and not used

此外，单纯地给 a 赋值也是不够的，这个值必须被使用，所以使用

每种类型都有自己的默认值，例如int的默认值就是0，string的默认值就是“”，空字符串

在同一个作用域中，已存在同名的变量，则之后的声明初始化，则退化为赋值操作。但这个前提是，最少要有一个新的变量被定义，且在同一作用域，例如，下面的y就是新定义的变量

package main

import (
    "fmt"
)

func main() {
    x := 140
    fmt.Println(&x)
    x, y := 200, "abc"
    fmt.Println(&x, x)
    fmt.Print(y)
}

运行结果：

0xc04200a2b0
0xc04200a2b0 200
abc

空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃

_ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值

例如函数返回2个值，但是我自己只使用其中一个。如果两个都接受，下面程序一个值不用的话会报错。所以我们就需要使用这个舍弃。有人说我返回一个不就行了？函数定义返回两个，你返回一个的话，此处编译不会通过。

并行赋值也被用于当一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)

2.3 常量声明

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型

不曾使用的常量，在编译的时候，是不会报错的（这点和变量不同）

常亮在声明的时候就必须赋值

var a=2
var b=7
const area = a * b   //报错，如果这么写必须把a和b都定义为const

var c="fjasldkfjaslkd"
const num=len(c)  //报错，把C定义为const则对。

显示指定类型的时候，必须确保常量左右值类型一致，需要时可做显示类型转换。这与变量就不一样了，变量是可以是不同的类型值

const identifier [type] = value

显式类型定义： const b string = "abc"
隐式类型定义： const b = "abc"

package main

import "fmt"

func main() {
   const LENGTH int = 10
   const WIDTH int = 5   
   var area int
   const a, b, c = 1, false, "str" //多重赋值

   area = LENGTH * WIDTH
   fmt.Printf("面积为 : %d", area)
   println()
   println(a, b, c)   
}

运行结果：

面积为 : 50
1 false str

常量可以作为枚举，常量组

const (
    Unknown = 0
    Female = 1
    Male = 2
)

常量组中如不指定类型和初始化值，则与上一行非空常量右值相同

package main

import (
    "fmt"
)

func main() {
    const (
        x uint16 = 16
        y
        s = "abc"
        z
    )
    fmt.Printf("%T,%v\n", y, y)
    fmt.Printf("%T,%v\n", z, z)
}

运行结果：

uint16,16
string,abc

2.4 iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。只用在常量组

在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次const声明，其所代表的数字会自动增加1

iota在const关键字出现时将被重置为0(const内部的第一行之前)，const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。

iota 可以被用作枚举值：

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

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：

const (
    a = iota
    b
    c
)

iota 用法

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

运行结果：

0 1 2 ha ha 100 100 7 8

如果中断iota自增，则必须显式恢复。且后续自增值按行序递增

自增默认是int类型，可以自行进行显示指定类型

数字常量不会分配存储空间，无须像变量那样通过内存寻址来取值，因此无法获取地址

三、基本数据类型

以下是go中可用的基本数据类型

image.png

2.1 布尔型bool

布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true

2.2 数值型

1、整型

int8 （8表示8个bit）
有符号 8 位整型 (-128 到 127)
int16
有符号 16 位整型 (-32768 到 32767)
int32
有符号 32 位整型 (-2147483648 到 2147483647)
int64
有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
uint8
无符号 8 位整型 (0 到 255)
uint16
无符号 16 位整型 (0 到 65535)
uint32
无符号 32 位整型 (0 到 4294967295)
uint64
无符号 64 位整型 (0 到 18446744073709551615)

int和uint:根据底层平台，表示32或64位整数。除非需要使用特定大小的整数，否则通常应该使用int来表示整数。
大小:32位系统32位，64位系统64位。
范围:-2147483648到2147483647的32位系统和-9223372036854775808到9223372036854775807的64位系统。

2、浮点型

float32

IEEE-754 32位浮点型数
float64

IEEE-754 64位浮点型数
complex64

32 位实数和虚数
complex128

64 位实数和虚数

3、其他

byte

类似 uint8，相当于给我类型起了别名
rune

类似 int32
uint

32 或 64 位
int

与 uint 一样大小，通操作系统相关

uintptr

无符号整型，用于存放一个指针

var a = 'A'
fmt.Println(a)    // 65
// %v 原型
// %q  对应utf8编码的字符
fmt.Println("a的数值：%d，%v,%q",a,a,a)   //a的数值：65

2.3 字符串型

字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本

var str string
str = "Hello World"  //string
str1 := `xu xiao feng`   //string
str2 := 'A'   //65 int32

2.4 派生类型

(a) 指针类型（Pointer）
(b) 数组类型
(c) 结构化类型(struct)
(d) Channel 类型
(e) 函数类型
(f) 切片类型
(g) 接口类型（interface）
(h) Map 类型

2.5 类型转换

强类型语言，运算时，需要统一类型

类型转换方式：T（v）

b :=3.14
c :=3.84
d :=int(b)   //3
e :=int(c)   //3  注意不是四舍五入

字符还能转一下，字符串是不能直接往数值上转的

四、运算符

3.1 算术运算符

+ - * / %(求余) ++ --
/  //取商
%  //取余，取模
++ -- //都是对于整型的

3.2 关系运算符

== != > < >= <=

3.3 逻辑运算符

运算符	描述
&&	所谓逻辑与运算符。如果两个操作数都非零，则条件变为真
\|\|	所谓的逻辑或操作。如果任何两个操作数是非零，则条件变为真
!	所谓逻辑非运算符。使用反转操作数的逻辑状态。如果条件为真，那么逻辑非操后结果为假

3.4 位运算符

A	B	A&B	A\|B	A^B
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	10

这里最难理解的就是^了，只要认为AB两者都相同的时候，为0，其他都为1

运算	描述	示例
&	二进制与操作副本位的结果，如果它存在于两个操作数	(A & B) = 12, 也就是 0000 1100
\|	二进制或操作副本，如果它存在一个操作数	(A \| B) = 61, 也就是 0011 1101
^	二进制异或操作副本，如果它被设置在一个操作数但不能同时是比特	(A ^ B) = 49, 也就是 0011 0001
<<	二进制左移位运算符。左边的操作数的值向左移动由右操作数指定的位数	A << 2 will give 240 也就是 1111 0000
>>	二进制向右移位运算符。左边的操作数的值由右操作数指定的位数向右移动	A >> 2 = 15 也就是 0000 1111

3.5 赋值运算符

运算符	描述	示例
=	简单的赋值操作符，分配值从右边的操作数左侧的操作数	C = A + B 将分配A + B的值到C
+=	相加并赋值运算符，它增加了右操作数左操作数和分配结果左操作数	C += A 相当于 C = C + A
-=	减和赋值运算符，它减去右操作数从左侧的操作数和分配结果左操作数	C -= A 相当于 C = C - A
*=	乘法和赋值运算符，它乘以右边的操作数与左操作数和分配结果左操作数	C = A is equivalent to C = C A
/=	除法赋值运算符，它把左操作数与右操作数和分配结果左操作数	C /= A 相当于 C = C / A
%=	模量和赋值运算符，它需要使用两个操作数的模量和分配结果左操作数	C %= A 相当于 C = C % A
<<=	左移位并赋值运算符	C <<= 2 相同于 C = C << 2
>>=	向右移位并赋值运算符	C >>= 2 相同于 C = C >> 2
&=	按位与赋值运算符	C &= 2 相同于 C = C & 2
^=	按位异或并赋值运算符	C ^= 2 相同于 C = C ^ 2
\|=	按位或并赋值运算符	C \|= 2 相同于 C = C \| 2

3.6优先级

运算符优先级
有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：

优先级	运算符
7	^ !
6	* / % << >> & &^
5	+ - \| ^
4	== != < <= >= >
3	<-
2`	&&
1	\|\|

当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。

golang基本语法

一、二进制、八进制、十进制、十六进制

1.1 进制

1.2 进制转换

1.3 原码，反码，补码

1.3.1 机器数和真值

1.3.2 原码，反码，补码

二、变量与常量

2.1 什么是变量

2.2 声明变量

多变量声明

注意事项

2.3 常量声明

2.4 iota

三、基本数据类型

2.1 布尔型bool

2.2 数值型

2.3 字符串型

2.4 派生类型

2.5 类型转换

四、运算符

3.1 算术运算符

3.2 关系运算符

3.3 逻辑运算符

3.4 位运算符

3.5 赋值运算符

3.6优先级

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

区块链系统教程