It really is as straightforward as this:

var arr = [[12, 'AAA'], [58, 'BBB'], [28, 'CCC'],[18, 'DDD']];

arr.sort(sortingFunction);

function sortingFunction(x, y) {
    if (x[0] === y[0]) {
        return 0;
    }
    else {
        return (x[0] < y[0]) ? -1 : 1;
    }
}

I encourage you to explore the documentation.

If you wish to arrange by the second column, follow these steps:

arr.sort(compareSecondColumn);

function compareSecondColumn(x, y) {
    if (x[1] === y[1]) {
        return 0;
    }
    else {
        return (x[1] < y[1]) ? -1 : 1;
    }
}

To effectively handle potential duplicates in the first column, it is recommended to utilize the code snippet provided below:

const data = [[12, 'AAA'], [12, 'BBB'], [12, 'CCC'],[28, 'DDD'], [18, 'CCC'],[12, 'DDD'],[18, 'CCC'],[28, 'DDD'],[28, 'DDD'],[58, 'BBB'],[68, 'BBB'],[78, 'BBB']];

data.sort((a, b) => {
    return a[0] - b[0];
});

Check out this solution:

//SORT BY FIRST COLUMN
arr = arr.sort((a, b) => a[0] - b[0]);

//SORT BY SECOND COLUMN
arr = arr.sort((a, b) => a[1] - b[1]);

Please note: The original answer mistakenly used a greater than sign (>) instead of the subtraction symbol (-), as mentioned in the comments provided.

Implementing sorting by the second string field using arrow functions

let array = [[12, 'CCC'], [58, 'AAA'], [57, 'DDD'], [28, 'CCC'],[18, 'BBB']];
array.sort((a, b) => a[1].localeCompare(b[1]));
console.log(array)

Like many individuals, I prefer to avoid having to update each index manually whenever I need to change the column being sorted.

function sortDataByColumn(data, columnIndex){

    data.sort(sortingFunction);

    function sortingFunction(a, b) {
        if (a[columnIndex] === b[columnIndex]) {
            return 0;
        }
        else {
            return (a[columnIndex] < b[columnIndex]) ? -1 : 1;
        }
    }

    return data;
}

var sortedData = sortDataByColumn(dataArray, 2);

Here's a concise way to sort cars by year:

var cars = [
  {type:"Volvo", year:2016},
  {type:"Saab", year:2001},
  {type:"BMW", year:2010}
]

function myFunction() {
  return cars.sort((a, b)=> a.year - b.year)
}

If you're looking to organize your data by the first column (which contains numeric values), use the following code:

arr.sort(function(a,b){
  return a[0]-b[0]
})

If you need to sort based on the second column (which contains text values), try this:

arr.sort(function(a,b){
  return a[1].charCodeAt(0)-b[1].charCodeAt(0)
})

Remember, in the second scenario, you'll be comparing their ASCII values.

Simply optimizing the process of sorting an array by a specific column index to reduce the cost of value retrieval.

function customSortByColumn(array, columnIndex){
    array.sort(customSortFunction)
    function customSortFunction(a, b) {
        a = a[columnIndex]
        b = b[columnIndex]
        return (a === b) ? 0 : (a < b) ? -1 : 1
    }
}
// Example
var data = [[12, 'AAA'], [58, 'BBB'], [28, 'CCC'],[18, 'DDD']]
customSortByColumn(data, 0)
console.log(JSON.stringify(data))
// "[[12,"AAA"],[18,"DDD"],[28,"CCC"],[58,"BBB"]]"

I am utilizing the sort method to arrange the elements in the array

Check out my code below:

const customSortArr = (array) => {
    array.sort((valueA, valueB) => valueA[0] - valueB[0])
    return array
}

const newArray = [
    [35, 'ZZZ'],
    [72, 'YYY'],
    [42, 'XXX'],
    [88, 'WWW']
]
console.log(customSortArr(newArray))

Building upon the contributions of charles-clayton and @vikas-gautam, I introduced the string test required for columns containing strings as in the original post.

return isNaN(a-b) ? (a === b) ? 0 : (a < b) ? -1 : 1 : a-b  ;

The isNaN(a-b) test checks if the strings cannot be converted to numbers. If they can, then the comparison a-b is valid.

It's important to note that sorting a column with mixed data types will always lead to interesting outcomes since the direct equality comparison (a === b) will consistently result in false.

You can find the complete script with Logger test below, utilizing Google Apps Script for implementation.

function testSort(){

function sortByCol(arr, colIndex){
    arr.sort(sortFunction);
    function sortFunction(a, b) {
        a = a[colIndex];
        b = b[colIndex];
       return isNaN(a-b) ? (a === b) ? 0 : (a < b) ? -1 : 1 : a-b  ;  // check for text strings that cannot be converted to numbers
       
       }
}
// Usage
var a = [ [12,'12', 'AAA'],
          [12,'11', 'AAB'],
          [58,'120', 'CCC'],
          [28,'08', 'BBB'],
          [18,'80', 'DDD'],
        ]
    var arr1 = a.map(function (i){return i;}).sort();  // use map to avoid interference from in-place sorting.

    Logger.log("Original unsorted:\n     " + JSON.stringify(a));
    Logger.log("Vanilla sort:\n     " + JSON.stringify(arr1));
    sortByCol(a, 0);
    Logger.log("By col 0:\n     " + JSON.stringify(a));
    sortByCol(a, 1);
    Logger.log("By col 1:\n     " + JSON.stringify(a));
    sortByCol(a, 2);
    Logger.log("By col 2:\n     " + JSON.stringify(a));

/* vanilla sort returns " [
                            [12,"11","AAB"],
                            [12,"12","AAA"],
                            [18,"80","DDD"],
                            [28,"08","BBB"],
                            [58,"120","CCC"]
                          ]
   if col 0 then returns "[
                            [12,'12',"AAA"],
                            [12,'11', 'AAB'],
                            [18,'80',"DDD"],
                            [28,'08',"BBB"],
                            [58,'120',"CCC"]
                          ]"
   if col 1 then returns "[
                            [28,'08',"BBB"],
                            [12,'11', 'AAB'],
                            [12,'12',"AAA"],
                            [18,'80',"DDD"],
                            [58,'120',"CCC"],

                          ]"
   if col 2 then returns "[
                            [12,'12',"AAA"],
                            [12,'11', 'AAB'],
                            [28,'08',"BBB"],
                            [58,'120',"CCC"],
                            [18,'80',"DDD"],
                          ]"
*/

}

The method of sorting data in an array depends on whether the column value is numeric or a string.

For sorting by the first column when the value is numeric:
array.sort( (a, b) => a[0] - b[0]);

To sort by the second column when the value is numeric:
array.sort( (a, b) => a[1] - b[1]);

When sorting by the first column and the value is a string/letter:
array.sort( function(a, b) {
    const nameA = a[0].toUpperCase(); // to prevent case sensitivity in sorting
    const nameB = b[0].toUpperCase();
    if(nameA > nameB)
        return 1;
    else if(nameB > nameA)
        return -1;
    else
        return 0;     
})

Given the complexity of my project with numerous columns, I decided to expand upon the solution provided by @jahroy. (I also later realized that @charles-clayton had suggested a similar approach.)
My approach involves passing the parameter specifying the column for sorting, and then redefining the sort function to use the designated index for comparison.

var NAME_COLUMN=0
var DATE_COLUMN=1

entries.sort(compareByColumnIndex(DATE_COLUMN))

function compareByColumnIndex(index) {
  return function(a,b){
    if (a[index] === b[index]) {
        return 0;
    }
    else {
        return (a[index] < b[index]) ? -1 : 1;
    }
  }
}

Great suggestion, Sabbir Ahmed! Let's modify the code to only order by the first character when dealing with three elements:

array.sort((a, b) => (a[n].charCodeAt(0)*1000000 + a[n].charCodeAt(1)*1000 + a[n].charCodeAt(2)) - (b[n].charCodeAt(0)*1000000 + b[n].charCodeAt(1)*1000 + b[n].charCodeAt(2)));

Arranging a two-dimensional array with specified sorting order and column. The default setting of 0 indicates no change, so the order must be explicitly stated: 1 => Ascending, -1 => Descending. The default column is set to 0.

const sortTwoDimensionalArray = (arr2d = [], order = 0, column = 0) => {
    if (column < 0 || column > 1) {
        if (order == 1) 
            return arr2d.sort((a, b) => a[column] - b[column])
        if (order == -1) 
            return arr2d.sort((a, b) => b[column] - a[column])
    }
    return arr2d
}

const twoDArray = [ [5, 3], [2, 5], [9, 1], [4, 1] ]
console.log(sortTwoDimensionalArray(twoDArray, 1, -1)) //  [ [ 2, 5 ], [ 5, 3 ], [ 9, 1 ], [ 4, 1 ] ]

If you are looking for a way to arrange a multi-dimensional integer array where each sub-array has a fixed length of 3: [ [ -6, 1, 5 ], [ -8, 3, 5 ], [ -8, 2, 6 ], [ -8, 3, 6 ] ]

const array = [ [ -6, 1, 5 ], [ -8, 3, 5 ], [ -8, 2, 6 ], [ -8, 3, 6 ] ]
const multiArraySort = (array, num) => {
  return array = array.sort((a,b) => {
    let boolean = true
    let i = 0 
    while(boolean){      
      if(a[i] === b[i]){        
        if(a[i+1] === b[i+1]){          
          i < num - 1 ? i++ : boolean = false
        }else {          
          return a[i+1] - b[i+1]          
        }        
      } else {                
        return a[i] - b[i]
      }
    }
    return 0
  })
}
// The number 3 represents the fixed length of sub-arrays
let sortedArray = multiArraySort(array, 3)

Answer: [ [ -8, 2, 6 ], [ -8, 3, 5 ], [ -8, 3, 6 ], [ -6, 1, 5 ] ]

The toSorted() function is a handy tool for sorting arrays without modifying the original array. Similar to the traditional sort() method, you can provide a custom comparison function to dictate how the elements should be sorted.

Learn more about Array.prototype.toSorted() here

const arr = [
    [12, "AAA"],
    [58, "BBB"],
    [28, "CCC"],
    [18, "DDD"]
  ];

  let arr1 = arr.toSorted();
  let arr2 = arr.toSorted((a, b) => a[0] - b[0]);
  let arr3 = arr.toSorted((a, b) => a[1] - b[1]);

  console.log(arr1);
  console.log(arr2);
  console.log(arr3);