golang1

一、变量

go声明变量一般形式使用var关键字：

var name type

声明变量将变量的类型放在变量的名称之后：

var a,b *int

go的基本类型：

　　bool,string,int,int8...uint...byte//uint8别名,rune//int32别名代表一个Unicode码,float32,float64,复数类型complex64,128

当一个变量被声明之后，系统自动赋予它该类型的零值，int为0，float为0.0，bool为false，string为空字符串，nil为指针。

所有的内存在go中都说经过初始化的。

命名规则驼峰，如numShips

标准格式：

　　var 变量名  变量类型

批量声明：

var (
    a int 
    b string
    c []float32
    // func 定义函数
    d func() bool
    // struct 自定义类型
    e struct {
        x int
    }
)

简短格式：

名字 ：=  表达式

　　1.定义变量

　　2.不能提供数据类型

　　3.只能用在函数内部

i,j := 0,1

变量初始化：

var hp int = 100  //var 变量名 类型 = 表达式   or     var hp = 100

net.Dial提供按指定协议和地址发起网络连接，该函数有两个返回值，一个是连接对象，一个说错误对象：

package main

import "net"

var conn net.Conn
var err error

func main() {
    conn, err = net.Dial("tcp", "127.0.0.1:8080")
}

多重赋值在go语言的错误处理和函数返回值中会大量使用：

// 将IntSlice声明为int类型
type IntSlice []int
// 为IntSlice类型编写一个len方法，提供切片长度
func (p IntSlice) Len() int           { return len(p) }
// 根据提供的i，j元素索引进行比较，返回比较结果
func (p IntSlice) Less(i, j int) bool { return p[i] < p[j] }
// 交换两个元素的值
func (p IntSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

匿名变量：下划线__

func GetData() (int, int) {
    return 100, 200
}
func main(){
    a, _ := GetData()
    _, b := GetData()
    fmt.Println(a, b)
}

一个变量，常量，类型或者函数在程序中都有一定的作用范围，称为作用域

　　函数内定义的称为局部变量

　　函数外定义的称为全局变量

　　函数中定义中的变量称为形式参数

//全局变量 a
var a int = 13

func main() {
    //局部变量 a 和 b
    var a int = 3
    var b int = 4

    fmt.Printf("main() 函数中 a = %d
", a)
    fmt.Printf("main() 函数中 b = %d
", b)
    c := sum(a, b)
    fmt.Printf("main() 函数中 c = %d
", c)
}
// 形式参数
func sum(a, b int) int {
    fmt.Printf("sum() 函数中 a = %d
", a)
    fmt.Printf("sum() 函数中 b = %d
", b)
    num := a + b
    return num
}

有符号整数类型int，无符号整数类型uint，uintptr

complex128(64位实数和虚数)和complex64(32位实数和虚数)

复数的值由三部分组成RE（实数部分）+IMI（虚数部分IM和虚数单位I），前两者都是float类型

声明复数语法格式：

var name complex128 = complex(x,y)
// name为复数的变量名，complex128为复数的类型，x，y分别代表该复数的两个float64类型的数值，x为实部，y为虚部
// 或者 ： name := complex(x,y)

使用real()获得该复数的实部x，使用imag()获得该复数的虚部y

正弦sin：

package main

import (
    "image"
    "image/color"
    "image/png"
    "log"
    "math"
    "os"
)

func main() {

    // 图片大小
    const size = 300
    // 根据给定大小创建灰度图
    pic := image.NewGray(image.Rect(0, 0, size, size))

    // 遍历每个像素
    for x := 0; x < size; x++ {
        for y := 0; y < size; y++ {
            // 填充为白色
            pic.SetGray(x, y, color.Gray{255})
        }
    }

    // 从0到最大像素生成x坐标
    for x := 0; x < size; x++ {

        // 让sin的值的范围在0~2Pi之间
        s := float64(x) * 2 * math.Pi / size

        // sin的幅度为一半的像素。向下偏移一半像素并翻转
        y := size/2 - math.Sin(s)*size/2

        // 用黑色绘制sin轨迹
        pic.SetGray(x, int(y), color.Gray{0})
    }

    // 创建文件
    file, err := os.Create("sin.png")

    if err != nil {
        log.Fatal(err)
    }
    // 使用png格式将数据写入文件
    png.Encode(file, pic) //将image信息写入文件中

    // 关闭文件
    file.Close()
}

    使用image包的NewGray()函数创建一个图片对象， 使用区域由image.Rect结构提供，image.Rect描述一个方形的两个定位点（x1,y1）和（x2,y2），image.Rect(0,0,size,size)表示使用完整灰度图，宽300，长300。

bool类型：(!true==false)==True

// 如果b为真，btoi返回1，如果为假，btoi返回0
func btoi(b bool) int {
    if b{
        return 1
    }
    return 0
}

字符串是一种值类型，不可变。

　　字符串的内容（纯字节）可以通过索引来获取，在[ ]内写入索引，索引从0开始

　　字符串str的第一个字节（纯字节）：str[0]

　　字符串拼接符使用“+”

　　strings.Index：正向搜索子字符串。

　　strings.LastIndex：反向搜索子字符串。

• 判断是否为字母：unicode.IsLetter(ch)
• 判断是否为数字：unicode.IsDigit(ch)
• 判断是否为空白符号：unicode.IsSpace(ch)

指针（pointer）在Go语言中可以被拆分为两个核心概念：

• 类型指针，允许对这个指针类型的数据进行修改，传递数据可以直接使用指针，而无须拷贝数据，类型指针不能进行偏移和运算。
• 切片，由指向起始元素的原始指针、元素数量和容量组成。

指针默认值为nil，指针变量通常缩写为ptr