code.fastix.org

Dateiansicht:

Datei:Projekte -> PHP:Input-Spekulator für Zahlen und Währungen -> IS4NaC.php
md5:839103c8fb406584605f7dbbabeab938
sha1:84b5a7b5e34c7db320e4e6c412789237e16f18fa
  1. <?php
  2. /** class Is4NaC
  3.  * @author: Jörg Reinholz, fastix WebDesign & Consult, Kassel (Germany), https://www.fastix.org
  4.  * @License: GPL, LGPL or MPL. Show https://code.fastix.org/lizenz.php
  5.  *
  6.  * This class try to become a float for input-strings in a row of international formats:
  7.  * - Many peoples using the point as as decimal-delimiter a few of chars as thousender-delimiter.
  8.  * - Germans use using the komma (",") as decimal-delimiter an the pooint as thousender-delimiter.
  9.  * - minus sign at the beginning, minus sign at the end
  10.  *
  11.  * Public-Propertys:
  12.  *
  13.  * @$outputFormat: String. Show http://php.net/manual/function.sprintf.php
  14.  *
  15.  * Methods:
  16.  *
  17.  * @setValue(string)            : input the string, save the number, returns the formatet number or false
  18.  * @setDecimals(integer)        : Set the number of digits after the decimal point.
  19.  * @setRoundMethod(const)       : Show http://php.net/manual/function.round.php
  20.  *
  21.  * @getValue                            : returns the formatet number or false
  22.  * @getValueRounded()           : Get the safed number rounded
  23.  * @getFormated()                       : Get the safed number rounded and formatet.
  24. */
  25.  
  26. class Is4NaC {
  27.         # Input-speculator for Numbers & Currency
  28.        
  29.         public  $outputFormat = '€ %01.2f';
  30.         private $decimals     = 2;
  31.         private $input         = '';
  32.         private $value        = 0;
  33.         private $arCommata    = array( '.', ',' );
  34.         private $arDelimiters = false ;
  35.         private $roundMethod  = PHP_ROUND_HALF_EVEN;
  36.         private $maxDecimals  = 14;
  37.                
  38.         function __construct() {
  39.                 $this -> arDelimiters = array(
  40.                         ' ',
  41.                         '\'',
  42.                         html_entity_decode( '&#x00A0;', ENT_XML1, 'UTF-8' ),
  43.                         html_entity_decode( '&#x202F;', ENT_XML1, 'UTF-8' ),
  44.                         html_entity_decode( '&#xFEFF;', ENT_XML1, 'UTF-8' ),
  45.                         html_entity_decode( '&#x0020;', ENT_XML1, 'UTF-8' ),
  46.                         html_entity_decode( '&#x2002;', ENT_XML1, 'UTF-8' ),
  47.                         html_entity_decode( '&#x2003;', ENT_XML1, 'UTF-8' ),
  48.                         html_entity_decode( '&#x2004;', ENT_XML1, 'UTF-8' ),
  49.                         html_entity_decode( '&#x2005;', ENT_XML1, 'UTF-8' ),
  50.                         html_entity_decode( '&#x2006;', ENT_XML1, 'UTF-8' ),
  51.                         html_entity_decode( '&#x2007;', ENT_XML1, 'UTF-8' ),
  52.                         html_entity_decode( '&#x2600;', ENT_XML1, 'UTF-8' ),
  53.                         html_entity_decode( '&#x180E;', ENT_XML1, 'UTF-8' )
  54.                 );     
  55.                 return true;
  56.         }
  57.                
  58.         function setValue( $s ) {
  59.                 $s = trim( $s );
  60.                 if ('' == $s) {
  61.                         $this -> value = false;
  62.                         return false;
  63.                 }
  64.                 $mPos = strpos( $s, '-' );
  65.                 if ( 0 === $mPos or ( strlen( $s ) -1 ) == $mPos ) {
  66.                                 $prefix=-1;
  67.                 } else {
  68.                                 $prefix=1;
  69.                 }
  70.                 if ( is_int( $s )  || is_float( $s ) ) {
  71.                         $this -> value = floatval( $prefix * $s );
  72.                 } else {
  73.                         $s = str_replace( $this -> arDelimiters, '', $s);
  74.                         if ('' == $s) {
  75.                                 $this -> value = false;
  76.                                 return false;
  77.                         }                      
  78.                         $sRevers = strrev( $s );
  79.                         $kommata = false;
  80.                         $posMin  = strlen( $s );
  81.                         foreach ( $this -> arCommata as $d ) {
  82.                                 $pos = strpos( $sRevers, $d );
  83.                                 if ( false !== $pos && $pos < $posMin ) {
  84.                                         $posMin = $pos;
  85.                                         if ( 1 == substr_count ( $s , $d )  ) {
  86.                                                 $kommata = $d;
  87.                                         }
  88.                                 }
  89.                         }
  90.                         if ( $kommata ) {
  91.                                         list ( $intPart, $decPart ) = explode ($kommata, $s, 2 );
  92.                                         $intPart = preg_replace( '/[^0-9]/', '' , $intPart );
  93.                                         $val = floatval( "$intPart" . '.' . "$decPart" );
  94.                                         $this -> value = floatval( $prefix * $val );
  95.                         } else {
  96.                                         $this -> value = floatval( $prefix * $s );
  97.                         }
  98.                        
  99.                 }
  100.                
  101.                 return $this -> getFormated();
  102.         }
  103.        
  104.         function getFormated( $outputFormat = false ) {
  105.                         if ( false === $outputFormat ) {
  106.                                 $outputFormat = $this->outputFormat;
  107.                         }
  108.                         return sprintf( $outputFormat, $this -> getValueRounded() );
  109.         }
  110.        
  111.         function getValue () {
  112.                         return $this -> value;
  113.         }
  114.        
  115.         function getValueRounded () {
  116.                         return round( $this -> value, $this -> decimals, $this -> roundMethod );
  117.         }
  118.        
  119.         function setDecimals( $i ) {
  120.                 if ( false === $i ) {
  121.                         $this -> decimals = $this -> maxDecimals;
  122.                 }
  123.                 elseif ( $i == intval ( $i ) ) {
  124.                         $this -> decimals = intval( $i );
  125.                         return true;
  126.                 } else {
  127.                         return false;
  128.                 }      
  129.         }
  130.        
  131.         function setRoundMethod ( $RoundMethod ) {
  132.                 if ( in_array( $RoundMethod, array ( PHP_ROUND_HALF_UP, PHP_ROUND_HALF_DOWN, PHP_ROUND_HALF_EVEN, PHP_ROUND_HALF_ODD ) ) ) {
  133.                         $this -> roundMethod = $RoundMethod;
  134.                         return true;
  135.                 } else {
  136.                         trigger_error( "(Caller: ) $RoundMethod not known. Only PHP_ROUND_HALF_UP, PHP_ROUND_HALF_DOWN, PHP_ROUND_HALF_EVEN, PHP_ROUND_HALF_ODD are allowed.", E_USER_ERROR );
  137.                 }
  138.         }
  139.  
  140. }
  141.  
  142. /** function Is4NaC (string [, $decimals=false [, $format='%01.2f' [, ]];
  143.  *
  144.  * This function use the class Is4NaC to try to become a float for input-strings in a row of international formats:
  145.  
  146.  * Parameters:
  147.  *
  148.  * @$string                                     : The input.
  149.  * @$decimals                           : Set the number of digits after the decimal point. If not set: 2.
  150.  * @$format                                     : Set the number-format for the return. if not set: '%01.2f'
  151.  * @roundMethod(const)          : Show http://php.net/manual/function.round.php
  152.  *
  153.  * @Return:
  154.  * string                                       : the rounded and formatet number
  155.  
  156. */
  157.  
  158. function Is4NaC ( $string, $decimals=false, $format='%01.2f', $roundMethod=PHP_ROUND_HALF_EVEN ) {
  159.         $is = new Is4NaC();
  160.         $is -> outputFormat = $format;
  161.         $is -> setDecimals ( $decimals );
  162.         $is -> setRoundMethod( $roundMethod );
  163.         $r = $is -> setValue( $string );
  164.         if ( false === $format or 'none' === $format )  {
  165.                 return $is->getValueRounded();
  166.         } elseif (false === $decimals )  {
  167.                 return $is->getValue();
  168.         } else {
  169.                 return $r;
  170.         }
  171. }
  172.