CN112988599A

CN112988599A - Page debugging method and device, electronic equipment and storage medium

Info

Publication number: CN112988599A
Application number: CN202110470683.7A
Authority: CN
Inventors: 李璐; 丁涛; 陈阳; 汤维中; 黄孝燕; 张梦欣
Original assignee: Tencent Technology Shenzhen Co Ltd
Current assignee: Tencent Technology Shenzhen Co Ltd
Priority date: 2021-04-29
Filing date: 2021-04-29
Publication date: 2021-06-18
Anticipated expiration: 2041-04-29
Also published as: CN112988599B

Abstract

The application relates to the technical field of computers, in particular to the technical field of cloud, and discloses a page debugging method, a page debugging device, electronic equipment and a storage medium, which are used for obtaining an intermediate state of page operation, wherein the method comprises the following steps: the method comprises the steps of receiving a script source code set of a page to be debugged, sent by first equipment, obtaining breakpoint indication information sent by second equipment, processing the script source code set to obtain a target script source code set, sending the target script source code set and the breakpoint indication information to the first equipment, and further sending received context variable information to the second equipment, so that the second equipment debugs the page to be debugged based on the context variable information. Therefore, the target script source code set can be interrupted and executed at any position according to actual configuration requirements, so that the running intermediate state of the target script source code set is obtained, the debugging effect on the page to be debugged can be further ensured, and the accuracy of the debugging result is improved.

Description

Page debugging method and device, electronic equipment and storage medium

Technical Field

The application relates to the technical field of computers, in particular to the technical field of cloud, and discloses a page debugging method and device, electronic equipment and a storage medium.

Background

Currently, in order to ensure that a page developed based on the fifth version hypertext Markup Language (HTML 5) can be normally displayed on a mobile terminal, a remote debugging on an H5 page on the mobile terminal is required.

In the related art, a debugging technology such as Web Remote review (Weinre) is usually adopted, and after a debugging script (JavaScript, JS) is inserted into a device to be debugged, bidirectional communication between the debugging device and the mobile terminal is realized in a socket communication manner, so that the purpose of debugging an H5 page on the mobile terminal by using the debugging device is realized.

For example, referring to fig. 1, which is a diagram of a debugging architecture in the related art of the present application, a debugging device implements debugging interaction with a mobile terminal through a local server in a socket communication manner.

However, when the Weinre technology is adopted to debug the H5 page, only the final result after the H5 page is run can be obtained, but the intermediate state when the H5 page is run on the mobile terminal cannot be obtained, so that a potential problem cannot be found in time in the running process of the H5 page, effective debugging cannot be realized in time, and the accuracy of the debugging result is seriously affected to a certain extent.

Disclosure of Invention

The embodiment of the application provides a page debugging method, a page debugging device, electronic equipment and a storage medium, which are used for solving the problem that the intermediate state of H5 page operation cannot be acquired in the process of debugging an H5 page.

In a first aspect, a first page debugging method provided in an embodiment of the present application is applied to a processing device, and includes:

receiving a script source code set of a page to be debugged, which is sent by first equipment, wherein the script source code set is sent by the first equipment after the first equipment receives address information of the page to be debugged, which is sent by second equipment;

sending the script source code set to the second device, acquiring breakpoint indication information returned by the second device based on the script source code set, and adding preset debugging functions to specified positions in script source codes of each line contained in the script source code set respectively to obtain a target script source code set;

sending the target script source code set and the breakpoint indication information to the first device, so that the first device reports context variable information when the target script source code set is interrupted and executed based on the breakpoint indication information;

and sending the context variable information to the second equipment so that the second equipment debugs the page to be debugged based on the context variable information.

Optionally, the receiving a script source code set of a page to be debugged, which is sent by the first device, includes:

receiving a debugging connection establishment request sent by second equipment, and acquiring address information of a page to be debugged carried in the debugging connection establishment request;

generating encrypted identification information corresponding to the address information, and generating coding information of the page to be debugged based on the encrypted identification information and the address information;

sending the encoded information to the second device to cause the second device to send the encoded information to the first device;

receiving a connection establishment request carrying the encrypted identification information and sent by the first equipment, and performing identity authentication on the first equipment based on the encrypted identification information;

and if the verification is confirmed to pass, receiving the script source code set of the page to be debugged, which is sent by the first equipment.

Optionally, the step of adding a preset debugging function to the specified positions in each line of script source codes included in the script source code set respectively to obtain a target script source code set includes:

sequentially acquiring script source codes of each line according to the compiling sequence of the script source codes of each line in the script source code set, wherein each line of script source codes is acquired, and a preset debugging function is added to a specified position in the script source codes of each line;

and generating a target script source code set corresponding to the script source code set based on each line of script source codes added with the debugging function.

Optionally, after receiving the script source code set of the page to be debugged sent by the first device, the method further includes:

receiving a document object model and style data of the page to be debugged, which are sent by the first device, and forwarding the document object model and the style data to the second device;

if a target object to be updated which is sent by the second equipment and obtained after a target object in the document object model is modified is received, sending the target object to be updated to the first equipment, generating a page screenshot of the page to be debugged according to the updated document object model and the style data fed back by the first equipment, and sending the page screenshot to the second equipment;

and if target data to be updated, which is sent by the second equipment and obtained after target data in the style data are modified, is received, sending the target data to be updated to the first equipment, generating a page screenshot of the page to be debugged according to the updated document object model and the style data fed back by the first equipment, and sending the page screenshot to the second equipment.

Optionally, in the process of receiving context variable information reported when the first device interrupts executing the target script source code set, the method includes:

and executing the following operations every time the context variable information reported by the first equipment is received:

sending currently received context variable information to the second equipment, so that the second equipment debugs the page to be debugged based on the context variable information, and displaying an interrupt execution state of the first equipment;

and responding to the indication information sent by the second equipment for continuing to execute the target script source code set, and sending the indication information to the first equipment so as to enable the first equipment to continue to execute the target script source code set.

Optionally, after completing the debugging of the page to be debugged, the method further includes:

generating an interactive instruction set capable of debugging a page to be debugged according to each interactive instruction with the second equipment;

and sending the interactive instruction set to the second equipment so that the second equipment executes debugging operation of other pages to be debugged by referring to the interactive instruction set.

In a second aspect, a second page debugging method provided in an embodiment of the present application includes:

receiving a script source code set of a page to be debugged, which is sent by processing equipment, wherein the script source code set is sent to the processing equipment by first equipment after address information of the page to be debugged is sent to the first equipment;

marking breakpoint positions in the script source code set, generating breakpoint indication information corresponding to the script source code set based on the marked breakpoint positions, and sending the breakpoint indication information to the processing equipment, so that the processing equipment sends the breakpoint indication information to the first equipment;

receiving context variable information sent by the processing device, displaying an interrupt execution state of the first device, and debugging the page to be debugged based on the context variable information, wherein the context variable information is reported to the processing device after the first device interrupts executing the script source code set based on the breakpoint indication information.

Optionally, the receiving a script source code set of a page to be debugged sent by the processing device includes:

sending a debugging connection request to a processing device, wherein the debugging connection request carries address information of a page to be debugged;

acquiring coding information generated by the processing equipment based on the address information, and sending the coding information to first equipment, wherein the coding information is generated by the processing equipment based on the address information and the encryption identification information after the processing equipment generates encryption identification information corresponding to the address information;

receiving a script source code set of the page to be debugged, which is sent by the processing device, wherein the script source code set is obtained based on the following operations: and after the processing equipment completes the identity verification of the first equipment based on the connection establishment request which is sent by the first equipment and carries the encrypted identification information, the first equipment sends the script source code set to the processing equipment.

Optionally, after receiving the script source code set of the page to be debugged sent by the processing device, the method further includes:

receiving a document object model and style data of the page to be debugged, which are sent by the processing equipment;

if the target object in the document object model is modified, after the modified target object to be updated is obtained, the target object to be updated is sent to the processing equipment, so that the processing equipment sends the target object to be updated to the first equipment;

and if the target data in the style data is modified, after the modified target data to be updated is obtained, the target data to be updated is sent to the processing equipment, so that the processing equipment sends the target data to be updated to the first equipment.

Optionally, after receiving the context variable information sent by the processing device, the method further includes:

and sending indication information for continuing to execute the target script source code set to the processing equipment so as to enable the processing equipment to send the indication information to the first equipment, wherein the indication information is used for indicating the first equipment to continue to execute the target script source code set.

and receiving an interactive instruction set sent by the processing equipment, and executing debugging operation of other pages to be debugged based on the interactive instruction set.

In a third aspect, a third page debugging method provided in the embodiment of the present application includes:

receiving address information of a page to be debugged sent by second equipment, and sending a script source code set of the page to be debugged to processing equipment so that the processing equipment sends the script source code set to the second equipment;

receiving a target script source code set and breakpoint indication information corresponding to the script source code set, where the target script source code set is obtained by adding a preset debugging function to a specified position in each line of script source codes included in the script source code set, and the breakpoint indication information is generated by the second device based on a breakpoint position marked in the script source code set;

and matching the position of one line of script source codes with the breakpoint position in the breakpoint indication information when executing one line of target script source codes corresponding to one line of script source codes in the script source code set, interrupting the execution of the target script source code set after determining that the matching is successful, and sending the current context variable information to the processing equipment.

Optionally, the receiving address information of the page to be debugged sent by the second device, and sending the script source code set of the page to be debugged to the processing device, includes:

receiving coding information sent by second equipment, wherein after the second equipment sends a debugging connection establishment request carrying address information of a page to be debugged to processing equipment, the processing equipment generates the coding information based on the address information and encrypted identification information generated corresponding to the address information, and sends the coding information to the second equipment;

identifying the coding information, and acquiring encryption identification information and address information of a page to be debugged, which are included in the coding information;

and sending a connection establishment request carrying the encrypted identification information to the processing equipment, and sending the script source code set of the page to be debugged to the processing equipment after confirming that the identity verification is completed on the processing equipment based on the encrypted identification information.

Optionally, after the sending the script source code set of the page to be debugged to the processing device, the method further includes:

sending a document object model and style data of the page to be debugged to the processing device, so that the processing device forwards the document object model and the style data to the second device;

if a target object to be updated sent by the processing equipment is received, updating a corresponding object in the document object model based on the target object to be updated, and sending the updated document object model and the style data to the processing equipment, wherein the target object to be updated is sent to the processing equipment after the second equipment is modified based on the document object model;

and if target data to be updated sent by the processing equipment is received, updating corresponding content in the style data based on the target data to be updated, and sending the updated document object model and the style data to the processing equipment, wherein the target data to be updated is sent to the processing equipment after the second equipment is modified based on the style data.

Optionally, after the sending the current context variable information to the processing device, the method further includes:

and receiving indication information sent by the processing equipment for continuing to execute the target script source code set, and continuing to execute the target script source code set, wherein the indication information is sent by the second equipment to the processing equipment.

In a fourth aspect, a first page debugging apparatus provided in an embodiment of the present application includes:

the device comprises a first receiving unit, a second receiving unit and a third receiving unit, wherein the first receiving unit is used for receiving a script source code set of a page to be debugged, which is sent by first equipment, and the script source code set is sent by the first equipment after the first equipment receives address information of the page to be debugged, which is sent by second equipment;

the acquisition unit is used for sending the script source code set to the second equipment, acquiring breakpoint indication information returned by the second equipment based on the script source code set, and respectively adding preset debugging functions to specified positions in script source codes of each line contained in the script source code set to obtain a target script source code set;

a first sending unit, configured to send the target script source code set and the breakpoint indication information to the first device, so that the first device reports context variable information when the target script source code set is interrupted and executed based on the breakpoint indication information;

and the second sending unit is used for sending the context variable information to the second equipment so that the second equipment debugs the page to be debugged based on the context variable information.

Optionally, when receiving the script source code set of the page to be debugged sent by the first device, the receiving unit is configured to:

Optionally, when a preset debugging function is added to the specified position in each line of script source codes included in the script source code set to obtain a target script source code set, the obtaining unit is configured to:

Optionally, after receiving the script source code set of the page to be debugged sent by the first device, the obtaining unit is further configured to:

Optionally, in the process of receiving context variable information reported when the first device interrupts executing the target script source code set, the first sending unit is configured to:

Optionally, after completing the debugging of the page to be debugged, the apparatus further includes a first processing unit, where the first processing unit is configured to:

In a fifth aspect, a second page debugging apparatus provided in an embodiment of the present application includes:

the second receiving unit is used for receiving a script source code set of the page to be debugged, which is sent by the processing equipment, wherein the script source code set is sent to the processing equipment by the first equipment after the address information of the page to be debugged is sent to the first equipment;

the generating unit is used for marking breakpoint positions in the script source code set, generating breakpoint indication information corresponding to the script source code set based on the marked breakpoint positions, and sending the breakpoint indication information to the processing equipment so that the processing equipment sends the breakpoint indication information to the first equipment;

and the debugging unit is used for receiving context variable information sent by the processing equipment, displaying the interrupt execution state of the first equipment, and debugging the page to be debugged based on the context variable information, wherein the context variable information is reported to the processing equipment after the first equipment interrupts the execution of the script source code set based on the breakpoint indication information.

Optionally, when receiving the script source code set of the page to be debugged sent by the processing device, the second receiving unit is configured to:

Optionally, after receiving the script source code set of the page to be debugged sent by the processing device, the second receiving unit is further configured to:

Optionally, after receiving the context variable information sent by the processing device, the debugging unit is further configured to:

Optionally, after completing the debugging of the page to be debugged, the apparatus further includes a second processing unit, where the second processing unit is configured to:

In a sixth aspect, a third page debugging apparatus provided in the embodiment of the present application includes:

the third receiving unit is used for receiving address information of a page to be debugged, which is sent by second equipment, and sending a script source code set of the page to be debugged to processing equipment so that the processing equipment sends the script source code set to the second equipment;

a fourth receiving unit, configured to receive a target script source code set and breakpoint indication information corresponding to the script source code set, where the target script source code set is obtained by adding a preset debugging function to a specified position in each line of script source codes included in the script source code set, and the breakpoint indication information is generated by the second device based on a breakpoint position marked in the script source code set;

and the matching unit matches the position of one line of script source codes with the breakpoint position in the breakpoint indication information when executing one line of target script source codes corresponding to one line of script source codes in the script source code set, and interrupts the execution of the target script source code set and sends the current context variable information to the processing equipment after determining that the matching is successful.

Optionally, when receiving address information of the page to be debugged sent by the second device and sending the script source code set of the page to be debugged to the processing device, the third receiving unit is configured to:

Optionally, after the script source code set of the page to be debugged is sent to the processing device, the third receiving unit is further configured to:

Optionally, after sending the current context variable information to the processing device, the matching unit is further configured to:

In a seventh aspect, an electronic device is provided in this application, and includes at least one processor and at least one memory, where the memory stores program code, and when the program code is executed by the processor, the at least one processor is enabled to execute the page debugging method provided in this application.

In an eighth aspect, an embodiment of the present application provides a computer-readable storage medium, which includes program code, when the program product runs on an electronic device, the program code is configured to enable the electronic device to execute a page debugging method provided in an embodiment of the present application.

The beneficial effect of this application is as follows:

in the embodiment of the application, after receiving the script source code set of the page to be debugged sent by the first device, the processing device adds the preset debugging functions to the specified positions in each row of script source codes included in the script source code set respectively to obtain the processed target script source code set, so that when the target script source code set is executed subsequently, the execution of the target script source code set can be interrupted at any position according to actual configuration requirements, so as to obtain the running intermediate state of the target script source code set, further guarantee the debugging effect on the page to be debugged, and improve the accuracy of the debugging result. In addition, in the page debugging process, the processing device is used as an intermediate link of communication transmission between the first device and the second device, and transmission channels are respectively established with the first device and the second device, so that related data can be remotely transmitted by means of a public network, and further, remote debugging of a page to be debugged on the first device is realized.

Drawings

The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the application and together with the description serve to explain the application and not to limit the application. In the drawings:

FIG. 1 is a diagram of a debugging architecture in the related art of the present application;

FIG. 2a is a schematic diagram of an application scenario in an embodiment of the present application;

FIG. 2b is a schematic diagram of a page displayed on the first device in the embodiment of the present application;

fig. 2c is a schematic diagram of a page displayed on the second device 230 in the embodiment of the present application;

FIG. 3a is a schematic flowchart of a process device executing page debugging in an embodiment of the present application;

fig. 3b is a schematic flowchart of receiving a script source code set of a page to be debugged, which is sent by a first device in the embodiment of the present application;

FIG. 3c is a schematic flow chart illustrating obtaining a target script source code set according to an embodiment of the present application;

FIG. 3d is a schematic diagram of a script source code set with a breakpoint added in the embodiment of the present application;

FIG. 3e is a schematic diagram of a source code set of a target script in an embodiment of the present application;

fig. 3f is a schematic operation diagram after receiving context information reported by a first device in the embodiment of the present application;

fig. 4a is a schematic view of an operation flow of a second device in a page debugging process in the embodiment of the present application;

fig. 4b is a schematic diagram of inputting address information of a page to be debugged by the second device in the embodiment of the present application;

fig. 4c is a schematic flowchart of the second device obtaining a script source code set sent by the processing device in this embodiment of the application;

FIG. 4d is a schematic diagram of a page displaying encoded information according to an embodiment of the present application;

FIG. 4e is a schematic diagram illustrating the marking of a breakpoint in a script source code set according to an embodiment of the present application;

fig. 5a is a schematic view of an operation flow of a first device in a page debugging process in the embodiment of the present application;

FIG. 5b is a schematic flow chart illustrating sending a script source code set according to an embodiment of the present application;

FIG. 6a is an interaction timing diagram of a page debugging process in the embodiment of the present application;

FIG. 6b is a timing diagram illustrating receiving data to be debugged and displaying a screenshot of a page in real time according to an embodiment of the present disclosure;

fig. 7 is a schematic logic structure diagram of a page debugging apparatus according to an embodiment of the present application;

fig. 8 is a schematic logic structure diagram of a page debugging apparatus according to an embodiment of the present application;

fig. 9 is a schematic logic structure diagram of a page debugging apparatus according to an embodiment of the present application;

fig. 10 is a schematic diagram of a hardware component of an electronic device to which an embodiment of the present application is applied;

fig. 11 is a schematic structural diagram of a computing device in an embodiment of the present application.

Detailed Description

In order to make the objects, technical solutions and advantages of the embodiments of the present application clearer, the technical solutions 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 obvious that the described embodiments are some embodiments, but not all embodiments, of the technical solutions of the present application. All other embodiments obtained by a person skilled in the art without any inventive step based on the embodiments described in the present application are within the scope of the protection of the present application.

Some concepts related to the embodiments of the present application are described below.

Script source code set: the script source code set is a generic name of all script source codes of a page to be debugged, and in the embodiment of the application, the script source code set at least includes all script (JavaScript, JS) source codes corresponding to the page to be debugged.

Breakpoint indication information: the system is used for indicating the position of the marked breakpoint in the script source code and recording the file and the line number where the marked breakpoint is located.

Breaking points: refers to a flag marking the interrupt operation at a specific position of a certain line of code.

Abstract Syntax Tree (AST): the method is used for analyzing the code and generating the form of a tree structure.

HTML 5: the abbreviation H5 is a language description mode for constructing Web content. HTML5 is the next generation standard of the internet, is a language way to build and present internet content, and is considered as one of the core technologies of the internet.

The present application relates to the field of Cloud technology (Cloud technology), wherein Cloud technology refers to a hosting technology for unifying series resources such as hardware, software, and network in a wide area network or a local area network to realize calculation, storage, processing, and sharing of data.

Cloud technology (Cloud technology) is based on a general term of network technology, information technology, integration technology, management platform technology, application technology and the like applied in a Cloud computing business model, can form a resource pool, is used as required, and is flexible and convenient. Cloud computing technology will become an important support. Background services of the technical network system require a large amount of computing and storage resources, such as video websites, picture-like websites and more web portals. With the high development and application of the internet industry, each article may have its own identification mark and needs to be transmitted to a background system for logic processing, data in different levels are processed separately, and various industrial data need strong system background support and can only be realized through cloud computing.

The following briefly introduces the design concept of the embodiments of the present application:

in the related art, when debugging a page to be debugged, a debugging technology such as Weinre is usually adopted to debug a remote mobile terminal through a debugging device. Therefore, it is required to ensure that the debugging device, the local server and the mobile terminal are in the same local area network, and in the debugging process, only the final result after the script source code set of the page to be debugged is executed on the mobile terminal can be obtained, and the intermediate state when the script source code set of the page to be debugged is executed on the mobile terminal cannot be obtained, so that the corresponding context information can not be found in time, and the accuracy of the debugging result is greatly influenced.

In view of this, in the embodiment of the present application, the debugging server establishes communication connections with the debugging device and the debugged mobile terminal respectively by using a public network, which avoids a drawback that only page debugging can be implemented in a local area network in the prior art, and after receiving a script source code set of a page to be debugged sent by the mobile terminal, the debugging server adds script source codes of each line included in the script source code set to a corresponding debugging function respectively to obtain a processed target script source code set, so that when executing the target script source code set subsequently, the execution of the target script source code set can be interrupted at any position according to actual configuration requirements, so as to obtain an intermediate state of the operation of the target script source code set, thereby ensuring a debugging effect on the page to be debugged, and improving accuracy of a debugging result.

The preferred embodiments of the present application will be described below with reference to the accompanying drawings of the specification, it should be understood that the preferred embodiments described herein are merely for illustrating and explaining the present application, and are not intended to limit the present application, and that the embodiments and features of the embodiments in the present application may be combined with each other without conflict.

Fig. 2a is a schematic view of an application scenario in the embodiment of the present application. The application scene includes a first device 210, a processing device 220, and a second device 230, a page 211 can be opened by the first device 210, a web page 231 can be opened by the second device 230, information interaction can be performed between the first device 210 and the processing device 220 in a web socket manner, interaction can be performed between the processing device 220 and the second device 230 in a web socket manner, multiple functional modules may exist on the second device, and are used for performing operations such as debugging, editing a console instruction, and viewing network information on the obtained data to be debugged, and a JS script Software Development Kit (JS SDK) may be built in the first device and is used for executing operations in a debugging process.

In this embodiment, the first device 210 is a debugged mobile terminal, a page to be debugged in the debugged mobile terminal may be an H5 page, the mobile terminal may be a personal computer, a mobile phone, a tablet computer, a notebook, an e-reader, and the like, the first device 210 may communicate with the processing device 220 by means of Socket bidirectional communication, and in an optional implementation, the communication network may be a wired network or a wireless network, so that the first device 210 and the processing device 220 may be directly or indirectly connected by a wired or wireless communication manner.

A page 211 is presented on the first device 210, as shown in fig. 2b, which is a schematic page displayed on the first device in this embodiment of the present application, only contents that can be presented on the page 211 are listed schematically in fig. 2b, when the page illustrated in fig. 2b is presented on a mobile terminal, the page may be presented in a pop-up window form, and different function menus are presented, so that by triggering the corresponding function menu, a corresponding chat area displaying chat information sent by the second device is displayed, or an area displaying a current debugging connection state is displayed, or a console area is displayed, so as to display an execution result of an instruction sent by the processing device.

It should be noted that, in the embodiment of the present application, the processing device 220 does not participate in the transmission process of the address information of the page to be debugged between the first device 210 and the second device 230, but in the debugging process, the information sent by the first device 210 must be sent to the second device 230 via the processing device 220, and similarly, the information sent by the second device 230 must be sent to the first device 210 via the processing device 220.

The processing device 220 is a debugging server, and may be an independent physical server, a server cluster or a distributed system formed by a plurality of physical servers, or a cloud server providing basic cloud computing services such as a cloud service, a cloud database, cloud computing, a cloud function, cloud storage, a network service, cloud communication, middleware service, a domain name service, a security service, a CDN, and a big data and artificial intelligence platform.

The second device 230 is a debugging device where a debugger is located, and the debugging device may be an electronic device such as a personal computer, a tablet computer, and a notebook computer that can implement a debugging function, and during a debugging process, the second device 230 may communicate with the processing device 220 by means of a communication network, and then send the interaction information to the first device 210 via the processing device 220.

A web page 231 is presented on the second device 230, as shown in fig. 2c, which is a schematic page diagram displayed on the second device 230 in the embodiment of the present application, in the web page, an input box for inputting address information of a page to be debugged is included, and indication information of a current connection state is displayed, as shown in fig. 2c, the current stage is a stage of starting debugging in the first step.

It should be noted that, in the embodiment of the present application, corresponding to the webpage illustrated in fig. 2b and 2c, a debugging platform application exists in the debugging process, and the first device 210 and the second device 230 are respectively installed with corresponding debugging platform applications. After the accounts with different permissions complete logging in on the web page of the debugging platform application, the presented pages are completely different, for example, after the debugged account logs in the debugging platform application on the first device 210, the web page as illustrated in fig. 2b is presented, but communication connection cannot be established with the processing device 220; after logging in the debugging platform application on the second device 230, the debugging account completes authentication with the processing device 220, establishes a communication connection with the processing device 220, and presents a web page illustrated in fig. 2 c. There are multiple servers that provide services for the debugging platform application, including the processing device 220 that participates in the forwarding and processing of debugging data during the debugging process, and other servers that provide other information interaction between the first device 210 and the second device 230.

In the embodiment of the application, the proposed page debugging method can be applied to a remote debugging scene of an H5 page, in the debugging process, remote communication connection is realized between a first device and a processing device and between a second device and the processing device through a public network, a debugging platform application for H5 page debugging is installed on the second device, so that a debugging person can initiate a debugging connection establishment request for the H5 page after logging in the debugging platform application to complete identity verification, further, the processing device sends data to be debugged of the H5 page received from the first device to the second device, related debugging operation is completed on the second device, and the second device sends instruction information and modified data in the debugging process to the first device through the processing device to perform synchronous display presentation.

In this way, in the page debugging process, the processing device 220 serves as an intermediate link of communication transmission between the first device 210 and the second device 230, and establishes transmission channels with the first device 210 and the second device 230, so that related data can be remotely transmitted by means of a public network, and further, remote debugging of a page to be debugged on the first device is realized.

In some possible embodiments of the present application, the method for debugging a page may be applied to a test scenario, so as to implement remote testing of a page on a second device, and related processing operations are similar, which is not described herein again.

In one possible application scenario, the processing devices 220 may be deployed in different regions for reducing communication delay, or different processing devices 220 may serve the regions corresponding to the first device 210 and the second device 230, respectively, for load balancing. The plurality of processing devices 220 are configured to share data via a blockchain, and the plurality of processing devices 220 correspond to a data sharing system formed by a plurality of servers. For example, the first device 210 is located at site a and communicatively coupled to the processing device 220, and the second device 230 is located at site b and communicatively coupled to other processing devices 220.

Each processing device 220 in the data sharing system has a node identifier corresponding to the processing device 220, and each processing device 220 in the data sharing system may store the node identifiers of other processing devices 220 in the data sharing system, so that the generated block is broadcast to other processing devices 220 in the data sharing system according to the node identifiers of other processing devices 220. Each processing device 220 may maintain a node identifier list as shown in the following table, and store the name of the processing device 220 and the node identifier in the node identifier list correspondingly. The node identifier may be an Internet Protocol (IP) address and any other information that can be used to identify the node, and table 1 only illustrates the IP address as an example.

TABLE 1

The object trajectory recognition method provided by the exemplary embodiment of the present application is described below with reference to the drawings in conjunction with the application scenarios described above, it should be noted that the application scenarios described above are only shown for the convenience of understanding the spirit and principles of the present application, and the embodiments of the present application are not limited in this respect.

The following describes a process of page debugging in the embodiment of the present application with reference to the accompanying drawings:

referring to fig. 3a, a schematic diagram of a process of executing page debugging by a processing device in an embodiment of the present application is shown. The process of executing page debugging by the processing device is described in detail below with reference to fig. 3 a.

Step 301: the processing equipment receives a script source code set of a page to be debugged, which is sent by first equipment, wherein the script source code set is sent by the first equipment after the first equipment receives address information of the page to be debugged, which is sent by second equipment.

In this embodiment of the application, after the second device sends the address information of the page to be debugged to the first device, the processing device receives a script source code set of the page to be debugged, where the script source code set at least includes JS source codes of the page to be debugged, and the page to be debugged may be an H5 page.

It should be noted that, in this embodiment of the application, to ensure secure interaction between the processing device and the first device, the processing device may authenticate the first device before receiving the script source code set sent by the first device, so as to verify whether the first device has an authority to access the processing device.

In executing step 301, refer to fig. 3b, which is a schematic flowchart illustrating a process of receiving a script source code set of a page to be debugged sent by a first device in an embodiment of the present application, and the following description is specifically described with reference to fig. 3 b.

Step 3011: and the processing equipment receives a debugging connection establishment request sent by the second equipment and acquires the address information of the page to be debugged carried in the debugging connection establishment request.

In specific implementation, the processing device receives a connection establishment request of the page to be debugged, which is sent by the second device when the second device intends to debug the page to be debugged, and acquires address information of the page to be debugged, which is carried in the connection establishment request.

Step 3012: and the processing equipment generates encrypted identification information corresponding to the address information and generates coding information of the page to be debugged based on the encrypted identification information and the address information.

In specific implementation, after receiving the address information of the page to be debugged sent by the second device, the processing device generates encrypted identification information corresponding to the address information of the page to be debugged, where the encrypted identification information may be a randomly generated dynamic identification code, or an identification code generated based on, for example, the current time and session identification (Identity).

It should be noted that, when the processing device generates the encrypted identification information, an existing verification code generation mechanism may also be used to generate the encrypted identification information that can be used to verify the identity of the first device.

In some possible embodiments of the present application, after the processing device generates the encrypted identification information, the processing device may set an associated valid duration for the encrypted identification information, start the timer to count down, and delete the record of the encrypted identification information after the timing is finished, so that the processing device can only receive the request sent by other devices to be verified within the valid duration range.

Furthermore, the processing device generates the coding information of the page to be debugged based on the encrypted identification information and the address information of the page to be debugged, wherein the coding information may specifically be a two-dimensional code, a barcode, or other forms of identifiable information.

Step 3013: the processing device transmits the encoded information to the second device to cause the second device to transmit the encoded information to the first device.

And after the processing equipment generates coding information corresponding to the page to be debugged, the coding information is sent to the second equipment, so that the second equipment sends the coding information to the first equipment.

It should be noted that, in this embodiment of the application, the processing device cannot directly send information to the first device before performing identity authentication on the first device, so that only the generated encoded information can be sent to the second device, and the encoded information is sent to the first device via the second device, where, in a debugging process, the first device and the second device cannot directly interact with each other, and before debugging, the processing device does not participate in interaction between the first device and the second device.

Step 3014: the processing equipment receives a connection establishment request which is sent by the first equipment and carries the encrypted identification information, and carries out identity authentication on the first equipment based on the encrypted identification information.

In specific implementation, the processing device receives a connection establishment request which is sent by the first device and carries encrypted identification information, compares the received encrypted identification information with encrypted identification information generated by address information corresponding to a page to be debugged, obtains a comparison result of the encrypted identification information, and takes the obtained comparison result as an authentication result of the first device.

Step 3015: the processing device determines whether the first device identity authentication passes, if so, performs step 3016, otherwise, performs step 3017.

And if the processing equipment determines that the obtained encrypted identification information is successfully matched with the stored encrypted identification information, the first equipment identity authentication is judged to be passed, and otherwise, the first equipment identity authentication is judged not to be passed.

Step 3016: the processing equipment receives a script source code set of a page to be debugged, which is sent by the first equipment.

In specific implementation, after the processing device determines that the first device passes the verification, the processing device receives a connection establishment request of the first device, and receives a script source code set of a page to be debugged, which is sent by the first device.

Step 3017: the processing device rejects the connection establishment request sent by the first device.

Therefore, the processing device can perform identity authentication on the first device through the generated encrypted identification information, and the security of information interaction with the first device is ensured, so that the subsequent process of receiving debugging data sent by the first device is safe and reliable, namely a safe encrypted debugging channel is established with the first device, and the information security of the first device is ensured to a certain extent.

Step 302: and the processing equipment sends the script source code set to the second equipment, acquires breakpoint indication information returned by the second equipment based on the script source code set, and respectively adds preset debugging functions at specified positions in each line of script source codes contained in the script source code set to obtain a target script source code set.

In a specific implementation, when step 302 is executed, referring to fig. 3c, which is a schematic flowchart of a process for obtaining a source code set of a target script in an embodiment of the present application, the following describes a process for obtaining a source code set of a target script with reference to fig. 3 c:

and step 3021, the processing device sends the obtained script source code set to the second device.

And step 3022, the processing device receives breakpoint indication information returned by the second device based on the script source code set.

And after the processing equipment sends the obtained script source code set to the second equipment, receiving breakpoint indication information returned by the second equipment based on the source code set, wherein the breakpoint indication information is used for indicating the position of a breakpoint and is used for representing the file name of the breakpoint and the corresponding line number.

For example, the acquired address information is: and sending the JS source code to the second equipment after the JS source code of the H5 page of http:// webdebug.xx.com/demo/sdkSide/index.html, and obtaining breakpoint indication information in a file form fed back by the second equipment, wherein the file corresponding to the breakpoint indication information can be a file of an Object Notation (JSON) type, and comprises a file name and a breakpoint line number corresponding to the breakpoint.

For another example, referring to fig. 3d, which is a schematic diagram of a script source code set added with a breakpoint in the embodiment of the present application, based on the position of the breakpoint illustrated in fig. 3d, the breakpoint indication information obtained by the processing device includes the following contents: file X-second line, file X-fourth line, file Y-first line, and file Y-second line.

And 3023, adding preset debugging functions to the designated positions of the script source codes in each line included in the script source code set by the processing device, respectively, to obtain a target script source code set.

When the processing equipment generates a target script source code set based on the script source code set, sequentially acquiring script source codes of all lines according to the compiling sequence of the script source codes of all lines in the script source code set, wherein each line of script source codes is acquired, and a preset debugging function is added to a specified position in the script source codes of the line, and the specified position can be before or after the script source codes of the line.

It should be noted that, in the embodiment of the present application, one line of script source codes corresponds to one preset debugging function, and the preset debugging functions added at specified positions in the script source codes of different lines may be the same.

For example, assuming that there is a debug function X, a preset debug function X may be added before each line of script source code, respectively.

For another example, assume that a line of script source code obtained by a processing device is:

var a = 1; // A variable a is defined and assigned a value of 1

Adding a preset debugging function in front of the obtained line of script source code to obtain a target script source code in the following schematic form, wherein the following pseudo code is only schematically illustrated:

withDebugger ("/test. js", X, isdibugerstatement); var a = 1; and/withdebug is a preset debugging function and is used for judging whether breakpoints exist in the X line in the/test.

{// denotes the beginning of the body of the function of the debug function withdebug

var with break point = break points [ file ] [ line ] | | isdebuggerstantent; // whether the current line has a breakpoint or is a debogger statement

if has a breakpoint;

sendXHR (); and/or when judging that a breakpoint exists in a currently executed line of target script source codes, sending an XHR request carrying context variable information to the processing equipment.

listentxhr (); if a response is requested, xhr is snooped and the target script source code continues to be executed

else directly executes the code;

denotes the end of the body of the function of the debug function withDebugger

It should be noted that, whether a breakpoint exists before the currently executed target script source code is determined, and the line number in the script source code set corresponding to the currently executed target script source code is used as a determination basis to implement correspondence with the breakpoint indication information.

Further, the processing device generates a target script source code set corresponding to the script source code set based on each line of script source code added with the debugging function.

For example, referring to fig. 3e, which is a schematic diagram of a source code set of a target script in this embodiment of the application, a script source code set obtained by a processing device may include multiple files, each file includes multiple lines of script source codes, and a preset debugging function is added to a specified position of each line of script source codes in each file, so as to obtain a source code set of a target script corresponding to the script source code set.

It should be noted that, in the embodiment of the present application, the operation sequence of step 3021, step 3022, and step 3023 is flexible, and in some possible embodiments of the present application, step 3023 may be executed first, and then step 3021 and step 3022 are executed; in other possible embodiments of the present application, step 3021 may be performed first, then step 3023 may be performed, and then step 3022 may be performed.

In this way, the processing device rewrites each line of script source codes in the script source code set to generate a target script source code set, so that each line of script source codes corresponds to the target script source codes and corresponds to the script source codes with preset debugging functions added at the specified positions, and the judgment statements of breakpoints can be executed before or after each line of target script source codes are executed, so that the target script source codes can be interrupted and executed at any position in the following process according to the actual configuration requirements.

Step 303: and the processing equipment sends the target script source code set and the breakpoint indication information to the first equipment so that the first equipment reports context variable information when the target script source code set is interrupted and executed based on the breakpoint indication information.

The processing equipment generates a target script source code set corresponding to the script source code set, acquires breakpoint indication information sent by the second equipment, and sends the target script source code set and the breakpoint indication information to the first equipment, so that when the first equipment executes the target script source code set, the execution of the target script source code set is interrupted at each breakpoint position indicated by the breakpoint indication information, and context variable information when the specified target script source code set is interrupted is reported.

Step 304: and the processing equipment sends the context variable information to the second equipment so that the second equipment debugs the page to be debugged based on the context variable information.

After receiving the context variable information sent by the first device, the processing device sends the obtained context variable information to the second device, so that the second device debugs the page to be debugged based on the obtained context variable information.

Specifically, refer to fig. 3f, which is a schematic operation diagram after receiving context information reported by the first device in the embodiment of the present application. When executing step 304, in the process of receiving the context variable information reported when the first device interrupts executing the target script source code set, the processing device performs the following operations every time the context variable information reported by the first device is received:

step 3041: and the processing equipment sends the currently received context variable information to the second equipment so that the second equipment debugs the page to be debugged based on the context variable information and displays the interrupt execution state of the first equipment.

And the processing equipment sends the currently received context variable information to the second equipment so that the second equipment debugs the page to be debugged based on the context variable information and displays the interrupt state of the first equipment on the second equipment.

Step 3042: and the processing device responds to the indication information of the target script source code set which is continuously executed and sent by the second device, and sends the indication information to the first device so as to enable the first device to continuously execute the target script source code set.

And after the second equipment initiates the instruction information for continuously executing the target script source code set, the processing equipment responds to the instruction information which is sent by the second equipment and used for continuously executing the target script source code set, and sends the instruction information to the first equipment so as to enable the first equipment to continuously execute the target script source code set.

Therefore, the processing device establishes a transmission path of real-time communication between the first device and the second device, can send the context variable information reported by the first device to the second device, can receive the indication information sent by the second device, and indicates the first device to continue executing the target script source code set, thereby ensuring the safe transmission of data in the debugging process.

It should be noted that, in this embodiment of the application, the data to be debugged, which is received by the processing device from the first device in the debugging process, is not limited to the script source code set of the page to be debugged, and may further include a Document Object Model (DOM), Style data, a network request, storage data, device environment data, and global variable data waiting for debugging data, where the Style data may specifically be Cascading Style Sheets (CSSs), the storage data may specifically be data (cookies) stored on a local terminal of a user, local storage data LocalStorage, session storage description sessiontarget, and the like.

The processing device receives various types of data to be debugged actively or passively sent by the first device and sends various types of debugging information to the second device for debugging, wherein the processing device can receive the script source code set of the page to be debugged after receiving other data to be debugged and can also receive the script source code set of the page to be debugged before receiving other debugging information. Since the various debugging information including the script source code set of the page to be debugged is independent of each other, the sequence of receiving the various data to be debugged can be configured according to the actual configuration requirement, and the application is not specifically limited herein.

In the following description, a debugging process of the processing device for a document object model and style data in data to be debugged after receiving a script source code set of a page to be debugged sent by the first device will be taken as an example and schematically described.

The processing equipment receives the document object model and the style data of the page to be debugged, which are sent by the first equipment, and forwards the document object model and the style data to the second equipment. Furthermore, the processing device performs corresponding processing specifically for different feedback data sent by the second device, and specifically, there may be the following two cases.

And in the first situation, the processing equipment receives a target object to be updated, which is sent by the second equipment and obtained after the target object in the document object model is modified.

In specific implementation, when the processing device receives a target object to be updated, which is sent by the second device and obtained after the target object in the document object model is modified, the processing device sends the target object to be updated to the first device.

Furthermore, the processing device generates a page screenshot of the page to be debugged according to the updated document object model and style data fed back by the first device, and sends the page screenshot to the second device, where the processing device may adopt a preset drawing tool, and obtain the page screenshot of the page to be debugged based on the updated document object model and style data, and the drawing tool may be a tool capable of generating the page based on the document object model and style data, such as a drawing tool of canvas series, specifically html2canvas and the like.

And in the second situation, the processing equipment receives target data to be updated, which is sent by the second equipment and obtained after the target data in the style data is modified.

In specific implementation, the processing device receives target data to be updated, which is sent by the second device and obtained after the target data in the style data is modified, and then sends the target data to be updated to the first device.

And then, generating a page screenshot of the page to be debugged according to the updated document object model and style data fed back by the first device, and sending the page screenshot to the second device, wherein a tool for generating the page screenshot may be the same as that in the case one, and is not described herein again.

Therefore, the processing equipment obtains the corresponding page screenshot based on the obtained updated document object model and style data, and then sends the page screenshot to the second equipment for displaying, so that the second equipment can preview the presentation effect of the modified document object model or style data in real time, the debugging of the page to be debugged can be assisted, and the debugging effect of the document object model and style data is ensured.

In some possible embodiments of the present application, after completing debugging of the page to be debugged, the processing device may generate an interactive instruction set capable of debugging the page to be debugged according to each interactive instruction between the processing device and the second device, and further send the interactive instruction set to the second device, so that the second device executes debugging operations of other pages to be debugged with reference to the interactive instruction set.

In specific implementation, the processing device may record all instruction information sent by the second device in the whole process of debugging the page to be debugged, generate a corresponding interactive instruction set based on all the obtained instruction information, and then send the generated interactive instruction set to the second device, so that the second device can refer to other pages to be debugged when debugging the pages.

It should be noted that, in the embodiment of the present application, the processing device sends the interactive instruction set to the second device interactive instruction set, so that when the second device is used for reference, the processing device may be inserted into the second device in the form of a functional module, so that the second device may automatically initiate a corresponding debugging instruction when using the functional module.

Therefore, the processing equipment integrates the interactive instruction set, so that the interactive instruction set capable of realizing the debugging function has portability, is favorable for systematization and regularization of the debugging function, is favorable for simplifying the complexity of the debugging process, and ensures the debugging effect of the page to be debugged.

Based on the same inventive concept, referring to fig. 4a, which is a schematic diagram of an operation flow of the second device in the page debugging process in the embodiment of the present application, the following describes, with reference to fig. 4a, a process of the second device executing page debugging in the embodiment of the present application:

step 401: and the second equipment receives a script source code set of the page to be debugged, which is sent by the processing equipment, wherein the script source code set is sent by the first equipment to the processing equipment after the address information of the page to be debugged is sent to the first equipment.

In some possible embodiments of the present application, after sending address information of a page to be debugged to a first device, a second device receives a script source set of the page to be debugged, where the script source set is sent to a processing device by the first device after receiving the address information of the page to be debugged.

For example, referring to fig. 4b, which is a schematic diagram of the second device inputting address information of a page to be debugged in the embodiment of the present application, in the webpage page illustrated in fig. 4b, the second device inputs the address information of the page to be debugged in an input box marked with a word "debug link" in front, and the content of the address information is: http:// webdebug.xx.com/demo/sdkSide/index.html, further triggering to send the address information to the first device, and receiving a script source code set sent by the processing device after the first device sends the script source code set of the page to be debugged corresponding to the address information to the processing device.

In some possible embodiments of the present application, in order to ensure secure interaction between the first device and the processing device, the second device may assist the processing device in performing authentication on the first device.

The following describes, with reference to the accompanying drawings, a process in which a second device receives a script source code set of a page to be debugged in the presence of authentication of a first device:

referring to fig. 4c, which is a schematic flowchart illustrating a process of obtaining, by a second device, a script source code set sent by a processing device in an embodiment of the present application, and referring to fig. 4c, a process of receiving the script source code set of a page to be debugged sent by the processing device is described in detail below:

step 4011: and the second equipment sends a debugging connection request to the processing equipment, wherein the debugging connection request carries the address information of the page to be debugged.

For example, as shown in fig. 4b, after the second device inputs the address information of the page to be debugged in the webpage shown in fig. 4b, the second device clicks to trigger the next operation, and the second device sends a debug connection establishment request carrying the address information of the page to be debugged to the processing device.

Step 4012: the second device acquires the coding information generated by the processing device based on the address information and sends the coding information to the first device, wherein the coding information is generated by the processing device corresponding to the address information and based on the address information and the encryption identification information after the encryption identification information is generated.

After acquiring the coded information sent by the processing device, the second device presents the coded information on a webpage and sends the coded information to the first device, wherein the coded information can be a two-dimensional code, a bar code or other forms of identifiable information.

It should be noted that, in this embodiment of the application, the second device sends the encoded information transmission process to the first device, without involving the participation of the processing device, and in the debugging process, all the instruction information and the data to be debugged between the second device and the first device are forwarded or processed through the processing device.

For example, refer to fig. 4d, which is a schematic diagram of a page displaying encoded information according to an embodiment of the present application. After the second device inputs the address information of the page to be debugged in the webpage illustrated in fig. 4d, clicking the next step, triggering to send the address information to the processing device, obtaining the two-dimensional code generated by the processing device based on the address information, and presenting the two-dimensional code in the webpage illustrated in fig. 4 d.

Step 4013: and the second equipment receives the script source code set of the page to be debugged, which is sent by the processing equipment.

After the second device sends the coding information to the first device, receiving a script source code set of the page to be debugged, which is sent by the processing device, wherein the script source code set is obtained based on the following operations: after the processing equipment completes the identity verification of the first equipment based on the connection establishment request which is sent by the first equipment and carries the encrypted identification information, the first equipment sends the script source code set to the processing equipment.

In this way, the script source code set obtained by the second device is sent after the processing device successfully authenticates the first device, which is equivalent to establishing a bidirectional transmission channel with the first device through the processing device, and thus, secure transmission of data to be debugged in the debugging process can be realized.

Step 402: and the second equipment marks the breakpoint positions in the script source code set, generates breakpoint indication information corresponding to the script source code set based on the marked breakpoint positions, and sends the breakpoint indication information to the processing equipment, so that the processing equipment sends the breakpoint indication information to the first equipment.

In specific implementation, after receiving a script source code set sent by a processing device, the second device marks the positions of all breakpoints in the script source code set according to actual processing requirements, generates breakpoint indication information corresponding to the script source code set based on the file names and the line numbers of all the marked breakpoints, and sends the generated breakpoint indication information to the first device via the processing device.

It should be noted that, in the embodiment of the present application, the breakpoint indication information may exist in a JSON file, and specifically includes a script source code file where the breakpoint is located, and a line number in the script source code file where the breakpoint is located.

For example, referring to fig. 4e, which is a schematic diagram of marking a breakpoint in a script source code set in the embodiment of the present application, according to an actual processing requirement, a second device marks a breakpoint at a specified position in the script source code set shown in fig. 4e, so as to obtain breakpoint indication information corresponding to the script source code set. Fig. 4e illustrates a connection state between the second device (the debugging device) and the processing device, a connection state between the first device (the debugged mobile terminal) and the processing device, and information such as a network type of the first device.

Step 403: and the second equipment receives the context variable information sent by the processing equipment, displays the interrupt execution state of the first equipment, and debugs the page to be debugged based on the context variable information, wherein the context variable information is that the first equipment interrupts the execution script source code set based on the breakpoint indication information and reports the interrupt execution script source code set to the processing equipment.

In specific implementation, after the second device sends the breakpoint indication information to the first device via the processing device, the second device receives context variable information forwarded by the processing device, and displays indication information of a target script source code set executed by the first device in an interrupted manner, where the context variable information is forwarded via the processing device, and the context variable information is sent at a breakpoint position indicated by the breakpoint indication information when the first device executes the target script source code set, where the context variable information may be environment variable information corresponding to the target script source code set executed by the first device in an interrupted manner.

In this embodiment of the application, the second device may determine the execution state of the first device according to actual needs, and when the first device interrupts executing the target script source code set, the second device may control whether the first device continues to execute the target script source code set.

Specifically, after receiving the context variable information sent by the processing device, the second device sends instruction information for continuing to execute the target script source code set to the processing device, so that the processing device sends the instruction information to the first device, where the instruction information is used to instruct the first device to continue to execute the target script source code set.

Therefore, after the second device configures the breakpoint indication information according to actual needs, the context variable information reported when the first device executes the target script source code set to the position marked with the breakpoint can be obtained, that is, the intermediate state when the first device runs the target script source code set is obtained, so that accurate debugging can be realized when a page to be debugged on the first device can be debugged subsequently based on the context variable information, and the accuracy of a debugging result is improved to a certain extent. Moreover, the second device can indicate whether the first device continues to execute the target script source code set or not through the processing device according to actual needs, so that the controllability of the debugging process is high, and the accurate debugging of the page to be debugged on the first device is facilitated.

It should be noted that, in debugging the page to be debugged on the first device, there may be multiple types of data to be debugged including script source code sets, such as document object models, style data, network requests, storage data, device environment data, and global variable data.

For the acquisition of other data to be debugged, in some possible embodiments of the present application, the second device may actively initiate an acquisition request to obtain the data to be debugged forwarded by the processing device, for example, the second device sends a console instruction. In other possible embodiments of the present application, the first device may report to the processing device actively, and receive data to be debugged sent by the processing device.

In the embodiment of the present application, since the various types of data to be debugged are independent from each other, the present application does not specifically limit the timing of acquiring the various types of data to be debugged.

In the following description, a process of debugging the document object model and the style data after the second device receives the script source code set of the page to be debugged sent by the processing device is taken as an example, and the following description is given:

after receiving the script source code of the page to be debugged, the second device may receive the document object model and the style data of the page to be debugged, which are sent by the processing device, where the second device processes the document object model and the style data, and the two situations are as follows:

and in the condition A, the second equipment modifies the target object in the document object model to obtain the target object to be updated.

In specific implementation, the processing device modifies the target object in the document object model to obtain a modified target object to be updated, and then sends the target object to be updated to the processing device, so that the processing device sends the target object to be updated to the first device.

And B, modifying the target data in the style data by the second equipment to obtain target data to be updated.

In specific implementation, the processing device modifies the target data in the style data to obtain modified target data to be updated, and then sends the target data to be updated to the processing device, so that the processing device sends the target data to be updated to the first device.

It should be noted that, because the document object model and the style data are mutually independent data to be debugged and correspond to the presentation effect of the page to be debugged, in the embodiment of the present application, in order to enable the second device to visually see the presentation effect of the debugged page on the first device during debugging, the page screenshot processed by the processing device may be received and presented on the web page, where the page screenshot may be presented on the web page of the second device in real time, after the second device modifies the data to be debugged that affects the presentation effect of the page to be debugged on the first device, the refresh operation on the page screenshot is simultaneously triggered, or the second device may set a refresh cycle of the page screenshot, and the periodic request processing device is based on the document object model and the style data obtained from the first device, the page screenshot is regenerated again, and the newly generated page screenshot is presented, and the manner of generating the page screenshot has been described in detail in the above description, which is not described herein again.

In some possible embodiments of the present application, when the processing device generates the interactive instruction set based on the interactive operation in the debugging process, the second device may receive the interactive instruction set sent by the processing device, and execute the debugging operation of the other page to be debugged based on the interactive instruction set.

Therefore, when the second device debugs the page to be debugged on other first devices, the second device can operate by referring to the instruction in the interactive instruction set, so that the debugging operation can be normalized, and the effective debugging process is facilitated.

Based on the same inventive concept, referring to fig. 5a, which is a schematic diagram of an operation flow of the first device in the page debugging process in the embodiment of the present application, the following describes, with reference to fig. 5a, an operation of the first device in the page debugging process in the embodiment of the present application:

step 501: the first device receives address information of the page to be debugged sent by the second device, and sends the script source code set of the page to be debugged to the processing device, so that the processing device sends the script source code set to the second device.

In specific implementation, after receiving address information of the page to be debugged sent by the second device, the first device sends the script source code set of the page to be debugged to the processing device, so that the processing device sends the script source code set to the first device, where an address of the processing device may be pre-configured for the first device, or the address of the processing device may be input on the first device by a relevant person.

It should be noted that, in the embodiment of the present application, a JS SDK may be pre-embedded in the first device, where the JS SDK is used for implementing debugging of a page to be debugged with the processing device and the second device, and an address of the processing device may be stored in the JS SDK, so as to send information to the processing device based on the address.

In some possible embodiments of the present application, in order to ensure secure transmission with the processing device, before sending the script source code set of the page to be debugged to the processing device, the first device may first pass authentication of the processing device.

Referring to fig. 5b, which is a schematic diagram of a process of sending a script source code set in the embodiment of the present application, the following description is provided with reference to fig. 5b, and the process of sending the script source code set is described:

step 5011: the method comprises the steps that first equipment receives coding information sent by second equipment, and after the second equipment sends a debugging connection establishment request carrying address information of a page to be debugged to processing equipment, the processing equipment generates the coding information based on encryption identification information generated by the address information and corresponding address information, and sends the coding information to the second equipment.

The first device receives the encoded information sent by the second device, where the encoded information may be a two-dimensional code, a barcode, or other identifiable information, and a generation process of the encoded information is described in detail in the foregoing description, and will not be described again here.

In this embodiment, when the first device receives the encoded information sent by the second device, the encoded data is not transmitted through the processing device.

For example, as illustrated in fig. 2b, to debug the page to be debugged, a debugging platform application may be installed, and after logging in the debugging platform application, the first device can receive the encoded information sent by the second device on the chat interaction page.

Step 5012: the first device identifies the coding information and acquires the encryption identification information and the address information of the page to be debugged, which are included in the coding information.

In specific implementation, after receiving the coding information, the first device identifies the coding information and acquires the encryption identification information and the address information of the page to be debugged, which are included in the coding information.

For example, assuming that the encoded information is two-dimensional code information, the first device may recognize the two-dimensional code information by using a manner of recognizing a two-dimensional code in a browser, for example, to obtain encrypted identification information included in the two-dimensional code information and address information of a page to be debugged.

Step 5013: the first equipment sends a connection establishment request carrying encrypted identification information to the processing equipment, and sends a script source code set of the page to be debugged to the processing equipment after confirming that identity authentication is completed on the processing equipment based on the encrypted identification information.

In specific implementation, after obtaining the encrypted identification information and the address information of the page to be debugged, the first device sends a connection establishment request carrying the encrypted identification information to the processing device, so as to implement identity authentication on the processing device based on the encrypted identification information. And then after the identity authentication is finished, sending the script source code set of the page to be debugged corresponding to the address information to the processing equipment.

Therefore, after the first device completes identity authentication on the processing device based on the encrypted identification information, the script source code set to be debugged is sent to the processing device, and the safe debugging process is guaranteed.

Step 502: the method comprises the steps that a first device receives a target script source code set and breakpoint indication information corresponding to the script source code set, wherein the target script source code set is obtained by respectively adding preset debugging functions to specified positions in script source codes of all lines contained in the script source code set, and the breakpoint indication information is generated by a second device based on breakpoint positions marked in the script source code set.

After the script source code set of the page to be debugged is sent to the processing device by the first device, receiving target debugging script source codes obtained after a preset debugging function is added to the designated positions of the script source codes of each line in the script source code set by the processing device, and receiving breakpoint indication information generated by the second device forwarded by the processing device, wherein the generation of the target debugging script set and the breakpoint indication information is described in detail in the above contents, and is not described herein again.

Step 503: and the first equipment matches the position of one line of script source codes with the breakpoint position in the breakpoint indication information in each line of target script source code execution set corresponding to one line of script source codes in the script source code set, interrupts the execution of the target script source code set after the matching is successful, and sends the current context variable information to the processing equipment.

After receiving the target script source code set, the first device matches the position of the script source code in the script source code set with the breakpoint position in the breakpoint indication information every time a line of target script source codes corresponding to a line of script source codes in the script source code set is executed, and after the successful matching is determined, the execution of the line of target script source codes and subsequent target script source codes in the target script source code set are interrupted, and context variable information in the current interrupted running state is reported to the processing device.

Therefore, by means of the target script source code set obtained by processing of the processing device and the interrupt indication information used for indicating the interrupt position, the first device can interrupt execution of the target script source code set at any specified interrupt position and report the context variable information in the corresponding interrupt running state, so that the intermediate state during running of the target script source code can be reported, the information of the intermediate state can be obtained in the debugging process, and the accuracy of page debugging is improved to a certain extent.

And further, the first device receives indication information of continuing to execute the target script source code set, which is sent by the processing device, and continues to execute the target script source code set, wherein the indication information is sent by the second device to the processing device.

In the embodiment of the application, after the first device interrupts executing the target script source code set, and after receiving the instruction information for continuing to execute the target script source code set, the first device continues to execute the target script source code set, wherein the instruction for instructing the first device to continue executing the target script source code is initiated by the second device and forwarded by the processing device.

In this way, for the debugged mobile terminal (first device) and the debugging device (second device) in the debugging process, the second device may control the progress of the debugging process, and indirectly instruct the first device to execute the target script source code set via the processing device, so that the debugging process is more flexible.

It should be noted that, in this embodiment of the application, for a page to be debugged on the first device, there are multiple types of data to be debugged including a script source code set, and the multiple types of data to be debugged are independent of each other, and an order in which the first device sends the multiple types of data to be debugged to the processing device is very flexible.

The following describes a process of sending other types of data to be debugged by the first device, taking an example that the first device sends the document object model and the style data after sending the script source code set of the page to be debugged to the processing device.

The first device sends the document object model and the style data of the page to be debugged to the processing device, so that the processing device forwards the document object model and the style data to the second device.

In some possible embodiments of the present application, when receiving a target object to be updated sent by a processing device, a first device updates a corresponding object in a document object model based on the target object to be updated, and sends the updated document object model and style data to the processing device, where the target object to be updated is sent to the processing device after a second device modifies based on the document object model.

In other possible embodiments of the present application, when receiving target data to be updated sent by a processing device, a first device updates corresponding content in style data based on the target data to be updated, and sends the updated document object model and style data to the processing device, where the target data to be updated is sent to the processing device after a second device modifies based on the style data.

Therefore, the first device can receive the modified document object model and the style data, so that the updating of corresponding contents is completed, and the effective debugging process is ensured.

Based on the same inventive concept, refer to fig. 6a, which is an interaction timing chart of a page debugging process in the embodiment of the present application. With reference to fig. 6a, an interaction flow between a debugged mobile terminal (first device), a debugging device (second device), and a debugging server (processing device) when performing page debugging in the embodiment of the present application is described below.

Step 601: and the debugging equipment sends the URL of the page to be debugged to the debugging server.

The debugging equipment acquires Uniform Resource Locator (URL) of a page to be debugged and sends the URL information to the debugging server.

Step 602: the debug server generates encoded information based on the URL and the encrypted identification information.

In specific implementation, the debugging server generates encrypted identification information for the obtained address information of the page to be debugged, and records the encrypted identification information as token, and then the debugging server generates coding information based on the URL and the token, wherein the coding information may be a two-dimensional code, a bar code, or other identifiable information.

Step 603: and the debugging server sends the coding information to the debugging equipment.

Step 604: and the debugging equipment sends the coding information to the debugged mobile terminal.

It should be noted that, in the embodiment of the present application, when the debugging device sends the encoding information to the device to be debugged, the debugging server does not participate in the transmission process of the encoding information.

Step 605: and the debugged mobile terminal sends a websocket request carrying the encrypted identification information to the debugging server.

In specific implementation, after the to-be-debugged device scans the coding information to obtain the encrypted identification information, the JS SDK inside the to-be-debugged device initiates communication with the web socket of the to-be-debugged device after detecting the encrypted identification information.

Step 606: and the debugging server carries out identity verification on the debugged mobile terminal based on the encrypted identification information.

Step 607: and the debugging server sends a connection instruction for establishing the websocket communication to the equipment to be debugged.

Step 608: and the debugged mobile terminal sends the script source code set of the page corresponding to the URL to the debugging server.

Step 609: and the debugging server sends the script source code set of the page corresponding to the URL to the debugging equipment.

Step 610: and the debugging server rewrites the script source code set into a target script source code set.

In specific implementation, the debugging server adds each line of script source codes to a corresponding debugging function through AST source code analysis, and then obtains a rewritten target script source code set based on each debugging function added with the script source codes.

Step 611: and the debugging server sends the rewritten target script source code set to the debugged mobile terminal.

Step 612: and the debugging equipment sends the breakpoint indication information to a debugging server.

When the method is specifically implemented, relevant personnel debug the equipment according to actual processing requirements. After adding breakpoints at each corresponding position in the script source code set, the debugging equipment generates breakpoint indication information corresponding to the script source code set, and the breakpoint indication information is used for recording files and line numbers of the breakpoints.

Step 613: and the debugging server sends the breakpoint identification information to the debugged mobile terminal.

Step 614: and the debugged mobile terminal reads the breakpoint indication information and executes the target script source code set.

Step 615: and the device to be debugged sends the local variables of the terminal execution target script source code set to a debugging server.

In specific implementation, the device to be debugged executes the rewritten target script source code set, wherein each line of target script source codes is executed And matched with breakpoint indication information in the memory, if the matching is determined to be successful, an XHR (XMLHttpRequest) request is sent to the debugging server, the execution of the target script source code set is interrupted, And the current context local variable is sent to the debugging server, wherein the XHR request is a JavaScript API for creating Asynchronous JavaScript And XML (Asynchronous JavaScript And XML, AJAX) requests, And provides the capability of sending requests between the browser And the server. Otherwise, if the matching is unsuccessful, the target script source code set is continuously read.

Step 616: and the server to be debugged sends the local variable when the script source code set of the execution target is interrupted to the debugging equipment.

In the embodiment of the application, after receiving an XHR request sent by a device to be debugged, a debugging server displays that the current device to be debugged is in an operation interruption state, displays a local variable, and waits to receive an instruction for continuing to operate a target script source code set.

Step 617: and the debugging equipment sends an instruction for continuously executing the target script source code set to a debugging server.

Step 618: and the debugging server sends the instruction for continuously executing the target script source code set to the equipment to be debugged.

Based on the same inventive concept, refer to fig. 6b, which is a timing diagram for receiving data to be debugged and displaying a screenshot of a page in real time in the embodiment of the present application.

Step 1: and the debugging equipment sends the data acquisition instruction to be debugged to the debugging server.

It should be noted that the debug data acquisition instruction may specifically be an edited console instruction, or may be an operation triggered based on modification and debugging of a part of the content.

Step 2: and the debugging server sends the data acquisition instruction to be debugged to the debugged mobile terminal.

And step 3: and the debugging equipment sends the corresponding data to be debugged to a debugging server.

It should be noted that, in the embodiment of the present application, the data to be debugged may be a network request, a DOM structure, cookie data, device environment information, a script source code set, and the like.

And 4, the debugging server sends the data to be debugged to the debugging equipment.

And 5: and the debugging equipment sends the modified text object model or the style data to a debugging server.

Step 6: and the debugging server sends the modified text object model or the style data to the debugged mobile terminal.

And 7: the debugged mobile terminal sends the latest text object model and style data to the debugging server.

It should be noted that, for the execution of step 7, the debugged mobile terminal may perform relevant operations in response to the page refresh request sent by the debugging device and forwarded by the processing device.

And 8: the debugging server draws the page screenshot based on the latest text object model and style data.

And step 9: and the debugging server sends the page screenshot to the debugging equipment.

Based on the same inventive concept, the embodiment of the present application further provides a page debugging apparatus, and a principle for solving the problem by the apparatus is the same as that of the page debugging method on the processing device side, so that the implementation of the apparatus may refer to the implementation of the method, and repeated details are not described again.

Referring to fig. 7, which is a schematic diagram of a logic structure of a page debugging apparatus according to an embodiment of the present disclosure, a page debugging apparatus 700 may include:

a first receiving unit 701, configured to receive a script source code set of a page to be debugged, where the script source code set is sent by a first device after the first device receives address information of the page to be debugged, where the address information is sent by a second device;

an obtaining unit 702, configured to send the script source code set to the second device, and obtain breakpoint indication information returned by the second device based on the script source code set, and add a preset debugging function to specified positions in each line of script source codes included in the script source code set, respectively, to obtain a target script source code set;

a first sending unit 703, configured to send the target script source code set and the breakpoint indication information to the first device, so that the first device reports context variable information when the target script source code set is interrupted and executed based on the breakpoint indication information;

the second sending unit 704 sends the context variable information to the second device, so that the second device debugs the page to be debugged based on the context variable information.

Optionally, when receiving a script source code set of a page to be debugged sent by the first device, the receiving unit 701 is configured to:

receiving a connection establishment request which is sent by first equipment and carries encrypted identification information, and carrying out identity authentication on the first equipment based on the encrypted identification information;

and if the verification is confirmed to pass, receiving a script source code set of the page to be debugged, which is sent by the first equipment.

Optionally, when a preset debugging function is added to each specified position in each line of script source codes included in the script source code set to obtain the target script source code set, the obtaining unit 702 is configured to:

sequentially acquiring script source codes of each line according to the compiling sequence of the script source codes of each line in the script source code set, wherein each line of script source codes is acquired, and a preset debugging function is added to a specified position in each line of script source codes;

Optionally, after receiving the script source code set of the page to be debugged sent by the first device, the obtaining unit 702 is further configured to:

receiving a document object model and style data of a page to be debugged, which are sent by first equipment, and forwarding the document object model and the style data to second equipment;

if a target object to be updated, which is sent by the second equipment and obtained after a target object in the document object model is modified, is received, sending the target object to be updated to the first equipment, generating a page screenshot of a page to be debugged according to the updated document object model and style data fed back by the first equipment, and sending the page screenshot to the second equipment;

and if target data to be updated, which is sent by the second equipment and obtained after the target data in the style data is modified, is received, sending the target data to be updated to the first equipment, generating a page screenshot of the page to be debugged according to the updated document object model and the style data fed back by the first equipment, and sending the page screenshot to the second equipment.

Optionally, in the process of receiving context variable information reported when the first device interrupts executing the target script source code set, the first sending unit 703 is configured to:

the following operations are executed every time the context variable information reported by the first equipment is received:

sending the currently received context variable information to second equipment, so that the second equipment debugs a page to be debugged based on the context variable information, and displaying an interrupt execution state of the first equipment;

and responding to the indication information of the target script source code set which is continuously executed and sent by the second equipment, sending the indication information to the first equipment so as to enable the first equipment to continuously execute the target script source code set.

Optionally, after completing the debugging of the page to be debugged, the apparatus further includes a first processing unit, and the first processing unit 705 is configured to:

and sending the interactive instruction set to the second equipment so that the second equipment refers to the interactive instruction set to execute debugging operation of other pages to be debugged.

Based on the same inventive concept, the embodiment of the present application further provides a page debugging apparatus, and because the principle of the apparatus for solving the problem is similar to the page debugging method of the second device side, the implementation of the apparatus may refer to the implementation of the method, and repeated details are not described again.

Referring to fig. 8, which is a schematic diagram of a logic structure of a page debugging apparatus according to an embodiment of the present disclosure, a page debugging apparatus 800 may include:

the second receiving unit 801 is configured to receive a script source code set of a page to be debugged, where the script source code set is sent by a processing device, and after address information of the page to be debugged is sent to a first device, the first device sends the address information to the processing device;

a generating unit 802, which marks breakpoint positions in the script source code set, generates breakpoint indication information corresponding to the script source code set based on the marked breakpoint positions, and sends the breakpoint indication information to the processing device, so that the processing device sends the breakpoint indication information to the first device;

the debugging unit 803 receives context variable information sent by the processing device, displays an interrupted execution state of the first device, and debugs a page to be debugged based on the context variable information, where the context variable information is that the first device interrupts executing the script source code set based on the breakpoint indication information and reports the interrupted execution script source code set to the processing device.

Optionally, when receiving the script source code set of the page to be debugged sent by the processing device, the second receiving unit 801 is configured to:

acquiring coding information generated by the processing equipment based on the address information, and sending the coding information to the first equipment, wherein the coding information is generated based on the address information and the encryption identification information after the encryption identification information is generated by the processing equipment corresponding to the address information;

receiving a script source code set of a page to be debugged, which is sent by a processing device, wherein the script source code set is obtained based on the following operations: after the processing equipment completes the identity verification of the first equipment based on the connection establishment request which is sent by the first equipment and carries the encrypted identification information, the first equipment sends the script source code set to the processing equipment.

Optionally, after receiving the script source code set of the page to be debugged sent by the processing device, the second receiving unit 801 is further configured to:

receiving a document object model and style data of a page to be debugged, which are sent by processing equipment;

Optionally, after receiving the context variable information sent by the processing device, the debugging unit 803 is further configured to:

and sending indication information for continuing to execute the target script source code set to the processing device so as to enable the processing device to send the indication information to the first device, wherein the indication information is used for indicating the first device to continue to execute the target script source code set.

Optionally, after completing the debugging of the page to be debugged, the apparatus further includes a second processing unit 804, where the second processing unit 804 is configured to:

Based on the same inventive concept, the embodiment of the present application further provides a page debugging apparatus, and as the principle of the apparatus for solving the technical problem is the same as the page debugging method of the first device side, the implementation of the apparatus may refer to the implementation of the method, and repeated details are not described again.

Referring to fig. 9, which is a schematic diagram of a logic structure of a page debugging apparatus according to an embodiment of the present disclosure, a page debugging apparatus 900 may include:

a third receiving unit 901, configured to receive address information of the page to be debugged sent by the second device, and send a script source code set of the page to be debugged to the processing device, so that the processing device sends the script source code set to the second device;

a fourth receiving unit 902, configured to receive a target script source code set and breakpoint indication information corresponding to the script source code set, where the target script source code set is obtained by adding a preset debugging function to a specified position in each line of script source codes included in the script source code set, and the breakpoint indication information is generated by the second device based on a breakpoint position marked in the script source code set;

and the matching unit 903 matches the position of one line of script source codes with the breakpoint position in the breakpoint indication information in each line of target script source code executing set corresponding to one line of script source codes in the script source code set, and after the matching is determined to be successful, interrupts the execution of the target script source code set and sends the current context variable information to the processing device.

Optionally, when receiving address information of a page to be debugged sent by the second device and sending a script source code set of the page to be debugged to the processing device, the third receiving unit 901 is configured to:

receiving coding information sent by second equipment, wherein after the second equipment sends a debugging connection establishment request carrying address information of a page to be debugged to processing equipment, the processing equipment generates the coding information based on the address information and encrypted identification information generated by the corresponding address information, and sends the coding information to the second equipment;

identifying coding information, and acquiring encryption identification information and address information of a page to be debugged, wherein the encryption identification information and the address information are included in the coding information;

and sending a connection establishment request carrying the encrypted identification information to the processing equipment, and sending the script source code set of the page to be debugged to the processing equipment after confirming that the identity authentication is completed on the processing equipment based on the encrypted identification information.

Optionally, after sending the script source code set of the page to be debugged to the processing device, the third receiving unit 901 is further configured to:

sending the document object model and the style data of the page to be debugged to the processing equipment so that the processing equipment forwards the document object model and the style data to the second equipment;

and if the target data to be updated sent by the processing equipment is received, updating the corresponding content in the style data based on the target data to be updated, and sending the updated document object model and the style data to the processing equipment, wherein the target data to be updated is sent to the processing equipment after the second equipment is modified based on the style data.

Optionally, after sending the current context variable information to the processing device, the matching unit 903 is further configured to:

and receiving indication information of continuing to execute the target script source code set, which is sent by the processing equipment, and continuing to execute the target script source code set, wherein the indication information is sent to the processing equipment by the second equipment.

For convenience of description, the above parts are separately described as modules (or units) according to functional division. Of course, the functionality of the various modules (or units) may be implemented in the same one or more pieces of software or hardware when implementing the present application.

As will be appreciated by one skilled in the art, each aspect of the present application may be embodied as a system, method or program product. Accordingly, each aspect of the present application may be embodied in the form of: an entirely hardware embodiment, an entirely software embodiment (including firmware, microcode, etc.) or an embodiment combining hardware and software aspects that may all generally be referred to herein as a "circuit," module "or" system.

In some possible implementations, referring to fig. 10, which is a schematic diagram illustrating a hardware structure of an electronic device according to an embodiment of the present disclosure, the electronic device 1000 may include at least one processor 1001 and at least one memory 1002. The memory 1002 stores therein program codes, which, when executed by the processor 1001, cause the processor 1001 to perform the steps in the page display method according to various exemplary embodiments of the present application described above in the present specification, for example, the processor 1001 may perform the steps as shown in fig. 3a-3c, 3f, 4a, 4c, 5a-5 b.

In some possible implementations, the present application further provides a computing device, which may include at least one processing unit and at least one storage unit. Wherein the storage unit stores program code which, when executed by the processing unit, causes the processing unit to perform the steps in the data page display according to various exemplary embodiments of the present application described above in this specification, for example, the processor 1001 may perform the steps as shown in fig. 3a-3c, 3f, 4a, 4c, 5a-5 b.

A computing device 1100 according to this embodiment of the present application is described below with reference to fig. 11. The computing device 1100 of FIG. 11 is only one example and should not be taken to limit the scope of use or functionality of embodiments of the present application.

Fig. 11 is a schematic structural diagram of a computing device in the embodiment of the present application. Computing device 1100 is represented in the form of a general purpose computing device. Computing device 1100 is represented in the form of a general purpose computing device. Components of computing device 1100 may include, but are not limited to: the at least one processing unit 1101, the at least one memory unit 1102, and a bus 1103 connecting different system components (including the memory unit 1102 and the processing unit 1101).

Bus 1103 represents one or more of any of several types of bus structures, including a memory bus or memory controller, a peripheral bus, and a processor or local bus using any of a variety of bus architectures.

The storage unit 1102 may include readable media in the form of volatile memory, such as Random Access Memory (RAM) 11021 and/or cache storage unit 11022, and may further include Read Only Memory (ROM) 11023.

The memory unit 1102 may also include a program/utility 11025 having a set (at least one) of program modules 11024, such program modules 11024 including, but not limited to: an operating system, one or more application programs, other program modules, and program data, each of which, or some combination thereof, may comprise an implementation of a network environment.

The computing device 1100 may also communicate with one or more external devices 1104 (e.g., keyboard, pointing device, etc.), with one or more devices that enable a user to interact with the computing device 1100, and/or with any devices (e.g., router, modem, etc.) that enable the computing device 1100 to communicate with one or more other computing devices. Such communication may occur via input/output (I/O) interfaces 1105. Moreover, the computing device 1100 may also communicate with one or more networks (e.g., a Local Area Network (LAN), a Wide Area Network (WAN), and/or a public network, such as the internet) via the network adapter 1106. As shown, the network adapter 1106 communicates with other modules for the computing device 1100 over the bus 1103. It should be understood that although not shown in the figures, other hardware and/or software modules may be used in conjunction with the computing device 1100, including but not limited to: microcode, device drivers, redundant processors, external disk drive arrays, RAID systems, tape drives, and data backup storage systems, among others.

In some possible embodiments, each aspect of the page display method provided by the present application may also be implemented in the form of a program product including program code for causing a computer device to perform the steps of the page display method according to various exemplary embodiments of the present application described above in this specification when the program product is run on the computer device, for example, the computer device may include the steps shown in fig. 3a-3c, 3f, 4a, 4c, 5a-5 b.

The program product may employ any combination of one or more readable media. The readable medium may be a readable signal medium or a readable storage medium. A readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples (a non-exhaustive list) of the readable storage medium include: an electrical connection having one or more wires, a portable 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 disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

While the preferred embodiments of the present application have been described, additional variations and modifications in those embodiments may occur to those skilled in the art once they learn of the basic inventive concepts. Therefore, it is intended that the appended claims be interpreted as including preferred embodiments and all alterations and modifications as fall within the scope of the application.

It will be apparent to those skilled in the art that various changes and modifications may be made in the present application without departing from the spirit and scope of the application. Thus, if such modifications and variations of the present application fall within the scope of the claims of the present application and their equivalents, the present application is intended to include such modifications and variations as well.

Claims

1. A page debugging method is applied to a processing device, and comprises the following steps:

2. The method of claim 1, wherein receiving the set of script source code for the page to be debugged sent by the first device comprises:

3. The method of claim 1, wherein the obtaining a target script source code set by adding preset debugging functions to specified positions in each line of script source code included in the script source code set respectively comprises:

4. The method according to any one of claims 1 to 3, wherein after receiving the script source code set of the page to be debugged sent by the first device, the method further comprises:

5. The method of any one of claims 1-3, wherein in receiving context variable information reported by the first device when the first device interrupted execution of the set of target script source code, comprising:

6. The method of any of claims 1-3, wherein after completing debugging of the page to be debugged, further comprising:

7. A page debugging method is applied to a second device and comprises the following steps:

8. The method of claim 7, wherein receiving the script source code set for the page to be debugged sent by the processing device comprises:

9. A page debugging method is applied to a first device and comprises the following steps:

10. The method of claim 9, wherein the receiving address information of the page to be debugged sent by the second device and sending the script source code set of the page to be debugged to the processing device comprises:

11. A page debugging apparatus, comprising:

12. A page debugging apparatus, comprising:

13. A page debugging apparatus, comprising:

14. An electronic device, comprising a processor and a memory, wherein the memory stores program code which, when executed by the processor, causes the processor to perform the steps of the method of any of claims 1 to 6, or causes the processor to perform the steps of the method of any of claims 7 to 8, or causes the processor to perform the steps of the method of any of claims 9 to 10.

15. Computer readable storage medium, characterized in that it comprises program code for causing an electronic device to perform the steps of the method of any of claims 1 to 6, or to perform the steps of the method of any of claims 7 to 8, or to perform the steps of the method of any of claims 9 to 10, when said program product is run on said electronic device.