CN107038058A - A kind of code process method and device - Google Patents

Abstract

The embodiment of the present application discloses a kind of code process method and device.Methods described includes：Obtain pending code；Determine each function call for specified function in the pending code, and each branch condition in the specified function；The parameter according to used in the branch condition and each function call, cutting processing is carried out to the branch code in the specified function corresponding to the branch condition.Using the embodiment of the present application, the partial redundance code in packaging file can be eliminated, so as to reduce the volume of packaging file.

Description

Code processing method and device

technical field

The present application relates to the technical field of computer software, in particular to a code processing method and device.

Background technique

With the rapid development of computer technology and Internet technology, a large number of various application programs have emerged, bringing convenience to people's lives.

Most applications or some functional modules in the applications need to be packaged and provided to users, and then users can use the packaged files after downloading and installing them. The packaging file usually contains function-related code and non-code files, such as JavaScript code used by the front-end control, program global configuration files, binary resource files, and so on.

However, as the functions of the application program become more and more powerful, the volume of the packaged file becomes larger and larger, which will have adverse effects on the user's acquisition of the packaged file, and will also reduce the execution efficiency of the code in the packaged file.

Contents of the invention

The embodiment of the present application provides a code processing method and device to solve the following technical problems in the prior art: as the functions of the application program become more and more powerful, the volume of the packaged file becomes larger and larger, and the packaged file will be obtained for the user. files, and will also reduce the execution efficiency of the code inside the packaged file.

In order to solve the above technical problems, the embodiment of the present application is implemented as follows:

A code processing method provided in an embodiment of the present application includes:

get pending code;

determining each function call for a specified function in the code to be processed, and each branch condition in the specified function;

According to the branch condition and the parameters used by the function calls, the branch code corresponding to the branch condition in the specified function is clipped.

A code processing device provided in an embodiment of the present application includes:

Get the module and get the code to be processed;

A determining module, determining each function call for a specified function in the code to be processed, and each branch condition in the specified function;

The processing module, according to the branch condition and the parameters used by the function calls, performs tailoring processing on the branch code corresponding to the branch condition in the specified function.

The above-mentioned at least one technical solution adopted in the embodiment of the present application can achieve the following beneficial effects: it can eliminate some redundant codes in the packaged file, thereby reducing the volume of the packaged file, thereby reducing the inconvenience caused by the prior art to the user in obtaining the packaged file. adverse effects, and it is also beneficial to improve the execution efficiency of the code in the packaging file, therefore, it can partially or completely solve the problems in the prior art.

Description of drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the following will briefly introduce the drawings that need to be used in the description of the embodiments or the prior art. Obviously, the accompanying drawings in the following description are only These are some embodiments described in this application. Those skilled in the art can also obtain other drawings based on these drawings without any creative effort.

FIG. 1 is a schematic flowchart of a code processing method provided in an embodiment of the present application;

FIG. 2 is a schematic structural diagram of a code processing device corresponding to FIG. 1 provided by an embodiment of the present application.

detailed description

Embodiments of the present application provide a code processing method and device.

In order to enable those skilled in the art to better understand the technical solutions in the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application. Obviously, the described The embodiments are only some of the embodiments of the present application, but not all of them. Based on the embodiments in this application, all other embodiments obtained by persons of ordinary skill in the art without creative efforts shall fall within the scope of protection of this application.

Figure 1 is a schematic flow diagram of a code processing method provided by the embodiment of the present application. The flow can be implemented by a program, and the devices that can carry the program include but are not limited to the following: personal computers, large and medium-sized computers, computer clusters, mobile phones, Tablet PCs, smart wearable devices, vehicles, etc.

The process in Figure 1 may include the following steps:

S101: Obtain the code to be processed.

In this embodiment of the application, the code may be based on any programming language. For example, code written in programming languages such as JavaScript, JAVA, C, C++, PHP, and Python. For ease of description, the following embodiments mainly use JavaScript code as an example for illustration.

In the embodiment of the present application, the code to be processed is usually the code waiting to be packaged or modularized for a specified application scenario.

The code to be processed includes function bodies of one or more functions, and one or more function calls to the functions. In different application scenarios, the function body may remain unchanged, but the parameters used in the corresponding function calls may be different, for example, different parameter types and different parameter values.

S102: Determine each function call for a specified function in the code to be processed, and each branch condition in the specified function.

In this embodiment of the present application, the specified function may be any function whose function body is included in the code to be processed. In practical applications, for each function whose function body is included in the code to be processed, each function in at least some of the functions can be used as a designated function, and the flow in Figure 1 is executed for each designated function .

In the embodiment of the present application, the function calls specifically include all function calls for a specified function in the code to be processed. The various function calls may use different parameters respectively.

For example, assuming the specified function is "clone(item)", a function call to the specified function could be "clone()", and another function call to the specified function could be "clone('foo')", wait. It can be seen that the parameter used by clone() is empty (belonging to non-item), and the parameter used by clone('foo') is the string foo.

In the embodiment of the present application, the specified function includes one or more branch conditions. The branch conditions specifically include all branch conditions in the specified function. Generally, branching conditions are contained in conditional statements such as "if", "else", etc.

For example, assume that the function clone(item) is specified as follows:

It can be seen that the specified function in the above example contains two branch conditions. The branch condition of branch 1 is "!item", and the branch condition of branch 2 is "typeof item==='string'".

It should be noted that, in practical applications, the function body of the specified function may not be included in the code to be processed. However, in this case, the subsequent clipping processing of the specified function may affect: the result of a function call to the specified function outside the code to be processed.

S103: According to the branch condition and the parameters used by the function calls, perform clipping processing on the branch code corresponding to the branch condition in the specified function.

In the embodiment of this application, as mentioned above, the code to be processed is usually the code waiting to be packaged or modularized for the specified application scenario. In the specified application scenario, when calling the function in the code to be processed, it is not necessary All branches in the function are used. Then, it can be considered that: in the specified application scenario, the code of the branch that will not be used is redundant, it can be cut out from the code to be processed, and then the cut code to be processed can be packaged to reduce the The volume of pending code.

In the embodiment of this application, according to the branch conditions and the parameters used by each function call, it can be determined which branches are not needed in the scene corresponding to the code to be processed, and then the code of the branch that will not be used can be determined Perform cropping.

In addition, it should be noted that this application does not limit the execution order of "determining the function calls for the specified function in the code to be processed" and "determining the branch conditions in the specified function" in step S102, It can be executed at the same time or one after the other.

Through the method in Fig. 1, part of the redundant codes (included in the above code to be processed) in the packaged file can be eliminated, thereby reducing the volume of the packaged file, and then reducing the cost of obtaining the packaged file for the user in the prior art adverse effects, and is also beneficial to improve the execution efficiency of the code in the packaging file, therefore, the problems in the prior art can be partially or completely solved.

Based on the method in FIG. 1 , the embodiment of the present application also provides some specific implementations and extensions of the method, which will be described below.

In this embodiment of the application, after the code to be processed is obtained, the subsequent steps can be implemented by traversing the code to be processed, or the code to be processed can be converted into a data form that is easier to analyze such as a syntax tree, and then according to the obtained Data enables next steps. The syntax tree is used as an example below.

Then for step S102, the determining the function calls for the specified function in the code to be processed may specifically include: generating a syntax tree of the code to be processed; determining the code to be processed according to the syntax tree of the code to be processed Each function call for the specified function in the processing code, the parameters used by each function call, and each branch condition in the specified function.

How to generate the syntax tree is not limited in this application, and it can be realized by using existing technologies. In the syntax tree, elements in the code such as functions and function calls can be represented as tree nodes, which are easy to analyze and operate.

As mentioned earlier, the process in Figure 1 may be executed for multiple functions in the code to be processed, therefore, all function calls and the parameters used in the code to be processed can be uniformly determined (and these data can be saved in such as List and other data structures for ease of use), in this way, these function calls and parameters can be directly used when executing the subsequent process, which is beneficial to improve the execution efficiency of the solution of the present application.

Specifically, the determining, according to the syntax tree of the code to be processed, each function call for a specified function in the code to be processed and the parameters used by each function call may include: according to the code to be processed Syntax tree, determine all function calls in the code to be processed, and determine the parameters used to determine all the function calls respectively; classify all the determined function calls, and the function calls for the same function are divided into Within the same class; among various classes, determine a type of function call for the specified function, and determine the parameters used by this type of function call.

Further, the determining each branch condition in the specified function may specifically include: determining the syntax tree of the specified function according to the syntax tree of the code to be processed; determining the syntax tree of the specified function according to the syntax tree of the specified function Describes each branch condition in the specified function.

In the embodiment of the present application, for step S103, the branch code corresponding to the branch condition in the specified function is trimmed according to the branch condition and the parameters used by the function calls, specifically, include:

Execute each branch condition in the branch conditions respectively:

According to the parameters used by each function call in the function calls, determine whether the parameters used for the function call can satisfy the branch condition; if the parameters used for each function call can not If the branch condition is satisfied, the branch code corresponding to the branch condition is deleted.

For ease of understanding, the above example is used for illustration.

Assume that for the above specified function clone(item) in the code to be processed, there are two function calls for clone(item): clone() and clone('foo'). It can be seen that clone() can meet the branch condition "!item" of branch 1 of clone(item), and clone('foo') can meet the branch condition "typeof item==='string" of branch 2 of clone(item). '", therefore, the branch codes of these two branches are not redundant and do not need to be pruned.

Assuming that clone(item) has only one function call clone() for clone(item), the parameters used by clone() do not satisfy the branch condition "typeof item==='string'" of branch 2, therefore, branch 2 The branch code of (that is, the branch code corresponding to the branch condition of branch 2) is redundant and can be trimmed. The function body of clone(item) after clipping is as follows:

Further, after executing each of the branch conditions respectively, it may also execute: if only one branch condition is included in the specified function after the execution, the code representing the branch condition delete. In this way, code redundancy can be further eliminated.

The reason for this is: if only one branch condition is included in the specified function after the execution, then for any function call in the specified function in the code to be processed, the function call used The parameters of must satisfy the branch condition, so it is only necessary to keep the code that needs to be executed when the branch condition is met, and it is not necessary to keep the branch condition itself.

For ease of understanding, the above example is used for illustration.

The function body of clone(item) after clipping in the above example is further clipped, and after further clipping, it is as follows:

"function clone(item){

return item;

}"

Because, in this example, the only function call of the code to be processed for clone(item) is clone(), so when the function call is executed, there is no need to judge the branch condition, and it is sufficient to directly execute "return item".

Based on a similar idea, after each branch condition in the branch conditions is executed, it can also be executed: for branch conditions other than the last branch condition in the specified function after the execution, if the corresponding If the branch codes of the other branch conditions all jump out of the specified function, the code representing the last branch condition is deleted. In this way, code redundancy can also be further eliminated.

The reason for this is: for any function call in the specified function in the code to be processed, if the parameters used in the function call do not satisfy the branch conditions before the last branch condition (if it is satisfied, the specified function will be jumped out, and the subsequent code in the specified function will not be executed), then the last branch condition must be satisfied, therefore, as long as the last branch condition is met, the required Execute the code without preserving the last branch condition itself.

The above describes a code processing method provided by the embodiment of the present application. Based on the same inventive idea, the embodiment of the present application also provides a corresponding device, as shown in FIG. 2 .

Fig. 2 is a schematic structural diagram of a code processing device corresponding to Fig. 1 provided by the embodiment of the present application. The device can be located on the execution body of the process in Fig. 1, including:

Obtaining module 201, obtaining the code to be processed;

Determining module 202, determining each function call for a specified function in the code to be processed, and each branch condition in the specified function;

The processing module 203, according to the branch condition and the parameters used by the function calls, performs tailoring processing on the branch code corresponding to the branch condition in the specified function.

Optionally, the determination module 202 determines each function call for a specified function in the code to be processed, and each branch condition in the specified function, specifically including:

The determining module 202 generates a syntax tree of the code to be processed, and determines each function call for a specified function in the code to be processed and the parameters used by each function call according to the syntax tree of the code to be processed, and each branch condition in the specified function.

Optionally, the determining module 202 determines each function call for a specified function in the code to be processed and the parameters used by each function call according to the syntax tree of the code to be processed, specifically including:

The determination module 202 determines all function calls in the code to be processed according to the syntax tree of the code to be processed, and determines the parameters used to determine all the function calls respectively, and executes on all the determined function calls Classification, the function calls for the same function are classified into the same class, and a type of function call for the specified function is determined in each category, and parameters used for this type of function call are determined.

Optionally, the determination module 202 determines each branch condition in the specified function, specifically including:

The determination module 202 determines the syntax tree of the specified function according to the syntax tree of the code to be processed, and determines each branch condition in the specified function according to the syntax tree of the specified function.

Optionally, the processing module 203 performs tailoring processing on the branch code corresponding to the branch condition in the specified function according to the branch condition and the parameters used by the function calls, specifically including:

The processing module 203 respectively executes on each of the branch conditions:

Determine whether the branch condition can be satisfied for the parameters used in the function call according to the parameters used in each of the function calls;

If the branch condition cannot be satisfied for the parameters used by each function call, delete the branch code corresponding to the branch condition.

Optionally, after the processing module 203 respectively executes each of the branch conditions, if the executed specified function contains only one branch condition, the code representing the branch condition delete.

Optionally, after the processing module 203 respectively executes each of the branch conditions, for branch conditions other than the last branch condition in the specified function after execution, if the corresponding If the branch codes of the other branch conditions mentioned above all jump out of the specified function, the code representing the last branch condition is deleted.

Optionally, the code is JavaScript code.

The device and the method provided in the embodiment of the present application are in one-to-one correspondence, therefore, the device also has beneficial technical effects similar to the corresponding method, since the beneficial technical effect of the method has been described in detail above, so it will not be repeated here The beneficial technical effect of the corresponding device.

In the 1990s, the improvement of a technology can be clearly distinguished as an improvement in hardware (for example, improvements in circuit structures such as diodes, transistors, and switches) or improvements in software (improvement in method flow). However, with the development of technology, the improvement of many current method flows can be regarded as the direct improvement of the hardware circuit structure. Designers almost always get the corresponding hardware circuit structure by programming the improved method flow into the hardware circuit. Therefore, it cannot be said that the improvement of a method flow cannot be realized by hardware physical modules. For example, a Programmable Logic Device (Programmable Logic Device, PLD) (such as a Field Programmable Gate Array (Field Programmable Gate Array, FPGA)) is such an integrated circuit, and its logic function is determined by programming the device by a user. It is programmed by the designer to "integrate" a digital system on a PLD, instead of asking a chip manufacturer to design and make a dedicated integrated circuit chip. Moreover, nowadays, instead of making integrated circuit chips by hand, this kind of programming is mostly realized by "logic compiler (logic compiler)" software, which is similar to the software compiler used when writing programs. The original code of the computer must also be written in a specific programming language, which is called a hardware description language (Hardware Description Language, HDL), and there is not only one kind of HDL, but many kinds, such as ABEL (Advanced Boolean Expression Language) , AHDL (Altera Hardware Description Language), Confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), Lava, Lola, MyHDL, PALASM, RHDL (Ruby Hardware Description Language), etc., currently the most commonly used is VHDL (Very-High-Speed Integrated Circuit Hardware Description Language) and Verilog. It should also be clear to those skilled in the art that only a little logical programming of the method flow in the above-mentioned hardware description languages and programming into an integrated circuit can easily obtain a hardware circuit for realizing the logic method flow.

The controller may be implemented in any suitable way, for example the controller may take the form of a microprocessor or processor and a computer readable medium storing computer readable program code (such as software or firmware) executable by the (micro)processor , logic gates, switches, Application Specific Integrated Circuit (ASIC), programmable logic controllers, and embedded microcontrollers, examples of controllers include but are not limited to the following microcontrollers: ARC 625D, Atmel AT91SAM, Microchip PIC18F26K20 and Silicone Labs C8051F320, the memory controller can also be implemented as part of the memory's control logic. Those skilled in the art also know that, in addition to realizing the controller in a purely computer-readable program code mode, it is entirely possible to make the controller use logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded The same function can be realized in the form of a microcontroller or the like. Therefore, such a controller can be regarded as a hardware component, and the devices included in it for realizing various functions can also be regarded as structures within the hardware component. Or even, means for realizing various functions can be regarded as a structure within both a software module realizing a method and a hardware component.

The systems, devices, modules, or units described in the above embodiments can be specifically implemented by computer chips or entities, or by products with certain functions. A typical implementing device is a computer. Specifically, the computer may be, for example, a personal computer, a laptop computer, a cellular phone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or Combinations of any of these devices.

For the convenience of description, when describing the above devices, functions are divided into various units and described separately. Of course, when implementing the present application, the functions of each unit can be implemented in one or more pieces of software and/or hardware.

Those skilled in the art should understand that the embodiments of the present invention may be provided as methods, systems, or computer program products. Accordingly, the present invention can take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.

The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It should be understood that each procedure and/or block in the flowchart and/or block diagram, and a combination of procedures and/or blocks in the flowchart and/or block diagram can be realized by computer program instructions. These computer program instructions may be provided to a general purpose computer, special purpose computer, embedded processor, or processor of other programmable data processing equipment to produce a machine such that the instructions executed by the processor of the computer or other programmable data processing equipment produce a An apparatus for realizing the functions specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing apparatus to operate in a specific manner, such that the instructions stored in the computer-readable memory produce an article of manufacture comprising instruction means, the instructions The device realizes the function specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions can also be loaded onto a computer or other programmable data processing device, causing a series of operational steps to be performed on the computer or other programmable device to produce a computer-implemented process, thereby The instructions provide steps for implementing the functions specified in the flow chart or blocks of the flowchart and/or the block or blocks of the block diagrams.

In a typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.

Memory may include non-permanent storage in computer readable media, in the form of random access memory (RAM) and/or nonvolatile memory such as read only memory (ROM) or flash RAM. Memory is an example of computer readable media.

Computer-readable media, including both permanent and non-permanent, removable and non-removable media, can be implemented by any method or technology for storage of information. Information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read only memory (ROM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Flash memory or other memory technology, Compact Disc Read-Only Memory (CD-ROM), Digital Versatile Disc (DVD) or other optical storage, Magnetic tape cartridge, tape magnetic disk storage or other magnetic storage device or any other non-transmission medium that can be used to store information that can be accessed by a computing device. As defined herein, computer-readable media excludes transitory computer-readable media, such as modulated data signals and carrier waves.

It should also be noted that the term "comprises", "comprises" or any other variation thereof is intended to cover a non-exclusive inclusion such that a process, method, article, or apparatus comprising a set of elements includes not only those elements, but also includes Other elements not expressly listed, or elements inherent in the process, method, commodity, or apparatus are also included. Without further limitations, an element defined by the phrase "comprising a ..." does not exclude the presence of additional identical elements in the process, method, article or apparatus comprising said element.

Those skilled in the art should understand that the embodiments of the present application may be provided as methods, systems or computer program products. Accordingly, the present application can take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.

This application may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The application may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including storage devices.

Each embodiment in this specification is described in a progressive manner, the same and similar parts of each embodiment can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the system embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and for relevant parts, refer to part of the description of the method embodiment.

The above descriptions are only examples of the present application, and are not intended to limit the present application. For those skilled in the art, various modifications and changes may occur in this application. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application shall be included within the scope of the claims of the present application.

Claims (16)

1. a kind of code process method, it is characterised in that including：

Obtain pending code；

Determine each function call for specified function in the pending code, and each branch's bar in the specified function Part；

The parameter according to used in the branch condition and each function call, to corresponding to described point in the specified function The branch code of branch condition carries out cutting processing.

2. the method as described in claim 1, it is characterised in that determine to be directed to each letter of specified function in the pending code Number is called, and each branch condition in the specified function, is specifically included：

Generate the syntax tree of the pending code；

According to the syntax tree of the pending code, determine in the pending code for specified function each function call and Each branch condition in parameter, and the specified function used in each function call.

3. method as claimed in claim 2, it is characterised in that the syntax tree according to the pending code, determines institute State in pending code for parameter used in each function call and each function call of specified function, specifically include：

According to the syntax tree of the pending code, all function calls in the pending code are determined, and determine to divide Parameter used in all function calls is not determined；

Pair determine all function calls classify, targeted function identical function call is in same class；

Called in all kinds of middle Certain function summaries for determining to be directed to specified function, and determine parameter used in such function call.

4. method as claimed in claim 2, it is characterised in that each branch condition in the determination specified function, tool Body includes：

According to the syntax tree of the pending code, the syntax tree of the specified function is determined；

According to the syntax tree of the specified function, each branch condition in the specified function is determined.

5. the method as described in claim 1, it is characterised in that described according to the branch condition and each function call institute The parameter used, carries out cutting processing to the branch code in the specified function corresponding to the branch condition, specifically includes：

Each branch condition in each branch condition is performed respectively：

Parameter used in each function call in each function call respectively, it is determined that being made for the function call Parameter, if the branch condition can be met；

If for parameter used in each function call, can not meet the branch condition, then delete and correspond to this point The branch code of branch condition.

6. method as claimed in claim 5, it is characterised in that described respectively to each branch's bar in each branch condition After part is performed, methods described also includes：

If only the code for representing the branch condition is deleted comprising a branch condition in the specified function after the execution Remove.

7. method as claimed in claim 5, it is characterised in that described respectively to each branch's bar in each branch condition After part is performed, methods described also includes：

For other branch conditions beyond last branch condition in the specified function after the execution, if corresponding to The branch code of other branch conditions can jump out the specified function, then will represent last branch condition Code deletion.

8. the method as described in any one of claim 1~7, it is characterised in that the code is JavaScript code.

9. a kind of code processing apparatus, it is characterised in that including：

Module is obtained, pending code is obtained；

Determining module, determines to be directed to each function call of specified function in the pending code, and in the specified function Each branch condition；

Processing module, the parameter according to used in the branch condition and each function call, to right in the specified function The branch code of branch condition described in Ying Yu carries out cutting processing.

10. device as claimed in claim 9, it is characterised in that the determining module determines to be directed in the pending code Each function call of specified function, and each branch condition in the specified function, are specifically included：

The determining module generates the syntax tree of the pending code, according to the syntax tree of the pending code, determines institute State in pending code for parameter used in each function call and each function call of specified function, and the finger Determine each branch condition in function.

11. device as claimed in claim 10, it is characterised in that the determining module is according to the grammer of the pending code Tree, determines for parameter used in each function call and each function call of specified function in the pending code, Specifically include：

The determining module determines that all functions in the pending code are adjusted according to the syntax tree of the pending code With, and determine to determine parameter used in all function calls respectively, pair all function calls determined are carried out Classification, targeted function identical function call is in same class, in all kinds of middle class letters determined for specified function Number is called, and determines parameter used in such function call.

12. device as claimed in claim 10, it is characterised in that the determining module determines each point in the specified function Branch condition, is specifically included：

The determining module determines the syntax tree of the specified function, according to described according to the syntax tree of the pending code The syntax tree of specified function, determines each branch condition in the specified function.

13. device as claimed in claim 9, it is characterised in that the processing module is according to the branch condition and described each Parameter used in function call, is carried out at cutting to the branch code in the specified function corresponding to the branch condition Reason, is specifically included：

The processing module is performed to each branch condition in each branch condition respectively：

Parameter used in each function call in each function call respectively, it is determined that being made for the function call Parameter, if the branch condition can be met；

If for parameter used in each function call, can not meet the branch condition, then delete and correspond to this point The branch code of branch condition.

14. device as claimed in claim 13, it is characterised in that the processing module is respectively in each branch condition After each branch condition is performed, if only comprising a branch condition in the specified function after the execution, will represent should The code deletion of branch condition.

15. device as claimed in claim 13, it is characterised in that the processing module is respectively in each branch condition After each branch condition is performed, for other points beyond last branch condition in the specified function after the execution Branch condition, if can jump out the specified function corresponding to the branch code of other branch conditions, will represent described in most The code deletion of latter branch condition.

16. the device as described in any one of claim 9~15, it is characterised in that the code is JavaScript code.