go语言36 go语言35岁

UINT64 a = 0ui64是什么意思？

其实是完全不一样的的东西 uint64是64位无符号整形数据 每个整数用64位2进制数去编码 表示的数据范围是0~2^64-1 0~18446744073709551615 而没有经过任何类型指定的数据matlab默认是double类型的浮点数 虽然也是占据64位，但是用的是浮点数的储存...

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：主机域名、雅安服务器托管、营销软件、网站建设、吴川网站维护、网站推广。

请教个问题，学py好还是go好，感觉go并发快，是以后的趋势

综合来说学JAVA的比较快一些，在网上找例子比较方便

对于一个武林高手来说，用什么编程工具都一样，只是武器不同而已。

代码元素地位跟什么一样

相比很多其它流行语言，Go的语法相对简洁。 此篇文章将介绍编程中常用的代码元素，并展示一份简单的Go程序代码，以便让刚开始学Go编程的程序员对Go代码结构有一个大概的印象。

编程和程序代码元素

简单来讲，编程可以看作是以各种方式控制和组合计算机运行中的各种操作，以达到各种各样的目的。 一个操作可能从一个硬件设备读取、或者向一个硬件设备写入一些数据，从而完成一个特定的任务。 对于现代计算机来说，最基本的操作是底层计算机指令，比如CPU和GPU指令。 常见的硬件设备包括内存、磁盘、网卡、显卡，显示器、键盘和鼠标等。

直接操控底层计算机指令进行编程是非常繁琐和容易出错的。 高级编程语言通过对底层指令进行一些封装和对数据进行一些抽象，从而使得编程变得直观和易于理解。

在流行高级编程语言中，一个操作通常是通过函数（function）调用或者使用操作符（operator）运算来完成的。 大多数高级编程语言都支持一些条件和循环控制语句。 这些条件和循环控制语句可以看作是特殊的操作。 它们的语法接近于人类语言，因此一个人写的代码很容易被其他人理解。

在大多数高级编程语言中，数据通常被抽象为各种类型（type）和值（value）。 一个类型可以看作是值的模板。一个值可以看作是某个类型的实例。 大多数编程语言支持自定义类型和若干预声明类型（即内置类型）。 一门语言的类型系统可以说是这门语言的灵魂。

编程中常常会使用大量的值。 一些在编码阶段可确定的值可以用它们的字面形式（literal，即字面量）来表示。 为了编程灵活和不易出错，其它的值一般使用变量（variable）和（具名）常量（named constant）来表示。

在《Go语言101》中，具名的函数、具名的值（包括变量和具名常量）、以及定义类型和类型别名将被统称为代码要素。 代码要素名必须为标识符（identifier）。

高级编程语言代码将被编译器或者解释器转换为底层机器码进行执行。 为了帮助编译器和解释器解析高级语言代码，一些单词将被用做关键字（keyword）。 这些单词不能被当做标识符使用。

很多现代高级语言使用包（package）来组织代码。 一个包必须引入（import）另一个包才能使用另一个包中的公有（导出的）代码要素。 包名和包的引入名也都必须是标识符。

尽管高级编程语言代码比底层机器指令友好和易懂，我们还是需要一些注释来帮助自己和其他程序员理解我们所写的代码。 在下一节的程序示例中，我们可以看到很多注释。

一个简单的Go示例程序

为了对各种代码元素有一个更清楚的认识，让我们来看一个简短的Go示例程序。 和很多其流行语言一样，Go使用//来起始一个行注释，使用一个/*和*/对来包裹一个块注释。

下面是这个Go示例程序。请注意阅读其中的注释。程序之后有更多解释。

package main // 指定当前源文件所在的包名

import "math/rand" // 引入一个标准库包

const MaxRand = 16 // 声明一个具名整型常量

// 一个函数声明

/*

StatRandomNumbers生成一些不大于MaxRand的非负

随机整数，并统计和返回小于和大于MaxRand/2的随机数

个数。输入参数numRands指定了要生成的随机数的总数。

*/

func StatRandomNumbers(numRands int) (int, int) {

// 声明了两个变量（类型都为int，初始值都为0）

var a, b int

// 一个for循环代码块

for i := 0; i numRands; i++ {

// 一个if-else条件控制代码块

if rand.Intn(MaxRand) MaxRand/2 {

a = a + 1

} else {

b++ // 等价于：b = b + 1

}

}

return a, b // 此函数返回两个结果

}

// main函数，或主函数，是一个程序的入口函数。

func main() {

var num = 100

// 调用上面声明的StatRandomNumbers函数，

// 并将结果赋给使用短声明语句声明的两个变量。

x, y := StatRandomNumbers(num)

// 调用两个内置函数（print和println）。

print("Result: ", x, " + ", y, " = ", num, "? ")

println(x+y == num)

}

将上面的程序代码存盘到一个名为basic-code-element-demo.go 的文件中并使用下列命令运行此程序：

$ go run basic-code-element-demo.go

Result: 46 + 54 = 100? true

在上面的示例程序中，单词package、import、const、func、var、for、if、else和return均为关键字。 其它大多数单词均为标识符。 请阅读关键字和标识符以获得更多关于关键字和标识符的信息。

四个int（一个在第15行，另三个在第13行） 表示内置基本类型int。int类型是Go中的基本整数类型之一。 第5行中的16、第17行中的0、 第20行中的1以及第30行的100均为整型字面量。 第35行的"Result: "是一个字符串字面量。 请阅读基本类型和它们的字面量表示以获取更多关于基本类型和它们的字面量的信息。 Go中的非基本类型（均为组合类型）将在以后的其它文章中介绍和解释。

第20行是一个赋值语句。 第5行声明了一个具名常量，叫做MaxRand。 第15行和第30行使用标准变量声明语句声明了三个变量。 第17行的变量i以及第33行的变量x和y是使用变量短声明语句声明的。 变量a和b在声明的时候被指定为int类型。 编译器会自动推导出变量i、num、x和y的类型均为int类型，因为它们的初始值都是整型字面量表示的。 请阅读常量和变量以获取什么是类型不确定值、类型推导、赋值、以及如何声明变量和具名常量。

上面的示例程序中使用了很多操作符，比如第17和19行的小于比较符，第36行的等于比较符==，还有第20和36行的加法运算符+。 第35行中的+不是一个运算符，它是一个字符串字面量中的一个字符。 一个使用操作符的操作中涉及到的值称为操作值（有时也可称为运算数）。 请阅读常用操作符以获取更多关于操作符的信息。 更多操作符将在后续其它文章中介绍。

第35和36行调用了两个内置函数print和println。 从第13行到第26行声明的函数StatRandomNumbers在第33行被调用。 第19行也调用了一个函数 Intn。 这个函数声明在math/rand标准库包中。 请阅读函数声明及函数调用以获取更多关于函数声明及函数调用的信息。

（注意，一般print和println这两个内置函数并不推荐使用。 在正式的项目中，我们应该尽量使用fmt标准库包中声明的相应函数。 《Go语言101》只在开始的几篇文章中使用了这两个函数。）

第1行指定了当前源文件所处的包的名称。 一个Go程序的主函数（main函数）必须被声明在一个名称为main的包中。 第3行引入了math/rand标准库包，并以rand做为引入名。 在这个包中声明的Intn函数将在第19行被调用。 请阅读代码包和包引入，以获取更多关于代码包和包引入的信息。

表达式、语句和简单语句一文中介绍了什么是表达式和语句。特别地，此文列出了所有的简单语句类型。 在Go代码中，各种流程控制代码块中的某些部分必须为简单语句，某些部分必须为表达式。

StatRandomNumbers函数的声明体中使用了两个流程控制代码块。 其中一个是for循环代码块，它内嵌了另外一个代码块。 另外一个代码块是一个if-else条件控制代码块。 请阅读基本流程控制语法以获取更多关于流程控制代码块的信息。 更多的特殊的流程控制代码块将在以后的其它文章中介绍。

空行常常用来增加代码的可读性。 上面的程序中也包涵了很多注释，但它们大多是为了Go初学者快速理解的目的而加入的。 我们应该尽量使代码自解释，只在确实需要解释的地方进行注释。

关于代码断行

像很多其它流行编程语言一样，Go也使用一对大括号{ and }来形成一个显式代码块。但是在Go代码中，编码样式风格有一些限制。 比如，很多左大括号{不能被放到下一行。 如果，上面的StatRandomNumbers被修改成如下所示，则上面的示例程序将编译不通过。

func StatRandomNumbers(numRands int) (int, int)

{ // 编译错误：语法错误

var a, b int

for i := 0; i numRands; i++

{ // 编译错误：语法错误

if rand.Intn(MaxRand) MaxRand/2

{ // 编译错误：语法错误

a = a + 1

} else {

b++

}

}

return a, b

}

一些程序员不是很喜欢这些限制。但是这些限制有两个好处：

它们使得Go程序编译得非常快。

它们使得不同的Go程序员编写的代码风格类似，从而一个Go程序员写的代码很容易被另一个程序员看懂。

我们可以阅读代码断行规则一文以获取更多关于代码换行规则的细节。在目前，我们最好避免将左大括号放在下一行。 或者说，每行的非空起始字符不能是左大括号（但是，请记住，这不是一个普适的规则

go的uint64转换成java的哪种类型

Golang 和java/c不同，Go在不同类型的变量之间赋值时需要显式转换。也就是说Golang中数据类型不能自动转换。

基本语法

表达式T（v））将值v 转换为类型T

T∶就是数据类型，比如int32，int64，float32等等

v∶ 就是需要转换的变量

var i int = 100

var b float64 = float64(i)

var c int64 = int64(b)

fmt.Printf("b=%f,c=%d",b,c)

b=100.000000,c=100

登录后复制

细节说明

1）Go中，数据类型的转换可以是从表示范围小-表示范围大，也可以范围大一范围小

2） 被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化!

3） 在转换中，比如将 int64 转成int8，编译时不会报错，只是转换的结果是按溢出处理，和

我们希望的结果不一样。（在转换的时候需要注意范围）

var a int64 = 10000000

var b int8 = int8(a)

fmt.Printf("%d",b)

-128

登录后复制

可以看到在转换的时候，一定要保证转换大数据要是对方可以接受的范围。

n1类型是int32，那么➕20整个就是int32类型，可是n2是int64，这样就会编译错误。

题二n4是12 + 127溢出超过了范围，运行的时候按照溢出处理。n3是直接编译不通过，128已经超过了int8类型的范围

基本数据类型和string的转换

字符串格式化

Go语言用于控制文本输出常用的标准库是fmt

fmt中主要用于输出的函数有:

Print: 输出到控制台,不接受任何格式化操作

Println: 输出到控制台并换行

Printf : 只可以打印出格式化的字符串。只可以直接输出字符串类型的变量（不可以输出别的类型）

Sprintf：格式化并返回一个字符串而不带任何输出

Fprintf：来格式化并输出到 io.Writers 而不是 os.Stdout

整数类型

格 式 描 述

%b 整型以二进制方式显示

%o 整型以八进制方式显示

%d 整型以十进制方式显示

%x 整型以十六进制方式显示

%X 整型以十六进制、字母大写方式显示

%c 相应Unicode码点所表示的字符

%U Unicode 字符, Unicode格式：123，等同于 "U+007B"

浮点数

格 式 描 述

%e 科学计数法，例如 -1234.456e+78

%E 科学计数法，例如 -1234.456E+78

%f 有小数点而无指数，例如 123.456

%g 根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出

%G 根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出

布尔

格 式 描 述

%t true 或 false

字符串

格 式 描 述

%s 字符串或切片的无解译字节

%q 双引号围绕的字符串，由Go语法安全地转义

%x 十六进制，小写字母，每字节两个字符

%X 十六进制，大写字母，每字节两个字符

指针

格 式 描 述

%p 十六进制表示，前缀 0x

var num1 int64 = 99

var num2 float64 = 23.99

var b bool = true

var mychar byte = 'h'

str1 := fmt.Sprintf("%d",num1)

str2 := fmt.Sprintf("%f",num2)

bool1 := fmt.Sprintf("%t",b)

mychar1 := fmt.Sprintf("%c",mychar)

fmt.Printf("%T,%T,%T,str1=%v,str2=%v,bool1=%v,mychar1=%v",str1,bool1,str2,str1,str2,bool1,mychar1)

string,string,string,string,str1=99,str2=23.990000,bool1=true,mychar1=h

登录后复制



使用strconv包 基本类型 - string类型

num1 := 99

str1 := strconv.FormatInt(int64(num1),10)

fmt.Printf("%T,%v",str1,str1)

num2 := 99.99

str2 := strconv.FormatFloat(num2,'f',10,64)

fmt.Printf("%T,%v\n",str2,str2)

登录后复制

strconv包提供了字符串与简单数据类型之间的类型转换功能，可以将简单类型转换为字符串，也可以将字符串转换为其它简单类型

string和int转换

int转string的方法是: Itoa()

str := strconv.Itoa(100)

fmt.Printf("type %v, value: %s\n", reflect.TypeOf(str), str)

登录后复制

2.string转int的方法是:

i, err := strconv.Atoi("100")

fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)

登录后复制

并不是所有string都能转化为int, 所以可能会报错:

i, err := strconv.Atoi("100x")

fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)

登录后复制

使用strconv包 string转其他类型

strconv包提供的Parse类函数用于将字符串转化为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint() 由于字符串转换为其它类型可能会失败，所以这些函数都有两个返回值，第一个返回值保存转换后的值，第二个返回值判断是否转换成功。

1.转bool

b, err := strconv.ParseBool("true")

fmt.Println(b, err)

登录后复制

2.转float

f1, err := strconv.ParseFloat("3.1", 32)

fmt.Println(f1, err)

f2, err := strconv.ParseFloat("3.1", 64)

fmt.Println(f2, err)

登录后复制

由于浮点数的小数部分 并不是所有小数都能在计算机中精确的表示, 这就造成了浮点数精度问题, 比如下面

var n float64 = 0

for i := 0; i 1000; i++ {

n += .01

}

fmt.Println(n)

关于浮点数精度问题: c计算机不都是0101吗，你有想过计算机是怎么表示的小数吗, 简单理解就是:

将其整数部分与小树部分分开, 比如5.25

对于整数部分 5 ，我们使用"不断除以2取余数"的方法，得到 101

对于小数部分 .25 ，我们使用"不断乘以2取整数"的方法，得到 .01

听说有一个包可以解决这个问题: github点抗 /shopspring/decimal

3.转int

func ParseInt(s string, base int, bitSize int) (i int64, err error)

base: 进制，有效值为0、2-36。当base=0的时候，表示根据string的前缀来判断以什么进制去解析：0x开头的以16进制的方式去解析，0开头的以8进制方式去解析，其它的以10进制方式解析

bitSize: 多少位，有效值为0、8、16、32、64。当bitSize=0的时候，表示转换为int或uint类型。例如bitSize=8表示转换后的值的类型为int8或uint8

fmt.Println(bInt8(-1)) // 0000 0001(原码) - 1111 1110(反码) - 1111 1111

// Parse 二进制字符串

i, err := strconv.ParseInt("11111111", 2, 16)

fmt.Println(i, err)

// Parse 十进制字符串

i, err = strconv.ParseInt("255", 10, 16)

fmt.Println(i, err)

// Parse 十六进制字符串

i, err = strconv.ParseInt("4E2D", 16, 16)

fmt.Println(i, err)

4.转uint

func ParseUint(s string, base int, bitSize int) (uint64, error)

用法和转int一样, 只是转换后的数据类型是uint64

u, err := strconv.ParseUint("11111111", 2, 16)

fmt.Println(u, err)

u, err = strconv.ParseUint("255", 10, 16)

fmt.Println(u, err)

u, err = strconv.ParseUint("4E2D", 16, 16)

fmt.Println(u, err)

其他类型转string

将给定类型格式化为string类型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。

fmt.Println(strconv.FormatBool(true))

// 问题又来了

fmt.Println(strconv.FormatInt(255, 2))

fmt.Println(strconv.FormatInt(255, 10))

fmt.Println(strconv.FormatInt(255, 16))

fmt.Println(strconv.FormatUint(255, 2))

fmt.Println(strconv.FormatUint(255, 10))

fmt.Println(strconv.FormatUint(255, 16))

fmt.Println(strconv.FormatFloat(3.1415, 'E', -1, 64))

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。

fmt表示格式：'f'（-ddd.dddd）、'b'（-ddddp±ddd，指数为二进制）、'e'（-d.dddde±dd，十进制指数）、'E'（-d.ddddE±dd，十进制指数）、'g'（指数很大时用'e'格式，否则'f'格式）、'G'（指数很大时用'E'格式，否则'f'格式）。

prec控制精度（排除指数部分）：对'f'、'e'、'E'，它表示小数点后的数字个数；对'g'、'G'，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。