isValidNumber

philosophology

I have function as such:

function isValidNumber($n) {
   if (ereg('^[0-9]$', $n))
     return true;
   elseif (ereg('^[0-9]+\.[0-9]{1}$', $n))
     return true;
   elseif (ereg('^[0-9]+\.[0-9]{2}$', $n)) 
     return true;  

   else  

     return false;
}

The problem is that it will recognize 00.25 as a valid number and .25 as a bad number!

HELP!

I want something fool-proof to filter currency.

Horizon88

How's this suit you?

function isValidNumber(&$n) {
   return preg_match('/^([0-9]+)?\.?([0-9]{2})?$/', $n);
}

Results of my tests:

Valid tests: 
Array
(
    [0] => 1000
    [1] => 10.00
    [2] => 100.04
    [3] => 100
    [4] => 100.00
    [5] => 0
    [6] => 00.25
    [7] => .25
)
Invalid tests: 
Array
(
    [0] => 10.0111
)

nrg_alpha

Horizon88;10918862 wrote:
How's this suit you?
function isValidNumber(&$n) {
   return preg_match('/^([0-9]+)?\.?([0-9]{2})?$/', $n);
}

Just two points I can think of.. I wonder why passing $n by reference? Since all you are doing is checking a format, you shouldn't require this (in other words, you are not making any modifications to $n).

Lastly, you are using captures when grouping parenthesis will do. Something like ([0-9]+)? could be (?:[0-9]+)? and ([0-9]{2})? could be (?:[0-9]{2})? instead. Since there is no need to store these values in this case, using grouping parenthesis makes regex work faster and is thus more efficient (granted, a single variable or small amount of variables going through your preg pattern wouldn't exhibit a discernible speed difference between capture / grouping parenthesis. More a matter of making the regex do the least amount of work needed to get the job done).

Horizon88

I'm passing it by reference because, as you said, I'm not modifying $n - there's no need to make a copy of it if we're not going to change the data either way. Copying it's just another operation we can skip.

I didn't use regular grouping parentheses instead of captures because I didn't know the difference. 😛 My regex skills aren't as good as they could be, but I wanted to give rewriting his patterns a shot.

nrg_alpha

Horizon88;10919089 wrote:
I'm passing it by reference because, as you said, I'm not modifying $n - there's no need to make a copy of it if we're not going to change the data either way. Copying it's just another operation we can skip.

Yeah, I was just seeing it from the standpoint that variables that are not passed by reference (thus local copies) are destroyed up return / completion of the function. Personally, I tend to only pass by reference if I need to make any direct manipualtions to that variable, otherwise, I simply let the local copy do its thing then terminate afterwards... But that's just me. Your way does shave off the need of a copy for sure.

Horizon88 wrote:
I didn't use regular grouping parentheses instead of captures because I didn't know the difference. 😛 My regex skills aren't as good as they could be, but I wanted to give rewriting his patterns a shot.

Ah, well now you know 🙂 It's a good pattern.. I was just wondering about the captures.

Horizon88

I started passing things by reference more often after I took a C++ course where I understood some of the low-level costs of passing things by value and just got into the habit of doing it in PHP, too. Passing by value has the overhead of allocating new memory, copying the value, then deleting it after it goes out of scope. It's not a big deal for little ints and numbers like we're playing with here, but when you start getting into larger objects and classes getting passed around, that little & can make a significant difference.

Shrike

I am pretty sure PHP is optimised with regard to pass-by-value. It's usually better to pass-by-value when you are dealing with scalars. Objects and arrays may be handled differently, especially in PHP5.

nrg_alpha

Horizon88;10919113 wrote:
...Passing by value has the overhead of allocating new memory, copying the value, then deleting it after it goes out of scope.

I was digging around and came across this article. In it, it describes what happens when variables are copied, references and whatnot. From what I gather (I'm still reading it), when a variable is copied, the value isn't copied, but rather, the 'other' variable merely points to the same zval (variable container) that the first variable points to (in order to save memory).

PHP tries to be smart when it deals with copying variables
like in $a = $b. Using the = operator is also called
an “assign-by-value” operation. While assigning by
value, the PHP engine will not actually create a copy of
the variable container, but it will merely increase the
refcount field in the variable container. As you can
imagine this saves a lot of memory in case you have a
large string of text, or a large array.

So what I am reading further down the page is that when passing by value, the only thing being done is a new symbol table is created ([along with a function stack] and thus destroyed upon return / exiting function scope).

So the idea is that when the new symbol table is created, the value is treated much like quoted above (in that the original and local function variable points to the same zval container). What I gather from this is that the only overhead is the creation / destruction of the symbol table as well as a function stack (but the zval container remains a single container that both variables point to.

In Figure 3, I illustrate exactly how variables are
passed to functions. In step 1, we assign a value to the
variable $a, again—“this is”. We pass this variable to the
do_something() function, where it is received in the
variable $s. In step 2, you can see that it is practically
the same operation as assigning a variable to another
one (like we did in the previous section with $b = $a),
except that the variable is stored in a different symbol
table—the one that belongs to the called function—
and that the reference count is increased twice, instead
the normal once. The reason for this is that the function’s
stack also contains a reference to the variable
container.

Granted, I'm no expert in how PHP handles variables.. but what I get from all this is that while there is some overhead in passing by value (which passing by reference doesn't involve), the actual value itself is not duplicated (assuming we are not making changes to the variable within the function - which in that case does create a new zval).