Day2.数据类型-条件判断

一.数据类型和操作符

(一).布尔类型

1. 整数和浮点数类型  
2. 复数类型  
3. 位运算  
4. 布尔类型  
    - var b bool 
    - var b bool = true  
    - var b = true  
    - 操作符==和!=  
    - 取反操作符 !b  
    - &&和||操作符  
    - 格式化输出占位符:%t

(二).整数和浮点数类型

1. 整数 int8、int16、int32、int64
2. int8中的8是指bit位,1Byte = 8Bits  
3. Bit意为"位""比特",是计算机运算的基础,属于二进制的范畴。
4. Byte意为"字节",是计算机文件大小的基本计算单位。
    - uint8、uint16、uint32、unit64。
    - int and uint 和操作系统平台相关。
    - float32 and float64浮点类型。
    - 所有整数初始为0,所有浮点数初始化为0.0,所有布尔类型初始化为false。
    - Go是强类型语言,不同类型相加以及赋值是不允许的。
    - 不同类型相加可以先做类型转换再相加。
    - 输出占位符:整数:%d,%x十六进制,%f浮点数。
    - 万能输出占位符:%v
    - %v the value in a default format when printing structs, the plus flag (%+v) adds field names
    - %#v a Go-syntax representation of the value
    - %T a Go-syntax representation of the type of the value
    - %% a literal percent sign; consumes no value

(三).复数complex

complex分两种: 
(1). complex64,以float32分别表示复数的实部(real),虚部(imag)  
(2). complex128,则以float64分别表示  
(3). 三个函数:complex,real,imag

(四).位操作符

1.位操作

与操作:&
1 & 1 = 1 
1 & 0 = 0 
0 & 1 = 0 
0 & 0 = 0

或操作:|
1 | 1 = 1 
1 | 0 = 1 
0 | 1 = 1 
0 | 0 = 0

异或:^ 同0异1
1 ^ 1 = 0 
1 ^ 0 = 1 
0 ^ 1 = 1 
0 ^ 0 = 0

左移:<<
1 << 10 = 1024 
1 << 20 = 1M 
1 << 30 = 1G

右移:>>
1024 >>10 = 1 
1024 >>1 = 512 
1024 >>2 = 256

2. 十进制整数转换为二进制整数

采用"除2取余,逆序排列"法。  
具体做法是:用2整除十进制整数,可以得到一个商和余数;  
再用2去除商,又会得到一个商和余数,如此进行,直到商为小于1时为止,  
然后把先得到的余数作为二进制数的低位有效位,后得到的余数作为二进制数的高位有效位,依次排列起来。

3. 199的二进制为 1100 0111 转换方式如下图

十进制转二进制

4. 二进制转为十进制 要从右到左用二进制的每个数去乘以2的相应次方,小数点后则是从左往右。

二进制转十进制

5. 位操作符例子:微博用户特权与位操作

1.微博红名  
2.微博达人  
3.VIP会员  
4.VIP超级会员  
5.蓝钻用户  
6.红钻用户

6. 操作符

(1).逻辑操作符:==、!=、>=、<=、<
(2).算术操作符:+、-、*、/、%

二.常量类操作

(一).init function

package main

import "fmt"

// 支持main函数前自动执行
func init() {
    fmt.Println("init called!")
}

func main() {
    fmt.Println("main called")
}

(二).包只初始化,不引用。

mysql_driver.go

package mysql_driver

import "fmt"

func init() {
    fmt.Println("mysql driver is inited")
}

main.go

package main

// 包含起来 不使用里面的函数 只初始化。 执行顺序为先执行引入外部包的init函数,再执行main函数里面的init函数。
import (
    "fmt"
    _ "godev2/day2/mysql_driver"
)

func main() {
    fmt.Println("hello")
}

const

1.常量使用const修饰,代表永远只读,不能修改。
2.只能修饰boole/number(int、float、complex)和string类型。
3.const identifier [type] = value

const.go

package main

import "fmt"

const (
    a = iota
    b
    c = 1
    d = iota
    e
)

const (
    o = 1 << iota
    p
    q
    r
    s
    t
)

func main() {
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)
    fmt.Println(e)

    fmt.Println(o, p, q, r, s, t)

}

三.字符串

(一).字符串的两种表示方法:

1.字符串使用双引号""2.反引号引起来的字符串原样输出 ``

(二).单引号为字符类型rune

四.循环判断(部分比较基础的部分略)

(一).for循环

package main

import "fmt"

func main() {
    var a int = 0

    for i := 0; i < 10; i++ {
        fmt.Println(i)
    }

    for a < 10 {
        fmt.Println(a)
        a++
    }

    /*for {
        fmt.Println("无限循环")
    }*/

    /* for range 遍历数组 切片 map/channel */
    str := "Hello world"
    for index, value := range str {
        fmt.Printf("index[%d],value[%c]\n", index, value)
    }
}

(二)break、continue用法

main.go

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        // i > 5 终止循环
        if i > 5 {
            break
        }
        fmt.Println(i)
    }
}

main.go

package main

import "fmt"

func main() {
    for {
        for i := 0; i < 10; i++ {
            // 忽略本次循环 继续下一轮
            if i > 5 {
                continue
            }
            fmt.Println(i)
        }
    }
}

五.字符串常用操作

1. 长度 len(str)
2. 拼接 +, fmt.Sprintf
3. 分割 strings.Split
4. 包含 strings.Contains
5. 前缀或后缀判断 strings.HasPrefix,strings.HasSuffix
6. 子串出现的位置 strings.Index(),strings.LastIndex()
7. join操作 strings.Join(a[]string,sep string)
package main

import (
    "fmt"
    "strings"
)

func strOperator() {
    str := "hello\t"
    str2 := str + "world"
    fmt.Printf("str2:%s\n", str2)

    // sep string 分隔符
    str3 := "what's|your|name?"
    fmt.Println(strings.Split(str3, "|"))

    isContain := strings.Contains(str3, "name1")
    if isContain {
        fmt.Printf("%t\n", isContain)
    } else {
        fmt.Printf("%t\n", isContain)
    }

    str4 := "baidu.com"
    ret := strings.HasPrefix(str4, "http")
    if ret {
        fmt.Printf("str4 is %s", str4)
    } else {
        str4 = "http://" + str4
        fmt.Printf("str4: %s\n", str4)
    }

    str5 := "http://zhangluya"
    ret = strings.HasSuffix(str5, ".com")
    if ret == true {
        fmt.Printf("str5 is %s", str5)
    } else {
        str5 := str5 + ".com"
        fmt.Printf("str5 is %s\n", str5)
    }

    str6 := "How to design your global database architecture?"
    fmt.Printf("first index: %d\n", strings.Index(str6, "o"))
    fmt.Printf("last index:%d\n", strings.LastIndex(str6, "l"))

    str7 := []string{"h", "e", "l", "l", "o"}
    fmt.Printf(strings.Join(str7, ""))

}
func main() {
    strOperator()
}

六.课后练习作业

(1).判断101-200之间有多少素数,并输出所有素数。

(2).求100-999中所有的水仙花数。

(3).对于一个数n,求n的阶乘之和,即1!+2!+3!+...n!

main.go

package main

import "fmt"

func primeNumber(n int) bool {
    if n <= 1 {
        return false
    }
    for i := 2; i < n; i++ {
        if n%i == 0 {
            return false
            break
        }
    }
    return true
}

func isNarcissus(n int) bool {
    if n < 100 || n > 999 {
        return false
    }

    var (
        x int //百位数
        y int //十位数
        z int //个位数
    )

    x = n / 100
    y = (n % 100) / 10
    z = n % 10

    cubeSum := x*x*x + y*y*y + z*z*z

    if cubeSum == n {
        return true
    }
    return false
    //fmt.Println(x, y, z)

}

func factorial(n int) int {
    if n <= 0 {
        return -1
    }

    var count int = 1
    for i := 2; i <= n; i++ {
        count = count * i
    }
    return count
}

func main() {

    // primeNumber
    for i := 101; i <= 200; i++ {
        if primeNumber(i) == true {
            fmt.Printf("%d is primeNumber\n", i)
        }
    }

    //Narcissus
    for i := 100; i <= 999; i++ {
        if isNarcissus(i) == true {
            fmt.Printf("%d\n", i)
        }
    }

    //Factorial

    var sum int = 0
    var n int = 10
    //fmt.Println(factorial(2))

    for i := 1; i <= n; i++ {
        result := factorial(i)
        sum = sum + result
    }
    fmt.Println(sum)
}
Copyright © zhangluya.com 2019            UPDATE 2020-03-26 15:42:33

results matching ""

    No results matching ""