Cross-platform low-code development system and method supporting code export

Abstract

The application belongs to the field of low-code platform development, and discloses a cross-platform low-code development system and method supporting code export; the method comprises the following steps: dividing a visual layout in a low-code platform into a central process area and R sub-process areas according to a preset rule; acquiring central structure data and sub-level structure data of a target project; acquiring a total logical complexity value of the project based on the central structure data and the sub-level structure data; acquiring an initial flowchart corresponding to the target project; inputting the central structure data, the sub-level structure data, the total logical complexity value and the initial flowchart into a pre-trained process optimization model to acquire an optimized target flowchart; and packing a target sub-process in the target flowchart as a reusable plug-in of a cross-project process; and the method effectively improves the operation efficiency of a developer project.

Description

TECHNICAL FIELD

[0001] The application belongs to the field of low-code platform development, and more particularly, the application relates to a cross-platform low-code development system and method supporting code export. BACKGROUND

[0002] A Chinese patent with the granted publication number CN115438050B discloses a hierarchical low-code development platform, which includes a module management unit, a menu item management unit, and a general query management unit. The module management unit is used to provide design functions of modules, wherein the modules include function modules and form modules, and also provides functions of designing data structures for the form modules, provides development controls, and designs interfaces for the form modules and the function modules based on the development controls through a drag-and-drop manner, and also supports a function of customizing scripts. The menu item management unit is used to support design of menu items, and configure basic information of the menu items, data source SQL, operation types of the menu items, and associated assemblies. The general query management unit is used to display the designed menu items and the designed form modules through a record list. The platform can reduce system complexity, realize different requirements of upper and lower levels, and realize low-code.

[0003] The existing technology still has the following problems:

[0004] When the business process or logic set by the user is too complex, the visual flowchart may become large and difficult to manage. The project process built by the user may be excessively redundant and have too many logic nodes in the layout interface, which eventually leads to a project view crash and affects the running efficiency of the project.

[0005] In view of this, the application provides a cross-platform low-code development system and method supporting code export to solve the above problems. SUMMARY

[0006] In order to overcome the above-mentioned defects of the prior art, in order to achieve the above-mentioned purpose, the application provides the following technical scheme: a cross-platform low-code development method supporting code export, comprising:

[0007] According to a preset rule, a visual layout in a low-code platform is divided into a center flow area and R sub-flow areas;

[0008] Obtain center structure data and sub-level structure data of a target project;

[0009] Based on the center structure data and the sub-level structure data, obtain a total logic complexity value of the project;

[0010] Obtain an initial flowchart corresponding to the target project;

[0011] Based on the center structure data, the sub-level structure data, the total logical complexity value and the initial flowchart, input into the pre-trained flow optimization model, the optimized target flowchart is obtained;

[0012] Packaging the target sub-flow in the target flowchart as a reusable plug-in of cross-project flow;

[0013] The project corresponding to the target flowchart and the reusable plug-in are converted into a Dart source code file, and a corresponding multi-end installation package is output.

[0014] Further, the flow optimization model acquisition method comprises:

[0015] A z-group flow data set is obtained, which includes center structure data, sub-level structure data, total logical complexity value, initial flowchart and corresponding target flowchart; the flow data set is used as a sample set, and the sample set is divided into a training set and a test set; an RNN classifier is constructed, the center structure data, the sub-level structure data, the total logical complexity value and the initial flowchart in the training set are used as the input of the flow optimization model, and the corresponding target flowchart in the training set is used as the output, the classifier is iteratively trained to obtain a preliminary optimization model; the preliminary optimization model is tested by using the test set, if the accuracy of the preliminary optimization model meets the preset accuracy, the preliminary optimization model is used as the flow optimization model; the preliminary optimization model is an RNN neural network model; z is a positive integer greater than 1.

[0016] Further, the sub-flow packaging method comprises:

[0017] Step 1: mark the reused sub-flow area in the editor, and mark the sub-flow area as "plug-in flow";

[0018] Step 2: the system packs the plug-in flow into an independently managed plug-in and stores it in the public plug-in library of the team; the plug-in includes sub-level structure data corresponding to the sub-flow area and plug-in description; the plug-in description includes function description, use scenario and version information of the plug-in;

[0019] Step 3: when other projects in the team need to implement the same function, the plug-in is directly imported from the public plug-in library, and the corresponding sub-flow structure schematic diagram is automatically generated on the canvas;

[0020] Step 4: when team members develop collaboratively, the "plug-in" is updated once, that is, it is synchronized to each project using the sub-flow, and finally integrated and exported for multi-end use.

[0021] Further, the center structure data is quantified data in the center flow area; the sub-level structure data is quantified data in the sub-flow area; the quantified data includes node quantity, connection quantity, nesting level, usage frequency and cross-area dependency; and the target project is a project built by a user.

[0022] The method for obtaining the total logic complexity value comprises: quantifying the node quantity, the connection quantity, the nesting level, the usage frequency and the cross-area dependency, comprehensively evaluating the logic complexity of each area, and calculating the total logic complexity value of the entire project.

[0023] Further, the method for obtaining the connection quantity and the cross-area dependency comprises:

[0024] If the start point and the end point of the connection are both in the center flow area, the connection quantity of the center flow area is counted.

[0025] If the start point and the end point of the connection are both in the same sub-flow area, the connection quantity of the sub-flow area is counted.

[0026] If the start point and the end point of the connection are not in the same sub-flow area and are not in the center flow area, the cross-area dependency is recorded.

[0027] Further, the method for obtaining the nesting level comprises:

[0028] The low-code platform performs one round of DFS on the center flow and the sub-flow respectively when the editor corresponding to the project is saved, and records the maximum level from the initial node corresponding to the respective flow to the deepest branch; the nesting level is counted once every time a node is passed.

[0029] Further, the method for obtaining the node quantity comprises:

[0030] When the project is loaded, all nodes are traversed to detect the unique identifier and the position of the node; if the position corresponding to the node is in the center flow area, the node quantity of the center flow area is counted; if the position corresponding to the node is outside the center flow area, the node quantity of the sub-flow area is counted.

[0031] Further, the initial flowchart is a project view built by a user on a cross-platform low-code development platform; and the initial flowchart is obtained by taking a screenshot of the current window of the user.

[0032] Further, the multi-end installation package includes installation packages for Android, iOS and Windows platforms; and the Dart source code file is obtained through a Flutter command line tool.

[0033] The cross-platform low-code development system supporting code export implements the cross-platform low-code development method supporting code export, comprising:

[0034] A logic layering module divides the visual layout in the low-code platform into a central process area and R sub-process areas according to preset rules;

[0035] A data acquisition module is configured to acquire central structure data and sub-level structure data of a target project;

[0036] A logic calculation module is configured to acquire a total logic complexity value of the project based on the central structure data and the sub-level structure data;

[0037] A picture acquisition module is configured to acquire an initial flowchart corresponding to the target project;

[0038] A process optimization module is configured to input the central structure data, the sub-level structure data, the total logic complexity value and the initial flowchart into a pre-trained process optimization model to acquire an optimized target flowchart;

[0039] A team expansion module is configured to package a target sub-process in the target flowchart as a reusable plug-in of a cross-project process;

[0040] A code output module is configured to convert the project corresponding to the target flowchart and the reusable plug-in into a Dart source code file and output a corresponding multi-end installation package.

[0041] The cross-platform low-code development system and method supporting code export have the following technical effects and advantages:

[0042] By acquiring the central structure data and the sub-level structure data of the project and the total logic complexity value, and combining the initial flowchart corresponding to the project, the initial flowchart is input into the pre-trained process optimization model for optimization, the mapping from the initial flowchart to the target flowchart is learned from the training set, and the optimization operation of sub-process and node folding on the process is automatically performed, thereby reducing the operation burden of the user in the complex project, improving the quality of the automatically generated target flowchart, and effectively improving the running efficiency of the corresponding project.

[0043] By quantitatively analyzing the number of nodes, the number of lines, cross-area dependence, nesting level and usage frequency of the central process area and the sub-process area, the system intelligently calculates the complexity and optimizes the flowchart, reduces the area with high coupling degree, avoids the spread of the tree-like structure of the project view, and improves the readability of the flowchart; meanwhile, the introduction of the usage frequency enables the nodes with high usage frequency to be preferentially maintained in the central process area, thereby effectively improving the maintainability and optimization capability of the process.

[0044] Based on the support of the Flutter framework, the platform can automatically generate Dart source code and installation packages adapted to multiple platforms (such as Android, iOS and Windows). By automatically generating code, developers can quickly complete the deployment of cross-platform projects, reducing the workload of manual coding and packaging, and significantly improving the speed and quality of project online. BRIEF DESCRIPTION OF DRAWINGS

[0045] Figure 1 A cross-platform low-code development system supporting code export for embodiment 1 of the present application;

[0046] Figure 2 A cross-platform low-code development method flowchart supporting code export for embodiment 2 of the present application;

[0047] Figure 3 A visual layout diagram for embodiment 1 of the present application;

[0048] Figure 4 A widget panel diagram in the low-code platform for embodiment 1 of the present application. DETAILED DESCRIPTION

[0049] The technical solutions in the embodiments of the present application will be described clearly and completely below with reference to the drawings in the embodiments of the present application. Obviously, the described embodiments are only a part of the embodiments of the present application, not all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative labor fall within the scope of protection of the present application.

[0050] Embodiment 1

[0051] Please refer to Figure 1 The cross-platform low-code development system supporting code export described in this embodiment includes a logical layering module, a data acquisition module, a logic calculation module, a picture acquisition module, a process optimization module, a team expansion module and a code output module. Each module is connected through wired and / or wireless connection.

[0052] The logical layering module divides the visual layout in the low-code platform into a central process area and R sub-process areas according to a preset rule. The preset rule is to set the main area of the system in the visual layout of the low-code platform. The project process in the main area is the central process area. The project process outside the main area is divided into R sub-process areas according to a preset distance. R is a positive integer greater than 1.

[0053] Exemplarily, please refer to Figure 3As shown, the visual layout in the low-code platform is divided into a central process area and 8 sub-process areas, with 4 sub-process areas on each side of the central process area, and the spacing between adjacent sub-process areas is equal, all being 0.

[0054] It should be noted that regarding the "main area in the visual layout" as the central process area enables the subsequent system to quickly determine which nodes belong to the core business and which are auxiliary logic or detachable sub-processes; at the same time, the user "draws" or "specifies" a main area in the visual layout, which can also accurately express the business focus.

[0055] The data acquisition module acquires central structure data and sub-level structure data of the target project; the central structure data is quantitative data in the central process area; the sub-level structure data is quantitative data in the sub-process area; the quantitative data includes node quantity, connection quantity, nesting level, usage frequency and cross-area dependency; the target project is a project constructed by the user.

[0056] The more the node quantity, the more complex the logic; if the node quantity in the central process area exceeds the preset node quantity, it indicates that the current main process is too large, and the subsequent maintenance and readability will decrease significantly, and it needs to be split or simplified again to prevent the canvas from being seriously congested; if the node quantity in the sub-process area is greater than or equal to the node quantity in the central process area, it indicates that the sub-process may have exceeded the size of the main process, weakening the original intention of hierarchical design.

[0057] It should be noted that for the low-code development platform based on Flutter of the present application, a node represents a logical function block, which corresponds to a Widget in Flutter.

[0058] For example, please refer to Figure 4 As shown, the low-code development platform includes a widget panel; the widgets include layout elements, basic elements, page elements and form elements; the layout elements include left-right layout, top-bottom layout, container, flow layout, navigation switch, waterfall, list layout, grid layout, division line, vertical division line, card layout, spacing, layer exchange, drag layout, flip card, expandable, table, carousel and page view; each widget corresponds to a node.

[0059] The connection quantity is the number of connections of nodes in each area of the central process area and the sub-process area; the more the connections, the higher the coupling degree of the corresponding area, and the more difficult it is to modify the area subsequently.

[0060] It should be noted that the cross-region dependency refers to the number of connections across different regions (such as the number of connections between the center process region and the sub-process region or between multiple sub-process regions); if the ratio of the cross-region dependency to the total number of connections is greater than or equal to a preset ratio, it indicates that the user's division of the project process is not independent enough, and further optimization needs to be performed through the subsequent process optimization model to reduce the dependency of different regions and reduce the influence range of the later fine-tuning; the total number of connections is the sum of the number of connections of the nodes in the center process region and the sub-process region and the cross-region dependency.

[0061] The nesting level of the center process region represents the maximum depth of nested conditions, loops, and sub-process calls in the center process; the nesting level of the sub-process region represents the maximum depth of judgment, loop, and parallel structure inside each sub-process; if the nesting level is too deep, the maintenance difficulty is high, and the canvas structure may appear "branch" type spread, causing low readability; therefore, when calculating the logic complexity subsequently, the nesting level is used as a level weight index, which can significantly enhance the comprehensive evaluation accuracy of the overall process complexity; if the level weight is high, it indicates that the process has deep nested structures, which need to be improved in the subsequent process optimization model to reduce the maintenance and modification cost.

[0062] The frequency of use is the number of triggers of each node during the test project run; by obtaining the number of triggers of each node, the accuracy of the subsequent calculation of logic complexity can be improved; at the same time, the unique identifier corresponding to the node and the frequency of use of the node are used as the input of the subsequent process optimization model, which helps to improve the optimization ability of the model to the initial flowchart input; for example, high-frequency nodes often need to maintain maintainability, thereby being divided into the center process.

[0063] The method for obtaining the number of nodes comprises:

[0064] When the project is loaded, all nodes are traversed once to detect the unique identifier and position of the node; if the position corresponding to the node is in the main region, the number of nodes in the center process region is counted; if the position corresponding to the node is outside the main region, the number of nodes in the sub-process region is counted.

[0065] The method for obtaining the number of connections and the cross-region dependency comprises:

[0066] If the start point and end point of the connection are both in the center process region, the number of connections in the center process region is counted.

[0067] If the start point and end point of the connection are both in the same sub-process region, the number of connections in the sub-process region is counted.

[0068] If the start point and end point of the connection are not in the same sub-process region and are not in the center process region, it is recorded as a cross-region dependency.

[0069] The acquisition method of the nesting level comprises:

[0070] The low-code platform performs one round of DFS (depth-first search) on the center flow and the sub-flow when the editor corresponding to the project is saved, and records the maximum level from the initial node corresponding to each flow to the deepest branch; wherein each node passed can increase the count of nesting level once.

[0071] The frequency of use is obtained by adding a buried point to the node; the buried point is a statistical code that records the number of occurrences of events when the project is running.

[0072] The logic calculation module obtains the total logic complexity value of the project based on the center structure data and the sub-level structure data.

[0073] The acquisition method of the total logic complexity value comprises:

[0074]

[0075] Wherein, C is the total logic complexity value; R+1 is the total number of center flow areas and sub-flow areas; r is the area number of the total number of center flow areas and sub-flow areas; N r is the number of nodes corresponding to the rth area; M r is the number of connections corresponding to the rth area; S r is the nesting level corresponding to the rth area; q is the total number of cross-area dependencies of the project; Q is the total number of connections of the project; U is the average value of the frequency of use of all nodes corresponding to the current area; α, β, λ and are the corresponding weight factors, respectively.

[0076] The picture acquisition module is configured to acquire an initial flowchart corresponding to the target project; the initial flowchart is a project view constructed by a user on a cross-platform low-code development platform.

[0077] The initial flowchart is acquired by taking a screenshot of the current window of the user.

[0078] The flow optimization module inputs the center structure data, the sub-level structure data, the total logic complexity value and the initial flowchart into a pre-trained flow optimization model to obtain an optimized target flowchart.

[0079] The acquisition method of the flow optimization model comprises:

[0080] Obtaining z sets of process data, the process data set including center structure data, sub-level structure data, total logical complexity value and initial flowchart and corresponding target flowchart; taking the process data set as a sample set, dividing the sample set into a training set and a test set; constructing an RNN classifier, taking the center structure data, sub-level structure data, total logical complexity value and initial flowchart in the training set as the input of the process optimization model, taking the corresponding target flowchart in the training set as the output, iteratively training the classifier to obtain a preliminary optimization model; testing the preliminary optimization model by using the test set, if the accuracy of the preliminary optimization model meets the preset accuracy, taking the preliminary optimization model as the process optimization model; the preliminary optimization model is an RNN neural network model; z is a positive integer greater than 1.

[0081] It should be noted that the corresponding target flowchart in the process data set is constructed by optimizing the initial flowchart by a person skilled in the art; the optimization operation includes sub-process and node folding, the purpose is to reduce the density of single process node and connection line, avoid excessive congestion and high complexity of the canvas; the sub-process refers to splitting large-scale, complex process area into smaller, more manageable sub-modules; the node folding is to combine multiple closely connected nodes into a higher level logical block. The optimization operation helps to reduce the nesting level in the flowchart, simplify the connection relationship, thereby improving the readability and maintainability of the flowchart.

[0082] By constructing the target flowchart, the pre-trained process optimization model can learn the mapping relationship from the initial complex flowchart to the simplified and optimized flowchart; this not only helps the system to automatically optimize the business process in the low-code platform, but also provides solid data support for subsequent process optimization; the use of training set and test set guarantees the generalization ability of the optimization model, so as to adapt to the process optimization needs of flowcharts of different project complexities.

[0083] The team expansion module is used to package the target sub-process in the target flowchart as a reusable plug-in of cross-project process.

[0084] When multiple projects need to share some common process fragments or business logic, the previously split sub-process can be packaged as a "reusable plug-in" to improve team collaboration efficiency and reduce the cost of repeated development.

[0085] The sub-process packaging method includes:

[0086] Step 1: Mark the sub-process area that needs to be reused in the editor as "plug-in process"; the marking of the plug-in process enables the sub-process area to be reused as an independent module in different projects, without relying on other process parts of the current project.

[0087] Step 2: The system packages the plug-in process into an independently managed plug-in and stores it in the team's public plug-in library; the plug-in includes sub-process area corresponding sub-level structure data and plug-in description; the plug-in description includes the function description, usage scenario and version information of the plug-in, which facilitates team members to understand the role of the plug-in.

[0088] Step 3: When other projects in the team need to implement the same function, directly import the plug-in from the public plug-in library, thereby automatically generating the corresponding sub-process structure diagram on the canvas.

[0089] It should be noted that since the target sub-process in the target flowchart is used as a plug-in, the plug-in at this time corresponds to the optimized sub-process area, which has modularity and high maintainability.

[0090] Step 4: When team members develop collaboratively, update the "plug-in" once, that is, synchronize to each project that uses this sub-process, and finally integrate and export to multiple ends for use.

[0091] It should be noted that the updated plug-in will be automatically synchronized to all projects that use the plug-in, avoiding the need for each project to modify and update the same function repeatedly.

[0092] Code output module, convert the target flowchart corresponding project and reusable plug-in into Dart source code file, output the corresponding multi-end installation package.

[0093] Under the support of Flutter cross-platform framework, the optimized process can automatically generate Dart source code and installation packages adapted to multiple platforms, including Android, iOS and Windows, etc., ensuring the cross-platform compatibility and scalability of the project built by the user; At the same time, the function of automatically generating code and installation package reduces the manual operation of the developer user, improves the project online speed.

[0094] It should be noted that Flutter is an open source UI toolkit developed by Google, designed for building high-performance, high-fidelity cross-platform applications; Flutter does not rely on platform native controls, but directly draws UI to the canvas through its own graphics engine (Skia); making the UI performance of Android, iOS, Windows and other platforms completely consistent, effectively avoiding the component adaptation problem of traditional cross-platform frameworks.

[0095] It should be noted that Dart is an object-oriented programming language developed by Google, and is also the official development language of Flutter; users only need to write Dart code, and Flutter automatically handles multi-platform adaptation problems; Dart source code is the "language carrier" of the Flutter cross-platform framework, and the Flutter cross-platform framework is the "function framework" of the Dart source code.

[0096] The multi-terminal installation package includes installation packages of platforms such as Android, iOS and Windows.

[0097] The Dart source code file is obtained through a Flutter command line tool.

[0098] Embodiment 2

[0099] Please refer to Figure 2 The embodiment provides a cross-platform low-code development method supporting code export, including:

[0100] According to a preset rule, the visual layout in the low-code platform is divided into a center flow area and R sub-flow areas;

[0101] Obtain the center structure data and the sub-level structure data of the target project;

[0102] Based on the center structure data and the sub-level structure data, obtain the total logical complexity value of the project;

[0103] Obtain the initial flowchart corresponding to the target project;

[0104] Based on the center structure data, the sub-level structure data, the total logical complexity value and the initial flowchart, input into a pre-trained flow optimization model to obtain an optimized target flowchart;

[0105] Packaging the target sub-flow in the target flowchart as a reusable plug-in of cross-project flow;

[0106] Convert the project corresponding to the target flowchart and the reusable plug-in into a Dart source code file, and output a corresponding multi-terminal installation package.

[0107] Embodiment 3

[0108] In order to ensure that the user can maintain high efficiency and high maintainability when building a large project for module management and reuse, the application also provides a multi-level sub-flow division system; not only can the complex project flow be divided into a plurality of small modules that are easier to manage and reuse, but also can ensure the independence and maintainability of each sub-flow, thereby avoiding the difficulty of maintenance caused by excessive complexity; the detailed operation steps of the multi-level sub-flow division are:

[0109] Step 1, record the logic complexity value corresponding to each region when calculating the total logic complexity value.

[0110] Step 2, if the logic complexity value of the current region is greater than the preset complexity threshold, further split it into two sub-flow regions, marked as n-level sub-region; the initial value of n is 1.

[0111] Step 3, if the logic complexity value of the n-level sub-region is still greater than the preset complexity threshold, further split it into two sub-flow regions, marked as n+1-level sub-region.

[0112] Step 4, repeat step 3 until the logic complexity value of the newly split sub-region is less than or equal to the preset complexity threshold, record all the split sub-regions, so that subsequent packaging of target sub-flows in the target flowchart is more intuitive and concise.

[0113] Through the multi-level sub-flow division method, the system can effectively reduce the complexity of the flow while maintaining efficiency and modularity, ensuring that users can quickly identify and maintain each independent sub-flow region when managing complex projects, improving the accuracy of sub-flow region reuse, and further improving the operating efficiency of the user team when building the total project.

[0114] The above-described embodiments are only used to illustrate the technical solutions of the present application, and not to limit them; although the present application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that they can modify the technical solutions described in the foregoing embodiments, or make equivalent replacements for some technical features; and these modifications or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present application, and should be included in the protection scope of the present application.

Claims

1. A cross-platform low-code development method supporting code export, characterized in that, The application relates to a method for optimizing a project flow in a low-code platform. The method comprises the following steps: dividing a visual layout in the low-code platform into a central flow area and R sub-flow areas according to preset rules; obtaining central structure data and sub-level structure data of a target project; the central structure data is quantitative data in the central flow area; the sub-level structure data is quantitative data in the sub-flow area; the quantitative data comprises node quantity, connection line quantity, nesting level, use frequency and cross-area dependence; the target project is a project constructed by a user; obtaining a total logical complexity value of the project based on the central structure data and the sub-level structure data; obtaining an initial flowchart corresponding to the target project; inputting the central structure data, the sub-level structure data, the total logical complexity value and the initial flowchart into a pre-trained flow optimization model to obtain an optimized target flowchart; packaging a target sub-flow in the target flowchart as a reusable plug-in of a cross-project flow; 2. The cross-platform low-code development method with support for code export of claim 1, wherein, converting the project corresponding to the target flowchart and the reusable plug-in into a Dart source code file and outputting a corresponding multi-terminal installation package. Acquisition The group flow data set, the flow data set including the center structure data, the sub-level structure data, the total logical complexity value and the initial flowchart and the corresponding target flowchart; the flow data set is taken as a sample set, the sample set is divided into a training set and a test set; the center structure data, the sub-level structure data, the total logical complexity value and the initial flowchart in the training set are taken as the input of the flow optimization model, the corresponding target flowchart in the training set is taken as the output, the classifier is iteratively trained, and a preliminary optimization model is acquired; the preliminary optimization model is tested by using the test set, if the accuracy of the preliminary optimization model meets the preset accuracy, the preliminary optimization model is taken as the flow optimization model; the preliminary optimization model is an RNN neural network model; is a positive integer greater than 1. 3.The cross-platform low-code development method with support of code derivation of claim 1, wherein, The method for obtaining the flow optimization model comprises the following steps: The sub-flow packaging method comprises the following steps: Step 1: marking a reused sub-flow area in an editor as a plug-in flow; Step 2: the system packages the plug-in flow into an independently managed plug-in and stores the plug-in in a public plug-in library of a team; the plug-in comprises sub-level structure data corresponding to the sub-flow area and plug-in description; the plug-in description comprises function description, use scenario and version information of the plug-in; Step 3: when other projects in the team need to realize the same function, the plug-in is directly imported from the public plug-in library to automatically generate a corresponding sub-flow structure schematic diagram on a canvas; 4. The cross-platform low-code development method with support for code export of claim 1, wherein, Step 4: when team members develop cooperatively, the plug-in is updated once, that is, the plug-in is synchronized to each project using the sub-flow, and finally integrated and exported for multi-terminal use.

5. The cross-platform low-code development method with support for code export of claim 4, wherein, The method for obtaining the total logical complexity value comprises the following steps: quantifying node quantity, connection line quantity, nesting level, use frequency and cross-area dependence, comprehensively evaluating the logical complexity of each area, and then calculating the total logical complexity value of the entire project. The method for obtaining the connection line quantity and the cross-area dependence comprises the following steps: if the start point and the end point of a connection line are both in the central flow area, the connection line quantity of the central flow area is counted; if the start point and the end point of a connection line are both in the same sub-flow area, the connection line quantity of the sub-flow area is counted; 6. The cross-platform low-code development method with support for code export of claim 4, wherein, if the start point and the end point of a connection line are not in the same sub-flow area and are not in the central flow area, the connection line is recorded as cross-area dependence. The method for obtaining the nesting level comprises the following steps:

7. The cross-platform low-code development method with support for code export of claim 4, wherein, when the low-code platform saves an editor corresponding to a project, a round of DFS is performed on the central flow and the sub-flow respectively, the maximum level from an initial node corresponding to each flow to the deepest branch is recorded, and the counting of the nesting level is increased once every time a node is passed. The method for obtaining the node quantity comprises the following steps: When the project is loaded, a traversal is performed on all nodes to detect the unique identifier and position of the nodes; if the position corresponding to the node is in the central process area, the number of nodes in the central process area is counted; if the position corresponding to the node is outside the central process area, the number of nodes in the sub-process area is counted.

8. The cross-platform low-code development method with support for code export of claim 1, wherein, The initial flowchart is a project view constructed by a user on a cross-platform low-code development platform; the initial flowchart is obtained by taking a screenshot of the current window of the user.

9. The cross-platform low-code development method with support for code export of claim 1, wherein, The multi-end installation package includes installation packages for Android, iOS and Windows platforms; the Dart source code file is obtained through a Flutter command line tool.

10. A cross-platform low-code development system supporting code export, implementing the cross-platform low-code development method of any one of claims 1-9, characterized in that, Comprise: A logic layering module divides the visual layout in the low-code platform into a central process area and R sub-process areas according to a preset rule; A data acquisition module is configured to acquire central structure data and sub-level structure data of a target project; A logic calculation module acquires a total logic complexity value of the project based on the central structure data and the sub-level structure data; A picture acquisition module is configured to acquire an initial flowchart corresponding to the target project; A process optimization module inputs the central structure data, the sub-level structure data, the total logic complexity value and the initial flowchart into a pre-trained process optimization model to acquire an optimized target flowchart; A team expansion module is configured to package a target sub-process in the target flowchart as a reusable plug-in of cross-project processes; A code output module is configured to convert the project corresponding to the target flowchart and the reusable plug-in into a Dart source code file and output a corresponding multi-end installation package.

Images