दिलचस्प पोस्ट
didSelectRowAtIndexPath: नहीं बुलाया जा रहा है क्लास के कन्स्ट्रक्टर फ़ंक्शन में एक मान रिटर्निंग कौन सा निर्भरता इंजेक्शन उपकरण मैं इस्तेमाल करना चाहिए? स्कैनर .nextLine () का उपयोग करना एक नई एंड्रॉइड सूचना का पता लगाएं फेसबुक शेयर यूआरएल थंबनेल समस्या OS X "El Capitan" पर रत्न स्थापित नहीं कर सकता एप्लिकेशन की शुरुआती गतिविधि बदलें कैसे ListView में एक पाद लेख जोड़ने के लिए? डिजिटल सर्टिफिकेट: .truststore फ़ाइल का उपयोग करने के लिए .cer फाइल कैसे आयात करें? पायथन कक्षा का आईडी अद्वितीय क्यों नहीं है, जब इसे जल्दी से बुलाया जाता है? एनजी-क्लिक गतिशील रूप से उत्पन्न HTML से काम नहीं कर रहा है फोर्ट्रान में मॉड्यूल, सबरॉरीनेस और फ़ंक्शन का सही उपयोग बाल नोड सूचकांक प्राप्त करें एक आइफ्रेम के भीतर से तत्व प्राप्त करें

क्या शफ़ल करने के लिए JavaScript Array.sort () विधि का उपयोग करना सही है?

मैं किसी को अपने जावास्क्रिप्ट कोड के साथ मदद कर रहा था और मेरी आँखें उस अनुभाग द्वारा पकड़ी गईं जो उस तरह दिख रही थी:

function randOrd(){ return (Math.round(Math.random())-0.5); } coords.sort(randOrd); alert(coords); 

मेरी पहली हालांकि थी: हे, यह संभवतः काम नहीं कर सकता! लेकिन फिर मैंने कुछ प्रयोग किया और पाया कि यह वास्तव में कम से कम अच्छी तरह से यादृच्छिक परिणाम प्रदान करने लगता है।

तब मैंने कुछ वेब खोज की और लगभग शीर्ष पर एक लेख मिला जिसमें से यह कोड सबसे अधिक प्रतिलिपि बना हुआ था। एक सुंदर सम्मानजनक साइट और लेखक की तरह देखा …

लेकिन मेरे पेट की भावना मुझे बताती है, यह गलत होगा। विशेष रूप से सॉर्टिंग एल्गोरिदम ECMA मानक द्वारा निर्दिष्ट नहीं है मुझे लगता है कि विभिन्न सॉर्टिंग एल्गोरिदम के परिणामस्वरूप अलग अलग गैर-यूनिफॉर्म शफल्स होंगे कुछ सॉर्टिंग एल्गोरिदम शायद असीमित लूप भी हो सकता है …

लेकिन आप क्या सोचते हैं?

और एक और सवाल के रूप में … मैं अब कैसे जाउंगा और मापूंगा कि कैसे इस फेरबदल तकनीक का परिणाम यादृच्छिक होगा?

अद्यतन: मैंने कुछ मापन किया और परिणामों में से एक के रूप में नीचे दिए गए परिणामों को पोस्ट किया।

Solutions Collecting From Web of "क्या शफ़ल करने के लिए JavaScript Array.sort () विधि का उपयोग करना सही है?"

यह कभी मेरा पसंदीदा तरीका फेरबदल नहीं रहा, आंशिक रूप से क्योंकि यह कार्यान्वयन-विशिष्ट है जैसा कि आप कहते हैं। विशेष रूप से, मुझे याद आ रहा है कि मानक पुस्तकालय या तो जावा या .नेट से सॉर्ट किया गया है (सुनिश्चित नहीं है कि) जो अक्सर पता लगा सकते हैं कि आप कुछ तत्वों के बीच एक असंगत तुलना के साथ समाप्त होते हैं (उदाहरण के लिए आप पहली बार A < B and B < C , लेकिन फिर C < A )।

यह वास्तव में जरूरत से ज्यादा जटिल (निष्पादन समय के मामले में) फेरबदल के रूप में समाप्त होता है

मैं फेरबदल एल्गोरिथम को पसंद करता हूं जो संग्रह को प्रभावी ढंग से "फेक" में संग्रहित करता है (संग्रह की शुरुआत में, शुरू में खाली) और "अस्थुलित" (शेष संग्रह)। एल्गोरिथ्म के प्रत्येक चरण पर, एक यादृच्छिक निर्बाध तत्व चुनें (जो पहले वाला हो सकता है) और इसे पहले असंतुष्ट तत्व के साथ स्वैप करें – फिर उसे फेरबदल (यानी मानसिक रूप से विभाजन को इसमें शामिल करने के लिए ले जाएँ) के रूप में लें।

यह ओ (एन) है और केवल यादृच्छिक संख्या जनरेटर के लिए n-1 कॉल की आवश्यकता है, जो कि अच्छा है। यह एक वास्तविक फेरबदल भी पैदा करता है – किसी भी तत्व के प्रत्येक स्थान में समाप्त होने का 1 / n मौका है, भले ही उसकी मूल स्थिति (एक उचित आरएनजी संभालने) की हो। सॉर्ट किए गए संस्करण किसी भी वितरण के अनुमानित है (यह सोचते हुए कि यादृच्छिक संख्या जनरेटर उसी मूल्य को दो बार नहीं लेता है, जो कि बेतरतीब डबल्स पर लौटने की संभावना नहीं है), लेकिन मैं फेरबदल के संस्करण के बारे में सोचने में आसान हूं I

इस दृष्टिकोण को फिशर-येट्स फेरफिल कहा जाता है।

मैं इसे एक बार इस फेरबदल को एक बार कोडित करने और इसे हर जगह पुनः उपयोग करने के लिए सर्वोत्तम अभ्यास के रूप में मानता हूं जहाँ आपको आइटम फेरबदल करने की आवश्यकता होती है। फिर आपको विश्वसनीयता या जटिलता के संदर्भ में क्रमबद्ध कार्यान्वयन के बारे में चिंता करने की आवश्यकता नहीं है। यह कोड की कुछ ही पंक्तियाँ हैं (जो मैं जावास्क्रिप्ट में प्रयास नहीं करूंगा!)

फेरबदल (और विशेष रूप से फेरबदल एल्गोरिदम सेक्शन) पर विकिपीडिया लेख एक यादृच्छिक प्रक्षेपण को छांटने के बारे में बात करता है – सामान्य रूप से फेरबदल के खराब कार्यान्वयन पर अनुभाग को पढ़ने में लायक है, इसलिए आप जानते हैं कि क्या बचने के लिए

जॉन ने पहले ही सिद्धांत को कवर कर लिया है , यहां एक कार्यान्वयन है:

 function shuffle(array) { var tmp, current, top = array.length; if(top) while(--top) { current = Math.floor(Math.random() * (top + 1)); tmp = array[current]; array[current] = array[top]; array[top] = tmp; } return array; } 

एल्गोरिथ्म O(n) , जबकि सॉर्टिंग O(n log n) होना चाहिए। देशी sort() फ़ंक्शन के मुकाबले जेएस कोड निष्पादित करने के ओवरहेड के आधार पर, यह प्रदर्शन में एक महत्त्वपूर्ण अंतर हो सकता है जो सरणी आकारों के साथ बढ़ाना चाहिए।


बॉबोबो के उत्तर के लिए टिप्पणी में, मैंने कहा कि प्रश्न में एल्गोरिथ्म समान रूप से वितरित संभाव्यताओं का उत्पादन नहीं कर सकता ( sort() के कार्यान्वयन के आधार पर)

मेरा तर्क इन पंक्तियों के साथ जाता है: एक सॉर्टिंग एल्गोरिथ्म के लिए अपेक्षाओं की एक निश्चित संख्या c की आवश्यकता होती है, उदाहरण के लिए c = n(n-1)/2 हमारी यादृच्छिक तुलना समारोह प्रत्येक तुलना के परिणाम समान रूप से संभव बनाता है, यानी 2^c समान रूप से संभावित परिणाम हैं। अब, प्रत्येक परिणाम को n! से एक के अनुरूप होना चाहिए n! सरणी की प्रविष्टियों के क्रमांतरण, जो सामान्य मामले में एक भी वितरण असंभव बना देता है। (यह एक सरलीकरण है, क्योंकि अपेक्षाकृत नीली हुई तुलना की वास्तविक संख्या इनपुट सरणी पर निर्भर करती है, लेकिन अभिप्रेत होना चाहिए।)

जैसा कि जॉन ने बताया, यह अकेले sort() का उपयोग करने पर फ़िशर-येटे को पसंद करने का कोई कारण नहीं है, क्योंकि यादृच्छिक संख्या जनरेटर भी छद्म-यादृच्छिक मूल्यों की संख्या को n! मैप करेगा n! क्रमपरिवर्तन। लेकिन फिशर-येट्स के परिणाम अब भी बेहतर होंगे:

Math.random() श्रेणी में एक छद्म-यादृच्छिक संख्या का उत्पादन करता है [0;1[ जैसा कि जेएस डबल-स्पेसिफिक फ्लोटिंग पॉइंट वैल्यू का उपयोग करता है, यह 2^x संभव मानों से मेल खाती है, जहां 52 ≤ x ≤ 63 (मैं वास्तविक संख्या को खोजने के लिए बहुत आलसी हूं)। Math.random() का उपयोग करके उत्पन्न होने वाली संभावना वितरण अच्छी तरह से व्यवहार करना बंद कर देगा यदि परमाणु घटनाओं की संख्या परिमाण के समान क्रम का है

फ़िशर-येट्स का उपयोग करते समय, प्रासंगिक पैरामीटर सरणी का आकार होता है, जो कि व्यावहारिक सीमाओं के कारण 2^52 कभी नहीं आना चाहिए।

एक यादृच्छिक तुलना समारोह के साथ क्रमबद्ध करते समय, फ़ंक्शन मूल रूप से केवल परवाह करता है कि रिटर्न का मान सकारात्मक या नकारात्मक है, इसलिए यह कभी भी एक समस्या नहीं होगी। लेकिन एक समान एक है: क्योंकि तुलनात्मक कार्य अच्छी तरह से व्यवहार करता है, 2^c संभव परिणाम हैं, जैसा कि कहा गया है, उतना ही संभव है। यदि c ~ n log n तो 2^c ~ n^(a·n) जहां a = const , जो इसे कम से कम संभव बनाता है 2^c एक ही परिमाण के रूप में (या उससे भी कम) n! और इस तरह एक असमान वितरण के लिए अग्रणी, भले ही सॉर्टिंग एल्गोरिथ्म पैरामाउंट पर समान रूप से मैप करने के लिए। अगर इसका कोई व्यावहारिक प्रभाव मेरे परे है।

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


नीचे पंक्ति: sort() रूप में लंबे समय तक sort() मर्जर्स का उपयोग करता है, आपको कोने के मामलों को छोड़कर काफी सुरक्षित होना चाहिए (कम से कम मुझे उम्मीद है कि 2^c ≤ n! एक कोने केस है), यदि नहीं, तो सभी दांव बंद हैं

मैंने कुछ मापन किया कि कैसे इस यादृच्छिक प्रकार के परिणाम यादृच्छिक हैं …

मेरी तकनीक का एक छोटा सरणी [1,2,3,4] लेना था और सभी (4! = 24) क्रमपरिवर्तनों का निर्माण करना था तो मैं सरणी में कई बार बार-बार फेरबदल की प्रक्रिया को लागू करूँगा और गणना करता हूँ कि प्रत्येक क्रम-वस्तु को कितनी बार जनरेट किया जाता है। एक अच्छा फेरबदल एल्गोरिदम परिणाम को सभी क्रमपरिवर्तनों पर बहुत समान रूप से वितरित करेगा, जबकि एक बुरा एक समान परिणाम नहीं बनाएगा।

नीचे दिए गए कोड का उपयोग करके मैंने फ़ायरफ़ॉक्स, ओपेरा, क्रोम, आईई 6/7/8 में परीक्षण किया था।

हैरानी की बात है मेरे लिए, यादृच्छिक सॉर्ट और असली फेरबदल दोनों समान समान वितरण बनाते हैं। तो ऐसा लगता है कि (जैसा कि कई लोगों ने सुझाया है) मुख्य ब्राउज़र मर्ज सॉर्ट का उपयोग कर रहे हैं बेशक यह मतलब नहीं है, कि वहाँ एक ब्राउज़र नहीं हो सकता है, जो अलग तरीके से करता है, लेकिन मैं कहूँगा इसका मतलब यह है कि यह यादृच्छिक-क्रम-विधि व्यवहार में उपयोग करने के लिए पर्याप्त विश्वसनीय है।

संपादित करें: यह परीक्षण वास्तव में यादृच्छिकता या उसके अभाव में सही ढंग से मापा नहीं था। अन्य उत्तर मैं पोस्ट पोस्ट देखें।

लेकिन प्रदर्शन पक्ष पर क्रिस्टोफ़ द्वारा दिए गए फेरबदल समारोह स्पष्ट विजेता था। यहां तक ​​कि छोटे चार तत्वों के लिए असली फेरबदल के बारे में दो बार के रूप में तेजी से यादृच्छिक-प्रकार के रूप में प्रदर्शन किया!

 // क्रिस्तोफ़ द्वारा पोस्ट किया गया शफल फ़ंक्शन
 var फेरफल = फ़ंक्शन (सरणी) {
     var tmp, वर्तमान, शीर्ष = array.length;

     अगर (शीर्ष) जबकि (- शीर्ष) {
         वर्तमान = मठ.फ्लूर (मठ.रेंडम () * (शीर्ष + 1));
         tmp = सरणी [वर्तमान];
         सरणी [वर्तमान] = सरणी [शीर्ष];
         सरणी [शीर्ष] = टीएमपी;
     }

     वापसी सरणी;
 };

 // यादृच्छिक सॉर्ट फ़ंक्शन
 var rnd = फ़ंक्शन () {
   वापसी गणित। (मठ। यादृच्छिक ()) - 0.5;
 };
 var randSort = फ़ंक्शन (ए) {
   वापसी एस्ोर्ट (आरडीडी);
 };

 var फ़रामिटेशन = फंक्शन (ए) {
   यदि (ए लांठ == 1) {
     वापसी [ए];
   }
   अन्य {
     var perms = [];
     के लिए (var i = 0; i <ए लांघ; i ++) {
       var x = एस्लाइस (i, i + 1);
       var xs = A.slice (0, i) .concat (एस्लाइस (i + 1));
       var उप-पेम्स = क्रमपरिवर्तन (एक्सएस);
       के लिए (var j = 0; j <subperms.length; j ++) {
         perms.push (x.concat (subperms [जे]));
       }
     }
     वापसी perms;
   }
 };

 var परीक्षण = समारोह (ए, पुनरावृत्त, फ़ैन्क) {
   // init क्रमपरिवर्तन
   var आँकड़े = {};
   var perms = क्रमपरिवर्तन (ए);
   के लिए (var i में perms) {
     आँकड़े ["" + perms [i]] = 0;
   }

   // कई बार घसीटना और आँकड़े इकट्ठा
   var start = नया दिनांक ();
   के लिए (var i = 0; i <iterations; i ++) {
     var शफ़ेड = फेंक (ए);
     आँकड़े [ "" + फेरबदल] ++;
   }
   var अंत = नया दिनांक ();

   // स्वरूप परिणाम
   var arr = [];
   के लिए (आँकड़े में var i) {
     arr.push (आई + "+ + आँकड़े [i]);
   }
   वापसी arr.join ("\ n") + "\ n \ n समय लिया:" + ((अंत - प्रारंभ) / 1000) + "सेकंड।";
 };

 चेतावनी ("बेतरतीब सॉर्ट:" + परीक्षण ([1,2,3,4], 100000, रैंड सॉर्ट);
 चेतावनी ("फेरबदल:" + परीक्षा ([1,2,3,4], 100000, फेरबदल));

दिलचस्प है कि, माइक्रोसॉफ्ट ने अपने पिक-रेन्ड-ब्राउज़र-पेज में एक ही तकनीक का इस्तेमाल किया

उन्होंने थोड़ा अलग तुलना फ़ंक्शन का इस्तेमाल किया:

 function RandomSort(a,b) { return (0.5 - Math.random()); } 

लगभग मेरे लिए एक ही लग रहा है, लेकिन यह इतना यादृच्छिक नहीं निकला …

इसलिए मैंने कुछ परीक्षणकर्ताओं को फिर से जुड़े लेख में प्रयुक्त एक ही पद्धति के साथ बनाया, और वास्तव में – पता चला कि यादृच्छिक-सॉर्टिंग-विधि त्रुटिपूर्ण परिणामों का उत्पादन किया। नया परीक्षण कोड यहां है:

 function shuffle(arr) { arr.sort(function(a,b) { return (0.5 - Math.random()); }); } function shuffle2(arr) { arr.sort(function(a,b) { return (Math.round(Math.random())-0.5); }); } function shuffle3(array) { var tmp, current, top = array.length; if(top) while(--top) { current = Math.floor(Math.random() * (top + 1)); tmp = array[current]; array[current] = array[top]; array[top] = tmp; } return array; } var counts = [ [0,0,0,0,0], [0,0,0,0,0], [0,0,0,0,0], [0,0,0,0,0], [0,0,0,0,0] ]; var arr; for (var i=0; i<100000; i++) { arr = [0,1,2,3,4]; shuffle3(arr); arr.forEach(function(x, i){ counts[x][i]++;}); } alert(counts.map(function(a){return a.join(", ");}).join("\n")); 

मैंने अपनी वेबसाइट पर एक साधारण परीक्षण पृष्ठ रखा है जो आपके वर्तमान ब्राउज़र के पूर्वाग्रह को अन्य लोकप्रिय ब्राउज़रों बनाकर अलग-अलग तरीक़े का उपयोग कर रहा है। यह सिर्फ Math.random()-0.5 का उपयोग करने के भयानक पूर्वाग्रह को दर्शाता है। रैंडम Math.random()-0.5 , एक और 'यादृच्छिक' फेरबदल जो पक्षपाती नहीं है, और ऊपर वर्णित फिशर-येट्स विधि

आप देख सकते हैं कि कुछ ब्राउज़रों पर 50% मौके के रूप में उच्च होता है कि कुछ तत्व 'फेरबदल' के दौरान बिल्कुल भी नहीं बदलेगा!

नोट: आप फिशर-येट्स के फेफड़े को @ क्रिस्टोफ़ द्वारा कार्यान्वित करके सफारी के लिए कोड को बदल कर थोड़ा तेज कर सकते हैं:

 function shuffle(array) { for (var tmp, cur, top=array.length; top--;){ cur = (Math.random() * (top + 1)) << 0; tmp = array[cur]; array[cur] = array[top]; array[top] = tmp; } return array; } 

परीक्षण परिणाम: http://jsperf.com/optimized-fisher-yates

मुझे लगता है कि उन मामलों के लिए ठीक है जहां आप वितरण के बारे में नहीं उठा रहे हैं और आप चाहते हैं कि स्रोत कोड को छोटा होना चाहिए

जावास्क्रिप्ट (जहां स्रोत लगातार फैलता है) में, छोटे बैंडविड्थ लागतों में अंतर होता है

यह निश्चित रूप से एक हैक है व्यवहार में, एक असीम पाशन एल्गोरिथ्म की संभावना नहीं है यदि आप ऑब्जेक्ट्स को छँटा रहे हैं, तो आप कॉओर्स सरणी के माध्यम से पाश कर सकते हैं और ऐसा कुछ कर सकते हैं:

 for (var i = 0; i < coords.length; i++) coords[i].sortValue = Math.random(); coords.sort(useSortValue) function useSortValue(a, b) { return a.sortValue - b.sortValue; } 

(और फिर उनके माध्यम से फिर से सॉर्ट वैल्यू निकालने के लिए)

फिर भी एक हैक यद्यपि। यदि आप इसे अच्छी तरह से करना चाहते हैं, तो आपको इसे कठिन तरीके से करना होगा 🙂

यदि आप डी 3 का उपयोग कर रहे हैं तो फ़िशर-येट्स का उपयोग करके एक अंतर्निहित फेरबदल समारोह है:

 var days = ['Lundi','Mardi','Mercredi','Jeudi','Vendredi','Samedi','Dimanche']; d3.shuffle(days); 

और यहां माइक इसके बारे में विस्तार में जा रहे हैं:

http://bost.ocks.org/mike/shuffle/

यह चार साल रहा है, लेकिन मैं यह इंगित करना चाहूंगा कि यह संभवतः कोई भी काम नहीं करेगा जो आपको एल्गोरिदम का सॉर्ट करना है।

सबूत: एन हैं! n तत्वों के क्रमांतर हर बार जब आप तुलना करते हैं, तो आप क्रमपरिवर्तन के सेट के दो सबसेट के बीच चयन कर रहे हैं। इसलिए प्रत्येक क्रमचय की संभावनाओं को कुछ कश्मीर के लिए भिन्न 2 ^ के साथ भिन्न होगा।

एन = 3 के लिए, छह समान रूप से-संभावना क्रमपरिवर्तन होते हैं। प्रत्येक क्रमचय की संभावना, फिर, 1/6 है 1/6 को दो अंकों की शक्ति के साथ अंश के रूप में व्यक्त नहीं किया जा सकता है, विभिन्न प्रकार के साथ निर्णय पेड़ को बाहर निकालने का प्रयास करें

संभवतः वितरित किए जाने वाले केवल आकार n = 0,1,2 हैं

यहां एक दृष्टिकोण है जो एक सरणी का उपयोग करता है:

मूल तर्क यह है:

  • N तत्वों की एक सरणी के साथ शुरू
  • सरणी से एक यादृच्छिक तत्व निकालें और उसे सरणी में दबाएं
  • सरणी के पहले n – 1 तत्वों से एक यादृच्छिक तत्व निकालें और उसे सरणी में दबाएं
  • सरणी के पहले n – 2 तत्वों से एक यादृच्छिक तत्व निकालें और उसे सरणी में दबाएं
  • सरणी के पहले तत्व को निकालें और उसे सरणी में दबाएं
  • कोड:

     for(i=a.length;i--;) a.push(a.splice(Math.floor(Math.random() * (i + 1)),1)[0]); 

    क्या आप सरणी को फेराने के लिए Array.sort () फ़ंक्शन का उपयोग कर सकते हैं – हाँ

    परिणाम काफी यादृच्छिक हैं – शायद नहीं मैं परीक्षण के लिए इस जावास्क्रिप्ट का इस्तेमाल किया:

     var array = ["a", "b", "c", "d", "e"]; var stats = {}; for (var i = 0; i < array.length; i++) { stats[array[i]] = []; for (var j = 0; j < array.length; j++) { stats[array[i]][j] = 0; } } //stats = { // a: [0, 0, 0, ...] // b: [0, 0, 0, ...] // c: [0, 0, 0, ...] // ... // ... //} for (var i = 0; i < 100; i++) { var clone = array.slice(0); clone.sort(function() { return Math.random() - 0.5; }); for (var j = 0; j < clone.length; j++) { stats[clone[j]][j]++; } } for (var i in stats) { console.log(i, stats[i]); } 

    नमूना आउटपुट:

     a [29, 38, 20, 6, 7] b [29, 33, 22, 11, 5] c [17, 14, 32, 17, 20] d [16, 9, 17, 35, 23] e [ 9, 6, 9, 31, 45] 

    आदर्श रूप से, गिनती समान रूप से वितरित की जानी चाहिए (उपरोक्त उदाहरण के लिए, सभी गिनती लगभग 20 होनी चाहिए)। लेकिन वे नहीं हैं। जाहिर है, यह वितरण ब्राउज़र द्वारा सॉर्टिंग एल्गोरिदम पर निर्भर करता है और यह सॉर्टिंग के लिए सरणी आइटम को कैसे पुनरावृत्त करता है।

    इस अनुच्छेद में अधिक अंतर्दृष्टि प्रदान की गई है:
    Array.sort () का उपयोग किसी सरणी को फेरबदल करने के लिए नहीं किया जाना चाहिए

    एडी ओस्मानी ने फिशर-येट्स फेरबदल के इस संस्करण को लागू किया:

     function shuffle(array) { var rand, index = -1, length = array.length, result = Array(length); while (++index < length) { rand = Math.floor(Math.random() * (index + 1)); result[index] = result[rand]; result[rand] = array[index]; } return result; } 

    इसे देखने के लिए वापस आने वाले लोगों के लिए, यह सबूत है कि सॉर्ट () को यादृच्छिक बनाने के लिए काम नहीं करता है: http://phrogz.net/JS/JavaScript_Random_Array_Sort.html

    इसमें कुछ भी गलत नहीं है।

    फ़ंक्शन जो आप .sort () में पास करते हैं आम तौर पर ऐसा कुछ दिखता है

     फंक्शन सॉर्टिंगफंक (पहला, दूसरा)
     {
       // उदाहरण:
       पहली वापसी - दूसरा;
     }
    

    सॉर्टिंग में आपका कामफन्क वापस लौटना है:

    • एक नकारात्मक संख्या अगर पहले दूसरे से पहले जाती है
    • एक सकारात्मक संख्या अगर पहले दूसरे के बाद जाना चाहिए
    • और 0 यदि वे पूरी तरह बराबर हैं

    उपर्युक्त सॉर्टिंग फंक्शन चीजों को क्रम में रखता है।

    अगर आपके पास है -'आ और + 'बेतरतीब ढंग से जो आपके पास है, तो आपको यादृच्छिक क्रम मिलती है।

    MySQL की तरह:

     चयन * तालिका से ORDER रैंड ()