学习golang注意点：

导的包必须使用；或者使用_未使用的包，作用是调用该包下的初始化方法。

局部变量声明必须使用。

go语言的包和java的相似，包名.变量访问

1. 初识go语言

1.1 Hello World

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

1.2 go 数据类型

布尔:

var a bool = true
var b bool = false

整型:

整型分为有符号和无符号的类型

8, 16 ,32 分别代表位数

int : 根据系统决定是32位还64位

int8 ： 1个字节，-128~127 相当于java中的short；

int16 ： 2个字节，-2¹⁵ ~ 2¹⁵ -1

int32 : 4个字节 -2³¹ ~2³¹ - 1

int64： 8个字节-2⁶³ ~2⁶³ - 1

uint : .....

无符号整形都是取值0~2¹⁶ - 1

var a int = -3
var b uint = 3 //uint类型不可以为负数

浮点型：

var a float32 = 100.0
var b float64 = 100.00 //默认

字符类型

golang中的字符使用的是字节保存的，本质就是一个int32类型

var a byte = 'a'
var b byte = 'c'
fmt.Print(a, "===", b)  //输出的是该字节对应的字节码： 97===99
fmt.Printf("%c === %c", a, b) // a === c

字符串型：

var str string = "hello world"
//多行字符串，不需要使用+来连接多行
var str2 string = `a
		asda asdasdadsadasd `

复数类型：

complex64 是两个float32组成 complex128两个float64组成

var a complex64 = 10 + 3i
var b complex128= 10 + 3i //默认

1.3 变量常量

局部变量：

属于函数或者方法；声明之后必须使用

var a = 3;
var b int = 3;
c := 3

全局变量

b := 10 这种全局变量声明是错误的

全局变量的概念：隶属于包,声明之后可以不使用

var a int
var (
	c int
	d string
)
var e = 3

常量

局部

const a = 3

全局

const a int = 10
const b  = 20
const (
	d int = 10
	e string = "ss"
	f = 30
)

1.5 字符串相关操作

golang中string底层是通过byte数组实现的，byte使用utf-8编码标识的Unicode文本,每个汉字占3个字节

求长度

func strDemo() {
    fmt.Println(len("hello")) //5
    fmt.Println(len("中")) //3
    fmt.Println(len([]rune("中"))) //1， 正确获取中文字符串长度
}

字符串遍历

//对中文无法支持
func strEach() {
	str := "hello world"
	for i := 0; i < len(str); i ++ {
		//fmt.Print(str[i] ,"\t") // 104	101	108	108	111	32	119	111	114	108	100
		//讲字节编码转为字符串输出
		fmt.Printf("%c\t", str[i]) //h	e	l	l	o	 	w	o	r	l	d
	}
}

func strEach() {
	str := "hello world 中国"
	for i, s := range str {
         //0	h1	e2	l3	l4	o5	 6	w7	o8	r9	l10	d11	 12	中15	国
        fmt.Print(i, "\t", string(s))
	}
}
//这个可以正确的输出索引
func strEachRune() {
	str := "中国人民"
	for i, s := range []rune(str) {
		fmt.Println(i, string(s))
	}
}

其他操作

str := "中国人民, hello world"
index := strings.Index(str, "国") //存在则 index > -1, 否则 == -1   此时index=-3
split := strings.Split(str, ",")
replace := strings.Replace(str, "o", "2", 1) //第三个参数标识替换几个，小于0，则替换所有
result := strings.EqualFold("中国", "中国2") //不区分大小写
fmt.Println("中国" == "中国H") //区分大小写， 同strings.Compare()5

1.6 相互转换

1.6.1 基本数据

golang基本数据数据之间的转换可使用公：T(i) 进行相互转换

//数据之间的相互转换
func transfer() {
	//
	var i int = 10
	var j float64 = 11.30
	x := float64(i)
	y := int(j)
	fmt.Print(x, "\t", y) //10	11
}

1.6.2 string <=> 基本数据类型

基本类型=>string

fmt.Sprintf(format string, param interface{})

func stringTrans() {
	var i int = 10
	var flag bool = true
	int_str := fmt.Sprintf("%d", i)
	bool_str := fmt.Sprintf("%t", flag)
	fmt.Println(int_str)
	fmt.Println(bool_str)
}

strconv

func stringStrco() {
	var i int = 10000
	var flag bool = true
	var price float64 = 130.32
	formatInt := strconv.FormatInt(int64(i), 10) //等价： strconv.Itoa(i)
	formatBool := strconv.FormatBool(flag)
	formatFloat := strconv.FormatFloat(price, 'f', 10, 64)
	fmt.Println(formatInt)
	fmt.Println(formatBool)
	fmt.Println(formatFloat)
}

String=>基本数据类型

func strToBase() {
	str_flag := "true"
	str_age := "20"
	str_price := "20.33"
	flag, _ := strconv.ParseBool(str_flag)
	age, _ := strconv.ParseInt(str_age, 10, 64)
	age_int, _ := strconv.Atoi(str_age)
	price, _ := strconv.ParseFloat(str_price, 64)
	fmt.Println(flag)
	fmt.Println(age)
	fmt.Println(price)
	fmt.Println(age_int)
}

1.6.3 字节数组和字符串

func byteAndStr() {
	str := "hello world, 中国"
	data := []byte(str)
	s := string(data)
	fmt.Println(s)
	fmt.Println(data)
}

1.7 时间

获取时间

func timeOperate() {
	cur := time.Now()
	curT := time.Now().Unix() //获取时间戳
	fmt.Println(cur) //2019-01-30 20:40:16.410689 +0800 CST m=+0.000353772
	fmt.Println(curT) //1548852137
}

时间和字符串转换

func formatTime() {
	format := time.Now().Format("2006-01-02 15:04:05")
	//时间戳转时间
	var timestamp int64 = 1548852137
	unix := time.Unix(timestamp, 0).Format("2006-01-02 15:04:05")
	//字符串转时间
	formatTimeStr := "2017-04-11 13:33:37"
	strToTime, _ := time.Parse("2006-01-02 15:04:05", formatTimeStr)
	fmt.Println(format) //2019-01-30 21:00:53
	fmt.Println(unix)
	fmt.Println(strToTime) //2017-04-11 13:33:37 +0000 UTC
}

1.8 复合数据类型

数组和切片（slice）之间的区别：

数组：声明的时候必须指定长度var arr [10]int，值类型,但是在java里面数组是引用类型

Slice: 长度可变,不需要指定长度，引用类型

1. 数组

//数组的声明
func createArray() {
	var books [3]string
	books[0] = "java"
	books[1] = "python"
	books[2] = "golang"
	names := [3]string{"lisi", "zhansan", "hand"}
	scores := [...]int{89, 59, 30, 100} //根据后面的内容决定长度
	fmt.Println(books)
	fmt.Println(names)
	fmt.Println(scores)
}
//数组的相关操作
func operateArray() {
	//数组长度
	scores := [...]int{89, 59, 30, 100}
	fmt.Println(len(scores))
	//数组遍历
	for i := 0; i < len(scores); i++ {
		fmt.Print(scores[i], "\t")
	}
	fmt.Println()
	for index, value := range scores {
		fmt.Print(index, "==", value, "\t")
	}
}

2. slice

slice是一个比较复杂的数据结构，也就相当于Java里面集合的概念，是一个可变长的数据

//最简单的一种声明方式
func createSlice() {
	var args []int
	args = make([]int, 10)
	args[0] = 1
	args[1] = 2
	args[2] = 3
	args[3] = 4
	args[4] = 5
	for index, value := range args {
		fmt.Println(index, value)
	}
}

通过数组定义一个切片

len 切片长度, 表示当前切片元素的个数

cap切片容量，表示切片可以容纳切片的个数，如果超出则报错

func createSlice2() {
	arrays := [...]int{1, 2, 3, 4, 5}
	slice := arrays[1:4] //[2 3 4]
	fmt.Println(len(slice)) //3
	fmt.Println(cap(slice)) //4
	slice[1] = 10
    //这里可以解释下图
	fmt.Println(arrays) //[1 2 10 4 5]
	fmt.Println(slice) // [2 10 4]
}

这里容量为什么是4？，如图

append&copy函数

当append超出原来容量的时候，会扩展原来的容量为原先的两倍

//append
func appendFunc() {
	slice := make([]int, 2, 4)
	slice[0] = 1
	slice[1] = 1
	slice = append(slice, 2)
	slice = append(slice, 3)
	slice = append(slice, 4)
	fmt.Println(len(slice)) //5
	fmt.Println(cap(slice)) //8
}
//copy函数的用法
func copyFunc() {
	slice := make([]int, 2, 4)
	slice2 := make([]int, 2, 4)
	slice[0] = 1
	slice[1] = 1
    copy(slice2, slice) //相当于 slice2 := slice[:]
	fmt.Println(slice2) // [1 1]
}

3. map

map 数据结构和java的HashMap类似。

//创建一个map
func createMap() {
	var product map[string]interface{} //声明
	product = make(map[string]interface{}) //初始化
	product["id"] = 1
	product["title"] = "口红"
	product["price"] = 199.33
	fmt.Println(product)
}
//遍历map
func mapForEach() {
	var product map[string]interface{} //声明
	product = make(map[string]interface{}) //初始化
	product["id"] = 1
	product["title"] = "口红"
	product["price"] = 199.33
	for key, value := range product {
		fmt.Println(key, value)
	}
}

1.9 golang面向对象

1. 结构体

go语言中的结构体和Java中的类很相似，包含属性，方法等内容。首字母大写对其他包可见，首字母小写只是对本包可见。

指针和值类型：指针类型的方法可以修改属性的值，值类型的不可以修改，

package main
import "fmt"
func main() {
	student := &Student{"zhansn", 24}
	fmt.Println(student.GetName())//zhansn
	student.SetName("lisi")
	fmt.Println(student.GetName()) //lisi
}
//对属性小写可以封装
type Student struct {
	name string
	age int
}
//定义结构体的方法GetName和SetName
func (this Student) GetName() string {
	return this.name
}
//这里使用指针可以改变属性的内容
func (this *Student) SetName(name string) {
	this.name = name
}

2. 继承

在go语言中结构体和结构体没有继承，而是通过组合的方式来获取其他结构体的方法。此时的Student可以使用Person的所有属性和方法，无论是否封装。

package main
import "fmt"
func main() {
	student := &Student{}
	fmt.Println(student.GetName()) // ""
	student.SetName("lisi")
	fmt.Println(student.GetName()) //lisi
}
//对属性小写可以封装
type Student struct {
	Person
}
type Person struct {
	name string
	age int
}
//定义类型的方法
func (this Person) GetName() string {
	return this.name
}
//这里使用指针可以改变属性的内容
func (this *Person) SetName(name string) {
	this.name = name
}

3. 接口

golang接口中没有变量，只有方法。

对于java中的多态描述：重载和重写两种多态。但是在golang中无法对方法进行重载，因为golang是一门面向函数编程的语言。所以golang可以通过重写来实现多态,而且是接口和子类之间的重写。

package main
import "fmt"
func main() {
	ben := &Ben{"benchi"}
	ao := &Ao{"aodi"}
	ToString(ben)
	ToString(ao)
}
type Car interface {
	GetName() string
	SetName(name string)
}
func ToString(car Car) {
	fmt.Println(car.GetName())
}
type Ben struct {
	name string
}
func (ben Ben) GetName() string {
	return ben.name
}
func (ben *Ben) SetName(name string) {
	ben.name = name
}
type Ao struct {
	name string
}
func (this Ao) GetName() string {
	return this.name
}
func (this *Ao) SetName(name string) {
	this.name = name
}

4. 类型断言

golang 类型断言和java中的instanceof 关键字相似，但是又比这个关键字高级，好用,实现方式val.(T)

func main() {
	var x interface{}
	x = 4
	if y, ok := x.(int); ok {
		fmt.Println(y)
	}
}

断言接口子类

package main
import "fmt"
func main() {
	ben := Ben{"benchi"}
	ao := Ao{"aodi"}
	ToString(ben)
	ToString(ao)
}
type Car interface {
	GetName() string
}
func ToString(car Car) {
	if ben, ok := car.(Ben); ok {
		fmt.Println(ben.GetName())
	} else if ao, ok := car.(Ao); ok {
		fmt.Println(ao.GetName())
	} else {
		fmt.Println("other type")
	}
}
type Ben struct {
	name string
}
func (ben Ben) GetName() string {
	return ben.name
}
type Ao struct {
	name string
}
func (this Ao) GetName() string {
	return this.name
}

如下代码，有什么问题呢？此时我们使用指针类型是实现了接口notify的方法，那么在SendNotify(u notify)中我们必须使用子类的指针作为参数传递到该函数，如果我们使用值类型实现接口notify的方法，例如func (this user) Notify()这样既可以使用指针也可以使用值传递参数。

package main
import "fmt"
func main() {
	u := &user{"hello"} //此时必须传递指针参数
	SendNotify(u)
}
type notify interface {
	Notify()
}
type user struct {
	name string
}
//指针实现接口
func (this *user) Notify() {
	fmt.Println(this.name)
}
func SendNotify(u notify) {
	u.Notify()
}

这是为什么呢？

对于一个方法method(param T) 可以接受值类型和指针类型的参数，method(param *T) 仅仅可以接受指针类型的参数。

5. 闭包

java中有函数式编程，集合框架中有一个消费型函数forEach,我们在golang中通过闭包实现该函数

package main
import "fmt"
func main() {
	data := []int{1,2,3,4,5}
	forEach(data, func(index int, value interface{}) {
		fmt.Println(index, value)
	})
}
func forEach(data []int, f func(int, interface{})) {
	for index, value := range data {
		f(index, value)
	}
}

2. golang 杂项

2.0 defer

defer会在函数或者方法结束前被调用,和Java中finally相似

func main() {
	/**
	first
	hello world
	defer is called
	 */
	say()
}
func say() {
	fmt.Println("first")
	defer fmt.Println("defer is called")
	fmt.Println("hello world")
}
//由于return了，所以return后面的语句不会被执行
func say2() {
	fmt.Println("first")
    return
	defer fmt.Println("defer is called")
	fmt.Println("hello world")
}

defer使用场景：错误处理，关闭资源，释放锁，后续会见到这些使用操作

2.1 错误处理

这里诉说的错误处理和Java中的异常处理一样，在java语言中错误处理一般都是try...catch…finally,而在golang语言中通过三个关键字对错误尽心处理：(defer recover) panic

defer+recover来捕获异常

func catchError() {
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println("出现异常", err)
		}
	}()
	a := 10
	b := 0
	x := a / b
	fmt.Println(x)
}

自定义异常

func catchError() {
	//在这里捕获处理，如果不进行捕获，则程序会崩溃
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println("出现异常", err)
		}
	}()
	err := selfError()
	//向外抛出异常
	panic(err)
}
func selfError() error {
	return errors.New("自定义异常")
}

2.2 日志

package main
import "log"
func main() {
    //  info:2019/02/04 16:47:25 LoggerDemo.go:6: message
	log.Println("message")
}
func init() {
	log.SetPrefix("info:")
	log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
}

func main() {
	log.Println("message")
	//Fatalln执行之后调用:os.Exit(1), 退出程序，后续程序不再执行
	log.Fatalln("打印日志，程序退出")
	fmt.Println("还会执行吗")
}

定制日志记录器

package logger
import (
	"log"
	"os"
	"io"
)
var (
	Debug *log.Logger  //仅仅输出到控制台
	Info *log.Logger
	Warning *log.Logger
	Error *log.Logger
)
const (
	logFlag = log.LstdFlags | log.Lshortfile
)
func init() {
	file, error := os.OpenFile("info.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
	if error != nil {
		panic(error)
	}
	Debug = log.New(os.Stdout, "debug:", logFlag)
	Info = log.New(io.MultiWriter(file, os.Stdout), "info:", logFlag)
	Warning = log.New(os.Stdout, "waring:", logFlag)
	Error = log.New(io.MultiWriter(file, os.Stderr), "error:", logFlag)
}

测试

package main
import "logger"
func main() {
	logger.Debug.Println("debug")
	logger.Info.Println("create a info log")
	logger.Error.Println("create a errr log")
}

2.3 IO流

package main
import (
	"os"
	"fmt"
	"bufio"
	"io"
	"io/ioutil"
)
func openFile() {
	file, err := os.Open("info.log")
	if err != nil {
		fmt.Println("文件错误", err)
	}
	defer file.Close()
	reader := bufio.NewReader(file)
	for {
		str, err := reader.ReadString('\n')
		if err == io.EOF { //表示读取完毕
			break
		}
		fmt.Print(str)
	}
}
//读取内容到内存中
func openFile2() {
	data, err := ioutil.ReadFile("info.log")
	if err != nil {
	}
	fmt.Print(string(data))
}
func writeFile() {
	file, err := os.OpenFile("hello.txt", os.O_WRONLY| os.O_CREATE | os.O_APPEND, 0666)
	if err != nil {
		fmt.Println("创建文件错误")
		return
	}
	defer file.Close()
	writer := bufio.NewWriter(file)
	for i := 0; i < 5; i++ {
		writer.WriteString("写入数据：\n")
	}
	writer.Flush() //将缓冲区内容写入到文件中
}
//判断文件是否存在
func IsExist() {
	_, e := os.Stat("info2.log")
	if e != nil {
		exist := os.IsNotExist(e)
		fmt.Println(exist)
	}
}

2.5 json

package main
import (
	"encoding/json"
	"fmt"
	"time"
)
type Book struct {
	Title string
	Author string
	Publish time.Time
}
//序列化map
func serializeMap() {
	student := make(map[string]interface{})
	student["name"] = "闰土"
	student["age"] = 20
	student["class"] = "大一"
	bytes, err := json.Marshal(student)
	if err != nil {
		fmt.Println("序列化错误")
	}
	fmt.Println(string(bytes)) //{"age":20,"class":"大一","name":"闰土"}
}
//序列化结构体
func serializeStruct() {
	book := Book{"青春","itcloud", time.Now()}
	bytes, _ := json.Marshal(book)
	fmt.Println(string(bytes)) // {"Title":"青春","Author":"itcloud","Publish":"2019-02-05T11:14:51.094709+08:00"}
}
func deserializeMap() {
	var student map[string]interface{}
	data := `{"age":20,"class":"大一","name":"闰土"}`
	err := json.Unmarshal([]byte(data), &student)
	if err != nil {}
	fmt.Println(student)
}
func deserializeStruct() {
	var book Book
	bookStr := `{"Title":"青春","Author":"itcloud","Publish":"2019-02-05T11:14:51.094709+08:00"}`
	json.Unmarshal([]byte(bookStr), &book)
	fmt.Println(book)
}

2.6 网络编程

1. TCP

客户端

package main
import (
	"bufio"
	"fmt"
	"net"
	"os"
)
func main() {
	conn, _ := net.Dial("tcp", "127.0.0.1:8088")
	reader := bufio.NewReader(os.Stdin)
	line, _ := reader.ReadString('\n')
	n, _ := conn.Write([]byte(line))
	fmt.Println(n)
}

服务端

package main
import (
	"fmt"
	"net"
)
func main() {
	listener, err := net.Listen("tcp", "127.0.0.1:8088")
	if flag := Checkout(err, "监听开启错误"); !flag {
		return
	}
	defer listener.Close()
	for {
		fmt.Println("等待客户端建立连接...")
		conn, err := listener.Accept()
		if flag :=  Checkout(err, "打开连接失败"); flag {
			fmt.Printf("conn= %v, ip = %v\n", conn, conn.RemoteAddr().String())
		}
		go process(conn)
	}
}
func process (conn net.Conn) {
	defer conn.Close()
	for {
		buf := make([]byte, 1024)
		readLen, err := conn.Read(buf)
		if flag := Checkout(err, "读取失败"); !flag {
			return
		}
		fmt.Println(string(buf[:readLen]))
	}
}
func Checkout(err error, msg string) bool {
	if err != nil {
		fmt.Println(msg, err)
		return false
	}
	return true
}

2. http

func main() {
	http.HandleFunc("/echo", echo)
	http.ListenAndServe(":8080", nil)
}
func echo(w http.ResponseWriter, r *http.Request) {
	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		w.Write([]byte("get body error"))
		return
	}
	strlen, err := w.Write(body)
	if err != nil && strlen != len(body) {
		w.Write([]byte("write a error"))
	}
}

package main
import (
	"net/http"
	"time"
)
//自定义handler
func main() {
	myHandler := &SelfHandle{format: time.RFC1123}
	http.Handle("/time", myHandler)
	http.ListenAndServe(":8080", nil)
}
type SelfHandle struct {
	format string
}
func (h *SelfHandle) ServeHTTP(w http.ResponseWriter,  r *http.Request) {
	forTime := time.Now().Format(h.format)
	w.Write([]byte("time is " + forTime))
}

多路复用处理器

package main
import "net/http"
//多路复用处理器
func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/hello", hello)
	mux.HandleFunc("/world", world)
	server := &http.Server{Addr: ":8080", Handler: mux}
	server.ListenAndServe()
}
func hello(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("hello"))
}
func world(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("word"))
}

golang学习总结的更多相关文章

golang学习之beego框架配合easyui实现增删改查及图片上传
golang学习之beego框架配合easyui实现增删改查及图片上传 demo目录: upload文件夹主要放置上传的头像文件,main是主文件,所有效果如下: 主页面: 具体代码: <!DO ...
Golang学习 - 学习资源列表
Golang 学习资源: <Go 语言圣经(中文版)> - 书籍 http://shinley.com/index.html <学习 Go 语言> - 书籍 http://w ...
Golang学习：sublime text3配置golang环境
最近导师让学习golang, 然后我就找了些有关golang的学习视频和网站. 昨天在电脑上下载了go tools, 之后在sublime上配置了golang的运行环境.By the way, 我的电 ...
golang学习笔记20 一道考察对并发多协程操作一个共享变量的面试题
golang学习笔记20 一道考察对并发多协程操作一个共享变量的面试题下面这个程序运行的能num结果是什么? package main import ( "fmt" " ...
golang学习笔记19 用Golang实现以太坊代币转账
golang学习笔记19 用Golang实现以太坊代币转账在以太坊区块链中,我们称代币为Token,是以太坊区块链中每个人都可以任意发行的数字资产.并且它必须是遵循erc20标准的,至于erc20标 ...
golang学习笔记18 用go语言编写移动端sdk和app开发gomobile
golang学习笔记18 用go语言编写移动端sdk和app开发gomobile gomobile的使用-用go语言编写移动端sdk和app开发https://blog.csdn.net/u01249 ...
golang学习笔记17 爬虫技术路线图，python，java，nodejs，go语言，scrapy主流框架介绍
golang学习笔记17 爬虫技术路线图,python,java,nodejs,go语言,scrapy主流框架介绍 go语言爬虫框架:gocolly/colly,goquery,colly,chrom ...
golang学习笔记16 beego orm 数据库操作
golang学习笔记16 beego orm 数据库操作 beego ORM 是一个强大的 Go 语言 ORM 框架.她的灵感主要来自 Django ORM 和 SQLAlchemy. 目前该框架仍处 ...
golang学习笔记14 golang substring 截取字符串
golang学习笔记14 golang substring 截取字符串golang 没有java那样的substring函数,但支持直接根据 index 截取字符串mystr := "hel ...
golang学习笔记13 Golang 类型转换整理 go语言string、int、int64、float64、complex 互相转换
golang学习笔记13 Golang 类型转换整理 go语言string.int.int64.float64.complex 互相转换 #string到intint,err:=strconv.Ato ...

随机推荐

倒计时特效的CountAnimationLabel
倒计时特效的CountAnimationLabel 效果: 源码: CountAnimationLabel.h 与 CountAnimationLabel.m // // CountAnimation ...
MSDN版、OEM版、RTM版、VOL版等的区别
我们常常听说操作系统的MSDN版.OEM版.RTM版.VOL版等等,它们到底是什么意思,有什么不同呢? (一)MSDN (Microsoft Developer Network)版MSDN软件是微软公 ...
Linux ping命令详解
Linux系统的ping命令是常用的网络命令,它通常用来测试与目标主机的连通性基于IMCP协议常见命令参数 -q 不显示任何传送封包的信息,只显示最后的结果 -n 只输出数值 -R 记录路由过程 ...
Linxu下 expect的安装与使用
expect学习 1.什么是except Expect是基于Tcl的一个相对简单的免费脚本文件语言工具,用于实现自动和交互式程序进行通信 is a software ...
Android启动外部应用的方法
1.根据package的名称获取应用的Launch Intent Intent LaunchIntent = getPackageManager().getLaunchIntentForPackage ...
js获取鼠标坐标位置兼容多个浏览器
这个是IE 11 下兼容下视图测试时可用. $(window).bind('beforeunload', function (event) { var _this = this; var x = ev ...
codeforces 407C Curious Array
codeforces 407C Curious Array UPD: 我觉得这个做法比较好理解啊参考题解:https://www.cnblogs.com/ChopsticksAN/p/4908377 ...
python接口测试：自动保存cookies
接口测试中遇到上一个请求返回响应包含cookie(如下图登录请求的响应结果).需将cookies保存下来,后续请求自动带入,否则会提示未登录. python requests的cookie类型是< ...
VNC Viewer
首先需要明确,什么事VNC , Virtual Network Computing ,VNC允许Linux系统可以类似实现像Windows中的远程桌面访问那样访问Linux桌面. 首先试试服务器装了V ...
python的*args和**kwargs基础用法
*args表示任何多个无名参数,它是一个tuple **kwargs:传入的字典,就如:a=1,传入键值,默认就传入到**kwargs中,如下面代码: class FOO: def __init__( ...

golang学习总结