create_function seems weak

rhunter007

Assume you have function map which inputs a function and an array and returns a new array with the input function applied to each element of the input array.

Also assume you have:
function foo ($num, $factor) {
return $num * $factor;
}

What I'd like to do is write:

function makeMultiplier ($factor) {
return create_function('$elt', 'return foo($elt,$factor)');
}

I could use this function to multiply every element in an array by, for example, 3:

$ar = array(1,2,3);
$new_array = map(makeMultiplier(3),$ar);

and then new_array would be:
array(3,6,9).

But, unfortunately, you can't create functions that refer to free variables that are not global. So how do I get around this?

Obviously, I could have written:
$new_array=map(create_function('$elt','return $elt * 3;'), $ar);

but you should imagine that my foo function is actually something really complicated and so the latter would not be a good solution in general.

My question: how do you do something like this is PHP?

Thanks for any advice!

laserlight

can [man]array_walk/man be used for this?

EDIT:
decided to read the manual myself 😃
I think array_map() is what you want.

rhunter007

Originally posted by laserlight
EDIT:
decided to read the manual myself 😃
I think array_map() is what you want. [/B]

Thanks for your post laserlight. I didn't know about the array_map function, so it's good to know that it's there. But it still doesn't resolve my current issue. Replace "array_map" with "map" above and the question still remains. I'm not trying to write map, but rather, I'm trying to get maximum use out of map (or array_map).

laserlight

To be honest, I've never used create_function() and I dont know what exactly you are trying to do.

I have the impression that you want to apply a callback function with arguments to an array, which array_map() can do, but that doesnt seem to be what you want.

rhunter007

I'll shorten the description of what I want to do then:

$x = 3;
$f = create_function('$arg','return $x + $arg;');
print($f(10));

I want this to print 13, but instead it gives an error saying that $x is undefined. So you might respond: so what? Why not just write 3 instead of $x in the create_function arguments...or, why are you even creating a function in the first place?

So, here's perhaps a more motivated problem: In PHP, write a function "create" which takes an input $arg and returns another function which takes an input $ar (an array) and multiples each element of $ar by $arg.

Why would you want to do this? Well, let's say your business makes functions for clients that multiply arrays by a certain number. It would feel like a waste to write such a function from scratch each time you have a new client (assume each client wants a different multiply factor). Instead, if you can solve my problem, you can just hand your client
<?
return create(5);
?>

if your client wants a factor of 5, or

<?
return create(100);
?>

if your client wants a factor of 100.

laserlight

"In PHP, write a function "create" which takes an input $arg and returns another function which takes an input $ar (an array) and multiples each element of $ar by $arg."

As I said, I never used it before.
I had the impression that create_funtion() would be used on the fly, not really to create new (permanent) functions.
PHP Manual confirmed it by noting that one of its common uses is for callback functions in array_walk(), hence it is on the fly.

In your example, of course $x is undefined, since it isnt in the argument list.
You should use:

<?php
$f = create_function('$x, $arg','return $x + $arg;');
$x = 3;
print($f($x, 10));
?>

Of course this falls under your "why are you even creating a function in the first place" point, since it duplicates the functionality of
print $x + 10;
with no real advantage.

In your multiply by 3 case, I would use:

<?php
function foo(&$num, $index, $factor) {
	$num *= $factor;
}

function create($factor) {
	return create_function('&$array', 'array_walk($array, "foo", ' . $factor . ');');
}

$array = array(1, 2, 3);
$f = create(3);
$f($array);
print_r($array);
?>

This does what you want somewhat, though personally it would be difficult to maintain for a complex function foo().
The idea is that foo() takes in the value of an array element as a reference, and the corresponding array index.
It then takes in other arguments, in this case $factor
What ever needs to be done on the array element is done.

Now, array_walk() takes in an array, a callback function to apply to each element of the array, as well as other arguments.
This callback function is your crucial function foo().

If you ask me, I'd rather just write a function with some distinct identifiers, then do a search and replace for what the client wants before handing him the function.