Using Array#sort you can apply this logic:

// If both are numbers or both are not numbers
isNaN(a.name) === isNaN(b.name) ?
     // then compare between them 
    (a.name > b.name ? 1 : -1) // or String#localeCompare if supported
    : // else
    // If the 1st is not a number move it up, if it's a number move it down
    (isNaN(a.name) ? -1 : 1); 

Without lodash:

var objects = [{"name":"A"},{"name":"3"},{"name":"1"},{"name":"B"}];

objects.sort(function(a, b) {
  return isNaN(a.name) === isNaN(b.name) ? (a.name > b.name ? 1 : -1) : (isNaN(a.name) ? -1 : 1);
});

console.log(objects);

As part of a lodash's chain:

var objects = [{"name":"A"},{"name":"3"},{"name":"1"},{"name":"B"}];

var result = _(objects)
  .sort(function(a, b) {
    return isNaN(a.name) === isNaN(b.name) ? (a.name > b.name ? 1 : -1) : (isNaN(a.name) ? -1 : 1);
  }) 
  .value();

console.log(result);

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.3/lodash.min.js"></script>

If name is an integer prefix it with z for comparison.

var objects = [
  {name: 'z'},
  {name: 'A'},
  {name: '1'},
  {name: 'B'}
], sorted = _.sortBy( objects, [
        function(d) {
            return !isNaN(parseFloat(d.name))
                   && isFinite(d.name)
                       ? 'z' + d.name
                       : d.name; }
    ]
);
console.log(sorted);

<script src="https://lodash.com/vendor/cdn.jsdelivr.net/lodash/4.17.3/lodash.min.js"></script>

Solution with two _.sortBy()

One for priotizing alphabets first, then another one for sorting the elements.

In my opinion it's more readable and it will have no performance impact.

const objects = [
  {name: 'B'},
  {name: '2'},
  {name: '1'},
  {name: 'A'}
]

const result = _.sortBy(_.sortBy(objects, o => !isNaN(parseInt(o.name)), 'name'))

console.log(result)

<script src="https://lodash.com/vendor/cdn.jsdelivr.net/lodash/4.17.3/lodash.min.js"></script>

I'm not sure if using lodash's sortBy is the correct approach for this problem. Here's an implementation using Javascript's Array#sort method.

It takes not only the first character but the entire string into account when doing the sorting.

const objects = [{
  name: '2'
}, {
  name: 'B'
}, {
  name: '1'
}, {
  name: 'A'
}, {
  name: 'A1'
}, {
  name: 'AA'
}]

objects.sort((o1, o2) => {
  let a = o1.name, b = o2.name;
  let isDigit = x => x >= 48 && x <= 57;

  for (let i = 0, n = Math.min(a.length, b.length); i < n; i++) {
    let aCharCode = a.charCodeAt(i), bCharCode = b.charCodeAt(i);
    
    if (aCharCode !== bCharCode) {
      if (isDigit(aCharCode) && !isDigit(bCharCode)) return 1;
      if (isDigit(bCharCode) && !isDigit(aCharCode)) return -1;
      return aCharCode - bCharCode;
    }
  }

  return a.length - b.length;
});

console.log(objects)

For the given input, this prints out

[
  {
    "name": "A"
  },
  {
    "name": "AA"
  },
  {
    "name": "A1"
  },
  {
    "name": "B"
  },
  {
    "name": "1"
  },
  {
    "name": "2"
  }
]

Partition the input, sort separately and join back:

Code:

const _ = require('lodash');

const customSort = (a) => _.chain(_.partition(a, i => isNaN(i.name))).flatMap(p => _.sortBy(p, 'name')).value();

const input = [
    { name: '1' },
    { name: 'A' },
    { name: '6' },
    { name: 'B' },
    { name: 'a' },
    { name: '0' },
    { name: '3' }];

console.log(customSort(input));

Output:

[ { name: 'A' },
  { name: 'B' },
  { name: 'a' },
  { name: '0' },
  { name: '1' },
  { name: '3' },
  { name: '6' } ]