CN116860224A - Two-dimensional code component and object generation method and system under code-free development environment - Google Patents

Two-dimensional code component and object generation method and system under code-free development environment Download PDF

Info

Publication number
CN116860224A
CN116860224A CN202211668793.5A CN202211668793A CN116860224A CN 116860224 A CN116860224 A CN 116860224A CN 202211668793 A CN202211668793 A CN 202211668793A CN 116860224 A CN116860224 A CN 116860224A
Authority
CN
China
Prior art keywords
dimensional code
query
action
subset
component
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
Application number
CN202211668793.5A
Other languages
Chinese (zh)
Inventor
翁杰
张晨一
陈思中
胡君
程瑛
刘鹏
胡凡
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Suzhou Fumuyun Technology Co ltd
Original Assignee
Suzhou Fumuyun Technology Co ltd
Priority date (The priority date 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 date listed.)
Filing date
Publication date
Application filed by Suzhou Fumuyun Technology Co ltd filed Critical Suzhou Fumuyun Technology Co ltd
Priority to CN202211668793.5A priority Critical patent/CN116860224A/en
Publication of CN116860224A publication Critical patent/CN116860224A/en
Pending legal-status Critical Current

Links

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/34—Graphical or visual programming
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
    • G06F3/01—Input arrangements or combined input and output arrangements for interaction between user and computer
    • G06F3/048—Interaction techniques based on graphical user interfaces [GUI]
    • G06F3/0484—Interaction techniques based on graphical user interfaces [GUI] for the control of specific functions or operations, e.g. selecting or manipulating an object, an image or a displayed text element, setting a parameter value or selecting a range
    • G06F3/0486—Drag-and-drop
    • 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
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/70—Software maintenance or management
    • G06F8/71—Version control; Configuration management
    • Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
    • Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
    • Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
    • Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management

Abstract

The invention discloses a two-dimensional code component and object generation method and system under a code-free development environment, wherein the method comprises the steps of establishing a visual element set of the two-dimensional code component under the code-free development environment; establishing a behavior element rule base of the two-dimensional code assembly in the design under the code-free development environment; object instantiation is carried out on the two-dimensional code component in design; respectively configuring input parameters and output action sets in running for the two-dimensional code object obtained by object instantiation; and initializing a page based on the visualized element set, the behavior element rule base, the input parameters and the output action set, executing page operation, and completing the generation of the two-dimensional code assembly and the object. The method and the device realize the generation of the two-dimensional code component and the object, and give consideration to the two-dimensional code component in two states in design and operation, so that the two-dimensional code component keeps consistent visual appearance in the two states, and the realization efficiency of the two-dimensional code object generation and interaction between the two-dimensional code component and the associated page object set is greatly improved in a more visual mode.

Description

Two-dimensional code component and object generation method and system under code-free development environment
Technical Field
The invention relates to the field of two-dimensional code assembly and object generation, in particular to a two-dimensional code assembly and object generation method and system under a code-free development environment.
Background
The various components (including controls) in the software pages and forms have two tenses, one is "design time" and the other is "runtime". "design time" refers to the state in which a developer develops a component in a designer, while in the development phase; and "runtime" refers to the program being in the runtime phase, for example, when a button control is in the designer's form, it is "at design time".
In the traditional development mode, all components are represented as code modules, the actual representation of the components in design is also code, and the multiplexing of the components can only be referenced after being packaged in the form of the code modules, so that the appearance of the components can be presented only when the code is compiled and run after the runtime code passes.
In the code-free development environment, the objectification of various components in the software page and the form is mainly realized in a dragging mode, the components are instantiated as objects after being dragged to the design panel, and at the moment, the instantiated objects belong to static objects and are concepts in a design time state. When software built through a code-free environment is deployed and run, the component will be transformed into a dynamic object, which is the concept in the runtime state. Thus, when designing and implementing components in a code-free development environment, it is also desirable to compromise both the design time and the runtime state of the component.
In a code-free development environment, the components under design are visible, the basic appearance is consistent with the runtime, all reusable components can be realized as a member of a code-free component library and presented in a visual manner, and only part of appearance attributes designed to be dynamically valued can present different states in the runtime than in the design. Therefore, compared with the traditional development process, the development process in the code-free environment is more visual, and the generation of the components and the objects in the code-free development environment is of great significance.
With the rapid development of the internet and the internet of things and the popularization of intelligent terminal equipment, the two-dimensional code component is the most commonly used component in various software pages and forms. The two-dimensional code is used as one of design components, generally exists in a picture form in a component library, and is a two-dimensional code object when being designed when being dragged to be instantiated in a design panel. The relation between the two-dimensional code component and the two-dimensional code object is that the two-dimensional code component exists in the component library and is a member in the component set, the two-dimensional code component is selected from the component library and dragged into the canvas, and a new two-dimensional code object is created in the canvas.
However, at present, research results for realizing two-dimensional code assembly and object generation in a code-free development environment under the two conditions of design time and operation time of the assembly are not achieved at the same time.
Disclosure of Invention
In view of the above, the invention provides a two-dimensional code component and object generation method and system in a code-free development environment, which realize the generation of the two-dimensional code component and the object in a dragging and configuration mode without writing codes, and the two-dimensional code component in two states of design and operation is considered, so that the realization efficiency of the generation of the two-dimensional code object is greatly improved.
The invention provides a two-dimensional code assembly and object generation method in a code-free development environment, which comprises the following steps:
establishing a visual element set of a two-dimensional code component in a code-free development environment;
establishing a behavior element rule base of the two-dimensional code assembly in the design under a code-free development environment;
object instantiation is carried out on the two-dimensional code component in design;
respectively configuring input parameters and output action sets in running for the two-dimensional code object obtained by object instantiation;
and initializing a page based on the visual element set, the behavior element rule base, the input parameters and the output action set, and executing page operation to complete the generation of the two-dimensional code component and the object.
Optionally, the visual element set includes a design-time visual element subset and a runtime visual element subset;
The subset of visual elements at design time is defined as: da= { DA 1 ，da 2 ，da 3 ，......，da n }；
Wherein DA is the subset of visual elements for the design, DA 1 ，da 2 ，da 3 ,...and da.) n The visual attributes of the two-dimensional code component in design are all shown; n is the total number of visual attributes of the two-dimensional code component in design, and n is more than or equal to 1;
the subset of runtime visualization elements is defined as: ra= { RA 1 ，ra 2 ，ra 3 ，......，ra m }；
Wherein RA is the subset of visual elements at runtime, RA 1 ，ra 2 ，ra 3 ,...and ra n The visual attributes of the two-dimensional code component in the running process are all the visual attributes of the two-dimensional code component in the running process; m is the total number of visual attributes of the two-dimensional code component in operation, and m is more than or equal to 1;
the design time visual element subset and the run time visual element subset further satisfy: RA n da=da.
Optionally, after the behavior element rule base of the two-dimensional code component in the code-free development environment is established, the method further includes:
dividing the behavior element rule base into a component behavior rule set and an object behavior rule set based on the visual element subset in design;
behavior in the behavior element rule baseThe element set is defined as: de= { DE 1 ，de 2 ，de 3 ，......，de X }；
Wherein DE is the behavior element set, DE 1 ，de 2 ，de 3 ,...and de X All are behavior elements in the behavior element set; x is the total number of the behavior elements in the behavior element rule base, and X is more than or equal to 1.
Optionally, the instantiating the two-dimensional code component in the design includes:
defining the format and storage form of the two-dimensional code component during object instantiation by adopting a description language of a JSON format;
based on the format and the storage form, establishing a rule relation among object instantiation, object storage and object rendering of the two-dimensional code component;
and carrying out object instantiation on the two-dimensional code component in design according to the rule relation.
Optionally, configuring input parameters of the running process for the two-dimensional code object obtained by object instantiation includes:
setting a URL source in a design time environment;
and carrying out URL assignment on the URL source under the running environment to obtain the input parameters.
Optionally, the input parameters include static parameter values and dynamic parameter values;
wherein the static parameter value refers to a fixed value, and the dynamic parameter value comprises four parameters including a component, an action parameter, a global variable, a variable and an event parameter.
Optionally, the output action set refers to a series of action sets of an object set in a URL page pointed by the two-dimensional code object, including a read-only class action subset and an editable class action subset;
The subset of read-only actions is { page initialization, nested query, assignment of values to page objects, page operation, closing } in order, and the subset of editable actions is { page initialization, nested query, assignment of values to page objects, page operation, save/modify, closing } in order.
Optionally, the nested queries in the subset of read-only class actions and the subset of editable class actions each comprise a combination of one or more sets of query actions.
Optionally, the number of times the nested queries in the subset of read-only class actions and the subset of editable class actions are each greater than or equal to 0;
setting the number of times of nested queries as N;
when n=0, the two-dimensional code object points to the content required to be filled by the object set in the URL page, the nested query directly transmits assignment through URL parameters, and the combination number of the nested query is 1;
when n=1, the nested query obtains the assignment content of the object set in the URL page through a single query, and the number of combinations of the nested query is 1;
when N is greater than or equal to 2, the nested queries fall into two categories:
the first category, the nested queries are expressed in order as a first set of query actions FQ 1 ＝{fq 1 ，fq 2 ，fq 3 ，......，fq i1 ，......，fq Y }；
Wherein FQ 1 For the first query action set, fq 1 ，fq 2 ，fq 3 ，......，fq i1 ,...and fq Y Are valid query actions in the first set of query actions; y is the total number of effective query actions in the first query action set, and Y is more than or equal to 2; ith 1-1 valid query action fq i1-1 Part or all of the result set of (1) is the i1 st valid query action fq i1 In which case the first set of query actions FQ 1 Number of combinations NP of (2) 1 The method meets the following conditions: NP (NP) 1 ＝1；
A second class, the nested queries being expressed in order as a second set of query actions FQ 2 ＝{fq 1 ，fq 2 ，fq 3 ，......，fq i2 ，......，fq Z }；
Wherein FQ 2 For the second set of query actions, fq 1 ，fq 2 ，fq 3 ，......，fq i2 ,...and fq Z Are valid query actions in the second set of query actions; z is the total number of effective query actions in the first query action set, and Z is more than or equal to 2; ith 2-1 valid query action fq i2-1 Results set and i2 th valid query action fq i2 There is or is not an intersection of the query input parameter sets of (a);
setting the second query action set FQ 2 The combined result set obtained after all the effective inquiry actions are completed is FQR;
the second query action set FQ 2 The following rules of convention exist for the execution order of (a):
(1) if fq i2-1 ∈FQ 2 ，fq i2 ∈FQ 2 And fq i2-1 Results set R (fq) i2-1 ) And fq i2 Is a query input parameter set I (fq i2 ) There is no intersection, i.e. I (fq i2 ) The elements in (2) may not be derived from R (fq i2-1 ) The second query action set FQ 2 Any available query action in (1) can redefine the query order arbitrarily, in which case the second set of query actions FQ 2 Number of combinations NP of (2) 2 The method meets the following conditions: NP (NP) 2 =z-! =z (Z-1) (Z-2) 2*1, and NP 2 The combination of species results in a completely consistent combined result set fqr=r (fq 1 )∪R(fq 2 )∪......∪R(fq Z )；
(2) Definition of fq k-1 ∈FQ 2 ，fq k ∈FQ 2 ，fq k+1 ∈FQ 2 ，fq s-1 ∈FQ 2 ，fq s ∈FQ 2 ，fq s+1 ∈FQ 2 Form a first sequential action subset { fq } k-1 ，fq k ，fq k+1 And a second subset of sequential actions { fq } s-1 ，fq s ，fq s+1 No necessary intersection exists between the result set of any action and the query input parameter set of the following action in the first sequence action subset and the second sequence action subset, then fq k And fq s At FQ 2 The positions in the query sequence can be randomly changed, so that the query sequence can be locally redefined;
if FQ 2 There are p first combined element subsets nk= { NK with randomly permutable order 1 ，nk 2 ， ...... ，nk p Second subset nq= { NQ of combined elements that are not randomly permutated 1 ，nq 2 ，......，nq q }＝{{fq a ，fq a+1 ，...，fq a+d }，{fq b ，fq b+1 ，...，fq b+j }，......，{fq x ，fq x+1 ，...，fq x+y }}；
Wherein { fq a ，fq a+1 ，...，fq a+d First group of combined elements in second combined element subset, fq a ，fq a+1 ，...，fq a+d Are elements in the first group of combined elements; { fq b ，fq b+1 ，...，fq b+j And is a second group of combined elements in the second subset of combined elements, fq b ，fq b+1 ，...，fq b+j Are elements in the second group of combined elements; … … { fq x ，fq x+1 ，...，fq x+y The q-th group of combined elements in the second combined element subset, fq x ，fq x+1 ，...，fq x+y Are all elements in the q-th group of combined elements; NK n FQ 2 When nq∈nq for any nq=nk, NQ n_fq=nq; the second query action set FQ 2 Number of combinations NP of (2) 2 The method meets the following conditions: NP (NP) 2 = (p+q) ++! = (p+q), (p+q-1), (p+q-2),. The number 2*1, and NP 2 The seed combinations all gave a completely identical result set fqr=r (nk 1 )∪R(nk 2 )∪......∪R(nk p )∪R(nq 1 )∪R(nq 2 )∪......∪R(nq q )。
In addition, the invention also provides a two-dimensional code assembly and object generation system in the code-free development environment, which is applied to the two-dimensional code assembly and object generation method in the code-free development environment, and comprises the following steps:
the element set establishing module is used for establishing a visual element set of the two-dimensional code component in the code-free development environment;
the element rule establishing module is used for establishing a behavior element rule base of the two-dimensional code assembly in the design under the code-free development environment;
the object instantiation module is used for carrying out object instantiation on the two-dimensional code component in design;
the parameter configuration module is used for respectively configuring input parameters and output action sets in running for the two-dimensional code object obtained by object instantiation;
and the initialization module is used for initializing a page based on the visual element set, the behavior element rule base, the input parameters and the output action set, executing page operation and completing the generation of the two-dimensional code assembly and the object.
The invention has the beneficial effects that: the method has the advantages that the states of the two-dimensional code assembly at the time of design and the time of operation can be considered simultaneously by establishing a visualized element set and a behavior element rule base at the time of design under the code-free development environment and configuring an input parameter and an output action set at the time of operation; the two-dimensional code group is subjected to object instantiation during design, and finally, the initialization page and page operation are performed based on the visual element set, the behavior element rule base and the input parameters and the output action set configured after object instantiation, so that the two-dimensional code component and the page initialization operation pointed by the two-dimensional code are realized, codes do not need to be written, the two-dimensional code component and the object generation are further realized, the two-dimensional code component in two states of design and operation are considered, the consistent visual appearance of the two-dimensional code component is kept in the two states, and the realization efficiency of the two-dimensional code object generation and interaction between the two-dimensional code object and the associated page object set is improved in a more visual mode.
Drawings
The features and advantages of the present invention will be more clearly understood by reference to the accompanying drawings, which are illustrative and should not be construed as limiting the invention in any way, in which:
FIG. 1 is a flowchart of a two-dimensional code component and an object generation method in a code-free development environment according to an embodiment of the present invention;
fig. 2a and fig. 2b each show a schematic diagram of an instantiation of a two-dimensional code component in a design panel and 8 fixing points of a two-dimensional code object in the design panel in the first embodiment of the present invention, where fig. 2a shows that the two-dimensional code object is fixed in a page, and fig. 2b shows that the two-dimensional code object is suspended on the page;
fig. 3a and fig. 3b are schematic diagrams respectively showing an action process of a read-only page and an editable page associated with a two-dimensional code object in a runtime state in the first embodiment of the invention, where fig. 3a shows an action process of the read-only page, and (b) shows an action process of the editable page;
FIG. 4 is a diagram showing a result page of a nested query that is a complete sequential query when the number of times N of the nested query is greater than or equal to 2 in the first embodiment of the present invention;
FIGS. 5a and 5b each show a schematic diagram of a result page of a nested query that is a non-complete sequential query when the number of times N of the nested query is equal to or greater than 2 in the first embodiment of the present invention, wherein FIG. 5a shows a schematic diagram of a page result in which no sequential relationship exists between all query actions, and FIG. 5b shows a schematic diagram of a page result in which a sequential relationship exists between partial query actions;
Fig. 6 shows a block diagram of a two-dimensional code component and an object generating system in a code-free development environment in the first embodiment of the present invention.
Detailed Description
For the purpose of making the objects, technical solutions and advantages of the embodiments of the present invention more apparent, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention, and it is apparent that the described embodiments are some embodiments of the present invention, but not all embodiments of the present invention. All other embodiments, which can be made by those skilled in the art based on the embodiments of the invention without making any inventive effort, are intended to fall within the scope of the invention.
Example 1
As shown in fig. 1, a method for generating a sawtooth wavy line pattern in a laser path includes:
s1: and establishing a visual element set of the two-dimensional code component in the code-free development environment.
In this embodiment, the visual elements of the two-dimensional code are divided into the visual elements at design time and the visual elements at operation time, so that the established visual element set includes the visual element subset at design time and the visual element subset at operation time.
Visualization during design refers to that in a code-free development environment, a two-dimensional code is used as one of design components, and generally exists in a picture form in a component tool box, and is instantiated as a design-time two-dimensional code object when dragged into a design panel.
The two-dimensional code component is defined as a subset of visual elements in the design panel when the two-dimensional code component is designed: da= { DA 1 ，da 2 ，da 3 ，......，da n }；
Wherein DA is the subset of visual elements for the design, DA 1 ，da 2 ，da 3 ,...and da.) n The visual attributes of the two-dimensional code component in design are all shown; n is the total number of visual attributes of the two-dimensional code component in design, and n is more than or equal to 1;
in this embodiment, the subset of the visual elements in the design is { width, height, positioning mode, horizontal position, vertical position, size, preview, static address }, and the visual attribute in the subset is defined in the code level expression mode as shown in the following table 1.
The runtime visualization refers to the appearance of the two-dimensional code component when the two-dimensional code component is designed and applied to a specific application program and the application program runs normally.
The subset of runtime visualization elements represented by the two-dimensional code component in the runtime application is defined as: ra= { RA 1 ，ra 2 ，ra 3 ，......，ra m }；
Wherein RA is the subset of visual elements at runtime, RA 1 ，ra 2 ，ra 3 ,...and ra n The visual attributes of the two-dimensional code component in the running process are all the visual attributes of the two-dimensional code component in the running process; m is the total number of the visual attributes of the two-dimensional code component in operation, and m is more than or equal to 1.
In this embodiment, the running visualization element subset of the two-dimensional code component is specifically { width, height, positioning mode, horizontal position, vertical position, size, whether preview, static address, dynamic parameter }, in principle RA n da=da, and when RA is arbitrary, since the setting of the visualization attribute during design agrees the fixed content and the variable content of the two-dimensional code object visualization during running, the value of each RA in RA may be derived from the configuration value during design or from the value transmitted by the running application program.
As shown in fig. 1, the method includes:
s2: and establishing a behavior element rule base of the two-dimensional code assembly in the design under the code-free development environment.
After S2, further comprising:
based on the visual element subset at design time, the behavior element rule base is divided into a component behavior rule set and an object behavior rule set.
On the basis of the visual element set in S1, the behavior element rule base in the design time state is divided into a component behavior rule set and an object behavior rule set, and all behavior rules of the two-dimensional code component are required to be in the range of the behavior element rule base. The relation between the two-dimensional code component and the two-dimensional code object is that the two-dimensional code component exists in the component library and is a member in the component set, the two-dimensional code component is selected from the component library and dragged into the canvas, and a new two-dimensional code object is created in the canvas.
The behavior element set of the behavior element rule base of the environment of the two-dimensional code component in design is positioned as follows: de= { DE 1 ，de 2 ，de 3 ，......，de X }；
Wherein DE is the behavior element set, DE 1 ，de 2 ，de 3 ,...and de X All are behavior elements in the behavior element set; x is the total number of behavioral elements in the behavioral element rule base,meets X not less than 1.
In this embodiment, the set of behavior elements is { single click, drag, add, delete, move, copy, paste, zoom }, where the set of behavior elements of the component behavior rule set is { single click, drag, add }, and the set of behavior elements of the object behavior rule set is { single click, delete, move, copy, paste, zoom }.
The behavior rules in the behavior element rule base in this embodiment are as follows:
rule 1: the code level corresponding to any behavior B is realized as a function f triggered by a two-dimensional code component or an object event B ；
Rule 2: arbitrary object function f B The input parameters of the behavior are null, and the object main body of the behavior is obtained by selecting the child object of the page this in the process of executing the function;
rule 3: the clicking action is the prepositive action of any other action, and the effective result of the clicking action is to select one two-dimensional code component or object, and simultaneously, the clicking action is the prepositive condition of two-dimensional code object attribute setting, data binding and event arrangement;
rule 4: the sequential combination of dragging and adding is a mode of creating a new two-dimensional code object in the canvas through a component library;
rule 5: the deleting, moving and copying actions only take effect after the clicking action occurs and one two-dimensional code object is determined to be selected;
rule 6: the copying behavior is a prepositive behavior of the pasting behavior, and the pasting behavior takes effect if and only if the copying behavior occurs and a two-dimensional code object is determined to be selected;
rule 7: the scaling behavior is effective after a two-dimensional code object is selected through a clicking behavior and fixed points in a frame of the two-dimensional code object are captured by a mouse, as shown in fig. 2a and 2b, fig. 2a and 2b show schematic diagrams of instantiation of a two-dimensional code component in a design panel and 8 fixed points of the two-dimensional code object in the design panel, wherein fig. 2a shows that the two-dimensional code object is fixed in a page, and fig. 2b shows that the two-dimensional code object is suspended on the page;
Rule 8: the clicking behavior is the only prepositive behavior for realizing attribute configuration, data binding and event arrangement of the two-dimensional code object.
As shown in fig. 1, the method includes:
s3: and carrying out object instantiation on the two-dimensional code component in design.
S3 comprises the following steps:
defining the format and storage form of the two-dimensional code component during object instantiation by adopting a description language of a JSON format;
based on the format and the storage form, establishing a rule relation among object instantiation, object storage and object rendering of the two-dimensional code component;
and carrying out object instantiation on the two-dimensional code component in design according to the rule relation.
The embodiment adopts the description language of the JSON format to define the format and the storage form of the two-dimensional code component during object instantiation, can be convenient for establishing the rule relation between the object instantiation of the two-dimensional code component and the object storage and the object rendering in the follow-up, can realize that the two-dimensional code component can be instantiated into a new two-dimensional code object after being dragged into the design panel through the rule relation completely related between the object instantiation, the object storage and the object rendering, and ensures that the two-dimensional code object in the design panel can be saved and re-rendered at any time.
The two-dimensional code component is one of a plurality of components in a code-free development environment, the components share a plurality of attributes or characteristics, and the JSON format of a two-dimensional code object obtained after the two-dimensional code component is instantiated is defined as follows:
{ "tag": "qrcode", "basicInfo": { "name": "two-dimensional code", "icon" fmy-erweima "," group "means [" component "]," drop ": [" prev "," next "]," type ": component", "position": false "," allowtdrop ": true," data "{" application range ": {" layout ": two-dimensional code", "width":300 "," height ": 300", "width": "px", "height": "px", "position": "contact": "region", "top":0 "," top ": front", "left":0 "," plug ": 0", "box": 200 "," view ": plug": 0 "," box ": 38 of the component", "plug", "box": 0 "," box "{ 200/region }" plug ": 0".
Tag, basicInfo and data are three primary labels, which respectively represent dynamic component identification, component basic information, layout and data behavior information, and qrcode represents tag values of two-dimensional code components; the basicInfo contains a component name, a component display icon, a belonging group and the like; the data contains the appearance, layout, action, bound static link and other contents of the components, and is divided into two levels of sub-labels, wherein the two levels of sub-labels comprise application and action, and other specific contents respectively form the next level of labels and attributes of the application and the action.
As shown in fig. 1, the method includes:
s4: and respectively configuring input parameters and output action sets in the running process for the two-dimensional code object obtained by object instantiation.
S4, configuring input parameters in operation for the two-dimensional code object obtained by object instantiation, wherein the input parameters comprise:
setting a URL source in a design time environment;
and carrying out URL assignment on the URL source under the running environment to obtain the input parameters.
The above process of configuring the input parameters during operation is performed in the design environment, and each instantiated two-dimensional code object corresponds to a set of personalized parameter value sets (the parameter value sets are called as input parameters), and the parameter value types are divided into two main types of static parameter values and dynamic parameter values. URL is the only way to transfer parameter value set, URL source is set in design time environment, URL assignment is carried out in running time environment through context, and parameter value type (including static parameter value and dynamic parameter value) is agreed at the same time, so that configuration of output parameters can be realized. Wherein, the static parameter value refers to a fixed value, and the dynamic parameter value comprises four parameters of a component, an action parameter, a global variable, a variable and an event parameter.
The essence of the two-dimensional code object is that the mapping relation of the URL and the two-dimensional code image is unique as a result of the picture processing of the URL address, so that the URL is the direct content of the two-dimensional code object, and the webpage pointed by the URL is the indirect content represented by the two-dimensional code object. Accordingly, the generation of the URL includes static generation and dynamic generation. The two-dimensional code object corresponding to the statically generated URL has no input parameters and the expression form is generally "ip/application route". The two-dimensional code object corresponding to the dynamic generation URL is derived from a certain page when the application program runs, and input parameters are divided into two types: the first class, the static class (i.e., static parameter value), the URL request instruction directly contains all parameters required for filling the content of the web page to which it points; the second category, dynamic category, URL request command only includes obtaining the query parameter of the filling content of the webpage pointed by the URL request command, when the webpage is initialized, the specific query method is called, the query parameter is used as the input parameter, and the output result is filled into the webpage after the query method is executed. The format of the parameterized URL is "ip/application route/parameter 1=value 1& parameter 2=value 2" &..once again.& parameter t=value t ", wherein t is greater than or equal to 1. The type Pt of parameter value is { component, action out parameter, global variable, fixed value, variable, event in parameter }. If Pt=the component, the parameter obtains a value set of a specific component set through the page this where the two-dimensional code object is located; if pt=act parameter, parameter is obtained by the action sequence parameter of the two-dimension code object operation; if Pt=global variable, acquiring parameters through the page this where the two-dimensional code object is located; if pt=fixed value, the parameter is directly set to the fixed value; if pt=variable, assigning the variable to the parameter, and dynamically calculating and obtaining the variable when the application program runs; if pt=event entry, the two-dimensional object triggers the entry parameters of the event domain in which the action is located.
S4, outputting an action set to refer to a series of action sets of an object set in a URL page pointed by the two-dimensional code object, wherein the action sets comprise a read-only action subset and an editable action subset;
the subset of read-only actions is { page initialization, nested query, assignment of values to page objects, page operation, closing } in order, and the subset of editable actions is { page initialization, nested query, assignment of values to page objects, page operation, save/modify, closing } in order.
The output of the instantiation two-dimension code object is a series of action sets of an object set in a URL page pointed by the two-dimension code, and the action sets comprise a read-only type action subset and an editable type action subset. The page types are divided into two types, namely read-only type and editable type, correspondingly, the action sets of the read-only type (namely the read-only type action subsets) are sequentially { page initialization, nested inquiry, page object assignment, page operation and closing }, and the action sets of the editable type (namely the editable type action subsets) are sequentially { page initialization, nested inquiry, page object assignment, page operation, storage/modification and closing }.
The combination of action sets is mainly embodied in nested queries. The nested query is actually not only a query, but also may include processing a part of query results, for convenience of description, the processing of the query and its result set is collectively referred to as a query, and is regarded as a complete set of query actions, for example, the result set of the query action Q1 is the result R1, and after the R1 is processed by the processing action P1, the result R2 is obtained, where the R2 is the final result of the process, and in the present invention, the whole process of obtaining R2 is also referred to as a query. As shown in fig. 3a and 3b, fig. 3a is a schematic diagram of an action process of a read-only page associated with a two-dimensional code object in a runtime state, and fig. 3b is a schematic diagram of an action process of an editable page associated with a two-dimensional code object in a runtime state.
When configuring the output action set in the running process, the combination of nested queries is very important, and a plurality of query action combination methods are often available for acquiring the same query result set, and only a unique combination method is available under special conditions, so that the nested queries in the read-only action subset and the editable action subset both comprise the combination of one or more query action sets.
Typically, the number of nested queries N.gtoreq.0.
When n=0, the URL pointed to by the two-dimensional code object represents that the content to be filled in the object set in the URL page (including the FixedPage or the page object) is directly assigned by the URL parameter, and in this case, the number of combinations of nested queries is 1.
When n=1, the assigned content of the page object can be obtained through a single query, and in this case, the number of combinations of nested queries is also 1.
When N is greater than or equal to 2, the query process in nested queries is divided into two categories:
(1) The first class (complete sequence query class for short), the query results with the front sequence are used as the query input parameters with the rear sequence and expressed as a first query action set FQ in sequence 1 ＝{fq 1 ，fq 2 ，fq 3 ，......，fq i1 ，......，fq Y }；
Wherein FQ 1 For the first query action set, fq 1 ，fq 2 ，fq 3 ，......，fq i1 ,...and fq Y Are all valid query actions in the first query action set, any fq i1 ∈FQ 1 Representing any effective query action, wherein Y is the total number of the effective query actions in the first query action set, and satisfies Y more than or equal to 2; ith 1-1 valid query action fq i1-1 Part or all of the result set of (1) is the i1 st valid query action fq i1 In which case the first set of query actions FQ 1 Number of combinations NP of (2) 1 The method meets the following conditions: NP (NP) 1 ＝1。
As shown in FIG. 4, when the number of nested queries N.gtoreq.2, FIG. 4 is a schematic diagram of a result page of a complete sequential query, the values of all the components in FIG. 4 are queried and populated by only one sequential combination of query value 1, query value 2, query value 3, query value 4, query value 5, query value 6, query value 7, query value 8, where value e represents the population of component e. Of course, in actual operation, it is possible that part of the neighboring values may be obtained simultaneously by 1 query action, which is also classified into the above-described complete sequential query class.
(2) The second class (abbreviated as incomplete sequence query class) is that a single query is not enough to provide all results through the input parameters of the URL, so that after splitting the query, the result sets are combined, and then the result sets are assigned to the page objects. In such cases, the nested queries are expressed in order as a second set of query actions FQ 2 ＝{fq 1 ，fq 2 ，fq 3 ，......，fq i2 ，......，fq Z }；
Wherein FQ 2 For the second set of query actions, fq 1 ，fq 2 ，fq 3 ，......，fq i2 ,...and fq Z Are valid query actions in the second set of query actions; z is the total number of effective query actions in the first query action set, and Z is more than or equal to 2; ith 2-1 valid query action fq i2-1 Results set and i2 th valid query action fq i2 With or without intersection of query input parameter sets of (c), any fq i2 ∈FQ 2 Representing any one of the valid query actions, the i2-1 st valid query action fq i2-1 Results set and i2 th valid query action fq i2 Both cases of intersection and non-intersection of the query input parameter sets of (2) may occur, let FQR represent FQ 2 And (3) combining the result sets obtained after all the inquiry actions are completed.
Second query action set FQ 2 The following rules of convention exist for the execution order of (a):
(1) if fq i2-1 ∈FQ 2 ，fq i2 ∈FQ 2 And fq i2-1 Results set R (fq) i2-1 ) And fq i2 Is a query input parameter set I (fq i2 ) There is no necessary intersection, i.e. I (fq i2 ) The elements in (2) may not be derived from R (fq i2-1 ) Second query action set FQ 2 All elements in (1) can arbitrarily redefine the query order, i.e., FQ 2 All elements present in the permutation order of the possible combinations number NP 2 The method meets the following conditions: NP (NP) 2 =z-! =z (Z-1) (Z-2) 2*1, and NP 2 The combination of species results in a completely consistent combined result set fqr=r (fq 1 )∪R(fq 2 )∪......∪R(fq Z )。
As shown in FIG. 5a, FIG. 5a is a schematic diagram of page results showing that no sequential relationship exists among all queries when the number of nested queries N is equal to or greater than 2, and the same result set can be obtained for filling component content by any query combination, namely, the sequential combination of query value 1, query value 2, query value 3, query value 4, query value 5, query value 6, query value 7, query value 8, query value 9, query value 10, and the result set obtained by the query value 10, query value 9, query value 8, query value 4, query value 7, query value 6, query value 3, query value 2, query value 5, and query value 1 are consistent, wherein the value f represents the filling content of the component f.
(2) In general, if there is a correlation combination in the query action set, i.e. there is a necessary intersection between the result set of a certain action and the query input parameter set of its following action, fq is defined k-1 ∈FQ 2 ，fq k ∈FQ 2 ，fq k+1 ∈FQ 2 ，fq s-1 ∈FQ 2 ，fq s ∈FQ 2 ，fq s+1 ∈FQ 2 Form a first sequential action subset { fq } k-1 ，fq k ，fq k+1 And a second subset of sequential actions { fq } s-1 ，fq s ，fq s+1 No necessary intersection exists between the result set of either action and the query input parameter set of its succeeding action, i.e. I (fq k ) The elements in (2) may not be derived from R (fq k-1 )，I(fq k+1 ) The elements in (2) may not be derived from R (fq k )，I(fq s ) The elements in (2) may not be derived from R (fq s-1 )，I(fq s+1 ) The elements in (2) may not be derived from R (fq s ) Fq is then k And fq s At FQ 2 Optionally, whereby the query order may be redefined locally.
If FQ 2 There are p first combined element subsets nk= { NK with randomly permutable order 1 ，nk 2 ， ...... ，nk p Second subset nq= { NQ of combined elements that are not randomly permutated 1 ，nq 2 ，......，nq q }＝{{fq a ，fq a+1 ，...，fq a+d }，{fq b ，fq b+1 ，...，fq b+j }，......，{fq x ，fq x+1 ，...，fq x+y }}；
Wherein { fq a ，fq a+1 ，...，fq a+d First group of combined elements in second combined element subset, fq a ，fq a+1 ，...，fq a+d Are elements in the first group of combined elements; { fq b ，fq b+1 ，...，fq b+j And is a second group of combined elements in the second subset of combined elements, fq b ，fq b+1 ，...，fq b+j Are elements in the second group of combined elements; … … { fq x ，fq x+1 ，...，fq x+y The q-th group of combined elements in the second combined element subset, fq x ，fq x+1 ，...，fq x+y Are all elements in the q-th group of combined elements; NK n FQ 2 When nq∈nq for any nq=nk, NQ n_fq=nq; the second query action set FQ 2 Number of combinations NP of (2) 2 The method meets the following conditions: NP (NP) 2 = (p+q) ++! = (p+q), (p+q-1), (p+q-2),. The number 2*1, and NP 2 The seed combinations all gave a completely identical result set fqr=r (nk 1 )∪R(nk 2 )∪......∪R(nk p )∪R(nq 1 )∪R(nq 2 )∪......∪R(nq q )。
As shown in FIG. 5b, when the number of nested queries N is equal to or greater than 2, FIG. 5b is a schematic diagram of page results showing that there is a sequential relationship among local queries, in which the values of component 1, component 2, component 3, and component 4 shown in the dashed boxes are in sequential query relationship, as are the values of component 7 and component 8, and there is no sequential query relationship among other component values, so that the sequential combination { query value 1→query value 2→query value 3→query value 4} - > query value 5→query value 6→ { query value 7→query value 8} - > query value 9→query value 10 is consistent with the result set of query value 5→ { query value 1→query value 2→query value 3→query value 4} →query value 6→query value 9→ { query value 7→query value 8} query value 10, and g represents the filling value of component g.
In addition, the rule of the rule (1) is supplemented, and in particular, in a code-free development environment, the output logic of the two-dimensional code is realized by means of event arrangement, and the basic principle of event arrangement is different from the traditional coding mode: the two operations with the direct front and rear relationships must be in a contiguous relationship in implementation, e.g., for the third set of query actions FQ 3 ＝{fq 1 ，fq 2 ，fq 3 ，......，fq u }(u≥2)，FC＝{fq v-1 ，fq v }(1＜u≤v)，FC∩FQ 3 ＝FC，FS＝FQ 3 -FC, assuming I (fq v ) The elements in (a) must come from R (fq v-1 ) While all elements in FS conform to the convention rules described in item (1) above, and fq v-1 And fq v The rule of the rule (1) is also met when the rule is combined with all elements in the FS separately, and the rule is combined with all elements in the FS in the third query action set FQ 3 In which any FS e FS cannot change execution order to fq v-1 And fq v Intermediate, i.e. in the combined mode of sequential query actions, fq v-1 And fq v Must be adjacent.
Taking fig. 5 (b) as an example, fc1= { query value 1→query value 2→query value 3→query value 4} and fc2= { query value 7→query value 8} must be kept as two complete independent queries, and any query value h e { query value 5, query value 6, query value 9, query value 10} must not be inserted into FC1 and FC2 to disrupt the respective query order.
As shown in fig. 1, the method includes:
S5: and initializing a page based on the visual element set, the behavior element rule base, the input parameters and the output action set, and executing page operation to complete the generation of the two-dimensional code component and the object.
And dividing the page triggered by the two-dimensional code object into two types, namely a read-only type and an editable type.
For read-only class pages. After the nested query is finished, assigning a value to the page object, assigning a URL parameter or a result set FQR to the component in the page and filling the component content. The operation set of the read-only page is expressed as single click/double click/drag/zoom-in/zoom-out operation of any object in the page, and the operations can meet the browsing requirement of a user on the page, but the operation cannot change the actual content of the page, and after the browsing process of the user is finished, the user can select to close the page. The course of action of a read-only page as shown in fig. 3 a. So far, the runtime content of the read-only page represented by one two-dimensional code object is totally ended. And for editable class pages. On the basis of the read-only pages, the editing and saving/modifying capabilities are increased, and the action sets are sequentially { page initialization, nested query, assignment of page objects, page operation, saving/modifying and closing }. A course of action of the editable page as shown in fig. 3 b. In the editable page, the page initialization, nested query, assignment of page objects and read-only pages are basically consistent, the operation set is represented by single click/double click/drag/zoom/modify value operation of any object in the page, the change of the page object needs to be saved/modified at the database or file level before closing, and the content belongs to page level code-free development content and does not belong to the generation content of two-dimensional code components and objects, and the detailed description is omitted. So far, the runtime content of the read-only page represented by one two-dimensional code object is totally ended.
It should be noted that, in this embodiment, after the two-dimensional code component and the object are generated according to the steps S1 to S5, the user may perform the page operation again through the step S5 by running the application program and scanning the two-dimensional code.
The innovation point of the invention is mainly that a code-free development idea is adopted, a two-dimensional code component object is created on the basis of a visual element set, a behavior rule base and various mappings, the code-free configuration triggering between the two-dimensional code object and an output page is realized, and the problem of multi-level nested query possibly existing in the initialization process of the output page is fully considered. The method can effectively improve the generation efficiency of the two-dimensional code component and the object in the code-free development environment, greatly reduce code writing related to the generation of the two-dimensional code, and directly avoid errors possibly caused by code writing.
The beneficial effects brought by the invention are as follows:
(1) A visual element set and a behavior rule base are established when the two-dimensional code component is designed under the code-free development environment;
(2) The method solves the problem of unified description and mapping of the two-dimensional code component object storage, instantiation and rendering;
(3) The method solves the problem of controlling interaction between the two-dimensional code component object and the page object set in the running state through configuration of the running input parameters and the running output action set.
(4) The two-dimensional code component is created and interactive logic configuration is generated in the running process under the code-free development environment, so that the implementation efficiency of the two-dimensional code component object is improved, and code programming is avoided.
Example two
As shown in fig. 6, a two-dimensional code component and object generating system in a code-free development environment is applied to a two-dimensional code component and object generating method in a code-free development environment in the first embodiment, and includes:
the element set establishing module is used for establishing a visual element set of the two-dimensional code component in the code-free development environment;
the element rule establishing module is used for establishing a behavior element rule base of the two-dimensional code assembly in the design under the code-free development environment;
the object instantiation module is used for carrying out object instantiation on the two-dimensional code component in design;
the parameter configuration module is used for respectively configuring input parameters and output action sets in running for the two-dimensional code object obtained by object instantiation;
and the initialization module is used for initializing a page based on the visual element set, the behavior element rule base, the input parameters and the output action set, executing page operation and completing the generation of the two-dimensional code assembly and the object.
According to the two-dimensional code component and object generation system under the code-free development environment, the two-dimensional code component and the page initialization operation pointed by the two-dimensional code are realized, codes are not required to be written, the two-dimensional code component and the object generation are further realized, the two-dimensional code component under two states of design and operation are considered, the consistent visual appearance of the two-dimensional code component is kept under the two states, and the realization efficiency of two-dimensional code object generation and interaction between the two-dimensional code component and an associated page object set is improved in a more visual mode.
The functions of each module of the two-dimensional code component and the object generating system in the code-free development environment described in this embodiment are in one-to-one correspondence with the steps of the two-dimensional code component and the object generating method in the code-free development environment of the first embodiment, so that details in this embodiment are not fully described, and detailed descriptions of the first embodiment and fig. 1 to 5 are omitted here.
Example III
The two-dimensional code assembly and object generating device in the code-free development environment comprises a processor, a memory and a computer program which is stored in the memory and can run on the processor, wherein the computer program realizes the method steps in the two-dimensional code assembly and object generating method in the code-free development environment of the first embodiment when running.
Through the computer program stored on the memory and running on the processor, the two-dimension code assembly and the page initialization operation pointed by the two-dimension code are realized without writing codes, and further the two-dimension code assembly and object generation are realized, and the two-dimension code assembly in two states of design and operation are considered, so that the two-dimension code assembly keeps consistent visual appearance in the two states, and the realization efficiency of two-dimension code object generation and interaction between the two-dimension code assembly and an associated page object set is improved in a more visual mode.
The processor may be a central processing unit (Central Processing Unit, CPU) or other general purpose processor. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like, the processor being a control center of the computer device, and the various interfaces and lines connecting the various parts of the overall computer device.
The memory may be used to store computer programs and/or models, and the processor implements various functions of the computer device by running or executing the computer programs and/or models stored in the memory, and invoking data stored in the memory. The memory may mainly include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program required for at least one function (e.g., a sound playing function, an image playing function, etc.); the storage data area may store data (e.g., audio data, video data, etc.) created according to the use of the handset. In addition, the memory may include high-speed random access memory, and may also include non-volatile memory, such as a hard disk, memory, plug-in hard disk, smart Media Card (SMC), secure Digital (SD) Card, flash Card (Flash Card), at least one disk storage device, flash memory device, or other volatile solid-state storage device.
It will be understood that each flow and/or block of the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer programs. These computer programs may 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, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer programs may also be stored in a computer readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer programs may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
The present embodiment also provides a computer storage medium including: at least one instruction, when executed, implements the method steps in the two-dimensional code component and object generating method in the code-free development environment of the first embodiment.
Through executing the computer storage medium containing at least one instruction, the two-dimensional code assembly and the page initialization operation pointed by the two-dimensional code are realized without coding codes, and further the two-dimensional code assembly and object generation are realized, and the two-dimensional code assembly in two states of design and operation is considered, so that the two-dimensional code assembly maintains consistent visual appearance in the two states, and the realization efficiency of two-dimensional code object generation and interaction between the two-dimensional code assembly and an associated page object set is improved in a more visual mode.
Similarly, the details of the third embodiment are not fully described in detail in the first embodiment, the second embodiment, and fig. 1 to 6, and are not repeated here.
Although embodiments of the present invention have been described in connection with the accompanying drawings, various modifications and variations may be made by those skilled in the art without departing from the spirit and scope of the invention, and such modifications and variations are within the scope of the invention as defined by the appended claims.

Claims (10)

1. A two-dimensional code assembly and object generation method in a code-free development environment is characterized by comprising the following steps:
establishing a visual element set of a two-dimensional code component in a code-free development environment;
establishing a behavior element rule base of the two-dimensional code assembly in the design under a code-free development environment;
object instantiation is carried out on the two-dimensional code component in design;
respectively configuring input parameters and output action sets in running for the two-dimensional code object obtained by object instantiation;
and initializing a page based on the visual element set, the behavior element rule base, the input parameters and the output action set, and executing page operation to complete the generation of the two-dimensional code component and the object.
2. The two-dimensional code component and object generation method in a code-less development environment according to claim 1, wherein the visualized element set includes a subset of visualized elements at design time and a subset of visualized elements at run time;
the subset of visual elements at design time is defined as: da= { DA 1 ，da 2 ，da 3 ，......，da n }；
Wherein DA is the subset of visual elements for the design, DA 1 ，da 2 ，da 3 ,...and da.) n The visual attributes of the two-dimensional code component in design are all shown; n is the total number of visual attributes of the two-dimensional code component in design, and n is more than or equal to 1;
The subset of runtime visualization elements is defined as: ra= { RA 1 ，ra 2 ，ra 3 ，......，ra m }；
Wherein RA is the subset of visual elements at runtime, RA 1 ，ra 2 ，ra 3 ,...and ra n The visual attributes of the two-dimensional code component in the running process are all the visual attributes of the two-dimensional code component in the running process; m is the total number of visual attributes of the two-dimensional code component in operation, and m is more than or equal to 1;
the design time visual element subset and the run time visual element subset further satisfy: RA n da=da.
3. The method for generating a two-dimensional code component and an object in a code-free development environment according to claim 1, wherein after the behavior element rule base of the two-dimensional code component in the code-free development environment during design is established, the method further comprises:
dividing the behavior element rule base into a component behavior rule set and an object behavior rule set based on the visual element subset in design;
the behavior element set in the behavior element rule base is defined as: de= { DE 1 ，de 2 ，de 3 ，......，de X }；
Wherein DE is the behavior element set, DE 1 ，de 2 ，de 3 ,...and de X All are behavior elements in the behavior element set; x is the total number of the behavior elements in the behavior element rule base, and X is more than or equal to 1.
4. The method for generating a two-dimensional code component and an object in a code-less development environment according to claim 1, wherein the instantiating the two-dimensional code component in the design comprises:
Defining the format and storage form of the two-dimensional code component during object instantiation by adopting a description language of a JSON format;
based on the format and the storage form, establishing a rule relation among object instantiation, object storage and object rendering of the two-dimensional code component;
and carrying out object instantiation on the two-dimensional code component in design according to the rule relation.
5. The two-dimensional code component and object generating method in a code-free development environment according to claim 1, wherein configuring input parameters in a runtime for a two-dimensional code object obtained by object instantiation comprises:
setting a URL source in a design time environment;
and carrying out URL assignment on the URL source under the running environment to obtain the input parameters.
6. The two-dimensional code component and object generation method in a code-less development environment according to claim 5, wherein the input parameters include static parameter values and dynamic parameter values;
wherein the static parameter value refers to a fixed value, and the dynamic parameter value comprises four parameters including a component, an action parameter, a global variable, a variable and an event parameter.
7. The method for generating a two-dimensional code component and an object in a code-free development environment according to claim 1, wherein the output action set refers to a series of action sets of an object set in a URL page pointed by the two-dimensional code object, and the series of action sets comprise a read-only action subset and an editable action subset;
The subset of read-only actions is { page initialization, nested query, assignment of values to page objects, page operation, closing } in order, and the subset of editable actions is { page initialization, nested query, assignment of values to page objects, page operation, save/modify, closing } in order.
8. The two-dimensional code component and object generation method in a code-less development environment of claim 7, wherein the nested queries in the subset of read-only class actions and the subset of editable class actions each comprise a combination of one or more sets of query actions.
9. The method for generating two-dimensional code components and objects in a code-less development environment according to claim 7, wherein the number of times of the nested queries in the subset of read-only class actions and the subset of editable class actions is equal to or greater than 0;
setting the number of times of nested queries as N;
when n=0, the two-dimensional code object points to the content required to be filled by the object set in the URL page, the nested query directly transmits assignment through URL parameters, and the combination number of the nested query is 1;
when n=1, the nested query obtains the assignment content of the object set in the URL page through a single query, and the number of combinations of the nested query is 1;
When N is greater than or equal to 2, the nested queries fall into two categories:
the first category, the nested queries are expressed in order as a first set of query actions FQ 1 ＝{fq 1 ，fq 2 ，fq 3 ，......，fq i1 ，......，fq Y }；
Wherein FQ 1 For the first query action set, fq 1 ，fq 2 ，fq 3 ，......，fq i1 ,...and fq Y Are valid query actions in the first set of query actions; y is the total number of effective query actions in the first query action set, and Y is more than or equal to 2; ith 1-1 valid query action fq i1-1 Part or all of the result set of (1) is the i1 st valid query action fq i1 In which case the first set of query actions FQ 1 Number of combinations NP of (2) 1 The method meets the following conditions: NP (NP) 1 ＝1；
A second class, the nested queries being expressed in order as a second set of query actions FQ 2 ＝{fq 1 ，fq 2 ，fq 3 ，......，fq i2 ，......，fq Z }；
Wherein FQ 2 For the second set of query actions, fq 1 ，fq 2 ，fq 3 ，......，fq i2 ,...and fq Z Are valid query actions in the second set of query actions; z is the total number of effective query actions in the first query action set, and Z is more than or equal to 2; ith 2-1 valid query action fq i2-1 Results set and i2 th valid query action fq i2 There is or is not an intersection of the query input parameter sets of (a);
setting the second query action set FQ 2 The combined result set obtained after all the effective inquiry actions are completed is FQR;
The second query action set FQ 2 The following rules of convention exist for the execution order of (a):
(1) if fq i2-1 ∈FQ 2 ，fq i2 ∈FQ 2 And fq i2-1 Results set R (fq) i2-1 ) And fq i2 Is a query input parameter set I (fq i2 ) There is no intersection, i.e. I (fq i2 ) The elements in (2) may not be derived from R (fq i2-1 ) The second query action set FQ 2 Any available query action in (1) can redefine the query order arbitrarily, in which case the second set of query actions FQ 2 Number of combinations NP of (2) 2 The method meets the following conditions: NP (NP) 2 =z-! =z (Z-1) (Z-2) 2*1, and NP 2 The combination of species results in a completely consistent combined result set fqr=r (fq 1 )∪R(fq 2 )∪......∪R(fq Z )；
(2) Definition of fq k-1 ∈FQ 2 ，fq k ∈FQ 2 ，fq k+1 ∈FQ 2 ，fq s-1 ∈FQ 2 ，fq s ∈FQ 2 ，fq s+1 ∈FQ 2 Form a first sequential action subset { fq } k-1 ，fq k ，fq k+1 And a second subset of sequential actions { fq } s-1 ，fq s ，fq s+1 No necessary intersection exists between the result set of any action and the query input parameter set of the following action in the first sequence action subset and the second sequence action subset, then fq k And fq s At FQ 2 The positions in the query sequence can be randomly changed, so that the query sequence can be locally redefined;
if FQ 2 There are p first combined element subsets nk= { NK with randomly permutable order 1 ，nk 2 ， ...... ，nk p Second subset nq= { NQ of combined elements that are not randomly permutated 1 ，nq 2 ，......，nq q }＝{{fq a ，fq a+1 ，...，fq a+d }，{fq b ，fq b+1 ，...，fq b+j }，......，{fq x ，fq x+1 ，...，fq x+y }}；
Wherein { fq a ，fq a+1 ，...，fq a+d First group of combined elements in second combined element subset, fq a ，fq a+1 ，...，fq a+d Are elements in the first group of combined elements; { fq b ，fq b+1 ，...，fq b+j And is a second group of combined elements in the second subset of combined elements, fq b ，fq b+1 ，...，fq b+j Are elements in the second group of combined elements; … … { fq x ，fq x+1 ，...，fq x+y The q-th group of combined elements in the second combined element subset, fq x ，fq x+1 ，...，fq x+y Are all elements in the q-th group of combined elements; NK n FQ 2 When nq∈nq for any nq=nk, NQ n_fq=nq;
the second query action set FQ 2 Number of combinations NP of (2) 2 The method meets the following conditions: NP (NP) 2 = (p+q) ++! = (p+q), (p+q-1), (p+q-2),. The number 2*1, and NP 2 The seed combinations all obtain a completely consistent result set FQR＝R(nk 1 )∪R(nk 2 )∪......∪R(nk p )∪R(nq 1 )∪R(nq 2 )∪......∪R(nq q )。
10. A two-dimensional code component and object generating system in a code-free development environment, wherein the two-dimensional code component and object generating method applied in the code-free development environment according to any one of claims 1 to 9 comprises:
the element set establishing module is used for establishing a visual element set of the two-dimensional code component in the code-free development environment;
the element rule establishing module is used for establishing a behavior element rule base of the two-dimensional code assembly in the design under the code-free development environment;
the object instantiation module is used for carrying out object instantiation on the two-dimensional code component in design;
the parameter configuration module is used for respectively configuring input parameters and output action sets in running for the two-dimensional code object obtained by object instantiation;
And the initialization module is used for initializing a page based on the visual element set, the behavior element rule base, the input parameters and the output action set, executing page operation and completing the generation of the two-dimensional code assembly and the object.
CN202211668793.5A 2022-12-24 2022-12-24 Two-dimensional code component and object generation method and system under code-free development environment Pending CN116860224A (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN202211668793.5A CN116860224A (en) 2022-12-24 2022-12-24 Two-dimensional code component and object generation method and system under code-free development environment

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN202211668793.5A CN116860224A (en) 2022-12-24 2022-12-24 Two-dimensional code component and object generation method and system under code-free development environment

Publications (1)

Publication Number Publication Date
CN116860224A true CN116860224A (en) 2023-10-10

Family

ID=88223935

Family Applications (1)

Application Number Title Priority Date Filing Date
CN202211668793.5A Pending CN116860224A (en) 2022-12-24 2022-12-24 Two-dimensional code component and object generation method and system under code-free development environment

Country Status (1)

Country Link
CN (1) CN116860224A (en)

Similar Documents

Publication Publication Date Title
US20230334229A1 (en) System and method providing responsive editing and viewing, integrating hierarchical fluid components and dynamic layout
US7661071B2 (en) Creation of three-dimensional user interface
CN101553771B (en) Rendering hypertext markup language content
AU2003237867B2 (en) System for hosting graphical layout/presentation objects
CN101421761B (en) Visual and scene graph interfaces
CN1534476B (en) Method and system for image processing by using computer
US6487565B1 (en) Updating animated images represented by scene graphs
CN104216691A (en) Application creating method and device
AU2012242947A2 (en) Method and system for personalizing images rendered in scenes for personalized customer experience
Demetrescu et al. Specifying algorithm visualizations: Interesting events or state mapping?
US20050253849A1 (en) Custom spline interpolation
JP7373563B2 (en) Systems and methods for creating and processing configurable applications for website building systems
US9836441B2 (en) Platform abstraction of graphics
CN113032708A (en) Code-free Web development system
AU2022246444A1 (en) System and method for smart interaction between website components
US7409642B2 (en) Method and system for applying user interface elements to data
CN112364496B (en) Avionics simulation panel generation system based on HTML5 and VUE technologies
US5479589A (en) Object-oriented system for selecting a graphic image on a display
CN114721632A (en) Page design method and device based on low-code visual component
CN114647409A (en) Large-screen visualization application creation platform, method, computing device and storage medium
US6925473B2 (en) Staged stylization in multiple tiers
CN116860224A (en) Two-dimensional code component and object generation method and system under code-free development environment
de Lange et al. Collaborative wireframing for model-driven web engineering
CN115810064A (en) Map making and publishing platform construction method based on open source GIS technology
CN116595284B (en) Webpage system operation method, device, equipment, storage medium and program

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