【原碼筆記】-- protobuf.js 與 Long.js

protobuf.js的結構和webpack的加載以後的結構很類似。這樣的模塊化組合是個不錯的結構方式。1個是適應了不一樣的加載方式，2個模塊直接很獨立。webpack的功能更全一點。但若是本身封裝js庫這樣夠用了。並且模塊對外統一接口 module.exports。這和node很像。

(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)

在處理超過16位的整形就得使用Long.js了。 主要是fromString和toString。

  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('radix');

        var p;
        if ((p = str.indexOf('-')) > 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 div.
        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的思路是把字符串8位一個截取。而後轉成Long型(高位，地位，符號位) 加起來。最後是一個Long型。 4294967296 是2的32次方。每次操做以前都會有一個基數的操做 mul(radixToPower)或者mul(power)這二者都是保證result的位數是正確的。

好比{low:123} 和{low:1} 相加以前，先要讓{low:123}乘以10，獲得{low:1230}再與{low:1}進行位操做。由於第一個是高位，不能直接相加。

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

fromBits 即轉爲Long對象。value%4294967296 獲得低位。/獲得高位。結果經過位移合併起來。mul是bit的乘法，add是bit的加法。 原理是講一個64位的拆成四段。分別16位。this.low左移16位 就獲得 low的32-17位是啥。 而後和addend對象的同位相加

最後的合併是經過|運算。位移以後再還原確實很巧妙。一時看上去都不大理解。

 LongPrototype.add = function add(addend) {
        if (!isLong(addend))
            addend = fromValue(addend);

        // Divide 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);
    };

>>>和>>有什麼區別？？。 

toString

LongPrototype.toString = function toString(radix) {
        radix = radix || 10;
        if (radix < 2 || 36 < radix)
            throw RangeError('radix');
        if (this.isZero())
            return '0';
        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),
                    div = this.div(radixLong),
                    rem1 = div.mul(radixLong).sub(this);
                return div.toString(radix) + rem1.toInt().toString(radix);
            } else
                return '-' + this.neg().toString(radix);
        }

        // Do several (6) digits each time through the loop, so as to
        // minimize the calls to the very expensive emulated div.
        var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),
            rem = this;
        var result = '';
        while (true) {
            var remDiv = rem.div(radixToPower),
                intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0,
                digits = intval.toString(radix);
            rem = remDiv;
            if (rem.isZero())
                return digits + result;
            else {
                while (digits.length < 6)
                    digits = '0' + digits;
                result = '' + digits + result;
            }
        }
    };

也是sub以後拼出來的。也就是fromstring的反向操做。