What would you use to zero pad a number in Flex/AS3?

Question

Duplicate of this one.

What would you use to pad zeroes to the left of a number in Flex/AS3?

Is there an equivalent to printf or NumberFormat that does this?

I'm looking for the nicest implementation of this or something similar:

public function zeroPad(number:int, width:int):String {
    // number = 46, width = 4 would return "0046"
}

Solution 1

public function zeroPad(number:int, width:int):String {
   var ret:String = ""+number;
   while( ret.length < width )
       ret="0" + ret;
   return ret;
}

Solution 2

Performance-wise, I prefer using a String constant and substr, like this:

package {
    public class Helper {
        private static const _ZEROS:String = "0000000000000000000000000000000000000000"; // 40 zeros, shorten/expand as you wish

        /*
         * f: positive integer value
         * z: maximum number of leading zeros of the numeric part (sign takes one extra digit)
         */
        public static function uint_Zeropadded(f:uint, z:int = 0):String {
            var result:String = f.toString();
            while (result.length < z)
                result = _ZEROS.substr(0, z - result.length) + result;
            return result;
        }
    }
}

The String constant has very little footstamp compared to the performance draw-backs of extending the string one by one digit numerous times. In most cases (up to 40 zeros in this example) number of instructions is the same for all calls.

Solution 3

Phil's variant as an elegant recursion:

public function zeroPad (number:String, width:int):String {
    if (number.length < width)
        return "0" + zeroPad(number, width-1);
    return number;
}

I don't know of its performance on AS3 but it sure looks cooler! :-)

Solution 4

public static function getFormatedValue(num:Number, roundDecimalPlace:Number=2, showLastZerosInDecimalPlaces:Boolean = false, decimalSeparator:String=".", thousandsSeparator:String=",", currency:String="$"):String
{
  //assigns true boolean value to neg in number less than 0
  var neg:Boolean = (num < 0);

  //make the number positive for easy conversion
  num = Math.abs(num)

  var roundedAmount:String = String(num.toFixed(roundDecimalPlace));

  //split string into array for dollars and cents
  var amountArray:Array = roundedAmount.split(".");
  var dollars:String = amountArray[0]
  var cents:String = amountArray[1]

  //create dollar amount
  var dollarFinal:String = ""
  var i:int = 0
  for (i; i < dollars.length; i++)
  {
    if (i > 0 && (i % 3 == 0 ))
    {
      dollarFinal = thousandsSeparator + dollarFinal;
    }

    dollarFinal = dollars.substr( -i -1, 1) + dollarFinal;
  }       

  //create Cents amount and zeros if necessary
  var centsFinal:String;

  if(showLastZerosInDecimalPlaces)
  {
    centsFinal = String(cents);

    var missingZeros:int = roundDecimalPlace - centsFinal.length;

    if (centsFinal.length < roundDecimalPlace)
    {
      for (var j:int = 0; j < missingZeros; j++) 
      {
        centsFinal += "0";
      }
    }
  }
  else
  {
    if(Number(cents) != 0)
    {
      centsFinal = String(String(Number("0."+cents)).split(".")[1]);
    }
    else
    {
      roundDecimalPlace = 0;
    }
  }

  var finalString:String = ""

  if (neg)
  {
    finalString = "-"+currency + dollarFinal
  } else
  {
    finalString = currency + dollarFinal
  }

  if(roundDecimalPlace > 0)
  {
    finalString += decimalSeparator + centsFinal;
  } 

  return finalString;
}

Solution 5

Very short example of zero padding routine (AS2)...

    Convert = function(Minutes) {
       return ('00'+String(int(Minutes/60)%24)).substr(-2,2);
    }

View more solutions

Comments

[Bron Davies]

recursion should be avoided whenever possible and it almost always is possible

[cregox]

@stinkbutt in this case, recursion makes more sense. I believe it's something not taught in many programming courses because it's not as intuitive as a loop and, in fact, it is more limiting than a loop. But saying it should be avoided whenever possible is a bit extreme. I'd say use recursion with caution and keep it small, because it can get really complicated for no good reason.

[Bron Davies]

The reason I say that is because a stack overflow is more likely when you use recursion - it may not be apparent right away but in the long term, you can inadvertently create a situation where a lot of data coupled with even just a couple of recursive methods will bring your application or script to its knees.

[cregox]

@stinkbutt well, if that's true to actionscript I wouldn't know, and then I have to agree with you to avoid it always, because it is always avoidable. But recursion exists in programming languages prior to loops and it should never be "more likely" to generate overflows with 'em.

[FlavorScape]

The reason to use recursion is for clarity when the problem is better suited to reducible problems. An iterative approach is nearly always faster and more efficient than a recursive approach.

[FlavorScape]

Recursing puts the memory on the stack (afterall, it has to retain all the previous state for each iteration), hence potential for stack overflow if the depth is high, or the memory low.

[cregox]

@FlavorScape nope, iterative isn't nearly nor farly always faster. But there's more to it and it's already "discussed" on another question. In short I like this saying: "write it the way that's clearer to read". I think in this case Phil is easier to read, but I only wrote this answer because I was feeling like going recursive! ;-)

[FlavorScape]

I believe as3 is of the family where a new stackframe is created for each recursion, no? That's a lot of memcopy and a lot of mem for deep recursions. obviously not the case here of course.