There's the standard npm semver version comparison library, but I have some simple logic to compare semver versions here:

const versionA = '14.8.3';
const versionB = '15.1.1';
const versionC = '15.1.2';

const semver = require('semver');
const assert = require('assert');

const isGreater = (a, b) => {

  const [majorA, minorA, patchA] = String(a).split('.').map(v => Number.parseInt(v));
  const [majorB, minorB, patchB] = String(b).split('.').map(v => Number.parseInt(v));


  if (majorA > majorB) {
    return true;
  }

  if (majorB > minorA) {
    return false;
  }

  if (minorA > minorB) {
    return true;
  }

  if (minorB > minorA) {
    return false;
  }

  if (patchA > patchB) {
    return true;
  }

  if (patchB > patchA) {
    return false;
  }

  return false;

};


assert(isGreater(versionB, versionA), 'version b should be greater.');
assert(isGreater(versionA, versionB), 'version b should be greater.');

my question is - is there a way to simplify the logic in the greaterThan function? This function is supposed to replicate the logic in semver.gt().

There's the standard npm semver version comparison library, but I have some simple logic to compare semver versions here:

const versionA = '14.8.3';
const versionB = '15.1.1';
const versionC = '15.1.2';

const semver = require('semver');
const assert = require('assert');

const isGreater = (a, b) => {

  const [majorA, minorA, patchA] = String(a).split('.').map(v => Number.parseInt(v));
  const [majorB, minorB, patchB] = String(b).split('.').map(v => Number.parseInt(v));


  if (majorA > majorB) {
    return true;
  }

  if (majorB > minorA) {
    return false;
  }

  if (minorA > minorB) {
    return true;
  }

  if (minorB > minorA) {
    return false;
  }

  if (patchA > patchB) {
    return true;
  }

  if (patchB > patchA) {
    return false;
  }

  return false;

};


assert(isGreater(versionB, versionA), 'version b should be greater.');
assert(isGreater(versionA, versionB), 'version b should be greater.');

my question is - is there a way to simplify the logic in the greaterThan function? This function is supposed to replicate the logic in semver.gt().

• javascript
• node.js
• semantic-versioning

2 Answers 2

You can use localeCompare instead, with the numeric option (with numeric, comparison is such that "1" < "2" < "10"), which is exactly the logic you're looking for:

const versionA = '14.8.3';
const versionB = '15.1.1';
const versionC = '15.1.2';
const versionD = '15.1.10';
const versionE = '15.2.1';
const versionF = '15.11.1';

const isGreater = (a, b) => {
  return a.localeCompare(b, undefined, { numeric: true }) === 1;
};

// first argument version comes later than second argument:
console.log(isGreater(versionB, versionA));
console.log(isGreater(versionC, versionB));
console.log(isGreater(versionD, versionC));
console.log(isGreater(versionE, versionD));
console.log(isGreater(versionF, versionE));

console.log('---');

// second comes before first:
console.log(isGreater(versionA, versionB));

// same, return value should be false:
console.log(isGreater(versionA, versionA));

Or, equivalently, you can pass the locale string

en-US-u-kn-true

as the second parameter instead of { numeric: true }.

I believe this is logically the same and shorter, but not exactly stunning in it's simplicity

const parseInt = (v: string) : number => {
   const num = Number.parseInt(v);
   if(!(Number.isInteger(num) && num > 0)){
      throw new Error('Could not parse positive integer from string')
   }
   return num;
};



 const isGreater = (a: string, b: string) : boolean => {
      
      const [majorA, minorA, patchA] = String(a).split('.').map(parseInt);
      const [majorB, minorB, patchB] = String(b).split('.').map(parseInt);
      
      if (majorA !== majorB) {
        return majorA > majorB;
      }
      
      if (minorA !== minorB) {
        return minorA > minorB;
      }
      
      return patchA > patchB;
      
    };