दिलचस्प पोस्ट
जावा त्रुटि: केवल एक प्रकार का आयात किया जा सकता है XYZ एक पैकेज को हल करता है Backbone.js मॉडल डेटा को सहेजने के तरीके? क्या रब्बी के पास असली मल्टीथ्रेडिंग है? रूट यूआरएल के लिए मैच और स्थिर संसाधनों की सेवा क्रोम और सफारी ब्राउजर (वेबकिट) को कैसे पता चलेगा क्रमिक निर्भरताओं को हेल लाइब्रेरी के लिए ग्रेडेल के माध्यम से हल नहीं किया गया MATLAB में एक विशिष्ट निर्देशिका के अंतर्गत सभी फाइलें कैसे प्राप्त करें? एंड्रॉइड में प्रवेश करने के लिए मैं आउटपुट कैसे लिखूं? ओरेकल में मूल्यों की सूची से मैं कैसे चुन सकता हूं स्प्रिंग-जर्सी में इन-मेमोरी यूनिट परीक्षण कैसे करें टुकड़ा जोड़ने या काम नहीं बदले त्रुटि – SqlDateTime अतिप्रवाह 1/1/1753 12:00:00 पूर्वाह्न और 12/31/9999 11:59:59 अपराह्न के बीच होना चाहिए रिच टेक्स्टबॉक्स स्ट्रिंग के विभिन्न भागों का रंग क्या रीडीम सुरक्षित करता है? क्या फ़ंक्शन के अस्तित्व की जांच करने के लिए टेम्पलेट लिखना संभव है?

सरणी तत्वों को क्रमबद्ध करें (संख्याओं वाला स्ट्रिंग), प्राकृतिक सॉर्ट करें

मेरे पास एक सरणी है;

["IL0 Foo", "PI0 Bar", "IL10 Baz", "IL3 Bob says hello"] 

और इसे सॉर्ट करने की आवश्यकता है, ऐसा लगता है;

 ["IL0 Foo", "IL3 Bob says hello", "IL10 Baz", "PI0 Bar"] 

मैंने एक सॉर्ट फ़ंक्शन की कोशिश की है;

 function compare(a,b) { if (a < b) return -1; if (a > b) return 1; return 0; } 

लेकिन यह आदेश देता है

 ["IL0 Foo", "IL10 Baz", "IL3 Bob says hello", "PI0 Bar"] 

मैंने एक regex के बारे में सोचने की कोशिश की है जो काम करेगी लेकिन मेरे सिर को उसके चारों ओर नहीं मिल सकता है।
यदि यह प्रारूप में मदद करता है तो हमेशा 2 अक्षरों, संख्याओं की संख्या, फिर किसी भी संख्या में वर्ण होंगे।

वेब के समाधान से एकत्रित समाधान "सरणी तत्वों को क्रमबद्ध करें (संख्याओं वाला स्ट्रिंग), प्राकृतिक सॉर्ट करें"

इसे "प्राकृतिक प्रकार" कहा जाता है और इसे जेएस में लागू किया जा सकता है:

 function naturalCompare(a, b) { var ax = [], bx = []; a.replace(/(\d+)|(\D+)/g, function(_, $1, $2) { ax.push([$1 || Infinity, $2 || ""]) }); b.replace(/(\d+)|(\D+)/g, function(_, $1, $2) { bx.push([$1 || Infinity, $2 || ""]) }); while(ax.length && bx.length) { var an = ax.shift(); var bn = bx.shift(); var nn = (an[0] - bn[0]) || an[1].localeCompare(bn[1]); if(nn) return nn; } return ax.length - bx.length; } ///////////////////////// test = [ "img12.png", "img10.png", "img2.png", "img1.png", "img101.png", "img101a.png", "abc10.jpg", "abc10", "abc2.jpg", "20.jpg", "20", "abc", "abc2", "" ]; test.sort(naturalCompare) document.write("<pre>" + JSON.stringify(test,0,3)); 
 var re = /([az]+)(\d+)(.+)/i; var arr = ["IL0 Foo", "PI0 Bar", "IL10 Baz", "IL3 Bob says hello"]; var order = arr.sort( function(a,b){ var ma = a.match(re), mb = b.match(re), a_str = ma[1], b_str = mb[1], a_num = parseInt(ma[2],10), b_num = parseInt(mb[2],10), a_rem = ma[3], b_rem = mb[3]; return a_str > b_str ? 1 : a_str < b_str ? -1 : a_num > b_num ? 1 : a_num < b_num ? -1 : a_rem > b_rem; }); 

मुझे भूगोल का समाधान बहुत पसंद आया, लेकिन मुझे संख्याओं से पहले सॉर्ट करने के लिए अंडरस्कोर ("_") की आवश्यकता थी यहां बताया गया है कि मैंने अपना कोड कैसे संशोधित किया है:

 var chunkRgx = /(_+)|([0-9]+)|([^0-9_]+)/g; function naturalCompare(a, b) { var ax = [], bx = []; a.replace(chunkRgx, function(_, $1, $2, $3) { ax.push([$1 || "0", $2 || Infinity, $3 || ""]) }); b.replace(chunkRgx, function(_, $1, $2, $3) { bx.push([$1 || "0", $2 || Infinity, $3 || ""]) }); while(ax.length && bx.length) { var an = ax.shift(); var bn = bx.shift(); var nn = an[0].localeCompare(bn[0]) || (an[1] - bn[1]) || an[2].localeCompare(bn[2]); if(nn) return nn; } return ax.length - bx.length; } ///////////////////////// test = [ "img12.png", "img10.png", "img2.png", "img1.png", "img101.png", "img101a.png", "abc10.jpg", "abc10", "abc2.jpg", "20.jpg", "20", "abc", "abc2", "_abc", "_ab_c", "_ab__c", "_abc_d", "ab_", "abc_", "_ab_cd", "" ]; test.sort(naturalCompare) document.write("<pre>" + JSON.stringify(test,0,3)); 

अग्रणी संख्याओं के साथ स्ट्रिंग में पैड नंबर, फिर सामान्य रूप से सॉर्ट करें

 var naturalSort = function (a, b) { a = ('' + a).replace(/(\d+)/g, function (n) { return ('0000' + n).slice(-5) }); b = ('' + b).replace(/(\d+)/g, function (n) { return ('0000' + n).slice(-5) }); return a.localeCompare(b); } var naturalSortModern = function (a, b) { return ('' + a).localeCompare(('' + b), 'en', { numeric: true }); } console.dir((["IL0 Foo", "PI0 Bar", "IL10 Baz", "IL3 Bob says hello"].sort(naturalSort))); console.dir((["IL0 Foo", "PI0 Bar", "IL10 Baz", "IL3 Bob says hello"].sort(naturalSortModern))); 

स्ट्रिंग के गैर-संख्यात्मक और संख्यात्मक भागों प्राप्त करने के लिए आप इस तरह एक regex कर सकते हैं:

 var s = "foo124bar23"; s.match(/[^\d]+|\d+/g) 

रिटर्न: ["foo", "124" , "bar" , "23"]

फिर अपने तुलना कार्य में आप दो स्ट्रिंग्स के भाग के माध्यम से उनसे भाग-बाय-पार्ट की तुलना कर सकते हैं। पहले नॉन-मिलान वाले हिस्सा समग्र तुलना का नतीजा निर्धारित करता है। प्रत्येक भाग के लिए, जांच लें कि क्या भाग एक अंक से शुरू होता है और यदि ऐसा है तो तुलना करने से पहले इसे नंबर के रूप में पार्स करें।

एक और विकल्प जोड़ें (क्यों नहीं):

 var ary = ["IL0 Foo", "PI0 Bar", "IL10 Hello", "IL10 Baz", "IL3 Bob says hello"]; // break out the three components in to an array // "IL10 Bar" => ['IL', 10, 'Bar'] function getParts(i){ i = i || ''; var parts = i.match(/^([az]+)([0-9]+)(\s.*)$/i); if (parts){ return [ parts[1], parseInt(parts[2], 10), parts[3] ]; } return []; // erroneous } ary.sort(function(a,b){ // grab the parts var _a = getParts(a), _b = getParts(b); // trouble parsing (both fail = no shift, otherwise // move the troubles element to end of the array) if(_a.length == 0 && _b.length == 0) return 0; if(_a.length == 0) return -1; if(_b.length == 0) return 1; // Compare letter portion if (_a[0] < _b[0]) return -1; if (_a[0] > _b[0]) return 1; // letters are equal, continue... // compare number portion if (_a[1] < _b[1]) return -1; if (_a[1] > _b[1]) return 1; // numbers are equal, continue... // compare remaining string if (_a[2] < _b[2]) return -1; if (_a[2] > _b[2]) return 1; // strings are equal, continue... // exact match return 0; }); 

jsfiddle उदाहरण

सुंदर नहीं, लेकिन पहले दो चार कोडों की जांच करें। अगर सभी समान पर्स और संख्याओं की तुलना करें:

 var arr = ["IL0 Foo", "IL10 Baz", "IL3 Bob says hello", "PI0 Bar"]; arr.sort(function (a1, b1) { var a = parseInt(a1.match(/\d+/g)[0], 10), b = parseInt(b1.match(/\d+/g)[0], 10), letterA = a1.charCodeAt(0), letterB = b1.charCodeAt(0), letterA1 = a1.charCodeAt(1), letterB1 = b1.charCodeAt(1); if (letterA > letterB) { return 1; } else if (letterB > letterA) { return -1; } else { if (letterA1 > letterB1) { return 1; } else if (letterB1 > letterA1) { return -1; } if (a < b) return -1; if (a > b) return 1; return 0; } }); 

उदाहरण

आप options साथ String#localeCompare उपयोग कर सकते हैं

संवेदनशीलता

स्ट्रिंग में कौन-सी अंतर नॉन-शून्य परिणाम मान हो सकते हैं। संभव मान हैं:

  • "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 array = ["IL0 Foo", "PI0 Bar", "IL10 Baz", "IL3 Bob says hello"]; array.sort(function (a,b) { return a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' }); }); console.log(array);