golang基础(1)

命名

几个坑

1.导入的包必须用到

2.申明的变量也必须用

3.申明的常量倒是可以不用

和Python很像的地方

//多变量申明
var a, b, c int

//多变量赋值
var a, b, c = 1, 2, 3

//变量交换
a, b = b, a

//[]访问符
medals := []string{"gold", "silver", "bronze"}
//或者一个一个
var medals [3]string
medals[0] = "gold"

//字符串
s := "hello, world"
fmt.Println(len(s))// "12"
fmt.Println(s[0], s[7]) // "104 119" ('h' and 'w')
fmt.Println(s[:5]) // "hello"
fmt.Println(s[7:]) // "world"
fmt.Println(s[:])  // "hello, world"

和C很像的地方

//定义类型
//type TypeName goType
//Typename(T) 表示类型转换，只有当两个类型的底层基础类型相同才能转换
type Password string
type Celsius float64
var c Celsius
println(c == 0)
println(c == Celsius(0))


//指针的概念
    x := 1
    p := &x
    fmt.Println(*p)      //1
    *p = 2
    fmt.Println(p)       //0xc42001c098
    fmt.Println(x)       //2
    fmt.Println(*p == x) //true


//命令行参数
//-n : 忽略行尾的换行符;
//-s : 指定分隔符
//-help : 查看参数
//./main -s , q w e r   =>   q,w,e,r
var n = flag.Bool("n", false, "omit trailing newline")
var sep = flag.String("s", " ", "separator")

func main(){
    flag.Parse()
    fmt.Print(strings.Join(flag.Args(), *sep))
    if !*n {
        fmt.Println()
    }
}

golang的内置函数

//func new(Type) *Type
//返回一个对应类型的指针
p := new(int)

垃圾回收

var global *int

func f() {
    var x int
    x = 1
    global = &x
    //这个变量虽然是局部变量，但是它的指针逃逸出了作用域
    //所以这个变量会在堆上分配
}

func g() {
    y := new(int)
    *y = 1
    //这个变量没有逃逸出去，也可以在栈上分配
}

循环

golang只有for循环，而没有了while

func gcd(x, y int) int {
    for y != 0 {
        x, y = y, x%y
    }
    return x
}

func fib(n int) int {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        x, y = y, x+y
    }
    return x
}

//range关键字可以简化很多
func main() {
    var str = []string{"1", "2", "3"}
    for s := range str{
        println(s)
    }
}

面向对象？

type Celsius float64
//表示类型能调用的方法，在方法名前面加(t T)
func (c Celsius) String() string {
    return fmt.Sprintf("%g。C", c)
}

func main() {
    var c = Celsius(100)
    println(c.String())
}

golang包

可以使用init初始化函数来简化初始化工作

该函数不能被调用或引用

var pc [5]byte

func init() {
    for i := range pc {
        pc[i] = pc[i/2] + byte(i&1)
    }
}

func main() {
    for s, i := range pc{
        print(s)//s是索引
        print("->")
        print(i)//i是对应的值
        print("\n")
    }
}

/*
0->0
1->1
2->1
3->2
4->1
*/

//另一种方法，使用匿名函数
var pc [256]byte = func() (pc [256]byte) {
    for i := range pc {
        pc[i] = pc[i/2] + byte(i&1)
    }
    return
}()

UTF8

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "Hello, 世界"
    fmt.Println(len(s))
    fmt.Println(utf8.RuneCountInString(s))

    for i, r := range "Hello, 世界" {
        fmt.Printf("%d\t%q\t%d\n", i, r, r)
    }
}

字节类型

strings包

• func Contains(s, substr string) bool
• func Count(s, sep string) int
• func Fields(s string) []string
• func HasPrefix(s, prefix string) bool
• func Index(s, sep string) int
• func Join(a []string, sep string) string

bytes包

• func Contains(b, subslice []byte) bool
• func Count(s, sep []byte) int
• func Fields(s []byte) [][]byte
• func HasPrefix(s, prefix []byte) bool
• func Index(s, sep []byte) int
• func Join(s [][]byte, sep []byte) []byte

func main() {
    s := "abc"
    b := []byte(s)
    s2 := string(b)
    println(s2)
}

func intsToString(values []int) string {
    var buf bytes.Buffer
    buf.WriteByte('[')
    for i, v := range values {
        if i > 0 {
            buf.WriteString(", ")
        }
        fmt.Fprintf(&buf, "%d", v)
    }
    buf.WriteByte(']')
    return buf.String()
}
func main() {
    fmt.Println(intsToString([]int{1, 2, 3})) // "[1, 2, 3]"
}

字符串格式化

# 定义示例类型和变量
type Human struct {
    Name string
}

var people = Human{Name:"zhangsan"}


普通占位符
占位符     说明                           举例                   输出
%v      相应值的默认格式。            Printf("%v", people)   {zhangsan}，
%+v     打印结构体时，会添加字段名     Printf("%+v", people)  {Name:zhangsan}
%#v     相应值的Go语法表示            Printf("#v", people)   main.Human{Name:"zhangsan"}
%T      相应值的类型的Go语法表示       Printf("%T", people)   main.Human
%%      字面上的百分号，并非值的占位符  Printf("%%")            %


布尔占位符
占位符       说明                举例                     输出
%t          true 或 false。     Printf("%t", true)       true

整数占位符
占位符     说明                                  举例                       输出
%b      二进制表示                             Printf("%b", 5)             101
%c      相应Unicode码点所表示的字符              Printf("%c", 0x4E2D)        中
%d      十进制表示                             Printf("%d", 0x12)          18
%o      八进制表示                             Printf("%d", 10)            12
%q      单引号围绕的字符字面值，由Go语法安全地转义 Printf("%q", 0x4E2D)        '中'
%x      十六进制表示，字母形式为小写 a-f         Printf("%x", 13)             d
%X      十六进制表示，字母形式为大写 A-F         Printf("%x", 13)             D
%U      Unicode格式：U+1234，等同于 "U+%04X"   Printf("%U", 0x4E2D)         U+4E2D



浮点数和复数的组成部分（实部和虚部）
占位符     说明                              举例            输出
%b      无小数部分的，指数为二的幂的科学计数法，
        与 strconv.FormatFloat 的 'b' 转换格式一致。例如 -123456p-78
%e      科学计数法，例如 -1234.456e+78        Printf("%e", 10.2)     1.020000e+01
%E      科学计数法，例如 -1234.456E+78        Printf("%e", 10.2)     1.020000E+01
%f      有小数点而无指数，例如 123.456        Printf("%f", 10.2)     10.200000
%g      根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出 Printf("%g", 10.20)   10.2
%G      根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出 Printf("%G", 10.20+2i) (10.2+2i)


字符串与字节切片
占位符     说明                              举例                           输出
%s      输出字符串表示（string类型或[]byte)   Printf("%s", []byte("Go语言"))  Go语言
%q      双引号围绕的字符串，由Go语法安全地转义  Printf("%q", "Go语言")         "Go语言"
%x      十六进制，小写字母，每字节两个字符      Printf("%x", "golang")         676f6c616e67
%X      十六进制，大写字母，每字节两个字符      Printf("%X", "golang")         676F6C616E67


指针
占位符         说明                      举例                             输出
%p      十六进制表示，前缀 0x          Printf("%p", &people)             0x4f57f0


其它标记
占位符      说明                             举例          输出
+      总打印数值的正负号；对于%q（%+q）保证只输出ASCII编码的字符。 
                                           Printf("%+q", "中文")  "\u4e2d\u6587"
-      在右侧而非左侧填充空格（左对齐该区域）
#      备用格式：为八进制添加前导 0（%#o）      Printf("%#U", '中')      U+4E2D
       为十六进制添加前导 0x（%#x）或 0X（%#X），为 %p（%#p）去掉前导 0x；
       如果可能的话，%q（%#q）会打印原始 （即反引号围绕的）字符串；
       如果是可打印字符，%U（%#U）会写出该字符的
       Unicode 编码形式（如字符 x 会被打印成 U+0078 'x'）。
' '    (空格)为数值中省略的正负号留出空白（% d）；
       以十六进制（% x, % X）打印字符串或切片时，在字节之间用空格隔开
0      填充前导的0而非空格；对于数字，这会将填充移到正负号之后