Dynamic form generation and verification method, equipment and medium
By employing component-level responsive data management and dynamic identifier technology, the problems of validation and selector functionality for dynamic form items were solved, resulting in a highly reusable and easily extensible dynamic form system that improves user experience and reduces development and maintenance costs.
Patent Information
- Application Number
- CN202511426865.9
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-09-30
- Publication Date
- 2026-01-06
AI Technical Summary
Existing front-end form components cannot accurately validate and implement selector component functionality when dynamically adding or removing form items, resulting in unsatisfactory performance.
Through component-level responsive data management, the form list, display status, selector content, etc. are stored separately. By using circular binding and dynamic identification technology, the form structure can be flexibly added or removed and the interaction logic and data display can be separated. Combined with rule objects, validation rules can be defined independently, supporting the reuse of multiple form components.
It improves code maintainability and system scalability, enhances user experience, ensures data integrity and intuitive operation, and reduces development and maintenance costs.
Smart Images
Figure CN121277501A_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of computer technology, and in particular to a method, device and medium for generating and validating dynamic forms. Background Technology
[0002] When developing mobile front-end forms using the uView framework, the forms contain repetitive form item groups that can be dynamically added or removed. Each form item group contains fixed sub-items, and users can add or delete form item groups as needed. However, most existing front-end form components are designed based on static table structures, which present significant adaptation problems for such dynamically added and removed form item groups. For example, it is impossible to accurately validate a specific form item group, and the selector component in the form cannot function properly, ultimately leading to unsatisfactory results. Summary of the Invention
[0003] To address the aforementioned issues, this application proposes a method for generating and validating dynamic forms, comprising: determining multiple pre-set component-level responsive data; storing corresponding data using the multiple component-level responsive data, wherein the multiple component-level responsive data includes a form list array, a display array, a selector array, an option list array, and a rule object; determining a data object corresponding to a sub-form item group based on the form list array, wherein the sub-form item group includes an input box and a selector; determining a boolean value corresponding to the sub-form item group based on the display array; determining the selection content of the selector based on the selector array; determining the selection list of the selector corresponding to the sub-form item group based on the option list array; and determining a validation rule based on the rule object; traversing the form list array to validate each sub-form item group; and executing submission logic on the validated sub-form item group.
[0004] In one example, determining the data object corresponding to the sub-form item group based on the form list array specifically includes: binding the form list array through a pre-set loop function to determine the form item group, changing the elements within the group of the form list array to change the form item group, and determining the identifier corresponding to the form item group based on pre-set form attributes.
[0005] In one example, determining the Boolean value corresponding to the subform item group based on the display array specifically includes: determining the newly added subform item group and determining the initial value corresponding to the newly added subform item group, adding the initial value to the display array; and modifying the Boolean value corresponding to the display array to control the state of the selector of the subform item group.
[0006] In one example, the method further includes: determining the newly added subform item group, copying the selector array to a new array, and determining a new identifier; storing the new array in the option list array to determine the selector option list corresponding to the newly added subform item group; determining the list attribute of the selector in the subform item group, and binding it according to the index position corresponding to the list attribute in the option list array.
[0007] In one example, determining the validation rules based on the rule object specifically includes: after the form component corresponding to the sub-form item group is created, obtaining the form component and binding the validation rules of the rule object to the corresponding form component.
[0008] In one example, the method further includes: traversing the form list array to determine the form component instance corresponding to each sub-form item group, and calling the form list array for validation; if the validation passes, storing the data object of the sub-form item group into a temporary array; after all sub-form item groups have passed validation, executing the form submission logic to call the backend interface to submit the form data.
[0009] In one example, the method further includes: obtaining the user's add request through a pre-set add button, and obtaining the user's delete request through a pre-set delete button in the sub-form item group.
[0010] In one example, the method further includes: determining a dynamic title for the subform item group based on pre-set title content, the title content including the subform serial number.
[0011] On the other hand, this application also proposes a dynamic form generation and validation device, comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the dynamic form generation and validation device to perform: the method described in any of the above examples.
[0012] On the other hand, this application also proposes a non-volatile computer storage medium storing computer-executable instructions, wherein the computer-executable instructions are configured as described in any of the above examples.
[0013] This application utilizes component-level responsive data management to separate and store form lists, display states, and selector content, decoupling data and logic and improving code maintainability. Employing circular binding and dynamic identifier technology, it allows for flexible addition and removal of sub-form item groups, automatically adapting to changes in form structure and enhancing system scalability. By controlling the selector state through a display array and dynamically updating selected items in conjunction with the option list array, it separates interactive logic from data display, improving user experience. Rule objects independently define validation rules, supporting reuse across multiple form components and reducing code duplication. A traversal validation mechanism ensures data integrity, and a temporary array stores valid data, preventing invalid submissions and improving data accuracy. Add / delete button interfaces are provided, supporting dynamic user form operations, and dynamic titles displaying sub-form numbers enhance intuitive operation. This method, through modular design, data-driven approaches, and state separation, constructs a highly reusable and easily scalable dynamic form system that meets the needs of complex business scenarios while reducing development and maintenance costs. It is suitable for mid-to-back-end management systems that require frequent adjustments to form structure or validation rules. Attached Figure Description
[0014] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments of this application and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings: Figure 1 This is a flowchart illustrating a method for generating and validating dynamic forms according to an embodiment of this application. Figure 2 This is a schematic diagram of a dynamic form generation and verification device according to an embodiment of this application. Detailed Implementation
[0015] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions of this application will be clearly and completely described below in conjunction with specific embodiments and corresponding drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.
[0016] The technical solutions provided by the various embodiments of this application are described in detail below with reference to the accompanying drawings.
[0017] like Figure 1 As shown, in order to solve the above problems, this application provides a method for generating and validating dynamic forms, the method including: S101. Determine multiple pre-set component-level responsive data, and store the corresponding data through the multiple component-level responsive data. The multiple component-level responsive data includes a form list array, a display array, a selector array, an option list array, and a rule object.
[0018] Vue is a JavaScript framework designed for building user interfaces. Built on standard HTML, CSS, and JavaScript technologies, it provides a declarative and component-based programming model. Vue features two-way data binding, where the `data` field is specifically used to store component-level reactive data, ensuring that the view automatically updates when data changes. Furthermore, Vue provides the `v-on` directive to simplify the binding process of event listeners. This directive allows developers to bind event listeners directly to specific DOM elements; its shorthand form is `@`. A Vue instance goes through several phases from creation to destruction, which together constitute Vue's lifecycle. The `mounted` phase, or the mounting completion phase, is particularly important. In this phase, the Vue instance has been successfully mounted to the DOM, allowing developers to safely access data and DOM elements, and perform related data fetching and DOM operations.
[0019] The Document Object Model (DOM) is a W3C-recommended standard programming interface for processing Extensible Markup Languages (XML), such as HTML and XML. It provides a platform- and language-independent application programming interface (API) that allows programs and scripts to dynamically access and update the content, structure, and style of a document. After processing, the document's results can be dynamically integrated into the current page. The DOM uses a tree-based document model, requiring the entire document to be loaded into memory for manipulation during processing.
[0020] User Interface (UI) refers to the overall design of a software's human-computer interaction methods, operational logic, and aesthetics, typically encompassing graphic design, web design, and mobile interface design. Node.js is a JavaScript runtime environment built on the Chrome V8 engine, employing an event-driven and non-blocking I / O model, providing a complete runtime platform for JavaScript server-side development. In the Vue framework, the native DOM event object can be accessed via the fixed parameter `$event`. This object contains complete information and parameters related to the event trigger, facilitating event handling and callback operations for developers. When the browser finishes loading the HTML document, it automatically creates a `document` object. This object, acting as a Document node in the logical tree, implements the HTML `Document` interface and contains the entire document's structural information. Developers can access and manipulate all elements on the HTML page through this object.
[0021] In one embodiment, Vue can utilize its v-for loop functionality to bind an array, dynamically generating forms by adding elements to that array. This includes a form list array `formList`, a display array `show`, a selector array `optionsItem`, an option list array `options`, and a rule object `rules`.
[0022] In practice, we first define a component-level reactive data array, formList, to store the data objects corresponding to dynamically generated sub-form item groups.
[0023] At the same time, another component-level responsive data array, show, is defined. Since column selectors are often used in forms, and column selectors need to be bound to a boolean variable to control their pop-up and collapse, this array is used to store the boolean value corresponding to each subform item group.
[0024] In addition, define another component-level reactive data array, optionsItem, as a reference for generating selector option content. The example content contains objects with value and label properties.
[0025] Each sub-form item group uses a separate array to define the list of options corresponding to its selector. For this purpose, a component-level reactive data array `options` is defined to store these sub-arrays.
[0026] Finally, define a component-level reactive data object `rules` to store custom validation rules. For example, specify that each sub-form group contains two form items: an input field and a selector field, with the corresponding field names being `inputName` and `selectName`. All validation rules require these fields. The `rules` object will configure these rules in detail.
[0027] S102. Determine the data object corresponding to the subform item group based on the form list array. The subform item group includes an input box and a selector. Determine the boolean value corresponding to the subform item group based on the display array. Determine the selection content of the selector based on the selector array. Determine the selection list of the selector corresponding to the subform item group based on the option list array. Determine the validation rules based on the rule object.
[0028] In one embodiment, a container DOM element is defined to hold form item groups, and its class name is set to `formBox`. Then, using Vue's `v-for` loop, the previously defined `formList` array is bound. By increasing or decreasing the number of elements in this array, form item groups can be dynamically generated or deleted. During the loop, `item` represents the current object in the array, and `index` represents the object's index within the array. Simultaneously, the `model` property of the form component `u-form` is dynamically bound to the current object `item` in the array, and the component's `ref` property is set to the form `'uForm' + index` to ensure that each `ref` value is unique and avoids duplication. Furthermore, `label-width` is set to 140 pixels to standardize form label width, and the error message type is specified as a toast popup.
[0029] In one embodiment, when a new subform item group needs to be added, the current array length is first obtained using `formList.length` as the index identifier `len` of the new subform. To avoid modifying the original data, `JSON.parse(JSON.stringify())` is used to deeply copy the `optionsItem` array to generate `newOptions`, and an `extra` field is added to each option object to mark the index of its respective subform. The processed `newOptions` is stored in the `options` array, and a new form data object containing `inputName` and `selectName` fields is added to `formList`, with the unique identifier `refName` set to `'uForm' + len`. Next, a boolean object `{value:false}` controlling the selector popup is added to the `show` array. Finally, the newly created form component instance is obtained using Vue's `$nextTick` method after the DOM update is complete, and its `setRules` method is called to bind predefined validation rules, ensuring that the validation logic of the newly added subform takes effect. Since the operations of the three reactive arrays are executed synchronously in the same event loop, the elements corresponding to their indices are naturally associated with the same subform item group.
[0030] In one embodiment, to clearly distinguish each dynamically generated subform item group, a view element is defined as a title container, and its class name is set to `title`. The content of this title is generated dynamically through binding and displayed as "Subform" plus the current subform's sequence number. The sequence number is calculated by incrementing the array index by one, ultimately presented as "Subform 1", "Subform 2", and so on, in a sequentially increasing format. In the template, this is achieved through a nested view structure. The outer view is named `subTitleRow`, and the inner view is named `title`. Its text content uses the interpolation expression `{{'Subform' + (index + 1)}}` to dynamically render the current subform's sequence number identifier.
[0031] In one embodiment, each sub-form item group contains two form items, the first of which is an input box component. Specifically, a view element with the class name `doFormRow` is used as a container. The form item is defined internally using a `u-form-item` component, with the left-side prompt text label set to "Input Example," and the `prop` attribute bound to `inputName` for form validation, while also marking it as required. A `u-input` input box is nested within this form item component, and the `v-model` is used for two-way binding to the `inputName` field in the current sub-form data object to achieve synchronized updates of the input value and the data. The placeholder prompt text is set to "Please enter."
[0032] In one embodiment, the second form item in each sub-form item group is a selector component, also using a view element with the class name `doFormRow` as its container. Internally, it defines the form item using the `u-form-item` component, sets the left-side tooltip label to "Select Example," and binds the `prop` attribute to `selectName` for form validation, marking it as a required field. Within this form item component, a `u-input` input field and a `u-select` selector component are nested. The input field uses `v-model` for two-way binding to the `selectName` field in the current sub-form data object to display the selected value, and sets the placeholder tooltip to "Please Select." A click event `@click="show[index].value = true"` is added; when clicked, the `value` of the corresponding object in the `show` array is set to `true`, thus controlling the pop-up of the `u-select` selector. The selector component u-select has its v-model property bound to show[index].value, which controls the pop-up and collapse states of the selector; the list property of the options list is dynamically bound to options[index], which is the subarray of the options array at the corresponding index; the color of the confirm button is set to #3db567, and the @confirm="select" event is triggered when the selection is confirmed.
[0033] In one embodiment, the JavaScript method triggered by the confirm event of the u-select component is defined as select, and its callback parameter is e. The parameter e is an array, where the unique element is the selected option object in the corresponding subarray of the options array. This object contains three fields: value, label, and extra. In the select method, by accessing the extra field of the first element e[0] of the callback parameter e, this field can be used as a unique identifier to locate the corresponding subform data object in the formList array. The label field value of the selected option object e[0] is assigned to the selectName field of the subform data object, so that the selected value is dynamically displayed in the input box of the current form item.
[0034] In one embodiment, a JavaScript method named `deleteItem` is defined to delete a specified subform item group. This method takes the index of the current subform item group as a parameter. Internally, the `splice()` method of the arrays is called to delete the element at the corresponding index from the three component-level reactive data arrays: `formList`, `options`, and `show`. Only one element is deleted from each array. This allows for the simultaneous removal of all data associated with the target subform item group from the three arrays, thus completing the overall deletion of the subform item group.
[0035] S103. Iterate through the form list array to validate each sub-form item group, and execute the submission logic for the validated sub-form item group.
[0036] In one embodiment, a JavaScript method named `submit` is defined to submit the entire form content. First, an empty array `list` is declared to store the validated subform data objects. Then, the `formList` array is iterated through, retrieving the corresponding form component instance through the `refName` field of each object and calling its `validate` method for validation. If validation passes (i.e., `valid` is true), the current subform data object `item` is added to the `list` array; if validation fails, an error log is output. After iteration, it is checked whether the `list` array is not empty and has the same length as `formList`, meaning all subforms have passed validation. If the conditions are met, the actual submission logic is executed, such as calling an API.
[0037] like Figure 2 As shown in the illustration, this application also provides a dynamic form generation and validation device, including: At least one processor; and, A memory that is communicatively connected to at least one processor; wherein, The memory stores instructions that can be executed by at least one processor to enable a dynamic form generation and validation device to perform the method described in any of the above embodiments.
[0038] This application also provides a non-volatile computer storage medium storing computer-executable instructions, which are configured as described in any of the above embodiments.
[0039] In the 1990s, improvements to a technology could be clearly distinguished as either hardware improvements (e.g., improvements to the circuit structure of diodes, transistors, switches, etc.) or software improvements (improvements to the methodology). However, with technological advancements, many methodological improvements today can be considered direct improvements to the hardware circuit structure. Designers almost always obtain the corresponding hardware circuit structure by programming the improved methodology into the hardware circuit. Therefore, it cannot be said that a methodological improvement cannot be implemented using hardware physical modules. For example, a Programmable Logic Device (PLD) (such as a Field Programmable Gate Array (FPGA)) is such an integrated circuit whose logic function is determined by the user programming the device. Designers can program and "integrate" a digital system onto a PLD themselves, without needing chip manufacturers to design and manufacture dedicated integrated circuit chips. Furthermore, nowadays, instead of manually manufacturing integrated circuit chips, this programming is mostly implemented using "logic compiler" software. Similar to the software compiler used in program development, the original code before compilation must also be written in a specific programming language, called a Hardware Description Language (HDL). There are many HDLs, such as ABEL (Advanced Boolean Expression Language), AHDL (Altera Hardware Description Language), Confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), Lava, Lola, MyHDL, PALASM, and RHDL (Ruby Hardware Description Language). Currently, the most commonly used are VHDL (Very-High-Speed Integrated Circuit Hardware Description Language) and Verilog. Those skilled in the art should also understand that by simply performing some logic programming on the method flow using one of these hardware description languages and programming it into an integrated circuit, the hardware circuit implementing the logical method flow can be easily obtained.
[0040] The controller can be implemented in any suitable manner. For example, it can take the form of a microprocessor or processor and a computer-readable medium storing computer-readable program code (e.g., software or firmware) executable by the (micro)processor, logic gates, switches, application-specific integrated circuits (ASICs), programmable logic controllers, and embedded microcontrollers. Examples of controllers include, but are not limited to, the following microcontrollers: ARC 625D, Atmel AT91SAM, Microchip PIC18F26K20, and Silicon Labs C8051F320. A memory controller can also be implemented as part of the control logic of the memory. Those skilled in the art will also recognize that, in addition to implementing the controller in purely computer-readable program code form, the same functionality can be achieved by logically programming the method steps to make the controller take the form of logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded microcontrollers. Therefore, such a controller can be considered a hardware component, and the means included therein for implementing various functions can also be considered as structures within the hardware component. Alternatively, the means for implementing various functions can be considered as both software modules implementing the method and structures within the hardware component.
[0041] The systems, devices, modules, or units described in the above embodiments can be implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a computer. Specifically, a computer can be, for example, a personal computer, laptop computer, cellular phone, camera phone, smartphone, personal digital assistant, media player, navigation device, email device, game console, tablet computer, wearable device, or any combination of these devices.
[0042] For ease of description, the above devices are described in terms of function, divided into various units. Of course, in implementing this specification, the functions of each unit can be implemented in one or more software and / or hardware.
[0043] The various embodiments in this application are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the device and medium embodiments are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the description of the method embodiments.
[0044] The devices and media provided in this application are one-to-one with the methods. Therefore, the devices and media also have similar beneficial technical effects as their corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the devices and media will not be repeated here.
[0045] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code. This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.
[0046] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.
[0047] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.
[0048] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.
[0049] Memory may include non-persistent storage in computer-readable media, such as random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. Memory is an example of computer-readable media.
[0050] Computer-readable media includes both permanent and non-permanent, removable and non-removable media that can store information using any method or technology. Information can be computer-readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, magnetic magnetic disk storage or other magnetic storage devices, or any other non-transferable medium that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transient computer-readable media, such as modulated data signals and carrier waves.
[0051] It should also be noted that the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such process, method, article, or apparatus. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes that element.
[0052] The above are merely embodiments of this application and are not intended to limit the scope of this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the scope of the claims of this application.
Claims
1. A method for generating and validating a dynamic form, characterized in that, The method comprises the following steps: determining a plurality of preset component-level responsive data, corresponding data storage is performed through the plurality of component-level responsive data, the plurality of component-level responsive data includes a form list array, a display array, a selector array, an option list array, and a rule object; determining a data object corresponding to a sub-form item group according to the form list array, the sub-form item group includes an input box and a selector, determining a Boolean value corresponding to the sub-form item group according to the display array, determining selection content of the selector according to the selector array, determining a selection list of the selector corresponding to the sub-form item group according to the option list array, and determining a verification rule according to the rule object; iterating the form list array to verify each sub-form item group, and executing a submission logic on the sub-form item group after verification.
2. The method of claim 1, wherein, The method further comprises the following steps: binding the form list array through a preset loop function to determine a form item group, changing elements in the form list array to change the form item group, and determining an identifier corresponding to the form item group according to a preset form attribute.
3. The method of claim 1, wherein, The method further comprises the following steps: determining a newly added sub-form item group, determining an initial value corresponding to the newly added sub-form item group, and adding the initial value to the display array; modifying the Boolean value corresponding to the display array to control the state of the selector of the sub-form item group.
4. The method of claim 1, wherein, The method further comprises the following steps: determining a newly added sub-form item group, copying the selector array to a new array, and determining a new identifier; storing the new array to the option list array to determine a selector option list corresponding to the newly added sub-form item group; determining a list attribute of the selector in the sub-form item group, and binding the list attribute to an index position corresponding to the option list array.
5. The method of claim 1, wherein, The method further comprises the following steps: after the creation of the form component corresponding to the sub-form item group is completed, obtaining the form component, and binding the verification rule of the rule object to the corresponding form component.
6. The method of claim 1, wherein, The method further comprises the following steps: iterating the form list array, determining a form component instance corresponding to each sub-form item group, and calling the form list array for verification; if the verification is passed, storing the data object of the sub-form item group into a temporary array; after all the sub-form item groups are verified, executing a form submission logic to call a backend interface to submit form data.
7. The method of claim 1, wherein, The method further comprises the following steps: obtaining a user's addition request through a preset addition button, and obtaining a user's deletion request through a preset deletion button in the sub-form item group.
8. The method of claim 1, wherein, The method further comprises the following steps: determining a dynamic title of the sub-form item group according to preset title content, the title content including a sub-form serial number.
9. A device for generating and validating a dynamic form, characterized in that, The method comprises the following steps: at least one processor; and a memory connected in communication with the at least one processor; wherein The memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the dynamic form generation and verification device to perform the method as claimed in any one of claims 1-8.
10. A non-transitory computer storage medium storing computer-executable instructions that, when executed, cause a computer to perform: The computer executable instructions are arranged to perform the method as claimed in any one of claims 1-8.