icyxp / util Goto Github PK

 type Data struct {
     Name string
     Age int
 }

 func Struct2Map(data Data) {
     m := make(map[string]interface{})
     t := reflect.TypeOf(data)
     v := reflect.ValueOf(data)
 
     for i := 0; i < t.NumField(); i++ {
 	    if !v.Field(i).IsZero() {
 		    m[t.Field(i).Name] = v.Field(i).Interface()
 		}
     }
 }

func LookUp(array []int32, targetNum int32) (num1, num2 int32) {
	left := 0
	right := len(array) - 1
	for i := 0; i < len(array); i++ {
		if array[left]+array[right] > targetNum {
			right--
		} else if array[left]+array[right] < targetNum {
			left++
		} else {
			num1, num2 = array[left], array[right]
			return
		}
	}
	return
}

func IsStrEqual(s1, s2 string) bool {
	if len(s1) != len(s2) {
		return false
	}
	for i := range s1 {
		if s1[i] != s2[i] {
			return false
		}
	}
	return true
}

func ReverseSlice(s []interface{}) {
	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
		s[i], s[j] = s[j], s[i]
	}
}

func IsExistItem(value interface{}, array interface{}) bool {
    switch reflect.TypeOf(array).Kind() {
        case reflect.Slice:
        s := reflect.ValueOf(array)
        for i := 0; i < s.Len(); i++ {
            if reflect.DeepEqual(value, s.Index(i).Interface()) {
                return true
            }
        }
    }
    return false
}

func CopyFile(destName, sourceName string) (int64, error) {
    src, err := os.Open(sourceName)
    if err != nil {
        panic(err)
    }
    defer src.Close()
    
    dest, err := os.Create(destName)
    if err != nil {
        panic(err)
    }
    defer dest.Close()
    return io.Copy(dest, src)
}

func IsMapEqual(m1, m2 map[int]int) bool {
	if len(m1) != len(m2) {
		return false
	}
	for k, m1V := range m1 {
		if m2V, ok := m2[k]; !ok || m2V != m1V {
			return false
		}
	}
	return true
}

func IsContainAll(x, y []string) bool {
    for len(y) <= len(x) {
        if len(y) == 0 {
            return true
        }
        if y[0] == x[0] {
            y = y[1:]
        }
        x = x[1:]
    }
}

import "fmt"

type options struct {
    a int64
    b string
    c map[int]string
}

func NewOption(opt ...ServerOption) *options {
    r := new(options)
    for _, o := range opt {
        o(r)
    }
    return r
}

type ServerOption func(*options)

func WriteA(s int64) ServerOption {
    return func(o *options) {
        o.a = s
    }
}

func WriteB(s string) ServerOption {
    return func(o *options) {
        o.b = s
    }
}

func WriteC(s map[int]string) ServerOption {
    return func(o *options) {
        o.c = s
    }
}

func main() {
    opt1 := WriteA(int64(1))
    opt2 := WriteB("test")
    opt3 := WriteC(make(map[int]string, 0))
    op := NewOption(opt1, opt2, opt3)
    fmt.Println(op.a, op.b, op.c)
}

//
func RemoveRepByLoop(slc []int) []int {
    result := []int{}
    for i := range slc {
        flag := true
        for j := range result {
            if slc[i] == result[j] {
                flag = false
                break
            }
        }
        if flag {
            result = append(result, slc[i])
        }
    }
    return result
}

//通过map转换
func RemoveRepByMap(slc []int) []int {
	result := make([]int, 0)
	tempMap := make(map[int]byte, 0)
	for _, e := range slc {
		l := len(tempMap)
		tempMap[e] = 0
		if len(tempMap) != l {
			result = append(result, e)
		}
	}
	return result
}

   func MaxSubStrLen(str string) int {
   	var maxLen int
   	var start int
   	m := make(map[rune]int)
   	for i, ch := range []rune(str) {
   		if lastIndex, ok := m[ch]; ok && lastIndex >= start {
   			start = lastIndex + 1
   		}
   		if i-start+1 > maxLen {
   			maxLen = i - start + 1
   		}
   		m[ch] = i
   	}
   	return maxLen
   } 

    func ConvertToBinary(data int) string {
    	result := ""
    	for ; data > 0; data = data / 2 {
    		n := data % 2
    		result = strconv.Itoa(n) + result
    	}
    	return result
    }