0.Go语言·基本数据类型

作者: 一枼落知天下 | 来源:发表于2019-06-12 15:50 被阅读0次

0.Go语言·基本数据类型
【OC梳理】基本数据类型和基本运算
【初识C语言】C语言基本数据类型
技术问 - int 和 Integer有什么区别
KDB数据库的专属语言——Q语言
三、JNI-基本类型、字符串和数组
Java的八种基本数据类型
JS - 对象的操作办法
一：Java基础入门-数据类型
JavaScript复制对象

基本数据类型

main.go DAY01

package main

import (
    "fmt"
)

var (
    name = "Jhou Shuai"
    age  = 16
    sex  = "female"
)
/**
 * @author Jhou Shuai
 * 这是一个main函数，是程序的入口
 */
func main() {
    // 如果变量预定义咯。不使用，程序会报错：a declared and not used
    // 变量定义，指定数据类型，如果不赋值。就默认。
    /*var i int
    fmt.Println("i=",i)

    var num =10.1
    fmt.Println("num=",num)

    name := "Tom"
    fmt.Println("My name is",name)*/

    //一次声明多个变量
    
    //var n1,n2,n3 int

    //一次声明多个不同类型的变量
    //var n1 ,name ,n3 = 100,"Tom",889
    
    // n1 ,name ,n3 := 100,"Tom~",889
    // fmt.Println(n1 ,name ,n3)

    fmt.Println(name ,age ,sex)
}

main.go DAY02

package main

/*import "fmt"
import "unsafe"*/

import (
    "fmt"
    "unsafe"
)

func main(){

    //两个字节，16位 2**
    var n2 int16 = 10 
    fmt.Printf("类型：%T,占用的字节数：%d \n",n2,unsafe.Sizeof(n2))

    var age byte = 23
    fmt.Printf("类型：%T,占用的字节数：%d \n",age,unsafe.Sizeof(age))
    fmt.Println("年龄",age) 
    // 不论字符串的len有多大，sizeof始终返回16，这是为啥，字符串不是也是不可变的吗？
    // 实际上字符串类型对应一个结构体，该结构体有两个域，
    // 第一个域是指向该字符串的指针，第二个域是字符串的长度，每个域占8个字节，
    // 但是并不包含指针指向的字符串的内容，
    // 这也就是为什么sizeof始终返回的是16
    var name string = "周帅周帅周帅周帅"
    fmt.Printf("类型：%T,占用的字节数：%d \n",name,unsafe.Sizeof(name))
    fmt.Println("姓名",name) 

}

main.go DAY03

//浮点数
package main

import (
    "fmt"
)

func main(){
    //float32 4个字节，float64 8个字节
    //符号位+指数位+尾数位=浮点数
    //说明浮点数都是有符号的
    var price float32 = 2333.3
    fmt.Println(price)

    //尾数部分可能对视，造成精度损失。
    //float64 比float32精度要准确
    //需要高精度的数，则应该选择float64
    var salary float32 = -123.0000901
    var income float64 = -123.0000901
    fmt.Println("salary:",salary,"income:",income)

    var fee = 0.3
    fmt.Printf("默认的浮点类型：%T \n",fee)

    //科学计数法
    num1 := 5.1224e2
    num2 := 5.1234E2
    num3 := 5.1234E-2
    fmt.Println("num1:",num1,"num2:",num2,"num3:",num3) 

    //通常。使用float64
}

main.go DAY04

//字符
package main

import (
    "fmt"
    "unsafe"
)

// byte

func main(){
    //字符-》对应码值-》二进制——》存储
    var chr byte  = 'a'
    var chr0 byte = '0'
    fmt.Println("chr",chr,"chr0",chr0)

    //bool类型 一个字节，只能取true或false
    var b = false
    fmt.Println("b = ",b,"字节大小：",unsafe.Sizeof(b))

    //字符串 string
    var address string = "四川成都玉林品上"
    fmt.Println(address)

    address = "四川成都玉林品上\nloufeng" 
    fmt.Println(address)

    //反引号 ``
    str3 := `
    var price float32 = 2333.3
    fmt.Println(price)

    //尾数部分可能对视，造成精度损失。
    //float64 比float32精度要准确
    //需要高精度的数，则应该选择float64
    var salary float32 = -123.0000901
    var income float64 = -123.0000901
    fmt.Println("salary:",salary,"income:",income)

    var fee = 0.3
    fmt.Printf("默认的浮点类型：%T \n",fee)

    //科学计数法
    num1 := 5.1224e2
    num2 := 5.1234E2
    num3 := 5.1234E-2
    fmt.Println("num1:",num1,"num2:",num2,"num3:",num3) 
    `
    fmt.Println(str3)

    //字符串拼接 需要把加号。放在上一行
    var str = "hello" + " world" +
    " i love you  forever " + " you don't know i love you "

    str += ",Lily!"

    fmt.Println(str)

    //在go中。数据类型都有一个默认值，没有初始化、赋值就会保留默认值或叫零值
    var a int    //0
    var b1 float32 //0
    var c float64 //0
    var isok bool //false
    var name string //""
    //%v 表示按照变量的值输出。
    fmt.Printf("a=%d , b=%f,c=%f,isok=%v,name=%v",a,b1,c,isok,name)

}

main.go DAY05

// 基本数据类型转换

package main

import (
    "fmt"
    "strconv"
)

func main(){
    // 显示转换     
    var i int32 = 10 
    var a float64 = float64(i)
    fmt.Printf("a=%v的数据类型：%T \n",a,a)

    var b int8 = int8(i)
    fmt.Printf("b=%v的数据类型：%T \n",b,b)

    var c int64 = int64(i)
    fmt.Printf("c=%v的数据类型：%T \n",c,c)

    fmt.Printf("i=%v的数据类型：%T \n",i,i)


    var salary int64 = 150000
    var income int8 = int8(salary)
    fmt.Printf("income=%v的数据类型：%T \n",income,income)

    //基本数据类型转 字符串 fmt.Sprintf()
    var str string
    var myChar byte = 'a'
    var isok bool = true
    //str = fmt.Sprintf("%d",i)
    str = strconv.FormatInt(c,10)
    fmt.Printf("类型：%T str=%q  \n",str,str)

    //str = fmt.Sprintf("%f",a)
    str = strconv.FormatFloat(a,'f',3,64)
    fmt.Printf("类型：%T str=%q  \n",str,str)

    str = fmt.Sprintf("%c",myChar)
    fmt.Printf("类型：%T str=%q  \n",str,str)

    //str = fmt.Sprintf("%t",isok)
    str = strconv.FormatBool(isok)
    fmt.Printf("类型：%T str=%q  \n",str,str)

    str = strconv.Itoa(int(c))
    fmt.Printf("类型：%T str=%q  \n",str,str)

}

main.go DAY06

package main

import (
    "fmt"
    _"strconv"
)

func main(){
    var salary int64 = 12000
    fmt.Println(salary)
}

main.go DAY07

//指针

package main

import (
    "fmt"
)


func main() {
    // 基本数据类型，在内存的布局
    var i int = 10
    //i的内存地址 &i 
    //i地址： 0xc00006a080
    fmt.Println("i地址：",&i)

    //
    //ptr 指针变量
    //ptr 的类型 *int
    //ptr 本身的值 &i
    var ptr *int = &i
    // 0xc00006a080
    fmt.Printf("ptr=%v\n",ptr)
    //ptr地址： 0xc000096020
    fmt.Println("ptr地址：",&ptr)
    // 0xc000096020
    fmt.Println("ptr指向的值",ptr)
    fmt.Println("*ptr指向的值",*ptr)
}

main.go DAY08

//指针
package main

import (
    "fmt"
)

func main() {
    var num int = 9
    fmt.Printf("num address:%v \n", &num)

    var ptr *int
    ptr = &num
    *ptr = 10
    fmt.Println("num=",num)

}

func Nine(){
    for i:=1;i<=9;i++{
        for j:=1;j<=i;j++{
            // 格式化输出，不换行 \t==》tab
            fmt.Printf("%v*%v=%v\t",i,j,i*j)
        }
        //输出后，换行
        fmt.Println()
    }
}

main.go DAY09

//string 转基本类型

package main

import (
    "fmt"
    "strconv"
)

func main(){
    var str string = "true"
    var b bool 
    /**
     * b,_ = strconv.ParseBool(str) 函数返回两个值
     * 返回bool，err 不想获得err ,就用下划线_忽略
     */
    b,_ = strconv.ParseBool(str)
    fmt.Printf("类型：%T str=%v  \n",b,b)

    var salary string = "12000"
    var money int64 
    //返回的都是64，因此要用int64接收，如果要int 用int()转
    money,_ = strconv.ParseInt(salary,10,64)
    fmt.Printf("类型：%T str=%v  \n",money,money)

    var fee string = "5.1256"
    var service float64
    service,_ = strconv.ParseFloat(fee,64)
    fmt.Printf("类型：%T str=%v  \n",service,service)

    //string 转基本类型，确保是数值型字符串  若不是数值型字符串 ，转换失败，直接设置为零。
    var value string = "zhoushuai"
    var val int64
    val,_ = strconv.ParseInt(value,10,64)
    // val = 0 
    fmt.Printf("类型：%T str=%v  \n",val,val) 


}

main.go DAY10

// Go语言·常量
package main
import (
    "fmt"
)

var content string = `
————————————————Go语言·常量————————————————————
一、常量
    使用const修改
    常量在定义的时候，就必须初始化
    常量是不能修改
    常量只能修饰bool,数值类型(int float)、string类型
    const 常量名(identifier) [type] = value
二、注意事项：
    常量名，没有必须大写的规定
    首字母大写。小写，常量的访问范围
`

/*
const (
    a = iota
    b = iota
    c,d = iota,iota
)
 
0 1 2 2

*/


/*const (
    a = iota
    b = iota
    c = iota
    d = iota
)
0 1 2 3*/

const (
    a = iota
    b 
    c 
    d 
)
// 0 1 2 3

func main() {
    var num int
    // 常量在定义的时候，就必须初始化,给值
    const tax int = 12
    fmt.Println(num, tax)

    fmt.Println(a, b, c, d)
    euler()
    consts()
    enums()
}


func euler() {
    // 复数 欧拉公式
    fmt.Printf("%.2f\n",cmplx.Exp(1i*math.Pi)+1)
}

func consts(){
    const(
        filename  =  "abac.txt"
        a,b = 3,4
    )
    var c int
    c = int(math.Sqrt(a*a+b*b))
    fmt.Println(filename,c)
}


func enums() {
    const(
        cpp = iota
        java
        python
        php
        golang
    )
    fmt.Println(cpp,java,python,php,golang)
    const(
        B = 1 << (10*iota)
        KB
        MB
        GB
        TB
        PB
    )
    fmt.Println(B,KB,MB,GB,TB,PB)
}

0.Go语言·基本数据类型
基本数据类型 main.go DAY01 main.go DAY02 main.go DAY03 main.go ...
【OC梳理】基本数据类型和基本运算
Objective-C作为以C语言为基础的语言，其基本数据类型与C语言类似。 1.基本数据类型基本数据类型可以参...
【初识C语言】C语言基本数据类型
C语言基本数据类型简介 1.概述 C 语言包含的数据类型如下图所示： C语言中的基本数据类型有整形、字符型、浮点型...
技术问 - int 和 Integer有什么区别
Java语言提供两种不同的类型，即基本数据类型和引用数据类型，int是基本数据类型，Integer是Java语言为...
KDB数据库的专属语言——Q语言
前言 KDB有着自己独特的语言，那就是Q语言。首先先介绍Q语言的基本数据类型，Q语言的基本数据类型就是：Atoms...
三、JNI-基本类型、字符串和数组
基本类型字符串数组 #1. 基本类型 Java语言中数据类型分为基本数据类型和引用数据类型，其中基本数据类型分...
Java的八种基本数据类型
Java的八种基本数据类型基本数据类型 Java语言提供了八种基本类型。基本数据类型：数值型、字符型、布尔型。...
JS - 对象的操作办法
在JavaScript这门语言中，数据类型分为两大类：基本数据类型和复杂数据类型。基本数据类型包括Numb...
一：Java基础入门-数据类型
1：什么是数据类型？ Java语言分为基本数据类型、引用数据类型和自定义类型。基本数据类型共有8种。引用数据...
JavaScript复制对象
在JavaScript这门语言中，数据类型分为两大类：基本数据类型和复杂数据类型。基本数据类型包括Number、B...