Detaillierte Erläuterung der Verwendung von protobuf.js und Long.js

Dieses Mal erkläre ich Ihnen ausführlich die Verwendung von protobuf.js und Long.js. Was sind die Vorsichtsmaßnahmen für die dringende Verwendung von protobuf.js und Long.js? Werfen wir einen Blick darauf.

Die Struktur von protobuf.js ist der Struktur von Webpack nach dem Laden sehr ähnlich. Diese modulare Kombination ist eine gute Strukturmethode. Eines ist an unterschiedliche Lademethoden angepasst und die beiden Module sind direkt unabhängig. Webpack ist funktionaler. Wenn Sie die js-Bibliothek jedoch selbst kapseln, reicht dies aus. Darüber hinaus verfügt das Modul über eine einheitliche externe Schnittstelle interface module.exports. Dies ist dem Knoten sehr ähnlich.

(function(global, undefined) {    "use strict";
    (function prelude(modules, cache, entries) {        function $require(name) {            var $module = cache[name];            //没有就去加载
            if (!$module)
                modules[name][0].call($module = cache[name] = { exports: {} }, $require, $module, $module.exports);            return $module.exports;
        }        //曝光成全局
        var proto = global.proto = $require(entries[0]);        // AMD
        if (typeof define === "function" && define.amd) {
            define(["long"], function(Long) {                if (Long && Long.isLong) {
                    proto.util.Long = Long;
                    proto.configure();
                }
            });            return proto;
        }        //CommonJS
        if (typeof module === "object" && module && module.exports)
            module.exports = proto;
    })    //传参    ({        1: [function (require, module, exports) {            function first() {
                console.log("first");
            }
            module.exports = first;
        }, {}],        2: [function(require, module, exports) {            function second() {
                console.log("second");
            }
            module.exports = second;
        }],        3: [function (require, module, exports) {            var proto = {};
            proto.first = require(1);
            proto.second = require(2);
            proto.build = "full";
            module.exports = proto;
        }]
      }, {}, [3]);
})(typeof window==="object"&&window||typeof self==="object"&&self||this)

Long.js muss verwendet werden, wenn Ganzzahlen mit mehr als 16 Bit verarbeitet werden. Hauptsächlich fromString und toString. Die Idee von

  function fromString(str, unsigned, radix) {        if (str.length === 0)            throw Error('empty string');        if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity")            return ZERO;        if (typeof unsigned === 'number') {            // For goog.math.long compatibility
            radix = unsigned,
            unsigned = false;
        } else {
            unsigned = !!unsigned;
        }
        radix = radix || 10;        if (radix < 2 || 36 < radix)            throw RangeError(&#39;radix&#39;);        var p;        if ((p = str.indexOf(&#39;-&#39;)) > 0)            throw Error('interior hyphen');        else if (p === 0) {            return fromString(str.substring(1), unsigned, radix).neg();
        }        // Do several (8) digits each time through the loop, so as to
        // minimize the calls to the very expensive emulated p.
        var radixToPower = fromNumber(pow_dbl(radix, 8));        var result = ZERO;        for (var i = 0; i < str.length; i += 8) {            var size = Math.min(8, str.length - i),                value = parseInt(str.substring(i, i + size), radix);            if (size < 8) {                var power = fromNumber(pow_dbl(radix, size));
                result = result.mul(power).add(fromNumber(value));
            } else {                result = result.mul(radixToPower);
                result = result.add(fromNumber(value));
            }
        }
        result.unsigned = unsigned;        return result;
    }

fromstring besteht darin, die Zeichenfolge 8 Ziffern nacheinander abzufangen. Konvertieren Sie es dann in den Long-Typ (High-Bit, Position, Vorzeichenbit) und addieren Sie es. Der letzte ist ein Drache. 4294967296 ist 2 hoch 32. Vor jeder Operation gibt es eine Basisoperation mul(radixToPower) oder mul(power), die beide sicherstellen, dass die Anzahl der Ziffern im Ergebnis korrekt ist.

Bevor Sie beispielsweise {low:123} und {low:1} addieren, multiplizieren Sie zunächst {low:123} mit 10, um {low:1230} zu erhalten, und führen Sie dann bitweise Operationen mit {low:1} aus. . Da es sich bei der ersten Position um eine hohe Position handelt, kann sie nicht direkt hinzugefügt werden.

function fromBits(lowBits, highBits, unsigned) {        return new Long(lowBits, highBits, unsigned);
    }

fromBits wird in ein Long-Objekt konvertiert. value%4294967296 erhält das Low-Bit. /Komm high. Die Ergebnisse werden nach Verschiebung zusammengefasst. mul ist die Multiplikation von Bits und add ist die Addition von Bits. Das Prinzip besteht darin, eine 64-Bit-Datei in vier Segmente aufzuteilen. 16 Bit bzw. Verschieben Sie this.low um 16 Bit nach links, um die 32–17 Bit von Low zu erhalten. Fügen Sie dann dieselbe Position mit dem Add-Objekt

hinzu und die endgültige Zusammenführung erfolgt durch die Operation |. Es ist wirklich clever, es nach der Verschiebung wiederherzustellen. Ich schien es eine Zeit lang nicht zu verstehen. Was ist der Unterschied zwischen

 LongPrototype.add = function add(addend) {        if (!isLong(addend))
            addend = fromValue(addend);        // pide each number into 4 chunks of 16 bits, and then sum the chunks.
        var a48 = this.high >>> 16;        var a32 = this.high & 0xFFFF;        var a16 = this.low >>> 16;        var a00 = this.low & 0xFFFF;        var b48 = addend.high >>> 16;        var b32 = addend.high & 0xFFFF;        var b16 = addend.low >>> 16;        var b00 = addend.low & 0xFFFF;        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
        c00 += a00 + b00;
        c16 += c00 >>> 16;
        c00 &= 0xFFFF;
        c16 += a16 + b16;
        c32 += c16 >>> 16;
        c16 &= 0xFFFF;
        c32 += a32 + b32;
        c48 += c32 >>> 16;
        c32 &= 0xFFFF;
        c48 += a48 + b48;
        c48 &= 0xFFFF;        return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);
    };

>>> und >>? ? .

toString

LongPrototype.toString = function toString(radix) {
        radix = radix || 10;        if (radix < 2 || 36 < radix)            throw RangeError(&#39;radix&#39;);        if (this.isZero())            return &#39;0&#39;;        if (this.isNegative()) { // Unsigned Longs are never negative
            if (this.eq(MIN_VALUE)) {                // We need to change the Long value before it can be negated, so we remove
                // the bottom-most digit in this base and then recurse to do the rest.
                var radixLong = fromNumber(radix),
                    p = this.p(radixLong),
                    rem1 = p.mul(radixLong).sub(this);                return p.toString(radix) + rem1.toInt().toString(radix);
            } else
                return &#39;-&#39; + this.neg().toString(radix);
        }        // Do several (6) digits each time through the loop, so as to
        // minimize the calls to the very expensive emulated p.
        var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),
            rem = this;        var result = &#39;&#39;;        while (true) {            var remp = rem.p(radixToPower),
                intval = rem.sub(remp.mul(radixToPower)).toInt() >>> 0,
                digits = intval.toString(radix);
            rem = remp;            if (rem.isZero())                return digits + result;            else {                while (digits.length < 6)
                    digits = '0' + digits;
                result = '' + digits + result;
            }
        }
    };

wird auch nach sub geschrieben. Das heißt, die umgekehrte Operation von fromstring.

Ich glaube, dass Sie die Methode beherrschen, nachdem Sie den Fall in diesem Artikel gelesen haben. Weitere spannende Informationen finden Sie in anderen verwandten Artikeln auf der chinesischen PHP-Website.

Empfohlene Lektüre:

Interessantes UglifyJS

Wie man JS automatisch mit Proto-Js abgleichen lässt

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Verwendung von protobuf.js und Long.js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!