TL; DR

All recursive code can be translated into an iterative form, but some algorithms are naturally recursive and more easily represented in this form.

Think, for example, of traversing all nodes in a tree or graph, processing all files in a directory and subdirectories, and so on.

In iterative mode you are responsible for manually managing the state of each step of the algorithm using some structure of data, often a stack, while in recursive mode you delegate this function to your programming language, by making use of variables and parameters that are automatically allocated in the execution stack at the beginning of each execution of the method method.

Example

To answer the questions, consider something a little more complex. I extracted the pseudo-code to traverse trees from the Wikipedia .

Recursive method

postorder(node)
  if node == null then return
  postorder(node.left)
  postorder(node.right)
  visit(node)

Method iterative

iterativePostorder(node)
  parentStack = empty stack  
  lastnodevisited = null 
  while (not parentStack.isEmpty() or node ≠ null)
    if (node ≠ null)
      parentStack.push(node)
      node = node.left
    else
      peeknode = parentStack.peek()
      if (peeknode.right ≠ null and lastnodevisited ≠ peeknode.right) 
        node = peeknode.right
      else
        visit(peeknode)
        lastnodevisited = parentStack.pop() 

Answers

1ª what is the advantage of using a recursive function?

In your example there is little advantage, but in what I put above, we clearly see that the recursive method:

• better expresses the functionality . Programming function makes everything heavy of this ability.
• is more compact . Less code means easier maintenance, less chance of errors and so on forth.
• automatic State Management . In the iterative example a stack (stack) was used. Think now of languages where memory management is not automatic. In C, for example, you would have to add code to allocate and release stack elements on each iteration.

2ª how is the memory consumption?

Depends on the function. Usually you should do a memory complexity and time analysis to analyze the differences, but it is somewhat obvious that in the vast majority of cases, recursive routines consume more memory and require more execution cycles.

Recursive routines usually use more memory by relocating variables on each recursive call, but iterative routines can use the same amount of memory if values are saved in lists or stacks, for example.

In iterative mode you have control, for better or for worse. There is a possibility to create a more optimized routine than the recursive version. But one should not take this as a rule, after all there are excellent recursive implementations that are more efficient than the average iterative implementations.

Also, efficiency depends greatly on the number of executions and the level of recursion. Just like ordering routines, some implementations work best when there are few iterations and others when there are more iterations. Some implementations recursives are better for small processing. See, for example, on this site that the performance for Fibonacci where n <= 5 was better for the recursive version.

In a very simple example, the Fibonacci recursive function has exponential complexity while the version can be implemented with two or three simple variables and therefore has constant memory usage .

On the other hand, almost always recursive routines end up needing be rewritten in its iterative version when the number of elements or Numbers processed is large, after all Recursion has a sensitive limit of both memory and data stacking.

And in addition to all this, there are techniques that can improve the performance and capacity of recursive routines, examples of which are:

• Memoization, or memorizing results
• Tail call, or recursion in tail

3rd should I use a recursive function instead of a common repeating Loop (e.g. for/while)? What would be the ideal situations for using recursive functions?

Should only if the algorithm is better expressed recursively and if the general use of that algorithm will not exceed the recursion limits.

I believe that the ideal situations have been exemplified above, that is:

• inherently algorithms recursive, best expressed in this format
• computational use is moderate, so as not to exceed the recursion limits

1. recursive functions are an advantage for cases where the problem is naturally defined as a function of itself, and where the recursive solution is the simplest. At first this may seem strange since recursion seems complicated and confusing, but over time and with understanding (a lot of practice too) you learn to identify problems where it is the best solution.
2. usually recursion represents an additional expenditure of memory, this occurs because each call of a function allocates a frame in the Call Stack, so each new invocation that the recursive function makes itself allocates a new frame in the stack and each new frame accumulates more memory, all this memory is only released when all recursive calls reach the breakpoint (when $num is == 0 in your example). If the recursive function makes too many calls to itself (accumulate too many frames in the stack) a "Stack Overflow" will occur. I recommend that you read this question and the answers provided in case you want a greater understanding about what the call stack is and how a stack overflow can occur.
3. how hard life is the answer is, it depends. As I have commented before the recursion advantage is for recursive problems by nature and for which a recursive solution is the simplest and most straightforward, a classic example is the manipulation of binary trees, an inherently recursive data structure. My suggestion final is: learn recursion, understand how it works, practice, eventually you will know the best time to use.

Those who do not experiment in practice end up not understanding the theory. So it's always good to show a practical example of use in the "real world".

A basic tip to know when to deploy is, when you need to perform multiple variable number repeat loops.

When you are sure that you can solve something with X number of repeat loops, then it is logical that the most sensible thing is to apply multiple loops, as long as they are not many. For example, 10 loops is a lot then it would be the case to think about the use of recursion.

Picture

while(){
    while(){
        while(){
            while(){
                while(){
                    while(){
                        while(){
                            while(){
                                while(){
                                    while(){

How would that look in a recursion?

function foo()
    while(){
       foo();

Below, a practical example of use.

In this situation I needed to create a function to normalize a path (filesystem). In PHP there is the function realpath() but this function normalizes only an existing path. The function below does the same as realpath() with the difference that it ignores whether the path exists or not. The purpose is only to normalize.

That it is a practical example of using recursion. Here in this case it would not fit to use multiple loops manually.

$path_canonicalize = function($str, $started = false) use(&$path_canonicalize)
{
    $str = str_replace('/', DIRECTORY_SEPARATOR, $str).DIRECTORY_SEPARATOR;

    if (!$started)
        $str = preg_replace("/".preg_quote(DIRECTORY_SEPARATOR, "'".DIRECTORY_SEPARATOR."'")."{2,}/", DIRECTORY_SEPARATOR, $str);

    $pos = strpos($str, '..'.DIRECTORY_SEPARATOR);
    if ($pos !== false)
    {
        $part = trim(substr($str, 0, $pos), DIRECTORY_SEPARATOR);
        $str = $path_canonicalize(trim(substr($part, 0, strrpos($part, DIRECTORY_SEPARATOR)), DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR.trim(substr($str, $pos+3), DIRECTORY_SEPARATOR), true);
    }
    return rtrim($str, DIRECTORY_SEPARATOR);
};

/*
Try those cases to check the consistency:
$str = __DIR__.'/template//////../header//..';
$str = __DIR__.'/template///..///../header//..';
$str = __DIR__.'/template/../header/..';
$str = __DIR__.'/template/../header/../';
$str = __DIR__.'/template/../header/..//';
$str = __DIR__.'/template/../header/..///';
$str = __DIR__.'/template/../header/..///..';
$str = __DIR__.'/template/../header/..///../';
$str = __DIR__.'/template\\..\\header\\..';
*/
$str = __DIR__.'/template/../header/..///..//';
echo 'original: '.$str.PHP_EOL;
echo 'normalized: '.$path_canonicalize($str).PHP_EOL;

In addition to what has been said in the other answers, recursive functions are especially advantageous in cases where it is possible to divide the problem in half. This is evident when working with binary trees, but is not limited to this.

Consider the two functions below to calculate multiplication from successive sums. While the iterative solution has O(N) complexity, the recursive solution has O(log(n)) complexity. This should compensate for the overhead for calling methods.

Sorry for the Python code, it was the language I was working on, but I think you can express the concept. If I have time later, I can try to translate to PHP.

def multIterativa(a, b):
    total = 0
    for i in range(b):
        total += a
    return total

def multRecursiva(a, b):    
    if b == 0:
        return 0
    if b == 1:
        return a
    total = multRecursiva(a, int(b / 2))
    total += total
    if b % 2 != 0:
        total += a
    return total