能够再次定义和应用,二进制、8进制、十六进制转为10进制

二.二.1 字面常量

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

25

3.14159

2+3i

true

"hello"

在其他语言中,常量常常有一定的类别,Go语言的字面常量是无类型的。只要那个常量在对应类别的值域范围内,就足以看做该项指标常量。例如,二5足以赋值给int、 uint、int32、int6四、float3二、float6四、complex6四、complex12捌等类其余变量。

四、运算符

二.五 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,都有三个应和的类型转变操作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)

}

 

叁、基本数据类型

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

公海赌船网址 1

image.png

2.四.四 二级指针(多级指针)

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

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.1 布尔型bool

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

2.1 变量

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

 公海赌船网址 2

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

于是众人起初斟酌 将标识位插足运算, 并且只保留加法的方法.
首先来看原码。总括10进制的表明式: 1-一=0

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

假如用原码表示, 让符号位也涉足计算, 显著对于减法来说,
结果是不正确的.那也正是干什么Computer内部不利用原码表示一个数.

为了缓和原码做减法的难点, 出现了反码。总计10进制的表达式:

1-1=0

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

发掘用反码总结减法, 结果的真值部分是没有错的.
而唯一的主题素材其实就出现在”0”这么些特其余数值上.
即使大家清楚上+0和-0是同1的, 不过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.3.2 浮点数

浮点数用于表示包罗小数点的数额。Go语言提供了二种精度的浮点数,float3二和float6四。float3贰与float6四之间需求强制转变。强制转变的方式T(V),T为要转变的目的项目,V要求改动的变量。

一 浮点数表示

var f1 float32

f1 = 10

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

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

 

2 浮点数比较

因为浮点数不是1种标准的表明方式,所以不可能像整型那样间接用==比较。推荐的法子如下,引进math包,总结三个数值之差的相对化值,若是这一个结果充足小,大家就认为那八个数值是特别的。至于那么些数小到哪些水平定义为相等,程序猿可以依赖项目供给本人定义。

import  "math"

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

    return math.Abs(f1-f2) < p

}

 

3 科学计数法

把3个数表示成a(一≤a<10,n为整数)与十的幂相乘的格局,这种记数法叫做科学记数法。举例:一玖八七=一.9九×拾^3。总结器或微型Computer表明十的幂是形似是用E或e,也便是一.9玖E叁=一玖八七。

f1 := 1.99e+3   //1990

f2 := 1.99e-3   //0.00199

 

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:依据底层平台,表示3二或63个人整数。除非必要运用一定大小的整数,否则一般应该利用int来代表整数。
大小:32位系统32位,64位系统64位。
限制:-214748364八到21474836四7的三二十个人系统和-9223372036854775808到9223372036854775807的陆十四位系统。

2、浮点型

  • float32

    IEEE-75肆 3一位浮点型数

  • float64

    IEEE-75四 陆十几位浮点型数

  • complex64

    3二 位实数和虚数

  • complex128

    6四 位实数和虚数

3、其他

  • byte

    类似 uint八,约等于给自身类型起了外号

  • 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.4 布尔型

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

var s string

//s = "mazhiguo"

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

   fmt.Println("OK")

else {

   fmt.Println("error")

}

2.5 类型转变

强类型语言,运算时,供给联合类型

类型调换情势:T(v)

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

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

二.三 数据类型

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

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

二.1 什么是变量

变量是为存款和储蓄特定项目标值而提必要内存地点的名称。在go中证明变量有多样语法。

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

2.一.贰 变量注解

一 一般宣称格式

选用var能够创设一个特定类型的变量。变量注解的形似语法如下:

var 变量名 类型 =  表达式

其间“类型”或“=表明式”多个部分能够简轻便单个中的三个。假使简单的是类型音信,那么将依据早先化表明式来演绎变量的花色。即使表达式省略,将用零值发轫化该变量。

var i int = 1

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

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

假若一个名字在函数内部定义,那么它不得不在函数内部选拔,假若在函数外部定义,那么在近些日子包的具有文件都得以访问。名字首字母的尺寸写决定了它在包外的可知性,首字母大写在包外能够访问。包本身的名字一般总是用小写字母。

在包品级注解的变量会在main入口函数实践在此之前实现起初化,局地变量就要宣称语句被试行的时候做到初叶化。如若未有出示早先化,那么将用零值开首化该变量。3个变量表明后未有运用也会唤起编写翻译错误。

2 简短变量注解

“名字 := 表达式”,变量的花色根据表明式自动推导。由于使用简便利落,被相近用于超越半数的一部分变量的宣示和早先化。注意,简短变量评释不能够用于包等级的变量证明。

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.1 进制

二进制:逢贰进一,数值唯有0和一。

8进制:逢8进一,数值有0,壹,二,三,四,五,陆,七

10进制:逢拾进一,数值有0,1,2,三,4,五,六,7,8,玖

十6进制:逢十6进一,数值有0,1,贰,叁,4,伍,陆,七,八,9,A,B,C,D,E,F

2.4指针

贰、变量与常量

2.6作用域

一个宣称语句将顺序中的实体和二个名字关闭,比方贰个函数或二个变量。申明语句的成效域是指源代码中得以有效行使这么些名字的限量。

不用将作用域和生命周期混为一谈。表明语句的作用域对应的是3个源代码的文本区域,它是叁个编译时的属性。2个变量的生命周期是指程序运维时变量存在的有用时间段,在此时间区域内,它能够被先后的别的一些引用,是3个运作时的定义。

语法块是由花括号所富含的一文山会海讲话。语法块内部宣称的名字是不能被外表语法块访问的。语句块决定了个中宣称的名字的效用域范围。有一个语法块为壹切源代码,称为全局语法块;然后是各种包的包语法块;每种for、if和switch语句的语法块;每种switch或select的分层也可能有独立的语法块;当然也许有显示书写的语法块(花括号包蕴的口舌)。

宣示语句对应的词法域决定了功能域范围的高低。对于内置的类别、函数和常量,譬如int、len和true等都以全局功效域的;任何在函数外部注解的名字能够在包的别样源文件中走访,是包级成效域。对于导入的包,则是对应源文件级的功用域。调节流标号,便是break、continue或goto语句后继之的这种标号,是函数级功用域。

当编写翻译器遭逢四个名字引用时,借使它是2个宣称,首先从最内层的功效域向全局作用域查找。假如寻找未果,则错误。假使名字在其二月表面分别证明过,则内部块的扬言首先被找到,它会遮掩外部同名的表明。

2.4 iota

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

在每3个const关键字出现时,被重新初始化为0,然后再下3个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=壹, c=二 方可简写为如下方式:

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类型,可以活动实行展示内定项目

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

二.7.二 标准输入函数

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.6优先级

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

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

本来,你可以由此选用括号来有的时候升高有些表明式的总体运算优先级。

2.3.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%-三的结果都以2。除法运算符的结果则依据于操作数是还是不是全为整数,举个例子伍.0/四.0的结果是一.二五,不过7/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

 

运算符优先级:

 

 

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

2.七 数据输入输出

一.三.壹 机器数和真值

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

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

二.四.二 注脚指针变量

声明指针变量的一般格局如下:

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)

}

注意事项

假如在同一的代码块中,大家无法重新对于同一名称的变量使用初始化证明,举例:a
:= 20 就是不被允许的,编写翻译器会提醒错误 no new variables on left side of
:=,但是 a = 20 是能够的,因为那是给一样的变量赋予三个新的值。

举个例子您在概念变量 a 从前运用它,则会得到编写翻译错误 undefined: a。

只要您证明了1个有个别变量却并未有在平等的代码块中采纳它,一样会拿走编写翻译错误,举例上边这些事例个中的变量
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 = 伍, 七 中被丢掉

_ 实际上是3个只写变量,你无法取得它的值。那样做是因为 Go
语言中您不可能不利用具备被声称的变量,但神蹟你并没有供给使用从多个函数得到的兼具重临值

比方说函数重回一个值,可是自己本人只行使当中三个。假使七个都接受,下边程序1个值不用的话会报错。所以大家就须求利用这几个放弃。有些人说作者重回二个不就行了?函数定义重返四个,你回来三个的话,此处编译不会透过。

交互赋值也被用于当一个函数再次回到多少个重临值时,举个例子此处的 val 和错误 err
是通过调用 Func壹 函数同期猎取:val, err = Func一(var一)

二.二.三 iota常量生成器

Go语言预订义的常量有:true、false和iota,其中iota比较特殊。常量证明能够动用iota常量生成器起头化,它用来生成壹组以一般规则起初化的常量,不过毫无每行都写一次初叶化表明式。在一个const注解语句中,在第3个注明的常量所在的行,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表明常量。注明时能够带项目。也得以不带项目,通过右揣测。

二.四 派生类型

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

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

小说由小编马志国在新浪的原创,若转发请于显明处标识出处:http://www.cnblogs.com/mazg/

2.3 字符串型

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

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

贰.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)

三.一 算术运算符

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

2.二.2 常量注脚

运用const来声称常量,能够给常量三个温馨的名字比方:

const pi = 3.1415926

也足以批量评释:

const (

     e = 2.7182818

     pi = 3.1415926

)

七个常量的宣示也能够界定品种,但不是不可缺少的。如若未有展现钦定项目,那么它与字面量一样,是无类型常量。常量定义的右值也能够是2个在编写翻译期运算的常量表明式,比方:

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 评释变量

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.3 复数

Go语言提供了三种精度的复数类型:complex6肆和complex12八,分别对应float32和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

一.贰 进制调换

二进制、捌进制、十六进制转为10进制

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

十进制转为二进制、捌进制、十陆进制
除以进制数

2.2 常量

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

二.三 常量申明

常量是二个不难易行值的标记符,在程序运行时,不会被修改的量。

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

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

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

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
)

常量组中如不内定项目和起始化值,则与上1行非空常量右值同样

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.1.3 赋值

一 简单赋值

赋值语句是立异八个变量的值,最简便易行的赋值”变量名= 新值的表明式”

var i int

i = 1      //简单赋值

 

二复合赋值运算符

特定的二元算术运算符和赋值语句的复合操作有二个简短的情势

var i int

i = i + 1

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

 

数值变量也能够支撑++递增和–递减语句。注意它是话语,不是表明式,所以x=i++那样的表明式是不当的。

3多种赋值

多重赋值允许同期立异三个变量的值。在赋值以前,赋值语句右侧的具有表明式会先进行求值,然后再统壹更新左侧对应的变量的值。这样在做三个数值调换时,没有供给引入第一个变量了。

x,y=y,x

4 _标识符

稍稍表达式会爆发多个值,举个例子调用多少个有多少个重返值的函数。能够运用下划线空白标记符_来放弃没有需求的值。

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

 

叁.二 关系运算符

== != > < >= <=

2.3.5 字符串

一 字符串常用操作

在Go语言中字符串也是壹种基本类型。1个字符串是1个不行改换的字节体系。常用的字符串操作如下表所示:

运算

含义

备注

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"

二 字符串值不可变

字符串的值是不可变的:五个字符串包蕴的字节种类永恒不会被改变,当然大家能够给1个字符串变量分配3个新字符串值。

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编码是一种字符编码,使用一到陆个字节表示二个字符。ASCII部分字符只利用三个字节,常用字符部分行使二或二个字节。变长的编码不可能直接通过索引来访问第n个字符。

Go语言的源文件选拔UTF八编码,unicode/utf八包提供提供了用来rune字符种类的UTF八编码和平化解码作用。如若关切每种unicode字符,能够采纳UTF捌解码器。unicode/utf八回顾提供了该意义。

s := "hello 世界"

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

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

将八个卡尺头型转换为字符串意思是生成以只包蕴对应unicode编码字符的UFT八字符串,假若对应的编码的字符无效,将用‘\uFfFD’无效字符作为替换:

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

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

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

 

string 接受到[]rune的类型转换,能够将二个UTF八编码的字符串解码为unicode字符串类别:

s := "世界"

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

r := []rune(s)

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

 

 

诸如”汉”字的Unicode编码是陆C4玖。陆C4玖在0800-FFFF之间,所以要用三字节模板:1110xxxx 10xxxxxx 十xxxxxx。将陆C4九写成二进制是:01拾 1十0 0十0 1001,将那一个比特流按三字节模板的分段方法分为0110 1一千壹 00十0一,依次取代模板中的x,得到:11十-01拾 拾-1壹仟一 拾-001001,即E陆 B1 8玖,那就是其UTF8的编码。

s := "汉"

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

r := []rune(s)

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

unicode相当于字符编码,即字典。utf八、uft1陆是怎么样以字节的方法存款和储蓄那几个编码。字符串可正如、可遍历、不可修改。

三.伍 赋值运算符

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

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

数组指针是只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]

 

 

多变量注明

先是种,以逗号分隔,注脚与赋值分开,若不赋值,存在默许值。这种措施的项目必须一律

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

其次种,直接赋值,下边包车型客车变量类型能够是分歧的种类

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

其二种,集结类型

var (
    name1 type1
    name2 type2
)

贰.四.壹 指针概念

指南针是3个项目,该项目标变量称为指针变量。指针变量存款和储蓄2个变量的地点。它不相同于一般的变量,一般变量存放的是数额自个儿,而指针变量存放的是数额的地点。

 公海赌船网址 3

叁.四 位运算符

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

三.3 逻辑运算符

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

相关文章