Traversing tree with recursion works strange (JavaScript)

You have effectively built a tree structure that looks something like so:

    [1, 3, 2, 5]
      /       \
  [1, 3]     [2, 5]
   /   \      /   \
  [1]  [3]   [2]   [5] 
   |    |     |     |
  [ ]  [ ]   [ ]   [ ]

In your first function, you have a few issues. The immediate issue is that you are using .lenght and not .length. The next thing to notice about your function is when it is performing its alert()s. In your case, you're only performing an alert() when a node has an empty array as its descendants property. In the above tree diagram, you'll notice that's only the case for your last nodes [1], [3], [2], and [5], so these are alerted. All other nodes that you traverse do have non-empty descendants, so those are not alerted/logged to the screen:

class tree_node {
  constructor(n_array) {
    this.n_array = n_array;
    this.descendants = [];
    this.child();
  }
  child() {
    if (this.n_array.length !=1){
      let m = Math.floor(this.n_array.length / 2);
      let l = this.n_array.slice(0,m);
      let r = this.n_array.slice(m);
      const left = new tree_node(l);
      const right = new tree_node(r);
      this.descendants.push(left, right);
    }
  }
}

let n_array = [1,3,2,5];
root_node = new tree_node(n_array); 

function show_tree(root_node){
  if (root_node.descendants.length != 0){
    root_node.descendants.forEach(element => {
      show_tree(element);
    });
  }
  else {
    console.log(root_node.n_array); // replaced with console.log (as this is a more preferred way of logging data)
  } 
}

show_tree(root_node);
// Logs:
// [1]
// [3]
// [2]
// [5]

Unlike your first function, your second function alerts every node it visits, not just those without descendants. That's because your alert() is the first line of the function, so it will always run the alert for every node that the show_tree() function is called with.

I expect that it will run into an error, because at the end of the tree root_node.descendants will be undefined

If you look at your tree_node class, you'll notice that every node that you create gets a descendants property that gets assigned to an empty array within your constructor. As a result, when you traverse/loop over your tree and make further recursive calls, each node you pass into your show_tree() function will have a descendants property - just sometimes the descendants of a node will be an empty array. As a result, no error occurs when you use:

root_node.descendants.forEach(..)

as it is valid to call .forEach() on an empty array ([]). This leads to your other question...:

I don't understand why this recursion stops and does not go into an endless loop

as you traverse your nodes in your tree, you'll eventually reach your leaf nodes (nodes with no descendants (.descendants is an empty array)). When this occurs, your .forEach() loop won't run the code within its "callback", and so no further recursive calls to show_tree() are made. Instead, the function returns to its caller, which can begin to "unravel" the recursive calls or continue looping over other sibling nodes.