go语言中基本数据类型及应用快速了解

目录
  • 整数
    • 特殊的整数类型
    • 如果想确定int和uint的大小
    • 溢出
  • 浮点数
  • 复数
  • 布尔值
  • 字符串
    • 字符串的“长度”与遍历字符串的做法
      • 字符串的“长度”
      • 遍历字符串
    • Rune与Byte(字节)
    • 字符串与字节slice的转换
    • 字符串不可变
  • 基本类型的值都是可比较的
  • 数值的类型转换
  • 运算符
  • 常量

整数

按位长度分度分为:8位,16位,32位,64位。

对应有符号整数:int8,int16,int32,int64。

对应无符号整数:uint8,uint16,uint32,uint64。

计算最大数和最小数规则:

  • 有符号整数:由于有符号,因此位数的最高位被用来存储符号,其他为存储数据值,所以对于n位数来说,取值范围是:-2^(n-1)^~2^(n-1)^-1,对应int8来说,就是 -127 ~ 127。
  • 无符号正数:不需要用最高位记录符号,全部位数表示数字。取值范围是:0 ~ 2^n^-1。对于int8来说,就是0 ~ 255。

特殊的整数类型

intuint以及uintptr

intuint根据特定的平台,其大小与原生的整数相同或者是该平台上运算效率最高的值。要么同时是64位,要么同时是32位,但也不能假定他们就是64位或者32位的整型。即使在一样的硬件下,不同编译器也有可能选用不同的大小。

至于uintptr,它的大小并不明确。但它肯定足够容纳一个指针的大小。常用于底层编程。

虽然intuint的长度可能与int32int64..其他整型相同但是他们是不同的类型。

如果想确定intuint的大小

fmt.Println(runtime.GOARCH)		// 看看CPU型号
fmt.Println(strconv.IntSize)	// 这才是int的大小,上面只是提供一个对照

溢出

不论是有符号数还是无符号数,若计算结果所需的位超出类型的范围,就称为溢出。溢出的高位会被无提示地抛弃。

var i int8 = -128
fmt.Println(i-1)	// 127
var i2 int8 = 127
fmt.Println(i2+1)	// -128
var u uint8 = 0
fmt.Println(u-1)	// 255
var u2 uint8 = 255
fmt.Println(u2+1)	// 0

浮点数

float32float64。遵循IEEE 754标准。

math.MaxFloat32给出了float32类型的最大值:3.4028234663852886e+38

math.MaxFloat64则是float64类型的最大值:1.7976931348623157e+308

浮点数可以用来表示小数。

十进制下,float32有效位大约是6位。float64有效位大约是15位。

浮点数的打印可以使用:

  • %g,保留足够的精度显示
  • %e,使用指数形式显示
  • %f,使用无指数形式显示
f := 2.71828
fmt.Printf("%g, %[1]e, %[1]f \n", f)	// 2.71828, 2.718280e+00, 2.718280

复数

complex64complex128 ,二者分别由float32float64组成。

使用real函数提取复数的实部,使用imag函数提取复数的虚部。

浮点数或者整数后面加i就会变成一个虚数,且它的实部为0

x := 1+2i
y := 3+4i

布尔值

bool类型就是布尔值,有true(真)和false(假)两个值。

布尔值无法隐式转换成数值,数值也不能转成布尔值。

它的零值是false

一元操作符!表示逻辑取反。!true表示false

字符串

string表示字符串。它是不可变的字节序列。Go中的字符串内部实现用UTF-8编码。

字符串的“长度”与遍历字符串的做法

字符串的“长度”

对字符串调用len函数,获取到的不是字符串的长度(字符的个数),而是字符串的字节数(字节切片的长度)。

如下,尽管字符个数只有6,但字节长度len(s)却有18,这是因为中文字符以UTF-8存储,通常包含3~4个字节。

s := "中文字节数多"
fmt.Println("len: ", len(s))	// len:  18

对字符串使用下标索引操作,会返回对应索引的字节,而不是字符。

s := "中文字节数多"
fmt.Println("len: ", len(s))	// len:  18
for i :=0; i < len(s); i++ {
    fmt.Printf("%d, %[1]c, %[1]T\n",s[i])
}

对应的输出如下:

len: 18
228, ä, uint8
184, ¸, uint8
173, ­, uint8
230, æ, uint8
150, �, uint8
135, �, uint8
229, å, uint8
173, ­, uint8
151, �, uint8
232, è, uint8
138, �, uint8
130, �, uint8
230, æ, uint8
149, �, uint8
176, °, uint8
229, å, uint8
164, ¤, uint8
154, �, uint8

因此不要随便乱用字符串的下标操作,否则可能获得有意想不到的结果。

遍历字符串

由上面的下标操作可以看出,对字符串的下标索引操作会获得单个字节而不是字符,假如现在我们想处理的是UTF-8解码的字符的话,有两种方式,基本思路都是处理成rune类型:

第一种,用UTF-8解码器显式处理这些字符,unicode/utf8包示例。

utf8.RuneCountInString(s)返回字符串转为rune后的个数,Go使用rune代表一个UTF-8字符。

utf8.utf8.DecodeRuneInString(s[i:])处理当前字符串,并算出下一个rune以及它所占的字节数。

s := "What? 中文字节数多"
runeCount := utf8.RuneCountInString(s)
fmt.Println("runeCount:", runeCount)	// runeCount: 12
for i:= 0; i<len(s); {
	r, size:= utf8.DecodeRuneInString(s[i:])
	fmt.Printf("i: %d, r:%q, type:%T \n", i, r, r)
	i += size
}

输出如下:

runeCount: 12
i: 0, r:'W', type:int32
i: 1, r:'h', type:int32
i: 2, r:'a', type:int32
i: 3, r:'t', type:int32
i: 4, r:'?', type:int32
i: 5, r:' ', type:int32
i: 6, r:'中', type:int32
i: 9, r:'文', type:int32
i: 12, r:'字', type:int32
i: 15, r:'节', type:int32
i: 18, r:'数', type:int32
i: 21, r:'多', type:int32

第二种,用range循环,Go会隐式的进行UTF-8解码。

注意,这里的i,指的是字节的下标,而不是字符的下标。

s := "What? 中文字节数多"
for i, r := range s {
    fmt.Printf("i: %d, rune: %q, type: %T \n", i, r, r)
}

输出如下:

i: 0, rune: 'W', type: int32
i: 1, rune: 'h', type: int32
i: 2, rune: 'a', type: int32
i: 3, rune: 't', type: int32
i: 4, rune: '?', type: int32
i: 5, rune: ' ', type: int32
i: 6, rune: '中', type: int32
i: 9, rune: '文', type: int32
i: 12, rune: '字', type: int32
i: 15, rune: '节', type: int32
i: 18, rune: '数', type: int32
i: 21, rune: '多', type: int32

Rune与Byte(字节)

int32的别名是rune,天然适合存储单个文字符号,为Go所采用的。

rune类型值代表一个UTF-8字符。以字节(byte)为单位对Unicode码点作变长编码。现在计算机都用UTF-8来表示单个字符。

字符串的是由“字符”组成的,字符用单引号包裹起来,如:

var b = 'h'
c := '冲'
fmt.Printf("%d, %q \n", b, b)	// 104, 'h'
fmt.Printf("%d, %q \n", c, c)	// 20914, '冲'

字节,byte类型,底层类型是uint8,由8个bit组成,它可以代表一个ASCII码。ASCII码是满足早期计算机的使用的,它用7位表示128个“字符”(ASCII字符):大小写英文字母、数字、标点符号和设备控制符。

字符串与字节slice的转换

字符串底层是一个字节数组,所以可以和[]byte类型互换。

s := "abc"
b := []byte(s)
s2 := string(b)

概念上,[]byte(s)转换操作会分配新的字节数组,拷贝填入s含有的字节,并生成一个slice的引用,指向整个数组。反之,用string(b)也会产生一份副本而不是操作真正的b,以此保证上面s2不变。

字符串不可变

字符串是不可变的,表现在其字符串值不可修改。平时我们看到的字符串修改操作、拼接操作并不改变原有的字符串值,而是将操作后生成新的字符串值赋予原来的变量。

s := "left foot"
t := s
s += ", right foot"

尽管字符串创建后,它底层的字节slice不可变,但是普通的字节slice是可以随意改变的。

var a = []byte{'h', 'e', 'l', 'l', 'o'}
fmt.Printf("%p, %[1]q \n", a)	// 0xc00000a098, "hello"
a[4] = ' '
fmt.Printf("%p, %[1]q \n", a)	// 0xc00000a098, "hell "

由于字符串的不可变以及避免频繁的操作字符串而导致的多次内存分配和复制,可以使用bytes.Buffer类型。

见GOPL的一个例子:

func intsToString(values []int) string {
	var buf bytes.Buffer
	buf.WriteByte('[')
	for i, v := range values {
		if i > 0 {
			buf.WriteString(",")
		}
		fmt.Fprintf(&buf, "%d", v)
	}
	buf.WriteByte(']')
	return buf.String()
}
func main() {
	fmt.Println(intsToString([]int{1, 2, 3})) // [1,2,3]
}

追加ASCII字符可以用writeByte,追加UTF-8编码的文字符号,最好用WriteRune方法。

基本类型的值都是可比较的

基本类型的值都是可比较的,如布尔值、数值、字符串等。

数值的类型转换

很多整型—整型的转换不会引起值的变化,仅告知编译器如何解读这么值。但缩减大小的类型转换,以及整型与浮点型的相互转换,会因此值的改变或者损失精度。

浮点型转整型会舍弃小数部分并向0取整。

var f = 3.526
i := int(f)
fmt.Printf("f: %v, i: %v \n", f, i) // f: 3.526, i: 3
var i16 = int16(555)
var i8 = int8(i16)
fmt.Printf("i16: %v, i8: %v \n", i16, i8) // i16: 555, i8: 43

运算符

运算符降序排列:

* 	/ 	% 	<< 	>> 	& 	&^
+ 	- 	| 	^
==	!=	<	<=	>	>=
&&
||

二元运算符分为五大优先级。同级别的运算符满足左结合律,可以用圆括号指定次序。

常量

常量是一种表达式,保证在编译阶段就计算出对应的值。所有常量本质上都属于基本类型:布尔型、字符串或者数字。

常量自编译后,其值恒定不变。

type Integer int
const I Integer = 10
const S string = "important_secret"
const (
	NUM1 = 1
	NUM2 = 2
	NUM3
	NUM4 = 5.5
	STR1 = "STR1"
)
func main() {
	fmt.Printf("I: %v \n", I)
	fmt.Printf("S: %v \n", S)
	fmt.Printf("NUM1: %v \n", NUM1)
	fmt.Printf("NUM2: %v \n", NUM2)
	fmt.Printf("NUM3: %v \n", NUM3)
	fmt.Printf("NUM4: %v \n", NUM4)
	fmt.Printf("STR1: %v \n", STR1)
}

输出如下:

I: 10
S: important_secret
NUM1: 1
NUM2: 2
NUM3: 2
NUM4: 5.5
STR1: STR1

以上就是go语言中基本数据类型及应用快速了解的详细内容,更多关于go基本数据类型的资料请关注我们其它相关文章!

(0)

相关推荐

  • Go语言特点及基本数据类型使用详解

    目录 一.Golang 简介 1.Go 语言的特点 2.Golang 的变量作用域 3.Golang 执行流程的两种方式 二.Golang 的基本操作 1.在 Linux 上安装 Golang 语言开发包 2.Golang 变量的基本使用 3.Golang 中整数的类型 4.Golang 基本数据类型的默认值 5.基本数据类型转换为 String 类型 一.Golang 简介 Golang(又称为 Go)是 Google 公司开发出的一种静态强类型.编译型.并发型,并具有垃圾回收功能的编程语言.

  • GO语言基本数据类型总结

    本文实例总结了GO语言基本数据类型.分享给大家供大家参考.具体如下: 1.注释(与C++一样) 行注释://块注释:/* ...*/ 2.标识符 可以这么说,除了数字开头的不允许,符号开头的不允许,关键字不允许,其他的Unicode字符组合都可以."_33"也可以是标识符."我们"也可以是标识符.标识符也区分大小写. (1).以大写字母开头的标识符是公开的.(这个很有意思) (2).其他任何标识符都是私有的. (3).空标识符"_"是一个占位符,

  • Golang通脉之数据类型详情

    目录 1.标识符与关键字 1.1 标识符 1.2 关键字 2.变量 2.1 什么是变量 2.2 变量类型 2.3 变量声明 3.常量 3.1 iota 4.基本数据类型 4.1 整型 4.2 浮点型 4.3 复数 4.4 布尔值 4.5 字符串 4.6 byte和rune类型 4.7 类型转换 5.运算符 5.1 算数运算符 5.2 关系运算符 5.3 逻辑运算符 5.4 位运算符 5.5 赋值运算符 5.6 运算符优先级 1.标识符与关键字 在了解数据类型之前,先了解一下go的标识符和关键字

  • Go语言基本的语法和内置数据类型初探

    Go令牌 Go程序包括各种令牌和令牌可以是一个关键字,一个标识符,常量,字符串文字或符号.例如,下面的Go语句由六个令牌: 复制代码 代码如下: fmt.Println("Hello, World!") 个体令牌是: 复制代码 代码如下: fmt . Println ( "Hello, World!" ) 行分离器 在Go程序,行的分隔符关键是一个语句终止.也就是说,每一个单独语句不需要特殊的分隔线; 在C编译器转到内部的地方; 作为语句终止符,表示一个逻辑实体的结

  • Go语言七篇入门教程二程序结构与数据类型

    目录 1. 程序结构 1.1 名称 1.2 声明 1.3 注释 1.4 单双引号 1.5 输出 2. 数据类型 2.1 整型 2.2 浮点型 2.3 复数 2.4 布尔型 2.5 字符串 2.6 常量 2.7 数组 2.8 切片 2.9 map 2.10 结构体 2.11 JSON 3. 流程控制 3.1 条件语句 3.2 选择语句 3.3 循环语句 如何学习Go 1. 程序结构 1.1 名称 如果一个实体名称在函数中声明,它只在函数局部有效.如果声明在函数外,它将对包里面的所有源文件可见. 实

  • go语言中基本数据类型及应用快速了解

    目录 整数 特殊的整数类型 如果想确定int和uint的大小 溢出 浮点数 复数 布尔值 字符串 字符串的“长度”与遍历字符串的做法 字符串的“长度” 遍历字符串 Rune与Byte(字节) 字符串与字节slice的转换 字符串不可变 基本类型的值都是可比较的 数值的类型转换 运算符 常量 整数 按位长度分度分为:8位,16位,32位,64位. 对应有符号整数:int8,int16,int32,int64. 对应无符号整数:uint8,uint16,uint32,uint64. 计算最大数和最小

  • Python语言中的数据类型-序列

    目录 一.什么是序列数据类型? 二.序列数据类型的基本操作 1.序列的通用方法 2.通过索引访问数据 3.同类型的序列进行拼接 4.判断序列成员 5.序列的排序操作 6.内置函数all()与any() 7.序列的拆分 三.列表 1.创建列表 2.向列表内添加数据 3.删除列表内的数据 三.元组 四.字符串 五.字节序列 前言:前面我们提到了Python数据类型中的内置数值类型与字符串类型.今天学习一下Python的序列数据类型,要知道的是在Python中没有数组这一数据结构,也没有提供直接创建数

  • 详解Go语言中的数据类型及类型转换

    目录 1.基本数据类型 2.基础数据类型转换 3.基本数据类型转为字符串 4.strconv的使用 5.字符串转为基础类型 1.基本数据类型 数据类型有很多,先研究一下基础的,例如:布尔型.数字类型.字符串类型. 数字类型有uint8.uint16.uint32.uint64.int8.int16.int32.int64(uint和int区别在于uint为无符号整数,即只支持正数,不支持负数形式) 数字浮点型有fload32.float64.complex64.complex126(后面两个均为

  • Go语言中基本数据类型的相互转换详解

    目录 基本数据类型的相互转换 基本语法 小知识 基本数据类型和string的转换 方法一 方法二 string和基本数据类型转换 基本数据类型的相互转换 Go在不同类型的变量之间赋值时需要显示转换,不能自动转换 基本语法 表达式 T(v): 将值v转换成类型T T就是数据类型: int32, int64, float32... v就是需要转换的变量 1.不考虑溢出的情况下,类型转换不会改变数值大小 var i int8 = 100 var n int32 = int32(i) fmt.Print

  • 详解易语言中的数据类型

    各种数据存放在磁盘或内存中都有其不同的存放格式,因此就存在不同的数据类型.了解各种数据的特性,对编程开发来说是十分重要. 程序中经常会进行一些运算,易语言中的运算都要使用运算符进行识别处理,并通过运算表达式来完成运算操作.程序中对各数据之间的关系的描述也要通过运算符. 1.易语言的数据类型 一个程序内部应包括两个方面的内容:1.数据的描述.2.操作步骤,即对程序动作的描述. 数据是程序操作的对象,操作的结果会改变数据的内容.打个比方:要做一道菜,做菜前先选择烹饪的原材料(即对数据进行描述),然后

  • C语言中字符串的存储方法

    众所周知,C语言中没有数据类型能够存储字符串,char数据类型仅仅能够存储一个字符的数据,那么在C语言中关于存储字符串这一难题我们改何去何从呢? 下面将详述相关的字符串存储方法; 1.使用字符数组存; [root@Qrui ruiy]# #include<stdio.h> int main(int argc,const char *argv[],const char **env[]) { char name[] = "qinrui";//定义一个字符数组,并初始化; cha

  • C语言中的参数传递机制详解

    C中的参数传递 本文尝试讨论下C中实参与形参的关系,即参数传递的问题. C语言的参数传递 值传递 首先看下列代码: #include <stdio.h> int main(){ int n = 1; printf("实参n的值:%d,地址:%#x\n", n, &n); void change(int i);//函数声明 change(n); printf("函数调用后实参n的值:%d,地址:%#x\n", n, &n); return

  • C语言中结构体变量私有化详解

    背景介绍 操作系统 : CentOS7.3.1611_x64 gcc版本 :4.8.5 什么是结构体? 在C语言中,结构体(struct)指的是一种数据结构,是C语言中聚合数据类型(aggregate data type)的一类.结构体可以被声明为变量.指针或数组等,用以实现较复杂的数据结构.结构体同时也是一些元素的集合,这些元素称为结构体的成员(member),且这些成员可以为不同的类型,成员一般用名字访问. 问题描述 C语言结构体定义中的变量默认是公有(Public)属性,如果实现成员变量的

  • 深入理解C语言中使用频率较高的指针与数组

    目录 定义 指针与二维数组 指针数组与数组指针 数组指针的应用 操作 总结 定义 指针:C语言中某种数据类型的数据存储的内存地址,例如:指向各种整型的指针或者指向某个结构体的指针. 数组:若干个相同C语言数据类型的元素在连续内存中储存的一种形态. 数组在编译时就已经被确定下来,而指针直到运行时才能被真正的确定到底指向何方.所以数组的这些身份(内存)一旦确定下来就不能轻易的改变了,它们(内存)会伴随数组一生. 而指针则有很多的选择,在其一生他可以选择不同的生活方式,比如一个字符指针可以指向单个字符

  • C语言深入探索数据类型的存储

    目录 数据类型介绍 类型的基本归纳 整型家族 浮点数家族 构造类型 指针类型 空类型 整型在内存中的存储 原码,反码,补码 大小端 浮点数在内存中的存储 浮点数存储的规则 数据类型介绍 首先,对于我们C语言中的数据类型,大家应该都有一个清晰的认识吧!如果不记得也没有关系哦~ 在这里来跟着小刘同学回顾一下吧! 关于数据类型,我们在前面已经学习过了一些内置数据类型,以及它们所占的内存空间的大小,例如: char         //字符数据类型int          //整型short      

随机推荐