Co byś użył do zerowania pad numer w Flex/AS3?

Question

Duplikat numeru this.

Co byś użył do zera zer na lewo od liczby w Flex/AS3?

Czy istnieje odpowiednik printf lub NumberFormat, który to robi?

szukam najpiękniejszych realizacji tego lub czegoś podobnego:

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

Answer 1

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

Answer 2

zrobić utrzymać printf w AS3: Niestety przepełnienie stosu nie pozwoli mi linki pocztowe, ale jeśli Nazwa projektu kodu Google to printf-as3

Informacje zwrotne są zawsze mile widziane.

-

http://code.google.com/p/printf-as3/

Answer 3

/** 
* originally by Chris Agiasotis @ http://agitatedobserver.com/as3-currency-formatter/ 
* improved by Joseph Balderson @ http://www.joeflash.ca 
*/ 
package 
{ 
    public class CurrencyFormat 
    { 
     public function CurrencyFormat(){ } 

     public function getCurrency(num:Number, 
        decimalSeparator:String=".", 
        decimalPlace:Number=2, 
        currency:String="$", 
        thousandsSeparator: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(decimalPlace)); 

      //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 = String(cents); 

      var missingZeros:int = decimalPlace - centsFinal.length; 

      if (centsFinal.length < decimalPlace) 
      { 
       for (var j:int = 0; j < missingZeros; j++) 
       { 
        centsFinal += "0"; 
       } 
      } 

      var finalString:String = "" 

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

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

      return finalString; 
     } 
    } 
} 

Answer 4

Phil's wariant jako elegancki recursion:

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

nie wiem o jego skuteczności w AS3, ale na pewno wygląda chłodniej! :-)

Answer 5

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; 
} 

Answer 6

Bardzo krótki przykład wypełnianie zerami rutyny (AS2) ...

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

Answer 7

Bardzo kompaktowe rozwiązanie:

public function zeroPad(s:String,pad:int):String { 
    for(;s.length<pad;s='0'+s); 
    return s; 
} 

Answer 8

Performance-mądry, wolę za pomocą Stała łańcuchowa i substr, w ten sposób:

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; 
     } 
    } 
} 

Stała String ma bardzo mało footstampa w porównaniu z wycofywanymi ciągami wielokrotnego przeciągania ciągu jedna po cyfrze. W większości przypadków (do 40 zer w tym przykładzie) liczba instrukcji jest taka sama dla wszystkich połączeń.