go 数据变量和操作符

数据类型

布尔类型

a. var b bool 和 var b bool = true 和 var b = false
b. 操作符 == 和 !=
c. 取反操作符： !b
d. && 和 || 操作符
e. 格式化输出占位符: %t

package main

import "fmt"

func boolTest(){
    var a bool = true

    var b bool  //bool类型不给定值 默认false

    fmt.Println(a,b)

    // == 和 !=
    fmt.Println(a == true, b== false, a != true)

    // 取反 ！

    fmt.Printf("a取反 %t", !a)

    /*
    &&(都相同是才为true)
    || (有一个为true则结果就为true)
   */

   if a == true && b == true{
       fmt.Println("right")
   }else{
    fmt.Println("no right")
   }

   if a == true && b == true{
        fmt.Println("right")
   }else{
        fmt.Println("no right")
    }

    // 格式化输出 用Printf  %t

    fmt.Printf("a的值为:%t", a)

    /*
        true false
        true true false
        a取反 falseno right
        no right
        a的值为:true
    */

}

func main(){
    boolTest()
}

整数和浮点型

a. int8、int16、int32、int64
b. uint8、uint16、uint32、uint64
c. int 和 uint，和操作系统平台相关
d. float32 和 float64浮点类型
e. 所有整数 初始化为0，所有浮点数初始化为0.0，布尔类型初始化为false

package main

import "fmt"

func boolTest(){
    var a bool = true

    var b bool  //bool类型不给定值 默认false

    fmt.Println(a,b)

    // == 和 !=
    fmt.Println(a == true, b== false, a != true)

    // 取反 ！

    fmt.Printf("a取反 %t", !a)

    /*
    &&(都相同是才为true)
    || (有一个为true则结果就为true)
   */

   if a == true && b == true{
       fmt.Println("right")
   }else{
    fmt.Println("no right")
   }

   if a == true && b == true{
        fmt.Println("right")
   }else{
        fmt.Println("no right")
    }

    // 格式化输出 用Printf  %t

    fmt.Printf("a的值为:%t", a)

    /*
        true false
        true true false
        a取反 falseno right
        no right
        a的值为:true
    */

}

func intTest(){
    var a1 int8 =    // -127-128
    var a2 int =
    fmt.Println(a1,a2)

    var a3 int
    // a3 =a1  不同的数据类型不能赋值  这样写 不对 应该 把 a1转为int类型
    a3 = int(a1)
    fmt.Println(a3)

    var a4 uint8 =  // 无符号  0-128
    fmt.Println(a4)

    /*
        124 885555555
        124
        100
    */
}

func floatTest(){
    var i float32
    var j float64 = 258.336
    var n float64
    fmt.Println(i,j,n)
}

func main(){
    //boolTest()
    // intTest()
    floatTest()
    /*
        0 258.336 0
    */
}

a. Go是强类型语言，不同类型相加以及赋值是不允许的
b. 那怎么样才能实现，不同类型相加呢？  强转
c. 输出占位符：整数%d，%x十六进制，%f浮点数

字符串类型

a. var str string
b. var str string = “hello world”
c. 字符串输出占位符%s
d. 万能输出占位符: %v

字符串的两种 表示方法

a. 双引号， “”，可以包含控制字符
b. 反引号 ``所有字符都是原样输出

package main
import “fmt”
func main() {
 var str = “hello world\n\n”
 var str2 = `hello \n \n \n`
fmt.Println(“str=“, str)
fmt.Println(“str2=“, str2)
} 

字符串常用操作

a. 长度：len(str)
b. 拼接：+，fmt.Sprintf
c. 分割：strings.Split
d. 包含： strings.Contains
e. 前缀或后缀判断：strings.HasPrefix, strings.HasSuffix
f. 字符串出现的位置: strings.Index(), strings.LastIndex()
g. join操作： strings.Join(a[]string, sep string)

package main

import (
    "fmt"
    "strings"
)

func jbyf() {
    var a string = "hello"
    var b = "world"

    c := "hello world "

    fmt.Println(a, b, c)

    var d = "an\nc" // 有特殊字符 则转义

    fmt.Println(d)

    d = `an\nc` // 原样输出

    fmt.Println(d)
}

func commonMethod() {
    aa := "lol is bad, but i like play lol"
    // 长度
    aLen := len(aa)
    fmt.Printf("aa的长度:%d\n", aLen) //aa的长度:31

    // 字符串拼接

    aaStr := "hello" + "world"
    fmt.Println(aaStr)                              // helloworld
    bbStr := fmt.Sprintf("%s-%s", "hello", "china") // hello-china
    fmt.Println(bbStr)

    // 字符串分割

    cc := "i-n-j"

    dd := strings.Split(cc, "-")
    fmt.Println(dd)    // [i n j]
    fmt.Println(dd[]) // n

    // 包含

    if strings.Contains(aa, "lol") {
        fmt.Println("aa is contains lol")
    } else {
        fmt.Println("aa is not contains lol")
    }

    // 前缀和后缀判断

    if strings.HasPrefix(aa, "lol") {
        fmt.Println("aa is start lol")
    } else {
        fmt.Println("aa is not start lol")
    }

    if strings.HasSuffix(aa, "lol") {
        fmt.Println("aa is end lol")
    } else {
        fmt.Println("aa is not end lol")
    }

    // 自字符串出现的位置

    fmt.Println(strings.Index(aa, "lol"))
    fmt.Println(strings.LastIndex(aa, "lol"))

    // Join 操作
    var strArr [] string = [] string{"aa", "bb", "cc"}
    fmt.Println(strings.Join(strArr, "*"))
}

func main() {
    // jbyf()
    commonMethod()
}

操作符

a. 逻辑操作符， == 、 != 、<、<=、>=
b. 算数操作符， +、-、* 、 /

go的基本结构

package main

import "fmt"

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

. 任何一个代码文件隶属于⼀个包
. import 关键字，引用其他包：
import(“fmt”)
import(“os”)
通常习惯写成：
import (
 “fmt”
 “os”
)

3. 开发可执行程序，package main，
并且有且只有一个main入口函数
4. 包中函数调用：
a. 同一个包中函数，直接用函数名调用
b. 不同包中函数，通过包名+点+ 函数名  进行 调用
5. 包访问控制规则：
a. 大写意味着这个函数/变量是可导出的
b. 小写意味着这个函数/变量是私有的，
包外部不能访问

字符串原理解析

1. 字符串底层就是一个byte数组，所以可以和[]byte类型互相转换
2. 字符串中的字符是不能修改的，那怎么修改呢
3. 字符串是由byte字节组成，所以字符串的长度是byte字节的长度
4. rune类型用来表示utf8字符，一个rune字符由1个或多个byte组成

package main

import "fmt"

func main() {
    var aa = "hello 世界"

    fmt.Printf("aa[0]=%c  len(aa)=%d\n", aa[], len(aa)) // aa[0]=h  len(aa)=12  字节的长度 一个中文占3个字节

    for index, str := range aa {
        fmt.Printf("aa[%d]=%c\n", index, str)
    }
    /*
        aa[0]=h
        aa[1]=e
        aa[2]=l
        aa[3]=l
        aa[4]=o
        aa[5]=
        aa[6]=世
        aa[9]=界
    */

    // 修改字符串

    var bb []byte
    bb = []byte(aa)
    fmt.Println(bb) // [104 101 108 108 111 32 228 184 150 231 149 140]

    bb[] = 'H'
    aa = string(bb)
    fmt.Println(aa)                   // Hello 世界
    fmt.Printf("aa的长度:%d\n", len(aa)) //

    var cc []rune

    cc = []rune(aa)
    fmt.Println(cc)                 // fmt.Printf("aa的长度:%d", len(aa))

      fmt.Printf("cc的长度:%d\n", len(cc)) // 8

      fmt.Printf("aa的长度:%d\n", len(aa)) // 12

    　fmt.Printf("aa[7] = %c\n", aa[7]) // aa[7] = ¸

    　fmt.Printf("cc[7] = %c\n", cc[7]) // cc[7] = 界

}

字符串练习

练习1：写一个程序，对英问字符串进行逆序。
练习2：写一个程序，对包含中文的字符串进行逆序。
练习3：写一个程序，判断一个字符串是否是回文

package main

import "fmt"

// 写一个程序，对英问字符串进行逆序。
func ewreverse() string {
    var aa = "hello world"
    var bb []byte
    bb = []byte(aa)
    for i := ; i < len(aa)/; i++ {
        tem := bb[len(aa)-i-]
        bb[len(bb)-i-] = bb[i]
        bb[i] = tem
    }

    aa = string(bb)
    return aa
}

// 写一个程序，对包含中问的字符串进行逆序。

func zwreverse() string {
    var aa = "hello 世界"
    var bb []rune
    bb = []rune(aa)

    for i := ; i < len(bb)/; i++ {
        tem := bb[len(bb)-i-]
        bb[len(bb)-i-] = bb[i]
        bb[i] = tem
    }

    aa = string(bb)
    return aa
}

//写一个程序，判断一个字符串是否是回文  (正序和倒序一样)
func testHuiwen() bool {
    var aa = "上海自来水来自海上"
    var bb []rune
    bb = []rune(aa)

    for i := ; i < len(bb)/; i++ {
        tem := bb[len(bb)-i-]
        bb[len(bb)-i-] = bb[i]
        bb[i] = tem
    }

    cc := string(bb)
    return cc == aa

}

func main() {
    // aa := ewreverse()
    // aa := zwreverse()
    aa := testHuiwen()
    fmt.Printf("aa=%t", aa)

}