• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    迪恩网络公众号

Go语言基本语法 1 二进制八进制16进制

原作者: [db:作者] 来自: [db:来源] 收藏 邀请



## 一、二进制、八进制、十进制、十六进制【扩展内容】


### 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 进制转换


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


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


### 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中声明变量有多种语法。


### 2.2 声明变量


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


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


声明一个变量


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


```go
var name type
name = value
```


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


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


```go
var name = value
```


第三种,省略var, 注意 :=左侧的变量不应该是已经声明过的(多个变量同时声明时,至少保证一个是新变量),否则会导致编译错误(简短声明)


```go
name := value


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


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


示例代码:


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


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


运行结果:


```go
Hello World false
```


#### 多变量声明


第一种,以逗号分隔,声明与赋值分开,若不赋值,存在默认值


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


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


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


第三种,集合类型


```go
var (
    name1 type1
    name2 type2
)
```


#### 注意事项


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


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


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


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


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


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


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


```go
package main


import (
"fmt"
)


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


运行结果:


```go
0xc04200a2b0
0xc04200a2b0 200
abc
```


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


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


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


### 2.3 常量声明


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


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


不曾使用的常量,在编译的时候,是不会报错的


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


```go
const identifier [type] = value
```


```go
显式类型定义: const b string = "abc"
隐式类型定义: const b = "abc"
```


```go
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)   
}
```


运行结果:


```go
面积为 : 50
1 false str
```


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


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


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


```go
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)
}
```


运行结果:


```go
uint16,16
string,abc
```


### 2.4 iota


iota,特殊常量,可以认为是一个可以被编译器修改的常量


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


iota 可以被用作枚举值:


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


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


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


**iota 用法**


```go
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中可用的基本数据类型


![](http://om1c35wrq.bkt.clouddn.com/002%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B.jpg)






### 2.1 布尔型bool


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


### 2.2 数值型


**1、整型**


- int8
  有符号 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


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






### 2.3 字符串型


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


```go
var str string
str = "Hello World"
```


### 2.4 派生类型


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


## 四、运算符


###3.1  算术运算符


```go
+ - * / %(求余) ++ --
```


###3.2 关系运算符


```go
== != > < >= <=
```


###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    | 1    |


这里最难理解的就是^了,只要认为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    | \|\|             |


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

==========================================================

从事区块链工作三年,作为一名区块链开发和从业人员,看现在市场混乱,培训机构,

各种吹嘘,实在受不了,从今天开始每天更新3篇到10篇博客帮助,小白解决问题,同时和几位大佬

建立知识星球,有任何问题,可以进行提问,帮助学习解答。目前博客路线从go语言开始到分布式到比特币以太坊

超级账本,eos的讲解从安装搭建环境到如何使用,并讲解api和源码解析。并介绍现在企业如何面试,区块链面试题等。

帮人代写白皮书(价格高)。


https://mp.csdn.net/postedit

知识星球《区块链技术交流》做好的区块链技术问答社区,欢迎来提问,作为星球成员福利,成员可加入区块链技术付费交流群。 


=======================================================================================





鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
SQL中GO的作用发布时间:2022-07-10
下一篇:
go语言——输入输出发布时间:2022-07-10
热门推荐
热门话题
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap