注册 登录
发贴工具
自动发帖软件»群发软件 › 群发软件公告教程 › AIWORK源码分享 › AIWROK软件运算符封装库示例
返回列表 发帖
查看: 6|回复: 0
打印 上一主题 下一主题

[24小时收录超级好的网站] AIWROK软件运算符封装库示例

[复制链接]

2463

主题

2511

帖子

1万

积分

积分
14980
跳转到指定楼层
楼主
发帖软件 发表于 5 小时前 | 只看该作者 |只看大图 回帖奖励 |正序浏览 |阅读模式
AIWROK软件运算符封装库示例
AIWROK软件运算符封装库示例 群发软件发帖工具

AIWROK软件运算符封装库示例 群发软件发帖工具
  1. /*
  2. 🍎AIwork运算符的高级封装和用法
  3. 🍎交流QQ群711841924群一，苹果内测群，528816639
  4.   JavaScript 运算符封装库示例
  5. */

  7. // 日志窗口配置（如需使用请取消注释）
  8. logWindow.show()
  9. logWindow.clear()
  10. logWindow.setHeight(2500)
  11. logWindow.setWidth(1500)
  12. logWindow.setNoClickModel()

  14. var OperatorUtils = {};

  16. OperatorUtils.version = '1.0.0';

  18. OperatorUtils.MathEngine = function() {
  19.     this.history = [];
  20.     this.variables = {};
  21. };

  23. OperatorUtils.MathEngine.prototype = {
  24.     calculate: function(expression) {
  25.         var keys = [];
  26.         for (var key in this.variables) {
  27.             if (this.variables.hasOwnProperty(key)) {
  28.                 keys.push(key);
  29.             }
  30.         }
  31.         var values = [];
  32.         for (var i = 0; i < keys.length; i++) {
  33.             values.push(this.variables[keys[i]]);
  34.         }
  35.         var funcArgs = keys.join(',');
  36.         var funcBody = 'return ' + expression;
  37.         var func = new Function(funcArgs, funcBody);
  38.         var result = func.apply(null, values);
  39.         this.history.push({
  40.             expression: expression,
  41.             result: result,
  42.             timestamp: new Date().getTime()
  43.         });
  44.         return result;
  45.     },

  47.     setVariable: function(name, value) {
  48.         this.variables[name] = value;
  49.         return this;
  50.     },

  52.     getVariable: function(name) {
  53.         return this.variables[name];
  54.     },

  56.     getHistory: function() {
  57.         return this.history;
  58.     },

  60.     clearHistory: function() {
  61.         this.history = [];
  62.         return this;
  63.     }
  64. };

  66. OperatorUtils.Arithmetic = {
  67.     add: function() {
  68.         var result = 0;
  69.         for (var i = 0; i < arguments.length; i++) {
  70.             var num = Number(arguments[i]);
  71.             if (isNaN(num)) {
  72.                 throw new TypeError('参数必须是数字');
  73.             }
  74.             result += num;
  75.         }
  76.         return result;
  77.     },

  79.     subtract: function(a, b) {
  80.         a = Number(a);
  81.         b = Number(b);
  82.         if (isNaN(a) || isNaN(b)) {
  83.             throw new TypeError('参数必须是数字');
  84.         }
  85.         return a - b;
  86.     },

  88.     multiply: function() {
  89.         var result = 1;
  90.         for (var i = 0; i < arguments.length; i++) {
  91.             var num = Number(arguments[i]);
  92.             if (isNaN(num)) {
  93.                 throw new TypeError('参数必须是数字');
  94.             }
  95.             result *= num;
  96.         }
  97.         return result;
  98.     },

  100.     divide: function(a, b) {
  101.         a = Number(a);
  102.         b = Number(b);
  103.         if (isNaN(a) || isNaN(b)) {
  104.             throw new TypeError('参数必须是数字');
  105.         }
  106.         if (b === 0) {
  107.             throw new Error('除数不能为零');
  108.         }
  109.         return a / b;
  110.     },

  112.     modulo: function(a, b) {
  113.         a = Number(a);
  114.         b = Number(b);
  115.         if (isNaN(a) || isNaN(b)) {
  116.             throw new TypeError('参数必须是数字');
  117.         }
  118.         if (b === 0) {
  119.             throw new Error('除数不能为零');
  120.         }
  121.         return a % b;
  122.     },

  124.     increment: function(value, prefix) {
  125.         value = Number(value);
  126.         if (isNaN(value)) {
  127.             throw new TypeError('参数必须是数字');
  128.         }
  129.         if (prefix) {
  130.             return ++value;
  131.         }
  132.         var original = value;
  133.         value++;
  134.         return original;
  135.     },

  137.     decrement: function(value, prefix) {
  138.         value = Number(value);
  139.         if (isNaN(value)) {
  140.             throw new TypeError('参数必须是数字');
  141.         }
  142.         if (prefix) {
  143.             return --value;
  144.         }
  145.         var original = value;
  146.         value--;
  147.         return original;
  148.     },

  150.     power: function(base, exponent) {
  151.         base = Number(base);
  152.         exponent = Number(exponent);
  153.         if (isNaN(base) || isNaN(exponent)) {
  154.             throw new TypeError('参数必须是数字');
  155.         }
  156.         var result = 1;
  157.         for (var i = 0; i < exponent; i++) {
  158.             result *= base;
  159.         }
  160.         return result;
  161.     },

  163.     sqrt: function(value) {
  164.         value = Number(value);
  165.         if (isNaN(value)) {
  166.             throw new TypeError('参数必须是数字');
  167.         }
  168.         if (value < 0) {
  169.             throw new Error('不能计算负数的平方根');
  170.         }
  171.         return Math.sqrt(value);
  172.     },

  174.     abs: function(value) {
  175.         value = Number(value);
  176.         if (isNaN(value)) {
  177.             throw new TypeError('参数必须是数字');
  178.         }
  179.         return value < 0 ? -value : value;
  180.     },

  182.     round: function(value, decimals) {
  183.         value = Number(value);
  184.         if (isNaN(value)) {
  185.             throw new TypeError('参数必须是数字');
  186.         }
  187.         decimals = decimals || 0;
  188.         var factor = Math.pow(10, decimals);
  189.         return Math.round(value * factor) / factor;
  190.     },

  192.     sum: function(arr) {
  193.         if (Object.prototype.toString.call(arr) !== '[object Array]') {
  194.             throw new TypeError('参数必须是数组');
  195.         }
  196.         var total = 0;
  197.         for (var i = 0; i < arr.length; i++) {
  198.             total += Number(arr[i]) || 0;
  199.         }
  200.         return total;
  201.     },

  203.     average: function(arr) {
  204.         if (Object.prototype.toString.call(arr) !== '[object Array]') {
  205.             throw new TypeError('参数必须是数组');
  206.         }
  207.         if (arr.length === 0) {
  208.             return 0;
  209.         }
  210.         return this.sum(arr) / arr.length;
  211.     },

  213.     max: function(arr) {
  214.         if (Object.prototype.toString.call(arr) !== '[object Array]') {
  215.             throw new TypeError('参数必须是数组');
  216.         }
  217.         if (arr.length === 0) {
  218.             throw new Error('数组不能为空');
  219.         }
  220.         var maxVal = arr[0];
  221.         for (var i = 1; i < arr.length; i++) {
  222.             if (arr[i] > maxVal) {
  223.                 maxVal = arr[i];
  224.             }
  225.         }
  226.         return maxVal;
  227.     },

  229.     min: function(arr) {
  230.         if (Object.prototype.toString.call(arr) !== '[object Array]') {
  231.             throw new TypeError('参数必须是数组');
  232.         }
  233.         if (arr.length === 0) {
  234.             throw new Error('数组不能为空');
  235.         }
  236.         var minVal = arr[0];
  237.         for (var i = 1; i < arr.length; i++) {
  238.             if (arr[i] < minVal) {
  239.                 minVal = arr[i];
  240.             }
  241.         }
  242.         return minVal;
  243.     },

  245.     range: function(start, end, step) {
  246.         start = Number(start);
  247.         end = Number(end);
  248.         step = step || 1;
  249.         step = Number(step);
  250.         
  251.         if (isNaN(start) || isNaN(end) || isNaN(step)) {
  252.             throw new TypeError('参数必须是数字');
  253.         }
  254.         if (step === 0) {
  255.             throw new Error('步长不能为零');
  256.         }
  257.         
  258.         var result = [];
  259.         var current = start;
  260.         if (step > 0) {
  261.             while (current <= end) {
  262.                 result.push(current);
  263.                 current += step;
  264.             }
  265.         } else {
  266.             while (current >= end) {
  267.                 result.push(current);
  268.                 current += step;
  269.             }
  270.         }
  271.         return result;
  272.     }
  273. };

  275. OperatorUtils.Assignment = {
  276.     assign: function(obj, key, value) {
  277.         if (typeof obj !== 'object' || obj === null) {
  278.             throw new TypeError('第一个参数必须是对象');
  279.         }
  280.         obj[key] = value;
  281.         return obj;
  282.     },

  284.     addAssign: function(obj, key, value) {
  285.         if (typeof obj !== 'object' || obj === null) {
  286.             throw new TypeError('第一个参数必须是对象');
  287.         }
  288.         obj[key] = (obj[key] || 0) + value;
  289.         return obj;
  290.     },

  292.     subtractAssign: function(obj, key, value) {
  293.         if (typeof obj !== 'object' || obj === null) {
  294.             throw new TypeError('第一个参数必须是对象');
  295.         }
  296.         obj[key] = (obj[key] || 0) - value;
  297.         return obj;
  298.     },

  300.     multiplyAssign: function(obj, key, value) {
  301.         if (typeof obj !== 'object' || obj === null) {
  302.             throw new TypeError('第一个参数必须是对象');
  303.         }
  304.         obj[key] = (obj[key] || 0) * value;
  305.         return obj;
  306.     },

  308.     divideAssign: function(obj, key, value) {
  309.         if (typeof obj !== 'object' || obj === null) {
  310.             throw new TypeError('第一个参数必须是对象');
  311.         }
  312.         if (value === 0) {
  313.             throw new Error('除数不能为零');
  314.         }
  315.         obj[key] = (obj[key] || 0) / value;
  316.         return obj;
  317.     },

  319.     moduloAssign: function(obj, key, value) {
  320.         if (typeof obj !== 'object' || obj === null) {
  321.             throw new TypeError('第一个参数必须是对象');
  322.         }
  323.         if (value === 0) {
  324.             throw new Error('除数不能为零');
  325.         }
  326.         obj[key] = (obj[key] || 0) % value;
  327.         return obj;
  328.     },

  330.     merge: function(target) {
  331.         if (typeof target !== 'object' || target === null) {
  332.             throw new TypeError('第一个参数必须是对象');
  333.         }
  334.         for (var i = 1; i < arguments.length; i++) {
  335.             var source = arguments[i];
  336.             if (typeof source === 'object' && source !== null) {
  337.                 for (var key in source) {
  338.                     if (source.hasOwnProperty(key)) {
  339.                         target[key] = source[key];
  340.                     }
  341.                 }
  342.             }
  343.         }
  344.         return target;
  345.     },

  347.     deepClone: function(obj) {
  348.         if (obj === null || typeof obj !== 'object') {
  349.             return obj;
  350.         }
  351.         if (Object.prototype.toString.call(obj) === '[object Array]') {
  352.             var arrCopy = [];
  353.             for (var i = 0; i < obj.length; i++) {
  354.                 arrCopy[i] = this.deepClone(obj[i]);
  355.             }
  356.             return arrCopy;
  357.         }
  358.         var objCopy = {};
  359.         for (var key in obj) {
  360.             if (obj.hasOwnProperty(key)) {
  361.                 objCopy[key] = this.deepClone(obj[key]);
  362.             }
  363.         }
  364.         return objCopy;
  365.     }
  366. };

  368. OperatorUtils.StringOps = {
  369.     concat: function() {
  370.         var result = '';
  371.         for (var i = 0; i < arguments.length; i++) {
  372.             result += String(arguments[i] || '');
  373.         }
  374.         return result;
  375.     },

  377.     join: function(sep) {
  378.         sep = sep || '';
  379.         var result = '';
  380.         for (var i = 0; i < arguments.length; i++) {
  381.             if (i > 0) {
  382.                 result += sep;
  383.             }
  384.             result += String(arguments[i] || '');
  385.         }
  386.         return result;
  387.     },

  389.     repeat: function(str, count) {
  390.         str = String(str);
  391.         count = Number(count) || 0;
  392.         var result = '';
  393.         for (var i = 0; i < count; i++) {
  394.             result += str;
  395.         }
  396.         return result;
  397.     },

  399.     padLeft: function(str, length, char) {
  400.         str = String(str);
  401.         char = char || ' ';
  402.         while (str.length < length) {
  403.             str = char + str;
  404.         }
  405.         return str;
  406.     },

  408.     padRight: function(str, length, char) {
  409.         str = String(str);
  410.         char = char || ' ';
  411.         while (str.length < length) {
  412.             str = str + char;
  413.         }
  414.         return str;
  415.     },

  417.     truncate: function(str, length, suffix) {
  418.         str = String(str);
  419.         suffix = suffix || '...';
  420.         if (str.length <= length) {
  421.             return str;
  422.         }
  423.         return str.substring(0, length - suffix.length) + suffix;
  424.     },

  426.     capitalize: function(str) {
  427.         str = String(str);
  428.         if (str.length === 0) return str;
  429.         return str.charAt(0).toUpperCase() + str.slice(1);
  430.     },

  432.     camelCase: function(str) {
  433.         str = String(str);
  434.         var words = str.split(/[\s_-]+/);
  435.         var result = words[0].toLowerCase();
  436.         for (var i = 1; i < words.length; i++) {
  437.             result += this.capitalize(words[i].toLowerCase());
  438.         }
  439.         return result;
  440.     },

  442.     kebabCase: function(str) {
  443.         str = String(str);
  444.         return str.replace(/([a-z])([A-Z])/g, '$1-$2')
  445.                   .replace(/[\s_]+/g, '-')
  446.                   .toLowerCase();
  447.     },

  449.     snakeCase: function(str) {
  450.         str = String(str);
  451.         return str.replace(/([a-z])([A-Z])/g, '$1_$2')
  452.                   .replace(/[\s-]+/g, '_')
  453.                   .toLowerCase();
  454.     },

  456.     reverse: function(str) {
  457.         str = String(str);
  458.         var result = '';
  459.         for (var i = str.length - 1; i >= 0; i--) {
  460.             result += str.charAt(i);
  461.         }
  462.         return result;
  463.     },

  465.     contains: function(str, search) {
  466.         str = String(str);
  467.         search = String(search);
  468.         return str.indexOf(search) !== -1;
  469.     },

  471.     startsWith: function(str, prefix) {
  472.         str = String(str);
  473.         prefix = String(prefix);
  474.         return str.indexOf(prefix) === 0;
  475.     },

  477.     endsWith: function(str, suffix) {
  478.         str = String(str);
  479.         suffix = String(suffix);
  480.         return str.slice(-suffix.length) === suffix;
  481.     },

  483.     stripTags: function(str) {
  484.         str = String(str);
  485.         return str.replace(/<[^>]*>/g, '');
  486.     },

  488.     escapeHtml: function(str) {
  489.         str = String(str);
  490.         var htmlEntities = {
  491.             '&': '&',
  492.             '<': '<',
  493.             '>': '>',
  494.             '"': '"',
  495.             "'": '''
  496.         };
  497.         return str.replace(/[&<>"']/g, function(match) {
  498.             return htmlEntities[match];
  499.         });
  500.     },

  502.     unescapeHtml: function(str) {
  503.         str = String(str);
  504.         var htmlEntities = {
  505.             '&': '&',
  506.             '<': '<',
  507.             '>': '>',
  508.             '"': '"',
  509.             ''': "'"
  510.         };
  511.         return str.replace(/&(amp|lt|gt|quot|#39);/g, function(match) {
  512.             return htmlEntities[match];
  513.         });
  514.     },

  516.     wordCount: function(str) {
  517.         str = String(str);
  518.         var trimmed = str.replace(/^\s+|\s+$/g, '');
  519.         var words = trimmed.split(/\s+/);
  520.         return trimmed === '' ? 0 : words.length;
  521.     },

  523.     countChars: function(str, char) {
  524.         str = String(str);
  525.         char = String(char);
  526.         var count = 0;
  527.         for (var i = 0; i < str.length; i++) {
  528.             if (str.charAt(i) === char) {
  529.                 count++;
  530.             }
  531.         }
  532.         return count;
  533.     },

  535.     format: function(str) {
  536.         str = String(str);
  537.         var args = arguments;
  538.         return str.replace(/\{(\d+)\}/g, function(match, index) {
  539.             var idx = parseInt(index, 10);
  540.             return args[idx + 1] !== undefined ? String(args[idx + 1]) : match;
  541.         });
  542.     },

  544.     template: function(str, data) {
  545.         str = String(str);
  546.         return str.replace(/\{\{(\w+)\}\}/g, function(match, key) {
  547.             return data[key] !== undefined ? String(data[key]) : match;
  548.         });
  549.     }
  550. };

  552. OperatorUtils.TypeCoercion = {
  553.     smartAdd: function(a, b) {
  554.         var numA = Number(a);
  555.         var numB = Number(b);
  556.         
  557.         if (!isNaN(numA) && !isNaN(numB) &&
  558.             String(a).replace(/^\s+|\s+$/g, '') !== '' && String(b).replace(/^\s+|\s+$/g, '') !== '') {
  559.             return numA + numB;
  560.         }
  561.         return String(a) + String(b);
  562.     },

  564.     smartConcat: function() {
  565.         var hasNumber = false;
  566.         var hasString = false;
  567.         var numbers = [];
  568.         var strings = [];
  569.         
  570.         for (var i = 0; i < arguments.length; i++) {
  571.             var val = arguments[i];
  572.             var num = Number(val);
  573.             
  574.             if (!isNaN(num) && String(val).replace(/^\s+|\s+$/g, '') !== '' &&
  575.                 !isNaN(parseFloat(val)) && isFinite(val)) {
  576.                 numbers.push(num);
  577.                 hasNumber = true;
  578.             } else {
  579.                 strings.push(String(val));
  580.                 hasString = true;
  581.             }
  582.         }
  583.         
  584.         if (hasNumber && !hasString) {
  585.             var sum = 0;
  586.             for (var j = 0; j < numbers.length; j++) {
  587.                 sum += numbers[j];
  588.             }
  589.             return sum;
  590.         }
  591.         
  592.         var result = '';
  593.         for (var k = 0; k < arguments.length; k++) {
  594.             result += String(arguments[k]);
  595.         }
  596.         return result;
  597.     },

  599.     toNumber: function(value, defaultValue) {
  600.         var num = Number(value);
  601.         return isNaN(num) ? (defaultValue || 0) : num;
  602.     },

  604.     toInt: function(value, defaultValue) {
  605.         var num = parseInt(value, 10);
  606.         return isNaN(num) ? (defaultValue || 0) : num;
  607.     },

  609.     toFloat: function(value, defaultValue) {
  610.         var num = parseFloat(value);
  611.         return isNaN(num) ? (defaultValue || 0) : num;
  612.     },

  614.     toString: function(value, defaultValue) {
  615.         if (value === null || value === undefined) {
  616.             return defaultValue || '';
  617.         }
  618.         return String(value);
  619.     },

  621.     toBoolean: function(value) {
  622.         if (typeof value === 'boolean') {
  623.             return value;
  624.         }
  625.         if (typeof value === 'string') {
  626.             return value.toLowerCase() === 'true';
  627.         }
  628.         if (typeof value === 'number') {
  629.             return value !== 0;
  630.         }
  631.         return Boolean(value);
  632.     },

  634.     isArray: function(value) {
  635.         return Object.prototype.toString.call(value) === '[object Array]';
  636.     },

  638.     isObject: function(value) {
  639.         return typeof value === 'object' && value !== null && !this.isArray(value);
  640.     },

  642.     isFunction: function(value) {
  643.         return typeof value === 'function';
  644.     },

  646.     isString: function(value) {
  647.         return typeof value === 'string';
  648.     },

  650.     isNumber: function(value) {
  651.         return typeof value === 'number' && !isNaN(value);
  652.     },

  654.     isInteger: function(value) {
  655.         return this.isNumber(value) && value % 1 === 0;
  656.     },

  658.     isFloat: function(value) {
  659.         return this.isNumber(value) && value % 1 !== 0;
  660.     }
  661. };

  663. OperatorUtils.Comparison = {
  664.     equals: function(a, b) {
  665.         if (a === b) return true;
  666.         if (a === null || b === null) return false;
  667.         if (typeof a !== typeof b) return false;
  668.         
  669.         if (typeof a === 'object') {
  670.             var aKeys = [];
  671.             for (var key in a) {
  672.                 if (a.hasOwnProperty(key)) {
  673.                     aKeys.push(key);
  674.                 }
  675.             }
  676.             var bKeys = [];
  677.             for (var key in b) {
  678.                 if (b.hasOwnProperty(key)) {
  679.                     bKeys.push(key);
  680.                 }
  681.             }
  682.             
  683.             if (aKeys.length !== bKeys.length) return false;
  684.             
  685.             for (var i = 0; i < aKeys.length; i++) {
  686.                 var key = aKeys[i];
  687.                 if (!b.hasOwnProperty(key) || !this.equals(a[key], b[key])) {
  688.                     return false;
  689.                 }
  690.             }
  691.             return true;
  692.         }
  693.         
  694.         return false;
  695.     },

  697.     deepEquals: function(a, b) {
  698.         return this.equals(a, b);
  699.     },

  701.     between: function(value, min, max, inclusive) {
  702.         value = Number(value);
  703.         min = Number(min);
  704.         max = Number(max);
  705.         
  706.         if (inclusive) {
  707.             return value >= min && value <= max;
  708.         }
  709.         return value > min && value < max;
  710.     },

  712.     clamp: function(value, min, max) {
  713.         value = Number(value);
  714.         min = Number(min);
  715.         max = Number(max);
  716.         
  717.         if (value < min) return min;
  718.         if (value > max) return max;
  719.         return value;
  720.     },

  722.     inRange: function(value, range) {
  723.         if (Object.prototype.toString.call(range) !== '[object Array]' || range.length !== 2) {
  724.             throw new TypeError('范围参数必须是包含两个元素的数组');
  725.         }
  726.         return this.between(value, range[0], range[1], true);
  727.     },

  729.     compare: function(a, b) {
  730.         if (a < b) return -1;
  731.         if (a > b) return 1;
  732.         return 0;
  733.     }
  734. };

  736. OperatorUtils.Bitwise = {
  737.     and: function(a, b) {
  738.         return (a | 0) & (b | 0);
  739.     },

  741.     or: function(a, b) {
  742.         return (a | 0) | (b | 0);
  743.     },

  745.     xor: function(a, b) {
  746.         return (a | 0) ^ (b | 0);
  747.     },

  749.     not: function(a) {
  750.         return ~(a | 0);
  751.     },

  753.     leftShift: function(a, b) {
  754.         return (a | 0) << (b | 0);
  755.     },

  757.     rightShift: function(a, b) {
  758.         return (a | 0) >> (b | 0);
  759.     },

  761.     unsignedRightShift: function(a, b) {
  762.         return (a | 0) >>> (b | 0);
  763.     }
  764. };

  766. OperatorUtils.Logical = {
  767.     and: function() {
  768.         for (var i = 0; i < arguments.length; i++) {
  769.             if (!arguments[i]) {
  770.                 return arguments[i];
  771.             }
  772.         }
  773.         return arguments[arguments.length - 1];
  774.     },

  776.     or: function() {
  777.         for (var i = 0; i < arguments.length; i++) {
  778.             if (arguments[i]) {
  779.                 return arguments[i];
  780.             }
  781.         }
  782.         return arguments[arguments.length - 1];
  783.     },

  785.     not: function(value) {
  786.         return !value;
  787.     },

  789.     ternary: function(condition, trueValue, falseValue) {
  790.         return condition ? trueValue : falseValue;
  791.     },

  793.     nullish: function(value, defaultValue) {
  794.         return value != null ? value : defaultValue;
  795.     },

  797.     coalesce: function() {
  798.         for (var i = 0; i < arguments.length; i++) {
  799.             if (arguments[i] != null) {
  800.                 return arguments[i];
  801.             }
  802.         }
  803.         return null;
  804.     }
  805. };

  807. OperatorUtils.Chainable = function(initialValue) {
  808.     this.value = initialValue;
  809. };

  811. OperatorUtils.Chainable.prototype = {
  812.     add: function(n) {
  813.         this.value = OperatorUtils.Arithmetic.add(this.value, n);
  814.         return this;
  815.     },

  817.     subtract: function(n) {
  818.         this.value = OperatorUtils.Arithmetic.subtract(this.value, n);
  819.         return this;
  820.     },

  822.     multiply: function(n) {
  823.         this.value = OperatorUtils.Arithmetic.multiply(this.value, n);
  824.         return this;
  825.     },

  827.     divide: function(n) {
  828.         this.value = OperatorUtils.Arithmetic.divide(this.value, n);
  829.         return this;
  830.     },

  832.     modulo: function(n) {
  833.         this.value = OperatorUtils.Arithmetic.modulo(this.value, n);
  834.         return this;
  835.     },

  837.     power: function(n) {
  838.         this.value = OperatorUtils.Arithmetic.power(this.value, n);
  839.         return this;
  840.     },

  842.     round: function(decimals) {
  843.         this.value = OperatorUtils.Arithmetic.round(this.value, decimals);
  844.         return this;
  845.     },

  847.     abs: function() {
  848.         this.value = OperatorUtils.Arithmetic.abs(this.value);
  849.         return this;
  850.     },

  852.     clamp: function(min, max) {
  853.         this.value = OperatorUtils.Comparison.clamp(this.value, min, max);
  854.         return this;
  855.     },

  857.     valueOf: function() {
  858.         return this.value;
  859.     },

  861.     toString: function() {
  862.         return String(this.value);
  863.     }
  864. };

  866. OperatorUtils.chain = function(value) {
  867.     return new OperatorUtils.Chainable(value);
  868. };

  870. OperatorUtils.Calculator = function() {
  871.     this.stack = [];
  872.     this.memory = 0;
  873. };

  875. OperatorUtils.Calculator.prototype = {
  876.     push: function(value) {
  877.         this.stack.push(Number(value));
  878.         return this;
  879.     },

  881.     pop: function() {
  882.         return this.stack.pop();
  883.     },

  885.     add: function() {
  886.         if (this.stack.length < 2) throw new Error('栈中至少需要两个值');
  887.         var b = this.stack.pop();
  888.         var a = this.stack.pop();
  889.         this.stack.push(a + b);
  890.         return this;
  891.     },

  893.     subtract: function() {
  894.         if (this.stack.length < 2) throw new Error('栈中至少需要两个值');
  895.         var b = this.stack.pop();
  896.         var a = this.stack.pop();
  897.         this.stack.push(a - b);
  898.         return this;
  899.     },

  901.     multiply: function() {
  902.         if (this.stack.length < 2) throw new Error('栈中至少需要两个值');
  903.         var b = this.stack.pop();
  904.         var a = this.stack.pop();
  905.         this.stack.push(a * b);
  906.         return this;
  907.     },

  909.     divide: function() {
  910.         if (this.stack.length < 2) throw new Error('栈中至少需要两个值');
  911.         var b = this.stack.pop();
  912.         var a = this.stack.pop();
  913.         this.stack.push(a / b);
  914.         return this;
  915.     },

  917.     modulo: function() {
  918.         if (this.stack.length < 2) throw new Error('栈中至少需要两个值');
  919.         var b = this.stack.pop();
  920.         var a = this.stack.pop();
  921.         this.stack.push(a % b);
  922.         return this;
  923.     },

  925.     power: function() {
  926.         if (this.stack.length < 2) throw new Error('栈中至少需要两个值');
  927.         var b = this.stack.pop();
  928.         var a = this.stack.pop();
  929.         this.stack.push(Math.pow(a, b));
  930.         return this;
  931.     },

  933.     memoryStore: function() {
  934.         if (this.stack.length > 0) {
  935.             this.memory = this.stack[this.stack.length - 1];
  936.         }
  937.         return this;
  938.     },

  940.     memoryRecall: function() {
  941.         this.stack.push(this.memory);
  942.         return this;
  943.     },

  945.     memoryClear: function() {
  946.         this.memory = 0;
  947.         return this;
  948.     },

  950.     memoryAdd: function() {
  951.         if (this.stack.length > 0) {
  952.             this.memory += this.stack[this.stack.length - 1];
  953.         }
  954.         return this;
  955.     },

  957.     memorySubtract: function() {
  958.         if (this.stack.length > 0) {
  959.             this.memory -= this.stack[this.stack.length - 1];
  960.         }
  961.         return this;
  962.     },

  964.     getResult: function() {
  965.         return this.stack.length > 0 ? this.stack[this.stack.length - 1] : 0;
  966.     },

  968.     clear: function() {
  969.         this.stack = [];
  970.         return this;
  971.     }
  972. };

  974. OperatorUtils.runAllExamples = function() {
  975.     print.log("=== JavaScript 运算符高级封装库 - 完整测试 ===\n");

  977.     print.log("1. 算术运算符测试:");
  978.     print.log("-------------------");
  979.     print.log("加法(5+3+2): " + OperatorUtils.Arithmetic.add(5, 3, 2));
  980.     print.log("减法(10-4): " + OperatorUtils.Arithmetic.subtract(10, 4));
  981.     print.log("乘法(3*4*2): " + OperatorUtils.Arithmetic.multiply(3, 4, 2));
  982.     print.log("除法(15/3): " + OperatorUtils.Arithmetic.divide(15, 3));
  983.     print.log("取模(17%5): " + OperatorUtils.Arithmetic.modulo(17, 5));
  984.     print.log("幂运算(2^10): " + OperatorUtils.Arithmetic.power(2, 10));
  985.     print.log("平方根(16): " + OperatorUtils.Arithmetic.sqrt(16));
  986.     print.log("绝对值(-42): " + OperatorUtils.Arithmetic.abs(-42));
  987.     print.log("四舍五入(3.14159,2): " + OperatorUtils.Arithmetic.round(3.14159, 2));
  988.     print.log("");

  990.     print.log("2. 数组运算测试:");
  991.     print.log("----------------");
  992.     var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  993.     print.log("数组求和: " + OperatorUtils.Arithmetic.sum(numbers));
  994.     print.log("数组平均: " + OperatorUtils.Arithmetic.average(numbers));
  995.     print.log("数组最大: " + OperatorUtils.Arithmetic.max(numbers));
  996.     print.log("数组最小: " + OperatorUtils.Arithmetic.min(numbers));
  997.     print.log("范围生成(1-10,步长2): " + JSON.stringify(OperatorUtils.Arithmetic.range(1, 10, 2)));
  998.     print.log("");

  1000.     print.log("3. 赋值运算符测试:");
  1001.     print.log("------------------");
  1002.     var obj = { x: 10, y: 5 };
  1003.     OperatorUtils.Assignment.addAssign(obj, 'x', 5);
  1004.     OperatorUtils.Assignment.multiplyAssign(obj, 'x', 2);
  1005.     print.log("对象操作后: " + JSON.stringify(obj));
  1006.     var target = { a: 1 };
  1007.     OperatorUtils.Assignment.merge(target, { b: 2 }, { c: 3 });
  1008.     print.log("对象合并: " + JSON.stringify(target));
  1009.     print.log("");

  1011.     print.log("4. 字符串运算测试:");
  1012.     print.log("--------------------");
  1013.     print.log("字符串连接: " + OperatorUtils.StringOps.concat('Hello', ' ', 'World'));
  1014.     print.log("字符串重复: " + OperatorUtils.StringOps.repeat('Abc', 3));
  1015.     print.log("左填充: " + OperatorUtils.StringOps.padLeft('42', 5, '0'));
  1016.     print.log("右填充: " + OperatorUtils.StringOps.padRight('Hi', 5, '*'));
  1017.     print.log("首字母大写: " + OperatorUtils.StringOps.capitalize('hello'));
  1018.     print.log("驼峰命名: " + OperatorUtils.StringOps.camelCase('hello-world'));
  1019.     print.log("字符串反转: " + OperatorUtils.StringOps.reverse('Hello'));
  1020.     print.log("包含检查: " + OperatorUtils.StringOps.contains('Hello World', 'World'));
  1021.     print.log("");

  1023.     print.log("5. 类型转换测试:");
  1024.     print.log("----------------");
  1025.     print.log("智能加法(5+5): " + OperatorUtils.TypeCoercion.smartAdd(5, 5));
  1026.     print.log("智能加法(\"5\"+5): " + OperatorUtils.TypeCoercion.smartAdd('5', 5));
  1027.     print.log("转数字(\"123.45\"): " + OperatorUtils.TypeCoercion.toNumber('123.45'));
  1028.     print.log("转整数(\"123.45\"): " + OperatorUtils.TypeCoercion.toInt('123.45'));
  1029.     print.log("转浮点(\"123.45\"): " + OperatorUtils.TypeCoercion.toFloat('123.45'));
  1030.     print.log("转字符串(12345): " + OperatorUtils.TypeCoercion.toString(12345));
  1031.     print.log("转布尔(\"true\"): " + OperatorUtils.TypeCoercion.toBoolean('true'));
  1032.     print.log("是数组([1,2,3]): " + OperatorUtils.TypeCoercion.isArray([1, 2, 3]));
  1033.     print.log("是对象({a:1}): " + OperatorUtils.TypeCoercion.isObject({ a: 1 }));
  1034.     print.log("");

  1036.     print.log("6. 比较运算测试:");
  1037.     print.log("----------------");
  1038.     print.log("深度相等: " + OperatorUtils.Comparison.deepEquals({ a: 1 }, { a: 1 }));
  1039.     print.log("范围检查(5在1-10): " + OperatorUtils.Comparison.between(5, 1, 10, true));
  1040.     print.log("限制范围(15在1-10): " + OperatorUtils.Comparison.clamp(15, 1, 10));
  1041.     print.log("");

  1043.     print.log("7. 位运算测试:");
  1044.     print.log("-------------");
  1045.     print.log("按位与(5&3): " + OperatorUtils.Bitwise.and(5, 3));
  1046.     print.log("按位或(5|3): " + OperatorUtils.Bitwise.or(5, 3));
  1047.     print.log("按位异或(5^3): " + OperatorUtils.Bitwise.xor(5, 3));
  1048.     print.log("按位非(~5): " + OperatorUtils.Bitwise.not(5));
  1049.     print.log("左移(5<<2): " + OperatorUtils.Bitwise.leftShift(5, 2));
  1050.     print.log("右移(16>>2): " + OperatorUtils.Bitwise.rightShift(16, 2));
  1051.     print.log("");

  1053.     print.log("8. 逻辑运算测试:");
  1054.     print.log("----------------");
  1055.     print.log("逻辑与: " + OperatorUtils.Logical.and(true, false, 'hello'));
  1056.     print.log("逻辑或: " + OperatorUtils.Logical.or(false, null, 'world'));
  1057.     print.log("逻辑非(true): " + OperatorUtils.Logical.not(true));
  1058.     print.log("三元运算(true,\"yes\",\"no\"): " + OperatorUtils.Logical.ternary(true, 'yes', 'no'));
  1059.     print.log("空值合并(null,\"default\"): " + OperatorUtils.Logical.nullish(null, 'default'));
  1060.     print.log("");

  1062.     print.log("9. 链式调用测试:");
  1063.     print.log("----------------");
  1064.     var chainResult = OperatorUtils.chain(10)
  1065.         .add(5)
  1066.         .multiply(2)
  1067.         .subtract(5)
  1068.         .divide(5)
  1069.         .round(2)
  1070.         .valueOf();
  1071.     print.log("链式计算: 10+5*2-5/5 = " + chainResult);
  1072.     print.log("");

  1074.     print.log("10. 计算器栈测试:");
  1075.     print.log("-----------------");
  1076.     var calc = new OperatorUtils.Calculator();
  1077.     calc.push(10).push(5).add().push(3).multiply();
  1078.     print.log("栈计算 (10+5)*3 = " + calc.getResult());
  1079.     print.log("");

  1081.     print.log("11. 数学引擎测试:");
  1082.     print.log("-----------------");
  1083.     var engine = new OperatorUtils.MathEngine();
  1084.     engine.setVariable('x', 5).setVariable('y', 10);
  1085.     var result = engine.calculate('x * y + 20');
  1086.     print.log("变量计算 x=5,y=10, x*y+20 = " + result);
  1087.     print.log("");

  1089.     print.log("=== 测试完成 ===");
  1090. };

  1092. OperatorUtils.quickTest = function() {
  1093.     print.log("=== 快速测试 ===");
  1094.     print.log("加法: " + OperatorUtils.Arithmetic.add(1, 2, 3));
  1095.     print.log("乘法: " + OperatorUtils.Arithmetic.multiply(2, 3, 4));
  1096.     print.log("连接: " + OperatorUtils.StringOps.concat('A', 'B', 'C'));
  1097.     print.log("智能加法: " + OperatorUtils.TypeCoercion.smartAdd('5', 5));
  1098.     print.log("链式: " + OperatorUtils.chain(10).add(5).multiply(2).valueOf());
  1099.     print.log("=== 快速测试完成 ===");
  1100. };

  1102. print.log("JavaScript 运算符封装库加载完成！");
  1103. print.log("");
  1104. print.log("使用方法：");
  1105. print.log("  OperatorUtils.runAllExamples()  - 运行完整测试");
  1106. print.log("  OperatorUtils.quickTest()       - 运行快速测试");
  1107. print.log("");

  1109. OperatorUtils.runAllExamples();
复制代码



AIWROK, AIWROK软件
楼主新帖
楼主热帖
untoAIWROK软件语法运行小示例nextAIWROK软件运算符封装库示例

相关帖子
回复

使用道具 举报

返回列表 发帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

相关导读了
    采集亚马逊正版群发工具有没有？
    Apr.20旅行X心语今天来说说YYPOST新功能的一个灵活用法，采集亚马逊商品信息，并且获得排名的软件，亚马逊现在越来越多客户做，淘宝的水是越来越清了，以前做电商的客户，现在都转战到外国，最赚钱的要数一些客户往亚马逊里堆了吧，拿我这个YYPOST的客户，最多的是采集，分析排名，刷价格，刷数量，改价，刷访问量等等技术
    企业发展B2B网站有什么东东软件可以发呢
    标题企业发展网B2B软件，现在虽然B2B网站收录不错，可愁的是心急的人们，他们太想一口吃撑胖子了，发帖宣传虽然不能像佛系那样淡定，但也不能像跑火车那般急躁对待，自己内容不收录，完全是自己操作内容问题，可以参考一下别人的内容是怎么弄的，然后自己要试着转变，而且收录这个内容，常常会变化的，不是一种规则就吃到老
    搜房天下房聊软件哪一个好呢
    本帖最后由 发帖软件 于 2019-5-22 16:15 编辑 2搜房天下群发房聊信息软件，开始本来打算做58同城的，但发一个就要一次点触验证码，这就让人没有感觉到存在的价值了吧，都是卖二手房和新房的搜房天下倒是可以发即时聊天信息，也没有发现他这个网站有啥子限制，登陆一个搜房天下账号，然后采集回来分类列表的网址，然后就一
    大家坛有没有好用的群发工具下载呢
    当你的笑容给我礼貌的招呼，大家坛全自动发帖软件，宣传推广是一场持久战，总是有一些人把软件用了一天，或是几个小时，就觉得自己付出太多了，那加进来的粉丝，或是流量，应该是和宣传多少成正比的，其实没有这么便宜的事，就像很多阅读量超过一百万的视频，或是电影，真正会在屏幕打赏的人不会超过三千，真正大额打赏给主
    群发正版软件中国塑料网
    中国塑料网群发软件YYPOST脚本下载地址，这个网站会有一个很奇怪的问题就是你在首页登陆无半个验证码，但在登陆网址登陆就会有一个验证码，所以我们灵活一些，在首页登陆就不用输入验证码了哈。网站秒收录比较高，但发的都是五金和建筑行业，先前有很多人都是发土建工程的大公司操作的，现在这个网站专为那个行业诞生的吧。
    OpenStreetMap网站正版2019年发帖工具下载
    本帖最后由 发帖软件 于 2019-5-21 11:13 编辑 OpenStreetMap网站全自动群发，OpenStreetMapOpenStreetMap（简称OSM，中文是公开地图）是一个网上地图协作计划，目标是创造一个内容自由且能让所有人编辑的世界地图。有的人编辑地图然后等收录，有的人发日志等收录，我们这里也是利用地图日志做为宣传的目标，简单的脚本理
    搜房天下全自动收短信全自动识别验证码注册账号软件
    房天下自动注册机，这个脚本是前几天发房聊的脚本廷伸品种，这个脚本能做到自动注册账号，自动保存账号，自动发房聊的效果，不过今天我们主要说一说怎么注册账号写脚本吧，这个搜房天天下的账号，可以发提问，可以发房聊，发论坛，发博客，还有发个人中心页都是有秒收的效果的，这样就省去了去买号，去乱花钱的效果了吧，而
    企业邮箱安卓端有什么APP软件可以发的呢
    请输入标题企业邮箱安卓发发送邮箱脚本，这个脚本是利用企业邮箱进行群发的，全程是一种模拟手工操作的过程，所以封号是很少的，而且企业邮箱群发到普通QQ邮箱不容易进垃圾箱中的，所以这个脚本也是这样的原理，不过最好是利用一些多开器，登陆多点的QQ邮箱账号会比较流畅一些，然后用软件一个一个的切换APP进行群发邮件会
    头条留评论软件有没有好用的呢？
    今天整一个今日头条留言软件，对于留言YYPOST是优势是比较大的存在，因为他往往专注一些下拉定位的优点，像今日头条这样，还是需要一些特殊下拉定位的，因为他新闻有长有短，有图有视频的，所以综合起来定位是比较难的，如果用POST也不是很轻松可以破解他的加密参数。这个脚本也是有一个不好的地方就是换号会比较麻烦，您电
    单网页生成神器
    最近新技术，网页生成机占领了整个网络的半壁江山，效果很疯狂，虽然不知道能持续多久，作为开发软件的领头者，一直在找收录的方法，一直在努力创新着，一直被人模仿，却从没有被超越过，这个网页生成机，已经出来有一段时间了，一直没有拿出来分享，醉过醉过，它是利用的一些小小收录漏洞整的，您最好用一些老站域名，进行
关闭
本站开发自动发帖软件是目前效果最好的发贴工具，软件可以兼容所有的论坛，进行群发贴子，可以对各大论坛自主录制操作流程，自动识别 验证码，自动注册账号，自动群发贴子，还可以设置成自动抢沙发，是推广宣传的神级软件，软件可以兼容任何IE能顶贴发贴论坛，完全可以 做成论坛发贴软件，生成脚本，对各大论坛程序完美支持的。软件不但发的贴子收录快，而且只用法简单，使用方便，价格便宜，软件客服16 小时在线全程协助，为您的宣传保驾护航。用最少的投资，实现最大的收益，用最简单的方式，完全最复杂的操作。 QQ

Copyright © 2014 ( 京ICP备09078825号 )

Powered by Discuz! X3.2

群发软件发帖工具
快速回复 返回列表 返回顶部
本站自动发贴软件，是现在最流行的做脚本软件，这种发贴工具，不但发贴收录快，而且抢占好的先机，完全自由编辑，实现针对性群发模拟操作，软件可以顶贴，也可以发贴，可以兼容支持Discuz、PHPWind、Dvbbs三大主流论坛，有手机验证码收件，邮件收发的功能，支持验证码识别，注册问题识别，多线程任务，自动上传头像，自动激活注册邮件，兼容防注册插件，本站软件原创正版，更新效率最快的原创软件。 『网络推广软件』『自动发帖软件』『 自动发帖』