Golang之Slice处理

func EqualSlice(slice1, slice2 interface{}) bool {
	if slice2 == nil || slice1 == nil {
		return false
	}
	if reflect.TypeOf(slice1).Kind() != reflect.TypeOf(slice2).Kind() || reflect.ValueOf(slice1).Index(0).Kind() != reflect.ValueOf(slice2).Index(0).Kind() {
		return false
	}
	if reflect.TypeOf(slice1).Kind() != reflect.Slice && reflect.TypeOf(slice1).Kind() != reflect.Array {
		return false
	}

	if reflect.ValueOf(slice1).Len() == reflect.ValueOf(slice2).Len() && ContainsSlice(slice1, slice2) {
		return true
	}
	return false
}


func EqualSliceE(slice1, slice2 interface{}) (bool, error) {
	if slice2 == nil || slice1 == nil {
		return false, errors.New("input param has nil")
	}
	if reflect.TypeOf(slice1).Kind() != reflect.TypeOf(slice2).Kind() || reflect.ValueOf(slice1).Index(0).Kind() != reflect.ValueOf(slice2).Index(0).Kind() {
		return false, errors.New("input param has different kind")
	}
	if reflect.TypeOf(slice1).Kind() != reflect.Slice && reflect.TypeOf(slice1).Kind() != reflect.Array {
		return false, errors.New("invalid type")
	}

	if reflect.ValueOf(slice1).Len() == reflect.ValueOf(slice2).Len() && ContainsSlice(slice1, slice2) {
		return true, nil
	}
	return false, nil
}

func ContainsSlice(slice1, slice2 interface{}) bool {
	if slice2 == nil || slice1 == nil {
		return false
	}
	if reflect.TypeOf(slice1).Kind() != reflect.TypeOf(slice2).Kind() || reflect.ValueOf(slice1).Index(0).Kind() != reflect.ValueOf(slice2).Index(0).Kind() {
		return false
	}
	sli2 := reflect.ValueOf(slice2)
	for i := 0; i < sli2.Len(); i++ {
		if !ContainsInSlice(slice1, sli2.Index(i).Interface()) {
			return false
		}
	}
	return true
}

func ContainsSliceE(slice1, slice2 interface{}) (bool, error) {
	if slice2 == nil || slice1 == nil {
		return false, errors.New("input param has nil")
	}
	if reflect.TypeOf(slice1).Kind() != reflect.TypeOf(slice2).Kind() || reflect.ValueOf(slice1).Index(0).Kind() != reflect.ValueOf(slice2).Index(0).Kind() {
		return false, errors.New("input param has different kind")
	}
	sli2 := reflect.ValueOf(slice2)
	for i := 0; i < sli2.Len(); i++ {
		if !ContainsInSlice(slice1, sli2.Index(i).Interface()) {
			return false, nil
		}
	}
	return true, nil
}

func ContainsInSlice(slice interface{}, elem interface{}) bool {
	if slice == nil {
		return false
	}
	switch reflect.TypeOf(slice).Kind() {
	case reflect.Slice, reflect.Array:
		if reflect.ValueOf(slice).Index(0).Kind() != reflect.TypeOf(elem).Kind() {
			return false
		}
		sli := reflect.ValueOf(slice)
		for i := 0; i < sli.Len(); i++ {
			if reflect.DeepEqual(sli.Index(i).Interface(), elem) {
				return true
			}
		}
	default:
		return false
	}
	return false
}

func ContainsInSliceE(slice interface{}, elem interface{}) (bool, error) {
	if slice == nil {
		return false, errors.New("input param is nil")
	}
	switch reflect.TypeOf(slice).Kind() {
	case reflect.Slice, reflect.Array:
		if reflect.ValueOf(slice).Index(0).Kind() != reflect.TypeOf(elem).Kind() {
			return false, errors.New("input param has different kind")
		}
		sli := reflect.ValueOf(slice)
		for i := 0; i < sli.Len(); i++ {
			if reflect.DeepEqual(sli.Index(i).Interface(), elem) {
				return true, nil
			}
		}
	default:
		return false, errors.New("invalid type")
	}
	return false, nil
}

func MultipyQuantityWithStr(str string, f float64) (resource.Quantity, error) {
	if len(str) == 0 {
		return resource.Quantity{}, errors.New("input has error")
	}
	if str == "0" {
		return resource.Quantity{Format: resource.DecimalSI}, nil
	}
	oldQuantity, err := resource.ParseQuantity(str)
	if err != nil {
		return resource.Quantity{}, err
	}
	newInt := cast.ToInt64(cast.ToFloat64(oldQuantity.Value()) * f)
	newQuantity := resource.NewQuantity(newInt, oldQuantity.Format)
	return *newQuantity, nil
}

func MultipyQuantityWithQuantity(oldQuantity resource.Quantity, f float64) (resource.Quantity, error) {
	newInt := cast.ToInt64(cast.ToFloat64(oldQuantity.Value()) * f)
	newQuantity := resource.NewQuantity(newInt, oldQuantity.Format)
	return *newQuantity, nil
}