दिलचस्प पोस्ट
सेवा से गतिविधि को आशय भेजें आईओएस: पृष्ठभूमि में चल रहे एप्लिकेशन को रखें java.lang.VerifyError: एक स्टैकमैप फ़्रेम की अपेक्षा करें तत्वों के समूह पर MVC बल jQuery सत्यापन आप कैपेबारा में यूआरएल को कैसे पोस्ट करते हैं? मैं एक सरणी का आकार, संग्रह या जावा में स्ट्रिंग कैसे प्राप्त कर सकता हूं? रिकॉर्ड से एचटीएमएल टैग निकालें अंतिम स्वच्छ / सुरक्षित फ़ंक्शन मैं सी # / .NET में एक एसएफटीपी सर्वर पर एक फाइल कैसे अपलोड कर सकता हूं? फ़ायरफ़ॉक्स में href = "फाइल: ///// …" के लिए वैकल्पिक हल सही तरीकों की तुलना में एक इंटरफ़ेस के लिए और अधिक है App.config में कस्टम कॉन्फ़िग अनुभाग कैसे बनाएं? यदि == का उपयोग करते हुए बयान अप्रत्याशित परिणाम देता है 3 डी दृश्य फिट करने के लिए कैमरा ले जाएं क्लास का नाम निर्धारित करने के लिए स्ट्रिंग का उपयोग करके जावास्क्रिप्ट ऑब्जेक्ट को इंस्टाटियेट करें

जावास्क्रिप्ट में साहचर्य सरणी / हैशिंग कैसे करें

मैं जावास्क्रिप्ट का उपयोग करते हुए कुछ आंकड़ों की जानकारी की गणना / संगृहीत करना चाहता हूं, सी # में समकक्ष कोड नीचे है (मैं चाहता हूं कि विशेषताएं – कुंजी-मूल्य जोड़ी, स्ट्रिंग / एट कुंजी वैल्यू जोड़ी, चाबियाँ द्वारा मूल्यों में हेरफेर करें, आदि), कोई भी विचार कैसे जावास्क्रिप्ट में एक ही समारोह को लागू करने के लिए? ऐसा लगता है कि कोई अंतर्निहित शब्दकोश या हैशटेबल नहीं है?

Dictionary<string, int> statistics; statistics["Foo"] = 10; statistics["Goo"] = statistics["Goo"] + 1; statistics.Add("Zoo", 1); 

Solutions Collecting From Web of "जावास्क्रिप्ट में साहचर्य सरणी / हैशिंग कैसे करें"

साहचर्य सरणियों के रूप में जावास्क्रिप्ट ऑब्जेक्ट का उपयोग करें।

एसोसिएटिव अर्रे: साधारण शब्दों में, एसोसिएटिव एरेज़ इंडेक्स के रूप में पूर्णांक संख्याओं के बजाय स्ट्रिंग का उपयोग करते हैं।

किसी ऑब्जेक्ट को साथ बनाएँ

 var dictionary = {}; 

जावास्क्रिप्ट आपको निम्न वाक्यविन्यास का उपयोग करके वस्तुओं को गुण जोड़ने की अनुमति देता है:

 Object.yourProperty = value; 

उसी के लिए एक वैकल्पिक वाक्यविन्यास है:

 Object["yourProperty"] = value; 

यदि आप निम्न सिंटैक्स के साथ मूल्य ऑब्जेक्ट नक्शे की कुंजी भी बना सकते हैं

 var point = { x:3, y:2 }; point["x"] // => 3; point.y // => 2; 

निम्न के रूप में for..in लूप का निर्माण करते हुए आप एक एसोसिएटिव सरणी के माध्यम से दोहरा सकते हैं

 for(key in dict){ var value = dict[key]; /* use key/value for intended purpose */ } 
 var associativeArray = {}; associativeArray["one"] = "First"; associativeArray["two"] = "Second"; associativeArray["three"] = "Third"; 

यदि आप ऑब्जेक्ट-ओरिएंटेड भाषा से आ रहे हैं तो आपको इस लेख को देखना चाहिए।

जब तक आपके पास एक विशिष्ट कारण नहीं है, सिर्फ एक सामान्य वस्तु का उपयोग करें जावास्क्रिप्ट में ऑब्जेक्ट प्रॉपर्टी को हैशटेबल शैली के वाक्यविन्यास का उपयोग करके संदर्भित किया जा सकता है:

 var hashtable = {}; hashtable.foo = "bar"; hashtable['bar'] = "foo"; 

दोनों foo और bar तत्वों को अब संदर्भित किया जा सकता है:

 hashtable['foo']; hashtable['bar']; // or hashtable.foo; hashtable.bar; 

बेशक इसका मतलब यह है कि आपकी चाबियाँ स्ट्रिंग होने चाहिए। यदि वे स्ट्रिंग नहीं हैं तो वे आंतरिक रूप से स्ट्रिंग्स में परिवर्तित हो जाते हैं, इसलिए यह अभी भी काम कर सकता है, YMMV

सभी आधुनिक ब्राउज़र एक जावास्क्रिप्ट मानचित्र ऑब्जेक्ट का समर्थन करते हैं। कुछ कारण हैं जो ऑब्जेक्ट से बेहतर मानचित्र का उपयोग करते हैं:

  • एक ऑब्जेक्ट में एक प्रोटोटाइप है, इसलिए नक्शे में डिफ़ॉल्ट कुंजी हैं।
  • एक वस्तु की चाबियाँ स्ट्रिंग्स हैं, जहां वे किसी मानचित्र के लिए कोई मूल्य हो सकते हैं।
  • किसी ऑब्जेक्ट के आकार का ट्रैक रखने के लिए आप आसानी से मानचित्र के आकार को प्राप्त कर सकते हैं।

उदाहरण:

 var myMap = new Map(); var keyObj = {}, keyFunc = function () {}, keyString = "a string"; myMap.set(keyString, "value associated with 'a string'"); myMap.set(keyObj, "value associated with keyObj"); myMap.set(keyFunc, "value associated with keyFunc"); myMap.size; // 3 myMap.get(keyString); // "value associated with 'a string'" myMap.get(keyObj); // "value associated with keyObj" myMap.get(keyFunc); // "value associated with keyFunc" 

यदि आप ऐसी चाबियाँ चाहते हैं जो अन्य ऑब्जेक्ट्स से कचरा एकत्रित करने के लिए संदर्भित नहीं हैं, तो मानचित्र के बजाय एक WeakMap का उपयोग करने पर विचार करें।

चूंकि जेएस में हर ऑब्जेक्ट की तरह काम करती है – और आम तौर पर एक हैशटेबल के रूप में लागू किया जाता है, मैं उसके साथ ही जाता हूं …

 var hashSweetHashTable = {}; 

यदि आपको अपनी चाबियाँ बस तारों के बजाय किसी ऑब्जेक्ट की आवश्यकता होती है तो आप अपने jshashtable का उपयोग कर सकते हैं

तो सी # कोड में ऐसा दिखता है:

 Dictionary<string,int> dictionary = new Dictionary<string,int>(); dictionary.add("sample1", 1); dictionary.add("sample2", 2); 

या

 var dictionary = new Dictionary<string, int> { {"sample1", 1}, {"sample2", 2} }; 

जावास्क्रिप्ट में

 var dictionary = { "sample1": 1, "sample2": 2 } 

सी # डिक्शनरी ऑब्जेक्ट में dictionary.ContainsKey() जैसी उपयोगी विधियां हैं। hasOwnProperty की dictionary.ContainsKey() जावास्क्रिप्ट में हम hasOwnProperty इस्तेमाल कर सकते हैं

 if (dictionary.hasOwnProperty("sample1")) console.log("sample1 key found and its value is"+ dictionary["sample1"]); 
 function HashTable() { this.length = 0; this.items = new Array(); for (var i = 0; i < arguments.length; i += 2) { if (typeof (arguments[i + 1]) != 'undefined') { this.items[arguments[i]] = arguments[i + 1]; this.length++; } } this.removeItem = function (in_key) { var tmp_previous; if (typeof (this.items[in_key]) != 'undefined') { this.length--; var tmp_previous = this.items[in_key]; delete this.items[in_key]; } return tmp_previous; } this.getItem = function (in_key) { return this.items[in_key]; } this.setItem = function (in_key, in_value) { var tmp_previous; if (typeof (in_value) != 'undefined') { if (typeof (this.items[in_key]) == 'undefined') { this.length++; } else { tmp_previous = this.items[in_key]; } this.items[in_key] = in_value; } return tmp_previous; } this.hasItem = function (in_key) { return typeof (this.items[in_key]) != 'undefined'; } this.clear = function () { for (var i in this.items) { delete this.items[i]; } this.length = 0; } } 

https://gist.github.com/alexhawkins/f6329420f40e5cafa0a4

 var HashTable = function() { this._storage = []; this._count = 0; this._limit = 8; } HashTable.prototype.insert = function(key, value) { //create an index for our storage location by passing it through our hashing function var index = this.hashFunc(key, this._limit); //retrieve the bucket at this particular index in our storage, if one exists //[[ [k,v], [k,v], [k,v] ] , [ [k,v], [k,v] ] [ [k,v] ] ] var bucket = this._storage[index] //does a bucket exist or do we get undefined when trying to retrieve said index? if (!bucket) { //create the bucket var bucket = []; //insert the bucket into our hashTable this._storage[index] = bucket; } var override = false; //now iterate through our bucket to see if there are any conflicting //key value pairs within our bucket. If there are any, override them. for (var i = 0; i < bucket.length; i++) { var tuple = bucket[i]; if (tuple[0] === key) { //overide value stored at this key tuple[1] = value; override = true; } } if (!override) { //create a new tuple in our bucket //note that this could either be the new empty bucket we created above //or a bucket with other tupules with keys that are different than //the key of the tuple we are inserting. These tupules are in the same //bucket because their keys all equate to the same numeric index when //passing through our hash function. bucket.push([key, value]); this._count++ //now that we've added our new key/val pair to our storage //let's check to see if we need to resize our storage if (this._count > this._limit * 0.75) { this.resize(this._limit * 2); } } return this; }; HashTable.prototype.remove = function(key) { var index = this.hashFunc(key, this._limit); var bucket = this._storage[index]; if (!bucket) { return null; } //iterate over the bucket for (var i = 0; i < bucket.length; i++) { var tuple = bucket[i]; //check to see if key is inside bucket if (tuple[0] === key) { //if it is, get rid of this tuple bucket.splice(i, 1); this._count--; if (this._count < this._limit * 0.25) { this._resize(this._limit / 2); } return tuple[1]; } } }; HashTable.prototype.retrieve = function(key) { var index = this.hashFunc(key, this._limit); var bucket = this._storage[index]; if (!bucket) { return null; } for (var i = 0; i < bucket.length; i++) { var tuple = bucket[i]; if (tuple[0] === key) { return tuple[1]; } } return null; }; HashTable.prototype.hashFunc = function(str, max) { var hash = 0; for (var i = 0; i < str.length; i++) { var letter = str[i]; hash = (hash << 5) + letter.charCodeAt(0); hash = (hash & hash) % max; } return hash; }; HashTable.prototype.resize = function(newLimit) { var oldStorage = this._storage; this._limit = newLimit; this._count = 0; this._storage = []; oldStorage.forEach(function(bucket) { if (!bucket) { return; } for (var i = 0; i < bucket.length; i++) { var tuple = bucket[i]; this.insert(tuple[0], tuple[1]); } }.bind(this)); }; HashTable.prototype.retrieveAll = function() { console.log(this._storage); //console.log(this._limit); }; /******************************TESTS*******************************/ var hashT = new HashTable(); hashT.insert('Alex Hawkins', '510-599-1930'); //hashT.retrieve(); //[ , , , [ [ 'Alex Hawkins', '510-599-1930' ] ] ] hashT.insert('Boo Radley', '520-589-1970'); //hashT.retrieve(); //[ , [ [ 'Boo Radley', '520-589-1970' ] ], , [ [ 'Alex Hawkins', '510-599-1930' ] ] ] hashT.insert('Vance Carter', '120-589-1970').insert('Rick Mires', '520-589-1970').insert('Tom Bradey', '520-589-1970').insert('Biff Tanin', '520-589-1970'); //hashT.retrieveAll(); /* [ , [ [ 'Boo Radley', '520-589-1970' ], [ 'Tom Bradey', '520-589-1970' ] ], , [ [ 'Alex Hawkins', '510-599-1930' ], [ 'Rick Mires', '520-589-1970' ] ], , , [ [ 'Biff Tanin', '520-589-1970' ] ] ] */ //overide example (Phone Number Change) // hashT.insert('Rick Mires', '650-589-1970').insert('Tom Bradey', '818-589-1970').insert('Biff Tanin', '987-589-1970'); //hashT.retrieveAll(); /* [ , [ [ 'Boo Radley', '520-589-1970' ], [ 'Tom Bradey', '818-589-1970' ] ], , [ [ 'Alex Hawkins', '510-599-1930' ], [ 'Rick Mires', '650-589-1970' ] ], , , [ [ 'Biff Tanin', '987-589-1970' ] ] ] */ hashT.remove('Rick Mires'); hashT.remove('Tom Bradey'); //hashT.retrieveAll(); /* [ , [ [ 'Boo Radley', '520-589-1970' ] ], , [ [ 'Alex Hawkins', '510-599-1930' ] ], , , [ [ 'Biff Tanin', '987-589-1970' ] ] ] */ hashT.insert('Dick Mires', '650-589-1970').insert('Lam James', '818-589-1970').insert('Ricky Ticky Tavi', '987-589-1970'); hashT.retrieveAll(); /* NOTICE HOW HASH TABLE HAS NOW DOUBLED IN SIZE UPON REACHING 75% CAPACITY ie 6/8. It is now size 16. [, , [ [ 'Vance Carter', '120-589-1970' ] ], [ [ 'Alex Hawkins', '510-599-1930' ], [ 'Dick Mires', '650-589-1970' ], [ 'Lam James', '818-589-1970' ] ], , , , , , [ [ 'Boo Radley', '520-589-1970' ], [ 'Ricky Ticky Tavi', '987-589-1970' ] ], , , , , [ [ 'Biff Tanin', '987-589-1970' ] ] ] */ console.log(hashT.retrieve('Lam James')); //818-589-1970 console.log(hashT.retrieve('Dick Mires')); //650-589-1970 console.log(hashT.retrieve('Ricky Ticky Tavi')); //987-589-1970 console.log(hashT.retrieve('Alex Hawkins')); //510-599-1930 console.log(hashT.retrieve('Lebron James')); //null 

मैंने इसे कुछ समस्या हासिल करने के लिए बनाया है, जैसे ऑब्जेक्ट कुंजी मैपिंग, गणन की क्षमता (साथ ही forEach() विधि के लिए) और समाशोधन

 function Hashtable() { this._map = new Map(); this._indexes = new Map(); this._keys = []; this._values = []; this.put = function(key, value) { var newKey = !this.containsKey(key); this._map.set(key, value); if (newKey) { this._indexes.set(key, this.length); this._keys.push(key); this._values.push(value); } }; this.remove = function(key) { if (!this.containsKey(key)) return; this._map.delete(key); var index = this._indexes.get(key); this._indexes.delete(key); this._keys.splice(index, 1); this._values.splice(index, 1); }; this.indexOfKey = function(key) { return this._indexes.get(key); }; this.indexOfValue = function(value) { return this._values.indexOf(value) != -1; }; this.get = function(key) { return this._map.get(key); }; this.entryAt = function(index) { var item = {}; Object.defineProperty(item, "key", { value: this.keys[index], writable: false }); Object.defineProperty(item, "value", { value: this.values[index], writable: false }); return item; }; this.clear = function() { var length = this.length; for (var i = 0; i < length; i++) { var key = this.keys[i]; this._map.delete(key); this._indexes.delete(key); } this._keys.splice(0, length); }; this.containsKey = function(key) { return this._map.has(key); }; this.containsValue = function(value) { return this._values.indexOf(value) != -1; }; this.forEach = function(iterator) { for (var i = 0; i < this.length; i++) iterator(this.keys[i], this.values[i], i); }; Object.defineProperty(this, "length", { get: function() { return this._keys.length; } }); Object.defineProperty(this, "keys", { get: function() { return this._keys; } }); Object.defineProperty(this, "values", { get: function() { return this._values; } }); Object.defineProperty(this, "entries", { get: function() { var entries = new Array(this.length); for (var i = 0; i < entries.length; i++) entries[i] = this.entryAt(i); return entries; } }); } 

क्लास Hashtable का दस्तावेज़ीकरण

तरीके:

  • get(key)
    निर्दिष्ट कुंजी से संबंधित मान देता है।
    पैरामीटर:
    key : जिस कुंजी से मूल्य पुनः प्राप्त होता है

  • put(key, value)
    निर्दिष्ट मूल्य के लिए निर्दिष्ट मान एसोसिएट्स।
    पैरामीटर:
    key : जिस कुंजी को मूल्य से जुड़ा हुआ है
    value : कुंजी से संबद्ध करने के लिए मान

  • remove(key)
    विशिष्ट मूल्य को इसके मूल्य के साथ निकाल देता है
    पैरामीटर:
    key : निकालने की कुंजी

  • clear()
    सभी हैशटेबल साफ़ करता है, दोनों चाबियाँ और मूल्यों को निकाल रहा है

  • indexOfKey(key)
    जोड़ने के क्रम के आधार पर, निर्दिष्ट कुंजी के सूचक को वापस लौटाता है।
    पैरामीटर:
    key : जिसकी कुंजी सूचकांक प्राप्त करती है

  • indexOfValue(value)
    जोड़ने के क्रम के आधार पर, निर्दिष्ट मान के सूचकांक लौटाता है।
    पैरामीटर:
    value : जिस मूल्य का सूचकांक मिलता है
    टिप्पणियाँ:
    यह जानकारी सरणी के indexOf() विधि द्वारा प्राप्त की जाती है, इसलिए यह ऑब्जेक्ट को toString() विधि के साथ तुलना करती है।

  • entryAt(index)
    वस्तु को दो गुणों के साथ देता है: कुंजी और मूल्य, निर्दिष्ट सूचकांक पर प्रविष्टि का प्रतिनिधित्व करते हैं।
    पैरामीटर:
    index : पाने के लिए प्रविष्टि का सूचकांक

  • containsKey(key)
    हैशटेबल में निर्दिष्ट कुंजी शामिल है या नहीं लौटाता है।
    पैरामीटर:
    key : चेक की कुंजी

  • containsValue(value)
    हैशटेबल में निर्दिष्ट मान शामिल है या नहीं।
    पैरामीटर:
    value : चेक करने के लिए मान

  • forEach(iterator)
    निर्दिष्ट iterator में सभी प्रविष्टियों को बदल देता है
    पैरामीटर:
    value : 3 पैरामीटर के साथ एक विधि: key , value और index , जहां index प्रविष्टि के सूचक को दर्शाता है।

    गुण:

  • length ( केवल-पढ़ने के लिए )
    हैशटेबल में प्रविष्टियों की गिनती हो जाती है

  • keys ( केवल-पढ़ने के लिए )
    हैशटेबल में सभी कीज़ की एक सरणी होती है।

  • values ( केवल-पढ़ने के लिए )
    हैशटेबल में सभी मानों की एक सरणी होती है

  • entries ( केवल-पढ़ने के लिए )
    हैशटेबल में सभी प्रविष्टियों की एक सरणी होती है। वे विधि entryAt() के उसी रूप में प्रतिनिधित्व कर रहे हैं entryAt()