Low-code conversion method and apparatus, readable storage medium, and device

Abstract

The present invention provides a low-code conversion method and apparatus, a readable storage medium, and a device. The method comprises: on the basis of a first keyword, a second keyword, and a third keyword in complete component code, extracting a module name, title, and filling code of the component code, and combining a preset readme file template with the module name, title, and filling code of the component code and generating low-code snippets; converting the low-code snippets into first-format code blocks; replacing the first, second, and third keywords with preset first, second, and third escape characters, so as to obtain escaped first-format code blocks; and traversing each escaped first-format code block and performing matching therefor against a preset second-format template, extracting the module name, title, and filling code of the component code from matched escaped first-format code blocks, and filling same into the second-format template and generating readable code. The method achieves automatic generation of fillable formatted code blocks, improving the efficiency of importing code into the system.

Description

Low-code conversion method, device, readable storage medium and equipment Technical Field

[0001] The present invention relates to the field of code conversion, and in particular to a low-code conversion method, apparatus, readable storage medium and device. Background Art

[0002] In the current software development process, developers save their project's source code to a Git repository and then deliver that repository to a code management platform for execution. However, different developers use different development platforms, coding languages, and coding habits, which can easily lead to different source code formats or languages ​​for different components of a project. Therefore, after developing a component, developers need to manually write code snippets for external use and external application programming interface documentation, requiring users to spend a considerable amount of time reading and understanding the principles of component implementation.

[0003] If users need to use an integrated development environment (IDE), they need to switch pages and copy and paste the code into the IDE, making it impossible to quickly search and use all components in the component library. This greatly reduces the development efficiency of R&D personnel and is not conducive to the large-scale copying and dissemination of code. Summary of the Invention

[0004] Based on this, the present invention provides a low-code conversion method, device, readable storage medium and equipment to convert the code fragments of the component into a data file in a fixed format, and generate code blocks that can be directly used in the IDE system from the data file through a script, greatly improving the development efficiency of R&D personnel.

[0005] In a first aspect, the present invention provides a low-code snippet conversion method, comprising:

[0006] Get the complete component code and preset README template;

[0007] Extracting a module name, title, and filler code of the component code according to the first keyword, the second keyword, and the third keyword in the complete component code, and combining the preset readme file template with the module name, title, and filler code of the component code to generate a low-code snippet;

[0008] If the low code snippet is updated, convert the low code snippet into a first format code block;

[0009] Replacing the first keyword, the second keyword, and the third keyword with a preset first escape character, a second escape character, and a third escape character, respectively, to obtain a first format code block after the escape;

[0010] The preset second format template is traversed through each of the escaped first format code blocks for matching, and the module name, title and filling code of the component code are extracted from the matched escaped first format code blocks and filled into the second format template to generate readable code.

[0011] Furthermore, the module name, title and filler code of the component code are extracted according to the first keyword, the second keyword and the third keyword in the complete component code, specifically:

[0012] Determine the proportion of various coding languages ​​in the code library where the component code is stored, and record the coding language with the highest proportion as the code library language;

[0013] According to the rules of the code library language, identifying a first keyword in the component code, and setting the text corresponding to the first keyword as the module name of the code block;

[0014] identifying a second keyword between the two adjacent first keywords according to a rule of the code library language, and setting text corresponding to the second keyword as a title of the code block;

[0015] According to the rules of the code library language, a third keyword is identified between the adjacent second keywords, and the text between the two adjacent third keywords is set as the filling code of the code block.

[0016] Furthermore, the first format is Json format.

[0017] Furthermore, the second format is an integrated development environment format.

[0018] In a second aspect, the present invention further provides a low-code fragment conversion device, comprising:

[0019] Information acquisition module, used to obtain complete component code and preset README file template;

[0020] a content extraction module, configured to extract a module name, a title, and filler code of a code block according to the first keyword, the second keyword, and the third keyword in the complete component code, and generate a low-code snippet by combining the readme file template with the module name, the title, and the filler code of the component code;

[0021] A format conversion module, configured to convert the low-code segment into a first format code block if an update of the low-code segment is monitored;

[0022] a parsing and conversion module, configured to replace the first keyword, the second keyword, and the third keyword with a preset first escape character, a second escape character, and a third escape character, respectively, to obtain a first format code block after the escape;

[0023] A readable code generation module is used to traverse the preset second format template to match each of the escaped first format code blocks, extract the module name, title and filling code of the component code from the matched escaped first format code block, and fill them into the second format template to generate readable code.

[0024] Furthermore, the content extraction module is used to extract the module name, title and filler code of the component code based on the first keyword, the second keyword and the third keyword in the complete component code, including:

[0025] a coding language determining unit, configured to determine the proportion of various coding languages ​​in a code library storing the component code, and record the coding language with the highest proportion as the code library language;

[0026] a module name determining unit, configured to identify a first keyword in the component code according to a rule of the code library language, and set a text corresponding to the first keyword as a module name of the code block;

[0027] a title determination unit, configured to identify a second keyword between the two adjacent first keywords according to a rule of the code library language, and set a text corresponding to the second keyword as a title of the code block;

[0028] The filling code determining unit is used to identify a third keyword between the adjacent second keywords according to the rules of the code library language, and set the text between the two adjacent third keywords as the filling code of the code block.

[0029] Furthermore, the first format is Json format.

[0030] Furthermore, the second format is an integrated development environment format.

[0031] In a third aspect, the present invention further provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of any one of the low-code conversion methods in the first aspect.

[0032] In a fourth aspect, the present invention further provides a computer device comprising a memory and a processor, wherein the memory stores a computer program, and when the processor executes the computer program, it executes any one of the low-code conversion methods in the first aspect.

[0033] The beneficial effects of adopting the above technical solution are: by converting the low-code snippet format, fillable formatted code blocks are automatically generated according to semantics, reducing the cost of manual writing; and converting low-code snippets into readable mode, improving the efficiency of daily development work, reducing the workload of importing code into the system, and improving office efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

[0034] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the following briefly introduces the drawings required for describing the embodiments or the prior art.

[0035] FIG1 is a schematic diagram of a low-code snippet conversion method according to an embodiment of the present application;

[0036] FIG2 is a schematic diagram of a low-code snippet conversion method according to an embodiment of the present application;

[0037] FIG3 is a schematic diagram of Json format code generation in one embodiment of the present application;

[0038] FIG4 is a schematic diagram of IDE format code generation in one embodiment of the present application;

[0039] FIG5 is a schematic diagram of searching for code blocks in an IDE system according to an embodiment of the present application;

[0040] FIG6 is a schematic diagram of a partial script of a conversion method in a low-code snippet in one embodiment of the present application;

[0041] FIG7 is a schematic diagram of a conversion device in a low-code segment in an embodiment of the present application. DETAILED DESCRIPTION

[0042] The following will combine the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of the present invention. In order to explain the present invention in more detail, the low-code conversion method, device, readable storage medium and equipment provided by the present invention are specifically described below in combination with the drawings.

[0043] Git is an open-source distributed version control system developed based on the Linux kernel. It uses a distributed repository approach, making source code publishing and communication extremely convenient and enabling efficient and high-speed version management for various projects. Git consists of a workspace, a staging area, a repository area, and a remote repository. The workspace is where developers typically store project component code; the staging area is used to temporarily store changes to project component code and maintain lists of files to be submitted; the repository area, also known as a version library, is a secure location for storing data, containing all submitted versions; and the remote repository is typically a server hosting the code and used for remote data exchange.

[0044] An integrated development environment (IDE), also known as an IDE, integrates multiple development tools and features. It automatically manages code repositories, helping developers avoid common programming errors. It also performs static code analysis and refactoring to improve code quality. IDEs also support collaborative development, allowing teams of developers to collaborate on projects and complete project components.

[0045] In the current software development process, R&D personnel need to copy and paste some commonly used code snippets. In addition, when the degree of modularization and componentization is high, developers need to read the external application program interface documents when using each component, which reduces the development efficiency of R&D personnel.

[0046] To address this issue, the present invention provides a low-code conversion method that converts the complete component code uploaded by R&D personnel into easily transmittable low-code snippets, then converts it into a unified first-format code, making the code readable on most platforms, and finally converts it into a second-format code, making the component code directly applicable in an integrated development environment system. This method will be described using the application of a terminal device as an example, with reference to the schematic diagram of the low-code conversion method shown in FIG1 and the schematic flow diagram of the low-code conversion method shown in FIG2.

[0047] The present application provides an application scenario for the low-code conversion method, which includes a terminal device provided in the embodiment. The terminal device includes, but is not limited to, a smartphone and a computer device, wherein the computer device can be at least one of a desktop computer, a portable computer, a laptop computer, a mainframe computer, a tablet computer, and the like. A user operates the terminal device to obtain a readable code. For details, please refer to the embodiment of the low-code conversion method.

[0048] Step S101: Obtain complete component code and a preset README file template.

[0049] A component, also known as an object, is a simple encapsulation of data and methods. The functionality of the component can be realized through the complete component code. The complete component code is typically written by the developer. The complete component code is stored in a Git repository. Due to the different development platforms and writing formats used by developers, the complete component code stored in the Git repository may be coded in a variety of languages ​​and formats.

[0050] The readme file is used as an auxiliary file provided to users to assist users in reading and using the component code in the Git repository. The readme file template refers to the description corresponding to each component in the readme file of the Git repository storing the component code.

[0051] Step S102: extract the module name, title and fill-in code of the component code according to the first keyword, the second keyword and the third keyword in the complete component code, and combine the preset self-reading file template with the module name, title and fill-in code of the component code to generate a low-code snippet.

[0052] Low-code snippets are different from traditional component complete code. They use visualization and less code to express components faster. Using a preset readme file template, the complete component code content is filtered, and unnecessary content is discarded, leaving only the valid code block module name, title, and filler code.

[0053] Step S103: If the low-code snippet is monitored to be updated, convert the low-code snippet into a first format code block.

[0054] The first format is JSON, a lightweight data exchange format that is easy to read and write, can exchange data between multiple coding languages, is easy to parse and generate by machines, and has higher communication and readability. The specific conversion code can be seen in Figure 3.

[0055] Step S104: replacing the first keyword, the second keyword, and the third keyword with a preset first escape character, a second escape character, and a third escape character, respectively, to obtain a first format code block after escape.

[0056] Since the first format code block may contain keywords that are likely to cause objections, in order to avoid recognition errors during the conversion of the first format code block, the first keyword, the second keyword, and the third keyword in the first format code block are replaced with a first escape character, a second escape character, and a third escape character, respectively.

[0057] Step S105: traverse the preset second format template to match each of the escaped first format code blocks, extract the module name, title and filling code of the component code from the matched escaped first format code block and fill them into the second format template to generate readable code.

[0058] Among them, the second format is the integrated development environment format, and is also a code format that can be recognized in the system environment where the component needs to run. The Git repository stores multiple escaped first format code blocks, and the preset second format template is matched with each escaped first format code block stored in the Git repository to find the escaped first format code block with the corresponding information. The corresponding content is filled into the second format template to generate a readable code, and the readable code can be directly called in the integrated development environment. The complete filled code in the readable code can be called by searching for the corresponding keyword. Among them, the specific conversion code can be seen in Figure 4.

[0059] Furthermore, in step S102, the code block module name, code block title and code block filling code are extracted according to the first keyword, the second keyword and the third keyword in the complete component code, specifically:

[0060] Step S201: determining the proportion of various coding languages ​​in the code library where the component code is stored, and recording the coding language with the highest proportion as the code library language.

[0061] Based on the language ratio of the Git repository where the complete component code is located, the language with the highest ratio is used as the code base language of the Git repository, and a specific language label is added.

[0062] Step S202: According to the rules of the code library language, identify the first keyword in the component code, and set the text corresponding to the first keyword as the module name of the code block.

[0063] Among them, the first keyword can be "###", the first keyword is identified, and the text corresponding to the first keyword is set as the code block module name.

[0064] Step S203: According to the rules of the code library language, a second keyword is identified between the two adjacent first keywords, and a text corresponding to the second keyword is set as a code block title.

[0065] For example, the second keyword is "number+'."", which is a list number. By determining the second keyword, the text in the same row as the second keyword is matched as the code block title.

[0066] Step S204: according to the rules of the code library language, identify a third keyword between the adjacent second keywords, and set the text between the two adjacent third keywords as a code block filling code.

[0067] Among them, the third keyword is "`" or "(````)", and the text between the two third keywords is the filling code.

[0068] By identifying the above keywords, the corresponding code block module name, title and filling code in the complete component code can be obtained.

[0069] The above-mentioned low-code conversion method first extracts the module name, title and fill-in code of the necessary code block from the complete component code to form a low-code snippet; then converts the low-code snippet into a more general Json format code block, which is more convenient for the code block to perform data conversion in different coding languages; finally, according to the integrated development environment, the Json format code block is converted into an integrated development environment code block, that is, an IDE code block, so that developers can directly search for the module name in the integrated development environment to obtain the complete fill-in code part of the code block; it improves the development efficiency of R&D personnel, and is also conducive to the large-scale copying and dissemination of code.

[0070] In order to more specifically illustrate the above-mentioned low-code conversion method, an example is given below in combination with the code in FIG5 and the effect diagram in FIG6:

[0071] The low-code conversion method runs in a bastion host where the Gitlab Runner environment is deployed. This bastion host includes but is not limited to computers with Windows, Linux, and MacOS systems.

[0072] Step S301: The deployment process of the operating environment is as follows:

[0073] Build a Docker runtime environment and start the Docker container;

[0074] Run the following command in the bastion host terminal: docker run-itd-restart=always-privileged=true-name espod -p port1-p port2-p port3-p port4-v;

[0075] The bastion host mapping project directory is: project directory espod:1.0.0.

[0076] Step S302: Build the Gitlab Runner module on the bastion host, monitor commit changes in the Git repository project, and use the Gitlab Runner script to generate low-code snippets. The specific process is as follows:

[0077] Install the GitLab Runner module on the bastion host, including the following five installation methods:

[0078] (1) curl -L -output custom path / gitlab-runner https: / / gitlab-runner-downloads,s3.amazonaws,com / latest / binaries / gitlab-runner-linux-amd64;

[0079] (2) chmod+x custom path / gitlab-runner;

[0080] (3)useradd-comment'Coder'-create-home;

[0081] (4)gitlab-runner-shell / bin / bash;

[0082] (5)gitlab-runner

[0083] install-user=gitlab-runner-working-directory= / home / gitlab-runner;

[0084] Start Gitlab-runner start;

[0085] Register to the bastion host using the registration URL and registration token information in the GitLab CI settings;

[0086] Configure Gitlab Runner on the bastion host and register the real-time update listener for the Git repository. To do this, run the following command on the bastion host terminal: gitlab-runner register-url register URL-registration-token register token;

[0087] After the monitoring is triggered, the low-code snippets of the custom template readme file are converted into Json format code blocks, and the Json format code blocks are uploaded to the Git repository.

[0088] Step S303: Write a script. After the developer pulls the formatted code repository, generate an IDE code block. See the code content in Figure 3:

[0089] Parse the Json format code block and replace the escape characters in the code block;

[0090] Generate the IDE code block template template.codesnippet, traverse all Json formatted code blocks, and fill the corresponding fields of the IDE code block template with the escaped code blocks;

[0091] Obtain administrator privileges and copy the generated IDE code blocks to the Xcode Code Snippets directory.

[0092] By setting the above steps, you can find the corresponding IDE code block through the search function in the integrated development environment system and directly get its corresponding fill code. In order to further improve the visualization and search features of the low-code snippet calling process, you can further set:

[0093] To create a Source Editor extension, create a new macOS project in Xcode and add a new Xcode Source Editor Extension target to the project.

[0094] Find the info file in the added extension directory and add an item under XC-Source-Editor-Command-Definitions;

[0095] In the Source-Editor-Command file, read the IDE code block and display it in the GUI;

[0096] After developing and running the editor extension, search for the corresponding keyword and double-click the code block in the extension to automatically fill it at the cursor.

[0097] The above-mentioned low-code conversion method can improve the code writing efficiency of R&D personnel in the daily development process and reduce the workload of searching for module codes and importing module codes.

[0098] It should be understood that although the steps in the flowcharts of Figures 1-2 are shown sequentially as indicated by arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified herein, there is no strict order restriction on the execution of these steps, and these steps can be executed in other orders. Moreover, at least some of the steps in Figures 1-2 may include multiple sub-steps or sub-stages, and these sub-steps or stages are not necessarily executed and completed at the same time, but can be executed at different times. The order of execution of these sub-steps or stages is not necessarily sequential, but can be executed in rotation or alternation with other steps or at least a portion of the sub-steps or stages of other steps.

[0099] The low-code fragment conversion method is described in detail in the embodiment disclosed in the above-mentioned invention. The above-mentioned method disclosed in the present invention can be implemented by various forms of equipment. Therefore, the present invention also discloses a low-code fragment conversion device corresponding to the above-mentioned method. In conjunction with Figure 7, a specific embodiment is given below for detailed description.

[0100] The information acquisition module 401 is used to acquire the complete component code and the preset README file template.

[0101] The content extraction module 402 is used to extract the module name, title and fill-in code of the code block based on the first keyword, second keyword and third keyword in the complete component code, and combine the self-reading file template with the module name, title and fill-in code of the component code to generate a low-code snippet.

[0102] The format conversion module 403 is configured to convert the low-code segment into a first-format code block if an update of the low-code segment is detected.

[0103] The parsing and conversion module 404 is configured to replace the first keyword, the second keyword, and the third keyword with a preset first escape character, a second escape character, and a third escape character, respectively, to obtain an escaped first format code block.

[0104] The readable code generation module 405 is used to traverse the preset second format template to match each of the escaped first format code blocks, extract the module name, title and filling code of the component code from the matched escaped first format code block, and fill them into the second format template to generate readable code.

[0105] Furthermore, the content extraction module 402 is configured to extract the module name, title, and filler code of the component code based on the first keyword, the second keyword, and the third keyword in the complete component code, including:

[0106] The coding language determining unit 501 is configured to determine the proportion of various coding languages ​​in the code base storing the component code, and record the coding language with the highest proportion as the code base language.

[0107] The module name determining unit 502 is configured to identify a first keyword in the component code according to the rules of the code base language, and set the text corresponding to the first keyword as the module name of the code block.

[0108] The title determining unit 503 is configured to identify a second keyword between the two adjacent first keywords according to the rules of the code base language, and set the text corresponding to the second keyword as the title of the code block.

[0109] The filling code determining unit 504 is configured to identify a third keyword between the adjacent second keywords according to the rules of the code library language, and set the text between the two adjacent third keywords as the filling code of the code block.

[0110] For the low-code conversion device, please refer to the above definition of the method and will not be repeated here. Each module in the above device can be implemented in whole or in part by software, hardware and their combination. The above modules can be embedded in or independent of the processor of the terminal device in the form of hardware, or stored in the memory of the terminal device in the form of software, so that the processor can call and execute the operations corresponding to the above modules.

[0111] In one embodiment, the present invention also provides a computer-readable storage medium having a computer program stored thereon, which implements the steps of the above-mentioned low-code conversion method when executed by a processor.

[0112] The computer-readable storage medium can be an electronic memory such as a flash memory, an EEPROM (Electrically Erasable Programmable Read-Only Memory), an EPROM (Erasable Programmable Read-Only Memory), a hard disk, or a ROM. Optionally, the computer-readable storage medium includes a non-transitory computer-readable storage medium. The computer-readable storage medium has storage space for program codes for executing any of the method steps of the above method. These program codes can be read from or written into one or more computer program products, and the program codes can be compressed in an appropriate form.

[0113] In one embodiment, the present invention provides a computer device comprising a memory and a processor, wherein the memory stores a computer program, and the processor performs the above-mentioned low-code conversion method when executing the computer program.

[0114] The computer device includes a memory, a processor, and one or more computer programs, wherein the one or more computer programs can be stored in the memory and configured to be executed by one or more processors, and the one or more applications are configured to execute the above-mentioned low-code conversion method.

[0115] The processor may include one or more processing cores. The processor uses various interfaces and lines to connect the various parts of the entire computer device, and performs various functions of the computer device and processes data by running or executing instructions, programs, code sets or instruction sets stored in the memory, and calling data stored in the memory. Optionally, the processor can be implemented in at least one hardware form of digital signal processing (DSP), field programmable gate array (FPGA), and programmable logic array (PLA). The processor can integrate one or more combinations of a central processing unit (CPU), a graphics processing unit (GPU) and a modem. Among them, the CPU mainly processes the operating system, user interface and application programs; the GPU is responsible for rendering and drawing display content; and the modem is used to handle wireless communication. It is understandable that the above-mentioned modem may not be integrated into the processor and may be implemented separately through a communication chip.

[0116] The memory may include random access memory (RAM) or read-only memory (ROM). The memory may be used to store instructions, programs, codes, code sets, or instruction sets. The memory may include a program storage area and a data storage area, wherein the program storage area may store instructions for implementing an operating system, instructions for implementing at least one function (such as a touch function, a sound playback function, an image playback function, etc.), instructions for implementing the above-mentioned various method embodiments, etc. The data storage area may also store data created by the terminal device during use, etc.

[0117] The above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit the same. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the various embodiments of the present invention.

Claims

1. A low code snippet conversion method, characterized in that: include: Get the complete component code and preset README template; Extracting a module name, a title, and a filler code of the component code according to the first keyword, the second keyword, and the third keyword in the complete component code, and combining the preset readme file template with the module name, the title, and the filler code of the component code to generate a low-code snippet; If the low code snippet is updated, convert the low code snippet into a first format code block; Replacing the first keyword, the second keyword, and the third keyword with a preset first escape character, a second escape character, and a third escape character, respectively, to obtain a first format code block after the escape; The preset second format template is traversed through each of the escaped first format code blocks for matching, and the module name, title and fill code of the component code are extracted from the matched escaped first format code block and filled into the second format template to generate readable code.

2. The low-code conversion method according to claim 1, characterized in that: The module name, title and filler code of the component code are extracted according to the first keyword, the second keyword and the third keyword in the complete component code, specifically: Determine the proportion of various coding languages ​​in the code base where the component code is stored, and record the coding language with the highest proportion as the code base language; According to the rule of the code library language, a first keyword in the component code is identified, and a text corresponding to the first keyword is set as a module name of a code block; According to the rule of the code library language, a second keyword is identified between the two adjacent first keywords, and a text corresponding to the second keyword is set as a title of the code block; According to the rule of the code library language, a third keyword is identified between the adjacent second keywords, and the text between the two adjacent third keywords is set as the filling code of the code block.

3. The low-code conversion method according to claim 1, characterized in that: The first format is the Json format.

4. The low-code conversion method according to claim 1, characterized in that: The second format is an integrated development environment format.

5. A low code snippet conversion device, characterized in that: include: Information acquisition module, used to obtain complete component code and preset README template; a content extraction module, for extracting a module name, a title and a filler code of a code block according to the first keyword, the second keyword and the third keyword in the complete component code, and combining the readme file template with the module name, the title and the filler code of the component code to generate a low-code snippet; A format conversion module, configured to convert the low-code snippet into a first format code block if an update of the low-code snippet is monitored; A parsing and conversion module, used for replacing the first keyword, the second keyword and the third keyword with a preset first escape character, a second escape character and a third escape character respectively, to obtain a first format code block after the escape; A readable code generation module is used to traverse the preset second format template through each of the escaped first format code blocks for matching, extract the module name, title and filling code of the component code from the matched escaped first format code block and fill them into the second format template to generate readable code.

6. The low-code conversion module according to claim 5, characterized in that: The content extraction module is used to extract the module name, title and filler code of the component code according to the first keyword, the second keyword and the third keyword in the complete component code, including: A coding language determination unit, used to determine the proportion of various coding languages ​​in the code library where the component code is stored, and record the coding language with the highest proportion as the code library language; A module name determination unit, configured to identify a first keyword in the component code according to a rule of the code library language, and set a text corresponding to the first keyword as a module name of a code block; a title determination unit, configured to identify a second keyword between the two adjacent first keywords according to a rule of the code library language, and set a text corresponding to the second keyword as a title of the code block; The filling code determining unit is used to identify a third keyword between the adjacent second keywords according to the rule of the code library language, and set the text between the two adjacent third keywords as the filling code of the code block.

7. The low-code conversion device according to claim 5, characterized in that: The first format is the Json format.

8. The low-code conversion device according to claim 5, characterized in that: The second format is an integrated development environment format.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the steps of the low-code conversion method of any one of claims 1-4 are implemented.

10. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that: When the processor executes the computer program, it performs any low-code conversion method in claims 1-4.

Images