code.fastix.org

Dateiansicht:

Datei:Projekte -> PHP:Input-Spekulator für Zahlen und Währungen -> IS4NaC.php
md5:07f5366c5fe3c5ae5688d1db39dff92e
sha1:4fe700bfac99314763d6582ba85f8fe778e19a9d
Download-Link:Download
  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 formated.
  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 $roundMethod  = PHP_ROUND_HALF_EVEN;
  35.         private $maxDecimals  = 14;
  36.                
  37.         function __construct() {
  38.                
  39.                 /*
  40.                  * I think only Germans use the ',' as decimal-separator
  41.                 */
  42.                
  43.                 if ( isset ( $_SERVER['HTTP_ACCEPT_LANGUAGE'] ) ) {
  44.                         list( $FirstLang, $dummy ) = explode( ',', $_SERVER['HTTP_ACCEPT_LANGUAGE'], 2 );
  45.                         if ('de' == strtolower( $FirstLang ) ) {
  46.                                 $this -> arCommata=[','];
  47.                         } else {
  48.                                 $this -> arCommata=['.'];
  49.                         }
  50.                 }
  51.                 return true;
  52.         }
  53.                
  54.         function setValue( $s ) {
  55.                 $s = trim( preg_replace( '/^[^0-9,.-]*/', '', $s ) );
  56.                 if ( '' == $s ) {
  57.                         $this -> value = false;
  58.                         return false;
  59.                 }
  60.                 $mPos = strpos( $s, '-' );
  61.                 if ( 0 === $mPos or ( strlen( $s ) -1 ) == $mPos ) {
  62.                                 $prefix = -1;
  63.                 } else {
  64.                                 $prefix = 1;
  65.                 }
  66.  
  67.                 $kommata = false;
  68.                 if ( false !== strpos( $s, '.' ) and false !== strpos( $s, ',' ) ) {
  69.                         $arCommata = [ '.', ',' ];
  70.                 } else {
  71.                         $arCommata = $this -> arCommata;
  72.                 }
  73.                 #print_r( $arCommata ); echo "<br>";
  74.                 $posMin  = PHP_INT_MAX;
  75.                 $sRevers = strrev( $s );
  76.                 if ( count ( $arCommata ) ) {
  77.                         foreach ( $arCommata as $d ) {
  78.                                 if ( 1 == substr_count( $s, $d ) ) {
  79.                                         $pos = strpos( $sRevers, $d );
  80.                                         if ( false !== $pos && $pos < $posMin ) {
  81.                                                 $posMin  = $pos;
  82.                                                 $kommata = $d;
  83.                                         }
  84.                                 }
  85.                         }
  86.                 }
  87.                 if ( $kommata ) {
  88.                         list ( $intPart, $decPart ) = explode ( $kommata, $s, 2 );
  89.                         $intPart = preg_replace( '/[^0-9]/', '' , $intPart );
  90.                         $decPart = preg_replace( '/[^0-9]/', '' , $decPart );
  91.                         $val = (float)( "$intPart" . '.' . "$decPart" );
  92.                         if ( 0 > $val ) {
  93.                                 $this -> value = $val;
  94.                         } else {
  95.                                 $this -> value = $prefix * $val;
  96.                         }
  97.                 } else {
  98.                         $val = (float) preg_replace( '/[^0-9]/', '' , $s );
  99.                         if ( 0 > $val ) {
  100.                                 $this -> value = $val;
  101.                         } else {
  102.                                 $this -> value = $prefix * $val;
  103.                         }
  104.                 }
  105.                 return $this -> getFormated();
  106.         }
  107.        
  108.         function getFormated( $outputFormat = false ) {
  109.                         if ( false === $outputFormat ) {
  110.                                 $outputFormat = $this->outputFormat;
  111.                         }
  112.                         return sprintf( $outputFormat, $this -> getValueRounded() );
  113.         }
  114.        
  115.         function getValue () {
  116.                         return $this -> value;
  117.         }
  118.        
  119.         function getValueRounded () {
  120.                         return round( $this -> value, $this -> decimals, $this -> roundMethod );
  121.         }
  122.        
  123.         function setDecimals( $i ) {
  124.                 if ( false === $i ) {
  125.                         $this -> decimals = $this -> maxDecimals;
  126.                 }
  127.                 elseif ( $i == intval ( $i ) ) {
  128.                         $this -> decimals = intval( $i );
  129.                         return true;
  130.                 } else {
  131.                         return false;
  132.                 }      
  133.         }
  134.        
  135.         function setRoundMethod ( $RoundMethod ) {
  136.                 if ( in_array( $RoundMethod, array ( PHP_ROUND_HALF_UP, PHP_ROUND_HALF_DOWN, PHP_ROUND_HALF_EVEN, PHP_ROUND_HALF_ODD ) ) ) {
  137.                         $this -> roundMethod = $RoundMethod;
  138.                         return true;
  139.                 } else {
  140.                         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 );
  141.                 }
  142.         }
  143.  
  144. }
  145.  
  146. /** function Is4NaC (string [, $decimals=false [, $format='%01.2f' [, ]];
  147.  *
  148.  * This function use the class Is4NaC to try to become a float for input-strings in a row of international formats:
  149.  
  150.  * Parameters:
  151.  *
  152.  * @$string                                     : The input.
  153.  * @$decimals                           : Set the number of digits after the decimal point. If not set: 2.
  154.  * @$format                                     : Set the number-format for the return. if not set: '%01.2f'
  155.  * @roundMethod(const)          : Show http://php.net/manual/function.round.php
  156.  *
  157.  * @Return:
  158.  * string                                       : the rounded and formatet number
  159.  
  160. */
  161.  
  162. function Is4NaC ( $string, $decimals=false, $format='%01.2f', $roundMethod=PHP_ROUND_HALF_EVEN ) {
  163.         $is = new Is4NaC();
  164.         $is -> outputFormat = $format;
  165.         $is -> setDecimals ( $decimals );
  166.         $is -> setRoundMethod( $roundMethod );
  167.         $r = $is -> setValue( $string );
  168.         if ( false === $format or 'none' === $format )  {
  169.                 return $is->getValueRounded();
  170.         } elseif (false === $decimals )  {
  171.                 return $is->getValue();
  172.         } else {
  173.                 return $r;
  174.         }
  175. }
  176.