জেএস ব্যবহার করে সফ্টওয়্যার সংস্করণ নম্বরটি কীভাবে তুলনা করবেন? (শুধুমাত্র সংখ্যা)

164

সফ্টওয়্যার সংস্করণ নম্বরটি এখানে:

"1.0", "1.0.1", "2.0", "2.0.0.1", "2.0.1"

আমি কীভাবে এটি তুলনা করতে পারি ?? সঠিক অর্ডারটি ধরুন:

"1.0", "1.0.1", "2.0", "2.0.0.1", "2.0.1"

ধারণাটি সহজ ...: প্রথম সংখ্যাটি পড়ুন, দ্বিতীয়টির চেয়ে দ্বিতীয়টি এর পরে তৃতীয় .... তবে আমি সংস্করণ নম্বরটি ভাসমান সংখ্যায় রূপান্তর করতে পারি না .... আপনিও সংস্করণ নম্বরটি দেখতে পাবেন এই:

"1.0.0.0", "1.0.1.0", "2.0.0.0", "2.0.0.1", "2.0.1.0"

এবং এই পিছনে ধারণাটি কী তা দেখতে আরও স্পষ্ট হয় ... তবে কীভাবে এটি একটি কম্পিউটার প্রোগ্রামে রূপান্তর করবেন ?? এটি বাছাই করার বিষয়ে কারও কোনও ধারণা আছে? ধন্যবাদ.

javascript  sorting 
— Tattat
সূত্র
5
এটি একটি ভাল ফিজবজ-ধরণের সাক্ষাত্কারের প্রশ্ন হবে।
— স্টিভ ক্লারিজ
2
এই কারণেই সমস্ত সফ্টওয়্যার সংস্করণ নম্বরগুলি 2001403 এর মতো পূর্ণসংখ্যার হওয়া উচিত you আপনি যখন এটি "বন্ধুত্বপূর্ণ উপায়ে" 2.0.04.3 "হিসাবে প্রদর্শন করতে চান তবে আপনি উপস্থাপনের সময় সংস্করণ নম্বরটি ফর্ম্যাট করুন।
— জারমড
2
এখানে সাধারণ সমস্যাটি হ'ল সিমান্টিক সংস্করণ তুলনা, এবং এটি তুচ্ছ নয় ( semver.org এ # 11 দেখুন )। সৌভাগ্যক্রমে, এর জন্য একটি অফিসিয়াল লাইব্রেরি রয়েছে, এনপিএমের জন্য অর্থপূর্ণ সংস্করণ ।
— ড্যান ড্যাসকলেসকু
1
সেমভারগুলির সাথে তুলনা করা একটি সহজ স্ক্রিপ্ট পাওয়া গেছে
— vsync

উত্তর:

133

এই তুলনা করার প্রাথমিক ধারণাটি ব্যবহার করা হবে Array.split হ'ল ইনপুট স্ট্রিংগুলি থেকে অংশগুলির অ্যারে পেতে এবং তারপরে দুটি অ্যারে থেকে অংশগুলির জোড়া তুলনা করতে হবে; অংশগুলি সমান না হলে আমরা জানি কোন সংস্করণটি ছোট।

মাথায় রাখতে কয়েকটি গুরুত্বপূর্ণ বিবরণ রয়েছে:

  1. প্রতিটি জুটির অংশগুলি কীভাবে তুলনা করা উচিত? প্রশ্নটি সংখ্যার সাথে তুলনা করতে চায়, তবে আমাদের যদি এমন সংস্করণ স্ট্রিং থাকে যা কেবলমাত্র অঙ্ক (যেমন "1.0a") দিয়ে তৈরি হয় না?
  2. যদি কোনও সংস্করণের স্ট্রিংয়ের অন্যের চেয়ে বেশি অংশ থাকে তবে কী হবে? সম্ভবত "1.0" কে "1.0.1" এর চেয়ে কম বিবেচনা করা উচিত, তবে "1.0.0" এর কী হবে?

আপনি সরাসরি ব্যবহার করতে পারেন এমন একটি বাস্তবায়নের কোড এখানে ( ডকুমেন্টেশন সহ টুকরা ):

function versionCompare(v1, v2, options) {
    var lexicographical = options && options.lexicographical,
        zeroExtend = options && options.zeroExtend,
        v1parts = v1.split('.'),
        v2parts = v2.split('.');

    function isValidPart(x) {
        return (lexicographical ? /^\d+[A-Za-z]*$/ : /^\d+$/).test(x);
    }

    if (!v1parts.every(isValidPart) || !v2parts.every(isValidPart)) {
        return NaN;
    }

    if (zeroExtend) {
        while (v1parts.length < v2parts.length) v1parts.push("0");
        while (v2parts.length < v1parts.length) v2parts.push("0");
    }

    if (!lexicographical) {
        v1parts = v1parts.map(Number);
        v2parts = v2parts.map(Number);
    }

    for (var i = 0; i < v1parts.length; ++i) {
        if (v2parts.length == i) {
            return 1;
        }

        if (v1parts[i] == v2parts[i]) {
            continue;
        }
        else if (v1parts[i] > v2parts[i]) {
            return 1;
        }
        else {
            return -1;
        }
    }

    if (v1parts.length != v2parts.length) {
        return -1;
    }

    return 0;
}

এই সংস্করণটি প্রাকৃতিকভাবে অংশগুলির সাথে তুলনা করে, চরিত্রের প্রত্যয় গ্রহণ করে না এবং "1.7" কে "1.7.0" এর চেয়ে ছোট বলে মনে করে। তুলনা মোডটি অভিধানিক এবং পরিবর্তিত সংক্ষিপ্ত সংস্করণ স্ট্রিং automaticallyচ্ছিক তৃতীয় যুক্তি ব্যবহার করে স্বয়ংক্রিয়ভাবে শূন্য প্যাড করা যেতে পারে।

এখানে একটি জেএসফিডাল রয়েছে যা এখানে "ইউনিট পরীক্ষা" চালায় ; এটি রিপার 234 এর কাজের সামান্য প্রসারিত সংস্করণ (আপনাকে ধন্যবাদ)।

গুরুত্বপূর্ণ দ্রষ্টব্য: এই কোডটি 9 টির আগে IE সংস্করণে চলবে না Array.mapএবং এর Array.everyঅর্থ হল যে আপনি যদি তাদের সমর্থন করতে চান তবে আপনাকে অনুপস্থিত পদ্ধতির জন্য পলিফিল সরবরাহ করতে হবে।

— জন
সূত্র
16
এখানে কয়েকটি ইউনিট পরীক্ষার একটি উন্নত সংস্করণ রয়েছে: jsfiddle.net/ripper234/Xv9WL/28
— ripper234
5
আরে সমস্ত, আমি পরীক্ষাগুলি এবং সমস্ত কিছুর সাথে এই টুকরোটি গিটারপোতে রোল করেছি এবং এটি এনপিএম এবং বোভারে রেখেছি যাতে আমি এটিকে আরও সহজে আমার প্রকল্পগুলিতে অন্তর্ভুক্ত করতে পারি। github.com/gabe0x02/version_compare
— গ্যাব্রিয়েল লিটম্যান
2
@ গ্যাব্রিয়েল লিটম্যান: আরে, এটি করার জন্য সময় দেওয়ার জন্য ধন্যবাদ! তবে এসও - তে সমস্ত কোড ডিফল্টরূপে সিসি-বাই-এসএ-এর সাথে লাইসেন্সযুক্ত । তার অর্থ আপনার প্যাকেজটি জিপিএল-লাইসেন্স থাকতে পারে না। আমি জানি আইনজীবি এখানে কেউ যার জন্য রয়েছে তা নয়, তবে আপনি যদি এটি স্থির করেন তবে ভাল হবে।
— জন
2
@ গ্যাব্রিয়েলিটম্যান: জিপিএল আসলে এই অর্থে খুব সীমাবদ্ধ যে আপনি বিদ্যমান জিপিএল কোডের সংস্পর্শে আসা সমস্ত কোডকে জিপিএল-লাইসেন্স দিতে বাধ্য হন। যাইহোক, ভবিষ্যতের রেফারেন্সের জন্য: একটি ভাল এবং ব্যাপকভাবে ব্যবহৃত "আপনি যা চান তা করুন, কোনও স্ট্রিং সংযুক্ত নেই" লাইসেন্স এমআইটি নয় ।
— জন
3
@ গ্যাব্রিয়েল লিটম্যান: ইতিমধ্যে প্রতিষ্ঠিত গ্রন্থাগারগুলি রয়েছে পাকা দেব দ্বারা রচিত যা সেমভার তুলনা সম্পাদন করে।
— ড্যান ড্যাসক্লেস্কু
82

semver

এনএমপি দ্বারা ব্যবহৃত শব্দার্থক সংস্করণ পার্সার।

। npm ইনস্টল সেমভার

var semver = require('semver');

semver.diff('3.4.5', '4.3.7') //'major'
semver.diff('3.4.5', '3.3.7') //'minor'
semver.gte('3.4.8', '3.4.7') //true
semver.ltr('3.4.8', '3.4.7') //false

semver.valid('1.2.3') // '1.2.3'
semver.valid('a.b.c') // null
semver.clean(' =v1.2.3 ') // '1.2.3'
semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
semver.gt('1.2.3', '9.8.7') // false
semver.lt('1.2.3', '9.8.7') // true

var versions = [ '1.2.3', '3.4.5', '1.0.2' ]
var max = versions.sort(semver.rcompare)[0]
var min = versions.sort(semver.compare)[0]
var max = semver.maxSatisfying(versions, '*')

সিমেন্টিক ভার্সনিং লিঙ্ক : https://www.npmjs.com/package/semver#prere कृपया- পরিচয়দাতা

— মোহাম্মদ আকদিম
সূত্র
8
হ্যাঁ. এটি সঠিক উত্তর - তুলনা করা সংস্করণগুলি অ-তুচ্ছ ( semver.org এ # 11 দেখুন ), এবং সেখানে উত্পাদন-স্তরের লাইব্রেরি রয়েছে যা কাজ করে।
— ড্যান ড্যাসকলেসকু
7
প্রযুক্তিগতভাবে, এটি সঠিক উত্তর নয়, যেহেতু নোড.জেএস এবং জাভাস্ক্রিপ্ট আলাদা। আমার ধারণা ছিল যে মূল প্রশ্নটি ব্রাউজারের জন্য আরও লক্ষ্যবস্তু হয়েছিল। তবে গুগল আমাকে এখানে এনেছে এবং ভাগ্যক্রমে আমি নোড ব্যবহার করছি :)
— লি গ্যারি
2
নোডজেএস কেবল একটি সার্ভার-সাইড কেবলমাত্র সমাধান নয়। ইলেক্ট্রন কাঠামো ডেস্কটপ অ্যাপ্লিকেশনগুলির জন্য একটি নোডজেএস এম্বেড করে। এটি আসলে আমি উত্তরটি খুঁজছিলাম।
— অ্যান্টনি রেমন্ড
2
সেভর এটি একটি এনপিএম প্যাকেজ, এটি কোনও জেএস পরিবেশে ব্যবহার করা যেতে পারে! এই অধিকার উত্তর
— neiker
4
@artuska আচ্ছা, তাহলে কেবল মত অন্য প্যাকেজের জন্য যেতে semver-তুলনা ): 233B (! 0.5kB কম) gzipped -
— Kano
50 
// Return 1 if a > b
// Return -1 if a < b
// Return 0 if a == b
function compare(a, b) {
    if (a === b) {
       return 0;
    }

    var a_components = a.split(".");
    var b_components = b.split(".");

    var len = Math.min(a_components.length, b_components.length);

    // loop while the components are equal
    for (var i = 0; i < len; i++) {
        // A bigger than B
        if (parseInt(a_components[i]) > parseInt(b_components[i])) {
            return 1;
        }

        // B bigger than A
        if (parseInt(a_components[i]) < parseInt(b_components[i])) {
            return -1;
        }
    }

    // If one's a prefix of the other, the longer one is greater.
    if (a_components.length > b_components.length) {
        return 1;
    }

    if (a_components.length < b_components.length) {
        return -1;
    }

    // Otherwise they are the same.
    return 0;
}

console.log(compare("1", "2"));
console.log(compare("2", "1"));

console.log(compare("1.0", "1.0"));
console.log(compare("2.0", "1.0"));
console.log(compare("1.0", "2.0"));
console.log(compare("1.0.1", "1.0"));
— জো
সূত্র
আমি মনে করি যে রেখাটি: var len = Math.min(a_components.length, b_components.length);2.0.1.1 এবং 2.0.1 সংস্করণগুলিকে সমান হিসাবে বিবেচনা করবে?
— জন এগারটন
1
না, লুপের ঠিক পরে দেখুন! যদি একটি স্ট্রিং অন্যটির উপসর্গ হয় (যেমন লুপটি প্রান্তে পৌঁছায়), তবে দীর্ঘতরটি আরও বেশি হিসাবে নেওয়া হয়।
— জো
মন্তব্যে আপনি সম্ভবত ইংরেজী ভাষার উপর আমার হোঁচট খেয়েছিলেন ...
— জো
@ জো আমি জানি কিছুটা পুরানো উত্তর তবে আমি ফাংশনটি ব্যবহার করছিলাম। পরীক্ষামূলকa = '7' দীর্ঘতর হওয়ায় এবং b = '7.0'ফেরত দেয় -1। এর জন্য কোনও পরামর্শ পেয়েছেন? ( console.log(compare("7", "7.0")); //returns -1)
— রাফেলডিডিএল
আমি মনে করি এটি অপরিবর্তিত আচরণের শিরোনামে আসে। আপনার যদি এই সংস্করণ নম্বরগুলি থাকে তবে আমি নিশ্চিত যে আপনার প্রয়োজনীয়তার সাথে মানিয়ে নিতে আপনি যুক্তিটি সংশোধন করতে পারেন।
— জো
48

এটি খুব ছোট, তবুও খুব দ্রুত তুলনা ফাংশনটি কোনও দৈর্ঘ্যের সংস্করণ সংখ্যা এবং প্রতি সেগমেন্টে কোনও সংখ্যার আকার নেয় ।

রিটার্ন মান:
- একটি < 0<b
- একটি সংখ্যা > 0যদি a> বি
-0 যদি a = খ হয়

সুতরাং আপনি এটি অ্যারে.সোর্ট () এর জন্য তুলনা ফাংশন হিসাবে ব্যবহার করতে পারেন ;

সম্পাদনা: "1" এবং "1.0.0" সমান হিসাবে স্বীকৃতি জানাতে বুগফিক্সড সংস্করণ স্ট্রিপিং শূন্যগুলি

function cmpVersions (a, b) {
    var i, diff;
    var regExStrip0 = /(\.0+)+$/;
    var segmentsA = a.replace(regExStrip0, '').split('.');
    var segmentsB = b.replace(regExStrip0, '').split('.');
    var l = Math.min(segmentsA.length, segmentsB.length);

    for (i = 0; i < l; i++) {
        diff = parseInt(segmentsA[i], 10) - parseInt(segmentsB[i], 10);
        if (diff) {
            return diff;
        }
    }
    return segmentsA.length - segmentsB.length;
}

// TEST
console.log(
['2.5.10.4159',
 '1.0.0',
 '0.5',
 '0.4.1',
 '1',
 '1.1',
 '0.0.0',
 '2.5.0',
 '2',
 '0.0',
 '2.5.10',
 '10.5',
 '1.25.4',
 '1.2.15'].sort(cmpVersions));
// Result:
// ["0.0.0", "0.0", "0.4.1", "0.5", "1.0.0", "1", "1.1", "1.2.15", "1.25.4", "2", "2.5.0", "2.5.10", "2.5.10.4159", "10.5"]
স্নিপেট প্রসারিত করুন

— LeJared
সূত্র
'0.0' এবং '0.0.0' দিয়ে ব্যর্থ হয়েছে। ফ্রেড
— এমরাগিনস
1
@ এমরাগিনস আপনার কখন এটি করা দরকার?
— স্কাইলার ইটনার
1
@ এমরাগিনস: এটি কোথায় ব্যর্থ হবে তা আমি দেখতে পাচ্ছি না। এটা তোলে আউটপুট ["0.0.0", "0.0", "0.4.1", "0.5", "1.0.0", "1", "1.1", "1.2.15", "1.25.4", "2", "2.5.0", "2.5.10", "2.5.10.4159", "10.5"] যেখানে আপনার কোড আউটপুট ["0.0", "0.0.0", "0.4.1", "0.5", "1", "1.0.0", "1.1", "1.2.15", "1.25.4", "2", "2.5.0", "2.5.10", "2.5.10.4159", "10.5"] , যা পুরোপুরি একই, 0.0 এবং 0.0.0 থেকে বিবেচনা করা হয় সমান যার মানে এটা অপ্রাসঙ্গিক কিনা '0.0' বিপরীতভাবে সামনে '0.0.0' বা ভাইস হয়।
— লেজারেড
আমি সম্মতি জানাই এটি একটি সাধারণ বিষয়। আমি এটি github.com/jonmiles/bootstrap-treeview দিয়ে ব্যবহার করছি , যা সংস্করণগুলির অনুরূপ পদ্ধতিতে নোড দেয়, কেবল এটি কেবল পিতামাতাদের / শিশু নোড এবং তাদের সূচকগুলি। যাত্রা। পিতামাতা: 0.0, শিশু: 0.0.0, 0.0.1। কেন আমি যত্ন করি সে সম্পর্কে আরও বিশদের জন্য এই সমস্যাটি দেখুন: github.com/jonmiles/bootstrap-treeview/issues/251
— এমারগিনস
1
এখানে উত্তর দেখুন stackoverflow.com/questions/6611824/why-do-we-need-to-use-radix । পুরানো ব্রাউজারগুলি নির্দিষ্ট না করা হলে র‍্যাডিক্স প্যারামিটার অনুমান করতে ব্যবহৃত হয়। "1.09.12" এর মাঝের অংশের মতো একটি সংখ্যার স্ট্রিংয়ের একটি শীর্ষস্থানীয় শূন্যটি মূলা = 8 দিয়ে পার্স করা হত যার ফলস্বরূপ 9 নম্বর প্রত্যাশার পরিবর্তে 0 নম্বর হবে
— লেজারেড
14

Http://java.com/js/deployJava.js থেকে নেওয়া :

    // return true if 'installed' (considered as a JRE version string) is
    // greater than or equal to 'required' (again, a JRE version string).
    compareVersions: function (installed, required) {

        var a = installed.split('.');
        var b = required.split('.');

        for (var i = 0; i < a.length; ++i) {
            a[i] = Number(a[i]);
        }
        for (var i = 0; i < b.length; ++i) {
            b[i] = Number(b[i]);
        }
        if (a.length == 2) {
            a[2] = 0;
        }

        if (a[0] > b[0]) return true;
        if (a[0] < b[0]) return false;

        if (a[1] > b[1]) return true;
        if (a[1] < b[1]) return false;

        if (a[2] > b[2]) return true;
        if (a[2] < b[2]) return false;

        return true;
    }
— user123444555621
সূত্র
সহজ, তবে তিনটি সংস্করণ ক্ষেত্রে সীমাবদ্ধ।
— ড্যান ড্যাসক্লেস্কু
11

আমি এখানে যা চাইছিলাম তা করছে এমন কোনও ফাংশন খুঁজে পেল না। তাই আমি আমার নিজের লিখেছি। এটি আমার অবদান। আমি আশা করি যে কেউ এটি দরকারী হবে।

পেশাদাররা:

  • স্বেচ্ছাসেবী দৈর্ঘ্যের সংস্করণ স্ট্রিং পরিচালনা করে। '1' বা '1.1.1.1.1.1'।

  • নির্দিষ্ট না করে প্রতিটি মানকে ডিফল্ট করে। কেবল একটি স্ট্রিং দীর্ঘ হওয়ার অর্থ এটি বড় সংস্করণ নয়। ('1' '1.0' এবং '1.0.0.0' এর মতো হওয়া উচিত))

  • স্ট্রিং নয় সংখ্যাগুলির সাথে তুলনা করুন ('3' <'21' সত্য হওয়া উচিত false মিথ্যা নয়))

  • লুপে অকেজো তুলনায় সময় নষ্ট করবেন না। (== এর সাথে তুলনা করা)

  • আপনি নিজের তুলনা করতে পারেন চয়ন করতে পারেন।

কনস:

  • এটি সংস্করণ স্ট্রিংয়ে অক্ষরগুলি পরিচালনা করে না। (আমি জানি না যে এটি কীভাবে কাজ করবে?)

আমার কোড, জনের গৃহীত উত্তরের মতো :

function compareVersions(v1, comparator, v2) {
    "use strict";
    var comparator = comparator == '=' ? '==' : comparator;
    if(['==','===','<','<=','>','>=','!=','!=='].indexOf(comparator) == -1) {
        throw new Error('Invalid comparator. ' + comparator);
    }
    var v1parts = v1.split('.'), v2parts = v2.split('.');
    var maxLen = Math.max(v1parts.length, v2parts.length);
    var part1, part2;
    var cmp = 0;
    for(var i = 0; i < maxLen && !cmp; i++) {
        part1 = parseInt(v1parts[i], 10) || 0;
        part2 = parseInt(v2parts[i], 10) || 0;
        if(part1 < part2)
            cmp = 1;
        if(part1 > part2)
            cmp = -1;
    }
    return eval('0' + comparator + cmp);
}

উদাহরণ :

compareVersions('1.2.0', '==', '1.2'); // true
compareVersions('00001', '==', '1.0.0'); // true
compareVersions('1.2.0', '<=', '1.2'); // true
compareVersions('2.2.0', '<=', '1.2'); // false
— ভিক্টর
সূত্র
এই সংস্করণটি আমার মতে অনুমোদিত উত্তরের চেয়ে ভাল!
— ব্যবহারকারী3807877
1
এই ফাংশনটি কোড ইনজেকশন প্রবণ হয় যদি তুলনামূলক প্যারামিটারটি চেক না করা ব্যবহারকারী ইনপুট সহ ব্যবহার করা হয়! উদাহরণ: তুলনা সংস্করণ ('1.2', '== 0; সতর্কতা ("cotcha");', '1.2');
— লেজারেড
পছন্দ করুন যখন আমি এটি লিখেছিলাম আমরা যদিও এটি ব্যবহারকারী জমা দেওয়া কোডের সাথে ব্যবহার করব না। এটি সম্ভবত একটি কন হিসাবে চিহ্নিত করা উচিত ছিল। সেই সম্ভাবনাটি দূর করার জন্য আমি এখন কোডটি আপডেট করেছি। এখন যদিও, যখন ওয়েবপ্যাক এবং অন্যান্য নোড.জেএস বান্ডেলরগুলি প্রচলিত হয়ে উঠেছে, আমি প্রস্তাব দেব যে মোহাম্মদ আকদিমের উপরের উত্তরটি সেমভার ব্যবহার করে প্রায় সবসময়ই এই প্রশ্নের সঠিক উত্তর হবে।
— ভিক্টর
10

সহজ এবং সংক্ষিপ্ত ফাংশন:

function isNewerVersion (oldVer, newVer) {
  const oldParts = oldVer.split('.')
  const newParts = newVer.split('.')
  for (var i = 0; i < newParts.length; i++) {
    const a = parseInt(newParts[i]) || 0
    const b = parseInt(oldParts[i]) || 0
    if (a > b) return true
    if (a < b) return false
  }
  return false
}

পরীক্ষা:

isNewerVersion('1.0', '2.0') // true
isNewerVersion('1.0', '1.0.1') // true
isNewerVersion('1.0.1', '1.0.10') // true
isNewerVersion('1.0.1', '1.0.1') // false
isNewerVersion('2.0', '1.0') // false
isNewerVersion('2', '1.0') // false
isNewerVersion('2.0.0.0.0.1', '2.1') // true
isNewerVersion('2.0.0.0.0.1', '2.0') // false
— আর্থার আরাজো
সূত্র
আপনি এটিকে আরও সহজ করে তুলতে পারেন: const a = ~~ newPartts [i]; আসলে এটি স্ট্রিংটিকে পূর্ণসংখ্যায় রূপান্তর করা সবচেয়ে কার্যকর উপায়, যা 0 পরিবর্তন করে যদি পরিবর্তনশীল অপরিজ্ঞাত হয় বা অ-সংখ্যাসূচক অক্ষর থাকে।
— ভ্যানোম
5

যদি এই ধারণাটি আমি দেখিনি এমন একটি লিঙ্কটিতে ইতিমধ্যে পরিদর্শন করা হয়েছে তবে আমাকে ক্ষমা করুন।

অংশগুলি এ জাতীয় ওজনে যোগ করার সাথে সাথে আমার কিছু সাফল্য আছে:

partSum = this.major * Math.Pow(10,9);
partSum += this.minor * Math.Pow(10, 6);
partSum += this.revision * Math.Pow(10, 3);
partSum += this.build * Math.Pow(10, 0);

যা তুলনা খুব সহজ করেছে (একটি দ্বিগুণ তুলনা)। আমাদের সংস্করণ ক্ষেত্রগুলি 4 টির বেশি নয়।

7.10.2.184  -> 7010002184.0
7.11.0.1385 -> 7011001385.0

আমি আশা করি এটি কারও পক্ষে সহায়তা করবে, কারণ একাধিক শর্তসাপেক্ষে কিছুটা ওভারকিল লাগে।

— Noxin
সূত্র
2
এই ভঙ্গ করবে, যদি this.minor> 999 (প্রধান ওভারল্যাপ হবে)
— Afanasii Kurakin
5

এখানে আরও একটি সংক্ষিপ্ত সংস্করণ যা কোনও সংখ্যক উপ সংস্করণ, প্যাডেড জিরো এবং অক্ষর সহ এমন সংখ্যার সাথে কাজ করে (1.0.0b3)

function compareVer(a, b)
{
    //treat non-numerical characters as lower version
    //replacing them with a negative number based on charcode of each character
    function fix(s)
    {
        return "." + (s.toLowerCase().charCodeAt(0) - 2147483647) + ".";
    }
    a = ("" + a).replace(/[^0-9\.]/g, fix).split('.');
    b = ("" + b).replace(/[^0-9\.]/g, fix).split('.');
    var c = Math.max(a.length, b.length);
    for (var i = 0; i < c; i++)
    {
        //convert to integer the most efficient way
        a[i] = ~~a[i];
        b[i] = ~~b[i];
        if (a[i] > b[i])
            return 1;
        else if (a[i] < b[i])
            return -1;
    }
    return 0;
}

আউটপুট:

0 : a = খ

1 : ক> খ

-1 : ক <বি

1.0.0.0.0.0 = 1.0
1.0         < 1.0.1
1.0b1       < 1.0
1.0a        < 1.0b
1.1         > 1.0.1b
1.1alpha    < 1.1beta
1.1rc1      > 1.1beta
1.0001      > 1.00000.1.0.0.0.01

কোড স্নিপেট দেখান

https://jsfiddle.net/vanowm/p7uvtbor/

— vanowm
সূত্র
5

2017 উত্তর: 

v1 = '20.0.12'; 
v2 = '3.123.12';

compareVersions(v1,v2) 
// return positive: v1 > v2, zero:v1 == v2, negative: v1 < v2 
function compareVersions(v1, v2) {
        v1= v1.split('.')
        v2= v2.split('.')
        var len = Math.max(v1.length,v2.length)
        /*default is true*/
        for( let i=0; i < len; i++)
            v1 = Number(v1[i] || 0);
            v2 = Number(v2[i] || 0);
            if (v1 !== v2) return v1 - v2 ;
            i++;
        }
        return 0;
    }

আধুনিক ব্রাউজারগুলির জন্য সহজতম কোড: 

 function compareVersion2(ver1, ver2) {
      ver1 = ver1.split('.').map( s => s.padStart(10) ).join('.');
      ver2 = ver2.split('.').map( s => s.padStart(10) ).join('.');
      return ver1 <= ver2;
 }

এখানে ধারণাটি সংখ্যাগুলির তুলনা করা তবে স্ট্রিং আকারে। তুলনা কাজ করতে দুটি স্ট্রিং একই দৈর্ঘ্যের হতে হবে। তাই:

"123" > "99" পরিণত "123" > "099"
সংক্ষিপ্ত সংখ্যা "সংশোধন" প্যাডিং

এখানে আমি প্রতিটি অংশকে দশকের দৈর্ঘ্যে শূন্য দিয়ে প্যাডিং করছি তবে উত্তরের জন্য কেবল সহজ স্ট্রিং তুলনা করুন

উদাহরণ:

var ver1 = '0.2.10', ver2=`0.10.2`
//become 
ver1 = '0000000000.0000000002.0000000010'
ver2 = '0000000000.0000000010.0000000002'
// then it easy to see that
ver1 <= ver2 // true
— পেরি মিমন
সূত্র
আপনি compareVersion2ঠিক কি ঘটবে ফাংশন ব্যাখ্যা করবেন ?
— উসমান ওয়াল
ভাল, তারপরে আপনি আরও ভাল সামঞ্জস্যের substringপরিবর্তে ব্যবহার করতে পারেন padStartঅর্থাৎ var zeros = "0000000000"; '0.2.32'.split('.').map( s => zeros.substring(0, zeros.length-s.length) + s ).join('.') আপনাকে দেবেন 0000000000.0000000002.0000000032:)
— উসমান ওয়াল
4

আমার বেশিরভাগ উত্তর উত্তর এখানে উত্তর

/**
 * Compare two semver versions. Returns true if version A is greater than
 * version B
 * @param {string} versionA
 * @param {string} versionB
 * @returns {boolean}
 */
export const semverGreaterThan = function(versionA, versionB){
  var versionsA = versionA.split(/\./g),
    versionsB = versionB.split(/\./g)
  while (versionsA.length || versionsB.length) {
    var a = Number(versionsA.shift()), b = Number(versionsB.shift())
    if (a == b)
      continue
    return (a > b || isNaN(b))
  }
  return false
}
— মিত্র
সূত্র
1
আপনার এটিকে একটি মডিউল তৈরি করা উচিত এবং এটি নোড.জেএস এ রাখা উচিত ততক্ষণে, আমি আপনার কোডটি আপনাকে এন্ট্রিবিউশন দিয়ে চুরি করছি। এই জন্য আপনাকে ধন্যবাদ.
— r3wt
3

যদিও এই প্রশ্ন ইতিমধ্যে অনেক আছে উত্তর রয়েছে, প্রত্যেকে তাদের নিজস্ব বাড়ির উঠোন-ব্রাউন সমাধান প্রচার করে, যদিও এর জন্য আমাদের কাছে (যুদ্ধের) পরীক্ষিত লাইব্রেরিগুলির একটি সম্পূর্ণ বাস্তুতন্ত্র রয়েছে।

এনপিএম , গিটহাব , এক্সে একটি দ্রুত অনুসন্ধান আমাদের কিছু সুন্দর libs দেবে, এবং আমি কয়েকটিটির মধ্য দিয়ে যেতে চাই:

semver-compareএকটি মহান লাইটওয়েট (~ 230B) liberal এর সংক্ষিপ্ত রূপ বিশেষত দরকারী যে আপনি যদি সংস্করণ সংখ্যা দ্বারা বাছাই করতে চান লাইব্রেরির উন্মুক্ত পদ্ধতি আয়, হয় -1, 0বা 1উপযুক্তভাবে।

লিব এর মূল:

module.exports = function cmp (a, b) {
    var pa = a.split('.');
    var pb = b.split('.');
    for (var i = 0; i < 3; i++) {
        var na = Number(pa[i]);
        var nb = Number(pb[i]);
        if (na > nb) return 1;
        if (nb > na) return -1;
        if (!isNaN(na) && isNaN(nb)) return 1;
        if (isNaN(na) && !isNaN(nb)) return -1;
    }
    return 0;
};

compare-semver আকারের চেয়ে বরং বিশাল (~ 4.4 কেবি গিগাবাইট), তবে কিছু দুর্দান্ত অনন্য তুলনা করার জন্য সংস্করণগুলির একটি স্ট্যাকের সর্বনিম্ন / সর্বাধিক সন্ধান করতে বা সরবরাহিত সংস্করণটি অনন্য বা কোনও সংগ্রহের মধ্যে অন্য কোনও কিছুর চেয়ে কম কিনা তা সন্ধান করার অনুমতি দেয় সংস্করণ।

compare-versionsএটি অন্য একটি ছোট লিবি (~ 630 বি গিজিপ) এবং স্পেসটি দুর্দান্তভাবে অনুসরণ করে, যার অর্থ আপনি আলফা / বিটা পতাকা এবং এমনকি ওয়াইল্ডকার্ডের সাথে সংস্করণ তুলনা করতে পারেন (ছোট / প্যাচ সংস্করণের মতো: 1.0.xবা1.0.* )

পয়েন্ট হ'ল: স্ট্যাকওভারফ্লো থেকে সর্বদা কোড কপি-পেস্ট করার দরকার নেই, যদি আপনি পছন্দসই প্যাকেজ ম্যানেজারের মাধ্যমে শালীন, (ইউনিট) পরীক্ষিত সংস্করণগুলি খুঁজে পেতে পারেন ।

— Kano
সূত্র
3

আমি একই ধরণের সমস্যার মুখোমুখি হয়েছিলাম এবং এরই জন্য আমি ইতিমধ্যে একটি সমাধান তৈরি করেছি। এটি চেষ্টা করে নির্দ্বিধায়।

এটির 0জন্য equal, 1যদি সংস্করণটি থাকে greaterএবং -1যদি তা থাকে returnsless

function compareVersion(currentVersion, minVersion) {
  let current = currentVersion.replace(/\./g," .").split(' ').map(x=>parseFloat(x,10))
  let min = minVersion.replace(/\./g," .").split(' ').map(x=>parseFloat(x,10))

  for(let i = 0; i < Math.max(current.length, min.length); i++) {
    if((current[i] || 0) < (min[i] || 0)) {
      return -1
    } else if ((current[i] || 0) > (min[i] || 0)) {
      return 1
    }
  }
  return 0
}


console.log(compareVersion("81.0.1212.121","80.4.1121.121"));
console.log(compareVersion("81.0.1212.121","80.4.9921.121"));
console.log(compareVersion("80.0.1212.121","80.4.9921.121"));
console.log(compareVersion("4.4.0","4.4.1"));
console.log(compareVersion("5.24","5.2"));
console.log(compareVersion("4.1","4.1.2"));
console.log(compareVersion("4.1.2","4.1"));
console.log(compareVersion("4.4.4.4","4.4.4.4.4"));
console.log(compareVersion("4.4.4.4.4.4","4.4.4.4.4"));
console.log(compareVersion("0","1"));
console.log(compareVersion("1","1"));
console.log(compareVersion("1","1.0.00000.0000"));
console.log(compareVersion("","1"));
console.log(compareVersion("10.0.1","10.1"));
স্নিপেট প্রসারিত করুন

— দুর্দান্ত দেব
সূত্র
2

ধারণাটি দুটি সংস্করণের তুলনা করে এবং জানে যেটি সবচেয়ে বড়। আমরা "মুছে ফেলি।" এবং আমরা ভেক্টরের প্রতিটি অবস্থানের সাথে অন্যটির তুলনা করি।

// Return 1  if a > b
// Return -1 if a < b
// Return 0  if a == b

function compareVersions(a_components, b_components) {

   if (a_components === b_components) {
       return 0;
   }

   var partsNumberA = a_components.split(".");
   var partsNumberB = b_components.split(".");

   for (var i = 0; i < partsNumberA.length; i++) {

      var valueA = parseInt(partsNumberA[i]);
      var valueB = parseInt(partsNumberB[i]);

      // A bigger than B
      if (valueA > valueB || isNaN(valueB)) {
         return 1;
      }

      // B bigger than A
      if (valueA < valueB) {
         return -1;
      }
   }
}
— আঙ্গুরের ছিরড়া
সূত্র
মহাকাব্যিক উত্তর, ঠিক আমি যা খুঁজছিলাম।
— ভিন্স
2 
// Returns true if v1 is bigger than v2, and false if otherwise.
function isNewerThan(v1, v2) {
      v1=v1.split('.');
      v2=v2.split('.');
      for(var i = 0; i<Math.max(v1.length,v2.length); i++){
        if(v1[i] == undefined) return false; // If there is no digit, v2 is automatically bigger
        if(v2[i] == undefined) return true; // if there is no digit, v1 is automatically bigger
        if(v1[i] > v2[i]) return true;
        if(v1[i] < v2[i]) return false;
      }
      return false; // Returns false if they are equal
    }
— ডাইলান এম
সূত্র
1
তাই আপনাকে স্বাগতম। এই প্রশ্নের ইতিমধ্যে অনেক ভাল উত্তর রয়েছে, আপনি নতুন কিছু যুক্ত না করা হলে দয়া করে নতুন উত্তর যুক্ত করা থেকে বিরত থাকুন।
— ext
1

replace()ফাংশন শুধুমাত্র স্ট্রিং প্রথম occurence প্রতিস্থাপন করে। সুতরাং, এর .সাথে প্রতিস্থাপন করা যাক ,। এরপরে সমস্ত মুছুন .এবং আবার ,টু করুন .এবং এটিকে প্রবাহিত করতে পার্স করুন।

for(i=0; i<versions.length; i++) {
    v = versions[i].replace('.', ',');
    v = v.replace(/\./g, '');
    versions[i] = parseFloat(v.replace(',', '.'));
}

অবশেষে, এটি বাছাই করুন:

versions.sort();
— সাসচা গ্যালি
সূত্র
1

এই ব্লগ পোস্টটি দেখুন । এই ফাংশনটি সংখ্যাগত সংস্করণ সংখ্যার জন্য কাজ করে।

function compVersions(strV1, strV2) {
  var nRes = 0
    , parts1 = strV1.split('.')
    , parts2 = strV2.split('.')
    , nLen = Math.max(parts1.length, parts2.length);

  for (var i = 0; i < nLen; i++) {
    var nP1 = (i < parts1.length) ? parseInt(parts1[i], 10) : 0
      , nP2 = (i < parts2.length) ? parseInt(parts2[i], 10) : 0;

    if (isNaN(nP1)) { nP1 = 0; }
    if (isNaN(nP2)) { nP2 = 0; }

    if (nP1 != nP2) {
      nRes = (nP1 > nP2) ? 1 : -1;
      break;
    }
  }

  return nRes;
};

compVersions('10', '10.0'); // 0
compVersions('10.1', '10.01.0'); // 0
compVersions('10.0.1', '10.0'); // 1
compVersions('10.0.1', '10.1'); // -1
— ডেভিড
সূত্র
1

উদাহরণস্বরূপ, যদি আমরা বর্তমান jQuery সংস্করণটি 1.8 এর চেয়ে কম কিনা তা পরীক্ষা করে দেখতে চাই , পার্সফ্লোয়েট ("1.10.1") ফেরত আসার পরে সংস্করণ "1.10.1" থাকলে parseFloat($.ui.version) < 1.8 )কোনও ভুল ফলাফল দিতে পারে 1.1। একটি স্ট্রিং তুলনাও ভুল হতে হবে, যেহেতু "1.8" < "1.10"মূল্যায়ন করেfalse ।

সুতরাং আমাদের এই মত একটি পরীক্ষা প্রয়োজন

if(versionCompare($.ui.version, "1.8") < 0){
    alert("please update jQuery");
}

নিম্নলিখিত ফাংশন এটি সঠিকভাবে পরিচালনা করে:

/** Compare two dotted version strings (like '10.2.3').
 * @returns {Integer} 0: v1 == v2, -1: v1 < v2, 1: v1 > v2
 */
function versionCompare(v1, v2) {
    var v1parts = ("" + v1).split("."),
        v2parts = ("" + v2).split("."),
        minLength = Math.min(v1parts.length, v2parts.length),
        p1, p2, i;
    // Compare tuple pair-by-pair. 
    for(i = 0; i < minLength; i++) {
        // Convert to integer if possible, because "8" > "10".
        p1 = parseInt(v1parts[i], 10);
        p2 = parseInt(v2parts[i], 10);
        if (isNaN(p1)){ p1 = v1parts[i]; } 
        if (isNaN(p2)){ p2 = v2parts[i]; } 
        if (p1 == p2) {
            continue;
        }else if (p1 > p2) {
            return 1;
        }else if (p1 < p2) {
            return -1;
        }
        // one operand is NaN
        return NaN;
    }
    // The longer tuple is always considered 'greater'
    if (v1parts.length === v2parts.length) {
        return 0;
    }
    return (v1parts.length < v2parts.length) ? -1 : 1;
}

এখানে কিছু উদাহরন:

// compare dotted version strings
console.assert(versionCompare("1.8",      "1.8.1")    <   0);
console.assert(versionCompare("1.8.3",    "1.8.1")    >   0);
console.assert(versionCompare("1.8",      "1.10")     <   0);
console.assert(versionCompare("1.10.1",   "1.10.1")   === 0);
// Longer is considered 'greater'
console.assert(versionCompare("1.10.1.0", "1.10.1")   >   0);
console.assert(versionCompare("1.10.1",   "1.10.1.0") <   0);
// Strings pairs are accepted
console.assert(versionCompare("1.x",      "1.x")      === 0);
// Mixed int/string pairs return NaN
console.assert(isNaN(versionCompare("1.8", "1.x")));
//works with plain numbers
console.assert(versionCompare("4", 3)   >   0);

একটি লাইভ নমুনা এবং পরীক্ষা স্যুট জন্য এখানে দেখুন: http://jsfiddle.net/mar10/8KjvP/

— mar10
সূত্র
আরঘ, সবেমাত্র লক্ষ্য করা গেছে যে রিপার 234 কয়েকমাস আগে মন্তব্যগুলিতে একটি ফিডাল ইউআরএল পোস্ট করেছিল যা বেশ অনুরূপ। যাইহোক, আমি আমার উত্তর এখানে
— রাখি
এই ক্ষেত্রে এই ক্ষেত্রে (প্রায়শই বেশিরভাগ রূপগুলিও ব্যর্থ হবে): সংস্করণকম্পার ('1.09', '1.1') "1" প্রদান করে, সংস্করণকম্পের ('1.702', '1.8') এর মতোই।
— shaman.sir
কোডটি "1.09"> "1.1" এবং "1.702"> "1.8" মূল্যায়ন করে, যা আমি সঠিক বলে মনে করি। আপনি যদি সম্মত না হন: আপনি কি এমন কোনও সংস্থানকে নির্দেশ করতে পারেন যা আপনার মতামতকে সমর্থন করে?
— mar10
এটি আপনার নীতিগুলির উপর নির্ভর করে - যেহেতু আমি জানি কোনও কঠোর নিয়ম বা কিছু নেই। সংস্থানগুলি সম্পর্কে, "ক্রমবর্ধমান ক্রম" এর "সফ্টওয়্যার সংস্করণ" এর উইকিপিডিয়া নিবন্ধ বলছে যে 1.81 1.8 এর একটি ছোট সংস্করণ হতে পারে, সুতরাং 1.8 কে 1.80 পড়তে হবে। শব্দার্থক সংস্করণ নিবন্ধ semver.org/spec/v2.0.0.html আরও বলেছে যে 1.9.0 -> 1.10.0 -> 1.11.0, সুতরাং 1.9.0 এর তুলনায় 1.90.0 হিসাবে বিবেচিত হবে। সুতরাং, এই যুক্তি অনুসরণ করে, 1.702 সংস্করণটি 1.8 সংস্করণের আগে ছিল, যা 1.800 হিসাবে বিবেচিত হয়।
— shaman.sir
1
আমি দেখতে পাচ্ছি যে কিছু বিধি 1.8 <1.81 <1.9 ব্যবহার করে। তবে সেমেভারে আপনি 1.81 এর পরিবর্তে 1.8.1 ব্যবহার করবেন। সেমভার (যেমন আমি এটি বুঝতে পারি) এই অনুমানের চারপাশে সংজ্ঞায়িত করা হয়েছে যে কোনও অংশ বাড়ানো সর্বদা একটি 'পরে' সংস্করণ তৈরি করে, সুতরাং 1.8 <1.8.1 <1.9 <1.10 <1.81 <1.90 <1.100। আমি কোনও ইঙ্গিত দেখতে পাচ্ছি না যে এটি দুটি অঙ্কের মধ্যেই সীমাবদ্ধ। সুতরাং আমি বলব যে আমার কোডটি সেমভারের সাথে সম্পূর্ণরূপে মেনে চলে।
— mar10
1

এখানে অ্যারে ব্যবহারের জন্য উপযুক্ত একটি কফিসিপি বাস্তবায়ন রয়েছে other

# Returns > 0 if v1 > v2 and < 0 if v1 < v2 and 0 if v1 == v2
compareVersions = (v1, v2) ->
  v1Parts = v1.split('.')
  v2Parts = v2.split('.')
  minLength = Math.min(v1Parts.length, v2Parts.length)
  if minLength > 0
    for idx in [0..minLength - 1]
      diff = Number(v1Parts[idx]) - Number(v2Parts[idx])
      return diff unless diff is 0
  return v1Parts.length - v2Parts.length
— LOAS
সূত্র
এটি লেজারেডের উত্তরে অনুপ্রাণিত ।
— ড্যান ড্যাসকলেসকু
এটি সঠিকভাবে কাজ করছে না ... এখানে ফলাফল .. ফলাফল ['১.১.২.২০১' ',' ২.১.১ ',' ৩.৩.১.০ ',' ৩.১.১.০ ']
— এরতান ২০০২ ২৩'১৯
1

সংস্করণ বাছাইয়ের জন্য আমি একটি নোড মডিউল লিখেছি, আপনি এটি এখানে পেতে পারেন: সংস্করণ-বাছাই

বৈশিষ্ট্য :

  • '1.0.1.5.53.54654.114.1.154.45' সিকোয়েন্সের কোনও সীমা নেই
  • ক্রম দৈর্ঘ্যের সীমা নেই: '1.1546515465451654654654654138754431574364321353734' কাজ
  • সংস্করণ অনুসারে অবজেক্টগুলিকে বাছাই করতে পারেন (পড়ুন দেখুন)
  • পর্যায় (আলফা, বিটা, আরসি 1, আরসি 2 এর মতো)

আপনার যদি অন্য কোনও বৈশিষ্ট্যের প্রয়োজন হয় তবে সমস্যাটি খুলতে দ্বিধা করবেন না।

— কোয়ান্টিন রোসেটি
সূত্র
1

এটি কোনও সময়ের দ্বারা পৃথক পৃথক কোনও দৈর্ঘ্যের সংখ্যাগত সংস্করণগুলির জন্য কাজ করে। এটি কেবলমাত্র সত্যই প্রত্যাবর্তন করে যদি myVersion> = = সর্বনিম্ন সংস্করণ হয়, এই ধারণাটি তৈরি করে যে সংস্করণ 1টি 1.0 এর চেয়ে কম, সংস্করণ 1.1 1.1.0 এর চেয়ে কম এবং এই জাতীয়। সংখ্যা গ্রহণ করা (কেবল একটি স্ট্রিংয়ে রূপান্তর করা) এবং হেক্সাডেসিমাল বা ডিলিমিটার গতিশীল করার মতো অতিরিক্ত শর্ত যুক্ত করার পক্ষে মোটামুটি সহজ হওয়া উচিত (কেবলমাত্র একটি সীমান্তের প্যারামিটার যোগ করুন তারপরে "।" এর সাথে প্রতিস্থাপন করুন)

function versionCompare(myVersion, minimumVersion) {

    var v1 = myVersion.split("."), v2 = minimumVersion.split("."), minLength;   

    minLength= Math.min(v1.length, v2.length);

    for(i=0; i<minLength; i++) {
        if(Number(v1[i]) > Number(v2[i])) {
            return true;
        }
        if(Number(v1[i]) < Number(v2[i])) {
            return false;
        }           
    }

    return (v1.length >= v2.length);
}

এখানে কিছু পরীক্ষা দেওয়া হল:

console.log(versionCompare("4.4.0","4.4.1"));
console.log(versionCompare("5.24","5.2"));
console.log(versionCompare("4.1","4.1.2"));
console.log(versionCompare("4.1.2","4.1"));
console.log(versionCompare("4.4.4.4","4.4.4.4.4"));
console.log(versionCompare("4.4.4.4.4.4","4.4.4.4.4"));
console.log(versionCompare("0","1"));
console.log(versionCompare("1","1"));
console.log(versionCompare("","1"));
console.log(versionCompare("10.0.1","10.1"));

বিকল্পভাবে এখানে একটি পুনরাবৃত্তি সংস্করণ

function versionCompare(myVersion, minimumVersion) {
  return recursiveCompare(myVersion.split("."),minimumVersion.split("."),Math.min(myVersion.length, minimumVersion.length),0);
}

function recursiveCompare(v1, v2,minLength, index) {
  if(Number(v1[index]) < Number(v2[index])) {
    return false;
  }
  if(Number(v1[i]) < Number(v2[i])) {
    return true;
    }
  if(index === minLength) {
    return (v1.length >= v2.length);
  }
  return recursiveCompare(v1,v2,minLength,index+1);
}
— শুল্জ
সূত্র
1

আমি তাদের তুলনা করার একটি সহজ উপায় খুঁজে পেয়েছি, আপনি এটি যা চান তা নিশ্চিত হন না। আমি যখন কনসোলে কোডের নীচে চলেছি তখন তা বোধগম্য হয় এবং সাজানোর () পদ্ধতি ব্যবহার করে আমি সংস্করণগুলির স্ট্রিংয়ের সাজানো অ্যারে পেতে পারি। এটি বর্ণানুক্রমিক ক্রমের উপর ভিত্তি করে।

"1.0" < "1.0.1" //true
var arr = ["1.0.1", "1.0", "3.2.0", "1.3"]
arr.sort();     //["1.0", "1.0.1", "1.3", "3.2.0"]
— inoutwhy
সূত্র
3
এটি দুই-সংখ্যার সংস্করণ সংখ্যাগুলির জন্য ভাল কাজ করে না, উদাহরণস্বরূপ, 1.10.0।
— লিউকিপ
1

আপনি String#localeCompareসাথে ব্যবহার করতে পারেoptions

সংবেদনশীলতা

স্ট্রিংগুলির মধ্যে কোন পার্থক্যগুলির ফলে অ-শূন্য ফলাফলের মান হওয়া উচিত। সম্ভাব্য মানগুলি হ'ল:

  • "base": কেবল বেস অক্ষরে পৃথক স্ট্রিংগুলি অসম হিসাবে তুলনা করে। উদাহরণ: a ≠ b, a = á, a = A।
  • "accent": কেবলমাত্র বেজ অক্ষর বা উচ্চারণ এবং অন্যান্য ডায়াক্রিটিক চিহ্নগুলির মধ্যে পৃথক স্ট্রিংগুলি অসম হিসাবে তুলনা করে। উদাহরণ: a ≠ b, a ≠ á,a = A ।
  • "case": কেবলমাত্র বেসের অক্ষর বা ক্ষেত্রে পৃথক স্ট্রিংগুলি অসম হিসাবে তুলনা করে। উদাহরণ: a ≠ b, a = á, a ≠ A।
  • "variant": স্ট্রিংগুলি যা বেস চিঠিগুলি, অ্যাকসেন্ট এবং অন্যান্য ডায়াক্রিটিক চিহ্নগুলিতে পৃথক হয় বা ক্ষেত্রে অসম হিসাবে তুলনা করে। অন্যান্য পার্থক্যও বিবেচনায় নেওয়া যেতে পারে। উদাহরণ: a ≠ b, a ≠ á, a ≠ A।

ডিফল্টটি "সাজানোর" ব্যবহারের জন্য "বৈকল্পিক"; এটি "অনুসন্ধান" ব্যবহারের জন্য স্থানীয়ভাবে নির্ভরশীল।

সাংখ্যিক

সংখ্যার কোলেশন ব্যবহার করা উচিত কিনা, যেমন "1" <"2" <"10"। সম্ভাব্য মানগুলি trueএবং false; ডিফল্ট হয় false। এই বিকল্পটি কোনও বিকল্পের সম্পত্তি বা একটি ইউনিকোড এক্সটেনশন কী দ্বারা সেট করা যেতে পারে; যদি উভয় সরবরাহ করা হয়, optionsসম্পত্তি অগ্রাধিকার নেয়। এই সম্পত্তি সমর্থন করার জন্য বাস্তবায়নের প্রয়োজন হয় না।

var versions = ["2.0.1", "2.0", "1.0", "1.0.1", "2.0.0.1"];

versions.sort((a, b) => a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' }));

console.log(versions);
স্নিপেট প্রসারিত করুন

— নিনা শোল্জ
সূত্র
এটি আসলে কীভাবে কাজ করে? উপরেরটি কী undefined, ভাষা? আমি অন্যদের পড়ার সময় আপনি কীভাবে এটি পোস্ট করতে পারেন?)
— এমপি্লুঞ্জন
undefinedএটি লোকেল অংশ, এখানে ব্যবহৃত হয় না।
— নিনা স্কলজ
0

আপনি তাদের সংখ্যায় রূপান্তর করতে পারেন এবং তারপরে আকার অনুসারে বাছাই করতে পারেন? দৈর্ঘ্যে <4 টি সংখ্যাতে 0 গুলি যুক্ত করুন

কনসোলের চারপাশে খেলা: 

$(["1.0.0.0", "1.0.1.0", "2.0.0.0", "2.0.0.1", "2.0.1", "3.0"]).each(function(i,e) {
    var n =   e.replace(/\./g,"");
    while(n.length < 4) n+="0" ; 
    num.push(  +n  )
});

বড় সংস্করণ, বড় সংখ্যা। সম্পাদনা: সম্ভবত বড় সংস্করণ সিরিজের অ্যাকাউন্টে সামঞ্জস্য করা দরকার

— বিরূদ্ধে
সূত্র
এটি কেবল একটি উদাহরণ ছিল, যেহেতু তিনি নিজে কিছু কাজ করতে পেরেছেন: পি এর পরিবর্তে 4 টির পরিবর্তে, বৃহত্তম সংস্করণটির সংখ্যার পরিমাণ পান, তারপরে 0 এর চেয়ে কম সংখ্যক পূরণ করুন
— কনট্রা
0

এটি একটি ঝরঝরে কৌশল। আপনি যদি মানগুলির একটি নির্দিষ্ট পরিসরের মধ্যে সাংখ্যিক মানগুলি নিয়ে কাজ করে থাকেন তবে আপনি সংস্করণ অবজেক্টের প্রতিটি স্তরের একটি মান নির্ধারণ করতে পারেন। উদাহরণস্বরূপ "বৃহত্তমতম মূল্য" এখানে 0xFF তে সেট করা আছে, যা আপনার সংস্করণে খুব "আইপি" ধরণের তৈরি করে।

এটি আলফা-সংখ্যাগত সংস্করণ (উদাহরণস্বরূপ 1.2a <1.2b) পরিচালনা করে

// The version compare function
function compareVersion(data0, data1, levels) {
    function getVersionHash(version) {
        var value = 0;
        version = version.split(".").map(function (a) {
            var n = parseInt(a);
            var letter = a.replace(n, "");
            if (letter) {
                return n + letter[0].charCodeAt() / 0xFF;
            } else {
                return n;
            }
        });
        for (var i = 0; i < version.length; ++i) {
            if (levels === i) break;
            value += version[i] / 0xFF * Math.pow(0xFF, levels - i + 1);
        }
        return value;
    };
    var v1 = getVersionHash(data0);
    var v2 = getVersionHash(data1);
    return v1 === v2 ? -1 : v1 > v2 ? 0 : 1;
};
// Returns 0 or 1, correlating to input A and input B
// Direct match returns -1
var version = compareVersion("1.254.253", "1.254.253a", 3);
— মাইকেল ডিল
সূত্র
0

আমি সংস্করণ থেকে @ mar10 , আমার দৃষ্টিকোণ থেকে, ভুল ব্যবহার একটি সুযোগ যদিও (এটা ঘটনা না যদি সংস্করণের সাথে সামঞ্জস্যপূর্ণ বলে মনে হয় শব্দার্থিক ভারশনিং ডকুমেন্ট, কিন্তু যদি কিছু "বিল্ড নম্বর" ব্যবহার করা হয় মামলা হতে পারে ):

versionCompare( '1.09', '1.1');  // returns 1, which is wrong:  1.09 < 1.1
versionCompare('1.702', '1.8');  // returns 1, which is wrong: 1.702 < 1.8

এখানে সমস্যাটি হ'ল সংস্করণ সংখ্যার উপ-সংখ্যাগুলি হ'ল কিছু ক্ষেত্রে, পিছনের শূন্যগুলি দিয়ে কাটা হয়েছে (কমপক্ষে আমি সম্প্রতি এটি বিভিন্ন সফ্টওয়্যার ব্যবহার করার সময় দেখেছি) যা কোনও সংখ্যার যুক্তিযুক্ত অংশের মতো, তাই:

5.17.2054 > 5.17.2
5.17.2 == 5.17.20 == 5.17.200 == ... 
5.17.2054 > 5.17.20
5.17.2054 > 5.17.200
5.17.2054 > 5.17.2000
5.17.2054 > 5.17.20000
5.17.2054 < 5.17.20001
5.17.2054 < 5.17.3
5.17.2054 < 5.17.30

প্রথম (বা প্রথম এবং দ্বিতীয় উভয়) সংস্করণ উপ-সংখ্যাটি অবশ্য সর্বদা পূর্ণসংখ্যার মান হিসাবে বিবেচিত হয় যা এটি আসলে সমান।

আপনি যদি এই ধরণের সংস্করণ ব্যবহার করেন তবে উদাহরণের মধ্যে আপনি কয়েকটি লাইন পরিবর্তন করতে পারেন:

// replace this:
p1 = parseInt(v1parts[i], 10);
p2 = parseInt(v2parts[i], 10);
// with this:
p1 = i/* > 0 */ ? parseFloat('0.' + v1parts[i], 10) : parseInt(v1parts[i], 10);
p2 = i/* > 0 */ ? parseFloat('0.' + v2parts[i], 10) : parseInt(v2parts[i], 10);

সুতরাং প্রথমটি বাদে প্রতিটি উপ-নম্বরকে একটি ভাসমান হিসাবে তুলনা করা হবে 09এবং তাই 1হয়ে যাবে 0.09এবং 0.1সেই অনুসারে এবং সঠিকভাবে এইভাবে তুলনা করা হবে । 2054এবং 3হয়ে যাবে 0.2054এবং0.3 ।

এর পরে সম্পূর্ণ সংস্করণটি হ'ল (ক্রেডিট @ মার 10 ):

/** Compare two dotted version strings (like '10.2.3').
 * @returns {Integer} 0: v1 == v2, -1: v1 < v2, 1: v1 > v2
 */
function versionCompare(v1, v2) {
    var v1parts = ("" + v1).split("."),
        v2parts = ("" + v2).split("."),
        minLength = Math.min(v1parts.length, v2parts.length),
        p1, p2, i;
    // Compare tuple pair-by-pair. 
    for(i = 0; i < minLength; i++) {
        // Convert to integer if possible, because "8" > "10".
        p1 = i/* > 0 */ ? parseFloat('0.' + v1parts[i], 10) : parseInt(v1parts[i], 10);;
        p2 = i/* > 0 */ ? parseFloat('0.' + v2parts[i], 10) : parseInt(v2parts[i], 10);
        if (isNaN(p1)){ p1 = v1parts[i]; } 
        if (isNaN(p2)){ p2 = v2parts[i]; } 
        if (p1 == p2) {
            continue;
        }else if (p1 > p2) {
            return 1;
        }else if (p1 < p2) {
            return -1;
        }
        // one operand is NaN
        return NaN;
    }
    // The longer tuple is always considered 'greater'
    if (v1parts.length === v2parts.length) {
        return 0;
    }
    return (v1parts.length < v2parts.length) ? -1 : 1;
}

পিএস এটি ধীর, তবে একই তুলনা ফাংশনটি পুনরায় ব্যবহার করে স্ট্রিংটি আসলে অক্ষরের অ্যারে ব্যবহার করে তা ভাবতেও সম্ভব:

 function cmp_ver(arr1, arr2) {
     // fill the tail of the array with smaller length with zeroes, to make both array have the same length
     while (min_arr.length < max_arr.length) {
         min_arr[min_arr.lentgh] = '0';
     }
     // compare every element in arr1 with corresponding element from arr2, 
     // but pass them into the same function, so string '2054' will act as
     // ['2','0','5','4'] and string '19', in this case, will become ['1', '9', '0', '0']
     for (i: 0 -> max_length) {
         var res = cmp_ver(arr1[i], arr2[i]);
         if (res !== 0) return res;
     }
 }
— shaman.sir
সূত্র
0

আমি এটি কনসের ধারণার ভিত্তিতে তৈরি করেছি এবং এটি জাভা সংস্করণ "1.7.0_45" এর জন্য অনুকূলিত করেছি। এটি কেবল একটি ফাংশন যা কোনও সংস্করণ স্ট্রিংকে একটি ফ্লোটে রূপান্তরিত করতে বোঝায়। এটি ফাংশন:

function parseVersionFloat(versionString) {
    var versionArray = ("" + versionString)
            .replace("_", ".")
            .replace(/[^0-9.]/g, "")
            .split("."),
        sum = 0;
    for (var i = 0; i < versionArray.length; ++i) {
        sum += Number(versionArray[i]) / Math.pow(10, i * 3);
    }
    console.log(versionString + " -> " + sum);
    return sum;
}

স্ট্রিং "1.7.0_45" 1.007000045000000001 এ রূপান্তরিত হয়েছে এবং এটি একটি সাধারণ তুলনার জন্য যথেষ্ট ভাল। ত্রুটিটি এখানে ব্যাখ্যা করা হয়েছে: জাভাস্ক্রিপ্টে ভাসমান পয়েন্ট নম্বর যথার্থতা কীভাবে মোকাবেলা করতে হবে? । আরও বেশি প্রয়োজন হলে যে কোনও অংশে 3 ডিজিট করে আপনি ডিভাইডার পরিবর্তন করতে পারেনMath.pow(10, i * 3); ।

আউটপুট এর মতো দেখতে পাবেন:

1.7.0_45         > 1.007000045
ver 1.7.build_45 > 1.007000045
1.234.567.890    > 1.23456789
— অ্যাড্রিয়ান এস
সূত্র
0

আমি সংস্করণ তুলনা একই সমস্যা ছিল, কিন্তু সংস্করণ সম্ভবত কিছু রয়েছে (যেমন: বিভাজক যে বিন্দু ছিল না, আরসি 1, আরসি 2 এর মতো এক্সটেনশন ...)।

আমি এটি ব্যবহার করেছি, যা মূলত সংস্করণটির স্ট্রিংগুলিকে সংখ্যা এবং অ-সংখ্যাগুলিতে বিভক্ত করে এবং সেই অনুসারে সেই সাথে তুলনা করার চেষ্টা করে।

function versionCompare(a,b) {
  av = a.match(/([0-9]+|[^0-9]+)/g)
  bv = b.match(/([0-9]+|[^0-9]+)/g)
  for (;;) {
    ia = av.shift();
    ib = bv.shift();
    if ( (typeof ia === 'undefined') && (typeof ib === 'undefined') ) { return 0; }
    if (typeof ia === 'undefined') { ia = '' }
    if (typeof ib === 'undefined') { ib = '' }

    ian = parseInt(ia);
    ibn = parseInt(ib);
    if ( isNaN(ian) || isNaN(ibn) ) {
      // non-numeric comparison
      if (ia < ib) { return -1;}
      if (ia > ib) { return 1;}
    } else {
      if (ian < ibn) { return -1;}
      if (ian > ibn) { return 1;}
    }
  }
}

কিছু ক্ষেত্রে এখানে কিছু অনুমান রয়েছে, উদাহরণস্বরূপ: "1.01" === "1.1", বা "1.8" <"1.71"। এটি "1.0.0-rc.1" <"1.0.0" পরিচালিত করতে ব্যর্থ হয়েছে, যেমনটি সিনেমিক সংস্করণ ২.০.০ দ্বারা নির্দিষ্ট করা হয়েছে

— ঊরীয়েল
সূত্র
0

বাছাইয়ের পূর্বে সংস্করণগুলি প্রসেস করা মানে পার্সইন্টকে অযথা একাধিকবার বলা হয় না। মাইকেল ডিলের পরামর্শের মতো অ্যারে # মানচিত্রটি ব্যবহার করে, এখানে একটি স্ট্যান্ডার্ড 3 পার্ট সেমভারের সর্বশেষতম সংস্করণটি খুঁজে পেতে আমি একটি ধরণের ব্যবহার করছি:

var semvers = ["0.1.0", "1.0.0", "1.1.0", "1.0.5"];

var versions = semvers.map(function(semver) {
    return semver.split(".").map(function(part) {
        return parseInt(part);
    });
});

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

var newest = versions[0].join(".");
console.log(newest); // "1.1.0"
স্নিপেট প্রসারিত করুন

— theGecko
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.