那一个名字不是第一字,二进制新匍京视频在线、八进制、十六进制转为十进制

小说由作者马志国在天涯论坛的原创,若转载请于显著处标记出处:http://www.cnblogs.com/mazg/

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

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语言提供了25个重点字,只好在一定的语法中行使。

25个关键字

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

若果用原码表示, 让符号位也加入总结, 彰着对于减法来说,
结果是不得法的.那也就是怎么统计机内部不利用原码表示一个数.

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

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),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的幂相乘的款型,这种记数法叫做科学记数法。例如:1990=1.99×10^3。总括器或电脑表达10的幂是相似是用E或e,也就是1.99E3=1990。

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,%v\n", y, y)
    fmt.Printf("%T,%v\n", 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语句块中的行索引)。

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("%x\n", s) //e4b896e7958c,utf8编码

r := []rune(s)

fmt.Printf("%x\n", 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(" %x\n", s) // e6b189,UTF8编码

r := []rune(s)

fmt.Printf("%x\n", 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或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.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,%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)

}

2.4 派生类型

(a) 指针类型(Pointer)
(b) 数组类型
(c) 结构化类型(struct)
(d) Channel 类型
(e) 函数类型
(f) 切片类型
(g) 接口类型(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 二级指针(多级指针)

二级指针保存一流指针变量的地点。

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

 

四、运算符

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),用于将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( )函数采纳默认格式将其参数格式化并写入标准输出。假若五个相邻的参数都不是字符串,会在它们的出口之间添加空格。重临写入的字节数和际遇的此外错误。函数原型如下:

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( )函数从规范输入扫描文本,将不负众望读取的空域分隔的值保存进成功传送给本函数的参数。换行视为空白。再次回到成功扫描的条目个数和遇到的任何错误。假设读取的条规比提供的参数少,会回到一个错误报告原因。函数原型如下:

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

理所当然,你可以通过使用括号来临时提高某个表明式的完全运算优先级。

相关文章