CN115729826A - Method and device for generating form verification rule, storage medium and electronic equipment - Google Patents
Method and device for generating form verification rule, storage medium and electronic equipment Download PDFInfo
- Publication number
- CN115729826A CN115729826A CN202211489481.8A CN202211489481A CN115729826A CN 115729826 A CN115729826 A CN 115729826A CN 202211489481 A CN202211489481 A CN 202211489481A CN 115729826 A CN115729826 A CN 115729826A
- Authority
- CN
- China
- Prior art keywords
- verification
- rule
- function
- array
- calling
- 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.)
- Pending
Links
- 238000012795 verification Methods 0.000 title claims abstract description 231
- 238000000034 method Methods 0.000 title claims abstract description 73
- 230000006870 function Effects 0.000 claims abstract description 220
- 238000012163 sequencing technique Methods 0.000 claims description 21
- 238000010200 validation analysis Methods 0.000 claims description 8
- 238000004590 computer program Methods 0.000 claims description 7
- 238000011161 development Methods 0.000 description 8
- 238000004891 communication Methods 0.000 description 4
- 238000012423 maintenance Methods 0.000 description 3
- 230000009286 beneficial effect Effects 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 238000013461 design Methods 0.000 description 1
- 238000010586 diagram Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000004806 packaging method and process Methods 0.000 description 1
- 230000001960 triggered effect Effects 0.000 description 1
Images
Landscapes
- Stored Programmes (AREA)
Abstract
The application discloses a method and a device for generating form verification rules, a storage medium and electronic equipment. The method comprises the following steps: establishing a rule checking object, wherein the rule checking object comprises a blank rule array; respectively defining a verification function corresponding to each preset verification rule in the rule verification object according to the preset verification rules, wherein the verification functions are used for writing the corresponding preset verification rules into the rule array; each verification function is invoked in turn. The method solves the problem that the readability and maintainability of the existing form component based on the Element UI are low.
Description
Technical Field
The present application relates to the field of computer technologies, and in particular, to a method and an apparatus for generating form validation rules, a storage medium, and an electronic device.
Background
With the continuous development of modern internet, the front-end technology is also continuously advanced, and various component libraries and tool libraries are layered endlessly. In a B-end service scene, the Element UI can become a choice of a plurality of technical teams for developing a background system.
Among them, the form verification provided by the form component carried by the Element UI has some disadvantages: in a complex background business system, a large number of custom check rules are usually needed, and each form field may also need multiple custom check rules for verification, but the form verification carried by the Element UI usually writes the custom check rules in the form of multiple loose objects inside the component. Such a writing method has poor readability and maintainability.
Disclosure of Invention
In view of this, the present application provides a method and an apparatus for generating a form verification rule, a storage medium, and an electronic device, which solve the problem that the readability and maintainability of the existing form component based on an Element UI are low.
According to an aspect of the present application, there is provided a method for generating a form verification rule, including:
establishing a rule checking object, wherein the rule checking object comprises a blank rule array;
respectively defining a verification function corresponding to each preset verification rule in the rule verification object according to the preset verification rules, wherein the verification functions are used for writing the corresponding preset verification rules into the rule array;
and calling each verification function in turn.
Optionally, the sequentially calling each of the verification functions includes:
sequencing a plurality of verification functions, calling a verification function with the first sequencing by using the rule checking object, and writing a preset verification rule corresponding to the verification function with the first sequencing into the rule array as an array element by using the verification function with the first sequencing;
taking the called verification function as a current function, and taking a verification function which is sequenced after the current function and is adjacent to the current function as a target function;
and calling the target function by using the rule checking object, writing a preset verification rule corresponding to the target function into the rule array by using the target function as an array element, and returning to the step of using the called verification function as the current function until the current function is the verification function with the last sequence.
Optionally, a return value of the verification function is the rule check object;
the calling the target function by using the rule check object comprises:
and calling the target function by using the return value of the current function.
Optionally, after the sequentially calling each of the verification functions, the method further includes:
and establishing an execution function, and calling the execution function by using the return value of the current function, wherein the return value of the execution function is the rule array.
Optionally, after the sequentially calling each of the verification functions, the method further includes:
and responding to the form verification request, reading a preset verification rule in the rule array, and verifying the target form by using the preset verification rule.
Optionally, before the creating a rule check object, the method further includes:
establishing a front-end code file, establishing a rule check class in the front-end code file, and defining rule array attributes in the rule check class;
the establishing of the rule check object comprises the following steps:
and generating the rule checking object by using the rule checking class.
Optionally, before the creating a front-end code file, the method further includes:
and determining that the running environment where the project corresponding to the front-end code file is located is a target environment, and installing an Element UI component library in the target environment.
According to another aspect of the present application, there is provided a form verification rule generation apparatus, including:
the attribute initialization module is used for establishing a rule check object, wherein the rule check object comprises a blank rule array;
the method comprises a method initialization module, a rule verification object and a rule verification module, wherein the method initialization module is used for respectively defining a verification function corresponding to each preset verification rule in the rule verification object according to the preset verification rule, and the verification function is used for writing the corresponding preset verification rule into the rule array;
and the calling module is used for calling each verification function in sequence.
Optionally, the calling module is configured to:
sequencing a plurality of verification functions, calling a verification function with the first sequencing by using the rule checking object, and writing a preset verification rule corresponding to the verification function with the first sequencing into the rule array as an array element by using the verification function with the first sequencing;
taking the called verification function as a current function, and taking a verification function which is sequenced after the current function and is adjacent to the current function as a target function;
and calling the target function by using the rule checking object, writing a preset verification rule corresponding to the target function into the rule array by using the target function as an array element, and returning to the step of using the called verification function as the current function until the current function is the verification function with the last sequence.
Optionally, the return value of the verification function is the rule check object;
the calling module is further configured to:
and calling the target function by using the return value of the current function.
Optionally, the apparatus further comprises an execution module configured to:
and establishing an execution function, and calling the execution function by using the return value of the current function, wherein the return value of the execution function is the rule array.
Optionally, the apparatus further comprises a verification module configured to:
and responding to the form verification request, reading a preset verification rule in the rule array, and verifying the target form by using the preset verification rule.
Optionally, the apparatus further comprises an object initialization module configured to:
establishing a front-end code file, establishing a rule check class in the front-end code file, and defining rule array attributes in the rule check class;
and generating the rule checking object by using the rule checking class.
Optionally, the apparatus further comprises an environment initialization module configured to:
and determining that the running environment where the project corresponding to the front-end code file is located is a target environment, and installing an Element UI component library in the target environment.
According to yet another aspect of the present application, there is provided a storage medium having stored thereon a computer program which, when executed by a processor, implements the method of generating the above-described form verification rule.
According to still another aspect of the present application, there is provided an electronic device, including a storage medium, a processor, and a computer program stored on the storage medium and executable on the processor, where the processor implements the method for generating the form verification rule when executing the program.
By means of the technical scheme, each verification function is called in sequence, the preset verification rule is written into an array by the verification function, and compared with the traditional method for establishing a plurality of loose objects aiming at a plurality of verification rules, the method is simpler in structure, improves readability and is more beneficial to later maintenance.
The above description is only an overview of the technical solutions of the present application, and the present application may be implemented in accordance with the content of the description so as to make the technical means of the present application more clearly understood, and the detailed description of the present application will be given below in order to make the above and other objects, features, and advantages of the present application more clearly understood.
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 flowchart illustrating a method for generating a form verification rule according to an embodiment of the present application;
fig. 2 shows a block diagram of a structure of a device for generating a form verification rule according to an embodiment of the present application.
Detailed Description
The present application will be described in detail below with reference to the accompanying drawings in conjunction with embodiments. It should be noted that the embodiments and features of the embodiments in the present application may be combined with each other without conflict.
In this embodiment, a method for generating a form verification rule is provided, as shown in fig. 1, the method includes:
the method for generating the form verification rule provided by the embodiment of the application can be used for form verification based on Element UI. It can be understood that the Element UI is a set of component library realized by adopting Vue 2.0.0 as a basic frame, a matched design resource is provided, and developers can perform secondary development and packaging based on the Element UI component library to enable a website to be rapidly formed.
In this step, a rule check object is first established, where the object includes a rule array, and the rule array is used to store the validation rule for the form. The rule array is a null array, and the verification rule is written into the array through the verification function in the subsequent rule establishing process, so that in an actual use scene, the form can be verified according to the verification rule only by reading elements in the array.
102, respectively defining a verification function corresponding to each preset verification rule in a rule verification object according to the preset verification rules, wherein the verification functions are used for writing the corresponding preset verification rules into a rule array;
in the step, a preset verification rule is determined according to actual service requirements, and a verification function corresponding to the preset verification rule is defined in a rule verification object. The number of the verification functions can be multiple, and each verification function is used for writing the corresponding preset verification rule into the rule array.
In the step, each verification function is called in sequence, and each verification rule is written into the rule array through the verification function. The sequence of calling the verification function can be set according to actual service requirements.
By applying the technical scheme of the embodiment, each verification function is sequentially called, the preset verification rule is written into an array by using the verification function, and compared with the traditional method for establishing a plurality of loose objects aiming at a plurality of verification rules, the method is simpler in structure, improves readability and is more beneficial to later maintenance.
Further, as a refinement and an extension of the specific implementation of the embodiment, in order to fully explain the specific implementation process of the embodiment, another method for generating a form verification rule is provided, and each verification function is sequentially called, where the method includes:
step 201, sequencing a plurality of verification functions, calling a verification function with the first sequencing by using a rule check object, and writing a preset verification rule corresponding to the verification function with the first sequencing into a rule array as an array element by using the verification function with the first sequencing;
step 202, taking the called verification function as a current function, and taking a verification function which is sequenced behind the current function and is adjacent to the current function as a target function;
step 203, the target function is called by using the rule checking object, the target function writes the corresponding preset verification rule as an array element into the rule array, and the step of using the called verification function as the current function is returned until the current function is the verification function with the last sequencing.
In this embodiment, when the verification function is called, the verification functions are ordered according to actual service requirements, and are called in sequence according to the order of the ordering, or the order of the verification functions in the rule check object is directly used as the calling order.
Specifically, the verification function with the first ordering is called first, and the corresponding preset verification rule is written into the rule array by the verification function. And then, sequentially taking each verification function as a target function, calling the target function by using the rule verification object, and writing the corresponding preset verification rule into the rule array when the target function is called. And after all the verification functions are called, all the preset verification rules corresponding to all the verification functions are written into the rule array.
When the preset verification rules are written into the rule array, each preset verification rule is used as one element of the rule array. Each array element may be a vector or may have other configurations.
Further, in another form verification rule generation method, a return value of a verification function is a rule verification object; calling the target function by using the rule check object, wherein the method comprises the following steps:
step 301, the target function is called by using the return value of the current function.
In this embodiment, the return value of each verification function is set as the rule verification object, and therefore, other verification functions may be called by using the return value of the verification function, so as to achieve the effect that the rule verification object calls the verification function.
For example, the check function may be of the form:
and taking the called verification function as a current function, taking the verification function which is sequenced behind the current function and is adjacent to the current function as a target function, calling the target function by using a return value of the current function, and then taking the target function as a new current function. In this loop, another verification function ordered after and adjacent to it is called with the return value of each verification function. That is, the return object of the previous function is the execution object of the next function, and the execution is performed sequentially, so that the chain call of the verification function is realized.
For example, if the rule verification object is validator and the three verification functions are validFunction1 (), validFunction2 (), and validFunction n (), the chain call of the verification functions can be implemented by the following statements: validFunction1 (). ValidFunction2 (). ValidFunction n ().
By the chain calling method, a rule is written into the rule array every time the call is made, and the current class of objects is returned until all preset verification rules are written into the rule array, and then the form verification can be performed by using the rule array.
According to the embodiment, the calling process of the verification function is closer to the natural language through chain calling, unnecessary code amount is reduced, development efficiency is improved, and maintenance difficulty is reduced.
Further, in another form verification rule generation method, after each verification function is called in sequence, the method further includes:
step 401, establishing an execution function, and calling the execution function by using a return value of the current function, wherein the return value of the execution function is a rule array.
In this embodiment, an execute function is built in the rule check object and a rule array is returned with the execute function.
Specifically, the execution function may be called by using a chain call method, and after each verification function is called in turn, the current function at this time is the verification function that is the last in the sequence. And calling the execution function by using the return value of the sorted last verification function, namely calling the execution function by using the rule check object, so that the execution function returns to the rule array in the rule check object.
The method for calling the execution function by using the return value of the verification function which is sequenced last is similar to the method for calling the verification function. For example, if the rule verification object is validator, the three verification functions are validFunction1 (), validFunction2 (), and validFunction n (), and the execution function is exec (), the chain call of the verification function and the execution function can be realized by the following statements:
validator.validFunction1().validFunction2().validFunctionN()。
further, in another form verification rule generation method, after each verification function is called in sequence, the method further includes:
step 501, responding to the form verification request, reading a preset verification rule in the rule array, and verifying the target form by using the preset verification rule.
In this embodiment, after the preset validation rules are all written into the rule array, the rule array can be used to perform form verification. Specifically, the reading of the preset validation rules in the rule array is triggered by the form verification request, wherein all the preset validation rules in the rule array can be read, and only one or more preset validation rules corresponding to the form verification request can be read.
After the preset verification rule is read, corresponding fields in the form are extracted by contrasting the preset verification rule, whether the field values meet the rule is verified, if yes, the verification is passed, and if not, the verification is not passed.
Further, in another method for generating a form verification rule, before establishing a rule check object, the method further includes:
step 601, establishing a front end code file, establishing a rule check class in the front end code file, and defining a rule array attribute in the rule check class;
establishing a rule check object, comprising:
step 701, generating a rule check object by using the rule check class.
In this embodiment, a folder is first created in the development project, and a front-end code file is created under the folder, where the front-end code file may be a js format file. Then, a rule check class is newly established in the front-end code file, a rule array attribute is defined in the rule check class, and then the establishment of a rule check object can be directly realized through the rule check class, and the established rule check class comprises a blank rule array.
In addition, a verification function and an execution function can be defined in the rule check class, and further the verification function and the execution function can be directly defined in the rule check object through the rule check class without writing the function in the rule check object.
Further, in another form verification rule generation method, before the front-end code file is created, the method further includes:
step 801, determining that the running environment where the project corresponding to the front-end code file is located is a target environment, and installing an Element UI component library in the target environment.
In this embodiment, the configuration of the development environment is first processed prior to development. Specifically, an Element UI component library is installed in the environment where the development project is located, namely the target environment, so that the development project can use components and functions related to the form in the component library.
The Element UI component library can be installed by using the following commands: npm instance-ui.
Further, as a specific implementation of the method for generating the form verification rule, an embodiment of the present application provides a device for generating the form verification rule, and as shown in fig. 2, the device includes: the device comprises an attribute initialization module, a method initialization module and a calling module.
The attribute initialization module is used for establishing a rule check object, wherein the rule check object comprises a blank rule array;
the method comprises a method initialization module, a rule verification object and a rule verification module, wherein the method initialization module is used for respectively defining a verification function corresponding to each preset verification rule in the rule verification object according to the preset verification rules, and the verification functions are used for writing the corresponding preset verification rules into a rule array;
and the calling module is used for calling each verification function in sequence.
In a specific application scenario, optionally, the calling module is configured to:
sequencing the plurality of verification functions, calling the verification function with the first sequencing by using the rule checking object, and writing the preset verification rule corresponding to the verification function with the first sequencing into the rule array as an array element by using the verification function with the first sequencing;
taking the called verification function as a current function, and taking a verification function which is sequenced behind the current function and is adjacent to the current function as a target function;
and calling the target function by using the rule checking object, writing the preset verification rule corresponding to the target function into the rule array as an array element by using the target function, and returning to the step of taking the called verification function as the current function until the current function is the verification function which is sequenced finally.
In a specific application scenario, optionally, a return value of the verification function is a rule check object;
the calling module is further configured to:
and calling the target function by using the return value of the current function.
In a specific application scenario, optionally, the apparatus further includes an execution module, configured to:
and establishing an execution function, and calling the execution function by using the return value of the current function, wherein the return value of the execution function is a rule array.
In a specific application scenario, optionally, the apparatus further includes a checking module, configured to:
and responding to the form verification request, reading a preset verification rule in the rule array, and verifying the target form by using the preset verification rule.
In a specific application scenario, optionally, the apparatus further includes an object initialization module, configured to:
establishing a front-end code file, establishing a rule check class in the front-end code file, and defining rule array attributes in the rule check class;
and generating a rule checking object by using the rule checking class.
In a specific application scenario, optionally, the apparatus further includes an environment initialization module, configured to:
and determining the operating environment of the project corresponding to the front-end code file as a target environment, and installing an Element UI component library in the target environment.
It should be noted that other corresponding descriptions of the functional modules related to the apparatus for generating a form verification rule provided in the embodiment of the present application may refer to the corresponding descriptions in the foregoing method, and are not described herein again.
Based on the above method, correspondingly, the embodiment of the present application further provides a storage medium, on which a computer program is stored, and when the computer program is executed by a processor, the method for generating the form verification rule is implemented.
Based on such understanding, the technical solution of the present application may be embodied in the form of a software product, which may be stored in a non-volatile storage medium (which may be a CD-ROM, a usb disk, a removable hard disk, etc.), and includes several instructions for enabling an electronic device (which may be a personal computer, a server, or a network device, etc.) to execute the method described in the implementation scenarios of the present application.
Based on the method shown in fig. 1 and the virtual device embodiment shown in fig. 2, in order to achieve the above object, an embodiment of the present application further provides an electronic device, which may specifically be a personal computer, a server, a network device, and the like, where the electronic device includes a storage medium and a processor; a storage medium for storing a computer program; a processor for executing a computer program to implement the method for generating the form validation rules as shown in fig. 1 and 2.
Optionally, the electronic device may further include a user interface, a network interface, a camera, radio Frequency (RF) circuitry, sensors, audio circuitry, a WI-FI module, and/or the like. The user interface may include a Display screen (Display), an input unit such as a keypad (Keyboard), etc., and the optional user interface may also include a USB interface, a card reader interface, etc. The network interface may optionally include a standard wired interface, a wireless interface (e.g., a bluetooth interface, a WI-FI interface), etc.
It will be understood by those skilled in the art that the present embodiment provides an electronic device structure that is not limiting of the electronic device, and may include more or fewer components, or some components in combination, or a different arrangement of components.
The storage medium may further include an operating system and a network communication module. An operating system is a program that manages and maintains the hardware and software resources of an electronic device, supporting the operation of information handling programs, as well as other software and/or programs. The network communication module is used for realizing communication among the controls in the storage medium and communication with other hardware and software in the entity equipment.
Through the above description of the embodiments, those skilled in the art will clearly understand that the present application can be implemented by software plus a necessary general hardware platform, and can also be implemented by hardware.
Those skilled in the art will appreciate that the drawings are merely schematic representations of one preferred implementation scenario and that the elements or processes in the drawings are not necessarily required to practice the present application. Those skilled in the art will appreciate that elements of a device in an implementation scenario may be distributed in the device in the implementation scenario according to the description of the implementation scenario, or may be located in one or more devices different from the present implementation scenario with corresponding changes. The units of the implementation scenario may be combined into one unit, or may be further split into a plurality of sub-units.
The above application serial numbers are for description purposes only and do not represent the superiority or inferiority of the implementation scenarios. The above disclosure is only a few specific implementation scenarios of the present application, but the present application is not limited thereto, and any variations that can be made by those skilled in the art are intended to fall within the scope of the present application.
Claims (10)
1. A method for generating form verification rules, the method comprising:
establishing a rule checking object, wherein the rule checking object comprises a blank rule array;
respectively defining a verification function corresponding to each preset verification rule in the rule verification object according to the preset verification rule, wherein the verification function is used for writing the corresponding preset verification rule into the rule array;
and calling each verification function in turn.
2. The method of claim 1, wherein said invoking each of said verification functions in turn comprises:
sequencing a plurality of verification functions, calling a verification function with the first sequencing by using the rule checking object, and writing a preset verification rule corresponding to the verification function with the first sequencing into the rule array as an array element by using the verification function with the first sequencing;
taking the called verification function as a current function, and taking a verification function which is sequenced after the current function and is adjacent to the current function as a target function;
and calling the target function by using the rule checking object, writing a preset verification rule corresponding to the target function into the rule array by using the target function as an array element, and returning to the step of using the called verification function as the current function until the current function is the verification function with the last sequence.
3. The method of claim 2, wherein the returned value of the validation function is the rule check object;
the calling the target function by using the rule check object comprises:
and calling the target function by using the return value of the current function.
4. The method of claim 3, wherein after said calling each of said verification functions in turn, said method further comprises:
and establishing an execution function, and calling the execution function by using the return value of the current function, wherein the return value of the execution function is the rule array.
5. The method of claim 1, wherein after said invoking each of said verification functions in turn, said method further comprises:
and responding to the form verification request, sequentially reading preset verification rules in the rule array, and verifying the target form by using the preset verification rules.
6. The method of claim 1, wherein prior to said creating a rule check object, the method further comprises:
establishing a front-end code file, establishing a rule check class in the front-end code file, and defining rule array attributes in the rule check class;
the establishing of the rule check object comprises the following steps:
and generating the rule checking object by using the rule checking class.
7. The method of claim 6, wherein prior to the creating a front-end code file, the method further comprises:
and determining that the running environment where the project corresponding to the front-end code file is located is a target environment, and installing an Element UI component library in the target environment.
8. An apparatus for generating form verification rules, the apparatus comprising:
the attribute initialization module is used for establishing a rule check object, wherein the rule check object comprises a blank rule array;
the method comprises the steps that a method initialization module is used for respectively defining a verification function corresponding to each preset verification rule in a rule verification object according to the preset verification rules, wherein the verification functions are used for writing the corresponding preset verification rules into a rule array;
and the calling module is used for calling each verification function in sequence.
9. A storage medium on which a program or instructions are stored, characterized in that the program or instructions, when executed by a processor, implement the steps of the method according to any one of claims 1 to 7.
10. An electronic device comprising a storage medium, a processor and a computer program stored on the storage medium and executable on the processor, wherein the processor implements the method of any one of claims 1 to 7 when executing the program.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211489481.8A CN115729826A (en) | 2022-11-25 | 2022-11-25 | Method and device for generating form verification rule, storage medium and electronic equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211489481.8A CN115729826A (en) | 2022-11-25 | 2022-11-25 | Method and device for generating form verification rule, storage medium and electronic equipment |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN115729826A true CN115729826A (en) | 2023-03-03 |
Family
ID=85298344
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211489481.8A Pending CN115729826A (en) | 2022-11-25 | 2022-11-25 | Method and device for generating form verification rule, storage medium and electronic equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115729826A (en) |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20040054755A1 (en) * | 2002-08-16 | 2004-03-18 | Matti Michael C. | Web-based form validation system and method |
| CN112579071A (en) * | 2020-12-24 | 2021-03-30 | 福建升腾资讯有限公司 | Form design method and system based on form designer and event rule |
| CN112800751A (en) * | 2021-02-19 | 2021-05-14 | 上海中通吉网络技术有限公司 | Method, device, equipment and storage medium for configuring and checking mobile terminal webpage form |
| CN115344850A (en) * | 2022-08-25 | 2022-11-15 | 浪潮云信息技术股份公司 | Web front-end form verification optimization method and system |
-
2022
- 2022-11-25 CN CN202211489481.8A patent/CN115729826A/en active Pending
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20040054755A1 (en) * | 2002-08-16 | 2004-03-18 | Matti Michael C. | Web-based form validation system and method |
| CN112579071A (en) * | 2020-12-24 | 2021-03-30 | 福建升腾资讯有限公司 | Form design method and system based on form designer and event rule |
| CN112800751A (en) * | 2021-02-19 | 2021-05-14 | 上海中通吉网络技术有限公司 | Method, device, equipment and storage medium for configuring and checking mobile terminal webpage form |
| CN115344850A (en) * | 2022-08-25 | 2022-11-15 | 浪潮云信息技术股份公司 | Web front-end form verification optimization method and system |
Non-Patent Citations (1)
| Title |
|---|
| 郭凤玲: "网络性能管理系统前台软件的研究与开发", 《中国优秀硕士学位论文全文数据库 信息科技辑》, 15 September 2008 (2008-09-15), pages 138 - 134 * |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9665841B2 (en) | Cross-platform application framework | |
| US10761905B2 (en) | Enhanced code callback | |
| CN108459964B (en) | Test case selection method, device, equipment and computer readable storage medium | |
| CN106547580B (en) | Method and device for hooking function, mobile terminal and storage medium | |
| US10191751B2 (en) | Information processing device for generating application programming interface information | |
| CN111488149A (en) | Table rendering method and device based on canvas element and computer equipment | |
| US10705858B2 (en) | Automatic import of third party analytics | |
| CN112817657B (en) | Application program starting item loading method, device, system and storage medium | |
| CN112965794B (en) | Algorithm calling method, electronic equipment and storage medium | |
| CN112767135A (en) | Rule engine configuration method and device, storage medium and computer equipment | |
| CN112767133A (en) | Service decision method and device, storage medium and computer equipment | |
| CN113018870A (en) | Data processing method and device and computer readable storage medium | |
| US20160358356A1 (en) | Asset catalog layered image support | |
| CN111488286A (en) | Method and device for independently developing Android module | |
| CN111142859A (en) | Script generation method and device, electronic equipment and storage medium | |
| CN109324838B (en) | Execution method and execution device of single chip microcomputer program and terminal | |
| CN115729826A (en) | Method and device for generating form verification rule, storage medium and electronic equipment | |
| CN114020278B (en) | Data processing method, device, equipment and storage medium | |
| US20180088930A1 (en) | Updating code within an application | |
| CN111581578B (en) | Interface request processing method and device | |
| US11726818B1 (en) | System for executing tasks in different programming languages | |
| CN112199092B (en) | Application development method and device and electronic equipment | |
| CN114331167A (en) | Champion challenger strategy management method, system, medium and equipment | |
| CN113805854A (en) | Method, system and device for realizing Hook of application layer based on Linux system and storage medium | |
| CN112068814A (en) | Method, device, system and medium for generating executable file |
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 |