CN116431127A - Low code development method, system, equipment and readable storage medium - Google Patents
Low code development method, system, equipment and readable storage medium Download PDFInfo
- Publication number
- CN116431127A CN116431127A CN202310268938.0A CN202310268938A CN116431127A CN 116431127 A CN116431127 A CN 116431127A CN 202310268938 A CN202310268938 A CN 202310268938A CN 116431127 A CN116431127 A CN 116431127A
- Authority
- CN
- China
- Prior art keywords
- component
- abstract syntax
- syntax tree
- tree
- generating
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 77
- 238000011161 development Methods 0.000 title claims abstract description 51
- 238000004590 computer program Methods 0.000 claims description 11
- 230000000977 initiatory effect Effects 0.000 claims 1
- 230000008569 process Effects 0.000 description 13
- 238000010586 diagram Methods 0.000 description 10
- 238000012545 processing Methods 0.000 description 4
- 238000004891 communication Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000003287 optical effect Effects 0.000 description 3
- 238000012795 verification Methods 0.000 description 3
- 230000009471 action Effects 0.000 description 2
- 238000010276 construction Methods 0.000 description 2
- 238000013461 design Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 238000004519 manufacturing process Methods 0.000 description 2
- 230000009467 reduction Effects 0.000 description 2
- 238000004458 analytical method Methods 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000006243 chemical reaction Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000000802 evaporation-induced self-assembly Methods 0.000 description 1
- 230000006870 function Effects 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 238000012423 maintenance Methods 0.000 description 1
- 230000002441 reversible effect Effects 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 230000009466 transformation Effects 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/34—Graphical or visual programming
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/42—Syntactic analysis
- G06F8/427—Parsing
-
- 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
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The present invention relates to a low code development method, system, device and readable storage medium, the method comprising: when the engine of the low-code platform monitors a component drag starting event, judging whether the component drag starting event is monitored for the first time; if the abstract syntax tree is not monitored for the first time, reading an executable source code of a current platform page, and analyzing the executable source code to obtain the abstract syntax tree; generating a component node structure tree and a file model according to the abstract syntax tree, and generating a platform page according to the component node structure tree and the file model for a user to drag; after the component dragging event is monitored, a new abstract syntax tree is generated according to the component, the page layout and the version number of the component dragging event, and then a new executable source code is generated and operated according to the new abstract syntax tree. The source code management mode is optimized, the method is suitable for rapid iteration projects, a platform can be rapidly built for many times, and support is provided for frequent project changes.
Description
Technical Field
The present invention relates to the field of computer technology, and in particular, to a low code development method, system, device, and readable storage medium.
Background
Low Code (Low Code) is a visual application development method, which uses less Code to deliver an application program at a faster speed, and the Code which a programmer does not want to develop is automated, which is called Low Code. The low code is a group of digital technology tool platforms, and based on more efficient modes such as graphic dragging, parameterized configuration and the like, quick construction, data arrangement, ecological connection and middle service are realized. Scene application innovation in digital transformation is achieved with little or no code. The low codes can realize great efficiency improvement and cost reduction under a proper service scene.
Low code development also has several problems in the fast-evolving process. The existing prominent pain point is the problem of secondary development of low codes, when the platform codes are generated by the low codes and iterated again, the codes developed in the previous development conflict with the codes generated by the low codes, so that the codes cannot be inserted again when the low codes are used again for development, the code conversion capability is only provided, and once the source codes are output, the process is not reversible. The more complex the traffic of the low code platform, the more complex the code. The maintenance cost rises and the efficiency can be out of control to a certain extent. Low code platform business requirements and code complexity are opposed.
Disclosure of Invention
Based on the above, the embodiments of the present application provide a low code development method, system, device and readable storage medium, which optimize a source code management manner, can be adapted to a project with rapid iteration, can quickly build a platform multiple times, and provides support for frequent project modification.
In order to achieve the above purpose, the embodiment of the present application provides the following technical solutions:
according to a first aspect of embodiments of the present application, there is provided a low code development method, the method including:
when the engine of the low-code platform monitors a component drag starting event, judging whether the component drag starting event is monitored for the first time;
if the abstract syntax tree is not monitored for the first time, reading an executable source code of a current platform page, and analyzing the executable source code to obtain the abstract syntax tree;
generating a component node structure tree and a file model according to the abstract syntax tree, and generating a platform page according to the component node structure tree and the file model for a user to drag;
after the component dragging event is monitored, a new abstract syntax tree is generated according to the component, the page layout and the version number of the component dragging event, and then a new executable source code is generated and operated according to the new abstract syntax tree.
Optionally, if the component drag start event is monitored for the first time, the method further includes:
acquiring a component, a page layout and a version number of a component drag starting event;
generating a component node structure tree and a file model corresponding to all pages according to the components, the page layout and the version number;
generating an abstract syntax tree according to the component node structure tree and the file model corresponding to all pages;
and generating and running executable source codes according to the abstract syntax tree, and storing the executable source codes.
Optionally, the generating the component node structure tree and the file model corresponding to all pages according to the components, the page layout and the version number includes:
and generating a component node structure tree and a file model based on the document objectification model tree according to the components, the page layout and the version number.
Optionally, after parsing the executable source code to obtain an abstract syntax tree, the method further comprises:
and traversing the abstract syntax tree to add a key point mark, wherein the key point mark is used for maintaining the structure of the abstract syntax tree unchanged.
Optionally, after the component drag event is monitored, generating a new abstract syntax tree according to the component, the page layout and the version number of the component drag event, and the method further includes:
verifying whether the component dragging event accords with a development rule or not and whether a component node structure tree is damaged or not according to the components, page layout and version numbers of the component dragging event;
if the development rule is met and the component node structure tree is not damaged, generating a new abstract syntax tree;
if the development rule is not met and/or the component node structure tree is damaged, stopping generating a new abstract syntax tree and sending out warning information.
Optionally, after the generating and running the new executable source code according to the new abstract syntax tree, the method further comprises:
storing the new executable source code and updating the version number.
According to a second aspect of embodiments of the present application, there is provided a low code development system, the system comprising:
the judging module is used for judging whether the component drag starting event is monitored for the first time when the low-code platform engine monitors the component drag starting event;
the abstract syntax tree restoring module is used for reading the executable source code of the current platform page if the abstract syntax tree restoring module is not monitored for the first time, and analyzing the executable source code to obtain an abstract syntax tree;
the page restoration module is used for generating a component node structure tree and a file model according to the abstract syntax tree, and generating a platform page for a user to drag according to the component node structure tree and the file model;
and the code updating module is used for generating a new abstract syntax tree according to the components, page layout and version number of the component dragging event after the component dragging event is monitored, and generating and running a new executable source code according to the new abstract syntax tree.
Optionally, the system further comprises:
the information acquisition module is used for acquiring the components, page layout and version numbers of the component dragging starting event;
the abstract syntax tree generation module is used for generating a component node structure tree and a file model corresponding to all pages according to the components, the page layout and the version number; generating an abstract syntax tree according to the component node structure tree and the file model corresponding to all pages;
and the code execution module is used for generating and running executable source codes according to the abstract syntax tree and storing the executable source codes.
Optionally, the generating the component node structure tree and the file model corresponding to all pages according to the components, the page layout and the version number includes:
and generating a component node structure tree and a file model based on the document objectification model tree according to the components, the page layout and the version number.
Optionally, the system further comprises:
and the marking module is used for traversing the abstract syntax tree and adding a key point mark, wherein the key point mark is used for maintaining the structure of the abstract syntax tree unchanged.
Optionally, the system further comprises:
the verification module is used for verifying whether the component dragging event accords with a development rule or not and whether a component node structure tree is damaged or not according to the component, the page layout and the version number of the component dragging event; if the development rule is met and the component node structure tree is not damaged, generating a new abstract syntax tree; if the development rule is not met and/or the component node structure tree is damaged, stopping generating a new abstract syntax tree and sending out warning information.
Optionally, the code updating module is further configured to store the new executable source code and update a version number.
According to a third aspect of embodiments of the present application, there is provided an electronic device, including: a memory, a processor and a computer program stored on the memory and executable on the processor, the processor executing the computer program to perform the method of the first aspect.
According to a fourth aspect of embodiments of the present application, there is provided a computer readable storage medium having stored thereon computer readable instructions executable by a processor to implement the method of the first aspect described above.
In summary, the embodiments of the present application provide a low code development method, system, device, and readable storage medium, which determine, when an engine of a low code platform monitors a component drag start event, whether the component drag start event is monitored for the first time; if the abstract syntax tree is not monitored for the first time, reading an executable source code of a current platform page, and analyzing the executable source code to obtain the abstract syntax tree; generating a component node structure tree and a file model according to the abstract syntax tree, and generating a platform page according to the component node structure tree and the file model for a user to drag; after the component dragging event is monitored, a new abstract syntax tree is generated according to the component, the page layout and the version number of the component dragging event, and then a new executable source code is generated and operated according to the new abstract syntax tree. The source code management mode is optimized, the method is suitable for rapid iteration projects, a platform can be rapidly built for many times, and support is provided for frequent project changes.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below. It will be apparent to those of ordinary skill in the art that the drawings in the following description are exemplary only and that other implementations can be obtained from the extensions of the drawings provided without inventive effort.
The structures, proportions, sizes, etc. shown in the present specification are shown only for the purposes of illustration and description, and are not intended to limit the scope of the invention, which is defined by the claims, so that any structural modifications, changes in proportions, or adjustments of sizes, which do not affect the efficacy or the achievement of the present invention, should fall within the scope of the invention.
Fig. 1 is a schematic flow chart of a low code development method provided in an embodiment of the present application;
fig. 2 is a schematic flow chart of an overall scheme provided in an embodiment of the present application;
FIG. 3 is a schematic diagram of a user first using low-code development process according to an embodiment of the present application;
FIG. 4 is a schematic diagram of a rule checking process according to an embodiment of the present application;
FIG. 5 is a schematic diagram of a multiple development process provided in an embodiment of the present application;
FIG. 6 is a block diagram of a low code development system provided by an embodiment of the present application;
fig. 7 shows a schematic structural diagram of an electronic device according to an embodiment of the present application;
fig. 8 shows a schematic diagram of a computer-readable storage medium according to an embodiment of the present application.
Detailed Description
The present invention will be described in further detail with reference to the drawings and examples, in order to make the objects, technical solutions and advantages of the present invention more apparent. It should be understood that the specific embodiments described herein are for purposes of illustration only and are not intended to limit the scope of the invention.
It will be understood that the terms "first," "second," and the like, as used herein, may be used to describe various elements, but these elements are not limited by these terms. These terms are only used to distinguish one element from another element.
Other advantages and advantages of the present invention will become apparent to those skilled in the art from the following detailed description, which, by way of illustration, is to be read in connection with certain specific embodiments, but not all embodiments. 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 be within the scope of the invention.
Fig. 1 shows a low code development method flow provided in an embodiment of the present application, where the method includes:
step 101: when the engine of the low-code platform monitors a component drag starting event, judging whether the component drag starting event is monitored for the first time;
step 102: if the abstract syntax tree is not monitored for the first time, reading an executable source code of a current platform page, and analyzing the executable source code to obtain the abstract syntax tree;
step 103: generating a component node structure tree and a file model according to the abstract syntax tree, and generating a platform page according to the component node structure tree and the file model for a user to drag;
step 104: after the component dragging event is monitored, a new abstract syntax tree is generated according to the component, the page layout and the version number of the component dragging event, and then a new executable source code is generated and operated according to the new abstract syntax tree.
In one possible embodiment, if the component drag start event is monitored for the first time, the method further comprises:
acquiring a component, a page layout and a version number of a component drag starting event; generating a component node structure tree and a file model corresponding to all pages according to the components, the page layout and the version number; generating an abstract syntax tree according to the component node structure tree and the file model corresponding to all pages; and generating and running executable source codes according to the abstract syntax tree, and storing the executable source codes.
In one possible implementation manner, the generating the component node structure tree and the file model corresponding to all pages according to the components, the page layout and the version number includes:
and generating a component node structure tree and a file model based on the document objectification model tree according to the components, the page layout and the version number.
In one possible implementation manner, after the parsing the executable source code to obtain an abstract syntax tree, the method further includes:
and traversing the abstract syntax tree to add a key point mark, wherein the key point mark is used for maintaining the structure of the abstract syntax tree unchanged.
In a possible implementation manner, after the component drag event is monitored, a new abstract syntax tree is generated according to the component, the page layout and the version number of the component drag event, and the method further comprises:
verifying whether the component dragging event accords with a development rule or not and whether a component node structure tree is damaged or not according to the components, page layout and version numbers of the component dragging event; if the development rule is met and the component node structure tree is not damaged, generating a new abstract syntax tree; if the development rule is not met and/or the component node structure tree is damaged, stopping generating a new abstract syntax tree and sending out warning information.
In one possible implementation, after the generating and running the new executable source code according to the new abstract syntax tree, the method further includes:
storing the new executable source code and updating the version number.
The low code development method provided in the embodiment of the present application is described in detail below with reference to the accompanying drawings.
Fig. 2 is a schematic flow chart of an overall scheme provided in an embodiment of the present application; in order to solve the problem that codes cannot be converted in two directions in the development of a low-code platform in the prior art, an AST abstract syntax tree is introduced to manage source codes. An abstract Syntax tree (Abstract Syntax Tree, AST), or simply Syntax tree (syncax tree), is an abstract representation of the source code Syntax structure. It represents the syntax structure of a programming language in the form of a tree, each node on the tree representing a structure in the source code. The syntax of the abstract syntax tree does not represent every detail that appears in the real syntax. For example, nested brackets are implicit in the tree structure and are not presented in the form of nodes; and conditional jump statements like if-condition-then can be represented using a node with two branches.
When the engine of the low-code platform monitors a component drag starting event, judging whether the component drag starting event is monitored for the first time;
if the component drag starting event is monitored for the first time, acquiring a component, page layout and version number of the component drag starting event; generating a component node structure tree and a file model corresponding to all pages according to the components, the page layout and the version number; generating an abstract syntax tree according to the component node structure tree and the file model corresponding to all pages; and generating and running executable source codes according to the abstract syntax tree, and storing the executable source codes.
If the abstract syntax tree is not monitored for the first time, reading an executable source code of a current platform page, and analyzing the executable source code to obtain the abstract syntax tree; generating a component node structure tree and a file model according to the abstract syntax tree, and generating a platform page according to the component node structure tree and the file model for a user to drag; after the component dragging event is monitored, a new abstract syntax tree is generated according to the component, the page layout and the version number of the component dragging event, and then a new executable source code is generated and operated according to the new abstract syntax tree.
In one possible implementation, when the low code platform is developed, the order of nodes under each page is recorded when the application layer outputs, and a component node structure tree is generated according to domtree.
In one possible implementation, the low code platform is provided with development rules about the components, and verification plug-ins during storage are added to protect key code structures, and the code structures cannot be modified. The generated key html, js adds a mark. When the codes are stored, the codes are checked through an AST abstract syntax tree, whether the codes contained in the marks are changed or not is checked, and if the codes are changed, warning information is sent.
According to the low code development method, the platform engine is established to process the user dragging action, and after the user dragging is completed, the platform engine generates a corresponding file model and a node tree according to the user dragging components and pages. And analyzing and restoring the file model into AST, traversing the AST, and adding marks, wherein the added marks are used for marking key nodes so as to protect the structure from being damaged. Generating source codes according to AST, injecting the source codes into the project realization module and outputting the source codes to users. AST is dynamically checked at user development to ensure that marked critical nodes of the AST are not changed.
When the user uses the method for the second time, the source codes are read and analyzed, the source codes are restored to AST, a file model and a node tree are built through the AST, and then the file model and the node tree are utilized to generate a platform page.
FIG. 3 is a schematic diagram of a user first using low-code development process according to an embodiment of the present application; the user of the low code platform drags the production code for the first time, and the component node structure tree and the file model of all pages of the current version are produced according to the version under the project root directory.
And processing the action of user dragging by establishing a platform engine, and generating a corresponding file model and a node tree by the platform engine according to the user dragging component and the page after the user dragging is completed. And analyzing and restoring the file model into AST, traversing the AST, and adding marks, wherein the added marks are used for marking key nodes so as to protect the structure from being damaged. Generating source codes according to AST, injecting the source codes into the project realization module and outputting the source codes to users.
Fig. 4 is a schematic diagram of a rule checking process according to an embodiment of the present application. The user is limited in developing the generated project, and each time the AST plug-in is saved, whether the AST plug-in is required to be called accords with the development rule or not and whether the component node structure tree is damaged or not is required to be checked. And if the development rule is not met and/or the structure of the component node structure tree is damaged, sending out warning information.
FIG. 5 is a schematic diagram of a multiple development process provided in an embodiment of the present application; when the user develops again, reading and analyzing the source code, restoring the source code to generate AST, returning the AST to the platform engine, establishing a file model and a node tree through the AST, and generating a platform page by using the file model and the node tree. The production code is dragged again, the component node structure tree is inserted, and the version number is updated.
According to the method provided by the embodiment of the application, the page form is analyzed, and a component node structure tree (a storage structure of a rendered page) and a file model (a page structure) of the page are generated through analysis; the structure of the abstract syntax tree (including the key nodes) is regenerated, and then the abstract syntax tree is used for generating codes. Executable source code is stored, as well as abstract syntax trees for restoration of code at a later re-development. When the secondary development is carried out, the source code is restored into an abstract grammar tree and a file model, and then the abstract grammar tree and the file model are imported into a low-code platform to generate a page for the user to drag again. After the user drags again, a new grammar tree is generated, and a new executable source code is generated according to the new grammar tree.
The source code management mode is optimized, and compared with the existing scheme, the expandability is improved. Compatibility schemes may also be added for underlying management of source code. The method supports the condition of multiple development, realizes the source code reduction development page and the rapid output of the source code, and reduces the learning cost of developers. The user does not need professional front-end knowledge, is available in a non-professional way, can build the device without professional knowledge such as programming, design, composition and the like when in use, and has universality. In the digital age nowadays, the system has wide application development space in multiple fields, can help users manage the system, and is a popular system which is simple and easy to understand.
In summary, the embodiment of the present application provides a low code development method, which determines, when an engine of a low code platform monitors a component drag start event, whether the component drag start event is monitored for the first time; if the abstract syntax tree is not monitored for the first time, reading an executable source code of a current platform page, and analyzing the executable source code to obtain the abstract syntax tree; generating a component node structure tree and a file model according to the abstract syntax tree, and generating a platform page according to the component node structure tree and the file model for a user to drag; after the component dragging event is monitored, a new abstract syntax tree is generated according to the component, the page layout and the version number of the component dragging event, and then a new executable source code is generated and operated according to the new abstract syntax tree. The source code management mode is optimized, the method is suitable for rapid iteration projects, a platform can be rapidly built for many times, and support is provided for frequent project changes.
Based on the same technical concept, as shown in fig. 6, the embodiment of the application further provides a low code development system, which includes:
the judging module 601 is configured to judge whether a component drag start event is monitored for the first time when the low code platform engine monitors the component drag start event;
the abstract syntax tree restoring module 602 is configured to, if not, read an executable source code of a current platform page and parse the executable source code to obtain an abstract syntax tree;
the page restore module 603 is configured to generate a component node structure tree and a file model according to the abstract syntax tree, and generate a platform page according to the component node structure tree and the file model, so as to be dragged by a user;
and the code updating module 604 is configured to generate a new abstract syntax tree according to the component, the page layout and the version number of the component drag event after the component drag event is monitored, and generate a new executable source code according to the new abstract syntax tree and operate the new executable source code.
In one possible embodiment, the system further comprises:
the information acquisition module is used for acquiring the components, page layout and version numbers of the component dragging starting event;
the abstract syntax tree generation module is used for generating a component node structure tree and a file model corresponding to all pages according to the components, the page layout and the version number; generating an abstract syntax tree according to the component node structure tree and the file model corresponding to all pages;
and the code execution module is used for generating and running executable source codes according to the abstract syntax tree and storing the executable source codes.
In one possible implementation manner, the generating the component node structure tree and the file model corresponding to all pages according to the components, the page layout and the version number includes:
and generating a component node structure tree and a file model based on the document objectification model tree according to the components, the page layout and the version number.
In one possible embodiment, the system further comprises:
and the marking module is used for traversing the abstract syntax tree and adding a key point mark, wherein the key point mark is used for maintaining the structure of the abstract syntax tree unchanged.
In one possible embodiment, the system further comprises:
the verification module is used for verifying whether the component dragging event accords with a development rule or not and whether a component node structure tree is damaged or not according to the component, the page layout and the version number of the component dragging event; if the development rule is met and the component node structure tree is not damaged, generating a new abstract syntax tree; if the development rule is not met and/or the component node structure tree is damaged, stopping generating a new abstract syntax tree and sending out warning information.
In one possible implementation, the code update module 604 is further configured to store the new executable source code and update a version number.
The embodiment of the application also provides electronic equipment corresponding to the method provided by the embodiment. Referring to fig. 7, a schematic diagram of an electronic device according to some embodiments of the present application is shown. The electronic device 20 may include: a processor 200, a memory 201, a bus 202 and a communication interface 203, the processor 200, the communication interface 203 and the memory 201 being connected by the bus 202; the memory 201 stores a computer program executable on the processor 200, and the processor 200 executes the method provided in any of the foregoing embodiments of the present application when the computer program is executed.
The memory 201 may include a high-speed random access memory (RAM: random Access Memory), and may further include a non-volatile memory (non-volatile memory), such as at least one disk memory. The communication connection between the system network element and at least one other network element is implemented through at least one physical port 203 (which may be wired or wireless), the internet, a wide area network, a local network, a metropolitan area network, etc. may be used.
The processor 200 may be an integrated circuit chip with signal processing capabilities. In implementation, the steps of the above method may be performed by integrated logic circuits of hardware in the processor 200 or by instructions in the form of software. The processor 200 may be a general-purpose processor, including a central processing unit (Central Processing Unit, CPU for short), a network processor (Network Processor, NP for short), etc.; but may also be a Digital Signal Processor (DSP), application Specific Integrated Circuit (ASIC), an off-the-shelf programmable gate array (FPGA) or other programmable logic device, discrete gate or transistor logic device, discrete hardware components. The disclosed methods, steps, and logic blocks in the embodiments of the present application may be implemented or performed. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like. The steps of a method disclosed in connection with the embodiments of the present application may be embodied directly in hardware, in a decoded processor, or in a combination of hardware and software modules in a decoded processor. The software modules may be located in a random access memory, flash memory, read only memory, programmable read only memory, or electrically erasable programmable memory, registers, etc. as well known in the art. The storage medium is located in the memory 201, and the processor 200 reads the information in the memory 201, and in combination with its hardware, performs the steps of the above method.
The electronic device provided by the embodiment of the application and the method provided by the embodiment of the application are the same in the invention conception, and have the same beneficial effects as the method adopted, operated or realized by the electronic device.
The present application further provides a computer readable storage medium corresponding to the method provided in the foregoing embodiments, referring to fig. 8, the computer readable storage medium is shown as an optical disc 30, on which a computer program (i.e. a program product) is stored, where the computer program, when executed by a processor, performs the method provided in any of the foregoing embodiments.
It should be noted that examples of the computer readable storage medium may also include, but are not limited to, a phase change memory (PRAM), a Static Random Access Memory (SRAM), a Dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), a Read Only Memory (ROM), an Electrically Erasable Programmable Read Only Memory (EEPROM), a flash memory, or other optical or magnetic storage medium, which will not be described in detail herein.
The computer readable storage medium provided by the above-described embodiments of the present application has the same advantageous effects as the method adopted, operated or implemented by the application program stored therein, for the same inventive concept as the method provided by the embodiments of the present application.
It should be noted that:
the algorithms and displays presented herein are not inherently related to any particular computer, virtual machine, or other apparatus. Various general purpose devices may also be used with the teachings herein. The required structure for the construction of such devices is apparent from the description above. In addition, the present application is not directed to any particular programming language. It will be appreciated that a variety of programming languages may be used to implement the teachings of the present application as described herein, and the above description of specific languages is provided for disclosure of preferred embodiments of the present application.
In the description provided herein, numerous specific details are set forth. However, it is understood that embodiments of the present application may be practiced without these specific details. In some instances, well-known methods, structures and techniques have not been shown in detail in order not to obscure an understanding of this description.
Similarly, it should be appreciated that in the foregoing description of exemplary embodiments of the application, various features of the application are sometimes grouped together in a single embodiment, figure, or description thereof for the purpose of streamlining the application and aiding in the understanding of one or more of the various inventive aspects. However, the disclosed method should not be construed as reflecting the intention that: i.e., the claimed application requires more features than are expressly recited in each claim. Rather, as the following claims reflect, inventive aspects lie in less than all features of a single foregoing disclosed embodiment. Thus, the claims following the detailed description are hereby expressly incorporated into this detailed description, with each claim standing on its own as a separate embodiment of this application.
Those skilled in the art will appreciate that the modules in the apparatus of the embodiments may be adaptively changed and disposed in one or more apparatuses different from the embodiments. The modules or units or components of the embodiments may be combined into one module or unit or component and, furthermore, they may be divided into a plurality of sub-modules or sub-units or sub-components. Any combination of all features disclosed in this specification (including any accompanying claims, abstract and drawings), and all of the processes or units of any method or apparatus so disclosed, may be used in combination, except insofar as at least some of such features and/or processes or units are mutually exclusive. Each feature disclosed in this specification (including any accompanying claims, abstract and drawings), may be replaced by alternative features serving the same, equivalent or similar purpose, unless expressly stated otherwise.
Furthermore, those skilled in the art will appreciate that while some embodiments described herein include some features but not others included in other embodiments, combinations of features of different embodiments are meant to be within the scope of the present application and form different embodiments. For example, in the following claims, any of the claimed embodiments can be used in any combination.
Various component embodiments of the present application may be implemented in hardware, or in software modules running on one or more processors, or in a combination thereof. Those skilled in the art will appreciate that some or all of the functions of some or all of the components in the creation means of a virtual machine according to embodiments of the present application may be implemented in practice using a microprocessor or Digital Signal Processor (DSP). The present application may also be embodied as an apparatus or device program (e.g., computer program and computer program product) for performing a portion or all of the methods described herein. Such a program embodying the present application may be stored on a computer readable medium, or may have the form of one or more signals. Such signals may be downloaded from an internet website, provided on a carrier signal, or provided in any other form.
It should be noted that the above-mentioned embodiments illustrate rather than limit the application, and that those skilled in the art will be able to design alternative embodiments without departing from the scope of the appended claims. In the claims, any reference signs placed between parentheses shall not be construed as limiting the claim. The word "comprising" does not exclude the presence of elements or steps not listed in a claim. The word "a" or "an" preceding an element does not exclude the presence of a plurality of such elements. The application may be implemented by means of hardware comprising several distinct elements, and by means of a suitably programmed computer. In the unit claims enumerating several means, several of these means may be embodied by one and the same item of hardware. The use of the words first, second, third, etc. do not denote any order. These words may be interpreted as names.
The foregoing is merely a preferred embodiment of the present application, but the scope of the present application is not limited thereto, and any changes or substitutions easily contemplated by those skilled in the art within the technical scope of the present application should be covered by the scope of the present application. Therefore, it should be understood by those skilled in the art that, based on the scope of the claims, all or part of the processes in the above embodiments may be implemented by a computer program, which may be stored in a computer readable storage medium, and the program may include processes in the embodiments of the above methods when executed. The storage medium may be a nonvolatile storage medium such as a magnetic disk, an optical disk, a Read-Only Memory (ROM), or a random access Memory (Random Access Memory, RAM).
The technical features of the above-described embodiments may be arbitrarily combined, and all possible combinations of the technical features in the above-described embodiments are not described for brevity of description, however, as long as there is no contradiction between the combinations of the technical features, they should be considered as the scope of the description.
The foregoing examples illustrate only a few embodiments of the invention and are described in detail herein without thereby limiting the scope of the invention. It should be noted that it will be apparent to those skilled in the art that several variations and modifications can be made without departing from the spirit of the invention, which are all within the scope of the invention. Accordingly, the scope of protection of the present invention is to be determined by the appended claims.
Claims (10)
1. A method of low code development, the method comprising:
when the engine of the low-code platform monitors a component drag starting event, judging whether the component drag starting event is monitored for the first time;
if the abstract syntax tree is not monitored for the first time, reading an executable source code of a current platform page, and analyzing the executable source code to obtain the abstract syntax tree;
generating a component node structure tree and a file model according to the abstract syntax tree, and generating a platform page according to the component node structure tree and the file model for a user to drag;
after the component dragging event is monitored, a new abstract syntax tree is generated according to the component, the page layout and the version number of the component dragging event, and then a new executable source code is generated and operated according to the new abstract syntax tree.
2. The method of claim 1, wherein if the component drag initiation event is first heard, the method further comprises:
acquiring a component, a page layout and a version number of a component drag starting event;
generating a component node structure tree and a file model corresponding to all pages according to the components, the page layout and the version number;
generating an abstract syntax tree according to the component node structure tree and the file model corresponding to all pages;
and generating and running executable source codes according to the abstract syntax tree, and storing the executable source codes.
3. The method of claim 2, wherein generating the component node structure tree and the file model for all pages according to the components, page layout and version numbers comprises:
and generating a component node structure tree and a file model based on the document objectification model tree according to the components, the page layout and the version number.
4. The method of claim 1, wherein after parsing the executable source code to obtain an abstract syntax tree, the method further comprises:
and traversing the abstract syntax tree to add a key point mark, wherein the key point mark is used for maintaining the structure of the abstract syntax tree unchanged.
5. The method of claim 1, wherein the generating a new abstract syntax tree from the component, the page layout, and the version number of the component drag event after the component drag event is to be monitored, the method further comprises:
verifying whether the component dragging event accords with a development rule or not and whether a component node structure tree is damaged or not according to the components, page layout and version numbers of the component dragging event;
if the development rule is met and the component node structure tree is not damaged, generating a new abstract syntax tree;
if the development rule is not met and/or the component node structure tree is damaged, stopping generating a new abstract syntax tree and sending out warning information.
6. The method of claim 1, wherein after generating and running new executable source code from the new abstract syntax tree, the method further comprises:
storing the new executable source code and updating the version number.
7. A low code development system, the system comprising:
the judging module is used for judging whether the component drag starting event is monitored for the first time when the low-code platform engine monitors the component drag starting event;
the abstract syntax tree restoring module is used for reading the executable source code of the current platform page if the abstract syntax tree restoring module is not monitored for the first time, and analyzing the executable source code to obtain an abstract syntax tree;
the page restoration module is used for generating a component node structure tree and a file model according to the abstract syntax tree, and generating a platform page for a user to drag according to the component node structure tree and the file model;
and the code updating module is used for generating a new abstract syntax tree according to the components, page layout and version number of the component dragging event after the component dragging event is monitored, and generating and running a new executable source code according to the new abstract syntax tree.
8. The system of claim 7, wherein the system further comprises:
the information acquisition module is used for acquiring the components, page layout and version numbers of the component dragging starting event;
the abstract syntax tree generation module is used for generating a component node structure tree and a file model corresponding to all pages according to the components, the page layout and the version number; generating an abstract syntax tree according to the component node structure tree and the file model corresponding to all pages;
and the code execution module is used for generating and running executable source codes according to the abstract syntax tree and storing the executable source codes.
9. An electronic device, comprising: memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the processor executes to implement the method according to any of the claims 1-6 when running the computer program.
10. A computer readable storage medium having stored thereon computer readable instructions executable by a processor to implement the method of any of claims 1-6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310268938.0A CN116431127A (en) | 2023-03-14 | 2023-03-14 | Low code development method, system, equipment and readable storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310268938.0A CN116431127A (en) | 2023-03-14 | 2023-03-14 | Low code development method, system, equipment and readable storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116431127A true CN116431127A (en) | 2023-07-14 |
Family
ID=87088136
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310268938.0A Pending CN116431127A (en) | 2023-03-14 | 2023-03-14 | Low code development method, system, equipment and readable storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116431127A (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117289937A (en) * | 2023-11-27 | 2023-12-26 | 成都中科极云软件有限公司 | Method and system for realizing linkage of internal and external data of layout container in low-code platform |
| CN118259891A (en) * | 2024-05-31 | 2024-06-28 | 济南浪潮数据技术有限公司 | VUE source code export method, equipment, program product and medium |
-
2023
- 2023-03-14 CN CN202310268938.0A patent/CN116431127A/en active Pending
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117289937A (en) * | 2023-11-27 | 2023-12-26 | 成都中科极云软件有限公司 | Method and system for realizing linkage of internal and external data of layout container in low-code platform |
| CN117289937B (en) * | 2023-11-27 | 2024-01-26 | 成都中科极云软件有限公司 | Method and system for realizing linkage of internal and external data of layout container in low-code platform |
| CN118259891A (en) * | 2024-05-31 | 2024-06-28 | 济南浪潮数据技术有限公司 | VUE source code export method, equipment, program product and medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN116431127A (en) | Low code development method, system, equipment and readable storage medium | |
| CN106547520B (en) | Code path analysis method and device | |
| CN104020994B (en) | Stream process definition device and stream process based on streaming system define method | |
| CN111124479B (en) | Method and system for analyzing configuration file and electronic equipment | |
| CN110309629B (en) | Webpage code reinforcement method, device and equipment | |
| CN110673852B (en) | Method, system and equipment for realizing control flow flattening based on front end of compiler | |
| CN115509514B (en) | Front-end data simulation method, device, equipment and medium | |
| CN111427578B (en) | Data conversion method, device and equipment | |
| Farzan et al. | Phased synthesis of divide and conquer programs | |
| CN112988163A (en) | Intelligent programming language adaptation method and device, electronic equipment and medium | |
| CN111240772A (en) | Data processing method and device based on block chain and storage medium | |
| CN110489124B (en) | Source code execution method, source code execution device, storage medium and computer equipment | |
| CN117008920A (en) | Engine system, request processing method and device, computer equipment and storage medium | |
| CN111367512B (en) | Method and device for creating Android library module dependency relationship in application development | |
| CN110765008B (en) | Data processing method and device | |
| US8954307B1 (en) | Chained programming language preprocessors for circuit simulation | |
| US8645758B2 (en) | Determining page faulting behavior of a memory operation | |
| CN116414396A (en) | LLVM (logical level virtual machine) target definition file generation method and device and electronic equipment | |
| CN111880803B (en) | Software construction method and device applied to multiple platforms | |
| JP2015146178A (en) | Creation of test context | |
| CN113536716A (en) | SOC system verification method and device, computer equipment and readable storage medium | |
| CN114817124A (en) | Inter-multi-core microcontroller mapping method, device and computer-readable storage medium | |
| CN112685043A (en) | Asynchronous conversion method, device and equipment of callback function and readable storage medium | |
| EP2782005A1 (en) | Verifying state reachability in a statechart model having computer program code embedded therein | |
| CN112818613A (en) | Automatic simulation method, device, equipment and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |