文章由小编马志国在网易的原创,若转发请于鲜明处标志出处:

一、二进制、八进制、10进制、十陆进制

日期:2014年7月19日

2.1 变量

变量是对一块内部存款和储蓄器空间的命名,程序能够经过定义一个变量来申请壹块内部存款和储蓄器空间。然后可以因而引用变量名来使用那块存款和储蓄空间。

 图片 1

1.1 进制

2进制:逢2进壹,数值唯有0和一。

八进制:逢八进1,数值有0,壹,贰,三,四,伍,6,七

10进制:逢十进一,数值有0,一,2,3,肆,五,陆,七,捌,玖

十陆进制:逢十6进一,数值有0,一,二,三,肆,伍,陆,七,八,玖,A,B,C,D,E,F

一、Go
在语法上有着类 C
的痛感。就算你指望将三个(或更多)语句放在1钟鼓文写,它们
必须用分号分隔。一般情况下,你不须求分号。

二.1.壹 变量命名

Go语言中的变量名、常量名、类型名、函数名和包名等有着的命名和C语言同样都遵照那样多个简约的命名规则:3个名字务必以二个字母或下划线开头,后边能够跟任意数量的假名、数字或下划线。对于字母区分轻重缓急写,例如:name和Name是七个不等的名字。

命名不可能与第三字同样,Go语言提供了贰四个第一字,只可以在特定的语法中动用。

二四个根本字

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语言还有大约30多个预订义的名字,首要用以内建的常量、类型和函数。那一个名字不是重要字,能够再度定义和应用,即便在某个特殊情况中另行定义是有意义的,但建议尽量不要再一次定义,以促成语义混乱难点。

内建常量

true false iota nil

内建项目

int int8 int16 int32 int64

uint uint8 uint16 uint32 uint64 uintptr

float32 float64 complex128 complex64

bool byte rune string error

内建函数

make len cap new append copy close delete

complex real imag

panic recover

 

一.2 进制调换

二进制、8进制、十陆进制转为10进制

  • 二进制转变为10进制

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
  • 八进制转变为10进制

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

10进制转为2进制、捌进制、十陆进制
除以进制数

贰、Go 同任何语言差别的地方在于变量的门类在变量名的前边。例如:不是,int
a,而是 a int。当定义了3个变量,它暗中认可赋值为其项目标 null
值。这代表,在 var a int后,a 的 值为 0。而 var s string,意味着 s
被赋值为零长度字符串,也正是 “”。

贰.1.2 变量申明

壹 一般宣称格式

使用var能够制造一个一定项指标变量。变量证明的貌似语法如下:

var 变量名 类型 =  表达式

中间“类型”或“=表明式”多个部分能够简简单单当中的3个。假若轻易的是类型新闻,那么将遵照开头化表达式来演绎变量的花色。假设表达式省略,将用零值起先化该变量。

var i int = 1

var j int   //j的值初始化为0

var k = 10  // k的类型自动推导

如若多个名字在函数内部定义,那么它不得不在函数内部选取,假设在函数外部定义,那么在近日包的保有文件都得以访问。名字首字母的深浅写决定了它在包外的可知性,首字母大写在包外能够访问。包本人的名字1般总是用小写字母。

在包等级注解的变量会在main入口函数实行在此以前到位开头化,局地变量就要注脚语句被施行的时候做到初叶化。如果未有呈现开始化,那么将用零值初步化该变量。四个变量表明后尚未动用也会挑起编写翻译错误。

二 简短变量注明

“名字 := 表明式”,变量的体系依照表明式自动推导。由于采纳简便利落,被大面积用于半数以上的部分变量的宣示和开首化。注意,简短变量申明不能够用于包级其他变量评释。

i := 100

 

三 四个变量申明

var i, j, k int = 1, 2, 3

var m, n int

var a, b, c = 1, 2, 3

d, e, f := 1, 2, 3

name, age := "张三", 20

也足以如此写:

var (

     name string

     age  int

)

 

1.3 原码,反码,补码

三、Go语言的变量证明和赋值

2.1.3 赋值

1 轻巧赋值

赋值语句是立异一个变量的值,最简易的赋值”变量名= 新值的表达式”

var i int

i = 1      //简单赋值

 

二复合赋值运算符

一定的二元算术运算符和赋值语句的复合操作有1个简练的方式

var i int

i = i + 1

i += 1    //与i = i + 1等价

 

数值变量也能够帮衬++递增和–递减语句。注意它是唇舌,不是表达式,所以x=i++那样的表明式是不对的。

三多重赋值

多种赋值允许同时更新多个变量的值。在赋值从前,赋值语句右侧的保有表明式会先举行求值,然后再统1更新左边对应的变量的值。那样在做多个数值调换时,不要求引进第多个变量了。

x,y=y,x

4 _标识符

有点表明式会发生八个值,例如调用叁个有多个重返值的函数。能够行使下划线空白标记符_来屏弃不须要的值。

_, err := io.Copy(dst, src)//丢弃字节数

 

一.3.1 机器数和真值

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

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

     在Go中使用var对变量举行宣示,

2.2 常量

在Go语言中,常量是指编写翻译时期就已知且不可改动的值。常量的心腹类型都以基础项目,包罗整型、浮点型、复数型、布尔类型和字符串类型等。

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]补
对于负数, 补码表示方式也是人脑无法直观看出其数值的. 通常也需要转换成原码在计算其数值.

于是芸芸众生开首斟酌 将标识位参加运算, 并且只保留加法的方法.
首先来看原码。计算十进制的表明式: 一-一=0

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

比方用原码表示, 让符号位也插足总结, 分明对于减法来讲,
结果是不得法的.那也正是干吗计算机内部不选取原码表示3个数.

为了缓解原码做减法的主题材料, 出现了反码。计算10进制的表达式:

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 字面常量

所谓字面常量,是指程序中硬编码的常量,如:

25

3.14159

2+3i

true

"hello"

在别的语言中,常量平时有特定的档次,Go语言的字面常量是无类型的。只要这一个常量在对应类别的值域范围内,就能够作为该项目标常量。例如,贰五方可赋值给int、 uint、int3贰、int6四、float32、float64、complex6四、complex12八等项目标变量。

二、变量与常量

      var a int 

2.贰.二 常量申明

运用const来声称常量,能够给常量一个温馨的名字例如:

const pi = 3.1415926

也足以批量声称:

const (

     e = 2.7182818

     pi = 3.1415926

)

一个常量的宣示也得以限制品种,但不是不可缺少的。假若未有显得钦命项目,那么它与字面量同样,是无类型常量。常量定义的右值也得以是3个在编写翻译期运算的常量表明式,例如:

const i = 1 << 3 //右值是常量表达式

假若是批量注明的常量,除第贰个外别的的常量的右手的初阶化表达式都得以轻易,私下认可使用前边常量的发轫化表明式写法。例如:

const (

        a = 1

        b

        c = 2

        d

        e

    )

    fmt.Println(a, b, c, d, e)

打印结果:1 1 2 2 2

2.一 什么是变量

变量是为存款和储蓄特定类型的值而提须求内部存款和储蓄器地点的称号。在go中评释变量有四种语法。

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

      a = 15

二.2.3 iota常量生成器

Go语言预约义的常量有:true、false和iota,其中iota比较特别。常量注明能够使用iota常量生成器初阶化,它用于生成一组以1般规则开始化的常量,不过并非每行都写贰遍起头化表达式。在贰个const注明语句中,在第二个申明的常量所在的行,iota将会被置为0,然后在每三个有常量注明的行加壹。上面是发源time包的例证。这种定义法在Go语言中一般用于定义枚举值。

type weekday int

const(

    Sunday weekday iota   //0

    Monday                //1   

    Tuesday               //2

    Wednesday             //3

    Thursday              //4

    Friday                //5 

    Saturday              //6

)

大家也足以在复杂的常量表明式中央银行使iota,例如上面种种常量都以102四的幂。

const (

    _ = 1 << (10 * iota)

    KiB

    MiB

    GiB

    TiB

)

fmt.Println(KiB, MiB, GiB, TiB)

打印结果:1024 1048576 1073741824 1099511627776

总括:var 申明变量,const评释常量。申明时得以带项目。也足以不带项目,通过右测度。

二.二 注明变量

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

以字母或下划线初始,由一个或七个字母、数字、下划线组成

宣示1个变量

先是种,钦赐变量类型,注解后若不赋值,使用暗中同意值

var name type
name = value

第二种,依据值自行剖断变量类型(类型揣摸Type inference)

1经1个变量有3个开首值,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将变量a注明为int型,然后通过=赋值。

②.三 数据类型

Go语言将数据类型分为四类:基础项目、复合类型、引用类型和接口类型。

  1. 主旨数据类型:数值、字符串和布尔型。
  2. 复合数据类型:数组和结构体。
  3. 引用类型:指针、切块、字典、函数和通道。
  4. 接口类型。

多变量注明

先是种,以逗号分隔,注脚与赋值分开,若不赋值,存在私下认可值。这种方式的品种必须1致

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

第二种,直接赋值,上边包车型客车变量类型能够是见仁见智的连串

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

其两种,集合类型

var (
    name1 type1
    name2 type2
)

     当然在Go语言中,大家能够把注解和赋值进度一步成功,

2.3.1 整数

1 整数类型

Go语言的数值类型涵盖了两种分裂长度的平头、浮点数和复数。每一个数值类型都决定了相应的取值范围和是或不是扶助正负号。

 

类型

长度(字节)

取值范围

int8

1

(0~255)

uint8

1

(-128~127)

int16

2

(0~65535)

uint16

2

(-32768~32767)

int32

4

(-2147483648~2147483647)

uint32

4

(0~4294967295)

int64

8

(-9223372036854775808~9223372036854775807)

uint64

8

(0~18446744073709551615)

int

4或8

与机器字长和编译器都有关系

uint

4或8

与机器字长和编译器都有关系

uintptr

4或8

32平台4个字节,64位平台8个字节,底层编程才需要

byte

1

与uint8等价,通常表示一个unicode字符编码

rune

4

与int32等价,一般强调是一个原始数据而不是一个小整数。在一个字符串中,表示一个字符对应utf8的码点。

 

2 运算符

Go语言提供了拉长的松开运算符,包罗算术运算符、相比运算符、逻辑运算符、位运算符、赋值运算符和其他运算符等。

算术运算符:

运算符

描述

+

*

/

%

模运算(求余数)

++

自增

自减

 

在Go语言中,%取模运算符的标识和被取模的标识总是同样的,因而5%3和5%-三的结果都以二。除法运算符的结果则凭借于操作数是不是全为整数,例如五.0/4.0的结果是一.25,不过7/四的结果为一,去掉小数部分,而不是肆舍伍入。

关系(比较)运算符:

多少个同样的整数类型可以行使上边包车型客车二元关系运算符实行对比,比较表达式的结果是布尔类型。

运算符

描述

==

相等

!=

不等

<

小于

<=

小于或等于

>

大于

>=

大于或等于

 

 

逻辑运算

运算符

描述

!

&&

||

 

位运算:

前5个操作运算符并不区分是有号子依然无符号数:

运算符

描述

&

位与and (左侧和右侧都为1,则为1;否则为0)

|

位或 or(左侧或右侧只要有一个为1,结果为1;都为0结果才为0)

^

位异或 xor (相同为0,不同为1)

&^

位清空and not(右侧是0,左侧数不变;右侧是1,则左侧数清零)

<<

左移

>>

右移

位运算的事例:

X=2,y=15

二进制结果

十进制结果

0000 0010 & 0000 1111

0000 0010

 2

0000 0010 | 0000 1111

0000 1111

15

0000 0010 ^ 0000 1111

0000 1101

13

0000 0010 &^ 0000 1111

0000 0000

0

0000 0010<<3  

0001 0000

16

0000 0010>>1

0000 0001

1

 

运算符优先级:

 

 

注意事项

一经在平等的代码块中,大家不得以重新对于同一名称的变量使用初始化申明,例如: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的暗中同意值就是“”,空字符串

在同2个作用域中,已存在同名的变量,则之后的注明开首化,则战败为赋值操作。但以在此在此之前提是,最少要有三个新的变量被定义,且在平等功效域,例如,上面包车型大巴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 = 伍, 柒 中被放弃

_ 实际上是二个只写变量,你不可能获取它的值。那样做是因为 Go
语言中你必须接纳具备被声称的变量,但有时候你并不必要使用从1个函数获得的有所重回值

比如函数再次回到1个值,但是作者要好只行使在那之中2个。假诺八个都接受,下面程序1个值不用的话会报错。所以大家就须求动用那些舍弃。有人说作者回来一个不就行了?函数定义重返三个,你回来三个来讲,此处编译不会因此。

互相之间赋值也被用来当1个函数再次回到七个重回值时,比如那里的 val 和错误 err
是透过调用 Func① 函数同时获取:val, err = Func一(var一)

     例如:

2.3.2 浮点数

浮点数用于表示包括小数点的多少。Go语言提供了两种精度的浮点数,float3二和float64。float3二与float64之间需求强制调换。强制转变的方式T(V),T为要调换的靶子项目,V供给转移的变量。

一 浮点数表示

var f1 float32

f1 = 10

f2 := 12.0 //带小数点的自动推导为float64

f2 = float64(f1) //需强制转换

 

二 浮点数比较

因为浮点数不是一种标准的说明格局,所以不可能像整型这样直接用==比较。推荐的主意如下,引进math包,总计三个数值之差的断然值,纵然这些结果非常小,大家就觉着那四个数值是相等的。至于这么些数小到哪边程度定义为相等,程序员能够依据项目必要协调定义。

import  "math"

func IsEqual(f1, f2, p float64) bool {

    return math.Abs(f1-f2) < p

}

 

叁 科学计数法

把三个数表示成a(一≤a<拾,n为整数)与十的幂相乘的样式,那种记数法叫做科学记数法。例如:一九八八=1.9玖×十^3。计算器或微型计算机表明拾的幂是相似是用E或e,也便是一.9九E3=1九玖零。

f1 := 1.99e+3   //1990

f2 := 1.99e-3   //0.00199

 

二.三 常量申明

常量是2个简便值的标志符,在程序运行时,不会被涂改的量。

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

不曾使用的常量,在编写翻译的时候,是不会报错的(那点和变量差别)

常亮在宣称的时候就务须赋值

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

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

来得钦命项目标时候,必须保险常量左右值类型1致,必要时可做体现类型调换。那与变量就不平等了,变量是能够是见仁见智的类型值

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

      a := 一伍(那一形式只可用在函数内)

2.3.3 复数

Go语言提供了三种精度的复数类型:complex6四和complex128,分别对应float3二和float6四二种浮点数精度。内建函数和自然的书写格局。

x := complex(1, 2) //内建函数

y := 1 + 2i     //自然书写

// real返回实部,imag返回虚部

fmt.Println(x, y, real(x), imag(x), real(y), imag(y))

打印结果:(1+2i) (1+2i) 1 2 1 2

2.4 iota

iota,特殊常量,能够以为是三个方可被编写翻译器修改的常量。只用在常量组

在每三个const关键字出现时,被重新初始化为0,然后再下三个const出现此前,每出现一遍const证明,其所表示的数字会自动增加一

iota在const关键字出现时将被重新恢复设置为0(const内部的率先行在此以前),const中每新扩张一行常量注解将使iota计数3次(iota可清楚为const语句块中的行索引)。

iota 能够被用作枚举值:

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

第多少个 iota 等于 0,每当 iota 在新的1行被运用时,它的值都会自动加
一;所以 a=0, b=一, 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类型,能够活动举办呈现钦赐项目

数字常量不会分配存储空间,无须像变量那样通过内部存款和储蓄器寻址来取值,由此十分的小概获得地址

   
 在那种情状中,变量的类别是由值推演出来的,值15是int的品类的,推演出变量a为int类型。

2.3.4 布尔型

一个布尔类型的值只有三种:true和false。布尔值不会隐式转变为数值0或1。布尔值能够和&&、||操作符结合,并且或然会有梗塞行为。若是运算符左侧已经得以规定整个布尔表明式的值,那么左边的表明式将不再求值。

var s string

//s = "mazhiguo"

if s != "" && s[0] == ‘m’ {

   fmt.Println("OK")

else {

   fmt.Println("error")

}

三、基本数据类型

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

图片 2

image.png

     

2.3.5 字符串

壹 字符串常用操作

在Go语言中字符串也是一种基本类型。叁个字符串是3个不得改动的字节体系。常用的字符串操作如下表所示:

运算

含义

备注

s1+s2

字符串连接

 

len(s)

字符串长度

字符串中的字节数,不是字符数

s[i]

取字符

索引i不能越界

s[i:j]

取子字符串

左闭右开,包含s[i],不包含s[j]。子字符串是一个新的字符串。

i,j都可能被忽略,忽略时,从0开始,最后一个字符结束。

 

s := "hello " + "world"

fmt.Println(len(s))// 11

fmt.Println(s[0], s[len(s)-1])//104 100 (h 和 d)

fmt.Println(s[1:4])//"ell"

fmt.Println(s[:5])//"hello"

fmt.Println(s[6:])//"world"

fmt.Println(s[:])//"hello world"

贰 字符串值不可变

字符串的值是不可变的:二个字符串包涵的字节类别恒久不会被退换,当然大家能够给三个字符串变量分配贰个新字符串值。

s := "hello world"

s[0] = "H"  //这是错误演示,字符串序列不能修改

s = "Hello" //给字符串变量s重新赋值

三 字符串遍历

字符串遍历支持以字节的章程遍历和以字符的措施遍历。

s := "hello 世界"

n := len(s)

//以字节的方式遍历

for i := 0; i < n; i++ {

  fmt.Println(i, s[i])

}

//以字符的方式遍历

for i, ch := range s {

  fmt.Println(i, ch)

}

 

打印结果:

0 104

1 101

2 108

3 108

4 111

5 32

6 228

7 184

8 150

9 231

10 149

11 140

0 104

1 101

2 108

3 108

4 111

5 32

6 19990

9 30028

 

四转义行列

在三个双引号包蕴的字符串字面值中,能够用反斜杠\始于的转义系列插入任意的数据。

大规模的ASCII调控代码的转义方式:

 

 

 

\a

响铃

\b

退格

\f

换页

\n

换行

\r

回车

\t

水平制表符

\v

垂直制表符

\’

单引号

\”

双引号

\\

反斜杠

 

 

5原生字符串字面值

原生的字符串字面值,用` `替代双引号。可用于编写正则表明式。常用来HTML模板、JSON票面价值、命令提示音信以及要求扩充到多行的场景。

tips := `请按要求执行以下操作:

 1 输入参数

 2 计算

 3 打印结果`

fmt.Println(tips)

 

6 UTF8编码

UTF8编码是1种字符编码,使用1到伍个字节表示3个字符。ASCII部分字符只利用3个字节,常用字符部分应用二或二个字节。变长的编码不可能直接通过索引来访问第n个字符。

Go语言的源文件接纳UTF捌编码,unicode/utf8包提供提供了用于rune字符体系的UTF八编码和解码作用。若是关怀各样unicode字符,能够应用UTF八解码器。unicode/utf8席卷提供了该功效。

s := "hello 世界"

fmt.Println(len(s))    //12

fmt.Println(utf8.RuneCountInString(s))//8

将2个整数型转变为字符串意思是生成以只含有对应unicode编码字符的UFT捌字符串,如果对应的编码的字符无效,将用‘\uFfFD’无效字符作为替换:

fmt.Println(string(65))      //"A"

fmt.Println(string(0x4eac))  //"京"

fmt.Println(string(12345678)) //无效字符

 

string 接受到[]rune的类型调换,可以将七个UTF8编码的字符串解码为unicode字符串系列:

s := "世界"

fmt.Printf("%x\n", s) //e4b896e7958c,utf8编码

r := []rune(s)

fmt.Printf("%x\n", r) //[4e16 754c],unicode编码

 

 

诸如”汉”字的Unicode编码是陆C4九。6C4玖在0800-FFFF之间,所以要用3字节模板:11拾xxxx 10xxxxxx 10xxxxxx。将6C4玖写成2进制是:0110 1十0 0100 100一,将以此比特流按叁字节模板的分支方法分为01十 1一千一 00拾0一,依次代替模板中的x,获得:1110-0110 十-110001 十-00100一,即E陆 B一 8九,那正是其UTF8的编码。

s := "汉"

fmt.Printf(" %x\n", s) // e6b189,UTF8编码

r := []rune(s)

fmt.Printf("%x\n", r)  //[6c49],unicode编码

unicode也正是字符编码,即字典。utf八、uft1陆是哪些以字节的章程存储这几个编码。字符串可正如、可遍历、不可修改。

2.1 布尔型bool

布尔型的值只好够是常量 true 可能 false。一个简约的例证:var b bool =
true

     使用var能够声美素佳儿组变量,

2.4指针

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或陆拾四个人整数。除非供给动用一定大小的整数,不然壹般应该利用int来表示整数。
大小:32位系统32位,64位系统64位。
界定:-214748364八到2147483647的3二位系统和-922337203685477580八到922337203685477580七的60位系统。

2、浮点型

  • float32

    IEEE-754 三11个人浮点型数

  • float64

    IEEE-754 6三个人浮点型数

  • complex64

    3二 位实数和虚数

  • complex128

    6四 位实数和虚数

3、其他

  • byte

    恍如 uint八,也正是给自身类型起了别称

  • rune

    类似 int32

  • uint

    32 或 64 位

  • int

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

  • uintptr

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

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

     例如:var (

二.四.壹 指针概念

指南针是三个种类,该类型的变量称为指针变量。指针变量存款和储蓄叁个变量的地址。它分裂于壹般的变量,壹般变量存放的是数据本人,而指针变量存放的是数量的地址。

 图片 3

2.三 字符串型

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

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

                     a int

二.四.二 评释指针变量

声明指针变量的相似情势如下:

var 变量名 *类型

例如:

var ip *int     //指向int类型的变量

var fp *float32 //指向float32类型的变量

var ptr [MAX]*int;//指向数组的指针

 

指南针操作注意事项:

  1. 默认值 nil,没有 NULL 常量。
  2. 操作符 “&” 取变量地址, “*”
    通过过指针访问目的对象。
    不⽀持指针运算,不⽀持
    “->” 运算符,直接⽤ “.” 访问指标成员
  3. 不可能对指针做加减法等运算
  4. 不存在函数的指针

package main

 

import "fmt"

 

type Student struct {

    Name string

    Age  int

}

 

func main() {

    a := 10

    b := 12.5

    var pa *int = &a

    var pb *float64 = &b

    //1 打印变量的值

    fmt.Printf("%v,%v\n", a, b)

    fmt.Printf("%v,%v\n", *pa, *pb)

    // 2 打印变量的地址

    fmt.Printf("%v,%v\n", &a, &b)

    fmt.Printf("%v,%v\n", pa, pb)

    // 3 指针默认值为nil

    var pc *int

    fmt.Printf("%v,\n", pc)

    // 4 通过指针访问对象成员

    ps := &Student{"张三", 18}

    fmt.Println(ps.Name, ps.Age)

}

二.4 派生类型

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

                     b bool

2.四.三数组指针和指针数组

数组指针是只一个指针变量保存的是数组的位置。指针数组,是指数组的各种成分都以指针类型。

package main

 

import "fmt"

 

func main() {

 

    var ptr *[3]int //数组指针

    arr := [3]int{1, 2, 3}

    ptr = &arr //保存了数组的地址

    fmt.Println(*ptr)

 

    var ptr2 [3]*int //指针数组,每一个元素都是指针

    a, b, c := 10, 20, 30

    ptr2[0] = &a

    ptr2[1] = &b

    ptr2[2] = &c

    fmt.Println(ptr2) //ptr2数组中的3个指针分别保存了a,b,c的地址

 

}

// 打印结果:

[1 2 3]

[0xc04200a2c8 0xc04200a2e0 0xc04200a2e8]

 

 

二.伍 类型转变

强类型语言,运算时,须求统1类型

类型转变方式:T(v)

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

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

                )

贰.4.4 二级指针(多级指针)

二级指针保存顶尖指针变量的地点。

package main

 

import "fmt"

 

func main() {

 

    var a int = 100

    var pa *int = &a

    var ppa **int = &pa

 

    //打印a的值

    fmt.Printf("%v,%v,%v\n", a, *pa, **ppa)

    //打印a的地址

    fmt.Printf("%v,%v,%v", &a, pa, *ppa)

 

}

//打印结果:

100,100,100

0xc0420401d0,0xc0420401d0,0xc0420401d0

 

四、运算符

      假若变量的类型1致,仍是能够运用var a,b int
那种艺术来声称变量,当然还足以行使这种方法进行宣示和赋值:a,b := 20,1陆

二.五 type定义类型

在其他程序中都会设有有的变量有着同样的内部结构,不过却意味着完全两样的概念。
一个体系证明语句创造了一个新的花色名称,和现存项目具备同等的底层结构。

type 类型名字 底层类型

例如:

type Age int    //年龄

type Height int //身高

type Grade int  //分数

type绝不只是对应于C/C++中的typedef,它不是用来定义壹密密麻麻的外号。更首要的是,它定义了一雨后玉兰片互不相干的表现特征:通过那一个互不相干的一颦一笑特征,本质上同样的东西表现出分化事物的特色:整数照旧平头,但年龄却不是可观也不是分数。大家得以独家为Age、Height、Grade定
义出下列分化的行事(表示为情势如故函数):

type Age int    //年龄

type Height int //身高

type Grade int  //分数

 

func (a Age) IsOld() bool {

// 超过50岁算老年

return a > 50

}

func (h Height ) NeedTicket() bool {

// 高于120cm需要买票

return h > 120

}

func (g Grade) Pass() bool {

// 60分及格

return g >= 60

}

项目证明语句1般现身在包一流,因而壹旦新成立的门类名字首字母大写,则在包外能够应用。对于每一个类型T,都有3个对应的类型调换操作T(x),用于将x转变为T类型。

package main

 

import (

    "fmt"

)

 

type Integer int

 

func (a Integer) Less(b Integer) bool {

    return a < b

}

func main() {

    var a Integer = 1

    fmt.Println(a.Less(2))

    var b int

    //不能直接赋值,需要T(x)类型转换

    b = a

    b = int(a)

    fmt.Println(b)

}

 

三.1 算术运算符

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

     
在Go语言中有三个破例的变量(_,即下划线),任何赋给它的值都被丢掉,那将要1部分地点变得很有用处。

2.6作用域

三个声称语句将先后中的实体和多少个名字关闭,比如贰个函数或二个变量。证明语句的成效域是指源代码中能够有效接纳那些名字的界定。

无须将作用域和生命周期混为壹谈。申明语句的功效域对应的是三个源代码的文本区域,它是1个编写翻译时的习性。1个变量的生命周期是指程序运营时变量存在的立竿见影时间段,在此时间区域内,它可以被先后的其它1些引用,是2个周转时的定义。

语法块是由花括号所包蕴的一多元讲话。语法块内部宣称的名字是力不从心被外表语法块访问的。语句块决定了当中宣称的名字的功效域范围。有三个语法块为全体源代码,称为全局语法块;然后是各样包的包语法块;每种for、if和switch语句的语法块;各样switch或select的分层也有独立的语法块;当然也有体现书写的语法块(花括号包括的说话)。

评释语句对应的词法域决定了功效域范围的分寸。对于内置的门类、函数和常量,例如int、len和true等都以全局成效域的;任何在函数外部注脚的名字能够在包的其余源文件中做客,是包级成效域。对于导入的包,则是对应源文件级的功用域。调整流标号,便是break、continue或goto语句后继之的那种标号,是函数级功用域。

当编写翻译器际遇贰个名字引用时,假设它是二个宣称,首先从最内层的成效域向全局功能域查找。假使寻找未果,则错误。假设名字在里头和表面分别证明过,则内部块的证明首先被找到,它会遮掩外部同名的宣示。

三.2 关系运算符

== != > < >= <=

      须求专注的是,Go 的编写翻译器对注明却未利用的变量在报错。

二.7 数据输入输出

三.三 逻辑运算符

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

   

二.7.壹 标准输出函数

Print( )函数采纳默许格式将其参数格式化并写入标准输出。假设多个相邻的参数都不是字符串,会在它们的输出之间增加空格。重临写入的字节数和碰到的任何不当。函数原型如下:

func Print(a …interface{}) (n int, err error)

 

Println( )与Print( )函数的效应基本一致,唯壹差别的是在出口停止后,自动增添换行。函数原型如下:

func Println(a …interface{}) (n int, err error)

 

Printf()函数依照format参数生成格式化的字符串并写入标准输出。重临写入的字节数和蒙受的其余错误。函数原型如下:

func Printf(format string, a …interface{}) (n int, err error)

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两者都同1的时候,为0,其余都为一

运算 描述 示例
& 二进制与操作副本位的结果,如果它存在于两个操作数 (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

4、Go语言的档次

2.7.2 标准输入函数

Scan( )函数从规范输入扫描文本,将成功读取的空域分隔的值保存进成功传送给本函数的参数。换行视为空白。重返成功扫描的条文个数和遭遇的别的错误。假设读取的条款比提供的参数少,会回来三个错误报告原因。函数原型如下:

func Scan(a …interface{}) (n int, err error)

Scanln类似Scan,但会在换行时停下扫描。最后二个条条框框后务必有换行或然达到甘休地点。函数原型如下:

func Scanln(a …interface{}) (n int, err error)

Scanf从正式输入扫描文本,根据format 参数钦命的格式将不负众望读取的空域分隔的值保存进成功传送给本函数的参数。重回成功扫描的条规个数和遭受的任何不当。函数原型如下:

 

func Scanf(format string, a …interface{}) (n int, err error)

叁.伍 赋值运算符

运算符 描述 示例
= 简单的赋值操作符,分配值从右边的操作数左侧的操作数 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

     一)布尔类型(bool):值可感到true和false

3.6优先级

运算符优先级
稍微运算符拥有较高的优先级,2元运算符的演算方向均是从左至右。下表列出了具有运算符以及它们的优先级,由上至下代表优先级由高到低:

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

理所当然,你能够由此采用括号来一时提高某些表明式的完全运算优先级。

   
 贰)数字类型:int,那几个项目依照硬件决定,在33个人机器上,int是三二十一位的,在60人机器上,int是64人。uint也是这般。

         
当大家想要鲜明长度时,能够动用int32(uint3二)。完整的平头类型列表(符号和无符号)是
int八,int16,int3二,int6四 和 byte,uint八,uint16,uint3二,uint6四。byte
是 uint8 的外号。浮点类型的值有 float32 和 float6四 (未有 float
类型)。6四 位的整数和浮点数总是 6四 位的,即就是在 三15人的架构上。须要留意的是这么些项目全部都以独立的,并且混合用这一个项目向变量赋值会引起编写翻译器错误。

           例如:

            var a int

            var b int32

            a = 15

            b = a + a//编写翻译器会报错,提醒(cannot use g + g (type int)
as type int32 in assignment)

         
对于数字类型的赋值,能够应用捌进制、十6进制或科学计数法:07七,0xFF,一e三依然 陆.022e贰3 那么些 都以官方的。

     3)常量:constant
,常量在编译时被创造,只可以是数字、字符串或布尔值。

          例如:

          const (

                a = iota

                b = iota
//iota是贰个枚举值,第壹次利用时值为0,下一次采纳时值就改成1,每3遍选拔值都会+一

          )

          const (

                a = 0

                b bool = true //明显钦命常量的品类

         )

      4)字符串

           字符串赋值:s := “Hello World!”

           字符串在 Go 中是 UTF-8的由双引号(”)包裹的字符体系。如若您采用单引号(’)则
表示二个字符(UTF-八 编码),那种在 Go 中不是 string
。壹旦给变量赋值,字符串就不可能改改了:在 Go 中字符串是不可变的。

           那么哪些落到实处转移字符串那种操作呢?要求经过上边这种情势:

               s := “Hello,World!”

               m := []rune(s)

               m[0] = ‘C’

               s二 := string(m) //实际上只是新创制了3个字符串

               fmt.Printf(“%s\n”, s2)

           多行字符串:

               s := “Starting part”

                      + “Ending part”

               会被更改为:

               s := “Starting part” ;

                      + “Ending part” ;

               这是不当的语法,应当那样写:

               s := “Starting part” +

                      “Ending part”

              Go 就不会在错误的地点插入分号。

             还足以动用反引号来落到实处,s := `Starting part

                                                               Ending
part`

             作为原始字符串符,值 在引号内的字符是不转义的。

      5)rune 

            rune是int3二的别名,用 UTF-8举行编码。那几个种类在什么样时候使用呢?例如需求遍历字符串中的字符。能够循环每一个字节(仅在利用 US ASCII
编码字符串时与字符等 价,而它们在 Go
中不设有!)。因而为了赢得实际的字符,需求采用 rune 类型。

      6)复数

            Go 原生补助复数。它的变量类型是 complex12八 (6九人虚数部分)。借使须要小片段 的,还有 complex6肆 – 叁拾位的虚数部分。复数写为 re + imi,re 是实数部分,im 是虚数部分,而 i
是标志 图片 4

            例如:

            var ss complex64 = 5 + 5i

            fmt.Printf(“Value is: %v”, ss)

           打字与印刷结果: Value is: (伍+5i)

      7)错误

           var e error定义了二个error类型的变量e,其的值是 nil。那几个error 类型是一个接 口。

伍、Go语言的运算符

      Go
辅助普通的数字运算符,下图中列出了现阶段支撑的运算符,以及其事先级。它们
全体是从左到右结合的。

      图片 5    

     
Go语言不帮衬运算符重载(只怕措施重载),而壹些内建运算符却辅助重载。例如

  • 能够用于整数、浮点数、复数和字符串(字符串相加表示串联它们)。

      

6、Go关键字

      图片 6

   
 上海体育场面中列出了Go中全数的第二字,1些曾经触发过,别的一些就要后头介绍。

相关文章