Problems and solutions when using encode scripts and normal scripts together_javascript skills

When I first did script encoding half a year ago, I had no experience in using it, so I asked on 51js if there were any problems with mixing encode scripts and normal scripts. As a result, no constructive opinions were received, which at least illustrates two problems. One is that no one cares, and the other is that there is no problem. Of course, I was more willing to accept the latter result, so I started using the mixed use of encode scripts and normal scripts.

With this understanding, I made a lot of scripts, and it seemed that there were really no problems, so I believed in my original judgment even more. The result was once again tricked by IE. The mixed use of encoded scripts and normal scripts is not without problems, and not all of them have problems, but problems will occur under certain conditions. It is really dizzying. Look at the following example:

Copy the code The code is as follows:

 
 
     
     
 
 
     
        #@~^8gAAAA==~,P~,P,Pr(L^Ycw.WDWOza Rtn/klo~xP6E    mOkGUv#@#@&,~P,P~~,    @#@&~,P~P,~,P~,P,lVDDcB}4% 1Y 2MWYKOXa Rtnd/moBbi@#@&,P~P,~P,8I@#@&PP~~,P~P@#@&,P~,P,PP}4NnmDR k/CLP',WE    mYbGU`*@#@&P~P~~,P~    @#@&P,P~~,PP~~,P~l^nMYcEr(L 1Yc k/CoBbI@#@&P,~P,PP,NIGjkAAA==^#~@ 
     
     
        #@~^FgEAAA==~,P~,P,P0!x1OkKx~2mG[`#,`8@#@&@#@&~~P,P,P~2U^KNnRa.WDWOza Rnk/Co~{PW!x1YkKxvb@#@&P~P,P~~,    @#@&~P,PP,~~P,P,.kOndkU vv2    mG[Rw.GDWOXancHnk/mo E#p@#@&,P~P,P~~)i@#@&@#@&,PP,~~P,2    mGNn t d/mL ,'~W!xmOrKxc#@#@&,P~,P,PPP@#@&~P,P~P,P~~,PMrYSk    ncBAx1W[  /dlTnB*i@#@&,PP~~,P~8p~,V0MAAA==^#~@ 
     
     
        function Normal() {}  
        Normal.prototype.Message = function() 
        { 
            WriteLine('Normal.prototype.Message'); 
        };  
        Normal.Message = function() 
        { 
            WriteLine('Normal.Message'); 
        };  
     
     
        var msg = '.prototype.Message" Fail.
'; 
        function WriteLine(msg) { document.write(msg   '

'); } 

        var o = new Object(); 
        try { o.Message(); } 
        catch(e) { WriteLine('Call "Object'   msg   e.message); } 
        try { Object.Message(); } 
        catch(e) { WriteLine('Call "Object.Message" Fail. 
'   e.message); } 

        var e = new Encode(); 
        try { e.Message(); } 
        catch(e) { WriteLine('Call "Encode'   msg   e.message); } 
        Encode.Message(); 

        var n = new Normal(); 
        try { n.Message(); } 
        catch(e) { WriteLine('Call "Normal'   msg   e.message); } 
        Normal.Message(); 
     
 
 

Save the above code as a *.htm file, and the result after opening is:

Call "Object.prototype.Message" Fail.
Object doesn't support this property or method
Call "Object.Message" Fail.
Object doesn't support this property or method
Encode.prototype.Message
Encode.Message
Normal.prototype.Message
Normal.Message
The two jscript.encode codes above are very simple, that is: Object.prototype.Message = function()
{
alert('Object.prototype.Message');
};
Object.Message = function()
{
alert('Object.Message');
};
function Encode() {}
Encode.prototype.Message = function( )
{
WriteLine('Encode.prototype.Message');
};
Encode.Message = function()
{
WriteLine('Encode.Message');
};
If we replace the two pieces of code above with the two pieces of jscript.encode code in the html, there will be no exceptions in subsequent runs, and we will get this output: Object.prototype.Message
Object.Message
...
The tests of the above code examples have explained the problem of encode script code in detail. That is, prototype methods and static methods imported into JScript built-in objects in encoded scripts cannot be referenced in non-encoded scripts. The Object in the above example is a built-in object of JScript. We imported a prototpye method and a static method Message() respectively. For the non-built-in object Encode, the prototype and static methods we imported in the encoded code can be accessed normally in the non-encoded code.

So how to access the import method of the built-in object? In fact, the solution is not complicated, but it is more cumbersome. We need to use some wrapper methods and put them together with the encoded code so that they can be accessed in non-encoded code. For example, the import of Object above, we can wrap it like this:

Object.prototype .Message = function()
{
WriteLine('Object.prototype.Message');
};
Object.Message = function()
{
WriteLine('Object .Message');
};
var obj = new Object();

function ObjectPrototypeMessage()
{
obj.Message();
}
function ObjectMessage()
{
Object.Message();
}
At this time, we can access the import method of the built-in object in the encoded code through wrapper methods such as ObjectPrototypeMessage and ObjectMessage .