package main
import (
"crypto/md5"
"fmt"
"log"
"math"
"math/bits"
"math/rand"
"os"
"reflect"
"runtime"
"sort"
"strconv"
"strings"
"sync"
"te"
"time"
"unsafe"
//"hash"
"encoding/hex"
fstate "fsm"
"io"
"regexp"
"text/tabwriter"
"path/filepath"
"errors"
"context"
)
var c bool
var age int
var score float32
var tree, tree2 uint16
var list []uint
func main() {
// _, txt := addStr(1, "new")
// fmt.Println("Google" + "Runoob", txt)
// var man male
// fu := man.change(6,5)
// fmt.Println("===>>", fu())
//main1()
//te.When()
rand.Seed(time.Now().Unix())
randseed = time.Now().UnixNano()
mainfi()
}
const (
Unknown = "1123swerwe"
Female = len(Unknown)
Male = unsafe.Sizeof(Unknown)
Today = iota
Nice
)
func addStr(num int, str string) (a, b int) {
age = 1
newd := 1
body, newd := age, 1
age += body
arr := []int{1, 23, 34, 3, 63}
slice1 := make([]int, 5)
fmt.Println(Unknown, Female, Male, unsafe.Sizeof(arr), Today, Nice)
bload(arr)
for k, v := range slice1 {
fmt.Println(k, v)
}
const Length int = 1
return age, newd
}
func bload(arr []int) {
arr[len(arr)-1] = 999
}
type male struct {
body float32
}
func (c male) change(a, b int) func() int {
NCC:
if a >= b {
fmt.Println(a, "big")
a = a - 1
goto NCC
} else {
fmt.Println(a, "small")
}
return func() int {
a++
return a
}
}
// 定义一个 DivideError 结构
type DivideError struct {
dividee int
divider int
}
func (obj *DivideError) Div() {
obj.dividee = 10
obj.divider = 9
}
func (obj DivideError) Div1() {
obj.dividee = 100
obj.divider = 90
}
// 实现 error 接口
func (de *DivideError) Error() string {
strFormat := Cannot proceed, the divider is zero. dividee: %d divider: 0
return fmt.Sprintf(strFormat, de.dividee)
}
// 定义 int 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
if varDivider == 0 {
dData := DivideError{
dividee: varDividee,
divider: varDivider,
}
errorMsg = dData.Error()
return
} else {
return varDividee / varDivider, ""
}
}
func main1() {
if result, errorMsg := Divide(100, 10); errorMsg == "" {
fmt.Println("100/10 = ", result)
}
// 当除数为零的时候会返回错误信息
if _, errorMsg := Divide(100, 0); errorMsg != "" {
fmt.Println("errorMsg is: ", errorMsg)
}
chans()
maps()
var di DivideError
di.Div()
//fmt.Println("====>>>>", di.dividee, di.divider)
}
func worker(id int, c chan int) {
for {
fmt.Printf("worker %d run %c\n", id, <-c)
}
}
func chans() {
// var channels [10]chan int
// for i:=0;i<2;i++{
// channels[i]=make(chan int)
// go worker(i,channels[i])
// }
// for i:=0;i<10;i++{
// channels[0] <- 'a'+i
// }
// fmt.Println("=======>>>")
// for i:=0;i<10;i++{
// channels[1] <- 'A'+i
// }
}
func maps() {
var contryMap map[string]string = make(map[string]string)
contryMap["nis"] = "nik"
contryMap["nid"] = "nikw"
contryMap["ni"] = "nikd"
for k, v := range contryMap {
fmt.Println(k, v)
}
fmt.Println("dd", contryMap["ni"+"s"])
fun(callback).call(2)
mains()
}
func mains() {
fmt.Printf(">>>>%T\n", 123)
type cat struct {
Name string
Type int `json:"type" id:"100"`
}
typeOfCat := reflect.TypeOf(cat{})
if catType, ok := typeOfCat.FieldByName("Type"); ok {
fmt.Println(catType.Tag.Get("json"))
fmt.Println(catType.Tag.Get("id"))
}
//main2()
main3()
}
//需要传递函数
func callback(i int) {
d := &i
fmt.Println("i am callBack", reflect.TypeOf(d))
fmt.Println(i)
}
//定义的type函数
type fun func(int)
//fun实现的Call接口的call()函数
func (f fun) call(i int) {
f(i)
}
//接口
// type Call interface {
// call(int)
// }
// 崩溃时需要传递的上下文信息
type panicContext struct {
functionss string // 所在函数
function int // 所在函数
}
// 保护方式允许一个函数
func ProtectRun(entry func()) {
//延迟处理的函数
defer func() {
// 发生宕机时，获取panic传递的上下文并打印
err := recover()
switch err.(type) {
case runtime.Error: // 运行时错误
fmt.Println("runtime error:", err)
default: // 非运行时错误
fmt.Println("error:", err)
}
}()
entry()
}
func main2() {
fmt.Println("运行前")
// 允许一段手动触发的错误
ProtectRun(func() {
fmt.Println("手动宕机前")
// 使用panic传递上下文
panic(&panicContext{
"手动触发panic",
555,
})
fmt.Println("手动宕机后")
})
// 故意造成空指针访问错误
ProtectRun(func() {
fmt.Println("赋值宕机前")
var a *int
*a = 1
fmt.Println("赋值宕机后")
})
fmt.Println("运行后")
}
type coder interface {
code()
debug()
}
type Gopher struct {
num int
language string
}
func (p Gopher) code() {
p.num++
fmt.Printf("I am coding %s language, num is %d\n", p.language, p.num)
}
func (p *Gopher) debug() {
p.num++
fmt.Printf("I am debuging %s language, num is %d\n", p.language, p.num)
}
func maintest() {
// var take coder
// take = &Gopher{100, "doing"}
// take.code()
// take.debug()
// take.code()
lsInt := make(chan int)
fmt.Println("6666666", time.Second)
count := 0
var lock sync.Mutex
go func() {
for i := 0; i < 26; i++ {
lock.Lock()
count = count + 1
fmt.Println("go<<<", i, count)
lock.Unlock()
lsInt <- i
}
}()
go func() {
for i := 0; i < 16; i++ {
m := <-lsInt
lock.Lock()
count = count + 1
fmt.Println("go>>>", m, count)
lock.Unlock()
}
}()
m := <-lsInt
lock.Lock()
count = count + 1
fmt.Println("main>>>", m, count)
lock.Unlock()
fmt.Println("zzzzz", count)
}
func mainos() {
// 预定义变量, 保存命令行参数
fmt.Println(os.Args)
// 获取host name
fmt.Println(os.Hostname())
fmt.Println(os.Getpid())
// 获取全部环境变量
// env := os.Environ()
// for k, v := range env {
// fmt.Println(k, v)
// }
// 终止程序
// os.Exit(1)
// 获取一条环境变量
//fmt.Println(os.Getenv("PATH"))
// 获取当前目录
dir, err := os.Getwd()
fmt.Println(dir, err)
// 创建目录
err = os.Mkdir(dir+"/new_file", 0755)
fmt.Println(err)
// 创建目录
err = os.MkdirAll(dir+"/new", 0755)
fmt.Println(err)
// 删除目录
err = os.Remove(dir + "/new_file")
err = os.Remove(dir + "/new")
fmt.Println(err)
// 创建临时目录
tmp_dir := os.TempDir()
fmt.Println(tmp_dir)
}
func findRoad(r *int) {
log.Println("road:", *r)
}
func entry() {
rd := int(999)
r := &rd
runtime.SetFinalizer(r, findRoad)
}
func main3() {
// entry()
// for i := 0; i < 3; i++ {
// time.Sleep(time.Second)
// runtime.GC()
// }
var x float64 = 3.4
//data := reflect.TypeOf(x)
value := reflect.ValueOf(x)
// floatData := value.Float()
// floatData = 1.3
over := value.Interface()
fmt.Println(reflect.TypeOf(over), reflect.TypeOf(over.(float64)), over, interface{}(interface{}(over)).(float64), interface{}(x).(float64))
return
}
func KeyPrefix(str interface{}) (prefix string) {
t := reflect.TypeOf(str).Elem()
prefix = fmt.Sprintf("%s_%s_", "india_game", t.String())
return
}
type pick struct {
str string
co int
}
type Person05 struct {
name string
sex string
age int
}
func (p Person05) printInfo() {
fmt.Printf("55>>名称：%s, 性别：%s, 年龄：%d\n", p.name, p.sex, p.age)
}
type inter interface {
printInfo()
}
type Person04 struct {
Person05
sex bool
name string
age int
}
func (p Person04) printInfo() {
fmt.Printf("44>>名称：%s, 性别：%s, 年龄：%d\n", p.name, p.sex, p.age)
}
type Student struct {
Person05
id int
}
func Float64bits(f float64) uint64 { return (uint64)(unsafe.Pointer(&f)) }
//func Float64bits(f, m float64){ return (uint64)(unsafe.Pointer(&f)) }
func init() {
}
func init() {
}
func main61() {
// str := "zzzzzz"
// m := KeyPrefix(&str)
// fmt.Println(m)
// picks := pick{}
// fmt.Println(&picks, &picks.co,&(picks.co), (&picks).co)
// user := pick{"go", 3}
// fmt.Printf("%v %v\n", user, &user)
// fmt.Printf("%+v %+v\n", user, &user)
// fmt.Printf("%#v %#v\n", user, &user)
// done := make(chan int, 1) // 带缓存通道
// go func() {
// fmt.Println(">>>>>1")
// <-done
// fmt.Println(">>>>>2")
// }()
// fmt.Println(">>>>>3")
// done <- 1
// fic.When(2)
// //fic2.When(3)
//fic.When(2)
// //fic2.When(3)
// fic2.Put()
// oldList := []int {1,2,3,4,5,6}
// i := 3
// fmt.Println(oldList[:1], oldList[i+1:])
// oldList = append(oldList[:i], oldList[i+1:]...)
// fmt.Println(oldList)
// x := []int {1,2,3}
// //注意下面这两个区别
// fmt.Println(append(x,4,5,6), x)
// if(fic.When == nil){
// fmt.Println("kkkkkkkk")
// }
// u := uint32(32)
// i := int32(1)
// fmt.Println(&u, &i)
// p := &i
// fmt.Println(">>",unsafe.Pointer(&u))
// p = (*int32)(unsafe.Pointer(&u))
// fmt.Println(*p)
// flo := 3.5
// fmt.Println(Float64bits(flo))
p := Person04{Person05{}, true, "putty", 10}
fmt.Println(p)
fmt.Println("SIZE", &(p), &(p.sex), &(p.name), &(p.age))
lang := (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&p)) + 24))
*lang = 20
fmt.Println(p)
// var x struct {
// a bool
// b string
// c bool
// b1 bool
// c1 bool
// d int32
// e []int
// }
// fmt.Println("SIZE", &(x),&(x.a),&(x.b),&(x.c),&(x.b1),&(x.c1),&(x.d),&(x.e))
// //Alignof 返回 m，m 是指当类型进行内存对齐时，它分配到的内存地址能整除 m。
// //fmt.Println("ALIGN",unsafe.Alignof(x),unsafe.Alignof(x.a),unsafe.Alignof(x.b),unsafe.Alignof(x.c))
// fmt.Println("OFFSET",0, unsafe.Offsetof(x.a), unsafe.Offsetof(x.b), unsafe.Offsetof(x.c))
// recover()
// a := make([]func(), 3 )
// i := 0
// for ; i < 3; i++ {
// a[i]= func( ){
// fmt.Println(i)
// }
// }
// defer func(){ fmt.Println("Zzz")}()
// defer func(){ }()
// defer func(){ fmt.Println("Zzz2")}()
// panic("zjjj")
//i = 6
// for _, s := range a {
// s()
// }
}
func main66() {
// defer func() {
// fmt.Println(recover())
// fmt.Printf(">>>%T", recover())
// }()
// fmt.Println(1, nil)
// a := []int{123}
// a[0] = 2
// maps := map[string]interface{}{}
// maps["student4"] = Person04
// maps["student5"] = student5
// fmt.Println("struct to string")
num := Person04{Person05{}, true, "putty", 10}
// if abs, ok := interface{}(num.name).(string); ok {
// fmt.Println("zzzzz", abs)
// }
num.printInfo()
v2 := reflect.ValueOf(num)
fmt.Println(">>", v2.Type())
// go func() {
// for {
// fmt.Println("goroutine1_print")
// }
// }()
// // 协程B
// go func() {
// time.Sleep(1 * time.Second)
// panic("goroutine2_panic")
// }()
// time.Sleep(20 * time.Second)
str := "LUCKY SPIN is wai@ting for YOU! Our players has won more than 1 Lakh totally in LUCKY SPIN today!Your city's player has won 2 Lakh in Poker today, come to WIN BIGGER!"
GetRandomStr(str)
// for i := 1; i< 80; i++ {
// fmt.Println(RandInt(3))
// }
x := 11
y := (1 << 0) | (1 << 3) //保证 z 中的第 0 位和第 3 位为 0
z := x &^ y
fmt.Printf("x = %b\n", x)
fmt.Println("\t&^")
fmt.Printf("y = %b\n", y)
fmt.Println("————————")
fmt.Printf("z = %04b\n", z)
}
func RandInt(max int) int {
if max <= 1 {
return 1
}
rr := rand.New(rand.NewSource(time.Now().UnixNano() * rand.Int63n(9999)))
return rr.Intn(max) + 1
}
//分隔符@
func GetRandomStr(str string) {
strLs := strings.Split(str, "@")
for k, str := range strLs {
fmt.Println(k, str)
}
fmt.Println(strLs[RandInt(len(strLs))-1])
}
const m0 = 0x5555555555555555 // 01010101 ...
const m1 = 0x3333333333333333 // 00110011 ...
const m2 = 0x0f0f0f0f0f0f0f0f // 00001111 ...
const m3 = 0x00ff00ff00ff00ff // etc.
const m4 = 0x0000ffff0000ffff
func P64(x uint64) {
str := ""
for i := 0; i < 64; i++ {
str = fmt.Sprint(x>>i&1, str)
}
fmt.Println(x, ">>>", str)
}
func P32(x uint64) {
str := ""
for i := 0; i < 32; i++ {
str = fmt.Sprint(x>>i&1, str)
}
fmt.Println(x, ">>>", str)
}
func P16(x uint64) {
str := ""
for i := 0; i < 16; i++ {
str = fmt.Sprint(x>>i&1, str)
}
fmt.Println(x, ">>>", str)
}
func onecnt(x uint64) int {
count := 0
for ; x > 0; x = x & (x - 1) {
count++
}
return count
}
func onetest(x uint64) {
const m = 1<<64 - 1
fmt.Println(x, x&m)
//var s te.StateStr
}
// func (x *StateStr)take() {
// }
func OnesCount64(x uint64) int {
const m = 1<<64 - 1
x = x>>1&(m0&m) + x&(m0&m)
x = x>>2&(m1&m) + x&(m1&m)
x = (x>>4 + x) & (m2 & m)
x += x >> 8
x += x >> 16
x += x >> 32
fmt.Println("==>", m0&m)
return int(x) & (1<<7 - 1)
}
func Abs(n float64) float64 {
return float64bits(bittofloat(n) &^ (1 << 63))
}
func float64bits(n uint64) float64 {
return (float64)(unsafe.Pointer(&n))
}
func bittofloat(n float64) uint64 {
return (uint64)(unsafe.Pointer(&n))
}
func GetFunctionName(i interface{}, seps ...rune) string {
// 获取函数名称
fmt.Println("**>>>>", runtime.FuncForPC(reflect.ValueOf(i).Pointer()))
fn := runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
// 用 seps 进行分割
fields := strings.FieldsFunc(fn, func(sep rune) bool {
for _, s := range seps {
if sep == s {
return true
}
}
return false
})
fmt.Println(fields)
if size := len(fields); size > 0 {
return fields[size-1]
}
return ""
}
func Println(v uint64) {
P16(v)
}
func getlog(v uint32) uint32 {
v--
v |= v >> 1
v |= v >> 2
v |= v >> 4
v |= v >> 8
v |= v >> 16
v++
v = tab32[(v*0x077CB531)>>27]
return v
}
const digits = "0123456789abcdefghijklmnopqrstuvwxyz"
var tab32 = [32]uint32{
0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9}
func main106() {
uintSize := 32 << (^int64(0) >> 32 & 1)
b := 1e20
fmt.Println(^uint(0), ^uint(0)>>32, (^uint(0) >> 32 & 1), uintSize)
const m = 1<<64 - 1
fmt.Println(b, m>>1&(^int64(0)), OnesCount64(4095), onecnt(4096))
onetest(409)
P16(123)
P16(123 &^ 6)
fmt.Println("name:", GetFunctionName(P16))
// P64(bittofloat(-0.1251234))
// P64(bittofloat(-1))
var pi te.StateStr
pi.Fill()
curT := time.Now()
const sun = iota
fmt.Println(">>>", curT.Nanosecond(), sun, time.Now().UTC())
// const char g_math_32[] ={0,1,23,2,29,24,14,3,30,27,25,18,20,15,10,4,31,22,28,13,26,17,19,9,21,12,16,8,11,7,6,5};
// #define LOG2(v) g_math_32[(uint32_t)((v) * 0x7dcd629) >> 27]
fmt.Println(strconv.FormatInt(127, 2))
var un uint64 = 88
un = -un
string_number := 869702343
result := fmt.Sprint(string_number)
fmt.Println(result)
x := 0x077CB531
fmt.Println((x & -x))
fmt.Printf("%T\n", result)
fmt.Println("===", digits[1:2], un, bits.TrailingZeros(2), getlog(120), bits.LeadingZeros(1<<60+4641213))
slice := make([]byte, 0)
slice1 := strconv.AppendBool(slice, false) // []byte中添加bool类型 （bool-->[]byte）
fmt.Println(string(slice1)) // false
slice2 := strconv.AppendInt(slice, 123, 2) // 2:二进制
fmt.Println(string(slice2)) // 1111011
slice3 := strconv.AppendFloat(slice, 3.141592, 'f', 4, 64) // 4:保留4位。 64:float64
fmt.Println(string(slice3)) // 3.1416
slice4 := strconv.AppendQuote(slice, "hello")
fmt.Println(string(slice4), reflect.ValueOf(slice3).Len()) // "hello" (包含双引号)
for k, v := range slice {
fmt.Println(k, v)
}
}
func requiresQuotes(u string) bool {
// When type URL contains any characters except [0-9A-Za-z./-]*, it must be quoted.
for , ch := range u {
switch {
case ch == '.' || ch == '/' || ch == '':
continue
case '0' <= ch && ch <= '9':
continue
case 'A' <= ch && ch <= 'Z':
continue
case 'a' <= ch && ch <= 'z':
continue
default:
return true
}
}
return false
}
func RandIntervalN(b1, b2 int32, n uint32) []int32 {
if b1 == b2 {
return []int32{b1}
}
min, max := int64(b1), int64(b2)
if min > max {
min, max = max, min
}
l := max - min + 1
if int64(n) > l {
n = uint32(l)
}
r := make([]int32, n)
m := make(map[int32]int32)
for i := uint32(0); i < n; i++ {
v := int32(rand.Int63n(l) + min)
//v := int32(Getrand(min, max))
if mv, ok := m[v]; ok {
r[i] = mv
} else {
r[i] = v
}
lv := int32(l - 1 + min)
if v != lv {
if mv, ok := m[lv]; ok {
m[v] = mv
} else {
m[v] = lv
}
}
l--
}
return r
}
func RandGroup(p ...uint32) int {
if p == nil {
panic("args not found")
}
r := make([]uint32, len(p))
for i := 0; i < len(p); i++ {
if i == 0 {
r[0] = p[0]
} else {
r[i] = r[i-1] + p[i]
}
}
rl := r[len(r)-1]
if rl == 0 {
return 0
}
rn := uint32(rand.Int63n(int64(rl)))
for i := 0; i < len(r); i++ {
if rn < r[i] {
return i
}
}
panic("bug")
}
func deepCopy(dst, src reflect.Value) {
switch src.Kind() {
case reflect.Interface:
value := src.Elem()
if !value.IsValid() {
return
}
newValue := reflect.New(value.Type()).Elem()
deepCopy(newValue, value)
dst.Set(newValue)
case reflect.Ptr:
value := src.Elem()
if !value.IsValid() {
return
}
dst.Set(reflect.New(value.Type()))
deepCopy(dst.Elem(), value)
case reflect.Map:
dst.Set(reflect.MakeMap(src.Type()))
keys := src.MapKeys()
for _, key := range keys {
value := src.MapIndex(key)
newValue := reflect.New(value.Type()).Elem()
deepCopy(newValue, value)
dst.SetMapIndex(key, newValue)
}
case reflect.Slice:
dst.Set(reflect.MakeSlice(src.Type(), src.Len(), src.Cap()))
for i := 0; i < src.Len(); i++ {
deepCopy(dst.Index(i), src.Index(i))
}
case reflect.Struct:
typeSrc := src.Type()
for i := 0; i < src.NumField(); i++ {
value := src.Field(i)
tag := typeSrc.Field(i).Tag
if value.CanSet() && tag.Get("deepcopy") != "-" {
deepCopy(dst.Field(i), value)
}
}
default:
dst.Set(src)
}
}
func DeepCopy(dst, src interface{}) {
typeDst := reflect.TypeOf(dst)
typeSrc := reflect.TypeOf(src)
if typeDst != typeSrc {
panic("DeepCopy: " + typeDst.String() + " != " + typeSrc.String())
}
if typeSrc.Kind() != reflect.Ptr {
panic("DeepCopy: pass arguments by address")
}
valueDst := reflect.ValueOf(dst).Elem()
valueSrc := reflect.ValueOf(src).Elem()
if !valueDst.IsValid() || !valueSrc.IsValid() {
panic("DeepCopy: invalid arguments")
}
deepCopy(valueDst, valueSrc)
}
func DeepClone(v interface{}) interface{} {
dst := reflect.New(reflect.TypeOf(v)).Elem()
deepCopy(dst, reflect.ValueOf(v))
return dst.Interface()
}
func Perm(n int) []int {
m := make([]int, n)
for i := 0; i < n; i++ {
j := rand.Intn(i + 1)
m[i] = m[j]
m[j] = i
fmt.Println(i, m[i], ">>", j, m[j])
}
return m
}
func C(sum, lec int) int {
ret := 1
low := 1
for i := 0; i < lec; i++ {
ret *= sum - i
low *= lec - i
}
// str := fmt.Sprint("C(", sum , ",", lec ,")" , ret/low)
// fmt.Println(str)
return ret / low
}
func Clist(para ...int) int {
all := 1
for i := 0; i < len(para); i += 2 {
all *= C(para[i], para[i+1])
}
return all
}
func Csum(para ...[]int) int {
all := 0
for i := 0; i < len(para); i++ {
all += Clist(para[i]...)
}
return all
}
var randseed int64 = 456213
func Getrand(min, max int64) int64 {
randseed = randseed >> 32 << 32
randseed := (1103515245*randseed + 1) % (2<<31 - 1)
fmt.Println(randseed)
if randseed < 0 {
randseed = -randseed
}
return randseed%(max-min+1) + min
}
func checkflo(flo map[int]int) bool {
for k := range flo {
if flo[k+1] > 0 && flo[k+2] > 0 && flo[k+3] > 0 && flo[k+4] > 0 {
return true
}
}
return false
}
func countdz() {
cards := make([]int, 0)
for i := 1; i < 14; i++ {
cards = append(cards, i)
cards = append(cards, i)
cards = append(cards, i)
cards = append(cards, i)
}
allcount := 1000000
count := make(map[string]int)
flocount := 0
for allcount > 0 {
allcount--
rand.Seed(int64(allcount))
selects := RandIntervalN(0, 51, 7)
static := make(map[int]int)
for i := 0; i < len(selects); i++ {
if v, ok := static[cards[selects[i]]]; ok {
static[cards[selects[i]]] = v + 1
} else {
static[cards[selects[i]]] = 1
}
}
if checkflo(static) {
flocount++
}
chipList := make([]int, 0)
for _, v := range static {
chipList = append(chipList, v)
}
sort.Ints(chipList)
arrStr := ""
for i := 0; i < len(chipList); i++ {
arrStr += strconv.Itoa(chipList[i])
}
if _, ok := count[arrStr]; ok {
count[arrStr]++
} else {
count[arrStr] = 1
}
}
fmt.Println(">>", count, flocount)
}
type special int32
func main6f() {
// strconv.ParseInt(...) fastest
// strconv.Atoi(...) still very fast
// fmt.Sscanf(...) not terribly fast but most flexible
// pstr := new(Person05)
// pstr.printInfo()
num := -1 << 63
num = num | (1<<63 - 1)
//newnum := (uint64)(unsafe.Pointer(&num))
//P64(newnum)
if requiresQuotes("sadfa32423") {
fmt.Println(">>>>#$%^&(")
}
nums := 3
find:
for {
switch {
case nums > 1:
fmt.Println("gjk")
nums--
case 2 > 1:
fmt.Println("999")
break find
}
}
// int32list := RandIntervalN(1, 10, 10)
// fmt.Println(int32list)
// fmt.Println(RandGroup(1,0,3))
// fmt.Println(Perm(10))
// fmt.Println(1<<0)
// v := Person04{}
// dst := reflect.New(reflect.TypeOf(v)).Elem()
// var picks special = 3
// var picks2 special = 2
// mk := picks + picks2
// fmt.Println(v, dst, mk)
//133784560
for i := 0; i < 100; i++ {
fmt.Println(Getrand(1, 10))
}
C(13, 7)
C(12, 5)
var arr [][]int = [][]int{
{52, 7},
{13, 7}, //1
{13, 1, 12, 5}, {13, 2, 11, 3}, {13, 3, 10, 1},
{13, 1, 12, 4}, {13, 2, 11, 1},
{13, 1, 12, 3},
{13, 2, 2, 1, 11, 2}, //3+2
{13, 2, 2, 1, 11, 1},
{13, 3, 3, 1},
{13, 2, 2, 1},
{13, 3, 3, 1},
{13, 5, 47, 2},
}
fmt.Println(Csum(arr...))
for k, v := range arr {
fmt.Println(k, ">>", float32(Clist(v...)))
}
fmt.Println("................")
absd := Person05{name: "fdafd"}
fmt.Println(absd.name, 133784560*21014559, math.Abs(1))
dict := make(map[int]int)
fmt.Println("ok0", dict[0])
if _, ok := dict[0]; ok {
fmt.Println("ok1", dict[0])
}
dict[0] = 0
if _, ok := dict[0]; ok {
fmt.Println("ok2", dict[0])
}
fmt.Println(dict[0], len(dict))
//countdz()\
var s byte = 0
var x interface{} // x 为零值 nil,静态类型为 interface{}
x = 42 //x declared but not used // x 的值为 42,动态类型为int, 静态类型为interface{}
fmt.Println(x, s)
//var v *T // v 为零值 nil, 静态类型为 *T
//x = v // x 的值为 (*T)(nil)， 动态类型为 *T, 静态类型为 *T
arrs := []int{1, 2, 3, 4}
fmt.Println(&arrs[0], &arrs[2])
slice := arrs[0:2]
fmt.Println(slice, &arrs[0], &slice[0], &arrs[2])
slice = append(slice, 8)
slice = append(slice, 9)
slice[0] = 11
slice = append(slice, 7)
slice[0] = 16
fmt.Println(slice, &arrs[0], &slice[0], &slice[2], ">>>", arrs[0], &arrs[2], "====", len(slice), cap(slice))
// bytes := hash.Sum([]byte{1,2,3,5})
// fmt.Println(CreateRandomStr("tomorrow"), hex.EncodeToString([]byte{255,16,16,16}), )
test(func() {
Exponent(3, 5)
})
test(func() {
math.Pow(3, 5)
})
tmp := [10]byte{9}
fmt.Println(tmp)
apple := -1
fmt.Println(">>>", apple<<5, maxDepth(128))
}
func maxDepth(n int) int {
var depth int
for i := n; i > 0; i >>= 1 {
depth++
}
return depth * 2
}
func GetSec() int64 {
return time.Now().UnixNano() / 10000000
}
func test(fn func()) {
tnum := GetSec()
for i := 0; i < 10000000; i++ {
fn()
}
fmt.Println(">>>", GetSec()-tnum)
}
func Exponent(a, n int64) int64 {
result := int64(1)
for i := n; i > 0; i >>= 1 {
if i&1 != 0 {
result *= a
}
a *= a
}
return result
}
//生成随机字符串//
func CreateRandomStr(seedStr string) string {
h := md5.New()
seedStr = seedStr + strconv.FormatInt(time.Now().UnixNano(), 10)
fmt.Println(seedStr)
io.WriteString(h, seedStr)
cipherStr := h.Sum(nil)
fmt.Println(cipherStr)
payNum := hex.EncodeToString(cipherStr)
return payNum
}
func saferoutine(c chan bool) {
for i := 0; i < 10; i++ {
fmt.Println("Count:", i)
time.Sleep(1 * time.Second)
}
c <- true
}
func panicgoroutine(c chan bool) {
time.Sleep(5 * time.Second)
panic("Panic, omg ...")
c <- true
}
const MaxRune = '\U0010FFFF'
const RuneError = '\uFFFD'
func TestCancelBeforeGenericEvent() {
fsm := fstate.NewFSM(
"start",
fstate.Events{
{Name: "run", Src: []string{"start"}, Dst: "end"},
},
fstate.Callbacks{
"before_event": func(e *fstate.Event) {
fmt.Println(">>>>")
e.Cancel()
},
},
)
fsm.Event("run")
if fsm.Current() != "start" {
fmt.Println("expected state to be 'start'")
}
}
type Interface interface {
// Len is the number of elements in the collection.
Len() int
// Less reports whether the element with
// index i should sort before the element with index j.
Less(i, j int) bool
// Swap swaps the elements with indexes i and j.
Swap(i, j int)
}
type interf []int
func swapRange(data interf, a, b, n int) {
for i := 0; i < n; i++ {
ab := data[a+i]
data[a+i] = data[b+i]
data[b+i] = ab
}
fmt.Println(a, b, n, ">>>", data)
}
func rotate(data interf, a, m, b int) {
i := m - a
j := b - m
for i != j {
if i > j {
swapRange(data, m-i, m, j)
i -= j
} else {
swapRange(data, m-i, m+j-i, i)
j -= i
}
}
swapRange(data, m-i, m, i)
}
func Copy(re *Person04) *Person04 {
re2 := *re
return &re2
}
func outs(obj interface{}){
}
func main6996() {
// c := make(chan bool, 2)
// go saferoutine(c)
// go panicgoroutine(c)
// for i := 0; i < 2; i++ {
// <-c
// }
// fmt.Println(reflect.TypeOf(MaxRune), RuneError)
// TestCancelBeforeGenericEvent()
// list := make([]int, 8)
// for i:=0 ;i< 8;i++ {
// list[i] = i
// }
// rotate(list, 0, 3, 8)
// fmt.Println(list)
reg1 := regexp.MustCompile("a.c")
buf := "abc azc a7c aac 888 a9c tac"
result1 := reg1.FindAllStringSubmatch(buf, -1)
fmt.Println("result1 = ", result1)
//目标字符串
searchIn := "John: 2578.34 William: 4567.23 Steve: 5632.18"
pat := "[0-9]+.[0-9]+" //正则
f := func(s string) string{
v, _ := strconv.ParseFloat(s, 32)
return strconv.FormatFloat(v * 2, 'f', 2, 32)
}
if ok, _ := regexp.Match(pat, []byte(searchIn)); ok {
fmt.Println("Match Found!")
}
re, _ := regexp.Compile(pat)
//将匹配到的部分替换为 "##.#"
str := re.ReplaceAllString(searchIn, "##.#")
fmt.Println(str)
//参数为函数时
str2 := re.ReplaceAllStringFunc(searchIn, f)
fmt.Println(str2)
s := regexp.MustCompile("a{2}").Split("baabaccadaaae", -1)
fmt.Println(s, len(s))
// s: ["", "b", "b", "c", "cadaaae"]
pat = `(((abc.)def.)ghi)`
src := `abc-def-ghi abc+def+ghi`
fmt.Println(regexp.MatchString(pat, src))
// true <nil>
fmt.Println(regexp.QuoteMeta(pat), re.String(),re.SubexpNames())
// \(\(\(abc\.\)def\.\)ghi\)
}
// main6 test
func main6() {
//Path操作
// fmt.Println(path.Ext("c:\\a/b.txt")) //.txt
// fmt.Println(path.IsAbs("c:/wind/aa/bb/b.txt")) //false
// fmt.Println(path.Join("c:", "aa", "bb", "cc.txt")) //c:/aa/bb/cc.txt
// isMatch, err := path.Match("c:/windows/*/", "c:/windows/system/")
// fmt.Println(isMatch, err) //true <nil>
// fmt.Println(path.Split("c:/windows/system/aaa.jpg")) //c:/windows/system/ aaa.jpg
// //FilePath操作
// fmt.Println("FilePath操作-----------------")
// fmt.Println(filepath.IsAbs("c:\\wind\\aa\\bb\\b.txt")) //true
fmt.Println(filepath.Abs(".")) //D:\Projects\GoPath\source\demo\syntax\path <nil>
// filepath.Walk("../", WalkFunc)
/*
File: ../../syntax IsDir: true size: 0
File: ..\..\syntax\painc IsDir: true size: 0
File: ..\..\syntax\painc\main.go IsDir: false size: 813
File: ..\..\syntax\painc\painc.exe IsDir: false size: 2498048
File: ..\..\syntax\path IsDir: true size: 0
File: ..\..\syntax\path\path.exe IsDir: false size: 2851328
File: ..\..\syntax\path\path.go IsDir: false size: 3419
*/
// tepl := "My name is {{ . }}"
// // 解析模板
// tmpl, err := text.New("test").Parse(tepl)
// // 数据驱动模板
// data := "jack"
// err = tmpl.Execute(os.Stdout, data)
w := tabwriter.NewWriter(os.Stdout, 10, 1, 5, '*', 0)
defer w.Flush()
// show := func(name string, v1, v2, v3 interface{}) {
// fmt.Fprintf(w, "%s\t%v\t%v\t%v\n", name, v1, v2, v3)
// }
//show("Int31",11111111111,2,2222223)
// Gosched：让当前线程让出 cpu 以让其它线程运行,它不会挂起当前线程，因此当前线程未来会继续执行
// NumCPU：返回当前系统的 CPU 核数量
// GOMAXPROCS：设置最大的可同时使用的 CPU 核数
// Goexit：退出当前 goroutine(但是defer语句会照常执行)
// NumGoroutine：返回正在执行和排队的任务总数
// GOOS：目标操作系统
fmt.Println("cpus:", runtime.NumCPU(), runtime.NumGoroutine())
fmt.Println("goroot:", runtime.GOROOT())
fmt.Println("archive:", runtime.GOOS)
//runtime.Goexit()
//runtime.GOMAXPROCS(1) //使用单核
exit := make(chan int)
go func() {
defer close(exit)
go func() {
fmt.Println("b")
}()
}()
for i := 0; i < 4; i++ {
fmt.Println("a:", i)
if i == 1 {
runtime.Gosched() //切换任务
}
}
<-exit
// go say("world")
// say("hello")
}
type T int
func IsClosed(ch <-chan T) bool {
select {
case <-ch:
return true
default:
}
return false
}
func main1112() {
c := make(chan T)
fmt.Println(IsClosed(c)) // false
close(c)
fmt.Println(IsClosed(c)) // true
}
func say(s string){
for i := 0; i < 2; i++ {
runtime.Gosched()
fmt.Println(s)
}
}
func WalkFunc(path string, info os.FileInfo, err error) error {
fmt.Println("File:", path, "IsDir:", info.IsDir(), "size:", info.Size())
return nil
}
func main1158() {
rand.Seed(time.Now().UnixNano())
log.SetFlags(0)
// ...
const MaxRandomNumber = 100000
const NumReceivers = 10
const NumSenders = 1000
wgReceivers := sync.WaitGroup{}
wgReceivers.Add(NumReceivers)
// ...
dataCh := make(chan int, 100)
stopCh := make(chan struct{})
// stopCh is an additional signal channel.
// Its sender is the moderator goroutine shown below.
// Its reveivers are all senders and receivers of dataCh.
toStop := make(chan string, 1)
// the channel toStop is used to notify the moderator
// to close the additional signal channel (stopCh).
// Its senders are any senders and receivers of dataCh.
// Its reveiver is the moderator goroutine shown below.
var stoppedBy string
// moderator
go func() {
stoppedBy = <- toStop // part of the trick used to notify the moderator
// to close the additional signal channel.
close(stopCh)
}()
// senders
for i := 0; i < NumSenders; i++ {
go func(id string) {
for {
value := rand.Intn(MaxRandomNumber)
if value == 0 {
// here, a trick is used to notify the moderator
// to close the additional signal channel.
select {
case toStop <- "sender#" + id:
default:
}
return
}
// the first select here is to try to exit the
// goroutine as early as possible.
select {
case <- stopCh:
return
default:
}
select {
case <- stopCh:
return
case dataCh <- value:
}
}
}(strconv.Itoa(i))
}
// receivers
for i := 0; i < NumReceivers; i++ {
go func(id string) {
defer wgReceivers.Done()
for {
// same as senders, the first select here is to
// try to exit the goroutine as early as possible.
select {
case <- stopCh:
return
default:
}
select {
case <- stopCh:
return
case value := <-dataCh:
if value == MaxRandomNumber-1 {
// the same trick is used to notify the moderator
// to close the additional signal channel.
select {
case toStop <- "receiver#" + id:
default:
}
return
}
log.Println(value)
}
}
}(strconv.Itoa(i))
}
// ...
wgReceivers.Wait()
log.Println("stopped by", stoppedBy)
}
func request(timeout time.Duration) (Response, error) {
//用于触发超时的上下文
deadline := time.Now().Add(timeout)
ctx, cancel := context.WithDeadline(context.Background(), deadline)
defer cancel()
//用于接收IO响应的通道
respCh := make(chan string)
start := time.Now()
//另起goroutine执行IO操作
go doIO(respCh)
var respData Response
var err error
//如果先接收到响应则停掉超时计时器
//如果超时计时器先触发，则生成一个error的实例
select {
case respData.body = <-respCh:
case <-ctx.Done():
err = errors.New("request timeout")
}
//记录总耗时
respData.elapse = time.Now().Sub(start)
return respData, err
}
type Response struct {
body string //响应内容
elapse time.Duration //响应耗时
}
func requestS(timeout time.Duration) (Response, error) {
//用于触发超时的计时器
timer := time.NewTimer(timeout)
//用于接收IO响应的通道
respCh := make(chan string)
start := time.Now()
//另起goroutine执行IO操作
go doIO(respCh)
var respData Response
var err error
//如果先接收到响应则停掉超时计时器
//如果超时计时器先触发，则生成一个error的实例
select {
case respData.body = <-respCh:
timer.Stop()
case <-timer.C:
err = errors.New("request timeout")
}
//记录总耗时
respData.elapse = time.Now().Sub(start)
return respData, err
}
func doIO(respCh chan string) {
//随机产生一个[0,100)毫秒的延迟，以模拟IO延时延迟
rand.Seed(time.Now().UnixNano())
delay := time.Duration(rand.Intn(100)) * time.Millisecond
fmt.Printf("delay=%v\n", delay)
time.Sleep(delay)
respCh <- "Hello World"
}
func mainTEST() {
resp, err := request(50 * time.Millisecond)
if err != nil {
fmt.Printf("error: %s\n", err.Error())
return
}
fmt.Printf("response: body=%s elapse=%s\n", resp.body, resp.elapse)
}
//worker工作的最大时长，超过这个时长worker自行收工无需等待manager叫停
const MAX_WORKING_DURATION = 5 * time.Second
//达到实际工作时长后，manager可以提前叫停
const ACTUAL_WORKING_DURATION = 2 * time.Second
func add(logs *[]int, lock *sync.Mutex, log int){
lock.Lock()
fmt.Println(">>>", log)
logs = append(logs, log)
lock.Unlock()
}
func qiess(logs []int) {
logs[0] = 99
for i := 0; i<10; i++ {
logs = append(logs, i)
fmt.Printf("%p", logs)
fmt.Println(" ",logs)
}
}
func print(para ...interface{}) {
fmt.Println(para...)
}
func worker1(ch chan struct{}, name string) {
for {
// select {
// case <-ch:
// fmt.Println(name, "return for ctxWithCancel.Done()")
// return
// default:
// fmt.Println(name, "working")
// }
time.Sleep(2 * time.Second)
}
}
func slaver(ch chan int){
//time.Sleep(1 * time.Second)
print(">>>>>0")
ch<-0
print(">>>>>1")
ch<-0
print(">>>>>2")
<-ch
print(">>>>>20")
ch<-0
print(">>>>>30")
}
func onec(ch chan int){
print("onec>>>>>1")
ch<-0
print("onec>>>>>2")
}
func mainfi12(){
chs := make(chan int)
print(">>>>>>>>>>>>")
go slaver(chs)
time.Sleep(1 * time.Second)
print(">>>>>>3")
<-chs
print(">>>>>>4")
<-chs
print(">>>>>>40")
//time.Sleep(1 * time.Second)
print(">>>>>>5")
}
func mainfis() {
var lock sync.Mutex
ch := make(chan int)
logs := make([]int, 0)
go slaver(ch) //go manager(ch, &logs, &lock)
add(&logs, &lock, 1)
<-ch
add(&logs, &lock, 2)
time.Sleep(1 * time.Second)
add(&logs, &lock, 3)
fmt.Println("gogo ", logs)
}
func manager(ch chan int, logs *[]int, lock *sync.Mutex) {
time.Sleep(1 * time.Second)
add(logs, lock, 4)
ch<- 0 //A
add(logs, lock, 5)
ch<- 0 //B
add(logs, lock, 6)
ch<- 0 //C
}
type MyChannel struct {
C chan T
once sync.Once
}
func NewMyChannel() *MyChannel {
return &MyChannel{C: make(chan T)}
}
func (mc *MyChannel) SafeClose() {
mc.once.Do(func(){
close(mc.C)
})
}
func takes() {
rand.Seed(time.Now().UnixNano())
log.SetFlags(0)
// ...
const MaxRandomNumber = 10
const NumReceivers = 2
wgReceivers := sync.WaitGroup{}
wgReceivers.Add(NumReceivers)
// ...
dataCh := make(chan int, NumReceivers)
// the sender
go func() {
for {
if value := rand.Intn(MaxRandomNumber); value == 110 {
// the only sender can close the channel safely.
close(dataCh)
return
} else {
print("<<1<", value)
dataCh <- value
print("<<2<", value)
}
time.Sleep(time.Second)
}
}()
// receivers
for i := 0; i < NumReceivers; i++ {
go func(i int) {
time.Sleep(time.Second)
defer wgReceivers.Done()
// receive values until dataCh is closed and
// the value buffer queue of dataCh is empty.
print(">>>>>>>>>>>>>", i)
for value := range dataCh {
print(">>>>>[", i,"]", value)
}
}(i)
}
wgReceivers.Wait()
}
func mainfissss(){
var C chan int
C = make(chan int)
var once sync.Once
once.Do(func(){
fmt.Println("zzzz")
close(C)
})
// go func() {
// for {
// if value := rand.Intn(10); value == 0 {
// // the only sender can close the channel safely.
// close(C)
// return
// } else {
// C <- value
// }
// }
// }()
fmt.Println("zzzz")
takes()
}
func mainfiff() {
rand.Seed(time.Now().UnixNano())
log.SetFlags(0)
// ...
const MaxRandomNumber = 100000
const NumReceivers = 10
const NumSenders = 1000
wgReceivers := sync.WaitGroup{}
wgReceivers.Add(NumReceivers)
// ...
dataCh := make(chan int, 100)
stopCh := make(chan struct{})
// stopCh is an additional signal channel.
// Its sender is the moderator goroutine shown below.
// Its reveivers are all senders and receivers of dataCh.
toStop := make(chan string, 1)
// the channel toStop is used to notify the moderator
// to close the additional signal channel (stopCh).
// Its senders are any senders and receivers of dataCh.
// Its reveiver is the moderator goroutine shown below.
var stoppedBy string
// moderator
go func() {
stoppedBy = <- toStop // part of the trick used to notify the moderator
// to close the additional signal channel.
close(stopCh)
}()
// senders
for i := 0; i < NumSenders; i++ {
go func(id string) {
for {
value := rand.Intn(MaxRandomNumber)
if value == 0 {
// here, a trick is used to notify the moderator
// to close the additional signal channel.
select {
case toStop <- "sender#" + id:
default:
}
return
}
// the first select here is to try to exit the
// goroutine as early as possible.
select {
case <- stopCh:
return
default:
}
select {
case <- stopCh:
return
case dataCh <- value:
}
}
}(strconv.Itoa(i))
}
// receivers
for i := 0; i < NumReceivers; i++ {
go func(id string) {
defer wgReceivers.Done()
for {
// same as senders, the first select here is to
// try to exit the goroutine as early as possible.
select {
case <- stopCh:
return
default:
}
select {
case <- stopCh:
return
case value := <-dataCh:
if value == MaxRandomNumber-1 {
// the same trick is used to notify the moderator
// to close the additional signal channel.
select {
case toStop <- "receiver#" + id:
default:
}
return
}
log.Println(value)
}
}
}(strconv.Itoa(i))
}
// ...
wgReceivers.Wait()
log.Println("stopped by", stoppedBy)
}
const MAIL_LIST = "MAIL_LIST"
func get() (ret int64) {
return
}
type pial struct{
Uid int32
List []int32
}
var nameList []string
var pickdata int32
func getpick()(int32,int32){
return 2,10
}
func updatepick() int32{
pickdata = 30
pickdata, err := getpick()
pickdata++
return pickdata + err
}
type datatry struct {
List []int json:"list"
}
var nowd datatry
func getnow()(fill datatry){
print(fill)
return
}
func mainfiqq() {
var t time.Time
var list []int = []int{1,2,3}
num := 10
gos := func()int{
num = RandInt(10)
return num
}
for i:= 0; i< gos() ;i++{
print(i, num)
}
print(t.String(), MAIL_LIST +"sadfkljasd", list[:0])
print( get())
pic := int64(10000)
pic = pic*pic
print(pic)
obj := pial{Uid: 0}
ls := &obj.List
*ls = append(*ls, 1,2)
print(*ls, obj)
lp := obj.List
lp[1] = 999
lp = append(lp[:0], lp[1:]...)
print(*ls, obj, lp)
print(nameList)
nameList = append(nameList, "gogo")
print(nameList)
print(pickdata)
updatepick()
print(pickdata, nowd.List, &(&nowd).List)
getnow()
// "2006-01-02", // RFC 3339
// "2006-01-02 15:04", // RFC 3339 with minutes
// "2006-01-02 15:04:05", // RFC 3339 with seconds
// "2006-01-02 15:04:05-07:00", // RFC 3339 with seconds and timezone
// "2006-01-02T15Z0700", // ISO8601 with hour
// "2006-01-02T15:04Z0700", // ISO8601 with minutes
// "2006-01-02T15:04:05Z0700", // ISO8601 with seconds
// "2006-01-02T15:04:05.999999999Z0700", // ISO8601 with nanoseconds
datetime := "2015-01-01 02:15:03" //待转化为时间戳的字符串
//日期转化为时间戳
timeLayout := "2006-01-02 15:05:15" //转化所需模板
loc, _ := time.LoadLocation("Local") //获取时区
tmp, _ := time.ParseInLocation(timeLayout, datetime, loc)
timestamp := tmp.Unix() //转化为时间戳 类型是int64
fmt.Println(timestamp)
print(time.Unix(1606444036+120,0))
print(strings.Count("asdfasdf","s"))
//时间戳转化为日期
datetime = time.Unix(timestamp, 0).Format(timeLayout)
fmt.Println(datetime)
testfn := func(str string) {
datetime = fmt.Sprintf("%s", time.Unix(int64(1000), 0).Format(str))
print(datetime)
}
testfn("01-02-2006 15:04:05")
testfn("01-02-0006 00022:04:05")
print(strings.Split("01020006", "-"))
// func (re *Regexp) ReplaceAllString(src, repl string) string
// func (re *Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string
// func (re *Regexp) ReplaceAllLiteralString(src, repl string) string
// ^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{8,16}$
// 分开来注释一下：
// ^ 匹配一行的开头位置
// (?![0-9]+$) 预测该位置后面不全是数字
// (?![a-zA-Z]+$) 预测该位置后面不全是字母
// [0-9A-Za-z] {8,16} 由8-16位数字或这字母组成
// $ 匹配行结尾位置
pat := `([A-Za-z0-9]+)\s*=\s*([A-Za-z0-9]+)`
src := ` abc = d23 abc1 = f456 `
reg := regexp.MustCompile(pat)
put := reg.ReplaceAllStringFunc(src, func(str string) string {
print(str)
return str+"end"
})
print(put)
lss := reg.FindAllStringSubmatch(src, -1)
print(lss)
pats := `(<cr:[f0-9]{6}>([a-zA-Z0-9])</>)`
regs := regexp.MustCompile(pats)
strco := `ni mail to this <cr:ff3ff6>sdfasd</>mm`
lsss := regs.FindAllStringSubmatch(strco, -1)
print(lsss)
print(strconv.QuoteToASCII("\u597adasdf你好fas12"))
print("-----------")
hasWord("\u597adasdf你好fas12")
}
// 一般字符 匹配自身 abc abc
// . 匹配任意除换行符"\n"外的字符， 在 DOTALL 模式中也能匹配换行符 a.c abc
// \ 转义字符，使后一个字符改变原来的意思；
// 如果字符串中有字符 * 需要匹配，可以使用 * 或者字符集［]。 a.c
// a\c a.c
// a\c
// [...] 字符集（字符类），对应的位置可以是字符集中任意字符。
// 字符集中的字符可以逐个列出，也可以给出范围，如 [abc] 或 [a-c]，
// 第一个字符如果是 ^ 则表示取反，如 [^abc] 表示除了abc之外的其他字符。 a[bcd]e abe 或 ace 或 ade
// \d 数字：[0-9] a\dc a1c
// \D 非数字：[^\d] a\Dc abc
// \s 空白字符：[<空格>\t\r\n\f\v] a\sc a c
// \S 非空白字符：[^\s] a\Sc abc
// \w 单词字符：[A-Za-z0-9] a\wc abc
// \W 非单词字符：[^\w] a\Wc a c
// 2) 数量词（用在字符或 (...) 之后）
// 语法 说明 表达式示例 匹配结果
// * 匹配前一个字符 0 或无限次 abc ab 或 abccc
// + 匹配前一个字符 1 次或无限次 abc+ abc 或 abccc
// ? 匹配前一个字符 0 次或 1 次 abc? ab 或 abc
// {m} 匹配前一个字符 m 次 ab{2}c abbc
// {m,n} 匹配前一个字符 m 至 n 次，m 和 n 可以省略，若省略 m，则匹配 0 至 n 次；
// 若省略 n，则匹配 m 至无限次 ab{1,2}c abc 或 abbc
// 3) 边界匹配
// 语法 说明 表达式示例 匹配结果
// ^ 匹配字符串开头，在多行模式中匹配每一行的开头 ^abc abc
// $ 匹配字符串末尾，在多行模式中匹配每一行的末尾 abc$ abc
// \A 仅匹配字符串开头 \Aabc abc
// \Z 仅匹配字符串末尾 abc\Z abc
// \b 匹配 \w 和 \W 之间 a\b!bc a!bc
// \B [^\b] a\Bbc abc
// 4) 逻辑、分组
// 语法 说明 表达式示例 匹配结果
// | | 代表左右表达式任意匹配一个，优先匹配左边的表达式 abc|def abc 或 def
// (...) 括起来的表达式将作为分组，分组将作为一个整体，可以后接数量词 (abc){2} abcabc
// (?P
// <number> 引用编号为
// (?P=name) 引用别名为
// 5) 特殊构造（不作为分组）
// 语法 说明 表达式示例 匹配结果
// (?:...) (…) 的不分组版本，用于使用 "|" 或后接数量词 (?:abc){2} abcabc
// (?iLmsux) iLmsux 中的每个字符代表一种匹配模式，只能用在正则表达式的开头，可选多个 (?i)abc AbC
// (?#...) # 后的内容将作为注释被忽略。 abc(?#comment)123 abc123
// (?=...) 之后的字符串内容需要匹配表达式才能成功匹配 a(?=\d) 后面是数字的 a
// (?!...) 之后的字符串内容需要不匹配表达式才能成功匹配 a(?!\d) 后面不是数字的 a
// (?<=...) 之前的字符串内容需要匹配表达式才能成功匹配 (?<=\d)a 前面是数字的a
// (?<!...) 之前的字符串内容需要不匹配表达式才能成功匹配 (?<!\d)a 前面不是数字的a
func hasWord(str string) {
txt := "abs123abs1234dfs32kkkl54"
//txt = strconv.QuoteToASCII(txt)
print(txt)
pat := ``
reg := regexp.MustCompile(pat)
ret := reg.FindAllStringSubmatch(txt, -1)
print(ret)
reg.ReplaceAllStringFunc2(txt, func(str []string) string {
print(str)
return str[0]
})
}
func (re Regexp) ReplaceAllStringFunc2(src string, repl func([]string) string) string {
b := re.replaceAll(nil, src, re.prog.NumCap, func(dst []byte, match []int) []byte {
slice := make([]string, len(match)/2)
for j := range slice {
if match[2j] >= 0 {
slice[j] = src[match[2j]:match[2j+1]]
}
}
return append(dst, repl(slice)...)
})
return string(b)
}
func replaceFunc(s []string) string {
n := 0
for i := 1; i < len(s); i++ {
ret, _ := strconv.Atoi(s[i])
n += ret
}
return strconv.Itoa(n)
}
func mainfi(){
repl := "1,10 1,50,12 1,12,5 1,20 1,3,2 "
place := regexp.MustCompile("(\d+),(\d+),(\d+)").ReplaceAllStringFunc2
repl = place(repl, replaceFunc)
fmt.Println(repl)
}
// FindAllStringSubmatch is the 'All' version of FindStringSubmatch; it
// returns a slice of all successive matches of the expression, as defined by
// the 'All' description in the package comment.
// A return value of nil indicates no match.