I may sound stupid to some but I want to know if there is some benefit of passing arguments to a function as an array,rather than passing each arguments or some downsides?
Unwritten rule for good programming practice is that function should not have more than 3-5 arguments.
Usually arrays or even objects are used to pass in the logical complete data structures.
I think this is due more transparent and readable code rather than any performance benefits.
Sure it might look nicer if you pass an array to a method, but what does it mean?
Arrays usually signify that you have a collection of the same thing, whilst method parameters are usually different things.
If you want to pass a list of things to a method and do the same action on all of them, then it makes perfect sense to use some type of array/collection object.
If however you want to make it tidier and avoid passing around lots of objects together, consider refactoring your code to use some kind of wrapper object that you can pass around more easily.
Also if you have so many arguments that you would consider using an array to hold them, it's a sure sign that you need to refactor your code ;-)
Mostly it just requires more typing to create an array and pass it, rather than just passing individual arguments.
Other than that there's no particular specific advantage to separate parameters.
Parameter list much more clear when you read function signature. Array is just one variable, say, $args. But what there in args?
if you have this array already, it is surely better to use it.
if you don't have this array already, using parameters will save you typing of array keyword and a couple of braces.
that's all.
Use whatever you feel more suitable for the case.
I think that when you have a few parameters or less than 5 (subjectively) then more useful is passing arguments as parameters. If you have a big count of arguments then using array is more useful that function/method with 15 parameters.
Related
Introduction
I have some sort of values that I might want to access several times each page is loaded. I can take two different approaches for accessing them but I'm not sure which one is 'better'. Three already implemented examples are several options for the Language, URI and displaying text that I describe here:
Language
Right now it is configured in this way: lang() is a function that returns different values depending on the argument.
Example: lang("full") prints the current language, "English", while lang() prints the abbreviation of the current language, "en". There are many more options, like lang("select"), lang("selectact"), etc that print different things. The code is too long and irrelevant for the case so if anyone wants it just ask for it.
Url
The $Url array also returns different values depending on the request. The whole array is fully defined in the beginning of the page and used to get shorter but accurate links of the current page.
Example: echo $Url['full'] would print "http://mypage.org/path/to/file.php?page=1" and echo $Url['file'] would print "file.php". It's useful for action="" within the forms and many other things. There are more values for $Url['folder'], $Url['file'], etc. Same thing about the code, if wanted, just request it.
Text
[You can skip this section]
There's another array called $Text that is defined in the same way than $Url. The whole array is defined at the beginning, making a mysql call and defining all $Text[$i] for current page with a while loop. I'm not sure if this is more efficient than multiple calls for a single mysql cell.
Example: echo $Text['54'] prints "This is just a test array!" which this could perfectly be implemented with a function like text(54).
Question
With the 3 examples you can see that I use different methods to do almost the same function (no pun intended), but I'm not sure which one should become the standard one for my code. I could create a function called url() and other called text() to output what I want. I think that working with functions in those cases is better, but I'm not sure why. So I'd really appreciate your opinions and advice.
Should I mix arrays and functions in the way I described or should I just use funcions?
Please, base your answer in this:
The source needs to be readable and reusable by other developers
Resource consumption (processing, time and memory).
The shorter the code the better.
The more you explain the reasons the better.
Thank you
PS, now I know the differences between $Url and $Uri.
It sounds like you're implementing ambiguous functions through the array notation. Normally, these would be classes with methods. $url['full'] would be $url->getFullPath(). Methods are preferred over the array accessor because methods are documented, and can be introspected by IDEs. Objects are more preferable because (in your examples) you can lazy-load the information. Right now, your script is compiling the $Url array and figuring out values for every possible key so it can be used in the script. Whereas a $request object could only do the parsing upon request - not instantiation.
I am using something like config array var. Where strings are set. Is better for later reading to use $LBL["hello"]='Hi!' than lbl(5). Think about yourself when you will return to your code aftre one year :)
Well, I read in my handy PHP book that it's very important to be able to distinguish between reference and variable parameters. The book says that the original value of parameterized variables are preserved when the variable is changed, and the original values of parameterized references change when the reference is changed. It says that's the key difference, if I am reading right.
Well, I'm wondering when each is more useful than the other. How do I know when to use variables and when to use references when I create my own functions?
It's pretty straightforward. Use references when you need to modify the value of the variable passed in to the function. Use variables when you don't need to or want to modify the value.
So, for example, if you're writing a function that takes an array and changes that array, you'd be better off using a reference for that array rather than returning a new array from the function.
"References" (variable aliases) make your code harder to understand and could be a source of hard to follow errors. There are no valid reasons to use references in php and to be on the safer side try to avoid them altogether.
And no, objects in php5 have nothing to do with "references".
"References" as implemented in php is a strange concept. Normally, in programming languages variables are independent of each other so that changing one variable doesn't affect others. Php "references" allow several variables to share the same value and to be dependent of each other. Basically, you change one variable, and suddenly another one, which you think is totally unrelated, is getting changed too. It's no good thing and often leads to much confusion.
Objects in php (do I need to add 'five'?) have nothing to do with "references" in the above sense. They behave much like C pointers (actually, this is what they are under the hood) - when you pass an object to a function, you actually pass a pointer, and the function can use this pointer to manipulate the object contents, but there's no way for the function to change the passed variable itself, for example, make it point to another object.
This "objects are references" misunderstanding is probably because people confuse php "references" (ampersand syntax) with the generic CS term , which also applies to pointers, handles etc.
Is it possible to omit certain variables from serialization? Say I have a temporary variable in a php object that I don't want serialized as it is a waste of space. The only thing I can think of is making them static but this is not ideal as it is not really part of the object which there will be many instances of.
This may not even be possible but would love to hear some ideas.
Take advantage of the __sleep method of your object.
when using arrays as parameters in functions, should I pass them by reference or by value? Or there is not that much significance?
Normally you should pass by value.
You should only pass be reference if you need to modify the array in place, rather than returning a new one.
There's no performance benefit to passing by reference when reading from an array because PHP uses copy-on-write,
If you're interested in maximising performance, do a speed test. Due to PHP optimisations, passing by reference is usually faster than passing by value only if you modify the array (however note the behaviour is also different!).
Passing by value helps reduce the side-effects of a function (side-effects are a common source of code complexity and bugs) and for this and other reasins, it is "better style".
So, pass by reference only if there is a good reason to do so.
Is it considered 'bad practice' to create an function like so:
// $arr_member_fields['first_name'] = $_POST['first_name'];
// $arr_member_fields['last_name'] = $_POST['first_name'];
// $arr_member_fields['email'] = $_POST['email'];
// $arr_member_fields['dob'] = $_POST['dob'];
// $arr_member_fields['gender'] = $_POST['gender'];
function update_member($int_member_id $arr_member_fields)
{
//some code
}
Or should a create a function with no array and just use variables instead -- like so:
function update_member($int_member_id, $str_first_name, $str_last_name, str_email, $str_dob, $chr_gender)
{
//some code
}
The reason why I prefer the first method (the one with the array) is that I always have the option to loop through the array for database insertion/updating purposes.
Very curious to know other peoples inputs on this.
Depends on the function. There is no best practice here that will adequately capture most cases when writing a function. What if you don't need to loop through the arguments?
Seems like you're best off passing arrays in this case.
This is a case where I would consider a structure to hold the data. That way I can pass the structure or an array of structure to a methods or I can access individual elements of the structure.
Of course if I wanted to go further I'd made a class instead of a structure. Then I can have methods as well as data, setters, getters with validation, and so on.
Things like this ultimately come down to effects on performance and code readability. While passing an array is extremely handy, it also makes it difficult to follow for someone else reading your code (or even for you if you're coming back to it 6 months later). This is especially true if the array is defined somewhere else in a large file, or another file altogether.
At the end of the day it really comes down to why you're trying to optimize your code in the first place. Is it for performance, or to make it easier to understand/read?
If it's for readability, pick the approach that seems easiest to understand. You'll thank yourself when you have to go back and tweak something months from now.
If it's for performance, make sure you actually need to improve performance and that you aren't optimizing something just for the sake of optimization. More often than not, you'll create a very real readability problem in an effort to solve a nonexistent performance problem.
I would go with the second method because your IDE can tell you what parameters it should take without having to go to that file. It might seem ok to use an array now for a small project, but as your project becomes larger its likely to become a problem later. It will also save you from asking yourself later when you're trying to use it "Did I use name_ first, or first_ name?" Those fields look like something that would all be in one table, which would be updated in a single statement anyway, so I don't see any reason you would want to loop over the array.
I think that passing parameters by array is generally a bad idea. If parameter lists are so long that they justify being passed as an array it's probably a sign that the code is not designed in the best way.
Passing parameters in an array is more difficult to document using something like PHPDocumentor and will also not be picked up by the code-completion in an IDE. Passing parameters explicity also allows for type hinting and is more transparent to the reader of the code.
Obviously if you are passing an array of items to be processed as a function argument then it makes sense to pass it as an array.