Method AsNumber

string.go:1103–1193

AsNumber parses float from string and returns a new Number instance with result. If base is 10 or omitted, uses strconv.ParseFloat. Otherwise, uses strconv.ParseInt or strconv.ParseUint with given base. Example: str := NewString(t, "100") str.AsNumber().IsEqual(100) Specifying base: str.AsNu

(base ...int)

//	str.AsNumber(10).IsEqual(100)
//	str.AsNumber(16).IsEqual(256)
func (s *String) AsNumber(base ...int) *Number {
	opChain := s.chain.enter("AsNumber()")
	defer opChain.leave()

	if opChain.failed() {
		return newNumber(opChain, 0)
	}

	if len(base) > 1 {
		opChain.fail(AssertionFailure{
			Type: AssertUsage,
			Errors: []error{
				errors.New("unexpected multiple base arguments"),
			},
		})
		return newNumber(opChain, 0)
	}

	b := 10
	if len(base) != 0 {
		b = base[0]
	}

	var fnum float64
	var inum int64
	var unum uint64
	var err error

	inum, err = strconv.ParseInt(s.value, b, 64)
	fnum = float64(inum)

	if err == nil && int64(fnum) != inum {
		opChain.fail(AssertionFailure{
			Type:   AssertValid,
			Actual: &AssertionValue{s.value},
			Errors: []error{
				errors.New("expected:" +
					" number can be represented as float64 without precision loss"),
			},
		})
		return newNumber(opChain, 0)
	}

	if err != nil && errors.Is(err, strconv.ErrRange) {
		unum, err = strconv.ParseUint(s.value, b, 64)
		fnum = float64(unum)

		if err == nil && uint64(fnum) != unum {
			opChain.fail(AssertionFailure{
				Type:   AssertValid,
				Actual: &AssertionValue{s.value},
				Errors: []error{
					errors.New("expected:" +
						" number can be represented as float64 without precision loss"),
				},
			})
			return newNumber(opChain, 0)
		}