使用JavaScript实现一个“字节码解释器”，并用它重新实现JS科学计算器的后端（后续4）

最新推荐文章于 2024-06-11 09:46:59 发布
最新推荐文章于 2024-06-11 09:46:59 发布
阅读量978 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 读书笔记 编译器技术 文章标签： JavaScript 指令生成 编译器 字节码 解释器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cteng/article/details/50160177
本文深入探讨了字节码指令生成技术及其在高级计算器算法中的应用，详细解析了指令生成规则和表达式求值过程，包括常量处理、表达式递归解析及运算符优先级处理等关键步骤。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

成功解决了字节码指令生成的问题，掌握一个原则：

1、数值常量expr100一律是MovImm #imm, R0，但把要不要执行Push R0推迟到expr20-60里做判断；
2、假设任何表达式的指令生成结果都对应于其值在R0里，要不要Push 当且仅当：

     此子表达式出现在二元运算的左侧，且右侧需要递归。（注意，右侧如果只是一个数值常量的话，倒是可以直接MovImm #right_imm, R1，不需要对左侧的结果进行Push R0）

function AdvancedCalculator(){
   //语法分析的原始输入流：
   this.tokens = [];//中缀带括号的, 3种语法分析输入单位：类型为String的(和)、类型为Number的value、类型为Object/String的运算符
   this.tokens_scan_index = 0;
   this.saved_tokens_scan_index_stack = [];
    //用于栈式自动机直接求值的转换后的流：
   //this.tokens2_values = [];//后缀value栈
   //this.tokens2_op = [];//运算符栈，由于去除了括号，所以只需要区分运算符是一元还是二元的      
   this.value_buffer = [];
   this.assember = new Assembler();
}

AdvancedCalculator.prototype = {
   //复杂的运算符定义为单独的Object：
   SQRT:  "Sqrt",
   SIN:  "Sin",
   COS:  "Cos",
   TAN: "Tan",
   COT: "Cot",
   LOG:  "Log", //以10为底
   LN:  "Ln", //以e为底
   POW:  "Pow",//x^y
   PI: Math.PI, //这是数值常量，不是运算符，不过也可以映射为0个输入的函数？？

   mapUnaryOperator2UnaryFunction: function(opToken){
      if(opToken==this.SQRT)
         return Math.sqrt;
      else if(opToken==this.SIN)
         return Math.sin;
      else if(opToken==this.COS)
         return Math.cos;
      else if(opToken==this.TAN)
         return Math.tan;
      else if(opToken==this.COT)
         return function(a){return 1/Math.tan(a);};
      else if(opToken==this.LOG)
         return Math.log10;
      else if(opToken==this.LN)
         return Math.log;
      else
         throw "未识别的一元运算符: "+opToken;
   },
   mapBinaryOperator2BinaryFunction: function(opToken){
      if(opToken==this.POW)
         return Math.pow;
      else if(opToken=="+")
         return function(a,b){return a+b;};
      else if(opToken=="-")
         return function(a,b){return a-b;};
      else if(opToken=="*")
         return function(a,b){return a*b;};
      else if(opToken=="/")
         return function(a,b){return a/b;};
      else
         throw "未识别的二元运算符: "+opToken;
   },

  nextToken: function(){
      if (this.tokens_scan_index>=0 && this.tokens_scan_index<this.tokens.length){
         var token_next = this.tokens[this.tokens_scan_index++];
         return token_next;
      }
      return null;//throw "错误的调用：token流已经结束";
   },
  hasMoreTokens: function(){
      return this.tokens_scan_index>=0 && this.tokens_scan_index<this.tokens.length;
   },

  pushTokenScanIndex: function(){
     assert( this.tokens_scan_index>=0 && this.tokens_scan_index<this.tokens.length);
     this.saved_tokens_scan_index_stack.push(this.tokens_scan_index);
      return this.saved_tokens_scan_index_stack.length-1;
  },
  popTokenScanIndexAt: function(stack_index){
     assert( stack_index>=0 && stack_index<this.saved_tokens_scan_index_stack.length);
     while(this.saved_tokens_scan_index_stack.length>stack_index)
        this.tokens_scan_index = this.saved_tokens_scan_index_stack.pop();
  },
  popTokenScanIndex: function(){
      this.tokens_scan_index = this.saved_tokens_scan_index_stack.pop();
  },
  discardLastTokenScanIndex: function(){
     this.saved_tokens_scan_index_stack.pop();
  },

   isUnaryOperator: function(token){
      return token==this.SIN || token== this.COS  || token==this.TAN || token==this.COT || token==this.LOG || token==this.LN;
   },
   isBinaryFunctionToken: function(token){//特殊的二元函数
      return token==this.POW;
   },
   isBinaryOperator: function(token){//所有的二元中缀操作符（包括二元函数）
      return token=="+" || token=="-" || token=="*" || token=="/" || this.isBinaryFunctionToken(token);
   },
   isOperator: function(token){//返回：0/1单元运算符包括函数/2元运算符
      if (this.isUnaryOperator(token))
         return 1;
      if (this.isBinaryOperator(token))
         return 2;
      return 0;
   },
   emitToken: function(token){
       this.tokens.push(token);
   },
   emitValueTokenIfAny: function(){
      //检查之前缓存的value_buffer
      if (this.value_buffer.length>0) {
         var value_str = this.value_buffer.join('');
         var value = Number(value_str); //a Number
         this.emitToken(value);
         this.value_buffer = []; //reset;
      }
   },
   emitButton: function(btn){
      if (btn=="(" || btn==")"){//括号是一种特殊的优先级运算符
         this.emitValueTokenIfAny();
         this.emitToken(btn);
      }
      else if (this.isOperator(btn)){
         this.emitValueTokenIfAny();
         this.emitToken(btn);
      }else{//0,1,2,3,4,5,6,7,8,9,.
         this.value_buffer.push(btn);
      }
   },
   emitButtons: function(btns){
      for(var i=0; i<btns.length; ++i){
        var btn = btns[i];
        this.emitButton(btn);
      }
   },
   //核心算法：如何把一个中缀的混合value和operator的流转换为分离的value和operator的求值栈？
   concat: function(target, source){
      while(source.length>0){
         var item = source.shift();
         target.push(item);
      }
   },
   evalExpr: function(){
      return this.evalExpr20();//利用短路特性，前一个得到true的话后续子表达式不会执行
   },
   evalExpr100: function(){
      if( !this.hasMoreTokens() )
         return [false,];//push操作暂存流位置之前最好都检查一下？区分2种情况：流中无可解析token VS token语法错误
      this.pushTokenScanIndex();
      var next_token = this.nextToken();
      if(next_token==null)
         throw "流非正常结束，此处应有一数值value！";
      assert(typeof next_token=="number");
      if(typeof next_token=="number"){
         this.assember.emitInstruction({type: "MovImm", arg: next_token, arg1: "R0"});
         //this.assember.emitInstruction({type: "Push", arg: "R0"});
         //正常情况下不需要push，只有发现此常量参与了一个二元原语函数的运算左端，而右端是一个需要递归的子表达式的时候
         return [true,next_token];
      }
      this.popTokenScanIndex();
      return [false,];
   },
   evalExpr80: function(){//括号表达式: 似乎不需要特殊处理？因为它只是改变了子表达式的优先级而已
      if( !this.hasMoreTokens() )
         return [false,];//push操作暂存流位置之前最好都检查一下？区分2种情况：流中无可解析token VS token语法错误
       this.pushTokenScanIndex();
       var next_token = this.nextToken();
       if (next_token==null){//流已经结束
          return false;
       }
       if (next_token=="("){
         var result = this.evalExpr(); //if has ES6 destructing, can write as var [success, value] = ...
         if(!result[0])
            throw "TODO: fixme";//此时saved_tokens_scan_index需要维护成一个栈了
         var next_next_token = this.nextToken();
         if(next_next_token==null)
            throw "流异常结束：expect a )";
         assert( next_next_token==")" );
         {
            //this.assember.emitInstruction({type: "Pop", arg: "R0"});
            //this.assember.emitInstruction({type: "Push", arg: "R0"});
         }
         return result;
      }
      //else:
      this.popTokenScanIndex();
      var result = this.evalExpr100();
      //this.assember.emitInstruction({type: "Pop", arg: "R0"});
      return result;
   },
   evalExpr60: function(){//一元函数
      if( !this.hasMoreTokens() )
         return [false,];//push操作暂存流位置之前最好都检查一下？区分2种情况：流中无可解析token VS token语法错误
       this.pushTokenScanIndex();
       var next_token = this.nextToken();
       if (next_token==null) {
         throw "流异常结束：期望一个Expr60";
       }
       if(this.isUnaryOperator(next_token)){
         var unaryOp = next_token;
         var result = this.evalExpr80();
         if (!result[0])
            throw "非法表达式！";//此时saved_tokens_scan_index需要维护成一个栈了, TODO: 支持 sin sin 1的语法？
         var unaryFunc = this.mapUnaryOperator2UnaryFunction(unaryOp);
         {
            //this.assember.emitInstruction({type: "Pop", arg: "R0"});
            this.assember.emitInstruction({type: "CallPrimitiveFunction", arg: next_token});;
            //this.assember.emitInstruction({type: "Push", arg: "R0"});
         }
         return [true, unaryFunc(result[1])];
      }
      this.popTokenScanIndex();
      var result = this.evalExpr80();
      //this.assember.emitInstruction({type: "Push", arg: "R0"});
      return result;
   },
   evalExpr50: function(){//二元函数，如x^y(Pow求幂)
      if( !this.hasMoreTokens() )
         return [false,];
      //expr50  := expr60 x^y expr50 | expr60
      var result = this.evalExpr60();
      if (result[0]) {
         var tmp_value = result[1];
         if( !this.hasMoreTokens() ) {
            //this.assember.emitInstruction({type: "Push", arg: "R0"})
            return [true, tmp_value];
         }
         this.pushTokenScanIndex();
         var next_token = this.nextToken();//should use let;
         while(this.isBinaryFunctionToken(next_token)){
            //右递归之前，需要将当前的R0压栈：
            this.assember.emitInstruction({type: "Push", arg: "R0"});
            var result2 = this.evalExpr50();
            if (!result2[0]) {
               //Here: 二元函数运算符（如x^y）已经匹配，但右边的子表达式不匹配，则输入无效
               throw "Input Invalid";
            }
            //这里的递归已经处理了结合性的问题
            var binFunc = this.mapBinaryOperator2BinaryFunction(next_token);
            tmp_value = binFunc(tmp_value, result2[1]);
            {
               //将当前右递归的运算结果（R0）移动到R1:
               this.assember.emitInstruction({type: "Mov", arg: "R0", arg1: "R1"});
               //将之前压栈的左侧值出栈：
               this.assember.emitInstruction({type: "Pop", arg: "R0"});
               this.assember.emitInstruction({type: "CallPrimitiveFunction", arg: next_token});
            }
            //
            this.discardLastTokenScanIndex();
            if( !this.hasMoreTokens() ){
                //this.assember.emitInstruction({type: "Push", arg: "R0"})
                return [true, tmp_value];
            }
         }
         this.popTokenScanIndex();
         //this.assember.emitInstruction({type: "Push", arg: "R0"})
         return [true,tmp_value];
      }
      return [false,];
   },
   evalExpr40: function(){//二元乘除, 乘除运算都认为是左结合的
      //expr40 ：= expr50 | expr50 ( '*' expr50 )* | expr50 ( '/' expr50)*
      //如果解析失败，恢复输入token流的扫描初始位置
      if( !this.hasMoreTokens() )
         return [false,];//push操作暂存流位置之前最好都检查一下？区分2种情况：流中无可解析token VS token语法错误
      this.pushTokenScanIndex();
      var result = this.evalExpr50();
      if (result[0]) {
         var tmp_value = result[1];
         if( !this.hasMoreTokens() )
            return [true, tmp_value];
         this.pushTokenScanIndex();
         var next_token = this.nextToken();//should use let;
         while(next_token=="*" || next_token=="/"){
            //右递归之前，需要将当前的R0压栈：
            this.assember.emitInstruction({type: "Push", arg: "R0"});
            //
            var result2 = this.evalExpr50();
            if (!result2[0]) {
               //Here: *或/运算符已经匹配，后右边的子表达式不匹配，则输入无效
               throw "Input Invalid";
            }
            //成功：
             //var binFunc = this.mapBinaryOperator2BinaryFunction(next_token);
             //tmp_value = binFunc(tmp_value, result2[1]);
             if(next_token=="*")
                tmp_value *= result2[1];
             else
                tmp_value /= result2[1];
             {
                //乘法和除法运算都是左结合的，问题是，这里子表达式的优先级都大于＊／
                //正常情况下，先算左边的子表达式，压栈，再算右边的，压栈，所以：
                this.assember.emitInstruction({type: "Mov", arg: "R0", arg1: "R1"});
                this.assember.emitInstruction({type: "Pop", arg: "R0"})
                this.assember.emitInstruction({type: "CallPrimitiveFunction", arg: next_token})
                //注意，这里assembler的写法与二元函数expr60的类似，不同之处在于parser的控制流程：一个是递归，一个是while
             }
             //
             this.discardLastTokenScanIndex();
            //下一次循环：
            if( !this.hasMoreTokens() )
               return [true, tmp_value];//流已经结束，当前expr40子表达式解析完成（但不代表整体成功）
            this.pushTokenScanIndex();
            next_token = this.nextToken();
         }//end while;
         assert( next_token!="*" && next_token!="/");
         this.popTokenScanIndex();//回退一个* /的位置，注意，这时可以清除流解析回退栈了（不清除其实也没关系）
         return [true,tmp_value];//最顶层的push不用pop了；
      }
      this.popTokenScanIndex();
      throw "Invalid Input: expect expr40 here";
    },
   //TODO: FIXME 对二元运算符而言，不管其结合性如何、是否满足交换律，优先级高的子表达式先运算！！！
   //        但是现在不需要以“编译器”的行为来考虑问题，只是解释器，表达式可以认为没有负作用（赋值语句），则可以直接一边语法解析一边求值
   evalExpr20: function(){//二元加减
      if( !this.hasMoreTokens() )
         return [false,];
     //如果解析失败，不用恢复，直接报错
     //expr20 := expr40 | expr40 ('+' expr40)* | expr40 ('-' expr40)* //加法可以是右结合的，减法不行, 这里把expr20改为expr40使得加法左结合
     //         | expr40 '+' expr20  //这么一来，加法将变成右结合的，不对；
     //this.pushTokenScanIndex();
     var result = this.evalExpr40();
      if (!result[0]) {
         return [false,];//整个表达式解析失败
      }
      //循环地向前看一个运算符，或者是+，或者是-
      var tmp_value = result[1];
      if( !this.hasMoreTokens() )
         return [true, tmp_value];
      this.pushTokenScanIndex();
      var next_token=this.nextToken();
      if(next_token==null){
            //注意，前面已经有一个expr40解析成功，所以这里即使流已经结束，仍然可以成功返回
            this.discardLastTokenScanIndex();
            return [true, tmp_value];
         }
      while(next_token=="+" || next_token=="-"){
         if(next_token=="+"){
            //右递归之前，需要将当前的R0压栈：
            this.assember.emitInstruction({type: "Push", arg: "R0"});
            //
            var result2 = this.evalExpr40(); //<-- 必须把＋运算parse为右递归，否则无法处理 1+2+3 这种情况
            if (!result2[0]) {
              return false;//整个表达式解析失败
            }
            tmp_value += result2[1];
            {
              this.assember.emitInstruction({type: "Mov", arg: "R0", arg1: "R1"});
              this.assember.emitInstruction({type: "Pop", arg: "R0"});
              this.assember.emitInstruction({type: "CallPrimitiveFunction", arg: "+"});
            }
         }else{//"-"
            //右递归之前，需要将当前的R0压栈：
            this.assember.emitInstruction({type: "Push", arg: "R0"});
            //
            var result2 = this.evalExpr40();
            if (!result2[0]) {
              return false;//整个表达式解析失败
            }
            tmp_value -= result2[1];
            {
              this.assember.emitInstruction({type: "Mov", arg: "R0", arg1: "R1"});
              this.assember.emitInstruction({type: "Pop", arg: "R0"});
              this.assember.emitInstruction({type: "CallPrimitiveFunction", arg: "-"});
            }
         }
         //成功的情况：
         this.discardLastTokenScanIndex();
         //下一次循环：
         if( !this.hasMoreTokens() )
               return [true, tmp_value];//流已经结束，当前expr20子表达式解析完成（但不代表整体成功）
         this.pushTokenScanIndex();
         next_token = this.nextToken();
      }//end while
      
      assert( next_token!="+" && next_token!="-"); //非法期刊：1+2-
      this.popTokenScanIndex();
      return [true, tmp_value];
   },
   calc: function(){
      this.emitValueTokenIfAny();//!!!
      //输入全部在tokens里，视为一个正确的表达式输入流，后期也可以考虑错误处理
      var result = this.evalExpr();//[success/fail, value]
      {
        alert(this.assember.toString());
        var intercepter = new BytecodeIntercepter();
        var interceptEvalResult = intercepter.eval(this.assember.getResult());
        alert("字节码解释器求值结果="+interceptEvalResult+" \r\n直接递归下降解释执行结果="+result);
      }
      //assert( result[0] );
      return result[1];
   }
}

parser的代码目前同时做2件事情：（1）老的直接在递归下降解析过程中求值，（2）新的通过Assembler生成字节码指令。


测试代码：

alert("7: sin(1+2)+cos(3-4)-tan(5*6)");
var ac = new AdvancedCalculator();
ac.emitButtons([ac.SIN, "(", "1", "+", "2", ")", "+", ac.COS, "(", "3", "-", "4", ")", "-", ac.TAN, "(", "5", "*", "6", ")"]);
var result = ac.calc();
assertEquals(result, Math.sin(1+2)+Math.cos(3-4)-Math.tan(5*6));

成功输出：

MovImm 1 R0
Push R0
MovImm 2 R0
Mov R0 R1
Pop R0
CallPrimitiveFunction +
CallPrimitiveFunction Sin
Push R0
MovImm 3 R0
Push R0
MovImm 4 R0
Mov R0 R1
Pop R0
CallPrimitiveFunction -
CallPrimitiveFunction Cos
Mov R0 R1
Pop R0
CallPrimitiveFunction +
Push R0
MovImm 5 R0
Push R0
MovImm 6 R0
Mov R0 R1
Pop R0
CallPrimitiveFunction *
CallPrimitiveFunction Tan
Mov R0 R1
Pop R0
CallPrimitiveFunction -

字节码解释器求值结果=7.086753510574282
直接递归下降解释执行结果=true,7.086753510574282


下一步工作：编写一个可视化界面？将JS代码格式化一下，然后变量命名再重构一下？加上AST生成和转换成JS运算表达式的支持？


使用JavaScript实现一个“字节码解释器”，并用它重新实现JS科学计算器的后端（后续1）
cteng的专栏
12-02 1624
字节码设计：第一版（仅仅用于表达式计算） PushImm 123 Push R2 Pop R0 Mov src, dst #寄存器到寄存器 MovImm imm, reg #加载立即数到寄存器 CallPrimitiveFunction ‘＋’ #ABI: 最多2个输入参数，R0,R1，输出结果在R0 核心JS代码（部分，优快云博客不支持上传附件）： functi
Java开发常见专业术语
weixin_42408447的博客
05-10 1万+
1.脚本 脚本（Script），是使用一种特定的描述性语言，依据一定的格式编写的可执行文件。 2.http协议 HTTP协议，即超文本传输协议(Hyper text transfer protocol)。是一种详细规定了浏览器和万维网(WWW = World Wide Web)服务器之间互相通信的规则，通过因特网传送万维网文档的数据传送协议。 3.B/S结构和C/S结构 B/S（Browser/Server）：指浏览器和服务器架构。 C/S（Client/Server）：指客户端和服务器架构 4.报文 报文
rusty-jsyc：用Rust编写JavaScript到字节码编译器
01-31
生锈的JSYC Rusty-JSYC（JavaScript bYtecode编译器）是用Rust编写JavaScript到字节码的编译器。 该字节码旨在与以JavaScript编写的提供的结合使用。 它们共同构成了虚拟化混淆的组件。 也有一篇解释了这个项目和虚拟化的困惑。 如何使用 您必须首先编译给定JavaScript代码。 之后，您可以使用提供的虚拟机执行它。 编译您JavaScript代码 您可以使用提供的命令行工具： cargo run < /path/to/javascript.js > < /path/to/vm-template.js > < /output/dir > -d 或将编译器用作库并从您自己的rust代码调用它： extern crate jsyc_compiler; use jsyc_compiler :: {JSSourceCode, BytecodeCompiler}; fn main () { let js_code = JSSourceCode :: new ( "console.log('Hello World');" . into
JavaScript的字节码 - v8 Ignition指令
lusing的专栏
12-08 2413
JavaScript的字节码 - v8 Ignition指令 前面的文章我们介绍了在js的AST层次的各种操作手段。AST操练熟练了之后，就差一步就可以执行了，那就是转换成中间代码，或者是解释型的字节码，或者是为编译器准备的IR. 我们以v8为例，首先看下v8的运行架构： 这个图中有三个不熟悉的专有名词，ignition, crankshaft和Turbofan。 其中，Ignition是v8的解释器，crankshaft是老一代的编译器，turbofan是较新一代的编译器。所以我们所说的字节码就对应于i
小型桌面计算器的实现(javacc)
novelly的专栏
05-27 1952
从开始学计算理论，就对形式语言，编译原理很感兴趣，所以大学对这门课学的也算是最好了。自己也实现过一些简单的词法分析器之类的东西，不过也都是学习目的的，质量一般 后来一直在Linux学习，对lex/yacc研究过一点时间，设计过一个小的脚本引擎，可以做一些比较复杂的数学运算，这个可以参考我的这篇博客。工作以后，平台 变成了java，跟C渐渐的离得远了，也喜欢上java这个提供语言级别的面向对象的语言
js 读取mid文件_高手不传之密：把JS代码生成字节码，用字节码技术保护NodeJS源码。...
weixin_39542936的博客
11-24 637
现在很后端服务都是用NodeJS开发的，比如网站后台、游戏服务器、应用服务等等。但NodeJS的后端，有一个弊端，常让人心里不踏实：JS的代码，代码是透明公开的，很容易被他人COPY，很容易自己开发产品就泄漏了，甚至是很快出现雷同产品。这里介绍一种NodeJS源代码保护方式：把nodejs代码转化为字节码，用node启动字节码文件的方式，保护nodejs源代码不泄漏。可应用于nodejs项目提交源...
编译器原理－－一个小计算器的实现
10-12
利用编译器原理的知识，实现的一个小计算器，支持最基本的四则运算和括号嵌套。
Golang笔记
怨行客
10-18 691
协程是用户态轻量级线程协程是线程调度的基本单位通常在函数前加上go关键字就能实现并发。一个Goroutine会以一个很小的栈启动2KB或4KB，当遇到栈空间不足时，栈会自动伸缩， 因此可以轻易实现成千上万个goroutine同时启动。
Java面试所需的知识
Tona_ZM的博客
11-15 3104
目录 1. 计算机网络 （1）网络7层架构 （2）TCP/IP原理 （3）HTTP原理 （4）加密算法 2. 数据结构 3. 算法 （1） Java算法 （2）海量数据处理 4. 操作系统 5. MySQL数据库 1、事务 2、数据库结构和锁 3、索引 4、情景题、优化题 5、琐碎知识 6、视图 7、存储过程和触发器 8、约束 6. Redis数据库...
逆向分析：基于 JS 字节码的保护技术
m0_73257876的博客
09-14 654
现在流行使用 JS 字节码对 JavaScript 源码进行保护。我怎么感觉技术也是轮回发展的呢？字节码与 JavaScript 源码的关系，就像汇编与 PE 或 ELF 一样，感觉又回到了 N 年前用 IDA+OD 做逆向的时代。但时代不同了，逆向的程序越来越大，工作量越来越大，需要更有效的自动化手段来降低逆向的工作量。当然，再自动的方法也只能是辅助工具，因为逆向就是个体力活。监控每个 JS API，准确地说是所有的 ECMAScript API。
【Cocos2d-js3.0Alpha2加密js文件】CH5混淆打包及JSB编译字节码jsc文件
yubin_cai的专栏
07-05 4260
//——————-ch5————————————- 【压缩混淆】 很简单，都已经写好了。 步骤: 1.复制cocos2d-html5/tools文件夹到项目根目录下。 2.命令行下进入该tools目录用nodejs执行publish.js就可以了。 项目目录\tools>node publish.js 【注意：】publish.js文件里要选择Simple模式。尝试Advanced不
【亲测免费】 探索JavaScript字节码的奥秘 - SpiderMonkey 34版Bytecode Decoder深度解析
最新发布
gitblog_00088的博客
06-11 538
探索JavaScript字节码的奥秘 - SpiderMonkey 34版Bytecode Decoder深度解析 在JavaScript开发的世界里，理解虚拟机内部运作总能激发开发者的好奇心和探索欲。今天，我们要向您推荐一个独特的开源项目——SpiderMonkey 34版Javascript字节码解码器，为那些渴望深入了解Mozilla SpiderMonkey引擎工作原理的开发者们提供了一...
脚本引擎执行Javascript和字节码操作
Mai_Dreizehn的博客
12-10 724
脚本引擎介绍： - 使得Java应用程序可以通过一套固定的接口与各种脚本引擎交互，从而达到在Java平台上调用各种脚本语言的目的。 - Java脚本API是连通Java平台和脚本语言的桥梁 - 可以把一些复杂变异的业务逻辑交给脚本语言处理，这又大大提高了开发效率 Java脚本API为开发者提供了如下功能： - 获取脚本程序输入，通过脚本引擎运行脚本并返回运行结果，这是最核心的接口。 -...
JS字符串转Byte[]
热门推荐
秋水浮萍任飘渺
09-13 5万+
js里面的string转byte[]，这里是微信小程序代码 stringToBytes : function ( str ) { var ch, st, re = []; for (var i = 0; i < str.length; i++ ) { ch = str.charCodeAt(i); // get char
JS生成字节码生成技术，用字节码保护商业NodeJS源码！
weixin_34274029的博客
03-14 1876
本文介绍一种NodeJS源代码保护方式：通过把nodejs代码转化为字节码，用node启动字节码文件的方式，保护nodejs源代码不泄漏。可应用于nodejs项目提交源码、nodejs产品在不可信的环境中部署，防止别人获取源码。如同JS代码一样，nodejs源码，也是透明代码，通常用node启动代码时，都必须把源码也放置到启动环境中。这在很多时候是不安全不稳妥的。因为js源码...
使用JavaScript实现一个“字节码解释器”，并用它重新实现JS科学计算器的后端（待续）
cteng的专栏
11-28 1646
为简化问题， 1、科学计算器不包含用户自定义函数，也就是说，“字节码解释器”不考虑嵌套调用栈的问题； 2、需要把表达式转换为序列化的基于“寄存器”（假设R0~R15）和“局部变量”（像LLVM那样%1~无限）的微指令字节码序列，这里面最重要的是一个CPS转换 3、需要定义字节码调用原语函数（PrimitiveFunction）的ABI规范，目前简化为：最多2个参数，用R0、R1传递，结果
[WebKit内核] JavaScript引擎深度解析--基础篇（一）字节码生成及语法树的构建详情分析
不积跬步无以至千里，不积小流无以成江海
03-26 9163
看到HorkeyChen写的文章《[WebKit] JavaScriptCore解析--基础篇(三)从脚本代码到JIT编译的代码实现》，写的很好，深受启发。想补充一些Horkey没有写到的细节比如字节码是如何生成的等等，为此成文。       JSC对JavaScript的处理，其实与Webkit对CSS的处理许多地方是类似的，它这么几个部分： （1）词法分析->出来词语(Token)
Js之字符串和字节码之间的相互转换-yellowcong
01-13 7664
做项目的时候，由于编码和码表问题，导致符号显示不正确的，还有符号是16进制的，还有的键盘code乱码的问题，可以通过二进制的方法，来解决这个问题，直接传递二进制，然后将二进制的转化为目标字符串，即可
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值