Zero-code platform operator creation method, electronic equipment and medium

Abstract

The invention discloses an operator creation method of a zero-code platform, electronic equipment and a medium, and belongs to the technical field of software development. The operator creation method comprises the following steps: in response to a creation instruction of a user, displaying an operator creation window in an interface of a zero code platform; in response to a to-be-created operator selected by a user through the operator creation window, calling a constructor function from a preset operator constructor to generate a corresponding operator object; calling a process designer, and adding the operator object to a tree node of a tree structure of a current process; and generating a module view according to the configuration information of the operator object, and rendering and displaying the module view on a canvas. According to the operator creation method of the zero-code platform, the electronic equipment and the medium provided by the invention, through combination of the operator creation window and a constructor mechanism, rapid generation and unified management of operator objects are realized, and the problems of tedious manual configuration and non-unified logic in a traditional creation mode are avoided.

Description

Technical Field

[0001] The present invention belongs to the technical field of software development, and in particular relates to an operator creation method, electronic device and medium for a zero-code platform. Background Art

[0002] With the continuous improvement of industrial automation, industrial automation standard software plays an increasingly important role in the fields of process management and automation control. These software can realize complex industrial process design, production line control, data processing and other tasks by integrating multiple functional modules and tools, providing strong support for the digital transformation and intelligent upgrading of enterprises.

[0003] In recent years, with the rise of zero-code platforms, the threshold for developing and using industrial automation software has been significantly lowered. Zero-code platforms enable non-professional programmers to participate in process design and tool creation through visual configuration and component-based development. This approach uses a graphical interface and predefined component library to transform complex code writing into intuitive drag-and-drop operations and parameter configuration, thereby improving development efficiency and expanding the user base.

[0004] Operators, as important units for building industrial task processes (programs), cover multiple dimensions such as data acquisition, signal processing, equipment control, task logic operations, and interface interaction, which directly affect whether the industrial task process can run stably according to the preset task logic. The existing operator creation methods generally lack unified creation logic and interaction processes, resulting in users having to use differentiated operation steps in different designers (such as resource managers, main task designers, and HMI designers), inconsistent user experience, and high learning costs.

[0005] Therefore, it is necessary to provide a new solution to the above technical problems. Summary of the invention

[0006] The object of the present invention is to provide an operator creation method, electronic device and medium for a zero-code platform, which can realize rapid creation of operators through a keyboard and improve software development efficiency.

[0007] To achieve the above purpose, the technical solution provided by the present invention is as follows: In a first aspect, the present invention provides an operator creation method for a zero-code platform, which includes: In response to the user's creation instruction, the operator creation window is displayed in the interface of the zero-code platform; in response to the user selecting the operator to be created through the operator creation window, the constructor is called from the preset operator constructor to generate the corresponding operator object; the process designer is called to add the operator object to the tree node of the tree structure of the current process; the module view is generated according to the configuration information of the operator object, and is rendered and displayed on the canvas.

[0008] In one or more embodiments, in response to the user selecting the operator to be created through the operator creation window, it includes: when the user creates an operator through the resource manager or the main task designer of the zero-code platform, in the toolbox of the resource manager or the main task designer, the operator to be created is selected by double-clicking the operator name, and the toolbox loads the supported operator list when the zero-code platform is started, and passes the selected operator name by binding the double-click event; in response to the user selecting the operator to be created by double-clicking the operator name, it is detected whether the process designer interface of the zero-code platform is in an activated state, and if not, the process designer interface is activated so that the operator is created in the activated state of the process designer interface.

[0009] In one or more embodiments, a constructor is called from a preset operator constructor to generate a corresponding operator object, including: obtaining the construction logic corresponding to the operator name selected by the user from the operator constructor set through a delegation mechanism, the delegation mechanism is registered when the process designer creates a new process, and binds the mapping relationship between the operator name and the construction logic; calling the constructor according to the construction logic to generate an operator object including operator properties, operation logic and interface configuration; assigning a globally unique identifier to the operator object, and binding the event processing logic of logging and user interaction.

[0010] In one or more embodiments, in response to a user selecting an operator to be created through the operator creation window, a constructor is called from a preset operator constructor to generate a corresponding operator object, including: when a user creates an operator through an HMI designer of a zero-code platform, the construction logic corresponding to the operator name selected by the user is obtained from a preset operator list by loading the operator assembly; an operator object is generated by calling a constructor corresponding to the construction logic through the operator constructor, and the operator object includes operator attribute information, a configuration interface, and an output interface; a globally unique identifier is assigned to the operator object, and log records and pop-up interaction events are bound; a control view bound to the operator object is generated through the HMI designer, and the control view is laid out on the canvas according to the current mouse position and displayed on the top layer.

[0011] In one or more embodiments, the operator object is added to the tree node of the tree structure of the current process, including: obtaining the tree structure of the current process, the tree structure recording the process logic in the form of hierarchical nodes; passing the operator object and tree structure parameters through the operator constructor interface, encapsulating the operator object as a tree node and appending it to the end node of the tree structure; and configuring the dependency relationship between the operator object and other operators according to the preset reference list parameters.

[0012] In one or more embodiments, an operator module view is generated according to the configuration information of the operator object and rendered and displayed on a canvas, including: extracting attribute data from the configuration information of the operator object, the attribute data including the operator name, icon and interface configuration; generating a module view according to the attribute data, the module view including a title area and input and output interfaces, the title area displays the operator name, and the input and output interfaces respectively generate a logical interface and a data interface according to the configuration information; binding the module view to the operator object, and rendering and displaying the module view of the operator object on the canvas according to the operator layout status on the current canvas.

[0013] In one or more embodiments, according to the operator layout status on the current canvas, the module view of the operator object is rendered and displayed on the canvas, including: if there is no operator on the current canvas, the module view of the operator object is displayed at a preset initial position of the canvas; if an operator already exists on the current canvas, the module view of the operator object is displayed at a preset offset position of the last operator created on the current canvas, and the operator object is automatically logically connected to the last created operator.

[0014] In one or more embodiments, the operator creation method also includes: extracting domain operators related to the current task process from a preset professional knowledge map based on the user's usage habits and industry, and generating an operator transfer probability matrix based on the usage frequency and dependency relationship of the domain operators; after the user creates an operator, the operator with the highest transfer probability automatically pops up in the operator creation window for the user to select and create.

[0015] In a second aspect, the present invention provides an electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the program, the operator creation method of the zero-code platform as described above is implemented.

[0016] In a third aspect, the present invention provides a computer-readable medium, which carries computer-executable instructions. When the computer-executable instructions are executed by a processor, they are used to implement the operator creation method of the zero-code platform as described above.

[0017] Compared with the prior art, the operator creation method, electronic device and medium of the zero-code platform provided by the present invention realize the rapid generation and unified management of operator objects by combining the operator creation window with the constructor mechanism, avoiding the problems of cumbersome manual configuration and inconsistent logic in the traditional creation method; in addition, the platform automatically generates module views according to the operator configuration information, and combines the canvas layout status for intelligent rendering and display, which not only optimizes the neatness of the interface, but also improves the visual expression ability of the process logic. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the prior art descriptions are briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in the present invention, and for ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.

[0019] Figure 1 This is a flowchart of a method for creating an operator of a zero-code platform in one embodiment of the present invention; Figure 2 A schematic diagram of calling an operator creation window in one embodiment of the present invention; Figure 3 A schematic diagram of displaying an operator list in an operator creation window according to operator name keywords in one embodiment of the present invention; Figure 4 This is a schematic diagram of selecting an operator in an operator list in one embodiment of the present invention; Figure 5 This is a schematic diagram of creating an operator through the operator creation window in one embodiment of the present invention; Figure 6 FIG. 4 is a schematic diagram of an electronic device according to an embodiment of the present invention. DETAILED DESCRIPTION

[0020] In order to enable those skilled in the art to better understand the technical solutions in the present invention, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings 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 creative work should fall within the scope of protection of the present invention.

[0021] In the context of industrial automation software increasingly emphasizing flexibility, visualization, and low-threshold operation, zero-code platforms have gradually become an important infrastructure for enterprise digital transformation. As the core component for building industrial task processes in the zero-code platform, operators undertake multiple key functions such as data processing, equipment control, and logic orchestration. The efficiency and consistency of their creation process directly affect the development experience and application promotion of the entire platform. However, in the existing technology, the operator creation method is scattered, the process is fragmented, and there is a lack of unified construction logic and visualization processing path. Especially in a multi-designer environment (such as resource manager, main task designer, HMI designer), users often need to face problems such as inconsistent operation logic, inconsistent interaction forms, and opaque construction process, resulting in low operator configuration efficiency, high learning cost, and poor process development experience.

[0022] Based on an in-depth analysis of the above problems, the present invention proposes an operator creation method for a zero-code platform. The overall idea is to establish a complete mechanism covering user command reception, operator construction generation, process structure organization and graphical interface display around the core path of unified entry, standard construction, structure mounting and visual rendering. This idea aims to incorporate operator creation behaviors in different designers into a unified management process by building a standardized creation channel, so as to avoid users facing a fragmented creation experience in a multi-interface environment. At the same time, by abstracting and encapsulating the construction logic of the operator, the platform can automatically generate operator objects with complete functional attributes based on user selection, thereby getting rid of the tediousness and uncertainty brought by manual configuration.

[0023] In terms of structural organization, this idea emphasizes incorporating the created operator objects into a hierarchical process structure system to ensure that the logical dependencies between operators can be clearly expressed and maintained. At the visualization level, the dynamic generation and intelligent arrangement of modular display units are achieved through the structured extraction of operator configuration information, thereby providing users with a clear, orderly, and interactive flowchart display effect. The present invention aims to build an efficient and low-threshold operator creation system through a unified mechanism, logical abstraction, and process-driven approach, so that the zero-code platform has stronger process modeling capabilities.

[0024] Please refer to Figure 1 FIG. 1 is a flowchart of a method for creating an operator of a zero-code platform in an embodiment of the present invention. The method for creating an operator of a zero-code platform specifically includes the following steps: S101: In response to a user's creation instruction, an operator creation window is displayed in the interface of the zero-code platform.

[0025] In step S101, the operator creation process can be quickly triggered by creating instructions, and an intuitive interactive interface is provided for the user to subsequently input keywords and search for the required operator. The purpose is to transform the traditional mouse-driven operation into a keyboard-driven mode, thereby improving the convenience and efficiency of the operation, and providing a centralized entry for operator creation.

[0026] Specifically, if Figure 2 As shown in the figure, when the user triggers the creation command (such as Ctrl+E), the system will immediately display an operator creation window on the canvas. The window contains an input control for entering operator name keywords. The user can directly enter keywords to search for operators. This process avoids the tedious steps of manually searching for operator tools in the traditional mode, making operator creation more efficient.

[0027] The creation command can be set to a common key combination, such as "Ctrl+E" or "Alt+C". When the user presses the key, the system detects the keyboard input event and immediately pops up an operator creation window at a preset position of the canvas (such as the center or upper left corner). The window can be designed as a lightweight floating window that contains a text input box as an input control, in which the user can type the operator name keyword. In addition, to enhance the user experience, the window can also support dynamic resizing or position adjustment, such as automatically avoiding existing operators according to the current content of the canvas to avoid blocking key areas. Another possible implementation method is to combine shortcut keys with voice input. After the user presses the shortcut key, not only will the window pop up, but keywords can also be directly entered through voice commands, further reducing manual operations.

[0028] When the user enters a keyword for the operator name in the input control of the operator creation window, the system automatically searches from the predefined operator library and dynamically displays the operators that meet the conditions in the form of a list in the operator creation window. This mechanism improves the convenience of operator creation, allowing users to quickly locate the target operator through intelligent search without manual search or dragging.

[0029] In terms of specific implementation methods, this step can adopt search optimization strategies such as fuzzy matching, intelligent association, and keyword priority sorting to improve search accuracy and user experience. Fuzzy matching means that after the user enters part of the keyword, the system can automatically associate it with related operators. Even if the user does not enter the complete name, they can get reasonable recommendations in the search results. For example, when the user enters "number", the system may return related operators such as "data processing", "data analysis", and "data filtering" to avoid search failures due to incomplete input.

[0030] The intelligent association function makes intelligent recommendations based on the keywords entered by the user, combined with the operator usage frequency, historical search records, and semantic relevance, so that the most commonly used or most relevant operators are displayed first. For example, if the user often uses the "data cleaning" operator, when the user enters "data", the operator can be listed first to improve search efficiency. In addition, the keyword priority sorting mechanism can ensure that search results are arranged according to relevance, frequency of use, and recommendation weight, so that the operators most likely to be selected by users are ranked first, reducing the user's operating costs.

[0031] The search function can be implemented based on a real-time input matching algorithm. For example, when a user types characters in an input control, the system uses fuzzy matching or prefix matching technology to dynamically query the operator library for operators containing the keyword and instantly update the operator list. This real-time performance ensures that users can see the results without pressing the confirmation key. For example, an operator library may contain hundreds of predefined operators, each with a name and description label. The search algorithm will quickly filter out operators with the word "read" in their names (such as "file reading tool", "IO signal reading", "analog reading", etc.) based on the input keyword (such as "read"). Figure 3 shown.

[0032] Search results can be updated in a dynamic list. When the characters entered by the user change, the operator list will be refreshed immediately so that users can preview the search results in real time without having to submit queries manually. This interactive method can reduce the user's waiting time and improve the response speed. The display form of the operator list can be designed as a drop-down menu or a scrolling list. The list items not only display the operator name, but also a short description or icon to facilitate users to quickly identify. In addition, to improve search efficiency, a cache mechanism can be introduced to prioritize operators that users have recently used frequently, or support multi-keyword combination searches (such as "production scheduling") to further narrow the screening range. Another possible implementation method is to combine intelligent recommendation technology, such as predicting operators that users may need based on user historical operation records and displaying them at the top, thereby reducing the input burden.

[0033] S102: In response to the user selecting an operator to be created through the operator creation window, a constructor is called from a preset operator constructor to generate a corresponding operator object.

[0034] Step S102 is a step for realizing automatic operator construction in the present invention. The core of the step is to convert the operator name selected by the user in the creation window into an operator object that is identifiable and executable within the platform. This process is essentially a dynamic construction process of the operator logic definition to the structural entity, and is a link to realize the standardized and scalable management of operators in the zero-code platform. The specific implementation path is: when the user selects an operator in the operator creation window (for example, highlight an operator name in the list and press the Enter key to confirm, such as Figure 4 As shown in the figure, the system will retrieve the corresponding construction logic from the preset constructor set based on the operator name, and call the constructor encapsulated in the construction logic to generate a complete operator object instance.

[0035] In this process, the platform usually maintains a registration system for operator constructors, and each available operator is bound to a constructor entity. The constructor is a component designed in a unified manner in the form of an interface or abstract class, which contains logical content such as initializing operator properties, configuring input and output ports, binding interaction events, and assigning unique identifiers. When the constructor is called, it not only generates the functional body of the operator, but also attaches necessary context information, such as the process to which it belongs, dependent references, default parameter values, etc., to ensure that the operator object can directly participate in the construction and operation of the process.

[0036] When the user selects the operator to be created in the operator creation window, the system can manage the construction logic of various operators through a preset operator constructor set. After the user selects the operator, the system extracts the corresponding construction template from the set according to the operator name or identifier. This template can be loaded in advance when the platform is initialized, and the operator type is associated with the construction logic through a mapping mechanism. The call of the construction logic can be implemented through delegation. The system dynamically calls the constructor according to the user input to generate an object containing operator properties (such as name, category), operation logic (such as data processing rules) and interface configuration (such as input and output definitions). In order to support diverse scenarios, the constructor can also load external operator templates through assemblies, and users can import custom operators to enhance the adaptability of the platform.

[0037] For example, if the user selects the "Analog Acquisition" operator in the creation window, the system will identify the constructor entry corresponding to the operator and automatically call the constructor provided by the constructor. During the execution of the function, an operator object with properties such as "input channel configuration", "refresh frequency parameters", and "output data interface" will be generated, and a globally unique ID will be automatically assigned. At the same time, the object will be bound to the platform's log system and pop-up feedback mechanism to enable it to record information and interact with users during operation. After the operator object is generated, it will enter the next process tree mounting or canvas rendering stage as a structural unit.

[0038] In an exemplary embodiment, in response to a user selecting an operator to be created through the operator creation window, specifically including: when a user creates an operator through the resource manager or main task designer of the zero-code platform, in the toolbox of the resource manager or the main task designer, the operator to be created is selected by double-clicking the operator name, the toolbox loads a list of supported operators when the zero-code platform is started, and transmits the selected operator name by binding a double-click event; in response to the user selecting the operator to be created by double-clicking the operator name, detecting whether the process designer interface of the zero-code platform is in an activated state, if not, activating the process designer interface so that the operator is created in the activated state of the process designer interface.

[0039] In the operator creation method of the zero-code platform proposed in the present invention, the operation mode in which the user selects the operator to be created through the operator creation window is not limited to general search and list selection, but also includes a more intuitive and convenient interaction mode supported by various designers in the platform (such as resource manager and main task designer), that is, quickly completing the selection and creation of the operator through the double-click operation in the toolbox.

[0040] Specifically, when the zero-code platform is started, the system automatically loads a list of all supported operators and displays these operator items in the form of icons or lists in the toolbox area of ​​the resource manager or main task designer. This toolbox can be a functional area fixed to the edge of the interface or in a floating panel, where users can quickly browse the available operator types. When the system loads these operator items, it binds interactive events to each item, especially double-click events. During the browsing process, the user only needs to double-click an operator name (for example, "double-click 'Data Collector'"), and the system will immediately recognize that the user intends to "select and create an operator" and pass the identification information of the operator (such as operator name, category code, etc.) to the internal construction module for subsequent processing.

[0041] After the double-click operation is completed, the platform will not execute the construction logic immediately, but will first detect the state of the process designer interface. This is to ensure that the creation and mounting logic of the operator can be executed in the correct context. Because the process designer is the core area that carries the logical structure and display structure of the operator object, if it is not in an activated or displayed state, it may cause the operator to fail to mount or render abnormally. Therefore, the system will determine in the background whether the current process designer is open and in the foreground focus state. If the judgment result is not activated or not opened, the system will automatically execute the activation process, including calling up the corresponding process view, setting the current task context, refreshing the canvas state, etc., to ensure that subsequent operator construction and layout operations are performed in a correct and controllable environment.

[0042] For example, a user is browsing the operator items under the "IO Device" category in the resource manager. Without explicitly opening the main flowchart, the user directly double-clicks the "Modbus Write Instruction" operator. The system first records the selection status of the operator, then automatically opens the main flowchart editing page, activates the current workflow, and ensures that the canvas and process structure have been initialized. Subsequently, the system passes the selected operator into the construction process to complete its object construction and structure mounting, thereby completing the full process closed loop of selection, positioning, construction and interface feedback in one operation.

[0043] Specifically, calling a constructor from a preset operator constructor to generate a corresponding operator object includes: obtaining the construction logic corresponding to the operator name selected by the user from the operator constructor set through a delegation mechanism, the delegation mechanism is registered when the process designer creates a new process, and binds the mapping relationship between the operator name and the construction logic; calling the constructor according to the construction logic to generate an operator object including operator properties, operation logic and interface configuration; assigning a globally unique identifier to the operator object, and binding the event processing logic of logging and user interaction.

[0044] Specifically, when the platform is initialized or the user creates a new process, the system will preload all available operator constructors and complete the registration of the binding mapping relationship between the "operator name" and the "construction logic" in the background. This registration process is implemented through a delegation mechanism. The platform binds a unique name identifier to each constructor, and encapsulates its constructor pointer or logic entry as a delegate (i.e., a function reference), and stores it in a central registry or mapping collection. In this way, when the user selects an operator in the creation window, the system does not need to perform a reflective dynamic type search, but can directly obtain the delegation logic registered by the corresponding constructor through fast key value matching.

[0045] The operator constructor collection can be designed as a preset template library to store the construction logic of various operators, such as sensor classes, controller classes, etc. The implementation of the delegation mechanism can associate the operator name with its construction logic through a mapping table or registry when the process designer is initialized or a new process is created. When the user selects an operator, the system dynamically queries the mapping table through the delegation and extracts the corresponding construction template. This delegation can be event-driven, such as triggering the call of the construction logic by listening to the user's selection action, or it can be configuration-driven, defining the mapping relationship through a configuration file. To enhance scalability, the constructor collection can support dynamic loading. Users can import custom operator types through external assemblies, and the system will register them in the mapping table.

[0046] When the constructor is called, an operator object is generated according to the construction logic. The object contains attributes (such as name, category), operation logic (such as data processing rules), and interface configuration (such as input and output ports). After generation, the system assigns a globally unique identifier to the object, which can be ensured by a random generation algorithm or a timestamp combination. At the same time, the bound event processing logic can include logging functions (recording the running status) and user interaction functions (triggering prompt windows). These events are associated with the operator object through the event subscription mechanism to ensure its monitorability and interactivity in the process.

[0047] For example, if the user selects the "high-speed counter acquisition" operator, after receiving the name, the platform will search for the delegate corresponding to the name in the constructor mapping collection, execute the delegate function, and automatically generate an operator object with a complete structure. This object not only includes basic properties (such as operator name, category, icon, version number), but also includes the processing entry of the running logic (such as start, pause, reset and other operation methods) and the structural definition of the input and output interface (such as input channel number, sampling frequency, output data format, etc.). The system will also assign it a globally unique identifier (usually a GUID) during the construction process, and bind the logging interface and user interaction processing logic in the object, such as pop-up windows, prompt boxes, configuration parameter writing, error feedback and other event entries.

[0048] In an exemplary embodiment, in response to a user selecting an operator to be created through the operator creation window, a constructor is called from a preset operator constructor to generate a corresponding operator object, specifically including: when a user creates an operator through the HMI designer of the zero-code platform, the construction logic corresponding to the operator name selected by the user is obtained from a preset operator list by loading the operator assembly; the operator object is generated by calling the constructor corresponding to the construction logic through the operator constructor, and the operator object includes operator attribute information, a configuration interface, and an output interface; a globally unique identifier is assigned to the operator object, and log records and pop-up interaction events are bound; a control view bound to the operator object is generated through the HMI designer, and the control view is laid out on the canvas according to the current mouse position and displayed on the top layer.

[0049] Specifically, when the user selects an operator to be created (such as a "button control" or "image display control") through the operator creation window in the HMI designer, the system will first retrieve the construction logic that matches the name from the operator assembly loaded by the platform. This process can be completed by scanning the assembly type list, determining the interface implementation, comparing the operator identifier, and locating the result as the constructor interface bound to the control. Unlike process operators, HMI operators not only contain process logic, but also must include interface display and event handling functions. Therefore, their construction logic usually encapsulates additional configuration information, such as control size, position, style, data binding structure, etc.

[0050] After obtaining the construction logic, the platform will call the constructor provided by the operator constructor to generate the corresponding operator object. This object generally contains three core contents: one is the operator attribute information, which is used to describe its basic information such as function definition, name, icon, version, type, etc.; the second is the configuration interface (ConfigUI), which is used to display the editable properties of the operator in the parameter panel on the right, such as size, position, binding field, color, etc.; the third is the output interface (OutputUI), which is the actual control element visible in the canvas of the operator, used for interaction with the user. The construction process of this object will also automatically complete a series of initialization operations, including parameter default value setting, attribute field initialization, logical interface mounting, etc.

[0051] After generating an operator object, the platform will assign a globally unique identifier to the operator object, usually generated in GUID format, to ensure that even in large-scale projects or repeated creation of controls, each operator can still be uniquely identified and called globally. This identifier is not only used for operator object registration, but also for naming, resource tracking, and data mapping of control views. At the same time, the system will also bind multiple event processing logics to the operator object, including log records (such as control state change records), pop-up prompts (such as verification failures, configuration warnings), and interactive events (such as clicks, double-clicks, focus changes, etc.) to support users in operating feedback and data response in the running state.

[0052] After the operator object is constructed, the system will automatically generate a corresponding control view for the operator object, that is, a UI element visible in the HMI designer canvas. This view not only includes the drawing of visual elements (such as borders, titles, icons, etc.), but also includes a two-way binding mechanism with the properties of the operator object. When generating controls, the platform will obtain the current position of the mouse pointer in the canvas and automatically layout the newly created controls at that position to ensure that users can intuitively perceive that the controls have been successfully added, thereby improving the feedback and operation efficiency of the interaction. After the controls are laid out, they will also be displayed on the top layer to ensure that they are not obscured by other layers in complex layouts.

[0053] For example, if a user wants to add a "real-time image preview box" control in the HMI designer, the platform will load the matching constructor from the visual operator assembly after receiving the selection instruction, and generate an operator object containing image preview output components, property configuration panels, binding interfaces, etc. through the constructor, and automatically place the output interface control of the object in the canvas according to the mouse position. At the same time, the control name is named in the form of GUID, the configuration panel is automatically expanded, and the user can immediately adjust the size and set the data channel binding. The overall process does not require manual writing of any code and is completely visually completed.

[0054] S103: calling the process designer to add the operator object to the tree node of the tree structure of the current process.

[0055] Through the call of the process designer, the operator objects created in the previous steps are embedded in the current process in the form of tree nodes to ensure that their positions and relationships in the process logic are systematically managed. The purpose is to achieve the structured organization of operators in the process, so that they not only exist as an independent functional unit, but also can be connected with the logical framework of the entire process, providing an orderly basis for subsequent operation and view display.

[0056] In the specific implementation, the zero-code platform can organize the operators and task nodes in the process through a "tree structure". This structure is similar to the hierarchical call relationship in the program or the directory tree in the file system. Each operator corresponds to a tree node, and the superior-subordinate relationship between nodes reflects the execution logic, data dependency, nested processes or control branches, etc. As the core module for carrying and managing this structure, the process designer is responsible for maintaining all node structures, execution paths and interactions between nodes of the current process.

[0057] When the user completes the operator selection in the creation window and the corresponding operator object is generated by the constructor, the system will automatically identify the currently activated process in the background, obtain the tree structure object corresponding to the process, and call the node insertion logic provided by the process designer to encapsulate the operator into a structured tree node and hang it at the appropriate position of the process tree. The usual default strategy is to append the new operator to the next level of the currently selected node, or to the terminal child node of the process root node. If you are currently in a nested process, subtask or logical branch structure, the system will automatically determine the insertion point based on the context to ensure the consistency and validity of the structural logic.

[0058] For example, if a user creates an "Analog Quantity Acquisition" operator in the main flow chart, and there are already two nodes, "Start Control" and "Device Initialization", in the current process tree, the system will add the new operator to the process structure as the third child node and register it with a unique ID. The platform will also automatically update the node's hierarchical identification, execution sequence number, logical mapping relationship and other information, and highlight the canvas module corresponding to the node in the visualization area, prompting the user that the operator has been successfully added to the process logic.

[0059] In an exemplary embodiment, the operator object is added to a tree node of a tree structure of the current process, specifically including: obtaining the tree structure of the current process, the tree structure recording the process logic in the form of hierarchical nodes; passing the operator object and tree structure parameters through an operator constructor interface, encapsulating the operator object as a tree node and appending it to the end node of the tree structure; and configuring the dependency relationship between the operator object and other operators according to preset reference list parameters.

[0060] To ensure that the operator can be correctly executed and scheduled in the process, it needs to be included in the process structure system maintained within the platform, and this structure system can be organized in a hierarchical tree structure. Therefore, adding the operator object to the tree node of the tree structure of the current process is essentially to complete the structural binding between the operator object and the task process, making the operator an identifiable, executable, and manageable node in the process tree.

[0061] This process needs to obtain the tree structure instance corresponding to the process that is currently running or being edited. The tree structure is generally automatically initialized by the platform when a new process is created. It contains a root node (representing the main process or task entry) and multiple child nodes for carrying specific operations. Each child node corresponds to a specific operator. The system expresses the execution order, parallel relationship or conditional branching and other control logic of the process by dividing the hierarchy of the tree structure, maintaining the parent-child relationship and node order. For example, under the root node of the main process, the child nodes may represent logical modules such as "initialization", "data collection", and "control execution" in turn, and each module can further contain sub-processes or nested logic.

[0062] When a new operator object is successfully constructed, the platform will connect the operator object to the current process tree structure through the constructor interface. This interface usually receives two key parameters: one is the constructed operator object, and the other is the reference or insertion point of the current process tree. The platform encapsulates the operator object as a tree node instance based on the currently selected node, the default insertion rule, or the user-defined position, and appends it to the target location, usually the end node. During the encapsulation process, the system will set a unique identifier, display name, type classification for the node, and associate the corresponding operator object reference to ensure that the tree node can fully carry the entire structure and behavior logic of the operator.

[0063] For example, if a user adds an "alarm processing" operator to the main task process, the system will encapsulate it into a tree node after generating its operator object, and add it to the end of the current process tree, marking it as a "control class" node. In addition to having structural attributes, this node also saves metadata such as execution parameters, log interfaces, view pointers, etc. related to the operator to ensure that it can be directly called during flowchart rendering and task scheduling.

[0064] Furthermore, in order to implement the upstream and downstream dependency logic between operators, the platform will also configure other operator objects that the newly created operator node needs to depend on based on the reference list parameters provided by the operator constructor. These references may include data sources (such as front-end collection operators), state judgment modules, shared configuration parameters, etc. The system will register these dependencies in the association mapping table of the process tree, thereby supporting runtime context transfer, data flow tracking, and error backtracking.

[0065] S104: Generate a module view according to the configuration information of the operator object, and render and display it on a canvas.

[0066] Step S104 is the interface presentation stage in the zero-code platform operator creation method of the present invention. Its core function is to dynamically generate a corresponding graphic module view based on the configuration information of the operator object that has been constructed and mounted in the process structure, and render the view to the platform's visualization canvas for display.

[0067] In actual implementation, each operator object contains a set of configuration information during the construction process, which may include the name, type, icon, input and output port definition, control logic attributes, parameter configuration items, etc. of the operator. This information is not only used for the function execution of the operator itself, but also for guiding its graphical presentation in the canvas. In step S104, this information is used to build a module view component with structural integrity, interactive capabilities and style consistency for users to view, edit and connect during the process construction process.

[0068] The generation of module views can be carried out in a "template + instance" manner. The platform defines a set of basic templates for different types of operators, including the title bar area, input and output interface area, icon display area, configuration entry, etc. The system instantiates a specific graphic module based on the attribute values ​​carried by the operator object, and sets its title content (such as "Modbus read instruction"), icon style (such as blue communication icon), number of ports and arrangement (such as 2 input ports on the left and 1 output port on the right), etc. A one-to-one correspondence is established between the view object and the operator object to achieve two-way binding of attributes. For example, when the user modifies the module title and adjusts the parameters, the platform can synchronously update the attribute values ​​in the corresponding operator object; and when the system dynamically adjusts an operator parameter through a script, the interface will automatically reflect the change status.

[0069] After the module view is built, it will be added to the current canvas. The platform will intelligently calculate the default display position of the new module based on the position of the existing modules in the current canvas to avoid overlap and maintain structural clarity. For example, if the current canvas already has three modules, the system will present the new module directly below or to the right of the last module based on the coordinates and default offset of the last module, forming a logically coherent and visually neat process layout. For some special types of operators (such as branch operators and loop control operators), the system will also add logic line preset points or nested structure entrances to facilitate subsequent access to sub-processes or conditional logic.

[0070] For example, when a user generates an "image recognition" operator through the creation window, the system will extract the operator name "image recognition", icon "camera icon", input interface definition "image stream", and output interface definition "recognition result" from its configuration information, and then generate a module view containing the above elements on the canvas. The image stream input interface is drawn on the left side of the module, and the recognition result output interface is drawn on the right side. The "image recognition" title is displayed in the center of the top, and a parameter configuration button is provided in the upper right corner of the module. Users can click it to open the property panel for detailed parameter settings.

[0071] In an exemplary embodiment, an operator module view is generated according to the configuration information of the operator object and rendered and displayed on a canvas, specifically including: extracting attribute data from the configuration information of the operator object, the attribute data including the operator name, icon and interface configuration; generating a module view according to the attribute data, the module view including a title area and input and output interfaces, the title area displays the operator name, and the input and output interfaces respectively generate a logical interface and a data interface according to the configuration information; binding the module view to the operator object, and rendering and displaying the module view of the operator object on the canvas according to the operator layout status on the current canvas.

[0072] Each operator carries a complete set of structural information and performance attributes during the construction phase, including but not limited to: operator name (such as "data acquisition", "image recognition", etc.), icon resources (used to visually distinguish operator categories in the view), interface definition (including the type, quantity and data direction of input and output interfaces), operator classification (such as control, vision, and calculation), etc. These attribute data are both input parameters for module view generation and the premise for ensuring the accuracy of user understanding of operators.

[0073] After extracting the attribute data, the system will generate a module view based on this information. The module view is the visual expression of the operator in the canvas, which is generally composed of multiple structural areas: the title area is used to display the name and icon of the operator; the left and right sides are used to display the input and output interfaces, where the input interface is on the left side of the module and the output interface is on the right side. The logical interface and the data interface are distinguished by different icons, colors or line types; the module body area may contain background colors, borders, shadows and other visual effects to enhance recognition. The layout and style of the entire view can be dynamically adapted according to the theme template or operator type provided by the platform. For example, for a visual processing operator "Image ROI Extraction", the system will generate a module with an image identification icon, a blue border, and a title of "Image ROI". The input image interface is displayed on the left, and the output image interface and location information interface are displayed on the right.

[0074] After the module view is generated, it needs to be bound to the operator object. This binding relationship ensures that the display content of the module view is synchronized with the configuration information in the operator object in real time. For example, when the user modifies the operator name through the parameter panel, the title area will be updated in real time; when the operator interface properties change (such as adding an output), an interface node will be automatically added to the right interface area. In addition, the binding also supports event propagation mechanisms, such as module dragging, clicking, connecting, etc., which can be passed back to the operator object through callbacks, thereby triggering logic updates or parameter verification. This "model-view binding" mechanism makes the user interface an "operable and observable" presentation layer of the operator object, greatly improving the interactivity and responsiveness of the platform.

[0075] In addition, the system will render the module view to the appropriate position based on the existing layout status on the current canvas. The rendering strategy usually adopts a relative layout algorithm, which offsets the coordinates based on the position of the last added module to avoid overlap between modules. For example, if the current last module is located at the canvas coordinates (400,300), the new module will appear at (400,400) or (500,300) by default. For some process branch nodes, the system will also consider the connection direction and logical structure, and automatically adjust the module position to optimize the overall layout to ensure that the flowchart structure is clear and the reading is smooth.

[0076] In an exemplary embodiment, the module view of the operator object is rendered and displayed on the canvas according to the operator layout status on the current canvas, specifically including: if there is no operator on the current canvas, the module view of the operator object is displayed at a preset initial position of the canvas; if an operator already exists on the current canvas, the module view of the operator object is displayed at a preset offset position of the last operator created on the current canvas, and the operator object is automatically logically connected to the last created operator.

[0077] In terms of specific implementation, when the canvas is empty, the system needs to define a preset initial position, such as the (0,0) coordinate point, or the upper left corner or center position of the canvas. For example, in a process orchestration scenario, the default initial position can be the upper left corner of the canvas to conform to the reading and operation habits from left to right and from top to bottom. For data stream processing applications, the initial operator can be placed in the center of the canvas to facilitate radial arrangement when other operators are added later. When rendering, the module view is drawn as a graphic element, including a title and an interface area. The implementation of automatic connection can be completed through interface matching logic. The system generates a connection line based on the logical interface of the new operator and the logical interface of the previous operator.

[0078] When there are already operators on the canvas, new operator module views need to be placed following certain offset rules to maintain the neatness and logic of the overall layout. The offset rules can usually be calculated based on the position of the last created operator. The system first traverses the coordinates of all operators on the canvas, identifies the last created operator (for example, based on timestamps or creation order), and then determines the position of the new operator based on preset rules (such as a vertical offset of 10 pixels). The offset direction can be flexibly configured, such as vertical append (below), horizontal append (behind, such as Figure 5 The specific offset method can be: Vertical arrangement: By default, the new operator is placed directly below the last created operator and maintains the preset vertical spacing to ensure that the intervals between operators are consistent and the canvas layout is clear. For example, if the "Data Input" operator is located at (100,100), the newly created "Data Processing" operator can be placed at (100,200), that is, staggered a certain distance in the vertical direction to ensure the intuitiveness of the flow direction.

[0079] Horizontal arrangement: The new operator can be placed to the right (behind) of the last created operator, and keep the horizontal spacing, which is suitable for scenarios where multiple operators need to work in parallel. For example, if the "Data Diversion" operator is at (100,100), the newly created "Data Storage" operator can be placed at (200,00), ensuring that the task nodes are arranged in parallel, which is convenient for subsequent connection and logical expansion.

[0080] The selected operator can be created behind the last operator created among the existing operators on the current canvas, and inherit the coordinate offset of the previous operator, so that each newly created operator will be laid out according to fixed rules relative to the last operator, avoiding confusion caused by random placement and making the entire operator arrangement more readable and logical.

[0081] In the actual implementation process, you first need to determine the last created operator, that is, the operator most recently created by the user as the reference point for the new operator. Then, the system automatically calculates the placement coordinates of the new operator based on the existing layout rules of the canvas. Inheriting the coordinate offset of the previous operator means that the placement of the new operator is not just a random append, but is based on the position and arrangement of the previous operator to ensure the consistency of the layout. For example, if the previous operator is arranged vertically, the new operator is offset downward along the Y axis by a fixed spacing by default; if it is arranged horizontally, the new operator is offset to the right along the X axis by a fixed spacing. This inherited layout can ensure the coherence of the canvas structure and make the layout of the operator more reasonable.

[0082] For example, if a user creates a "Data Import" operator on the canvas, the system places it at (100,100) by default. Later, if the user wants to create a "Data Processing" operator, the system will detect that the last created operator is "Data Import" and calculate the position based on its coordinates. Assuming that the system uses the horizontal arrangement rule by default and sets a fixed horizontal offset (such as 100 pixels), the "Data Processing" operator will be automatically placed at (200,100) to keep it aligned left and right. If the user subsequently creates a "Data Storage" operator, the system will again detect that the last created operator is "Data Processing" and continue to place it at (300,100) along the same horizontal offset.

[0083] In an exemplary embodiment, domain operators related to the current task process can be extracted from a preset professional knowledge map based on the user's usage habits and industry, and an operator transfer probability matrix can be generated based on the usage frequency and dependency relationship of the domain operators; after the user creates an operator, the operator with the highest transfer probability will automatically pop up in the operator creation window for the user to choose to create.

[0084] By analyzing the user's historical behavior, industry characteristics, and domain knowledge, multiple operators that the user may use continuously in a business process are modeled, the potential sequence rules and logical dependencies are identified, and expressed and stored in the form of a probability matrix. Different from simple keyword search or manual recommendation, this method is an intelligent recommendation mechanism for contextual semantics and behavior prediction, which can reduce the cognitive burden of users looking for operators and automatically guide them to perform logical operator splicing.

[0085] In terms of specific implementation methods, the platform can establish an industry knowledge graph based on multi-source data, including: the relationship between various operators and tasks, common operator process combinations, typical usage patterns in different industries, etc. For example, for the electrical engineering industry, the knowledge graph will include typical processes such as "signal acquisition → data filtering → feature extraction → alarm judgment"; and in the image processing industry, it will include task sequences such as "image acquisition → image preprocessing → target detection → classification recognition". Through the structured semantic relationship of the knowledge graph, the system can judge the task intent when the user selects the first operator, and extract the corresponding subgraph as a candidate recommendation path.

[0086] Based on this, the system will count the historical co-occurrence frequency, creation order, number of connections, and other information between each group of adjacent operators in these candidate paths to form an operator transfer probability matrix. Each element in the matrix represents the probability of transferring from the current operator to the next operator. For example, if a user creates a "data collection" operator, the system queries the transfer probability matrix and finds that the user's most commonly used next step in similar scenarios is the "filter" operator, with a transfer probability of 85%, followed by the "format conversion" operator (transfer probability 60%) and the "normalization processing" operator (transfer probability 42%). At this time, the system will automatically pop up the "filter" operator with the highest probability in the operator creation window, and highlight it as a recommended item. Other options are arranged from high to low probability for users to choose.

[0087] This recommendation mechanism improves the creation efficiency of users and ensures the correctness of process logic and business relevance. For users who are not familiar with platform operations or are just getting started, they may not understand how to select and combine operators for a task. The transition probability matrix can provide an experience-driven intelligent assistance method, allowing users to quickly build an operator process that meets industry standards without having to be proficient in process construction.

[0088] In summary, the operator creation method of the zero-code platform provided by the present invention drives the display of the operator creation window, keyword search, operator selection and final creation through keyboard shortcuts, and intelligently positions and places new operators according to the existing operator status on the canvas, shortening the traditional second-level operations that rely on mouse dragging and double-clicking to the key response level, significantly improving the creation efficiency, shortening the development cycle of industrial automation process design, and saving time and labor costs.

[0089] Please refer to Figure 6As shown, an embodiment of the present invention further provides an electronic device 600, which includes at least one processor 601, a memory 602 (such as a non-volatile memory), a memory 603, and a communication interface 604, and the at least one processor 601, the memory 602, the memory 603, and the communication interface 604 are connected together via an internal bus 605. At least one processor 601 is used to call at least one program instruction stored or encoded in the memory 602, so that the at least one processor 601 performs various operations and functions of the operator creation method of the zero-code platform described in various embodiments of this specification.

[0090] In the embodiments of the present specification, the electronic device 600 may include, but is not limited to, personal computers, server computers, workstations, desktop computers, laptop computers, notebook computers, mobile electronic devices, smart phones, tablet computers, cellular phones, personal digital assistants (PDAs), handheld devices, messaging devices, wearable electronic devices, consumer electronic devices, and the like.

[0091] An embodiment of the present invention also provides a computer-readable medium, which carries computer execution instructions. When the computer execution instructions are executed by a processor, they can be used to implement various operations and functions of the operator creation method of the zero-code platform described in the various embodiments of this specification.

[0092] The computer-readable medium in the present invention can be a computer-readable signal medium or a computer-readable storage medium or any combination of the above two. The computer-readable storage medium can be, for example, but not limited to, a system, device or component of electricity, magnetism, light, electromagnetic, infrared, or semiconductor, or any combination of the above. More specific examples of computer-readable storage media can include, but are not limited to: an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In the present invention, a computer-readable storage medium can be any tangible medium containing or storing a program, which can be used by an instruction execution system, device or device or used in combination with it.

[0093] In the present invention, a computer-readable signal medium may include a data signal propagated in a baseband or as part of a carrier wave, which carries a computer-readable program code. Such propagated data signals may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the above. A computer-readable signal medium may also be any computer-readable medium other than a computer-readable storage medium, which may send, propagate, or transmit a program for use by or in conjunction with an instruction execution system, device, or device. The program code contained on the computer-readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wire, optical cable, RF, etc., or any suitable combination of the above.

[0094] It will be appreciated by those skilled in the art that embodiments of the present invention may be provided as methods, systems, or computer program products. Therefore, the present invention may take the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware. Furthermore, the present invention may take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0095] The present invention is described with reference to flowcharts and / or block diagrams of methods, apparatuses, systems, and computer program products according to embodiments of the present invention. It should be understood that each process and / or block in the flowchart and / or block diagram, as well as a combination of processes and / or blocks in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing device generate instructions for implementing the process in the flowchart. Figure 1 A process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.

[0096] It will be apparent to those skilled in the art that the invention is not limited to the details of the exemplary embodiments described above and that the invention can be implemented in other specific forms without departing from the spirit or essential features of the invention. Therefore, the embodiments should be considered exemplary and non-limiting in all respects, and the scope of the invention is defined by the appended claims rather than the foregoing description, and it is intended that all variations falling within the meaning and scope of the equivalent elements of the claims be included in the invention. Any reference numeral in a claim should not be considered as limiting the claim to which it relates.

[0097] In addition, it should be understood that although the present specification is described according to implementation modes, not every implementation mode contains only one independent technical solution. This description of the specification is only for the sake of clarity. Those skilled in the art should regard the specification as a whole. The technical solutions in each embodiment may also be appropriately combined to form other implementation modes that can be understood by those skilled in the art.

Claims

1. A method for creating an operator for a zero-code platform, characterized in that: include: In response to the user's creation instruction, an operator creation window is displayed in the interface of the zero-code platform; In response to the user selecting an operator to be created through the operator creation window, calling a constructor from a preset operator constructor to generate a corresponding operator object; Calling the process designer to add the operator object to the tree node of the tree structure of the current process; Generate a module view according to the configuration information of the operator object and render it on the canvas.

2. The operator creation method of the zero-code platform according to claim 1, characterized in that: In response to the user selecting an operator to be created through the operator creation window, the method includes: When a user creates an operator through the resource manager or main task designer of the zero-code platform, in the toolbox of the resource manager or main task designer, the operator to be created is selected by double-clicking the operator name. The toolbox loads the supported operator list when the zero-code platform is started, and transmits the selected operator name by binding the double-click event; In response to the user selecting the operator to be created by double-clicking the operator name, it is detected whether the process designer interface of the zero-code platform is in an activated state. If not, the process designer interface is activated so that the operator is created when the process designer interface is activated.

3. The operator creation method of the zero-code platform according to claim 2, characterized in that: Call the constructor from the preset operator constructor to generate the corresponding operator object, including: The construction logic corresponding to the operator name selected by the user is obtained from the operator constructor set through the delegation mechanism. The delegation mechanism is registered when the process designer creates a new process, and the mapping relationship between the operator name and the construction logic is bound; Calling the constructor according to the construction logic to generate an operator object including operator properties, operation logic and interface configuration; Assign a globally unique identifier to the operator object and bind the event processing logic of logging and user interaction.

4. The operator creation method of the zero-code platform according to claim 1, characterized in that: In response to the user selecting an operator to be created through the operator creation window, calling a constructor from a preset operator constructor to generate a corresponding operator object, including: When a user creates an operator through the HMI designer of the zero-code platform, the construction logic corresponding to the operator name selected by the user is obtained from the preset operator list by loading the operator assembly; Generate an operator object by calling a constructor corresponding to the construction logic through an operator constructor, wherein the operator object includes operator attribute information, a configuration interface, and an output interface; Assign a globally unique identifier to the operator object and bind log records and pop-up window interaction events; A control view bound to the operator object is generated through the HMI designer, and the control view is laid out on the canvas according to the current mouse position and displayed on the top layer.

5. The operator creation method of the zero-code platform according to claim 1, characterized in that: Adding the operator object to the tree node of the tree structure of the current process includes: Obtain a tree structure of the current process, where the tree structure records the process logic in the form of hierarchical nodes; Passing the operator object and tree structure parameters through the operator constructor interface, encapsulating the operator object as a tree node and appending it to the end node of the tree structure; According to the preset reference list parameters, the dependency relationship between the operator object and other operators is configured.

6. The operator creation method of the zero-code platform according to claim 1, characterized in that: Generate an operator module view according to the configuration information of the operator object and render it on the canvas, including: Extracting attribute data from the configuration information of the operator object, the attribute data including the operator name, icon and interface configuration; Generate a module view according to the attribute data, the module view comprising a title area and an input / output interface, the title area displays an operator name, and the input / output interface generates a logic interface and a data interface respectively according to the configuration information; The module view is bound to the operator object, and according to the operator layout state on the current canvas, the module view of the operator object is rendered and displayed on the canvas.

7. The operator creation method of the zero-code platform according to claim 1, characterized in that: According to the operator layout status on the current canvas, the module view of the operator object is rendered and displayed on the canvas, including: If there is no operator on the current canvas, the module view of the operator object is displayed at a preset initial position of the canvas; If an operator already exists on the current canvas, the module view of the operator object is displayed at the preset offset position of the last created operator on the current canvas, and the operator object is automatically logically connected to the last created operator.

8. The operator creation method of the zero-code platform according to claim 1, characterized in that: The operator creation method further includes: According to the user's usage habits and industry, domain operators related to the current task process are extracted from the preset professional knowledge map, and the operator transition probability matrix is ​​generated according to the usage frequency and dependency relationship of the domain operators; After the user creates an operator, the operator with the largest transfer probability will automatically pop up in the operator creation window for the user to select and create.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that: When the processor executes the program, it implements the operator creation method of the zero-code platform as described in any one of claims 1 to 8.

10. A computer-readable medium, characterized in that The computer-readable medium carries computer-executable instructions, which, when executed by a processor, are used to implement the operator creation method of the zero-code platform as described in any one of claims 1 to 8.

Images