CN112214392B - JS code debugging method, device, terminal and storage medium - Google Patents
JS code debugging method, device, terminal and storage medium Download PDFInfo
- Publication number
- CN112214392B CN112214392B CN201910621773.4A CN201910621773A CN112214392B CN 112214392 B CN112214392 B CN 112214392B CN 201910621773 A CN201910621773 A CN 201910621773A CN 112214392 B CN112214392 B CN 112214392B
- Authority
- CN
- China
- Prior art keywords
- class
- terminal
- engine
- debugger
- instruction
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 59
- 230000008569 process Effects 0.000 claims abstract description 21
- 238000004891 communication Methods 0.000 claims description 25
- 238000004806 packaging method and process Methods 0.000 claims description 13
- 230000006978 adaptation Effects 0.000 abstract description 4
- 238000010586 diagram Methods 0.000 description 14
- 230000006870 function Effects 0.000 description 10
- 230000002452 interceptive effect Effects 0.000 description 7
- 238000011161 development Methods 0.000 description 6
- 238000012545 processing Methods 0.000 description 5
- 230000001419 dependent effect Effects 0.000 description 4
- 238000005538 encapsulation Methods 0.000 description 4
- 230000009471 action Effects 0.000 description 3
- 230000000007 visual effect Effects 0.000 description 3
- 238000001514 detection method Methods 0.000 description 2
- 241000282672 Ateles sp. Species 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 239000000470 constituent Substances 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
- 238000011084 recovery Methods 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
- 230000001960 triggered effect Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3624—Software debugging by performing operations on the source code, e.g. via a compiler
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3644—Software debugging by instrumenting at runtime
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3648—Software debugging using additional hardware
- G06F11/3656—Software debugging using additional hardware using a specific debug interface
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
Abstract
The application calls a JS engine to run JS codes, and when a debugging instruction sent by a second terminal is received, the debugger is called, and the debugger controls the process of the JS engine to run the JS codes based on the debugging instruction. According to the scheme disclosed by the application, the JS codes of the terminal application are not debugged by the browser, so that the debugging of the JS codes of the terminal application is not limited by a debugging platform due to the problem of adaptation of the browser, and the debugging of the JS codes of the terminal application is realized on the premise of not needing the codes of the terminal application.
Description
Technical Field
The application belongs to the technical field of computers, and particularly relates to a JS code debugging method, a JS code debugging device, a JS code debugging terminal and a JS code storage medium.
Background
JS (JavaScript) is an transliteration scripting language, and the translator of JS code is called the JS engine, which is used to interpret and execute JS code. At the beginning of the design, JS was mainly used for web application development.
Currently, JS is increasingly applied to development of terminal applications. For example, a JS code is loaded in the terminal application, and the JS code is interpreted and executed by a JS engine built in the terminal, so that a corresponding page is displayed in the terminal application, where the page may be considered as an item of the terminal application, and the page may be a static page, such as an information push page, or may be a dynamic page, such as a game page. That is, in the case that the terminal application is not updated, the terminal application has a richer function by pushing the JS code to the terminal application.
After the project is developed based on JS, the project needs to be debugged, and after the debugging is passed, the project is released. In addition, after a certain item is released, if a problem occurs in the item, the item needs to be debugged.
The current debugging process of JS codes for terminal application is as follows: and acquiring codes of the terminal application and JS codes to be debugged, debugging the codes of the terminal application by utilizing the IDE, and simultaneously debugging the JS codes by utilizing a browser (a JS debugging tool is integrated in the browser). Where IDE is an abbreviation of Integrated Development Environment, an application program for providing a program development environment, generally includes tools such as a code editor, compiler, debugger, and graphical user interface.
It can be seen that the debugging of the JS code for the terminal application at present cannot be separated from the debugging of the code for the terminal application. In some scenarios, the code of the terminal application is not easily available, so that debugging the JS code of the terminal application is very difficult at present.
Disclosure of Invention
In view of this, an object of the present application is to provide a method, an apparatus, a terminal, and a storage medium for debugging JS codes of a terminal application, so as to debug JS codes of a terminal application more conveniently and easily on the premise that no code of the terminal application is available.
In order to achieve the above purpose, the present application provides the following technical solutions:
the application provides a JS code debugging method, which is applied to a first terminal, and comprises the following steps:
running an application, wherein a debugger is arranged in the application;
obtaining a JS code, and calling a JS engine to run the JS code by the application;
receiving a debugging instruction sent by a second terminal;
and calling the debugger, and controlling the JS engine to run the JS code process by the debugger based on the debugging instruction.
Optionally, the debug instruction includes a state control instruction;
The process of controlling, by the debugger, the JS engine to run the JS code based on the debug instruction includes: and controlling the JS engine to run the state of the JS codes by the debugger based on the state control instruction.
Optionally, the debug instruction further includes an information acquisition instruction;
the process of controlling, by the debugger, the JS engine to run the JS code based on the debug instruction, further includes: controlling the JS engine to read the running information of the JS codes by the debugger based on the information acquisition instruction;
the method further comprises the steps of: and acquiring the operation information read by the JS engine, and sending the operation information to the second terminal so that the second terminal can display the operation information.
The application also provides a JS code debugging method, which is applied to the second terminal, and comprises the following steps:
receiving input operation and generating a debugging instruction;
and sending the debugging instruction to the first terminal, so that a debugger built in the application of the first terminal controls the JS engine to run the JS codes based on the debugging instruction.
Optionally, the debug instruction includes a state control instruction, where the state control instruction is configured to: triggering the debugger to control the JS engine to run the state of the JS codes.
Optionally, the debug instruction further includes an information acquisition instruction, where the information acquisition instruction is configured to: triggering the debugger to control the JS engine to read the running information of the JS codes;
the method further comprises the steps of: and displaying the operation information sent by the first terminal.
The application also provides a JS code debugging device, which is applied to a first terminal, and comprises:
the application running unit is used for running an application, and a debugger is arranged in the application;
the engine calling unit is used for obtaining JS codes, and the application calls a JS engine to operate the JS codes;
the instruction receiving unit is used for receiving a debugging instruction sent by the second terminal;
and the control unit is used for calling the debugger and controlling the JS engine to run the JS code based on the debugging instruction by the debugger.
Optionally, when the debug instruction is an information acquisition instruction, the control unit is configured to: invoking the debugger, and controlling the JS engine to read the running information of the JS codes by the debugger based on the information acquisition instruction;
the apparatus further comprises: and the operation information sending unit is used for obtaining the operation information read by the JS engine and sending the operation information to the second terminal so that the second terminal can display the operation information.
The application also provides a JS code debugging device, which is applied to a second terminal, and comprises:
the instruction generation unit is used for receiving input operation and generating a debugging instruction;
and the instruction sending unit is used for sending the debugging instruction to the first terminal so that a debugger built in the application of the first terminal controls the JS engine to run the JS codes based on the debugging instruction.
Optionally, the apparatus further includes:
an operation information receiving unit, configured to receive operation information sent by the first terminal;
and the display unit is used for displaying the operation information.
The application also provides a terminal, comprising: a processor, a memory, and a communication interface;
wherein the processor is configured to execute a program stored in the memory;
the memory is used for storing a program, and the program is used for at least: running an application, wherein a debugger is arranged in the application; obtaining a JS code, and calling a JS engine to run the JS code by the application; receiving a debugging instruction sent by a second terminal; and calling the debugger, and controlling the JS engine to run the JS code process by the debugger based on the debugging instruction.
The application also provides a terminal, comprising: a processor, a memory, an input unit and a communication interface;
Wherein the processor is configured to execute a program stored in the memory;
the memory is used for storing a program, and the program is used for at least: receiving input operation and generating a debugging instruction; and sending the debugging instruction to the first terminal, so that a debugger built in the application of the first terminal controls the JS engine to run the JS codes based on the debugging instruction.
The application also provides a storage medium, in which computer executable instructions are stored, and when the computer executable instructions are loaded and executed by a processor, the JS code debugging method is realized.
Therefore, the beneficial effects of the application are as follows:
in the scheme disclosed by the application of the first terminal, the debugger is built in the application of the first terminal, and can control the JS engine to run the JS code process of the application based on the debugging instruction, so that the debugging of the JS code of the terminal application is not dependent on a browser any more, and the debugging of the JS code of the terminal application is not limited by a debugging platform due to the problem of adaptation of the browser. In addition, the first terminal utilizes a debugger built in the application to control the JS engine to run the JS code of the application in the process of running the application by the first terminal, and realizes debugging of the JS code of the application on the premise of not needing the code of the application. Based on the above, the scheme provided by the application enables the debugging of JS codes aiming at terminal application to be more convenient and easy to use.
Drawings
In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the drawings that are required in the embodiments or the description of the prior art will be briefly described, and it is obvious that the drawings in the following description are some embodiments of the present application, and other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
Fig. 1 is a schematic diagram of a composition architecture of a JS code debug system disclosed in the present application;
FIG. 2 is a schematic diagram of another architecture of a JS code debug system disclosed in the present application;
FIG. 3 is a flow chart of one embodiment of a JS code debugging method disclosed in the present application;
FIG. 4 is a schematic diagram of the debug class and the encapsulation class of the Javascript core engine;
FIG. 5 is a schematic diagram of classes contained by the debugger disclosed herein;
fig. 6 is a schematic diagram of a VS Code plug-in a second terminal disclosed in the present application;
fig. 7-1 to 7-3 are schematic views of UI interfaces in the second terminal disclosed in the present application;
FIG. 8 is a schematic diagram of the data types contained in the core class of the debug plug-in disclosed in the present application;
FIG. 9 is a flowchart of another embodiment of a JS code debugging method disclosed in the present application;
Fig. 10 is a schematic structural diagram of a JS code debugging device disclosed in the present application;
fig. 11 is a schematic structural diagram of another JS code debugging device disclosed in the present application;
fig. 12 is a hardware configuration diagram of a terminal disclosed in the present application;
fig. 13 is a hardware configuration diagram of another terminal disclosed in the present application.
Detailed Description
The debugging of the JS code for the terminal application at present is seriously dependent on the code of the terminal application. The development of the terminal application and the development of the project in the terminal application are often cross departments and even cross companies, and the acquisition of the code of the terminal application is limited based on the consideration of the code security, which causes the code of the terminal application to be difficult to acquire. This results in great difficulty in debugging the JS code for the terminal application at present.
Moreover, the JS engines currently mainstream include the Javascript core engine under apple ecology, V8 under android ecology, and SpiderMonkey under Mozilla ecology. When the JS codes of the terminal application are debugged, a corresponding browser is needed to be used. For example, when debugging JS code using JavaScript core as an engine, the Safari browser under apple ecology must be used. However, the Safari browser can only be installed on a terminal using the iOS or macOS operating system, and thus, for the JS code using javascript core as an engine, debugging can only be performed by using the terminal of the iOS or macOS operating system, and the debugging platform is greatly limited.
Therefore, the applicant provides a method, a device, a terminal and a storage medium for debugging JS codes of a terminal application on the premise of no code of the terminal application, and the debugging of the JS codes of the terminal application is not dependent on a browser any more, so that the debugging of the JS codes of the terminal application is more convenient and easy to use.
For the purposes of making the objects, technical solutions and advantages of the embodiments of the present application more clear, the technical solutions of the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it is apparent that the described embodiments are some embodiments of the present application, but not all embodiments. All other embodiments, which can be made by one of ordinary skill in the art without undue burden from the present disclosure, are within the scope of the present disclosure.
For ease of understanding, the constituent architecture of the system to which the schemes of the present application are applied will be described first.
Referring to fig. 1, fig. 1 is a schematic diagram of a composition architecture of a JS code debug system disclosed in the present application.
As can be seen from fig. 1, the JS code debugging system includes a first terminal 100 and a second terminal 200.
Wherein, the first terminal 100 and the second terminal 200 are connected in a point-to-point manner.
In practice, a USB cable may be used to connect the first terminal 100 and the second terminal 200. In addition, if the first terminal 100 and the second terminal 200 each include a short-range communication module, the first terminal 100 and the second terminal 200 may establish a connection through the short-range communication module. For example, the first terminal 100 and the second terminal 200 establish a connection through a bluetooth module.
The first terminal 100 may be a mobile device such as a mobile phone or a tablet computer, or may be a fixed device such as a personal computer. The second terminal 200 may be a fixed device such as a personal computer, or a mobile device such as a mobile phone or a tablet computer.
The second terminal 200 is configured to receive an input operation, generate a corresponding debug instruction based on the input operation, and send the debug instruction to the first terminal 100.
The first terminal 100 installs an application, and a debugger is built in the application. The application can be shopping application, information application, communication application and video application. The debugger in the application has the following functions: and analyzing the debug instruction, and controlling the JS engine to run the JS codes based on the debug instruction.
The first terminal 100 runs the application to obtain a JS code to be debugged, the application invokes the JS engine to run the JS code, and when receiving a debug instruction sent by the second terminal 200, the first terminal 100 invokes a debugger built in the application, and the debugger controls the process of running the JS engine to run the JS code based on the debug instruction.
The debugger can control the state of the JS engine running the JS codes, such as controlling the JS engine to pause running after running the appointed JS codes, controlling the JS engine to resume running the JS codes, and controlling the JS engine to run the appointed JS codes. The debugger can also control the JS engine to read the running information of the JS codes.
In practice, the debug instruction sent by the second terminal 200 to the first terminal 100 includes a status control instruction. When receiving the state control instruction sent by the second terminal 200, the first terminal 100 controls the state of the JS engine running the JS code by the debugger built in the application based on the state control instruction.
In addition, the debug instruction transmitted from the second terminal 200 to the first terminal 100 further includes an information acquisition instruction. When receiving the information acquisition instruction sent by the second terminal 200, the first terminal 100 controls the JS engine to read the running information of the JS code by using the debugger built in the application. The first terminal 100 also acquires the operation information read by the JS engine, and transmits the operation information to the second terminal 200. The received operation information is displayed by the second terminal 200 so that the user intuitively knows the debugging process of the JS code of the terminal application.
Referring to fig. 2, fig. 2 is a schematic diagram of another composition architecture of the JS code debug system disclosed in the present application.
As can be seen from fig. 2, the JS code debugging system includes a first terminal 100, a second terminal 200, and a relay device 300.
In contrast to the JS code debugging system shown in fig. 1, the first terminal 100 and the second terminal 200 establish a connection through the relay apparatus 300, that is, the relay apparatus 300 performs data transfer between the first terminal 100 and the second terminal 200.
In implementation, the relay device 300 may be a router, or may be a server or a server cluster.
Specifically, the relay apparatus 300 receives the debug instruction transmitted from the second terminal 200, and transmits the debug instruction to the first terminal 100. In addition, the relay apparatus 300 is also configured to receive information transmitted from the first terminal 100 and transmit the information to the second terminal 200.
Note that, in the JS code debug system shown in fig. 1 and 2, after the second terminal 200 generates the debug instruction, the debug instruction needs to be encapsulated according to a predefined rule, so that the first terminal 100 can correctly understand the debug instruction. Similarly, after the first terminal 100 generates the information to be fed back to the second terminal 200, the information needs to be encapsulated according to a predefined rule so that the second terminal 200 can accurately acquire the information. For example, a Java debug protocol (JDWP) is used to encapsulate debug instructions and information, the first 4 bytes of all commands are data length, the later bytes are specific data content, and the data format is JSON.
In addition, in the scenario where the first terminal 100 and the second terminal 200 communicate through the relay device 300, after the second terminal 200 encapsulates the debug instruction according to a predefined rule, it is further required to encapsulate again according to a communication protocol between the second terminal 200 and the relay device 300; after the first terminal 100 encapsulates the information to be sent according to the predefined rule, it is further required to encapsulate the information again according to the communication protocol between the first terminal 100 and the relay device 300, so as to ensure smooth data transmission.
It can be seen that in the scheme disclosed in the application, a debugger is built in the application of the first terminal, and the debugger can control the JS engine to run the process of the JS code of the application based on the debug instruction generated by the second terminal, so that the debugging of the JS code of the terminal application is not dependent on the browser any more, and the debugging of the JS code of the terminal application is not limited by a debugging platform due to the problem of adaptation of the browser. In addition, the first terminal utilizes a debugger built in the application to control the JS engine to run the JS code of the application in the process of running the application by the first terminal, and realizes debugging of the JS code of the application on the premise of not needing the code of the application. Based on the above, the scheme provided by the application enables the debugging of JS codes aiming at terminal application to be more convenient and easy to use.
For a better understanding of the present solution, the following description is provided in connection with the system architecture shown in fig. 1.
Referring to fig. 3, fig. 3 is a flowchart of one embodiment of a JS code debugging method disclosed herein. The method comprises the following steps:
step S301: the first terminal runs the application.
Wherein the application is built with a debugger. The debugger is used for: and analyzing the debugging instruction, and controlling the JS engine to run the JS codes based on the debugging instruction.
Step S302: the first terminal obtains a JS code, and the application invokes a JS engine to run the JS code.
Step S303: and the second terminal receives the input operation and generates a debugging instruction.
As an implementation manner, the second terminal displays a UI (user interface) which displays various controls, and the user triggers the second terminal to generate a corresponding debugging instruction by clicking the controls, as shown in fig. 7-1. In addition, the second terminal may also display a JS code in the UI interface.
Step S304: and the second terminal sends a debugging instruction to the first terminal.
Step S305: the first terminal calls a debugger, and the debugger controls the JS engine to run the JS codes based on the debugging instruction. That is, the process of running the JS code by the JS engine is controlled by the debugger based on the debug instruction.
The debugging instruction generated by the second terminal comprises a state control instruction and an information acquisition instruction.
When the first terminal receives the state control instruction, step S305 is specifically that the debugger controls the JS engine to run the state of the JS code based on the state control instruction.
In practice, the state control instructions include, but are not limited to: enable, disable, setBuakPoint, removeBreakPoint, resume, i.e., performing a recovery after stopping to a breakpoint, setpOver, stepOut, and StepINto.
When the first terminal receives the information acquisition instruction, step S305 is specifically that the debugger controls the JS engine to read the running information of the JS code based on the information acquisition instruction. And then, the first terminal acquires the running information read by the JS engine and sends the running information to the second terminal. And displaying the received operation information by the second terminal.
In practice, information acquisition instructions include, but are not limited to: getProperties (get variable information). That is, the above-described operation information includes, but is not limited to, variable information.
After receiving the breakpoint setting instruction, the first terminal invokes the debugger, and the debugger controls the JS engine to pause the operation of the JS code when the JS code operates to the breakpoint. After the JS codes pause running, the first terminal sends a pause notification to the second terminal, wherein the pause notification carries stack frame information at the moment. And after receiving the pause notification, the second terminal generates a GetProperties instruction according to the stack frame information and sends the GetProperties instruction to the first terminal. And controlling the JS engine to acquire the variable information at the moment by a debugger built in the application of the first terminal based on the GetProperties instruction, and sending the variable information to the first terminal. The second terminal displays the received variable information, and in addition, the second terminal can display stack frame information, so that a user can intuitively know the debugging condition of JS codes of terminal applications. Variable information displayed by the UI interface of the second terminal is shown in fig. 7-2, and stack frame information displayed by the UI interface of the second terminal is shown in fig. 7-3.
In addition, after the JS code pauses running, a single step running instruction, that is, setpOver, stepOut and StepIn above, can be sent to the first terminal through the second terminal, so that the debugger controls the JS engine to execute the JS code according to the corresponding rule.
The debugger in the application is described in more detail below.
The debugger in the present application is implemented based on the debug class and the encapsulation class provided by the JS engine.
Take the javascript core engine as an example: the tuning class provided by the JavascriptCore engine comprises a JSC:: debugger class, the packaging class comprises an instructor:: script DebugServers class, and the principle is shown in figure 4.
The JSC is characterized in that the debug class is a debugging class, and a debugging interface provided by the debug class is mainly used for: the method comprises the steps of connecting/disconnecting (attach/detach) debugger, setting a breakpoint in JS codes, controlling the JS codes which pause running at the breakpoint through instructions such as continuous/StepOver/stepnot and the like, and returning a corresponding interface method to a subclass after the breakpoint is triggered.
The Injector:: script DebugServers class inherits from the JSC:: debugger, implements the method that the JSC:: debugger is handed to the subclass for implementation, and redistributes (dispatches) the methods in the form of registration Listener, thereby providing a more convenient and friendly interface for developers.
The debugger based on the debug class and the encapsulation class implementation provided by the JavaScript core engine mainly comprises three classes: JSDebuggerImpl class, jsdebuggerwrapier class, debugserver class. The principle of the debugger is shown in fig. 5.
Wherein:
1. the JSDebuggerImpl class inherits from both the instructor:: script debugserver class and the instructor:: script debuglister class, exposes the Attach () and the Attach () interfaces to the outside except for the rewrite method, and registers to the service (Server). The JSDebuggerImpl class maintains a JSGlobalObject object that is used to obtain sourceProvider in the sourcespersed () function of the debugger.
The JSDebuggerImpl class maintains a JSDebuggerImpl handler object through which onbreak points hit () and onException () events are notified. And the JSDebuggerImplHandler implementation class is JSDebuggerWrapper.
2. The JsDebuggerWrapper class is responsible for encapsulation and event distribution.
Specifically, the jsdebuggerwrapp class encapsulates the JSDebuggerImpl class. The JSDebuggerWrapper class realizes a JSDebuggerImplHandler interface and distributes callbacks of the interface outwards through JSDebuggerWrapperCallback. JsDebuggerWrapperCallback is created by the debugserver class.
3. The debugserver class is responsible for communicating with the second terminal.
Specifically, the debug class encapsulates the JsDebuggerWrapper class. The debug class creates a JsDebuggerWrapperCallback to obtain notifications from the JSDebuggerImpl class and perform corresponding logic processing.
The communication with the second terminal mainly comprises two aspects of operation: and firstly, receiving a debugging instruction from the second terminal. Such as a StepOver instruction, the instruction is transferred and processed through JsDebuggerWrapper- > JSDebuggerImpl- > JSC:: debugger. And secondly, receiving an event from the JSC (Java platform) such as a break point trigger event, and sending corresponding stack frame information and variable information to a second terminal for display by the debugserver.
In implementation, a Visual Studio Code plug-in may be provided in the second terminal 200, and generation of a debug instruction and display of operation information are implemented through the Visual Studio Code plug-in.
Visual Studio Code is abbreviated as VSCode and is a Code editor supporting both windows operating system, linux operating system and macOC operating system. The VS Code plug-in mainly comprises two parts: the UI interface and Debug plug-in core class JS-Debug are shown in FIG. 6.
The UI interface is provided with a plurality of controls, as shown in fig. 7-1, according to the sequence from left to right, the first control is used for generating a Continue instruction, the second control is used for generating a StepOver instruction, the third control is used for generating a stepnto instruction, the fourth control is used for generating a StepOut instruction, the fifth control is used for generating a Restart instruction, and the sixth control is used for generating a Stop instruction. When the user clicks the control, the second terminal generates a corresponding debugging instruction and sends the corresponding debugging instruction to the first terminal.
After the second terminal sends a StepOver instruction, a StepDito instruction and a StepOut instruction each time, the JS engine of the first terminal pauses after executing the corresponding JS codes, and sends a pause notification carrying stack frame information at the moment to the second terminal, and after receiving the pause notification, the second terminal generates a GetProperties instruction according to the stack frame information carried by the pause notification and sends the GetProperties instruction to the first terminal, so that the first terminal feeds back variable information at the moment.
For example, the user clicks a second control on the UI interface, and the second terminal generates a corresponding StepOver instruction and sends the instruction to the first terminal. The debugger built in the application of the first terminal controls the JS engine to execute a certain line of JS codes, and then stops at the next line. At this time, the debugger sends a pause notification to the second terminal, the pause notification being used to indicate that the JS engine has paused running JS code, and the pause notification also carrying stack frame information (frame) at this point. And after receiving the pause notification, the second terminal generates a GetProperties instruction according to the received stack frame information and sends the GetProperties instruction to the first terminal. And a debugger built in the application of the first terminal controls the JS engine to acquire the variable information at the moment based on the GetProperties instruction, and sends the variable information to the first terminal.
In addition, the UI interface may further display a code line number, when the user clicks the code line number, the second terminal generates a breakpoint setting instruction and sends the breakpoint setting instruction to the first terminal, where the position of the breakpoint is the clicked code line number, and when the user clicks the code line number again, the second terminal generates a breakpoint removing instruction and sends the breakpoint removing instruction to the first terminal.
The core class JS-Debug of the debugging plug-in mainly follows the DAP (Debug Adapter Protocol, debugging adaptation protocol) to develop and realize, and can support two debugging modes of Launch and Attach. The core class JS-Debug of the Debug plug-in mainly defines three data types: protocolMessage, arguments and Model, as shown in fig. 8.
Protocol message defines a Request-Response (Request-Response) architecture for implementing two functions: firstly, what data is needed by the UI interface, a specific debugging Request is sent to the JS-Debug, and parameters are attached; secondly, after receiving the Request, the JS-Debug acquires corresponding data from the first terminal, returns Response and replies to the UI interface for display.
The parameters represent parameter types, and different debug Request requests require different parameter entries, collectively named "XXXARGues".
The Model is a package of the debug Model provided by the VS Code, and belongs to custom data, such as: stack frame, breakPoint break point, variable.
Two debug modes, namely, mount and Attach, are described here:
the Launch mode is an active mode. And the second terminal sends the JS code to be debugged to the first terminal. The debugging mode is mainly suitable for debugging the JS codes of the terminal application in the development stage.
The Attach mode is a passive mode. And the first terminal sends the JS code to be debugged to the second terminal. The debugging mode is mainly suitable for fault detection of the JS codes of the terminal application, namely, after the JS codes of the terminal application are released, when the JS codes are found to be problematic, the JS codes are debugged for the purpose of locating faults and carrying out fault detection.
In order to facilitate understanding of the solution disclosed in the present application, the following description is presented in connection with an application scenario to which the present application is applicable.
Referring to fig. 9, fig. 9 shows a flowchart of the JS code debugging method disclosed in the present application in an application scenario. Wherein the first terminal 100 and the second terminal 200 are connected through a USB cable.
Step S901: the second terminal obtains a JS code to be debugged. The JS code is used for displaying a game page in an interface of a first application, wherein the first application is a communication application such as a mobile phone QQ.
Step S902: and the second terminal sends the JS code to be debugged to the first terminal. The first terminal is provided with a first application, and a debugger is built in the first application.
Step S903: and the interactive interface of the second terminal receives a first input operation of a user and generates an enable instruction.
Step S904: the second terminal sends an enable instruction to the first terminal.
Step S905: and the first terminal responds to the enabling instruction, operates the first application, and invokes the JS engine to operate the JS codes by the first application.
Step S906: and the interactive interface of the second terminal receives a second input operation of the user and generates a SetBuakPoint instruction. The setb reakpoint instruction contains a breakpoint location, which is the code line number of the JS code.
The interactive interface of the second terminal can display a plurality of controls, and the interactive operation of the interactive interface is the operation of clicking the controls. And when the user clicks the control of the interactive interface, the second terminal generates a corresponding debugging instruction.
Step S907: the second terminal sends a SetPreakPoint instruction to the first terminal.
Step S908: and a debugger built in a first application of the first terminal controls the JS engine based on the SetBReakPoint instruction, and the running is suspended when the JS code is run to the breakpoint position.
Step S909: the first terminal sends a pause notification to the second terminal, the pause notification carrying stack frame information at the moment.
Step S910: and the second terminal generates a GetProperties instruction based on stack frame information carried by the pause notification.
Step S911: and the second terminal sends a GetProperties instruction to the first terminal.
Step S912: the debugger controls the JS engine to read the current variable information based on the GetProperties instruction.
Step S913: the first terminal transmits variable information to the second terminal.
Step S914: and displaying stack frame information and variable information on an interactive interface of the second terminal.
Then, the user may perform an operation at the second terminal, so that the second terminal generates a content instruction, and sends the content instruction to the first terminal. And controlling the JS engine to resume the operation of the JS codes by a debugger built in a first application of the first terminal based on the Continue instruction.
On the other hand, the application also provides a JS code debugging device, which is applied to the first terminal. Referring to fig. 10, fig. 10 is a schematic structural diagram of a JS code debugging device disclosed in the present application. The device comprises:
an application running unit 101 for running an application having a debugger built therein;
The engine calling unit 102 is configured to obtain a JS code, and call the JS engine to run the JS code by the application;
an instruction receiving unit 103, configured to receive a debug instruction sent by the second terminal;
and the control unit 104 is used for calling the debugger and controlling the JS engine to run the JS codes based on the debugging instruction by the debugger.
Optionally, when the debug instruction is a state control instruction, the control unit 104 is configured to: and calling a debugger, and controlling the state of the JS engine running JS codes by the debugger based on the state control instruction.
Optionally, when the debug instruction is an information acquisition instruction, the control unit 104 is configured to: and calling a debugger, and controlling the JS engine to read the running information of the JS codes by the debugger based on the information acquisition instruction. Correspondingly, the device also comprises: and the running information sending unit is used for acquiring the running information read by the JS engine and sending the running information to the second terminal so that the second terminal can display the running information.
On the other hand, the application also provides a JS code debugging device, which is applied to the second terminal. Referring to fig. 11, fig. 11 is a schematic structural diagram of a JS code debugging device disclosed in the present application. The device comprises:
An instruction generation unit 201 for receiving an input operation, generating a debug instruction;
the instruction sending unit 202 is configured to send the debug instruction to the first terminal, so that a debugger built in an application of the first terminal controls a process of running the JS code by the JS engine based on the debug instruction.
Optionally, the apparatus further comprises: an operation information receiving unit, configured to receive operation information sent by a first terminal; and a display unit for displaying the operation information.
On the other hand, the present application also provides a first terminal, whose hardware structure is shown in fig. 12, where the first terminal 100 may include a processor 1201, a memory 1202, and a communication interface 1203.
Optionally, the first terminal 100 may further comprise an input unit 1204, a display 1205, and a communication bus 1206.
The processor 1201, the memory 1202, the communication interface 1203, the input unit 1204, the display 1205, and the like all perform communication with each other through the communication bus 1206.
In the present embodiment, the processor 1201 may be a central processing unit (Central Processing Unit, CPU), an asic, a dsp, an off-the-shelf programmable gate array, or other programmable logic device.
The processor 1201 may call a program stored in the memory 1202.
The memory 1202 is configured to store one or more programs, and the programs may include program code that includes computer operation instructions, and in the embodiment of the present application, at least the programs for implementing the following functions are stored in the memory 1202:
running an application, wherein a debugger is arranged in the application; obtaining a JS code, and calling a JS engine to run the JS code by the application; receiving a debugging instruction sent by a second terminal; and calling a debugger, and controlling the JS engine to run the JS codes by the debugger based on the debugging instruction.
In one possible implementation, the memory 1202 may include a storage program area and a storage data area, wherein the storage program area may store an operating system, and at least one application program required for a function (such as an image playing function, etc.), and the like; the storage data area may store data created during use of the computer, such as user data, image data, and the like.
In addition, memory 1202 may include high-speed random access memory, and may also include non-volatile memory, such as at least one magnetic disk storage device or other volatile solid-state storage device.
The communication interface 1203 may be an interface of a communication module, such as an interface of a bluetooth module, a USB interface, an interface of a GSM module.
Of course, the structure of the first terminal shown in fig. 12 is not limited to the first terminal in the embodiment of the present application, and the first terminal may include more or fewer components than shown in fig. 12, or may combine some components in practical applications.
On the other hand, the present application also provides a second terminal, whose hardware structure is shown in fig. 13, where the second terminal 200 may include a processor 1301, a memory 1302, a communication interface 1303, and an input unit 1304.
Optionally, the second terminal 200 may also include a display 1305 and a communication bus 1306.
The processor 1301, the memory 1302, the communication interface 1303, the input unit 1304, the display 1305, and the like all perform communication with each other through the communication bus 1306.
In the present embodiment, the processor 1301 may be a central processing unit (Central Processing Unit, CPU), an asic, a dsp, an off-the-shelf programmable gate array, or other programmable logic device.
The processor 1301 may call a program stored in the memory 1302.
The memory 1302 is used to store one or more programs, and the programs may include program codes including computer operation instructions, and in this embodiment, at least the programs for implementing the following functions are stored in the memory 1302:
receiving input operation and generating a debugging instruction; and sending the debugging instruction to the first terminal, so that a debugger built in the application of the first terminal controls the JS engine to run the JS codes based on the debugging instruction.
In one possible implementation, the memory 1302 may include a storage program area and a storage data area, where the storage program area may store an operating system, and at least one application program required for a function (such as an image playing function, etc.), and so on; the storage data area may store data created during use of the computer, such as user data, image data, and the like.
In addition, memory 1302 may include high-speed random access memory, and may also include non-volatile memory, such as at least one magnetic disk storage device or other volatile solid-state storage device.
The communication interface 1303 may be an interface of a communication module, such as an interface of a bluetooth module, a USB interface, or an interface of a GSM module.
Of course, the structure of the second terminal shown in fig. 13 is not limited to the second terminal in the embodiment of the present application, and the second terminal may include more or fewer components than shown in fig. 13 or may combine some components in practical applications.
On the other hand, the application further provides a storage medium, in which computer executable instructions are stored, wherein when the computer executable instructions are loaded and executed by the processor, the JS code debugging method described in any one of the above embodiments is implemented.
Finally, it is further noted that relational terms such as first and second, and the like are used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Moreover, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element.
In the present specification, each embodiment is described in a progressive manner, and each embodiment is mainly described in a different point from other embodiments, and identical and similar parts between the embodiments are all enough to refer to each other. For the system disclosed in the embodiment, since it corresponds to the method disclosed in the embodiment, the description is relatively simple, and the relevant points refer to the description of the method section.
The previous description of the disclosed embodiments is provided to enable any person skilled in the art to make or use the present application. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the generic principles defined herein may be applied to other embodiments without departing from the spirit or scope of the application. Thus, the present application is not intended to be limited to the embodiments shown herein but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.
Claims (13)
1. The JS code debugging method is characterized by being applied to a first terminal, and comprises the following steps:
running an application, wherein a debugger is arranged in the application; the Debugger is realized based on a JSC:: debuger class and an instructor:: script debugServer class in a JavascriptCore engine; the debugger comprises a JSDebuggerImpl class, a JSDebuggerWrapper class and a debugserver class;
The JSDUggerImpl class inherits from both the Injector:: script DebugServers class and the Injector:: script DebugListener class; the JSDUyggerImpl class is used for maintaining JSDUyggerImplHandler;
the JsDebuggerWrapper class is used for packaging the JSDebuggerImpl class and realizing JSDebuggerImplHandler, JSDebuggerImplHandler for notifying OnBreakpointHit and OnException events;
the debug server class is used for packaging the JsDebuggerWrapper class and creating JsDebuggerWrapperCallback; jsDebuggerWrapperCallback is used to distribute callbacks of JSDebuggerImplHandler outwards;
obtaining a JS code, and calling a JS engine to run the JS code by the application; the JS engine is a JavaScript core engine;
receiving a debugging instruction sent by a second terminal through a debug server class, and transmitting the debugging instruction to a JSC through a JSDebuggerWrapper class and a JSDebuggerImpl class in sequence;
and calling the debugger, and controlling the JS engine to run the JS code process by the debugger based on the debugging instruction.
2. The method of claim 1, wherein the debug instructions comprise state control instructions;
the process of controlling, by the debugger, the JS engine to run the JS code based on the debug instruction includes: and controlling the JS engine to run the state of the JS codes by the debugger based on the state control instruction.
3. The method of claim 1, wherein the debug instructions further comprise information acquisition instructions;
the process of controlling, by the debugger, the JS engine to run the JS code based on the debug instruction, further includes: controlling the JS engine to read the running information of the JS codes by the debugger based on the information acquisition instruction;
the method further comprises the steps of: and acquiring the operation information read by the JS engine, and sending the operation information to the second terminal so that the second terminal can display the operation information.
4. A JS code debugging method, wherein the method is applied to a second terminal, the method comprising:
receiving input operation and generating a debugging instruction;
the debugging instruction is sent to a first terminal, so that a Debugger built in an application of the first terminal receives the debugging instruction through a debug server class, and the debugging instruction is sequentially transmitted to a JSC through a JSDebuggerWrapper class and a JSDebuggerImpl class; the JS engine is a JavaScript core engine;
the Debugger is realized based on a JSC:: debuger class and an instructor:: script debugServer class in a JavascriptCore engine; the debugger comprises a JSDebuggerImpl class, a JSDebuggerWrapper class and a debugserver class;
The JSDUggerImpl class inherits from both the Injector:: script DebugServers class and the Injector:: script DebugListener class; the JSDUyggerImpl class is used for maintaining JSDUyggerImplHandler;
the JsDebuggerWrapper class is used for packaging the JSDebuggerImpl class and realizing JSDebuggerImplHandler, JSDebuggerImplHandler for notifying OnBreakpointHit and OnException events;
the debug server class is used for packaging the JsDebuggerWrapper class and creating JsDebuggerWrapperCallback; jsDebuggerWrapperCallback is used to dispatch callbacks of jsdebuggerimphandler outwards.
5. The method of claim 4, wherein the debug instructions comprise state control instructions to: triggering the debugger to control the JS engine to run the state of the JS codes.
6. The method of claim 5, wherein the debug instructions further comprise information acquisition instructions to: triggering the debugger to control the JS engine to read the running information of the JS codes;
the method further comprises the steps of: and displaying the operation information sent by the first terminal.
7. A JS code debugging device, characterized in that it is applied to a first terminal, said device comprising:
The application running unit is used for running an application, and a debugger is arranged in the application; the Debugger is realized based on a JSC:: debuger class and an instructor:: script debugServer class in a JavascriptCore engine; the debugger comprises a JSDebuggerImpl class, a JSDebuggerWrapper class and a debugserver class;
the JSDUggerImpl class inherits from both the Injector:: script DebugServers class and the Injector:: script DebugListener class; the JSDUyggerImpl class is used for maintaining JSDUyggerImplHandler;
the JsDebuggerWrapper class is used for packaging the JSDebuggerImpl class and realizing JSDebuggerImplHandler, JSDebuggerImplHandler for notifying OnBreakpointHit and OnException events;
the debug server class is used for packaging the JsDebuggerWrapper class and creating JsDebuggerWrapperCallback; jsDebuggerWrapperCallback is used to distribute callbacks of JSDebuggerImplHandler outwards;
the engine calling unit is used for obtaining JS codes, and the application calls a JS engine to operate the JS codes; the JS engine is a JavaScript core engine;
the instruction receiving unit is used for receiving a debugging instruction sent by the second terminal through a debug server class and transmitting the debugging instruction to the JSC through a JSDebuggerWrapper class and a JSDebuggerImpl class in sequence;
And the control unit is used for calling the debugger and controlling the JS engine to run the JS code based on the debugging instruction by the debugger.
8. The apparatus of claim 7, wherein when the debug instruction is an information acquisition instruction, the control unit is to: invoking the debugger, and controlling the JS engine to read the running information of the JS codes by the debugger based on the information acquisition instruction;
the apparatus further comprises: and the operation information sending unit is used for obtaining the operation information read by the JS engine and sending the operation information to the second terminal so that the second terminal can display the operation information.
9. A JS code debugging device, characterized in that it is applied to a second terminal, said device comprising:
the instruction generation unit is used for receiving input operation and generating a debugging instruction;
the instruction sending unit is used for sending the debugging instruction to the first terminal, so that a Debugger built in the application of the first terminal receives the debugging instruction through a debug server class, and the debugging instruction is sequentially transmitted to the JSC through a JSDebuggerWrapper class and a JSDebuggerImpl class, wherein the debug class controls the JS engine to run JS codes based on the debugging instruction; the JS engine is a JavaScript core engine;
The Debugger is realized based on a JSC:: debuger class and an instructor:: script debugServer class in a JavascriptCore engine; the debugger comprises a JSDebuggerImpl class, a JSDebuggerWrapper class and a debugserver class;
the JSDUggerImpl class inherits from both the Injector:: script DebugServers class and the Injector:: script DebugListener class; the JSDUyggerImpl class is used for maintaining JSDUyggerImplHandler;
the JsDebuggerWrapper class is used for packaging the JSDebuggerImpl class and realizing JSDebuggerImplHandler, JSDebuggerImplHandler for notifying OnBreakpointHit and OnException events;
the debug server class is used for packaging the JsDebuggerWrapper class and creating JsDebuggerWrapperCallback; jsDebuggerWrapperCallback is used to dispatch callbacks of jsdebuggerimphandler outwards.
10. The apparatus of claim 9, wherein the apparatus further comprises:
an operation information receiving unit, configured to receive operation information sent by the first terminal;
and the display unit is used for displaying the operation information.
11. A terminal, comprising: a processor, a memory, and a communication interface;
wherein the processor is configured to execute a program stored in the memory;
The memory is used for storing a program, and the program is used for at least:
running an application, wherein a debugger is arranged in the application; the Debugger is realized based on a JSC:: debuger class and an instructor:: script debugServer class in a JavascriptCore engine; the debugger comprises a JSDebuggerImpl class, a JSDebuggerWrapper class and a debugserver class;
the JSDUggerImpl class inherits from both the Injector:: script DebugServers class and the Injector:: script DebugListener class; the JSDUyggerImpl class is used for maintaining JSDUyggerImplHandler;
the JsDebuggerWrapper class is used for packaging the JSDebuggerImpl class and realizing JSDebuggerImplHandler, JSDebuggerImplHandler for notifying OnBreakpointHit and OnException events;
the debug server class is used for packaging the JsDebuggerWrapper class and creating JsDebuggerWrapperCallback; jsDebuggerWrapperCallback is used to distribute callbacks of JSDebuggerImplHandler outwards;
obtaining a JS code, and calling a JS engine to run the JS code by the application; the JS engine is a JavaScript core engine;
receiving a debugging instruction sent by a second terminal through a debug server class, and transmitting the debugging instruction to a JSC through a JSDebuggerWrapper class and a JSDebuggerImpl class in sequence;
And calling the debugger, and controlling the JS engine to run the JS code process by the debugger based on the debugging instruction.
12. A terminal, comprising: a processor, a memory, an input unit and a communication interface;
wherein the processor is configured to execute a program stored in the memory;
the memory is used for storing a program, and the program is used for at least: receiving input operation and generating a debugging instruction; the debugging instruction is sent to a first terminal, so that a Debugger built in an application of the first terminal receives the debugging instruction through a debug server class, and the debugging instruction is sequentially transmitted to a JSC through a JSDebuggerWrapper class and a JSDebuggerImpl class; the JS engine is a JavaScript core engine;
the Debugger is realized based on a JSC:: debuger class and an instructor:: script debugServer class in a JavascriptCore engine; the debugger comprises a JSDebuggerImpl class, a JSDebuggerWrapper class and a debugserver class;
the JSDUggerImpl class inherits from both the Injector:: script DebugServers class and the Injector:: script DebugListener class; the JSDUyggerImpl class is used for maintaining JSDUyggerImplHandler;
The JsDebuggerWrapper class is used for packaging the JSDebuggerImpl class and realizing JSDebuggerImplHandler, JSDebuggerImplHandler for notifying OnBreakpointHit and OnException events;
the debug server class is used for packaging the JsDebuggerWrapper class and creating JsDebuggerWrapperCallback; jsDebuggerWrapperCallback is used to dispatch callbacks of jsdebuggerimphandler outwards.
13. A storage medium having stored therein computer-executable instructions that, when loaded and executed by a processor, implement the JS code debugging method of any one of claims 1-3, or implement the JS code debugging method of any one of claims 4-6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910621773.4A CN112214392B (en) | 2019-07-10 | 2019-07-10 | JS code debugging method, device, terminal and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910621773.4A CN112214392B (en) | 2019-07-10 | 2019-07-10 | JS code debugging method, device, terminal and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112214392A CN112214392A (en) | 2021-01-12 |
| CN112214392B true CN112214392B (en) | 2024-01-30 |
Family
ID=74048502
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910621773.4A Active CN112214392B (en) | 2019-07-10 | 2019-07-10 | JS code debugging method, device, terminal and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112214392B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114625660A (en) * | 2022-03-22 | 2022-06-14 | 阿里巴巴（中国）有限公司 | Debugging method and device |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105847325A (en) * | 2016-03-14 | 2016-08-10 | 广州酷狗计算机科技有限公司 | Method and device for debugging application client side |
| CN108920205A (en) * | 2018-06-11 | 2018-11-30 | Oppo（重庆）智能科技有限公司 | A kind of control method, device and computer storage medium |
| CN109669876A (en) * | 2018-12-30 | 2019-04-23 | 艾普阳科技（深圳）有限公司 | A kind of debugging control program and system of javascript code |
-
2019
- 2019-07-10 CN CN201910621773.4A patent/CN112214392B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105847325A (en) * | 2016-03-14 | 2016-08-10 | 广州酷狗计算机科技有限公司 | Method and device for debugging application client side |
| CN108920205A (en) * | 2018-06-11 | 2018-11-30 | Oppo（重庆）智能科技有限公司 | A kind of control method, device and computer storage medium |
| CN109669876A (en) * | 2018-12-30 | 2019-04-23 | 艾普阳科技（深圳）有限公司 | A kind of debugging control program and system of javascript code |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112214392A (en) | 2021-01-12 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109800173B (en) | Program debugging method, device and storage medium | |
| CN111176626B (en) | Cross-programming-language code calling method and device, medium and equipment | |
| CN103309660B (en) | Mobile solution cross-platform development method | |
| CN111158818A (en) | Page rendering method and device | |
| US8756577B2 (en) | Collaborative software debugging in a distributed system with private debug sessions | |
| CN107688529B (en) | Component debugging method and device | |
| US8910190B2 (en) | Analytics data collection with low integration cost for dynamic message passing systems | |
| CN107391219B (en) | Function Compilation Method and device | |
| CN111338623B (en) | Method, device, medium and electronic equipment for developing user interface | |
| US9009673B2 (en) | Collaborative software debugging in a distributed system with collaborative step over operation | |
| CN104536890A (en) | Testing system, method and device | |
| CN108628739A (en) | A kind of method that Lua scripts are debugged, client, server and debugger | |
| CN103577568A (en) | Cross-platform mobile safety comprehensive information aggregation system and method adopting same | |
| CN105743955B (en) | A kind of extension JavaScript object method | |
| CN111857658A (en) | Method, device, medium and electronic equipment for rendering dynamic component | |
| CN111159039A (en) | Service simulation method, system, device and storage medium | |
| CN114168460A (en) | Remote debugging method, device and storage medium for front-end code in hybrid development | |
| US20150212930A1 (en) | Application test system, application test method and storage medium | |
| CN112463618B (en) | Automatic test method, device, medium and equipment | |
| KR20140021090A (en) | An interface for interworking with javascripts in hybrid web applications | |
| CN111666199B (en) | Debugging method executed on intelligent terminal and software debugger | |
| CN112214392B (en) | JS code debugging method, device, terminal and storage medium | |
| CN106557411B (en) | Method and system for testing Hybrid application in Android system | |
| CN113971257A (en) | Function menu access method and device for hybrid application | |
| CN113760736A (en) | Test method, device and system |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |