基础数据类型和运算符

基础数据类型

数字

整型

整型分为以下两个大类：无符号和有符号。uint8就是我们熟知的byte型，int16对应C语言中的short型，int64对应C语言中的long型。

*即便是都是整数，但是类型不同仍然不能进行计算或比较。

类型		符号	描述
uint8		无	8位整型 (0 到 255) ,byte类型
uint16			16位整型 (0 到 65535)
uint32	uint		32位整型 (0 到 4294967295),uint在32位操作系统上
uint64	uint		64位整型 (0 到 18446744073709551615),uint在64位操作系统上
uintptr			用于存放一个指针，只在底层编程使用
int8		有	8位整型 (-128 到 127)
int16			16位整型 (-32768 到 32767)
int32	int		32位整型 (-2147483648 到 2147483647),int在32位操作系统上,rune类型
int64	int		64位整型 (-9223372036854775808 到 9223372036854775807),int在64位操作系统上

在使用int和 uint类型时，不能假定它是32位或64位的整型，而是考虑int和uint可能在不同平台上的差异。
获取对象的长度的内建len()函数返回的长度可以根据不同平台的字节长度进行变化。实际使用中，切片或 map 的元素数量等都可以用int来表示。

而涉及到二进制传输、读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用int和 uint。

int和uint说明

/*
Go1.13版本之后引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字，例如：
v := 0b100，代表二进制的 100，相当于十进制的 4。
v := 0o377，代表八进制的 377，相当于十进制的 255。
v := 0xa0，代表十六进制 a0，相当于十进制的 160。
而且还允许我们用 _ 来分隔数字，比如说：
v := 123_456 等于 123456。
我们可以借助fmt函数来将一个整数以不同进制形式展示。
*/

package main

import "fmt"

// 全局变量m
var m = 100
const pi float32 = 3.1415

func main() {
    v0 := 0b10   //
    v1 := 8      //默认十进制
    v2 := 0o377   //0表示八进制
    v3 := 0xa0   //0x表示16进制
    v := 123_456
    fmt.Printf("%d \n",v)  //结果为123456
    fmt.Printf("%b \n",v0) //将v0表示为二进制 10
    fmt.Printf("%d \n",v0) //将v0表示为十进制 2
    fmt.Printf("%d \n",v1) //将v1表示为十进制 8
    fmt.Printf("%b \n",v1) //将v1表示为二进制 1000
    fmt.Printf("%o \n",v2) //将v2表示为八进制 377
    fmt.Printf("%x \n",v3) //将v3表示为十六进制 a0
    fmt.Printf("%d \n",v3) //将v3表示为十进制 160
}

View Code

// byte 等同于int8，常用来处理ascii字符
// rune 等同于int32,常用来处理unicode或utf-8字符
    
package main

import (
        "fmt"
    "reflect"
        )

func main() {
    var r rune = 97
    var i byte = 97
    fmt.Println(reflect.TypeOf(r),reflect.TypeOf(i)) // int32 uint8
}

byte和rune

浮点型

Go语言支持两种浮点型数：float32和float64。

这两种浮点型数据格式遵循IEEE 754标准： 
float32 范围 3.4e38，常量定义：math.MaxFloat32。 
float64 范围 1.8e308，常量定义：math.MaxFloat64。

范围

//打印浮点数时，可以使用fmt包配合动词%f，代码如下：
package main

import (
    "fmt"
    "math"
    )

func main() {
    fmt.Println(math.Pi)                //完整输出 3.141592653589793
    fmt.Printf("%f\n",math.Pi)   //float32完整输出 3.141593
    fmt.Printf("%2f\n",math.Pi)  //float64完整输出 3.141593
    fmt.Printf("%.f\n",math.Pi)  //3
    fmt.Printf("%.1f\n",math.Pi) //3.1
    fmt.Printf("%.2f\n",math.Pi) //3.14

    const f  =  3.141592653589793
    var f32 float32 = 3.141592653589793
    var f64 float64 = 3.141592653589793
    fmt.Println(f)     //3.141592653589793
    fmt.Println(f32)   //3.1415927
    fmt.Println(f64)   //3.141592653589793
}

打印浮点数/浮点数的格式化输出

复数

复数由实部和虚部组成，go支持两种复数类型：complex64和complex128，complex64的实部和虚部为32位，complex128的实部和虚部为64位。

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)

复数的定义

布尔值

Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。

布尔类型变量的默认值为false。
Go 语言中不允许将整型强制转换为布尔型.
布尔型无法参与数值运算，也无法与其他类型进行转换。

注意

package main

import (
    "fmt"
    )

func main() {
    var t bool = true
    var f bool
    fmt.Println(t)  // true
    fmt.Println(f)  // false
}

布尔值的定义

字符串

golang中string的内部实现使用UTF-8编码，字符串的值为双引号(")中的内容。

底层是通过byte数组实现的。中文字符在unicode下占2个字节，在utf-8编码下占3个字节，而golang默认编码是utf-8。

实现

package main

import "fmt"
    

func main() {
    var s string = "hello,Eva"
    fmt.Println(s)
}

字符串的定义

/*
Go语言中要定义一个多行字符串时，就必须使用反引号字符：

s1 := `第一行
第二行
第三行
`
反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。
*/
package main

import "fmt"

func main() {
    s := `hello,
eva,\nHave you eaten?
`
    fmt.Println(s)
}


/*
结果：
hello,
eva,\nHave you eaten?

*/

定义多行字符串

字符串转义符

转义符	含义
`\r`	回车符（返回行首）
`\n`	换行符（直接跳到下一行的同列位置）
`\t`	制表符
`\'`	单引号
`\"`	双引号
`\\`	反斜杠

字符串的常用操作

方法	介绍
len(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.Index(),strings.LastIndex()	子串出现的位置
strings.Join(a[]string, sep string)	join操作

package main

import "fmt"

func main() {
    var s string = "你好,Eva"
    var s2 string = "hello,Eva"
    fmt.Println(s,len(s),len([]rune(s)))   //非全英文字符时使用rune计算字符串长度
    fmt.Println(s2,len(s2),len([]byte(s2))) //全英文字符时使用byte计算字符串长度

计算字符串的长度

package main

import "fmt"

func main() {
    var s string = "你好,Eva"
    for i:=0;i<len(s);i++{
        fmt.Printf("%d,%v,%c \n",i,s[i],s[i])
    }
    println("*********************")
    for ind,r := range s{
        fmt.Printf("%d,%v,%c\n",ind,r,r)
    }
}

字符串的遍历

package main

import "fmt"
func main() {
    s1 := "开开心心"
    s2 := "不动脑筋"
    fmt.Println(s1+","+s2)
    fmt.Printf("%s,%s",s1,s2)
}

字符串拼接

package main

import "fmt"

func main() {
    //strings.Split(s,sep)
    s1 := "hello,eva"
    ret := strings.Split(s1,",")
    fmt.Println(ret) // [hello eva]

    // strings.Contains(s,substr)
    ret2 := strings.Contains(s1,"hello")
    fmt.Println(ret2) // true

    // strings.HasPrefix/strings.HasSuffix
    ret3 := strings.HasPrefix(s1,"hello")
    fmt.Println(ret3)  // true
    ret4 := strings.HasSuffix(s1,"hello")
    fmt.Println(ret4)  // flase

    // strings.Index(s,substr)
    ret5 := strings.Index(s1,"eva")
    fmt.Println(ret5)  // 6

    // strings.Join(lst,sep)
    l := []string{"a","b","c"}
    ret6 := strings.Join(l,"-")
    fmt.Println(ret6)  // a-b-c
}

strings的方法

/*
要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。
*/
func changeString() {
    s1 := "big"
    // 强制类型转换
    byteS1 := []byte(s1)
    byteS1[0] = 'p'
    fmt.Println(string(byteS1))

    s2 := "白萝卜"
    runeS2 := []rune(s2)
    runeS2[0] = '红'
    fmt.Println(string(runeS2))
}

修改字符串(了解)

格式化打印常见格式化符号 

%T操作变量所属类型

%d 整型格式

%s 字符串格式

%c 字符

%f 浮点型

%v 自动匹配格式

运算符

算数运算符

运算符	描述
+	相加
-	相减
*	相乘
/	相除
%	求余

注意： ++（自增）和--（自减）在Go语言中是单独的语句，并不是运算符。

关系运算符

运算符	描述
==	检查两个值是否相等，如果相等返回 True 否则返回 False。
!=	检查两个值是否不相等，如果不相等返回 True 否则返回 False。
>	检查左边值是否大于右边值，如果是返回 True 否则返回 False。
>=	检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
<	检查左边值是否小于右边值，如果是返回 True 否则返回 False。
<=	检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。

逻辑运算符

运算符	描述
&&	逻辑 AND 运算符。如果两边的操作数都是 True，则为 True，否则为 False。
\|\|	逻辑 OR 运算符。如果两边的操作数有一个 True，则为 True，否则为 False。
!	逻辑 NOT 运算符。如果条件为 True，则为 False，否则为 True。

位运算符

位运算符对整数在内存中的二进制位进行操作。

运算符	描述
&	参与运算的两数各对应的二进位相与。（两位均为1才为1）
\|	参与运算的两数各对应的二进位相或。（两位有一个为1就为1）
^	参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。（两位不一样则为1）
<<	左移n位就是乘以2的n次方。 “a<<b”是把a的各二进位全部左移b位，高位丢弃，低位补0。
>>	右移n位就是除以2的n次方。 “a>>b”是把a的各二进位全部右移b位。

赋值运算符

运算符	描述
=	简单的赋值运算符，将一个表达式的值赋给一个左值
+=	相加后再赋值
-=	相减后再赋值
*=	相乘后再赋值
/=	相除后再赋值
%=	求余后再赋值
<<=	左移后赋值
>>=	右移后赋值
&=	按位与后赋值
\|=	按位或后赋值
^=	按位异或后赋值

posted @ 2019-11-25 17:05 Eva_J 阅读(220) 评论(0) 收藏举报

程序媛

Eva_J

基础数据类型和运算符