Is it better practice to have 2 functions, or 1 complex function?

Question

I'm curious as to what is considered better practice in the programming community.

On submit, a function is called, where some validation is done, and then a post is made through AJAX. I was considering having a function handle them both. I would change all element IDs to be the same, with only the difference of an incrementing number (e.g. txt1, txt2 / txt1Cnt, txt2Cnt / txt1Lbl, txt2Lbl, etc...)

Then I'd add loops and conditional statements to properly handle each form. This sounds like the fun way, which is why I wanted to do it, but now I'm thinking that maybe it would not be considered very efficient, since I wouldn't need to differentiate all the different elements if I just had 2 functions. Especially because the forms are not identical.

So, my question is, is there a rule of thumb when it comes to this sort of thing? Is it better to have less functions, or less complexity?

Thanks for your time.

Answer 1

There are several things you need to consider in these cases.

1. Code reusage - Breaking code into functions which do one or several certain things will let you reuse them later.

2. Code Readability - Code can be more readable when you divide it into logical functions. Especially in cases when someone else will be dealing with your code

3. Performance - If this function is called many times, in most cases it is better to have 1 function

Answer 2

A good rule of thumb is the Single Responsibility Principle, which says that a function should do only one thing.

Answer 3

More simple functions, less complexity.

Answer 4

My rule of thumb is: if there's a chance that I'll need this logic further on for another purpose, then it's better to separate it to its own method or function.

It forces you to spend some extra time abstracting some conditionals to fit the general case, but it saves you N extra times of repeating the logic in other use case.

Answer 5

Generally I like to make sure a single function or method performs a single significant task. This has two benefits;

• Improve Code Readability - If you come back to your code in x months time, when you can no longer remember writing the code, it can be less time consuming to follow and adapt a sequence of shorter functions than a small number of large functions that each perform multiple tasks.
• Increase Code Reusability - This applies more to OOP classes, but is also relevant in procedural. If you write a function that performs a reasonably specific task you can then re-use the function again in future projects, requiring the adaptation of a few parameters or paths rather than extracting the parts of a long, multi-functional function to rebuild the function to the new project's needs.