nodejs如何进行源码加密

一、背景

nodejs作为越发繁荣的生态，出现诸多丰富的组件，但是由于nodejs的解释性运行的问题,导致代码安全性的问题越来越大。那么如何对源码进行加密呢，我们通过循序渐进的方法实现代码的加密。

二、解决思路

1.通过代码混淆或者代码压缩，降低可读性。

这类方法普遍使用在github等开源社区中，代码虽然开源，但是只要我不提供文档说明，我不告诉你业务逻辑。给你代码也是瞎的，但是如果对于业务逻辑比较简单的情况，或者有UI功能进行辅助，大家也可以猜个八九不离十。根本谈不上加密，只是增加你修改的难度，本质等同于我不告诉你怎么写的，我不换行写，我所有变量都都用abc定义，你行你自己看呗状态， 个人觉得效果不佳。

加密效果:☆

维护难度:☆☆☆

加密出来的样子：

       t.exports = function() {
            "use strict";
            var t = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(t) {
                return typeof t
            }
            : function(t) {
                return t && "function" == typeof Symbol && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t
            }
              , e = function(t, e) {
                if (!(t instanceof e))
                    throw new TypeError("Cannot call a class as a function")
            }
              , n = function() {
                function t(t, e) {
                    for (var n = 0; n < e.length; n++) {
                        var i = e[n];
                        i.enumerable = i.enumerable || !1,
                        i.configurable = !0,
                        "value"in i && (i.writable = !0),
                        Object.defineProperty(t, i.key, i)
                    }
                }
                return function(e, n, i) {
                    return n && t(e.prototype, n),
                    i && t(e, i),
                    e
                }
            }()
              , i = Object.assign || function(t) {
                for (var e = 1; e < arguments.length; e++) {
                    var n = arguments[e];
                    for (var i in n)
                        Object.prototype.hasOwnProperty.call(n, i) && (t[i] = n[i])
                }
                return t
            }
              , r = function() {
                function t(n) {
                    var i = !(arguments.length > 1 && void 0 !== arguments[1]) || arguments[1]
                      , r = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : []
                      , o = arguments.length > 3 && void 0 !== arguments[3] ? argume