Small program debugging method and device, electronic equipment, readable medium and program product

Abstract

The embodiment of the invention discloses an applet debugging method and device, electronic equipment, a readable medium and a program product. A specific embodiment of the method comprises the following steps: acquiring an applet package file corresponding to a target applet according to jump information corresponding to the target applet; and through a target application corresponding to the target applet, performing analysis processing on the applet compressed package file to obtain applet page information. And generating applet debugging page information according to the applet page information. And displaying the applet debugging page corresponding to the applet debugging page information for debugging. The implementation mode is related to a computer, a full-link real operation environment can be provided, and therefore the small program debugging efficiency is improved.

Description

Technical Field

[0001] Embodiments of the present disclosure relate to the field of computer technology, and in particular to a method, device, electronic device, readable medium, and program product for debugging an applet. Background Art

[0002] Mini Programs are applications that can be used without downloading and installing. Users can open the application by scanning or searching. When developing Mini Programs, it is often necessary to debug the Mini Programs. Currently, the commonly used method for debugging Mini Programs is to simulate debugging the Mini Programs through developer tools.

[0003] However, the inventors have found that when the above method is used to debug a mini program, the following technical problems often occur:

[0004] When simulating and debugging a mini program through developer tools, a large amount of system resources are consumed to simulate the operating environment, and there is a gap between the simulated operating environment and the actual operating environment of the mini program, resulting in poor mini program debugging efficiency.

[0005] The above information disclosed in this Background section is only for enhancement of understanding of the background of the inventive concept and therefore it may contain information that does not form the prior art that is already known in this country to a person of ordinary skill in the art. Summary of the invention

[0006] The content of this disclosure is used to introduce concepts in a brief form, which will be described in detail in the detailed implementation section below. The content of this disclosure is not intended to identify the key features or essential features of the technical solution claimed for protection, nor is it intended to limit the scope of the technical solution claimed for protection.

[0007] Some embodiments of the present disclosure propose applet debugging methods, devices, electronic devices, computer-readable media, and computer program products to solve one or more of the technical problems mentioned in the above background technology section.

[0008] In the first aspect, some embodiments of the present disclosure provide a mini-program debugging method, the method comprising: obtaining a mini-program compressed package file corresponding to the target mini-program based on the jump information of the target mini-program; parsing the mini-program compressed package file through the target application corresponding to the target mini-program to obtain mini-program page information; generating mini-program debugging page information based on the mini-program page information; and displaying the mini-program debugging page corresponding to the mini-program debugging page information for debugging.

[0009] Optionally, before obtaining the mini-program compressed package file corresponding to the target mini-program according to the jump information corresponding to the target mini-program, the method further includes: generating the jump information corresponding to the target mini-program according to the identification information corresponding to the target mini-program.

[0010] Optionally, before generating the jump information corresponding to the target applet according to the identification information corresponding to the target applet, the method further includes: in response to detecting a debugging start operation, obtaining applet information corresponding to the target applet; decompressing the applet information to obtain a source file; constructing a compressed package file corresponding to the target applet according to the source file; packaging the compressed package file to obtain a applet compressed package file; and sending the applet compressed package file to a server corresponding to the target applet.

[0011] Optionally, the above-mentioned generating jump information corresponding to the target mini-program according to the identification information corresponding to the target mini-program includes: generating jump protocol information according to a preset jump protocol template and the identification information corresponding to the target mini-program; determining the jump protocol information as the jump information corresponding to the target mini-program.

[0012] Optionally, the above-mentioned mini-program compressed package file is parsed and processed by the target application corresponding to the above-mentioned target mini-program to obtain the mini-program page information, including: according to the identification information of the above-mentioned target mini-program, the application corresponding to the above-mentioned mini-program compressed package file is determined as the target application; according to the mini-program engine container corresponding to the above-mentioned target application, the mini-program compressed package file is parsed and processed to obtain the mini-program page information.

[0013] Optionally, before generating the mini-program debugging page information according to the mini-program page information, the method further includes: displaying the mini-program page corresponding to the mini-program page information through the target application.

[0014] Optionally, the above-mentioned mini-program page information includes page element hierarchy information, element style layout information and code breakpoint information.

[0015] Optionally, the mini-program debugging page information is generated based on the mini-program page information, including: filling the page element hierarchy information, the element style layout information and the code breakpoint information into a preset debugging template respectively to generate the mini-program debugging page information.

[0016] In the second aspect, some embodiments of the present disclosure provide a mini-program debugging device, which includes: an acquisition unit, configured to acquire a mini-program compressed package file corresponding to the target mini-program according to the jump information of the target mini-program; a parsing unit, configured to parse the mini-program compressed package file through a target application corresponding to the target mini-program to obtain mini-program page information; a generation unit, configured to generate mini-program debugging page information according to the mini-program page information; and a display unit, configured to display the mini-program debugging page corresponding to the mini-program debugging page information for debugging.

[0017] Optionally, the mini-program debugging device further includes a first generating unit, and the first generating unit is configured to generate jump information corresponding to the target mini-program according to identification information corresponding to the target mini-program.

[0018] Optionally, the mini-program debugging device further includes a sending unit, which is configured to obtain mini-program information corresponding to the target mini-program in response to detecting a debugging start operation; decompress the mini-program information to obtain a source file; construct a compressed package file corresponding to the target mini-program based on the source file; package the compressed package file to obtain a mini-program compressed package file; and send the mini-program compressed package file to a server corresponding to the target mini-program.

[0019] Optionally, the first generating unit is further configured to: generate jump protocol information according to a preset jump protocol template and identification information corresponding to the target applet; and determine the jump protocol information as jump information corresponding to the target applet.

[0020] Optionally, the parsing unit is further configured to: determine the application corresponding to the mini-program compressed package file as the target application according to the identification information of the target mini-program; and parse the mini-program compressed package file according to the mini-program engine container corresponding to the target application to obtain the mini-program page information.

[0021] Optionally, the mini-program debugging device further includes a first display unit, and the first display unit is configured to: display the mini-program page corresponding to the mini-program page information through the target application.

[0022] Optionally, the generation unit is further configured to: fill the page element hierarchy information, the element style layout information and the code breakpoint information into a preset debugging template respectively to generate mini-program debugging page information.

[0023] In a third aspect, some embodiments of the present disclosure provide an electronic device comprising: one or more processors; a storage device on which one or more programs are stored, and when the one or more programs are executed by the one or more processors, the one or more processors implement the method described in any implementation manner of the above-mentioned first aspect.

[0024] In a fourth aspect, some embodiments of the present disclosure provide a computer-readable medium having a computer program stored thereon, wherein when the program is executed by a processor, the method described in any implementation manner of the above-mentioned first aspect is implemented.

[0025] In a fifth aspect, some embodiments of the present disclosure provide a computer program product, including a computer program, which implements the method described in any implementation manner of the above-mentioned first aspect when executed by a processor.

[0026] The above-mentioned embodiments of the present disclosure have the following beneficial effects: the mini-program debugging method of some embodiments of the present disclosure can provide a full-link real operating environment, thereby improving the mini-program debugging efficiency. Specifically, the reason for the low mini-program debugging efficiency is that when the mini-program is simulated and debugged through the developer tool, a large amount of system resources need to be consumed to simulate the operating environment, and there is a gap between the simulated operating environment and the real operating environment of the mini-program. Based on this, the mini-program debugging method of some embodiments of the present disclosure, first, according to the jump information of the corresponding target mini-program, obtains the mini-program compressed package file corresponding to the above-mentioned target mini-program. Thus, the compressed package file of the target mini-program can be obtained through the jump information of the target mini-program, without scanning the code, solving the technical problem that the code cannot be scanned in the simulator. Secondly, through the target application corresponding to the above-mentioned target mini-program, the above-mentioned mini-program compressed package file is parsed and processed to obtain the mini-program page information. Thus, the above-mentioned target mini-program can be opened through the target application, and the mini-program can be run in the real application environment, thereby realizing the link opening. Then, according to the above-mentioned mini-program page information, the mini-program debugging page information is generated. Thus, the information of the page to be debugged by the user can be obtained for subsequent display. Finally, the mini-program debugging page corresponding to the mini-program debugging page information is displayed for debugging. Thus, the user can view the mini-program page information and debug the mini-program page information on the displayed mini-program debugging page. Also, because the mini-program compressed package file can be parsed by the target application to obtain the mini-program page information, and the mini-program debugging page is displayed according to the mini-program page information for debugging, the mini-program can be debugged in the real operating environment, thereby improving the mini-program debugging efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

[0027] The above and other features, advantages and aspects of the embodiments of the present disclosure will become more apparent with reference to the following detailed description in conjunction with the accompanying drawings. Throughout the accompanying drawings, the same or similar reference numerals represent the same or similar elements. It should be understood that the drawings are schematic and that components and elements are not necessarily drawn to scale.

[0028] Figure 1 is a schematic diagram of an application scenario of a small program debugging method according to some embodiments of the present disclosure;

[0029] Figure 2 is a flowchart of some embodiments of the mini-program debugging method according to the present disclosure;

[0030] Figure 3 are flowcharts of other embodiments of the mini-program debugging method according to the present disclosure;

[0031] Figure 4 is a schematic diagram of the structure of some embodiments of the mini-program debugging device according to the present disclosure;

[0032] Figure 5 It is a schematic diagram of the structure of an electronic device suitable for implementing some embodiments of the present disclosure. DETAILED DESCRIPTION

[0033] Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although certain embodiments of the present disclosure are shown in the accompanying drawings, it should be understood that the present disclosure can be implemented in various forms and should not be construed as being limited to the embodiments set forth herein. On the contrary, these embodiments are provided to provide a more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are only for exemplary purposes and are not intended to limit the scope of protection of the present disclosure.

[0034] It should also be noted that, for ease of description, only the parts related to the invention are shown in the drawings. In the absence of conflict, the embodiments and features in the embodiments of the present disclosure can be combined with each other.

[0035] It should be noted that the concepts such as "first" and "second" mentioned in the present disclosure are only used to distinguish different devices, modules or units, and are not used to limit the order or interdependence of the functions performed by these devices, modules or units.

[0036] It should be noted that the modifications of "one" and "plurality" mentioned in the present disclosure are illustrative rather than restrictive, and those skilled in the art should understand that unless otherwise clearly indicated in the context, it should be understood as "one or more".

[0037] The names of the messages or information exchanged between multiple devices in the embodiments of the present disclosure are only used for illustrative purposes and are not used to limit the scope of these messages or information.

[0038] The present disclosure will be described in detail below with reference to the accompanying drawings and in conjunction with embodiments.

[0039] Figure 1 It is a schematic diagram of an application scenario of the mini-program debugging method of some embodiments of the present disclosure.

[0040] exist Figure 1 In the application scenario, first, the computing device 101 can obtain the applet compression package file 103 corresponding to the target applet according to the jump information 102 of the corresponding target applet. For example, the jump information 102 can be "https:xxxx.html". The applet compression package file 103 can be an application package. Secondly, the computing device 101 can parse the applet compression package file 103 through the target application corresponding to the target applet to obtain the applet page information 104. Then, the computing device 101 can generate the applet debugging page information 105 according to the applet page information 104. Finally, the computing device 101 can display the applet debugging page 106 corresponding to the applet debugging page information 105 for debugging. For example, the applet debugging page 106 can include the applet page 1031 and the debugging page 1062.

[0041] It should be noted that the computing device 101 can be hardware or software. When the computing device is hardware, it can be implemented as a distributed cluster consisting of multiple servers or terminal devices, or as a single server or a single terminal device. When the computing device is embodied as software, it can be installed in the hardware devices listed above. It can be implemented as multiple software or software modules for providing distributed services, or as a single software or software module. No specific limitation is made here.

[0042] It should be understood that Figure 1 The number of computing devices in the embodiment is only illustrative. Any number of computing devices may be provided according to implementation requirements.

[0043] Continue to refer Figure 2 , shows a process 200 of some embodiments of the mini-program debugging method according to the present disclosure. The mini-program debugging method includes the following steps:

[0044] Step 201, obtaining the mini-program compressed package file corresponding to the target mini-program according to the jump information of the target mini-program.

[0045] In some embodiments, the execution body of the applet debugging method (eg Figure 1 The computing device shown in the figure) can obtain the applet compressed package file corresponding to the target applet according to the jump information of the corresponding target applet. Among them, the target applet can be the applet to be debugged. The jump information can be information for obtaining the compressed package of the target applet. For example, the jump information can be a pre-stored jump protocol link. The applet compressed package file can be the application package of the target applet. For example, the applet compressed package file can be APK (Android application package). In practice, first, the execution subject can determine the identifier representing the target applet in the jump information of the corresponding target applet. Then, the application package with the same corresponding identifier as the identifier of the target applet can be obtained as the applet compressed package file. Specifically, the execution subject can obtain the applet compressed package file from the server of the corresponding target applet. The identifier of the target applet can uniquely represent the target applet. The server can be a server. Thus, the compressed package file of the target applet can be obtained through the jump information of the target applet without scanning the code, which solves the technical problem that the code cannot be scanned in the simulator.

[0046] Step 202, parse the mini-program compressed package file through the target application corresponding to the target mini-program to obtain the mini-program page information.

[0047] In some embodiments, the execution subject may parse the compressed package file of the applet through the target application corresponding to the target applet to obtain the applet page information. Among them, the target application may be an application that can provide an operating environment for the target applet. For example, the target application may be a pre-set application. The applet page information may be information representing the applet page displayed by the target applet in the target application. For example, the applet page information may be a code string representing various parameters (such as font parameters) of the applet page. In practice, the execution subject may parse the compressed package file of the applet through the applet engine container embedded in the pre-set application to obtain the applet page information. As an example, the applet engine container may be any one of the following: Cycles engine, Redshift, Unreal engine. Thus, the target applet can be opened through the target application to enable the applet to run in the real application environment, thereby realizing the link connection.

[0048] In some optional implementations of some embodiments, by corresponding to the target application of the target mini-program, the execution subject may parse the mini-program compressed package file to obtain the mini-program page information by executing the following steps:

[0049] The first step is to determine the application corresponding to the compressed package file of the above-mentioned mini-program as the target application based on the identification information of the above-mentioned target mini-program. In practice, the above-mentioned execution entity may determine the application that can run the above-mentioned target mini-program as the target application. As an example, first, the above-mentioned execution entity may determine the preset application configuration information included in the preset application configuration information set, which has the same preset identification information as the identification information of the above-mentioned target mini-program, as the target application configuration information. Among them, the above-mentioned preset application configuration information may include preset identification information and application identification. Then, the above-mentioned execution entity may determine the application corresponding to the application identification included in the above-mentioned target application configuration information as the target application.

[0050] The second step is to parse the compressed package file of the mini-program according to the mini-program engine container corresponding to the target application to obtain the mini-program page information. In practice, the execution subject can parse and render the compressed package file of the mini-program through the mini-program engine container embedded in the target application to obtain the mini-program page information.

[0051] Step 203, generating mini-program debugging page information according to the mini-program page information.

[0052] In some embodiments, the above-mentioned execution entity can generate the mini-program debugging page information based on the above-mentioned mini-program page information. Among them, the above-mentioned mini-program debugging page information can be information that characterizes the mini-program page and the debugging page. In practice, first, the above-mentioned execution entity can generate the debugging page information through the developer debugging tool of the above-mentioned browser. As an example, the font information included in the above-mentioned mini-program debugging page information can be filled into the debugging template in the above-mentioned developer debugging tool to obtain the debugging page information. For example, the above-mentioned developer debugging tool can be xcode. Finally, the above-mentioned execution entity can combine the above-mentioned mini-program page information and the above-mentioned debugging page information to obtain the mini-program debugging page information. Thus, the information of the page that the user wants to debug can be determined based on the mini-program page information.

[0053] Optionally, before generating the mini-program debugging page information according to the mini-program page information, the execution subject may also display the mini-program page corresponding to the mini-program page information through the target application. In practice, the execution subject may render the mini-program page information through the mini-program engine container embedded in the target application to obtain the corresponding mini-program page, so as to display and run the mini-program in the target application. Thus, users can view the running of the target mini-program in the real application environment.

[0054] Step 204, displaying the mini-program debugging page corresponding to the mini-program debugging page information for debugging.

[0055] In some embodiments, the above-mentioned execution subject may display the applet debugging page corresponding to the above-mentioned applet debugging page information for debugging. Among them, the above-mentioned applet debugging page may include an applet page and a debugging page. In practice, first, the above-mentioned execution subject may display the applet debugging page corresponding to the above-mentioned applet debugging page information. Then, in response to detecting the user's parameter modification operation on the debugging page included in the above-mentioned applet debugging page, the above-mentioned applet page may be adjusted according to the modified parameters corresponding to the above-mentioned parameter modification operation. As an example, in response to detecting a parameter modification operation representing the adjustment of the font size to size four, the font size of the characters on the above-mentioned applet page may be changed to size four. Thus, the user can view the page information of the applet on the displayed applet debugging page and debug the page information of the applet in real time.

[0056] Optionally, the above-mentioned mini-program page information includes page element hierarchy information, element style layout information and code breakpoint information. Among them, the above-mentioned page element hierarchy information may be information characterizing the page element hierarchy of the above-mentioned target mini-program. For example, the above-mentioned page element hierarchy information may be a code string characterizing the stacking order of each element in the page. The above-mentioned element style layout information may be information characterizing the element style layout of the page of the above-mentioned target mini-program. For example, the above-mentioned element style layout information may be a code string characterizing that the element style layout of the above-mentioned target mini-program is a horizontal layout. The above-mentioned code breakpoint information may be information characterizing the code breakpoint of the above-mentioned target mini-program. For example, the above-mentioned code breakpoint information may be information characterizing that the program of the above-mentioned target mini-program is interrupted when running to this position.

[0057] In some optional implementations of some embodiments, the execution entity may fill the page element level information, the element style layout information, and the code breakpoint information into a preset debugging template to generate mini-program debugging page information. The preset debugging template may be a template for filling in various parameters of the target mini-program page for viewing and debugging. Thus, through the mini-program debugging page information, users can view and modify the page element level information, element style layout information, and code breakpoint information of the mini-program.

[0058] The above-mentioned embodiments of the present disclosure have the following beneficial effects: the mini-program debugging method of some embodiments of the present disclosure can provide a full-link real operating environment, thereby improving the mini-program debugging efficiency. Specifically, the reason for the low mini-program debugging efficiency is that when the mini-program is simulated and debugged through the developer tool, a large amount of system resources need to be consumed to simulate the operating environment, and there is a gap between the simulated operating environment and the real operating environment of the mini-program. Based on this, the mini-program debugging method of some embodiments of the present disclosure, first, according to the jump information of the corresponding target mini-program, obtains the mini-program compressed package file corresponding to the above-mentioned target mini-program. Thus, the compressed package file of the target mini-program can be obtained through the jump information of the target mini-program, without scanning the code, solving the technical problem that the code cannot be scanned in the simulator. Secondly, through the target application corresponding to the above-mentioned target mini-program, the above-mentioned mini-program compressed package file is parsed and processed to obtain the mini-program page information. Thus, the above-mentioned target mini-program can be opened through the target application, and the mini-program can be run in the real application environment, thereby realizing the link opening. Then, according to the above-mentioned mini-program page information, the mini-program debugging page information is generated. Thus, the information of the page to be debugged by the user can be obtained for subsequent display. Finally, the mini-program debugging page corresponding to the mini-program debugging page information is displayed for debugging. Thus, the user can view the mini-program page information and debug the mini-program page information on the displayed mini-program debugging page. Also, because the mini-program compressed package file can be parsed by the target application to obtain the mini-program page information, and the mini-program debugging page is displayed according to the mini-program page information for debugging, the mini-program can be debugged in the real operating environment, thereby improving the mini-program debugging efficiency.

[0059] Further references Figure 3 , which shows a process 300 of other embodiments of the mini-program debugging method. The process 300 of the mini-program debugging method includes the following steps:

[0060] Step 301, in response to detecting a debugging start operation, obtaining applet information corresponding to a target applet.

[0061] In some embodiments, the applet debugging method runs on an execution entity (e.g. Figure 1 The computing device shown in the figure) can obtain the applet information of the corresponding target applet in response to detecting the debugging start operation. The above-mentioned debugging start operation can be an operation that represents the operation of starting the debugging target applet. For example, the above-mentioned debugging start operation can be a click operation of the user acting on the debugging start button. The above-mentioned debugging start button can be a button that represents the debugging start after clicking. For example, the above-mentioned button can be a physical button or a virtual button. The above-mentioned applet information may include the source code package of the applet stored in a compressed format. The above-mentioned applet information can be pre-stored on the server by the developer. In practice, in response to detecting the debugging start operation of the corresponding target applet, the above-mentioned execution subject can obtain the applet information of the corresponding target applet from the server.

[0062] Step 302, decompress the mini-program information to obtain the source file.

[0063] In some embodiments, the execution subject may decompress the mini-program information to obtain a source file. The source file may be a source code package obtained after decompression. In practice, the execution subject may decompress the mini-program source code package stored in a compressed format to obtain a source file.

[0064] Step 303, construct a compressed package file corresponding to the target applet according to the source file.

[0065] In some embodiments, the execution subject may construct a compressed package file corresponding to the target applet according to the source file. The compressed package file may be an executable file of the target applet. In practice, the execution subject may construct an executable file corresponding to the target applet according to the source file through a construction tool as a compressed package file. The construction tool may be any one of the following: Maven, Gradle, Jenkins.

[0066] Step 304, packaging the constructed compressed package file to obtain a mini-program compressed package file.

[0067] In some embodiments, the execution subject may package the compressed package file to obtain a mini-program compressed package file. The compressed package file may be an executable mini-program package. For example, the compressed package file may be a compressed file with the suffix apk. In practice, the execution subject may package the compressed package file to obtain a mini-program compressed package file through an engine.

[0068] Step 305: Send the mini-program compressed package file to the server corresponding to the target mini-program.

[0069] In some embodiments, the execution subject may send the mini-program compressed package file to a server corresponding to the target mini-program, wherein the server corresponding to the target mini-program may be a server corresponding to the target mini-program.

[0070] Step 306: Generate jump information corresponding to the target applet according to the identification information corresponding to the target applet.

[0071] In some embodiments, the execution entity may generate jump information corresponding to the target applet according to the identification information corresponding to the target applet. In practice, the execution entity may splice the identification information with the preset jump information template to obtain the jump information corresponding to the target applet. The preset jump information template may be a pre-set jump information template. For example, the preset jump protocol template may be a URL (Uniform Resource Locator) protocol.

[0072] In some optional implementations of some embodiments, according to the identification information corresponding to the target applet, the execution subject may generate the jump information corresponding to the target applet by executing the following steps:

[0073] The first step is to generate jump protocol information according to the preset jump protocol template and the identification information corresponding to the above-mentioned target applet. Among them, the above-mentioned preset jump protocol template can be a template for a protocol link that jumps from a web page to an application in advance. The above-mentioned preset jump protocol template may include identification information parameters. The above-mentioned jump protocol information may be information that characterizes the resource package path for the target application to obtain the applet information. For example, the above-mentioned jump protocol information may be a protocol link or a QR code. In practice, the above-mentioned execution entity may replace the identification information parameters in the above-mentioned preset jump protocol template with the identification information to obtain the jump protocol information.

[0074] The second step is to determine the jump protocol information as the jump information corresponding to the target applet.

[0075] Step 307: Obtain the mini-program compressed package file corresponding to the target mini-program according to the jump information of the target mini-program.

[0076] Step 308, parse the mini-program compressed package file through the target application corresponding to the target mini-program to obtain the mini-program page information.

[0077] Step 309, generating mini-program debugging page information according to the mini-program page information.

[0078] Step 310, displaying the mini-program debugging page corresponding to the mini-program debugging page information for debugging.

[0079] In some embodiments, the specific implementation of steps 307-310 and the technical effects thereof can be referred to in Figure 2 The steps 201-204 in the corresponding embodiment are not described in detail here.

[0080] from Figure 3 It can be seen that Figure 2 Compared with the description of some corresponding embodiments, Figure 3 The process 300 of the mini-program debugging method in some corresponding embodiments reflects the detection of the user's debugging start operation, and the automatic construction of the mini-program compressed package file and the content of the jump information. Therefore, the scheme described in these embodiments can automatically build the mini-program compressed package file and jump information when the user turns on debugging, and further display the debugging information in the application running the mini-program and in the browser for debugging based on the jump information, so as to realize the debugging of the mini-program with an automated process, without the need for the user to independently package the mini-program and enter the mini-program information in the developer tool, and further improve the mini-program debugging efficiency.

[0081] Further references Figure 4 As an implementation of the methods shown in the above figures, the present disclosure provides some embodiments of a small program debugging device. These device embodiments are similar to Figure 2 Corresponding to the method embodiments shown, the device can be specifically applied to various electronic devices.

[0082] like Figure 4 As shown, the mini-program debugging device 400 of some embodiments includes: an acquisition unit 401, a parsing unit 402, a generation unit 403 and a display unit 404. Among them, the acquisition unit 401 is configured to acquire the mini-program compression package file corresponding to the target mini-program according to the jump information of the target mini-program; the parsing unit 402 is configured to parse the mini-program compression package file through the target application corresponding to the target mini-program to obtain the mini-program page information; the generation unit 403 is configured to generate the mini-program debugging page information according to the mini-program page information; the display unit 404 is configured to display the mini-program debugging page corresponding to the mini-program debugging page information for debugging.

[0083] In an optional implementation of some embodiments, the above-mentioned mini-program debugging device 400 may also include a first generation unit (not shown in the figure), and the above-mentioned first generation unit may be configured to generate jump information corresponding to the above-mentioned target mini-program based on the identification information corresponding to the target mini-program.

[0084] In an optional implementation of some embodiments, the above-mentioned mini-program debugging device may also include a sending unit (not shown in the figure), which may be configured to obtain mini-program information corresponding to the target mini-program in response to detecting a debugging start operation; decompress the above-mentioned mini-program information to obtain a source file; based on the above-mentioned source file, construct a construction compressed package file corresponding to the above-mentioned target mini-program; package the above-mentioned construction compressed package file to obtain a mini-program compressed package file; and send the above-mentioned mini-program compressed package file to the server corresponding to the above-mentioned target mini-program.

[0085] In an optional implementation of some embodiments, the first generating unit may be further configured to: generate jump protocol information according to a preset jump protocol template and identification information corresponding to the target applet; and determine the jump protocol information as jump information corresponding to the target applet.

[0086] In an optional implementation of some embodiments, the parsing unit 402 may be further configured to: determine the application corresponding to the mini-program compressed package file as the target application based on the identification information of the target mini-program; and parse the mini-program compressed package file based on the mini-program engine container corresponding to the target application to obtain the mini-program page information.

[0087] In an optional implementation of some embodiments, the above-mentioned mini-program debugging device 400 may also include a first display unit (not shown in the figure), and the above-mentioned first display unit may be configured to: display the mini-program page corresponding to the above-mentioned mini-program page information through the above-mentioned target application.

[0088] In an optional implementation of some embodiments, the generation unit 403 may be further configured to fill the page element level information, the element style layout information and the code breakpoint information into a preset debugging template respectively to generate mini-program debugging page information.

[0089] It is understood that the units described in the device 400 are similar to those described in the reference Figure 2 Therefore, the operations, features and beneficial effects described above for the method are also applicable to the device 400 and the units included therein, and will not be described in detail here.

[0090] Reference below Figure 5 , which shows an electronic device 500 (such as Figure 1 A schematic diagram of the structure of the computing device 101 shown in FIG. Figure 5 The electronic device shown is only an example and should not bring any limitation to the functions and scope of use of the embodiments of the present disclosure.

[0091] like Figure 5 As shown, the electronic device 500 may include a processing device 501 (e.g., a central processing unit, a graphics processing unit, etc.), which can perform various appropriate actions and processes according to a program stored in a read-only memory 502 (ROM) or a program loaded from a storage device 508 into a random access memory 503 (RAM). In the RAM 503, various programs and data required for the operation of the electronic device 500 are also stored. The processing device 501, the ROM 502, and the RAM 503 are connected to each other via a bus 504. An input / output (I / O) interface 505 is also connected to the bus 504.

[0092] Typically, the following devices may be connected to the I / O interface 505: an input device 506 including, for example, a touch screen, a touch pad, a keyboard, a mouse, a camera, a microphone, an accelerometer, a gyroscope, etc.; an output device 507 including, for example, a liquid crystal display (LCD), a speaker, a vibrator, etc.; and a communication device 509. The communication device 509 may allow the electronic device 500 to communicate with other devices wirelessly or by wire to exchange data. Figure 5 The electronic device 500 is shown with various devices, but it should be understood that it is not required to implement or possess all the devices shown. More or fewer devices may be implemented or possessed instead. Figure 5 Each block shown in the figure may represent one device, or may represent multiple devices as required.

[0093] In particular, according to some embodiments of the present disclosure, the process described above with reference to the flowchart can be implemented as a computer software program. For example, some embodiments of the present disclosure include a computer program product, which includes a computer program carried on a computer-readable medium, and the computer program contains program code for executing the method shown in the flowchart. In some such embodiments, the computer program can be downloaded and installed from the network through the communication device 509, or installed from the storage device 508, or installed from the ROM 502. When the computer program is executed by the processing device 501, the above-mentioned functions defined in the method of some embodiments of the present disclosure are executed.

[0094] It should be noted that the computer-readable medium recorded in some embodiments of the present disclosure may be a computer-readable signal medium or a computer-readable storage medium or any combination of the above two. The computer-readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or device, or any combination of the above. More specific examples of computer-readable storage media may include, but are not limited to: an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In some embodiments of the present disclosure, a computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in combination with an instruction execution system, device or device. In some embodiments of the present disclosure, a computer-readable signal medium may include a data signal propagated in a baseband or as part of a carrier wave, which carries a computer-readable program code. This propagated data signal may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the above. The computer readable signal medium may also be any computer readable medium other than a computer readable storage medium, which may send, propagate or transmit a program for use by or in conjunction with an instruction execution system, apparatus or device. The program code contained on the computer readable medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, RF (radio frequency), etc., or any suitable combination of the above.

[0095] In some embodiments, the client and the server may communicate using any currently known or future developed network protocol such as HTTP (Hyper Text Transfer Protocol), and may be interconnected with any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include a local area network ("LAN"), a wide area network ("WAN"), an internet (e.g., the Internet), and a peer-to-peer network (e.g., an ad hoc peer-to-peer network), as well as any currently known or future developed network.

[0096] The computer-readable medium may be included in the electronic device; or it may exist independently without being installed in the electronic device. The computer-readable medium carries one or more programs. When the one or more programs are executed by the electronic device, the electronic device: obtains the applet compression package file corresponding to the target applet according to the jump information of the target applet; parses the applet compression package file through the target application corresponding to the target applet to obtain the applet page information; generates the applet debugging page information according to the applet page information; and displays the applet debugging page corresponding to the applet debugging page information for debugging.

[0097] Computer program code for performing the operations of some embodiments of the present disclosure may be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, C++, and conventional procedural programming languages ​​such as "C" or similar programming languages. The program code may be executed entirely on the user's computer, partially on the user's computer, as a separate software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving a remote computer, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0098] The flow chart and block diagram in the accompanying drawings illustrate the possible architecture, function and operation of the system, method and computer program product according to various embodiments of the present disclosure. In this regard, each square box in the flow chart or block diagram can represent a module, a program segment or a part of a code, and the module, the program segment or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some implementations as replacements, the functions marked in the square box can also occur in a sequence different from that marked in the accompanying drawings. For example, two square boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each square box in the block diagram and / or flow chart, and the combination of the square boxes in the block diagram and / or flow chart can be implemented with a dedicated hardware-based system that performs a specified function or operation, or can be implemented with a combination of dedicated hardware and computer instructions.

[0099] The units described in some embodiments of the present disclosure may be implemented by software or by hardware. The described units may also be provided in a processor, for example, may be described as: a processor including an acquisition unit, a parsing unit, a generation unit, and a display unit. Among them, the names of these units do not constitute a limitation on the units themselves in certain cases, for example, the display unit may also be described as "a unit for displaying the mini-program debugging page corresponding to the mini-program debugging page information mentioned above".

[0100] The functions described above herein may be performed at least in part by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), application specific standard products (ASSPs), systems on chips (SOCs), complex programmable logic devices (CPLDs), and the like.

[0101] Some embodiments of the present disclosure further provide a computer program product, including a computer program, which implements any of the above-mentioned applet debugging methods when executed by a processor.

[0102] The above descriptions are only some preferred embodiments of the present disclosure and an explanation of the technical principles used. Those skilled in the art should understand that the scope of the invention involved in the embodiments of the present disclosure is not limited to the technical solutions formed by a specific combination of the above-mentioned technical features, but should also cover other technical solutions formed by any combination of the above-mentioned technical features or their equivalent features without departing from the above-mentioned inventive concept. For example, the above-mentioned features are replaced with the technical features with similar functions disclosed in the embodiments of the present disclosure (but not limited to) and the technical solutions formed.

Claims

1. A small program debugging method, comprising: According to the jump information of the corresponding target applet, obtain the applet compressed package file corresponding to the target applet; By using the target application corresponding to the target mini-program, the mini-program compressed package file is parsed to obtain mini-program page information; Generate mini-program debugging page information according to the mini-program page information; The mini-program debugging page corresponding to the mini-program debugging page information is displayed for debugging.

2. The method according to claim 1, wherein: Before acquiring the mini-program compressed package file corresponding to the target mini-program according to the jump information of the target mini-program, the method further includes: According to the identification information corresponding to the target applet, jump information corresponding to the target applet is generated.

3. The method according to claim 2, wherein: Before generating jump information corresponding to the target mini-program according to the identification information corresponding to the target mini-program, the method further includes: In response to detecting a debugging start operation, obtaining applet information corresponding to a target applet; Decompressing the mini-program information to obtain a source file; According to the source file, construct a construction compressed package file corresponding to the target applet; Packaging the constructed compressed package file to obtain a mini-program compressed package file; The mini-program compressed package file is sent to the server corresponding to the target mini-program.

4. The method according to claim 2, wherein: The step of generating jump information corresponding to the target mini-program according to the identification information corresponding to the target mini-program includes: Generate jump protocol information according to the preset jump protocol template and the identification information corresponding to the target applet; The jump protocol information is determined as the jump information corresponding to the target applet.

5. The method according to claim 1, wherein: The step of parsing the mini-program compressed package file by the target application corresponding to the target mini-program to obtain mini-program page information includes: According to the identification information of the target applet, determining the application corresponding to the applet compressed package file as the target application; According to the mini-program engine container corresponding to the target application, the mini-program compressed package file is parsed to obtain mini-program page information.

6. The method according to claim 1, wherein: Before generating the mini-program debugging page information according to the mini-program page information, the method includes: The mini-program page corresponding to the mini-program page information is displayed through the target application.

7. The method according to claim 1, wherein: The mini program page information includes page element level information, element style layout information and code breakpoint information; as well as The step of generating mini-program debugging page information according to the mini-program page information includes: The page element level information, the element style layout information and the code breakpoint information are respectively filled into a preset debugging template to generate mini-program debugging page information.

8. A small program debugging device, comprising: An acquisition unit is configured to acquire a mini-program compressed package file corresponding to the target mini-program according to the jump information of the target mini-program; A parsing unit is configured to parse the mini-program compressed package file through a target application corresponding to the target mini-program to obtain mini-program page information; A generating unit, configured to generate mini-program debugging page information according to the mini-program page information; The display unit is configured to display the mini-program debugging page corresponding to the mini-program debugging page information for debugging.

9. An electronic device, comprising: one or more processors; a storage device having one or more programs stored thereon, When the one or more programs are executed by the one or more processors, the one or more processors implement the method according to any one of claims 1 to 7.

10. A computer readable medium having a computer program stored thereon, wherein: When the computer program is executed by a processor, the method according to any one of claims 1 to 7 is implemented.

11. A computer program product, comprising a computer program, which, when executed by a processor, implements the method according to any one of claims 1 to 7.

Images