带spark.formatters.NumberFormatter的分隔符后不超过9位？

Question

我必须在使用spark.formatters.NumberFormatter的Flex-AdvancedDataGrid中显示非常小的值(电容)。如果我对fractionalDigits使用3、6或9，一切都很好。

但是如果我使用12，因为我需要在小数点分隔符后面加上12位数字，那么这个值在9位数字之后就被截断了！

有没有办法在分隔符之后得到9位以上的数字？

或者有没有办法使用像“4.7E-12”这样的格式(必须是E-9、E-12、E-15等等)

Answer 1

toPrecision和toFixed在20位数字的情况下都能正常工作。这就够了。我会在这个基础上写一个函数来得到像4.7E-12这样的结果。

谢谢你的帮助Jan

Answer 2

我创建了a custom pattern formatter class，它允许您指定如何使用所需的符号或结构格式化字符串/数字。根据您的需求，这可能会对您有所帮助。如果需要，可以随意修改这个类。

CustomPatternFormatter.as

package
{
    import mx.formatters.Formatter;

    public class CustomPatternFormatter extends Formatter
    {
        private static const VALID_PATTERN_CHARACTERS:String = "#,.-";

        // Use # as a placeholder for a regular
        // character in the input string.
        // Then add other characters between the
        // # symbol for the desired output format.
        // ex. The pattern ##,##,##.## with input 12345678
        // will output 12,34,56.78
        public var formatPattern:String;

        // If True, the input string must match the number
        // of # characters in the formatPattern.
        public var inputMustMatchPatternLength:Boolean;

        //Constructor
        public function CustomPatternFormatter()
        {
            super();
            formatPattern = "";
            inputMustMatchPatternLength = false;
        }

        // Override format().
        override public function format(value:Object):String
        {
            // Reset error if it exists.
            if (error)
                error = null;

            // If value is null, or empty String just return ""
            // but treat it as an error for consistency.
            // Users will ignore it anyway.
            if (!value || (value is String && value == ""))
            {
                error = "Cannot convert an empty value";
                return "";
            }

            // Check to see if the input value must match the format pattern
            if (inputMustMatchPatternLength && String(value).length != countOccurrences(formatPattern, "#"))
            {
                error = "The input value length does not match the format pattern length.";
                return "";
            }

            // If the value is valid, format the string.
            var fStrLen:int = 0;
            var letter:String;
            var n:int;
            var i:int;
            var v:int;

            // Make sure the formatString is valid.
            n = formatPattern.length;
            for (i = 0; i < n; i++)
            {
                letter = formatPattern.charAt(i);
                if (letter == "#")
                {
                    fStrLen++;
                }
                else if (VALID_PATTERN_CHARACTERS.indexOf(letter) == -1)
                {
                    error = "You can only use the following symbols in the formatPattern: " + VALID_PATTERN_CHARACTERS;
                    return "";
                }
            }

            var returnString:String = "";
            var vStr:String = String(value).replace(".", "").split("").reverse().join("");
            var fArr:Array = formatPattern.split("").reverse();
            var fChar:String;

            // Format the string
            for (v = 0; v < vStr.length; v++)            {                   if (fArr.length > 0)
                {
                    do
                    {
                        fChar = fArr.shift();

                        if (fChar != "#")
                            returnString += fChar;

                    } while (fChar != "#" && fArr.length > 0);
                }

                returnString += vStr.charAt(v);
            }

            // Return the formatted string
            return returnString.split("").reverse().join("");
        }

        protected function countOccurrences(str:String, char:String):int
        {
            var count:int = 0;
            for (var i:int=0; i < str.length; i++)
            {
                if (str.charAt(i) == char)
                {
                    count++;
                }
            }
            return count;
        }
    }
}