ReadOperator.go

package main

import (
	"fmt"
	"math/big"
)

// ComparisonOperator는 다양한 비교 연산을 수행하는 구조체입니다.
type ComparisonOperator struct{}

// Eq 함수는 두 값이 같은지 확인합니다.
func (co *ComparisonOperator) Eq(vars []interface{}) bool {
	left, right := co.parseVars(vars)
	if left != nil && right != nil {
		return left.Cmp(right) == 0
	}
	return vars[0] == vars[1]
}

// Ne 함수는 두 값이 다른지 확인합니다.
func (co *ComparisonOperator) Ne(vars []interface{}) bool {
	left, right := co.parseVars(vars)
	if left != nil && right != nil {
		return left.Cmp(right) != 0
	}
	return vars[0] != vars[1]
}

// Gt 함수는 첫 번째 값이 두 번째 값보다 큰지 확인합니다.
func (co *ComparisonOperator) Gt(vars []interface{}) bool {
	left, right := co.parseVars(vars)
	if left != nil && right != nil {
		return left.Cmp(right) > 0
	}
	return vars[0].(string) > vars[1].(string)
}

// Gte 함수는 첫 번째 값이 두 번째 값보다 크거나 같은지 확인합니다.
func (co *ComparisonOperator) Gte(vars []interface{}) bool {
	left, right := co.parseVars(vars)
	if left != nil && right != nil {
		return left.Cmp(right) >= 0
	}
	return vars[0].(string) >= vars[1].(string)
}

// Lt 함수는 첫 번째 값이 두 번째 값보다 작은지 확인합니다.
func (co *ComparisonOperator) Lt(vars []interface{}) bool {
	left, right := co.parseVars(vars)
	if left != nil && right != nil {
		return left.Cmp(right) < 0
	}
	return vars[0].(string) < vars[1].(string)
}

// Lte 함수는 첫 번째 값이 두 번째 값보다 작거나 같은지 확인합니다.
func (co *ComparisonOperator) Lte(vars []interface{}) bool {
	left, right := co.parseVars(vars)
	if left != nil && right != nil {
		return left.Cmp(right) <= 0
	}
	return vars[0].(string) <= vars[1].(string)
}

// parseVars 함수는 두 값을 *big.Float 타입으로 변환합니다.
func (co *ComparisonOperator) parseVars(vars []interface{}) (*big.Float, *big.Float) {
	left, ok1 := co.toBigFloat(vars[0])
	right, ok2 := co.toBigFloat(vars[1])
	if ok1 && ok2 {
		return left, right
	}
	return nil, nil
}

// toBigFloat 함수는 값을 *big.Float 타입으로 변환합니다.
func (co *ComparisonOperator) toBigFloat(val interface{}) (*big.Float, bool) {
	switch v := val.(type) {
	case int:
		return big.NewFloat(float64(v)), true
	case int64:
		return big.NewFloat(float64(v)), true
	case float64:
		return big.NewFloat(v), true
	case string:
		f, _, err := big.ParseFloat(v, 10, 0, big.ToNearestEven)
		if err == nil {
			return f, true
		}
	}
	return nil, false
}

func main() {
	co := &ComparisonOperator{}
	vars := []interface{}{"123.45", "123.45"}

	fmt.Println("Eq:", co.Eq(vars))   // true
	fmt.Println("Ne:", co.Ne(vars))   // false
	fmt.Println("Gt:", co.Gt(vars))   // false
	fmt.Println("Gte:", co.Gte(vars)) // true
	fmt.Println("Lt:", co.Lt(vars))   // false
	fmt.Println("Lte:", co.Lte(vars)) // true
}

코드 설명

1. ComparisonOperator 구조체

   • 다양한 비교 연산을 수행하는 메서드들을 정의한 구조체입니다.

2. Eq 함수

   • 두 값이 같은지 확인합니다.

   • 숫자 값은 *big.Float 타입으로 변환하여 비교합니다.

   • 변환된 값이 nil이 아니면 Cmp 메서드로 비교하고, 그렇지 않으면 기본 비교 연산을 사용합니다.

3. Ne 함수

   • 두 값이 다른지 확인합니다.

   • 숫자 값은 *big.Float 타입으로 변환하여 비교합니다.

   • 변환된 값이 nil이 아니면 Cmp 메서드로 비교하고, 그렇지 않으면 기본 비교 연산을 사용합니다.

4. Gt 함수

   • 첫 번째 값이 두 번째 값보다 큰지 확인합니다.

   • 숫자 값은 *big.Float 타입으로 변환하여 비교합니다.

   • 변환된 값이 nil이 아니면 Cmp 메서드로 비교하고, 그렇지 않으면 문자열 비교 연산을 사용합니다.

5. Gte 함수

   • 첫 번째 값이 두 번째 값보다 크거나 같은지 확인합니다.

   • 숫자 값은 *big.Float 타입으로 변환하여 비교합니다.

   • 변환된 값이 nil이 아니면 Cmp 메서드로 비교하고, 그렇지 않으면 문자열 비교 연산을 사용합니다.

6. Lt 함수

   • 첫 번째 값이 두 번째 값보다 작은지 확인합니다.

   • 숫자 값은 *big.Float 타입으로 변환하여 비교합니다.

   • 변환된 값이 nil이 아니면 Cmp 메서드로 비교하고, 그렇지 않으면 문자열 비교 연산을 사용합니다.

7. Lte 함수

   • 첫 번째 값이 두 번째 값보다 작거나 같은지 확인합니다.

   • 숫자 값은 *big.Float 타입으로 변환하여 비교합니다.

   • 변환된 값이 nil이 아니면 Cmp 메서드로 비교하고, 그렇지 않으면 문자열 비교 연산을 사용합니다.

8. parseVars 함수

   • 두 값을 *big.Float 타입으로 변환합니다.

9. toBigFloat 함수

   • 주어진 값을 *big.Float 타입으로 변환합니다.

   • int, int64, float64, string 타입을 처리합니다.

main 함수

• ComparisonOperator 구조체의 인스턴스를 생성하고 다양한 비교 연산을 수행합니다.

• 각 연산 결과를 출력합니다.

이 코드는 다양한 데이터 타입에 대해 비교 연산을 수행하며, 특히 숫자 값을 *big.Float 타입으로 변환하여 정확한 비교를 수행합니다.