जावास्क्रिप्ट में थोड़ा सरणी लागू करने का सबसे अच्छा तरीका क्या है?मैं जावास्क्रिप्ट में बिट सरणी कैसे बना सकता हूं?
उत्तर
कर यहाँ एक मैं मार पड़ी है:
अद्यतन - इस वर्ग के बारे में कुछ मुझे सारा दिन परेशान कर दिया गया था - यह आधारित आकार नहीं था - बनाने एन स्लॉट/बिट्स के साथ एक बिटरायर दो कदम ऑपरेशन था - तत्काल, आकार बदलें। आकार आधारित उदाहरण के साथ या तो सरणी मान या आधार 10 संख्यात्मक मान के साथ पॉपुलर करने के लिए वैकल्पिक वैकल्पिक पैरामीटर के आधार पर आकार को आकार के रूप में अपडेट किया गया है।
(फिडल यह here के साथ) से त्वरित और गंदी आधारित प्रोटोटाइप के लिए refactor के लिए पूछने के लिए @Daniel Baulig को
/* BitArray DataType */
// Constructor
function BitArray(size, bits) {
// Private field - array for our bits
this.m_bits = new Array();
//.ctor - initialize as a copy of an array of true/false or from a numeric value
if (bits && bits.length) {
for (var i = 0; i < bits.length; i++)
this.m_bits.push(bits[i] ? BitArray._ON : BitArray._OFF);
} else if (!isNaN(bits)) {
this.m_bits = BitArray.shred(bits).m_bits;
}
if (size && this.m_bits.length != size) {
if (this.m_bits.length < size) {
for (var i = this.m_bits.length; i < size; i++) {
this.m_bits.push(BitArray._OFF);
}
} else {
for(var i = size; i > this.m_bits.length; i--){
this.m_bits.pop();
}
}
}
}
/* BitArray PUBLIC INSTANCE METHODS */
// read-only property - number of bits
BitArray.prototype.getLength = function() { return this.m_bits.length; };
// accessor - get bit at index
BitArray.prototype.getAt = function (index) {
if (index < this.m_bits.length) {
return this.m_bits[index];
}
return null;
};
// accessor - set bit at index
BitArray.prototype.setAt = function (index, value) {
if (index < this.m_bits.length) {
this.m_bits[index] = value ? BitArray._ON : BitArray._OFF;
}
};
// resize the bit array (append new false/0 indexes)
BitArray.prototype.resize = function (newSize) {
var tmp = new Array();
for (var i = 0; i < newSize; i++) {
if (i < this.m_bits.length) {
tmp.push(this.m_bits[i]);
} else {
tmp.push(BitArray._OFF);
}
}
this.m_bits = tmp;
};
// Get the complimentary bit array (i.e., 01 compliments 10)
BitArray.prototype.getCompliment = function() {
var result = new BitArray(this.m_bits.length);
for (var i = 0; i < this.m_bits.length; i++) {
result.setAt(i, this.m_bits[i] ? BitArray._OFF : BitArray._ON);
}
return result;
};
// Get the string representation ("101010")
BitArray.prototype.toString = function() {
var s = new String();
for (var i = 0; i < this.m_bits.length; i++) {
s = s.concat(this.m_bits[i] === BitArray._ON ? "1" : "0");
}
return s;
};
// Get the numeric value
BitArray.prototype.toNumber = function() {
var pow = 0;
var n = 0;
for (var i = this.m_bits.length - 1; i >= 0; i--) {
if (this.m_bits[i] === BitArray._ON) {
n += Math.pow(2, pow);
}
pow++;
}
return n;
};
/* STATIC METHODS */
// Get the union of two bit arrays
BitArray.getUnion = function (bitArray1, bitArray2) {
var len = BitArray._getLen(bitArray1, bitArray2, true);
var result = new BitArray(len);
for (var i = 0; i < len; i++) {
result.setAt(i, BitArray._union(bitArray1.getAt(i), bitArray2.getAt(i)));
}
return result;
};
// Get the intersection of two bit arrays
BitArray.getIntersection = function (bitArray1, bitArray2) {
var len = BitArray._getLen(bitArray1, bitArray2, true);
var result = new BitArray(len);
for (var i = 0; i < len; i++) {
result.setAt(i, BitArray._intersect(bitArray1.getAt(i), bitArray2.getAt(i)));
}
return result;
};
// Get the difference between to bit arrays
BitArray.getDifference = function (bitArray1, bitArray2) {
var len = BitArray._getLen(bitArray1, bitArray2, true);
var result = new BitArray(len);
for (var i = 0; i < len; i++) {
result.setAt(i, BitArray._difference(bitArray1.getAt(i), bitArray2.getAt(i)));
}
return result;
};
// Convert a number into a bit array
BitArray.shred = function (number) {
var bits = new Array();
var q = number;
do {
bits.push(q % 2);
q = Math.floor(q/2);
} while (q > 0);
return new BitArray(bits.length, bits.reverse());
};
/* BitArray PRIVATE STATIC CONSTANTS */
BitArray._ON = 1;
BitArray._OFF = 0;
/* BitArray PRIVATE STATIC METHODS */
// Calculate the intersection of two bits
BitArray._intersect = function (bit1, bit2) {
return bit1 === BitArray._ON && bit2 === BitArray._ON ? BitArray._ON : BitArray._OFF;
};
// Calculate the union of two bits
BitArray._union = function (bit1, bit2) {
return bit1 === BitArray._ON || bit2 === BitArray._ON ? BitArray._ON : BitArray._OFF;
};
// Calculate the difference of two bits
BitArray._difference = function (bit1, bit2) {
return bit1 === BitArray._ON && bit2 !== BitArray._ON ? BitArray._ON : BitArray._OFF;
};
// Get the longest or shortest (smallest) length of the two bit arrays
BitArray._getLen = function (bitArray1, bitArray2, smallest) {
var l1 = bitArray1.getLength();
var l2 = bitArray2.getLength();
return l1 > l2 ? smallest ? l2 : l1 : smallest ? l2 : l1;
};
क्रेडिट।
+1 करेगा। लेकिन क्या आप कृपया अपनी विधियों पर टिप्पणी कर सकते हैं ?? और क्या है। डॉक्टर ?? – DrStrangeLove
आपको '' '' के बजाय ''BitArray.prototype''' में विधियों को बिल्कुल जोड़ना चाहिए। –
और जब भी कन्स्ट्रक्टर फ़ंक्शन का आह्वान किया जाता है तो आपको यह सब पुन: असाइन नहीं करना चाहिए। मेरे द्वारा सबमिट किए गए संपादन को देखें। –
मुझे बिट एरे के बारे में पता नहीं है, लेकिन आप बाइट एरे को नई सुविधाओं के साथ आसान बना सकते हैं।
typed arrays देखें। मैंने क्रोम और फ़ायरफ़ॉक्स दोनों में इनका उपयोग किया है। महत्वपूर्ण एक Uint8Array है।
var arr = new UintArray(512);
और यह तक पहुँचने (छठी बाइट):
512 अप्रारंभीकृत बाइट्स की एक सरणी बनाने के
var byte = arr[5];
Node.js के लिए, Buffer (सर्वर साइड) का उपयोग करें।
संपादित करें:
अलग-अलग बिट्स, उपयोग बिट मास्क का उपयोग करने के।
एक की स्थिति में थोड़ा पाने के लिए, num & 0x1
आईई या फ़ायरफ़ॉक्स 3.6 जैसे व्यापक ब्राउज़र में आप इसे कैसे संभालेंगे? – Jiri
फ़ायरफ़ॉक्स 3.6 ठीक काम करना चाहिए। आईई के लिए, एक नियमित सरणी का उपयोग करें और सुनिश्चित करें कि केवल पूर्णांक ही अंदर जाएं। बिट मास्किंग अभी भी काम करेगी। – tjameson
मैं पूरी तरह से पुराने ब्राउज़र को अनदेखा कर दूंगा। यदि वे पुराने ब्राउज़र का उपयोग कर रहे हैं, तो बस उपयोगकर्ता को बताएं, "क्षमा करें, कृपया एक असली ब्राउज़र डाउनलोड करें। यहां कुछ लिंक दिए गए हैं ..."। वह पूरी दुनिया को कुछ अच्छा = डी – tjameson
Stanford Javascript Crypto Library (SJCL) बिट एरे कार्यान्वयन प्रदान करता है और बिट इनपुट में विभिन्न इनपुट (हेक्स स्ट्रिंग्स, बाइट Arrays, आदि) को परिवर्तित कर सकता है।
उनका कोड गिटहब पर सार्वजनिक है: bitwiseshiftleft/sjcl। तो यदि आप bitArray.js देख रहे हैं, तो आप उनके बिट सरणी कार्यान्वयन को पा सकते हैं।
बाइट्स से बिट्स में एक रूपांतरण here पाया जा सकता है।
क्या आप कृपया जिस समस्या का सामना कर रहे हैं उसका वर्णन कर सकते हैं? –
कोई समस्या नहीं है। यह सिर्फ सीखने के उद्देश्यों के लिए है। – DrStrangeLove
आप थोड़ा सरणी नकल करने में सक्षम हो सकते हैं, लेकिन मेरा मानना है कि प्रत्येक सरणी तत्व अभी भी बाइट्स में संग्रहीत है, इस प्रकार आपको स्मृति लाभ नहीं मिलेगा। – vol7ron