It does not work because there is an b.ipo does not exist. You can use b[0].ipo then compare it, eg:

var array = [ [ { ipo: 10 } ], [ { ipo: 5 } ], [ { ipo: 15 } ], ];
array.sort(function(a, b) {
 return a[0].ipo > b[0].ipo;
}); 
console.log(array);

You need to know that Array inherits from Object.

In JavaScript, any Object instance is an associative array(!), so acts like an Array in PHP. For example:

var o = {}; // or new Object();
o['foo'] = 'bar';
o[0] = 'baz';
for (i in o) { console.log(i, o[i]); }

Sorting an Object does not make much sense. indexOf would kinda work in theory, but is not implemented.

Arrays are ordered lists. Array instances have push(), length, indexOf(), sort() etc., but those only work for numerical indexes. But again, Array inherits from Object, so any array can also contain non-numerical index entries:

var a = []; // or new Array();
a[0] = 'foo'; // a.length is now 1
a.push('baz'); // a[1] === 'baz'
a.qux = 1; // will not affect a.length
a.sort(); // will not affect a.qux
for (i in a) { console.log(i, a[i]); }

I recommend playing around with arrays and objects, and you'll soon get the point.

This array is already sorting from server script of PHP But when i get it from ajax and convert JSON to array then ONLY chrome web browser sort it in numeric thread_id in ascending order.

So now I'm add _ before thread_id from server side to key as _378552 is now string so no sort by CHROME.

And after all i remove _ from thread_id while accessing it.. so my problem solved. This is only problem in chrome browser.

This should get you started.

(corresponding jsBin is here : http://jsbin.com/olegoj/1/edit )

// 3D points array.
var points=[];

var Vector=function(x,y,z) {
  this.x=x;
  this.y=y;
  this.z=z;
};

Vector.prototype.toString= function() {
  return (' x: ' + this.x + ' y: ' + this.y  + ' z : ' + this.z);
};

// returns a new vector translatedfrom ampVec * random 
Vector.prototype.createRandomShift= function(ampVec) {
    var thisRandom = Math.random()*0.9+0.1;
  return  new Vector(
      thisRandom*ampVec.x+this.x,
       thisRandom*ampVec.y+this.y,
        thisRandom*ampVec.z+this.z    );
};

var pointCount=20;

var pt = new Vector(Math.random()*100|0, Math.random()*100|0, Math.random()*100|0 );
var ampVec = new Vector(Math.random()*4-2, Math.random()*4-2, Math.random()*4 - 2);
var ampVecAmp = new Vector(Math.random()*2-1, Math.random()*2-1, Math.random()*2-1) ;

// fill the point array.
// based on the current point shifted randomly by ampVec
// ampVec itself is shifted randomly by ampVecAmp 
for(var i=0; i<pointCount; i++) {
   points.push(pt );
   pt=pt.createRandomShift(ampVec);
   ampVec=ampVec.createRandomShift(ampVecAmp);
}

// array of face. a face is an array of 3 point indexes.
var facelist=[];

var faceCount=10, i=faceCount;

// fill the face array
while(i--) {
    var thisFacePoints=[];
    var ip1 = 0;
    // 3 point indexes
    thisFacePoints.push(ip1=Math.random()*pointCount|0);
    thisFacePoints.push(Math.random()*pointCount|0);
    thisFacePoints.push(Math.random()*pointCount|0);
    facelist.push(thisFacePoints);
}

// returns the min z for a face
var minZ=function(f) {
    return Math.min(f[0].z, Math.min(f[1].z, f[2].z));
};

// returns the max z for a face                  
var maxZ=function(f) {
   return Math.max(f[0].z, Math.max(f[1].z, f[2].z));
};

// !!! sort the faces on Z !!!
facelist.sort(function(a,b) {
   if (maxZ(a) < minZ (b)) return 1;  // a fully below b
   if (minZ(b) < minZ(a) ) return -1;  // b fully below a
   // !!!!!!!!!!!!!!!!!!!!!!!!
   // in fact here is the tricky part :
   // here a and b overlap in Z.
  return trickyFaceZSort(a,b); 
 });

 // !!!!!! returns wether face a is < to face b when looking at Z (0,0,1).
//Required : a and b overlaps by Z.
var trickyFaceZSort= function(a,b) {
 // do some checks on projected(xi), projected(yi)  -> return 0 if no overlap
 // then you have the hardest part ahead : x,y and z overlap.
 return 0;
};

// Print sorted faces
for(var i=0; i<facelist.length; i++) {
    var fp=facelist[i];
console.log(' *** face ' + i + ' *** ');
console.log(' ** point 0 ' + points[fp[0]] + ' *** ');
console.log(' ** point 1 ' + points[fp[1]] + ' *** ');
console.log(' ** point 2 ' + points[fp[2]] + ' *** ');  
}

You can assign a number to each case, with the cases that should come first having lower numbers and then subtract the two when comparing.

function sortBy() {
  const getOrder = ({favorites})=>favorites?.length === 1 ? 0 : !favorites?.length ? 1 : 2;
  const cmp = (a, b) => (getOrder(a) - getOrder(b));
  return list => list.sort(cmp);
}

const data = [{ rentalName: "Foo", favorites:[{}, {}, {}] }, { rentalName: "Bar", favorites:[{}] }, { rentalName: "Baz", favoriteslikes:[{}] }, { Name: "Plugh", favorites:[] }];

const sortByLikes = sortBy();

console.log(sortByLikes(data));

Just loop through biggest length of the inner lists, assuming 0 if no value present:

function sortMulti(a, b) {
  for (var index = 0; index < Math.max(a.length, b.length); index++) {
    var A = (a[index] === void 0) ? 0 : a[index];
    var B = (b[index] === void 0) ? 0 : b[index];
    var cmp = B - A;
    if (cmp != 0) {
      return cmp;
    }
  }
  return 0;
}
//TEST
var lista = [
  [1, 20],
  [2, 4],
  [2, 5],
  [1, 1],
  [0, 9],
  [2, 2, 5],
  [1, 3]
];
var listb = [
  [0, 9],
  [1, 1],
  [1, 2],
  [2, 4],
  [2, 5]
];
var output = document.body.appendChild(document.createElement("pre"));
output.innerHTML = "Sorting multidimensionals:\nRAW:\nList a: [" + JSON.stringify(lista.join("],["), null, 1) + "]\nList b: [" + JSON.stringify(listb.join("],["), null, 1) + "]\nSORTED (biggest to smallest):\nList a: [" + JSON.stringify(lista.sort(sortMulti).join("],["), null, 1) + "]\nList b: [" + JSON.stringify(listb.sort(sortMulti).join("],["), null, 1) + "]";

EDIT 1 - Version 2.0

Here is a version that uphold the rules edited into the question:

function sortMulti(a, b) {
    for (var outerIndex = 0; outerIndex < Math.max(a.length, b.length); outerIndex++) {
        var A = (a[outerIndex] === void 0 ? [0, 0] : a[outerIndex]);
        var B = (b[outerIndex] === void 0 ? [0, 0] : b[outerIndex]);
        for (var innerIndex = 0; innerIndex < Math.max(A.length, B.length); innerIndex++) {
            var cmp = (A[innerIndex] === void 0 ? 0 : A[innerIndex] - B[innerIndex] === void 0 ? 0 : B[innerIndex]);
            if (cmp !== 0) {
                return cmp;
            }
        }
    }
    return 0;
}
//TEST
var list = [
    [[21, 5], [16, 18]],
    [[12, 45], [15, 23]],
    [[12, 45], [15, 22]]
];
var output = document.body.appendChild(document.createElement("pre"));
output.innerHTML = "RAW\n" + JSON.stringify(list.sort(sortMulti).map(function (a) { return JSON.stringify(a); }), null, 2) + "\nSORTED\n" + JSON.stringify(list.sort(sortMulti).map(function (a) { return JSON.stringify(a); }), null, 2) + "\n";

You can use a compare function which can be passed as an argument to the sort() function - see Array.prototype.sort() for more detailed information. In your case the compare function may look like this:

var items = [
    { name: 'foo-1', featured: true,  createdAt: 1493000001 },
    { name: null,    featured: false, createdAt: 1493000003 },
    { name: 'foo-3', featured: true,  createdAt: 1493000002 },
    { name: 'foo-4', featured: false, createdAt: 1493000004 },
    { name: 'foo-5', featured: false, createdAt: 1493000005 },
];

function compare(a, b) {
    if (a.featured === true && b.featured === false) return -1;
    if (a.featured === false && b.featured === true) return 1;
    if (a.name === null && b.featured !== null) return -1;
    if (a.name !== null && b.name === null) return 1;

    return b.createdAt - a.createdAt;
};

items.sort(compare);

It should cover the case when the name is an empty string.

There is an npm package called lodash. You can achieve your required functionality with their sortBy method.

const _ = require('lodash');

let employees = [
    {name: 'John', salary: 90000, bonus: 1000},
    {name: 'David', salary: 90000, bonus: 1200},
    {name: 'Ana', salary: 80000, bonus: 3000}
];

const sortedArray = _.sortBy(employees, ['name', 'salary', 'bonus']);

I hope it helps.

The best approach would be to use the following, as there may be repetitive values in the first column.

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

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

array.sort( function (a,b) {
    if (a[0] > b[0]) return  1;
    if (a[0] < b[0]) return -1;
    if (a[2] > b[2]) return  1;
    if (a[2] < b[2]) return -1;
    return 0;
});