CN114371848A - Page joint debugging method, device, equipment and storage medium - Google Patents
Page joint debugging method, device, equipment and storage medium Download PDFInfo
- Publication number
- CN114371848A CN114371848A CN202210043707.5A CN202210043707A CN114371848A CN 114371848 A CN114371848 A CN 114371848A CN 202210043707 A CN202210043707 A CN 202210043707A CN 114371848 A CN114371848 A CN 114371848A
- Authority
- CN
- China
- Prior art keywords
- page
- debugged
- script
- search
- configuration data
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Withdrawn
Links
- 238000000034 method Methods 0.000 title claims abstract description 69
- 230000001172 regenerating effect Effects 0.000 claims abstract description 21
- 230000001960 triggered effect Effects 0.000 claims description 20
- 230000008859 change Effects 0.000 claims description 10
- 230000004044 response Effects 0.000 claims description 8
- 238000004590 computer program Methods 0.000 claims description 4
- 230000000153 supplemental effect Effects 0.000 claims description 4
- 238000011161 development Methods 0.000 abstract description 4
- 238000010586 diagram Methods 0.000 description 7
- 238000012986 modification Methods 0.000 description 5
- 230000004048 modification Effects 0.000 description 5
- 230000008569 process Effects 0.000 description 5
- 230000006870 function Effects 0.000 description 4
- 238000012545 processing Methods 0.000 description 4
- 230000008878 coupling Effects 0.000 description 3
- 238000010168 coupling process Methods 0.000 description 3
- 238000005859 coupling reaction Methods 0.000 description 3
- 230000009286 beneficial effect Effects 0.000 description 2
- 238000004891 communication Methods 0.000 description 2
- 238000012217 deletion Methods 0.000 description 2
- 230000037430 deletion Effects 0.000 description 2
- 230000000694 effects Effects 0.000 description 2
- 230000008676 import Effects 0.000 description 2
- 239000013589 supplement Substances 0.000 description 2
- 244000166124 Eucalyptus globulus Species 0.000 description 1
- 238000007792 addition Methods 0.000 description 1
- 238000004458 analytical method Methods 0.000 description 1
- 238000003491 array Methods 0.000 description 1
- 230000002457 bidirectional effect Effects 0.000 description 1
- 238000006243 chemical reaction Methods 0.000 description 1
- 238000013524 data verification Methods 0.000 description 1
- 238000005111 flow chemistry technique Methods 0.000 description 1
- 238000007726 management method Methods 0.000 description 1
- 238000012544 monitoring process Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/38—Creation or generation of source code for implementing user interfaces
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/35—Creation or generation of source code model driven
- G06F8/355—Round-trip engineering
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/36—Software reuse
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Human Computer Interaction (AREA)
- Stored Programmes (AREA)
Abstract
The application provides a page joint debugging method, device, equipment and storage medium, and relates to the technical field of internet. The method comprises the following steps: acquiring a script file of a page to be debugged; generating a configuration file of the page to be debugged according to the script file, wherein the configuration file comprises: configuration data of the script file; and regenerating the page to be debugged according to the configuration file corresponding to the modified configuration data so as to debug the page to be debugged. Compared with the prior art, the problem of low development efficiency of the page is avoided.
Description
Technical Field
The application relates to the technical field of internet, in particular to a page joint debugging method, device, equipment and storage medium.
Background
Before the pages are presented to people, the pages which are finally presented to people can be generated only by developing debugging and configuration for a period of time, and each page needs debugging and configuration of a developer one by one.
In the prior art, a common pc end management system has a large number of add-delete-modify-Check (CRUD), each page needs to write html, js and css, a common input box at the front end of a web needs to write patterns, verify data, bind events, and enable a DOM structure and a browser to be compatible, and a large number of repeated codes are generated. And later, through the setting of the UI library, a framework of componentization ideas is developed, the style and the DOM structure are unified, a lot of repeated codes are reduced, and the development efficiency is improved.
However, the way of writing pages in the industrial era of componentization is to write DOM and CSS codes, and one page needs to be written into three parts respectively, or to introduce many UI components, so that development efficiency still needs to be improved.
Disclosure of Invention
An object of the present application is to provide a method, an apparatus, a device, and a storage medium for page joint debugging, so as to solve the problem of low development efficiency of pages in the prior art.
In order to achieve the above purpose, the technical solutions adopted in the embodiments of the present application are as follows:
in a first aspect, an embodiment of the present application provides a page joint debugging method, where the method includes:
acquiring a script file of a page to be debugged;
generating a configuration file of the page to be debugged according to the script file, wherein the configuration file comprises: configuration data of the script file;
and regenerating the page to be debugged according to the configuration file corresponding to the modified configuration data so as to debug the page to be debugged.
Optionally, the page to be debugged is a search page, and the script file includes: searching the script; the regenerating the page to be debugged according to the configuration file corresponding to the modified configuration data to debug the page to be debugged includes:
generating a search component according to the modified configuration data of the search script;
and regenerating a search control in the page to be debugged according to the search component so as to debug the page to be debugged.
Optionally, the script file further includes: listing a script; the regenerating the page to be debugged according to the configuration file corresponding to the modified configuration data to debug the page to be debugged includes:
generating a paging list component according to the modified configuration data of the list script;
and respectively regenerating a search control and a query list in the page to be debugged according to the search component and the paging list component so as to debug the page to be debugged.
Optionally, the method further comprises:
responding to the triggering operation of the search control, and acquiring a request event triggered by the configuration data of the search script;
and generating a query result corresponding to the request event in a query list on the page.
Optionally, before the triggering operation of the response search control and the request event triggered by the configuration data of the search script are acquired, the method further includes:
acquiring an object array in the configuration data of the search script;
the acquiring a request event triggered by configuration data of the search script in response to the triggering operation of the search control comprises:
and responding to the triggering operation of the search control, and acquiring a corresponding request event triggered by the object array.
Optionally, the modifying operation comprises at least one of: a supplemental operation, a sort operation, a modify dynamic component operation, a delete operation, a modify operation, or a verify operation.
Optionally, the method further comprises:
and responding to the change operation of the object array, and triggering a request event corresponding to the changed object array.
In a second aspect, another embodiment of the present application provides a page joint debugging apparatus, including: the device comprises an acquisition module and a generation module, wherein:
the acquisition module is used for acquiring a script file of a page to be debugged;
the generating module is configured to generate a configuration file of the page to be debugged according to the script file, where the configuration file includes: configuration data of the script file; and regenerating the page to be debugged according to the modified configuration data so as to debug the page to be debugged.
Optionally, the page to be debugged is a search page, and the script file includes: searching the script; the generating module is specifically used for generating a search component according to the modified configuration data of the search script; and regenerating a search control in the page to be debugged according to the search component so as to debug the page to be debugged.
Optionally, the script file further includes: listing a script; the generating module is specifically configured to generate a paging list component according to the modified configuration data of the list script; and respectively regenerating a search control and a query list in the page to be debugged according to the search component and the paging list component so as to debug the page to be debugged.
Optionally, the obtaining module is specifically configured to obtain, in response to a trigger operation of a search control, a request event triggered by configuration data of the search script;
the generating module is specifically configured to generate a query result corresponding to the request event in a query list on the page.
Optionally, the obtaining module is specifically configured to obtain an object array in the configuration data of the search script; and responding to the triggering operation of the search control, and acquiring a corresponding request event triggered by the object array.
Optionally, the modifying operation comprises at least one of: a supplemental operation, a sort operation, a modify dynamic component operation, a delete operation, a modify operation, or a verify operation.
Optionally, the apparatus further comprises: and the triggering module is used for responding to the change operation of the object array and triggering the changed request event corresponding to the object array.
In a third aspect, another embodiment of the present application provides a page joint debugging device, including: a processor, a storage medium and a bus, wherein the storage medium stores machine-readable instructions executable by the processor, when the page tuning device runs, the processor and the storage medium communicate with each other through the bus, and the processor executes the machine-readable instructions to perform the steps of the method according to any one of the first aspect.
In a fourth aspect, another embodiment of the present application provides a storage medium having a computer program stored thereon, where the computer program is executed by a processor to perform the steps of the method according to any one of the above first aspects.
The beneficial effect of this application is: by adopting the page joint debugging method provided by the application, the page to be debugged is generated according to the modified configuration file, the configuration file is automatically generated according to the script file and forms a standardized format, when the user needs to joint debug the page to be debugged, only the configuration data needs to be directly modified in the configuration file, and each component does not need to be modified and configured by taking the component as a unit, so that the joint debugging efficiency is greatly saved.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings that are required to be used in the embodiments will be briefly described below, it should be understood that the following drawings only illustrate some embodiments of the present application and therefore should not be considered as limiting the scope, and for those skilled in the art, other related drawings can be obtained from the drawings without inventive effort.
Fig. 1 is a schematic flowchart of a page joint debugging method according to an embodiment of the present application;
fig. 2 is a schematic flowchart of a page joint debugging method according to another embodiment of the present application;
fig. 3 is a schematic flowchart of a page joint debugging method according to another embodiment of the present application;
fig. 4 is a schematic flowchart of a page joint debugging method according to another embodiment of the present application;
fig. 5 is a schematic structural diagram of a page joint debugging apparatus according to an embodiment of the present application;
fig. 6 is a schematic structural diagram of a page joint debugging apparatus according to another embodiment of the present application;
fig. 7 is a schematic structural diagram of a page joint debugging device according to 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 in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it is obvious that the described embodiments are some embodiments of the present application, but not all embodiments.
The components of the embodiments of the present application, generally described and illustrated in the figures herein, can be arranged and designed in a wide variety of different configurations. Thus, the following detailed description of the embodiments of the present application, presented in the accompanying drawings, is not intended to limit the scope of the claimed application, but is merely representative of selected embodiments of the application. All other embodiments, which can be derived by a person skilled in the art from the embodiments of the present application without making any creative effort, shall fall within the protection scope of the present application.
Additionally, the flowcharts used in this application illustrate operations implemented according to some embodiments of the present application. It should be understood that the operations of the flow diagrams may be performed out of order, and steps without logical context may be performed in reverse order or simultaneously. One skilled in the art, under the guidance of this application, may add one or more other operations to, or remove one or more operations from, the flowchart.
The page joint debugging method provided by the embodiment of the present application is explained below with reference to a plurality of specific application examples.
In a possible implementation manner, an embodiment of the present invention provides a page joint debugging method, and fig. 1 is a schematic flow chart of the page joint debugging method provided in an embodiment of the present application, as shown in fig. 1, the method includes:
s101: and acquiring a script file of the page to be debugged.
In the embodiment of the application, the script file of the page to be debugged may be, for example, a js script file, where the manner of acquiring the script file may be, for example, that a user writes the js script file in a console by copying the pre-written js script file in the console after opening a browser developer tool; or, in other possible embodiments, after clicking the console, the user may directly write the pre-written js script file in the console; it should be understood that the above embodiments are only exemplary, and the way how to write the js script in the console can be flexibly adjusted according to the user's needs, and is not limited to the above embodiments.
S102: and generating a configuration file of the page to be debugged according to the script file.
The configuration file includes: configuration data of the script file.
In an embodiment of the application, after the js script file is written in the console, the console runs according to the js script file to analyze the js script file, so as to obtain configuration data corresponding to the script file, and then generates the configuration file corresponding to the page to be debugged according to the configuration data obtained through analysis.
S103: and regenerating a page to be debugged according to the modified configuration data so as to debug the page to be debugged.
In some possible embodiments, the modifying operation comprises, for example, at least one of: a supplement operation, a sort operation, a modify dynamic component operation, a delete operation, a modify operation, a verify operation, or the like.
For example, in some possible embodiments, for example, the modifying operation may include: the supplementary operation and the sorting operation, for example, for some scenarios that require further supplementary and sorting of the configuration file, for example, there may be some interface addresses that require supplementary of the name of the microservice in the configuration file, or there may be some column groups in the configuration file, or the sorting of some texts needs to be changed. Alternatively, some characters in the table or the page may need to change the display color, the display style, the display background color, etc.
Alternatively, the modification operation may be a configuration operation for dictionary values, for example, in some scenarios where a click event needs to be added to some file or some table, where the way of adding the click event may be, for example: generating a dictionary value by configuring in a dynamic component or modifying the configuration, so as to format or trigger the configuration of an event on a field or a table corresponding to the dictionary value by the dictionary value, where the dictionary value is used to determine a correspondence between characters and events in the field or the table, and in some possible embodiments, for example, an event corresponding to a character 1 configured in advance in the dictionary value may be, for example, a start, an event corresponding to a character 2 may be, for example, an end, an event corresponding to a character 3 may be, for example, in progress, an event corresponding to a character 4 may be, for example, a format, and the like; it should be understood that the foregoing embodiment is only an exemplary illustration, and both the information configured in the specific dictionary value and the corresponding relationship between the information may be flexibly adjusted according to the user's needs, and are not limited to the foregoing embodiment.
Or, the modification operation may also be a scenario for deletion or modification in the configuration file, for example, a user may supplement, modify or delete a code of a service logic in the configuration file, or perform operations such as data verification and service flow processing; it should be understood that the above embodiments are only exemplary, and the operation manner and the operation items corresponding to the specific modification operation can be flexibly adjusted according to the user's needs, and are not limited to the embodiments described above.
By adopting the page joint debugging method provided by the application, the page to be debugged is generated according to the modified configuration file, the configuration file is automatically generated according to the script file and forms a standardized format, when the user needs to joint debug the page to be debugged, only the configuration data needs to be directly modified in the configuration file, and each component does not need to be modified and configured by taking the component as a unit, so that the joint debugging efficiency is greatly saved.
Optionally, on the basis of the foregoing embodiment, an embodiment of the present application may further provide a page joint debugging method, and an implementation process of debugging a page to be debugged in the foregoing method is described as follows with reference to the accompanying drawings. Fig. 2 is a schematic flowchart of a page joint debugging method according to another embodiment of the present application, where a page to be debugged is a search page, and a script file includes: searching a script Commonsearch; as shown in fig. 2, S103 may include:
s104: and generating a search component according to the configuration data of the modified search script.
In the embodiment of the application, a user can modify a search component by directly modifying configuration data corresponding to a search script in a configuration file.
In the embodiment of the application, for example, a plurality of functional components may be supported in the search component, for example, the search component may include a pull-down function, an input box function, a date function, and the like, and specifically, the functions may be flexibly set according to the user needs, and the search component is generated through configuration data of the search script, so that the search component can be directly debugged in a configuration file of the search script, so that debugging of a plurality of functional components is realized, and thus debugging efficiency is improved.
S105: and regenerating a search control in the page to be debugged according to the search component so as to debug the page to be debugged.
In an embodiment of the present application, CommonSearch is a form (form) component of a search condition, and the component may include: date, input box, pull-down menu with remote search, etc., it should be understood that the above embodiments are only exemplary, and the content included in the specific search component can be flexibly adjusted according to the user's needs, and is not limited to the above embodiments.
The incoming parameter of CommonSearch is an object array, which may include, for example: type of input box (type), key field (key, field exposed after point search), configuration of form item of component library tool (element-ui) (config); in the embodiment of the present application, the v-bind of the vue component is utilized to transfer the object array into the form base component. And circulating the form of an el-form-item component in the form basic component through a v-for so that the form basic component renders the specific basic component according to the type, and realizing the bidirectional data binding value between the basic component and the object array through the v-model.
The form state maintained in the search script is that the state value of the search script is initialized according to the key in the object array by circulating the props object array search List of common search, when the user changes the key in the object array, the state value of the search script also changes, and an event is triggered by clicking the search control, so that the state value of the search script is transmitted.
In the embodiment of the application, because a label is not written in the whole searching component, all related keys and configuration attributes are placed in the object array of the js script, if the keys are the same as the parameter fields in the background interface document, the configuration file can be directly generated according to the js script without any data conversion.
If the parameter fields in the key and background interface documents are different, a data (data) or method (method) needs to be defined in the dynamic component defined by the component attribute in the configuration file, and the data or method is used for converting the original data in the interface into the expected presentation style of the page.
In some possible embodiments, the interface document may be, for example, a tag (html) page, and may be directly executed in the browser developer tool through a js script, and a configuration file corresponding to the js script is generated according to the js script and the interface document.
Optionally, on the basis of the foregoing embodiment, an embodiment of the present application may further provide a page joint debugging method, and an implementation process of debugging a page to be debugged in the foregoing method is described as follows with reference to the accompanying drawings. Fig. 3 is a schematic flowchart of a page joint debugging method according to another embodiment of the present application, where a script file further includes: list script CommonTable; as shown in fig. 3, S103 may include:
s106: and generating a paging list component according to the configuration data of the modified list script.
In the embodiment of the application, a user can modify the paging list component by directly modifying the configuration data corresponding to the list script in the configuration file.
S107: and respectively regenerating a search control and a query list in the page to be debugged according to the search component and the paging list component so as to debug the page to be debugged.
In the embodiment of the application, when a user clicks a search control in a page to be debugged, a query (search) event in CommonSearch is triggered, data in a form (form) is transmitted to a main page of the page to be debugged, after the main page receives the transmitted data, the acquired data is formatted, converted into a data format required by an interface and re-assigned, and the formatted data is displayed on the main page.
In the embodiment of the present application, the CommonTable may monitor a change of option (prop) parameters, and after monitoring the change of the parameters, a trigger request corresponding to the changed parameters may be generated.
In some possible embodiments, the pps included in CommonTable may include, for example: the method includes the following steps of querying parameters (params), column names and fields (columns), http parameters (httpfieder), operations (btns) in the last column of the list, whether to execute immediately (immedate), whether to remember options (memory), unique identifiers (selectKey) of each row, and paging configuration (paging), and it should be understood that the above embodiments are merely exemplary, and the option parameters included in a particular common table may be flexibly adjusted according to user needs, and are not limited to the above embodiments.
The params parameter in commonTable internally monitors the key value in the object array in CommonSearch, and triggers the query request to be retransmitted once the key in the object array changes.
In the embodiment of the application, the column name and the field (columns) are object data, one object data represents a certain field in a column of a table, and for a certain general column of objects, only the corresponding label (label) and option (tips) need to be set. For a column object that needs a special style, for example, for a column object that needs a special setting such as a color of a character bar, a background color, or a bold, slant, underline, or font style change, a component field (component) field, that is, an object, is introduced into the column object by using a pre-configured dynamic component, so as to implement the special setting for the column object.
Wherein, in the embodiment of the application, the progressive framework (. vue) component is compiled into a js object. The method includes the steps that a template (template) is contained in an el table column (el-table-column) component, a row (row) can be transmitted to represent a row of data, and then a component object is transmitted in the component vue.
In addition, by adding v-bind ═ $ attrs ", it can be realized that the trigger event is added from the dynamic component object, and received from the external main page. The dynamic component object can also be introduced into a component, which is defined in the same way as the component vue, and can define date (data), components (components), method (method), etc., but the definition of the introduced eucalyptus requires defining template (template) field whose field type is string field, wherein in the embodiment of the present application, since the dynamic component vue is actually a js object, but the js object cannot define class, but can write style in the html element string. If the style type of the cascading style sheet (css) is written as class, a global class is needed, but this is contrary to writing a private style in the dynamic component of vue, and there is a problem that it is difficult to maintain the global class, so the style type of the cascading style sheet (css) in the embodiment of the present application is written as a style class, and cannot be written as a class.
In an embodiment of the present application, the CommonTable may remember the data purchased on the previous page after acquiring the data across pages.
The CommonTable internally maintains a state, after data is acquired across pages, the data can be traversed in response to the acquired data, if the state value in the acquired data has a value, namely is not null, a toggle Row Selection (checkbox) event is triggered, and a check box (checkbox) is checked. For the case that there is an operation in the last column of the list, for example, the user needs to add a new, edit, or delete button in the last column, at this time, an object props of btns may be imported according to the selected button, where the object props includes a configuration (config) and a btnList, where the config refers to a configuration parameter of the operation, and may import a style, and set a width of the operation column, and also may import a prop of el-table-column, if the object is an add, delete, or change, only a character string "add", "delete", or "edit" may be needed, if the user needs to add a button of other contents in the last column, an object including name, key, config, and isshwn needs to be imported, where the isshwn is a method object, and its parameter is data in one row, and a bootbean value may be returned according to the method and the data in one row, where the bootean data type is a numeric value that can be stored as 16 bits (2 bytes), but the data content can only be True or False, and whether each button is displayed can be judged according to the value of the coolbean.
In the embodiment of the application, because the interface parsing script has a unified interface document: after a developer tool is opened by a browser, a user can directly execute a script file in the browser by clicking a console, so that a configuration file corresponding to the script file can be obtained, and parameters corresponding to a common table are determined in the configuration file: httpreader, columns, params and the like, and because the parameters are generated by an interface request mode which is agreed with a background in advance, a standardized flow is formed, and therefore, by adopting the joint debugging method provided by the application, a front end is basically not needed in the joint debugging process, and the joint debugging efficiency is greatly improved.
Optionally, on the basis of the foregoing embodiment, an embodiment of the present application may further provide a page joint debugging method, and an implementation process of debugging a page to be debugged in the foregoing method is described as follows with reference to the accompanying drawings. Fig. 4 is a schematic flow chart of a page joint debugging method according to another embodiment of the present application, and as shown in fig. 4, the method may further include:
s108: and responding to the triggering operation of the search control, and acquiring a request event triggered by the configuration data of the search script.
In the embodiment of the application, before a request event triggered by configuration data is acquired, an object array in the configuration data of a search script needs to be acquired; and then responding to the triggering operation of the search control, and acquiring the corresponding request event triggered by the object array.
In some possible embodiments, the paging list component may monitor the object array corresponding to the search component, and if it is monitored that the object data is changed, for example, a user adjusts a search keyword or a search type, the change operation of the object array is responded to, and a request event corresponding to the changed object array is triggered, that is, the corresponding request event is triggered again according to the changed object data.
S109: and generating a query result corresponding to the request event in a query list on the page.
By adopting the page joint debugging method provided by the application, the list page capable of dynamically supporting addition, deletion, modification or inquiry can be generated by directly modifying the configuration file, and the configuration file is generated by directly analyzing the interface document by the script file, so that a standardized interface calling mode is formed, and the joint debugging interface can be automatically jointed and debugged by the back end, thereby not only improving the joint debugging efficiency, but also greatly saving the time of a front-end engineer. Therefore, by adopting the joint debugging method provided by the application, the list in the page is not only standardized, but also can be configured separately aiming at a single piece of data in the list in a manner of transmitting a dynamic component, so that the flexibility of list configuration is ensured.
The following explains the page joint debugging apparatus provided in the present application with reference to the accompanying drawings, where the page joint debugging apparatus can execute any one of the page joint debugging methods shown in fig. 1 to 4, and specific implementation and beneficial effects of the page joint debugging apparatus refer to the above description, which is not described again below.
Fig. 5 is a schematic structural diagram of a page joint debugging apparatus according to an embodiment of the present application, and as shown in fig. 5, the apparatus includes: an obtaining module 201 and a generating module 202, wherein:
an obtaining module 201, configured to obtain a script file of a page to be debugged;
a generating module 202, configured to generate a configuration file of the page to be debugged according to the script file, where the configuration file includes: configuration data of the script file; and regenerating a page to be debugged according to the modified configuration data so as to debug the page to be debugged.
Optionally, the page to be debugged is a search page, and the script file includes: searching the script; a generating module 202, specifically configured to generate a search component according to the modified configuration data of the search script; and regenerating a search control in the page to be debugged according to the search component so as to debug the page to be debugged.
Optionally, the script file further comprises: listing a script; a generating module 202, specifically configured to generate a paging list component according to the configuration data of the modified list script; and respectively regenerating a search control and a query list in the page to be debugged according to the search component and the paging list component so as to debug the page to be debugged.
Optionally, the obtaining module 201 is specifically configured to, in response to a triggering operation of a search control, obtain a request event triggered by configuration data of a search script;
the generating module 202 is specifically configured to generate a query result corresponding to the request event in a query list on the page.
Optionally, the obtaining module 201 is specifically configured to obtain an object array in the configuration data of the search script; and responding to the triggering operation of the search control, and acquiring a corresponding request event triggered by the object array.
Optionally, the modifying operation comprises at least one of: a supplemental operation, a sort operation, a modify dynamic component operation, a delete operation, a modify operation, or a verify operation.
Optionally, on the basis of the above embodiments, the embodiments of the present application may further provide a page joint debugging apparatus, and an implementation process of the apparatus shown in fig. 5 is described as follows with reference to the accompanying drawings. Fig. 6 is a schematic structural diagram of a page joint debugging apparatus according to another embodiment of the present application, and as shown in fig. 6, the apparatus further includes: the triggering module 203 is configured to trigger a request event corresponding to the changed object array in response to a change operation of the object array.
The above-mentioned apparatus is used for executing the method provided by the foregoing embodiment, and the implementation principle and technical effect are similar, which are not described herein again.
These above modules may be one or more integrated circuits configured to implement the above methods, such as: one or more Application Specific Integrated Circuits (ASICs), or one or more microprocessors, or one or more Field Programmable Gate Arrays (FPGAs), etc. For another example, when one of the above modules is implemented in the form of a Processing element scheduler code, the Processing element may be a general-purpose processor, such as a Central Processing Unit (CPU) or other processor capable of calling program code. For another example, these modules may be integrated together and implemented in the form of a system-on-a-chip (SOC).
Fig. 7 is a schematic structural diagram of a page joint debugging device according to an embodiment of the present application, where the page joint debugging device may be integrated in a terminal device or a chip of the terminal device.
As shown in fig. 7, the page joint debugging apparatus includes: a processor 501, a storage medium 502, and a bus 503.
The processor 501 is used for storing a program, and the processor 501 calls the program stored in the storage medium 502 to execute the method embodiment corresponding to fig. 1-4. The specific implementation and technical effects are similar, and are not described herein again.
Optionally, the present application also provides a program product, such as a storage medium, on which a computer program is stored, including a program, which, when executed by a processor, performs embodiments corresponding to the above-described method.
In the several embodiments provided in the present application, it should be understood that the disclosed apparatus and method may be implemented in other ways. For example, the above-described apparatus embodiments are merely illustrative, and for example, a division of a unit is merely a logical division, and an actual implementation may have another division, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may be in an electrical, mechanical or other form.
Units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.
In addition, functional units in the embodiments of the present application may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit can be realized in a form of hardware, or in a form of hardware plus a software functional unit.
The integrated unit implemented in the form of a software functional unit may be stored in a computer readable storage medium. The software functional unit is stored in a storage medium and includes several instructions for enabling a computer device (which may be a personal computer, a server, or a network device) or a processor (processor) to perform some steps of the methods according to the embodiments of the present application. And the aforementioned storage medium includes: a U disk, a removable hard disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk or an optical disk, and other various media capable of storing program codes.
Claims (10)
1. A page joint debugging method is characterized by comprising the following steps:
acquiring a script file of a page to be debugged;
generating a configuration file of the page to be debugged according to the script file, wherein the configuration file comprises: configuration data of the script file;
and regenerating the page to be debugged according to the configuration file corresponding to the modified configuration data so as to debug the page to be debugged.
2. The method of claim 1, wherein the page to be debugged is a search page, and the script file comprises: searching the script; the regenerating the page to be debugged according to the configuration file corresponding to the modified configuration data to debug the page to be debugged includes:
generating a search component according to the modified configuration data of the search script;
and regenerating a search control in the page to be debugged according to the search component so as to debug the page to be debugged.
3. The method of claim 2, wherein the script file further comprises: listing a script; the regenerating the page to be debugged according to the configuration file corresponding to the modified configuration data to debug the page to be debugged includes:
generating a paging list component according to the modified configuration data of the list script;
and respectively regenerating a search control and a query list in the page to be debugged according to the search component and the paging list component so as to debug the page to be debugged.
4. The method of claim 3, wherein the method further comprises:
responding to the triggering operation of the search control, and acquiring a request event triggered by the configuration data of the search script;
and generating a query result corresponding to the request event in a query list on the page.
5. The method of claim 4, wherein prior to obtaining the configuration data triggered request event of the search script in response to the triggering operation of the search control, the method further comprises:
acquiring an object array in the configuration data of the search script;
the acquiring a request event triggered by configuration data of the search script in response to the triggering operation of the search control comprises:
and responding to the triggering operation of the search control, and acquiring a corresponding request event triggered by the object array.
6. The method of claim 1, wherein the modifying operation comprises at least one of: a supplemental operation, a sort operation, a modify dynamic component operation, a delete operation, a modify operation, or a verify operation.
7. The method of claim 5, wherein the method further comprises:
and responding to the change operation of the object array, and triggering a request event corresponding to the changed object array.
8. A page joint debugging device, characterized in that the device comprises: the device comprises an acquisition module and a generation module, wherein:
the acquisition module is used for acquiring a script file of a page to be debugged;
the generating module is configured to generate a configuration file of the page to be debugged according to the script file, where the configuration file includes: configuration data of the script file; and regenerating the page to be debugged according to the modified configuration data so as to debug the page to be debugged.
9. A page joint debugging device, characterized in that the device comprises: a processor, a storage medium and a bus, the storage medium storing machine-readable instructions executable by the processor, the processor and the storage medium communicating via the bus when the page joint debugging device is running, the processor executing the machine-readable instructions to perform the method of any one of the preceding claims 1 to 7.
10. A storage medium, characterized in that the storage medium has stored thereon a computer program which, when being executed by a processor, performs the method of any of the preceding claims 1-7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210043707.5A CN114371848A (en) | 2022-01-14 | 2022-01-14 | Page joint debugging method, device, equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210043707.5A CN114371848A (en) | 2022-01-14 | 2022-01-14 | Page joint debugging method, device, equipment and storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN114371848A true CN114371848A (en) | 2022-04-19 |
Family
ID=81144073
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210043707.5A Withdrawn CN114371848A (en) | 2022-01-14 | 2022-01-14 | Page joint debugging method, device, equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114371848A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115269066A (en) * | 2022-09-19 | 2022-11-01 | 平安银行股份有限公司 | Interface calling method, device and storage medium |
-
2022
- 2022-01-14 CN CN202210043707.5A patent/CN114371848A/en not_active Withdrawn
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115269066A (en) * | 2022-09-19 | 2022-11-01 | 平安银行股份有限公司 | Interface calling method, device and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7216340B1 (en) | Analysis data validation tool for use in enterprise architecture modeling with result based model updating | |
| US7424702B1 (en) | Data integration techniques for use in enterprise architecture modeling | |
| US20070130512A1 (en) | Systems and methods for report design and generation | |
| US20030140045A1 (en) | Providing a server-side scripting language and programming tool | |
| CN111078555B (en) | Test file generation method, system, server and storage medium | |
| CN113051514B (en) | Element positioning method and device, electronic equipment and storage medium | |
| CN110688307A (en) | JavaScript code detection method, apparatus, device and storage medium | |
| US20150278190A1 (en) | Web server system, dictionary system, dictionary call method, screen control display method, and demonstration application generation method | |
| Barnaby et al. | Exempla Gratis (EG): Code examples for free | |
| CN111782213A (en) | Dynamic control page generation system based on DOM | |
| CN111427577A (en) | Code processing method and device and server | |
| CN114371848A (en) | Page joint debugging method, device, equipment and storage medium | |
| CN117389562A (en) | Front-end code visual configuration and intelligent generation method and system based on Vue | |
| CN111796808A (en) | Implementation method based on DAOTable universal list component | |
| JP4846030B2 (en) | Operation verification apparatus, operation verification method, and operation verification program | |
| JP2001125855A (en) | Dynamic web page generation program | |
| CN111126008A (en) | XSD-based code generation method and device, computer equipment and storage medium | |
| CN116069330A (en) | Middle and background template construction method, device and storage medium | |
| CN112699279B (en) | Method, device, equipment and storage medium for automatically processing components | |
| CN115509668A (en) | Method, device and equipment for constructing front-end page analytic framework and storage medium | |
| CN111459793B (en) | Full life cycle software automatic test method and device | |
| CN112068833B (en) | Browser system | |
| CN114385155A (en) | vue project visualization tool generation method, device, equipment and storage medium | |
| CN113779362A (en) | Data searching method and device | |
| CN113687827A (en) | Data list generation method, device and equipment based on widget and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| TA01 | Transfer of patent application right | ||
| TA01 | Transfer of patent application right |
Effective date of registration: 20220610 Address after: Room 6f-604-3, HD media building, No. 28, nantiancheng Road, high speed rail new town, Xiangcheng District, Suzhou, Jiangsu 215100 Applicant after: Suzhou Jiqi Wulian Technology Co.,Ltd. Address before: No. 201, second floor, building 8, No. 27, Jiancai Chengzhong Road, Haidian District, Beijing 100082 Applicant before: BEIJING HUITONGTIANXIA IOT TECHNOLOGY CO.,LTD. |
|
| WW01 | Invention patent application withdrawn after publication | ||
| WW01 | Invention patent application withdrawn after publication |
Application publication date: 20220419 |