欢迎您光临bv1946伟德体育官方网站!

golang基本语法

时间:2019-11-28 17:05

文章由小编马志国在博客园的原创,若转载请于明显处标志出处:

生机勃勃、二进制、八进制、十进制、十二进制

2.1 变量

变量是对一块内部存款和储蓄器空间的命名,程序能够因而定义四个变量来报名一块内部存款和储蓄器空间。然后能够通过援引变量名来使用那块存款和储蓄空间。

 图片 1

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

2.1.1 变量命名

Go语言中的变量名、常量名、类型名、函数名和包名等具备的命名和C语言相通都遵照那样一个简便的命名法则:贰个名字必需以多个假名或下划线伊始,后边能够跟任性数量的假名、数字或下划线。对于字母区分抑扬顿挫写,举个例子: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

 

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

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

2.1.2 变量表明

1 日常宣称格式

行使var能够创立二个特定类型的变量。变量评释的平时语法如下:

var 变量名 类型 =  表达式

当中“类型”或“=表达式”多少个部分能够轻松在那之中的一个。假如轻易的是类型音讯,那么将依赖带头化表明式来演绎变量的档期的顺序。假使表明式省略,将用零值初叶化该变量。

var i int = 1

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

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

生龙活虎经三个名字在函数内部定义,那么它必须要在函数内部使用,假若在函数外界定义,那么在现阶段包的兼具文件都足以访问。名字首字母的分寸写决定了它在包外的可以见到性,首字母大写在包外能够访谈。包本身的名字经常总是用小写字母。

在包等第申明的变量会在main入口函数实施早先达成开首化,局地变量就要注脚语句被实施的时候做到开头化。若无出示开首化,那么将用零值开头化该变量。二个变量申明后未有运用也会孳生编写翻译错误。

2 简短变量表明

“名字 := 表明式”,变量的品类依据表明式自动推导。由于应用轻松利落,被大范围用于大多数的风度翩翩对变量的评释和最初化。注意,简短变量证明不可能用于包品级的变量表明。

i := 100

 

3 多个变量注明

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 原码,反码,补码

2.1.3 赋值

1 简单赋值

赋值语句是翻新四个变量的值,最简单易行的赋值”变量名= 新值的表明式”

var i int

i = 1      //简单赋值

 

2复合赋值运算符

特定的二元算术运算符和赋值语句的复合操作有三个轻巧的款型

var i int

i = i + 1

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

 

数值变量也能够支撑++递增和--依次减少语句。注意它是话语,不是表明式,所以x=i++那样的表明式是张冠李戴的。

3多种赋值

多种赋值允许同期更新四个变量的值。在赋值以前,赋值语句左侧的持有表明式会先实行求值,然后再统豆蔻年华更新侧面对应的变量的值。那样在做五个数值交流时,无需引进第八个变量了。

x,y=y,x

4 _标识符

多少表达式会产生四个值,比方调用三个有多个再次来到值的函数。能够使用下划线空白标志符_来扬弃没有必要的值。

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

 

1.3.1 机器数和真值

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

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

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

于是大家最早探讨 将标记位参预运算, 而且只保留加法的方法. 首先来看原码。计算十进制的表达式: 1-1=0

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

设若用原码表示, 让符号位也到场总括, 鲜明对于减法来讲, 结果是不科学的.那也正是干吗Computer内部不使用原码表示二个数.

为了解决原码做减法的标题, 现身了反码。总括十进制的说明式:

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

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

25

3.14159

2+3i

true

"hello"

在别的语言中,常量平常常有一定的等级次序,Go语言的字面常量是无类型的。只要这几个常量在对应项目标值域范围内,就足以视作该品种的常量。比方,25能够赋值给int、 uint、int32、int64、float32、float64、complex64、complex128等品类的变量。

二、变量与常量

2.2.2 常量注解

应用const来声称常量,能够给常量叁个和好的名字举例:

const pi = 3.1415926

也能够批量宣称:

const (

     e = 2.7182818

     pi = 3.1415926

)

一个常量的扬言也得以界定品种,但不是少不了的。若无展现内定项目,那么它与字面量同样,是无类型常量。常量定义的右值也得以是一个在编译期运算的常量表明式,举例:

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.1 什么是变量

变量是为存款和储蓄特定项指标值而提必要内部存款和储蓄器地方的名称。在go中注脚变量有多种语法。

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

2.2.3 iota常量生成器

Go语言预订义的常量有:true、false和iota,当中iota相比较特殊。常量证明能够动用iota常量生成器伊始化,它用来生成风流罗曼蒂克组以经常准绳初阶化的常量,可是绝不每行都写三回开首化表明式。在二个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,比如下边每一个常量都是1024的幂。

const (

    _ = 1 << (10 * iota)

    KiB

    MiB

    GiB

    TiB

)

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

打印结果:1024 1048576 1073741824 1099511627776

小结:var 声明变量,const评释常量。证明时能够带项目。也能够不带项目,通过右测度。

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

2.3 数据类型

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

  1. 基本数据类型:数值、字符串和布尔型。
  2. 复合数据类型:数组和构造体。
  3. 引用类型:指针、切成片、字典、函数和通道。
  4. 接口类型。

多变量证明

率先种,以逗号分隔,注解与赋值分开,若不赋值,存在暗中同意值。这种方法的花色必需生龙活虎致

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

第三种,直接赋值,上面包车型大巴变量类型能够是例外的品类

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

其二种,集结类型

var (
    name1 type1
    name2 type2
)

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%-3的结果都以2。除法运算符的结果则依附于操作数是还是不是全为整数,比如5.0/4.0的结果是1.25,然则7/4的结果为1,去掉小数部分,实际不是四舍五入。

关系(比较)运算符:

多个相通的卡尺头类型能够使用上边包车型地铁二元关系运算符举行相比较,比较表明式的结果是布尔类型。

运算符

描述

==

相等

!=

不等

<

小于

<=

小于或等于

>

大于

>=

大于或等于

 

 

逻辑运算

运算符

描述

!

&&

||

 

位运算:

前4个操作运算符并不区分是有标记还是无符号数:

运算符

描述

&

位与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的暗许值便是“”,空字符串

在同一个职能域中,已存在同名的变量,则之后的宣示初步化,则战败为赋值操作。但以从前提是,起码要有一个新的变量被定义,且在同等功用域,举例,下边的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.2 浮点数

浮点数用于表示满含小数点的数据。Go语言提供了二种精度的浮点数,float32和float64。float32与float64之间须要强制转变。强制调换的格局T(V卡塔尔(英语:State of Qatar),T为要改造的对象项目,V供给转移的变量。

1 浮点数表示

var f1 float32

f1 = 10

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

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

 

2 浮点数相比较

因为浮点数不是风姿罗曼蒂克种标准的表明形式,所以不可能像整型那样直接用==比较。推荐的艺术如下,引进math包,计算多少个数值之差的相对化值,假若这几个结果丰富小,大家就觉着这多个数值是十三分的。至于这一个数小到哪些水平定义为相等,技术员能够依附项目供给自个儿定义。

import  "math"

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

    return math.Abs(f1-f2) < p

}

 

3 科学计数法

把一个数表示成a(1≤a<10,n为整数)与10的幂相乘的样式,这种记数法叫做科学记数法。例如:一九八七=1.99×10^3。计算器或微微机表明10的幂是日常是用E或e,也正是1.99E3=1987。

f1 := 1.99e+3   //1990

f2 := 1.99e-3   //0.00199

 

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,%vn", y, y)
    fmt.Printf("%T,%vn", z, z)
}

运作结果:

uint16,16
string,abc

2.3.3 复数

Go语言提供了三种精度的复数类型:complex64和complex128,分别对应float32和float64三种浮点数精度。内建函数和自然的书写形式。

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表明,其所表示的数字会自动扩充1

iota在const关键字现身时将被重新载入参数为0(const内部的率先行早前卡塔尔,const中每新扩展意气风发行常量注脚将使iota计数一次(iota可驾驭为const语句块中的行索引卡塔尔(英语:State of Qatar)。

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类型,可以活动开展呈现内定项目

数字常量不会分配存款和储蓄空间,无须像变量那样通过内部存款和储蓄器寻址来取值,由此不可能拿到地址

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 字符串

1 字符串常用操作

在Go语言中字符串也是少年老成种为主类型。一个字符串是三个不可改变的字节系列。常用的字符串操作如下表所示:

运算

含义

备注

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"

2 字符串值不可变

字符串的值是不可变的:二个字符串包含的字节系列长久不会被转移,当然大家得以给二个字符串变量分配二个新字符串值。

s := "hello world"

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

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

3 字符串遍历

字符串遍历补助以字节的点子遍历和以字符的主意遍历。

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

 

4转义行列

在二个双引号蕴涵的字符串字面值中,能够用反斜杠初叶的转义连串插入任意的数量。

大范围的ASCII调整代码的转义形式:

 

 

 

a

响铃

b

退格

f

换页

n

换行

r

回车

t

水平制表符

v

垂直制表符

单引号

双引号

\

反斜杠

 

 

5原生字符串字面值

原生的字符串字面值,用` `替代双引号。可用来编写正则表明式。常用来HTML模板、JSON面值、命令提醒信息以致必要扩展到多行的景色。

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

 1 输入参数

 2 计算

 3 打印结果`

fmt.Println(tips)

 

6 UTF8编码

UTF8编码是生机勃勃种字符编码,使用1到4个字节表示叁个字符。ASCII部分字符只使用1个字节,常用字符部分应用2或3个字节。变长的编码不能够间接通过索引来访谈第n个字符。

Go语言的源文件选拔UTF8编码,unicode/utf8包提供提供了用来rune字符连串的UTF8编码和平解决码作用。假使关怀各类unicode字符,能够利用UTF8解码器。unicode/utf8席卷提供了该意义。

s := "hello 世界"

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

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

将多个大背头型转换为字符串意思是生成以只包罗对应unicode编码字符的UFT8字符串,若是对应的编码的字符无效,将用‘uFfFD’无效字符作为替换:

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

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

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

 

string 接受到[]rune的类型调换,能够将三个UTF8编码的字符串解码为unicode字符串序列:

s := "世界"

fmt.Printf("%xn", s) //e4b896e7958c,utf8编码

r := []rune(s)

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

 

 

譬如说"汉"字的Unicode编码是6C49。6C49在0800-FFFF之间,所以要用3字节模板:1110xxxx 10xxxxxx 10xxxxxx。将6C49写成二进制是:0110 1100 0100 1001,将那么些比特流按三字节模板的分支方法分为0110 110001 001001,依次替代模板中的x,获得:1110-0110 10-110001 10-001001,即E6 B1 89,这正是其UTF8的编码。

s := "汉"

fmt.Printf(" %xn", s) // e6b189,UTF8编码

r := []rune(s)

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

unicode约等于字符编码,即字典。utf8、uft16是何许以字节的艺术存储那一个编码。字符串可正如、可遍历、不可改过。

2.1 布尔型bool

布尔型的值只能是常量 true 大概 false。三个简便的例子:var b bool = true

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或62个人整数。除非供给运用一定大小的大背头,不然日常应该使用int来表示整数。
大小:32位系统32位,64位系统64位。
限定:-2147483648到2147483647的三十几个人系统和-9223372036854775808到9223372036854775807的陆15人系统。

2、浮点型

  • float32

    IEEE-754 叁十四人浮点型数

  • float64

    IEEE-754 陆十五个人浮点型数

  • 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.4.1 指针概念

指南针是三个档期的顺序,该品种的变量称为指针变量。指针变量存款和储蓄三个变量的地点。它不一样于常常的变量,常常变量贮存的是数量本人,而指针变量寄放的是数码的地点。

 图片 3

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.2 申明指针变量

声明指针变量的相通格局如下:

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,%vn", a, b)

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

    // 2 打印变量的地址

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

    fmt.Printf("%v,%vn", pa, pb)

    // 3 指针默认值为nil

    var pc *int

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

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

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

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

}

2.4 派生类型

(a卡塔尔国 指针类型(Pointer)
(b卡塔尔(英语:State of Qatar) 数组类型
(c卡塔尔(英语:State of Qatar) 构造化类型(struct卡塔尔(قطر‎
(d) Channel 类型
(e卡塔尔(英语:State of Qatar) 函数类型
(f卡塔尔国 切丝类型
(g卡塔尔(英语:State of Qatar) 接口类型(interface)
(h) Map 类型

2.4.3数组指针和指针数组

数组指针是只一个指针变量保存的是数组的地点。指针数组,是指数组的每种成分都是指针类型。

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]

 

 

2.5 类型调换

强类型语言,运算时,要求统生龙活虎类型

类型转变方式:T(v)

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

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

2.4.4 二级指针(多级指针卡塔尔(英语:State of Qatar)

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

package main

 

import "fmt"

 

func main() {

 

    var a int = 100

    var pa *int = &a

    var ppa **int = &pa

 

    //打印a的值

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

    //打印a的地址

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

 

}

//打印结果:

100,100,100

0xc0420401d0,0xc0420401d0,0xc0420401d0

 

四、运算符

2.5 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

}

花色注脚语句日常出以往包一级,由此黄金年代旦新创造的连串称字首字母大写,则在包外能够动用。对于每四个类型T,都有叁个遥相呼应的类型调换操作T(x卡塔尔(英语:State of Qatar),用于将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)

}

 

3.1 算术运算符

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

2.6作用域

二个扬言语句将前后相继中的实体和多个名字关闭,比方贰个函数或四个变量。证明语句的效率域是指源代码中得以有效应用这些名字的限制。

无须将成效域和生命周期同日而道。注解语句的效能域对应的是二个源代码的文书区域,它是二个编写翻译时的品质。三个变量的生命周期是指程序运行时变量存在的卓有功用时间段,在这时候间区域内,它能够被前后相继的其余一些援用,是一个运营时的概念。

语法块是由花括号所蕴藏的大器晚成雨后春笋讲话。语法块内部宣称的名字是心有余而力不足被表面语法块访谈的。语句块决定了内部宣称的名字的作用域范围。有一个语法块为全部源代码,称为全局语法块;然后是各类包的包语法块;每一种for、if和switch语句的语法块;种种switch或select的支行也可能有独立的语法块;当然也是有展现书写的语法块(花括号包涵的话语卡塔尔。

宣称语句对应的词法域决定了成效域范围的大小。对于内置的门类、函数和常量,譬如int、len和true等都是大局功用域的;任何在函数外界证明的名字能够在包的别的源文件中拜会,是包级作用域。对于导入的包,则是对应源文件级的成效域。调节流标号,正是break、continue或goto语句后随着的这种标号,是函数级作用域。

当编写翻译器蒙受贰个名字引用时,假若它是一个扬言,首先从最内层的作用域向全局功能域查找。借使搜索未果,则错误。若是名字在其四之日外界分别证明过,则内部块的宣示首先被找到,它会隐瞒外界同名的扬言。

3.2 关系运算符

== != > < >= <=

2.7 数据输入输出

3.3 逻辑运算符

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

2.7.1 标准输出函数

Print( 卡塔尔(英语:State of Qatar)函数选用暗中同意格式将其参数格式化并写入标准输出。若是多少个相邻的参数都不是字符串,会在它们的输出之间增加空格。再次来到写入的字节数和碰着的任何错误。函数原型如下:

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两个都相同的时间,为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

2.7.2 标准输入函数

Scan( 卡塔尔(英语:State of Qatar)函数从标准输入扫描文本,将成功读取的空域分隔的值保存进成功传送给本函数的参数。换行视为空白。再次来到成功扫描的条目款项个数和蒙受的其余错误。假诺读取的条规比提供的参数少,会回到叁个错误报告原因。函数原型如下:

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)

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

自然,你能够经过行使括号来一时升高有些表明式的总体运算优先级。

上一篇:devexpress wpf lookup用法
下一篇:没有了