The Array.from() method creates a new, shallow-copied Array instance from an array-like or iterable object.

function createAndFillTwoDArray({
  rows,
  columns,
  defaultValue
}){
  return Array.from({ length:rows }, () => (
      Array.from({ length:columns }, ()=> defaultValue)
   ))
}

console.log(createAndFillTwoDArray({rows:3, columns:9, defaultValue: 'q'}))

You were thinking in the right direction but there are some errors in your code ;)

• You have to initialize the array first before you can push elements into it.
• And you were counting i++ twice

Javascript

var ground = []; // Initialize array
for (var i = 0 ; i < 15; i++) {
    ground[i] = []; // Initialize inner array
    for (var j = 0; j < 9; j++) { // i++ needs to be j++
        ground[i][j] = (Math.random() * 5 | 0) + 6;
    }
}

Maybe even better (reusable)

function createGround(width, height){
    var result = [];
    for (var i = 0 ; i < width; i++) {
        result[i] = [];
        for (var j = 0; j < height; j++) {
            result[i][j] = (Math.random() * 5 | 0) + 6;
        }
    }
    return result;
}
// Create a new ground with width = 15 & height = 9
var ground = createGround(15, 9);

Here's a quick way I've found to make a two dimensional array.

function createArray(x, y) {
    return Array.apply(null, Array(x)).map(e => Array(y));
}

You can easily turn this function into an ES5 function as well.

function createArray(x, y) {
    return Array.apply(null, Array(x)).map(function(e) {
        return Array(y);
    });
}

Why this works: the new Array(n) constructor creates an object with a prototype of Array.prototype and then assigns the object's length, resulting in an unpopulated array. Due to its lack of actual members we can't run the Array.prototype.map function on it.

However, when you provide more than one argument to the constructor, such as when you do Array(1, 2, 3, 4), the constructor will use the arguments object to instantiate and populate an Array object correctly.

For this reason, we can use Array.apply(null, Array(x)), because the apply function will spread the arguments into the constructor. For clarification, doing Array.apply(null, Array(3)) is equivalent to doing Array(null, null, null).

Now that we've created an actual populated array, all we need to do is call map and create the second layer (y).

In my opinion, the const semantics in JavaScript are too weak to help static code analysis or to allow for compiler optimizations. Where const is (mis-)used to signal immutability, I'd go with e.g. declaring ALL_CAPS identifiers instead.

All const does is assure you that the value assigned to it is the same value throughout the scope. If it was assigned an array, it will be the same array and not suddenly change to another array or a different value altogether.

Mutation of the value, however, is a different story. JavaScript has no concept of immutability.Object.freeze does exist, and primitives are immutable, but that's about it.

For your code, if you're aiming to avoid mutation of your arrays, temporary values, counters and all, swap your loop for array.map and create a range function. Create a range, map through it, fill it with values, repeat.

function range(n){
  return Array(n).fill(0);
}

function matrix(dim, value){
  return range(dim).map(v => range(dim).map(v => value));
}

console.log(matrix(10, 2));

You are reinitializing the empty array in every loop iteration:

array1[i]=[];

When you should only be doing this once per value of i. Move the initialization out of the inner-most loop.