Go_02_基础数据类型

Go语言基础类型：

​ boolean , int/u

1，整型

//整型的定义，使用:=符号
var value1 int32
func main(){
    value2:=64
}

//整型的运算
x,y:=2,4
if x==y {
    fmt.Println("X等于Y")
}

//一个小demo演示
package main
import "fmt"
var x int32
var y int64

func main(){
    x,y=2,4
    if x==y{//若尝试在if语句中比较两个不同类型的字符，那编译会出错
        fmt.Println("x等于y")
    }
    if x==2 || y==2 {
        fmt.Println("x等于y")
	}
}

整型数据所支持的位运算

x<<y 左移

x>>y 右移

x^y 异或

x&y 与

x|y 或

^x 取反

2，浮点型

在Go语言中没有float类型。float32精确到小数点后7位，float64精确到小数点后15位。

//浮点表示的demo
package main
import(
	"fmt",
    "reflect"
)
func main(){
	var value1 float64
    value1=1
    value2:=2
    value3:=3.0
    v:=value1+value3
    fmt.Println(value1,vaule2,value3,v)
    fmt.Println("v的类型是:",reflect.TypeOf(v))
}//输出结果：1 2 3 4

//浮点型的运算
package main
import(
	"fmt"
)

func main(){
    var value1 float64
    value1=1
    value2:=1.000000001
    if value1==value2{
        fmt.Println("相等")
    }
}


//复数
package main
import(
	"fmt"
)

var value1 float64
func main(){
    var v1 complex64//由两个float32构成的复数类型
    v1 = 3.2+12i
    v2 :=3.2+12i
    v3 :=complex(3.2,12)
    v:=v2+v3
    fmt.Println(v1,v2,v3,v)
}//返回: (3.2+12i) (3.2+12i) (3.2+12i) (6.4+24i)


package main
import(
	"fmt"
)

func main(){
    v2:=3.2+12i
    v3:=complex(3.2,12)
    v:=v2+v3
    fmt.Println(v2,v3,v)
    vr:=real(v)//获取实部
    vi:=imag(v)//获取虚部
    fmt.Println(vr,vi)
}
//返回:(3.2+12i)(3.2+12i)(3.2+12i)(6.4+24i)

3，字符与字符串

Go语言的字符串是一种基本类型，这一点和C语言不一样，C语言没有原生的字符串类型

在Go语言中，一个字符串是一个不可改变的UTF-8字符序列，一个ASCII码占用1字节，其他字符根据需要占用2-4字节。

//字符串的表示
package main
import(
	"fmt"
)

var value1 float64
func main(){
    s:="aA你2"
    fmt.Println("字符串长度:",len(s))
    for i:=0;i<len(s);i++{
        fmt.Println(s[i])
    }
    s:="你好，"
    t:=s
    s+="世界。"
    fmt.Println(s)
    fmt.Println(t)//源字符串没有改变
}

//返回:字符串长度: 6
//97 65 228 189 160 50 你好，世界  你好，

内置的len()函数可以返回一个字符串中的字节数目（不是rune字符数目），索引操作s[i]可以返回第i字节值，i必须满足0<=i<len(s)条件约束

Go语言字符串类型支持一下两种形式的字面值。

1）解释字符串

该类字符串使用“ ”括起来，其中的相关的转义字符将被替换，这些转义字符包括：

\a
\b
\f
\n
\r
\t
\u
\v
\'
\"
\\

2）非解释字符串

该类字符串使用反引号（一般是在Esc键下面，数字1键左边）括起来，支持换行，这和js的模块字很像

package main
import("fmt")
var values float64
func main(){
    str1:=`世间若有苦难在\n
    岂能敌我Kok`
    str2:="是的"
    fmt.Println(str1)
    fmt.Printf(str2)
}

操作字符串

package main
import("fmt")
var value1 float64
func main(){
    s:="abc你"
    for i:=0;i<len(s);i++{
        fmt.Println(s[i])
    }
    c:=s[len(s)]
    fmt.Println(len(s),c)
    fmt.Println(s[0:7])
    /* 
    返回：
    97
    98
    99
    100
    228
    189
    160
    7 160
    abc 你
    */
}

连接字符串

使用”+“来连接字符串：

package main

import("fmt")

var value1 float64

func main(){
    s:="abc you"
    fmt.Println(s[4:]+"hi")
    str:="hello,"+"Go language."
    fmt.Println(str)
}

/*返回：
	youhi
	hello,Go language
*/

字符串遍历

package main
import "fmt"
func main(){
    s:="我是中国人"
    for i:=0;i<len(s);i++{
        fmt.Printf("%c",s[i])
    }
    fmt.Printf("\n")
    for _,v:=range s{
        fmt.Printf("%c",v)
    }
    fmt.Print("\n")
}

/*返回
	乱码
	我是中国人*/

遍历字符串一般使用range方式，如果要获取各个字符的字节值，可以使用

fmt.Printf("%d is %c",i,s[i])