CN114610293A - A custom instruction development method and data interaction framework - Google Patents

Abstract

The application provides a custom instruction development method and a data interaction framework, wherein the custom instruction development method is applied to a client, and comprises the following steps: judging whether the user-defined instruction contains an editing path or not; wherein, the editing path points to the custom instruction attribute value editing area; if yes, sending a custom instruction attribute value editing command to the development end; receiving an edited custom instruction from a development end; acquiring script data information of the edited user-defined instruction; and generating a script command of the program according to the edited self-defining instruction and the script data information of the edited self-defining instruction. By using the instruction development method provided by the application, the user can independently develop the graphic instruction; the problems that the graphic instruction can not meet the requirements of users, the development period is long, the program compiling is extremely complex and time-consuming are solved.

Description

A custom instruction development method and data interaction framework

technical field

The present application relates to the field of instruction development, and in particular, to a custom instruction development method and a data interaction framework.

Background technique

As one of the current human-computer interaction methods, graphics programming is developed by developers. The related graphics instructions are generally pre-established in the application program, and users can only write programs according to the developed graphics instructions.

Sometimes a simple function needs to write many instructions to achieve the desired effect, and there are limitations and complexity in writing related programs; and sometimes the existing graphics instructions cannot meet the needs of users, and need to be submitted to relevant developers for development. Longer cycles affect customer usage.

SUMMARY OF THE INVENTION

The purpose of the embodiments of the present application is to provide a custom instruction development method and a data interaction framework. On the client side, it is judged whether the custom instruction contains an edit path; if the custom instruction contains an edit path, a custom instruction attribute value editing command is sent to the development terminal. The development terminal receives the custom command attribute value editing command; enters the custom command attribute value editing area; sends the edited custom command to the client. The client receives the edited custom command and saves it in the custom command. The development end generates script data information of the edited custom command in the custom command script generation area according to the edited attribute value, and sends the script data information of the edited custom command to the client. The client obtains the script data information of the edited custom instruction; generates a script command of the program according to the edited custom instruction and the script data information of the edited custom instruction. It realizes the user's independent development of graphics instructions; avoids the problems that the graphics instructions do not meet the user's needs, the development cycle is long, and the programming is extremely complicated and time-consuming; it reduces the unnecessary instruction operations of the user.

In a first aspect, an embodiment of the present application provides a method for developing a custom instruction, which is characterized in that the method is applied to a client, and the method includes: judging whether the custom instruction contains an edit path; wherein the edit path points to editing the attribute value of the custom instruction If the custom command contains an edit path, send a custom command attribute value editing command to the development end; receive the edited custom command from the development end; obtain the script data information of the edited custom command; The edited custom instruction and the script data information of the edited custom instruction generate the script command of the program.

In the above implementation process, the client side determines whether the custom instruction contains an edit path; if it contains an edit path, it sends a custom instruction attribute value editing command to the development side; and then receives the edited custom instruction from the development side and the edited The script data information of the custom instruction; generate the script command of the program according to the edited custom instruction and the script data information of the edited custom instruction. Using the custom instruction development method provided by the embodiment of the present application to develop custom instructions can realize the display and editing of attribute values inside the instructions, and can realize the generation of script data of the instructions; based on this method, users can independently develop graphics instructions .

Optionally, in the embodiment of the present application, before judging whether the custom command contains an editing path, the method further includes: adding a custom command according to a custom command adding specification; wherein the custom command includes a single command and a basic framework command; A single instruction is configured to implement the script function of a single instruction; the basic framework instruction is configured to implement the interaction function between the script function of the basic framework instruction and other instruction scripts; generate data in the specified format according to the custom instruction; and send the data in the specified format to development side.

In the above implementation process, two kinds of custom instructions are added, which are a single instruction and a basic framework instruction, and then the data in the specified format is generated according to the custom instruction, and the data in the specified format is sent to the development end. By setting a single instruction and a basic frame instruction, the script function of a single instruction and the interaction between the instruction and other instruction script information can be met. These two custom instruction types can basically meet the daily development needs of users.

Optionally, in this embodiment of the present application, adding a custom instruction according to a custom instruction adding specification includes: receiving an input of basic instruction information; wherein the basic instruction information includes an instruction name and an instruction type; receiving an input of path information; wherein , the path information includes editing path information, script path information, and attribute information of the adding instruction; wherein, the attribute information includes attribute name, attribute type, and attribute value.

In the above implementation process, the user-defined instruction is added by inputting basic instruction information, inputting path information, and adding attribute information of the instruction. To customize the basic information of the instruction, the path information, and the attribute information of the instruction. In the addition of the instruction, the user can add the instruction, which can realize the user's independent development of the graphic instruction.

Optionally, in the embodiment of the present application, after sending the data in the specified format to the development terminal, the method further includes: judging the attribute information of the instruction according to the data in the specified format; sequentially generating attribute modules according to the attribute information; wherein the attribute module includes custom instruction information; and form a custom instruction according to the attribute module.

In the above implementation process, the attribute modules are sequentially generated according to the attribute information, and then the custom instructions are formed according to the attribute modules. The final custom instruction is generated by the attribute information of the instruction, and the user can independently develop the graphic instruction according to his own needs.

In a second aspect, an embodiment of the present application provides a method for developing a custom instruction, which is characterized in that the method is applied to a development end, and the development end includes: a custom instruction attribute value editing area and a custom instruction script generation area; the method includes: receiving The custom instruction attribute value editing command issued by the client; according to the custom instruction attribute value editing command, edit the attribute value of the custom instruction in the custom instruction attribute value editing area, and send the edited attribute value to The client; according to the edited attribute value, generate the script data information of the edited custom instruction in the custom instruction script generation area; and send the script data information of the edited custom instruction to the client.

In the above implementation process, a custom instruction attribute value editing command issued by the client is received; the custom instruction attribute value editing command edits the attribute value of the custom instruction in the custom instruction attribute value editing area; Send the edited custom command; generate the script data information of the edited custom command in the custom command script generation area according to the edited attribute value; send the script data information of the edited custom command to the client . The custom instruction development method provided by the embodiment of the present application can implement editing of instruction attribute values and generation of script data.

Optionally, in the embodiment of the present application, sending the edited attribute value to the client includes: the custom command attribute value editing area receives the custom command attribute value editing command; entering the custom command attribute value editing area; sending and editing After the custom command to the client.

In the above implementation process, the custom command attribute value editing area receives the custom command attribute value editing command; enters the custom command attribute value editing area; and sends the edited custom command to the client. Editing the attribute value of the custom command in the custom command attribute value editing area overcomes the problem that the existing graphic commands do not meet the needs of the user, and also provides a scene for the editing operation required by the customer.

Optionally, in this embodiment of the present application, generating script data information of the edited custom instruction in the custom instruction script generation area according to the edited attribute value, including: editing the attribute value from the custom instruction attribute value. The area is transmitted to the client; the attribute value sent by the client is received; the script function generates script data information according to the attribute value; wherein, the script function represents a specific script data information generation rule.

In the above implementation process, the attribute value is transmitted from the custom instruction attribute value editing area to the client; the script function generates script data information according to the attribute value. The script data information of the custom command is generated in the command script generation area, and the attribute value of the custom command is used as one of the generation conditions of the script data information of the custom command. Define the command script generation area to generate the script data information of the custom command. It can be seen that the generation of script data information can be realized by the custom instruction development method provided in the embodiment of the present application.

In a third aspect, an embodiment of the present application provides a method for developing a custom command, characterized in that the method for developing a custom command is applied to a system including a client and a development end, and the method includes: determining, by the client, whether the custom command contains editing path; wherein, the editing path points to the custom instruction attribute value editing area; if the custom instruction contains an editing path, the custom instruction attribute value editing command is sent to the development terminal; the development terminal receives the custom instruction attribute value editing command; Enter the custom command attribute value editing area; send the edited attribute value to the client; the client receives the edited custom command attribute value and saves it in the custom command; the development end, according to the editing After the attribute value, the script data information of the edited custom command is generated in the custom command script generation area; the script data information of the edited custom command is sent to the client; and the client obtains the edited custom command. The script data information of the custom instruction; the script command of the program is generated according to the edited custom instruction and the script data information of the edited custom instruction.

In a fourth aspect, an embodiment of the present application provides a data interaction framework, which is characterized in that, when applied to a client, the data interaction framework includes: an application program module; the application program module is used to determine whether the custom instruction contains an editing path; wherein, The editing path points to the custom instruction attribute value editing area; if the custom instruction contains an editing path, a custom instruction attribute value editing command is sent to the development terminal; the application module is also used to receive the edited data from the development terminal. Customize the attribute value of the instruction and save it to the inside of the customized instruction; obtain the script data information of the edited customized instruction; and generate the script command of the program according to the edited customized instruction and the script data information of the edited customized instruction .

In a fifth aspect, the embodiments of the present application further provide a data interaction framework, which is characterized in that, when applied to a development end, the data interaction framework includes: a custom command attribute value editing module and a custom command script generation module; wherein, the custom command The attribute value editing module is used to receive the custom command attribute value editing command sent by the client; the custom command attribute value editing module is also used to edit the command according to the custom command attribute value, in the custom command attribute value editing area Edit the attribute value of the custom command, and send the edited attribute value to the client; the custom command script generation module is used to generate the edited command in the custom command script generation area according to the edited attribute value. Script data information of the custom command; send the script data information of the edited custom command to the client.

Description of drawings

In order to explain the technical solutions of the embodiments of the present application more clearly, the following briefly introduces the accompanying drawings that need to be used in the embodiments of the present application. It should be understood that the following drawings only show some embodiments of the present application, therefore It should not be regarded as a limitation of the scope. For those of ordinary skill in the art, other related drawings can also be obtained from these drawings without any creative effort.

1 is a flowchart of a client of a method for developing a custom instruction provided by an embodiment of the present application;

2 is a flowchart of generating a custom instruction provided by an embodiment of the present application;

3 is a flowchart of a development end of a method for developing a custom instruction provided by an embodiment of the present application;

4 is a flowchart of editing a custom instruction attribute value by a development terminal provided by an embodiment of the present application;

FIG. 5 is a schematic diagram of interaction between a client and a development terminal according to an embodiment of the present application;

6 is a schematic diagram of a client module of a data interaction framework provided by an embodiment of the present application;

FIG. 7 is a schematic diagram of a development end module of a data interaction framework provided by an embodiment of the present application.

Detailed ways

The technical solutions in the embodiments of the present application will be described below with reference to the accompanying drawings in the embodiments of the present application. For example, the flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executables for implementing the specified logical function(s) instruction. It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It is also noted that each block of the block diagrams and/or flowchart illustrations, and combinations of blocks in the block diagrams and/or flowchart illustrations, can be implemented in dedicated hardware-based systems that perform the specified functions or actions , or can be implemented in a combination of dedicated hardware and computer instructions. In addition, each functional module in each embodiment of the present invention may be integrated to form an independent part, or each module may exist independently, or two or more modules may be integrated to form an independent part.

During the research process, the applicant found that when using graphics instructions to write programs, users can only write programs according to the developed graphics instructions. Sometimes a simple function needs to write many instructions to achieve the desired effect, and there are limitations in writing related programs. complexity and complexity; sometimes the existing graphics instructions cannot meet the needs of users and need to be submitted to relevant developers for development, and the long development cycle affects the use.

Based on this, the custom instruction development method provided by the present application determines whether the custom instruction contains an edit path on the client side; if the custom instruction contains an edit path, a custom instruction attribute value editing command is sent to the developer. The development terminal receives the custom command attribute value editing command; edits the attribute value and sends the edited attribute value to the client; the client receives the edited custom command attribute value and saves it in the custom command; development The client generates the script data information of the edited custom command in the custom command script generation area according to the edited attribute value; the client obtains the script data information of the edited custom command; according to the edited custom command and The script data information of the edited custom instruction generates the script command of the program. It realizes the user's independent development of graphics instructions; avoids the problems that the graphics instructions do not meet the user's needs, the development cycle is long, and the programming is extremely complicated and time-consuming; the program is concise and clear, and the program development is more flexible.

Please refer to FIG. 1. FIG. 1 is a flowchart of a client of a custom instruction development method provided by an embodiment of the present application. The custom instruction development method includes:

Step S100: Determine whether the custom instruction contains an editing path.

In the above step S100, it is determined whether the custom instruction contains an edit path. It should be noted that the editing path points to the custom instruction attribute value editing area, and the editing operation on the custom instruction attribute value can be performed in the custom instruction attribute value editing area.

Step S101: Send a custom instruction attribute value editing command to the development terminal.

In the above step S101, if the client determines in the above step S100 that the custom instruction contains an edit path, the client sends a custom instruction attribute value editing command to the developer. It should be noted that, the above-mentioned development terminal may be a web terminal, another client, or other virtual environment with a storage function.

Step S102: Receive the edited custom instruction from the development end.

In the above-mentioned step S102, the client receives the edited custom instruction from the development terminal. It should be noted that the custom instruction at this time includes the information of the modified attribute value, which can represent the user's response to the attribute value according to his own needs. Revise.

Step S103: Acquire script data information of the edited custom instruction.

In the above step S103, the client sends the edited custom instruction attribute value to the development terminal, and the development terminal returns the instruction script data information to the client. It should be noted that the script data information of the custom command at this time represents the robot execution command with the edited custom command attribute value as a parameter.

Step S104: Generate a script command of the program according to the edited custom instruction and the script data information of the edited custom instruction.

In the above step S104, the script command of the program is generated according to the edited custom instruction and the script data information of the edited custom instruction. During the process of saving the program, the client will request the user to the custom web server through the http protocol. User-defined script data, in the web server, users can organize relevant script strings according to the script specification. It should be noted that the request sent by the client to the developer can be a GET request, and the relevant parameters of the GET request will be spliced by the application according to the relevant instruction attributes, but the text attributes will not be spliced, and the relevant parameters can be the attribute values of the instruction. , property type, script path, etc.

It can be seen from this that the flow chart of the client of a method for developing a custom instruction provided by the embodiment of the present application, through the client, it is judged whether the custom instruction contains an edit path; if the custom instruction contains an edit path, it is sent to the development end Custom directive attribute value editing command. The development terminal receives the custom command attribute value editing command; edits the attribute value, and calls back the edited custom command attribute value to the client, and the client saves the attribute value in the custom command; when the program is saved, the client will The edited custom command attribute value is passed to the development end (web server), and the developer end uses the custom command attribute value as the script parameter of the custom command to generate a complete script function and return it to the client; the client obtains the edit The script data information of the customized instruction after editing; the script command of the program is generated according to the edited customized instruction and the script data information of the customized instruction after editing, and the user can modify the attribute value of the customized instruction according to his own needs. It realizes the user's independent development of graphics instructions.

In an optional embodiment, before judging whether the custom command contains an editing path, the method further includes: adding a custom command according to a custom command adding specification; wherein the custom command includes a single command and a basic framework command; a single command Configured to implement the scripting function of a single instruction; the basic framework instruction is configured to implement the interaction function between the scripting function of the basic framework instruction and other instruction scripts; generate data in a specified format according to the custom instruction; and store the data in the instruction format to the development end. Exemplarily, when adding a single instruction, the instruction type can select "Instruction", and the drop-down box of the instruction attribute type includes: text, condition, input box, drop-down box, hidden text, etc.; when adding a basic framework instruction, the instruction type can select "Instruction". Block", the drop-down box of the instruction attribute type includes: text, condition, input box, drop-down box, hidden text, and CASE block. By default, two CASE block attributes are created, namely the successful case block attribute and the failure CASE block attribute. It should be noted that other instructions cannot be dragged into a single instruction, only the script function of this instruction can be implemented; other instructions can be dragged into the CASE block of the basic framework instruction, which can realize the interaction between the script function of this instruction and other instruction scripts. , which is often used for conditional judgment.

In an optional embodiment, adding a custom instruction according to a custom instruction adding specification includes: receiving an input of basic instruction information; wherein the basic instruction information includes an instruction name and an instruction type; receiving an input of path information; wherein, the path The information includes edit path information, script path information, and attribute information of an add instruction; wherein the attribute information includes attribute name, attribute type, and attribute value. Exemplarily, the process of creating an instruction is as follows: (1) input an instruction name, the name is unique; (2) select an instruction type (it can be an instruction or an instruction block); (3) enter an edit path (optional, the correct URL path); (4) Enter the script path (required, correct URL path); (5) Add the attributes required by the instruction. The specification for adding attributes is as follows: a. Enter the attribute name, the name is unique; b. Select the attribute type. Attribute types include text, condition, input box, drop-down box, hidden text, CASE block; c. Input attribute value (conditional attribute has no attribute value) or script path (input script path when creating CASE block attribute).

Please refer to FIG. 2. FIG. 2 is a flowchart of generating a custom instruction provided by an embodiment of the present application, and the method includes:

Step S200: Determine the attribute information of the instruction according to the data in the specified format.

In the above step S200, attribute information of the instruction is determined according to data in a specified format, and the data in the specified format may be JSON data or other lightweight data exchange formats.

Step S201: Generate attribute modules in sequence according to the attribute information.

In the above step S201, it is determined which attribute types are added according to the attribute information in the above step S201, and the attribute modules are further sequentially generated according to the attribute information. It should be noted that only conditional instructions can be dragged into the conditional attribute module, and variable type instructions can be dragged into the input box attribute module.

Step S202: Form a custom instruction according to the attribute module.

In the above step S202, a complete custom graphics instruction is formed according to the attribute module.

It should be noted that, in this embodiment, each time a custom command is generated, the command information is stored in the controller, and the created custom command configuration information is obtained from the controller when logging in to the device next time. The terminal can be displayed and used without the need to create custom commands every time you log in.

In the above embodiment, the client determines the attribute information of the instruction according to the data in the specified format, sequentially generates the attribute module according to the attribute information, and forms a custom instruction according to the attribute module; thereby generating the custom instruction, the client can freely use the generated self-defined instruction. Define directives.

Please refer to FIG. 3. FIG. 3 is a flowchart of a development end of a custom instruction development method provided by an embodiment of the present application, and the method includes:

Step S300: Receive a custom instruction attribute value editing command sent by the client.

In the above-mentioned step S300, the development terminal receives the custom instruction attribute value editing command sent by the client terminal.

Step S301: Edit the attribute value of the customized instruction in the customized instruction attribute value editing area according to the customized instruction attribute value editing command.

In the above step S301, the development terminal edits the attribute value of the custom instruction in the custom instruction attribute value editing area according to the custom instruction attribute value editing command.

Step S302: Send the edited custom instruction to the client.

In the above step S302, the development end sends the edited custom instruction in the above step S301 to the client.

Step S303: When saving the program, the client applies for script data information to the development end, and transmits the edited attribute value to the development end; Script data information for custom directives.

In the above step S303, the development terminal generates script data information of the edited custom instruction in the custom instruction script generation area according to the edited attribute value, and the script data information can reflect the user's modification of the attribute value of the custom instruction .

Step S304: Send the script data information of the edited custom instruction to the client.

In the above step S304, the development terminal sends the script data information of the edited custom instruction to the client terminal.

It can be seen that, in the flowchart of the development end of a method for developing a custom command provided by the embodiment of the present application, the custom command attribute value is edited in the custom command attribute value editing area; The generation of script data information of the custom instruction; realizes the modification of the attribute value of the custom instruction by the user, and the script data generated according to the attribute value of the custom instruction. The current limitation of programming with instructions has been changed, and users can easily realize their own programming ideas.

Please refer to FIG. 4. FIG. 4 is a flowchart of editing a custom command attribute value by a development terminal provided by an embodiment of the present application, and the method includes:

Step S400: The custom instruction attribute value editing area receives a custom instruction attribute value editing command.

In the above step S400, the custom instruction attribute value editing area of the development end receives the custom instruction attribute value editing command.

Step S401 : enter the custom instruction attribute value editing area.

In the above step S401, the development terminal enters the custom command attribute value editing area. It should be noted that the client application loads and displays the custom command editing interface through the http protocol, and its attribute value can be modified on the command editing interface.

Step S402: Send the edited custom instruction to the client.

In the above step S402, the development end sends the edited custom instruction obtained in the step S401 to the client.

It can be seen that, in the above embodiment, the attribute value of the custom command is edited in the custom command editing area of the development end to generate an edited custom command, and the command is sent to the client; thus, the custom command is implemented. Free editing of attribute values, users can edit and modify attribute values, making the program writing simple and clear.

In an optional embodiment, generating script data information of the edited custom instruction in the custom instruction script generation area according to the edited attribute value includes: converting the attribute value from the custom instruction attribute value The editing area is transmitted to the client; the attribute value sent by the client is received; the script function generates script data information according to the attribute value; wherein the script function represents a specific script data information generation rule, which may be a custom A function whose directive attribute value is a variable.

Please refer to FIG. 5. FIG. 5 is a schematic diagram of interaction between a client and a development terminal provided by an embodiment of the present application. The method includes:

Step S500(a): The client side determines whether the custom instruction contains an edit path; wherein, the edit path points to the custom instruction attribute value editing area.

Step S500(b): If the custom instruction contains an edit path, send a custom instruction attribute value editing command to the development terminal.

In the above step S500, on the client side, it is determined whether the custom instruction contains an edit path; if the custom instruction contains an edit path, a custom instruction attribute value editing command is sent to the development terminal.

Step S501(a): The development terminal receives a custom instruction attribute value editing command.

Step S501(b): Enter the custom instruction attribute value editing area.

Step S501(c): Send the edited custom instruction to the client.

In the above step S501, the development terminal receives the custom instruction attribute value editing command, enters the custom instruction attribute value editing area, and sends the edited attribute value to the client.

Step S502: The client receives the edited custom instruction, and saves it into the custom instruction.

In the above step S502, the client receives the edited custom instruction, and saves it into the custom instruction.

Step S503(a): The development terminal generates script data information of the edited custom command in the custom command script generation area according to the edited attribute value.

Step S503(b): Send the script data information of the edited custom instruction to the client.

In the above step S503, the development terminal generates script data information of the edited custom instruction, and sends the edited script data information of the custom instruction to the client.

Step S504(a): The client obtains script data information of the edited custom instruction.

Step S504(b): Generate a script command of the program according to the edited custom instruction and the script data information of the edited custom instruction.

In the above step S504, the client obtains the script data information of the edited custom command sent in the above step S503(b), and generates the program's script data information according to the edited custom command and the script data information of the edited custom command. script command. Exemplarily, after getting the attribute value, the developer uses the attribute value as a parameter of the script function, and then returns the complete script function according to the script specification to organize the relevant script strings to the client side, and the client side extracts the complete script string according to the script specification. The complete custom instruction script is combined with other instruction scripts to generate a complete program execution script.

In the above-mentioned embodiment, the client and the development end perform data interaction, and the interaction mode can be performed through the http protocol. In this way, the custom command editing area of the client and the development end interacts with the custom command script generation area, which realizes the editability and modifiability of the custom command, and makes it easier to write programs using the command.

Please refer to FIG. 7 . FIG. 7 is a schematic diagram of a client module of a data interaction framework provided by an embodiment of the present application. The client module 600 of the data interaction framework includes: an application module 601 .

The application module 601 is used for judging whether the custom instruction contains an editing path; wherein, the editing path points to the custom instruction attribute value editing area; if the custom instruction contains an editing path, the custom instruction attribute value editing area is sent to the development terminal Order;

The application module 601 is also used to receive the edited custom instruction from the development end; obtain script data information of the edited custom instruction; and according to the edited custom instruction and the edited script data of the custom instruction Script commands for message generators.

In an optional embodiment, before the application module 601 determines whether the custom instruction contains an editing path, the method further includes: the application module 601 adds a custom instruction according to the custom instruction adding specification; wherein, the custom instruction includes a single Instructions and basic framework instructions; a single instruction is configured to implement the script function of a single instruction; the basic framework instruction is configured to implement the interaction function between the script function of the basic framework instruction and other instruction scripts; the application module 601 generates a specified format according to the custom instruction data; and send data in the specified format to the developer.

In an optional embodiment, the application module 601 adds a custom instruction according to the custom instruction adding specification, including: the application module 601 receives the input of basic instruction information; wherein, the basic instruction information includes the instruction name, the instruction type; the application The program module 601 receives the input of path information; wherein the path information includes editing path information, script path information; and attribute information of the adding instruction; wherein the attribute information includes attribute name, attribute type, and attribute value.

In an optional embodiment, after the application module 601 sends the data in the specified format to the development terminal, the method further includes: the application module 601 determines the attribute information of the instruction according to the data in the specified format; the application module 601 determines the attribute information according to the attribute information Attribute modules are sequentially generated; wherein, the attribute modules contain custom instruction information; and the application module 601 forms a custom instruction according to the attribute modules.

Please refer to FIG. 7 , which is a schematic diagram of a data interaction framework development end module provided by an embodiment of the present application. The data interaction framework client module 700 includes: a custom command attribute value editing module 701 , and a custom command script generation module 702 .

The custom instruction attribute value editing module 701 is configured to receive a custom instruction attribute value editing command sent by the client.

The custom instruction attribute value editing module 701 is further configured to edit the command according to the custom instruction attribute value, edit the attribute value of the custom instruction in the custom instruction attribute value editing area; and send the edited custom instruction to the client instruction.

The custom instruction script generation module 702 is used to generate script data information of the edited custom instruction in the custom instruction script generation area according to the edited attribute value; and send the script of the edited custom instruction to the client Data information.

In an optional embodiment, editing the attribute value of the custom instruction by the custom instruction attribute value editing module 701 includes: the custom instruction attribute value editing area 701 receives the custom instruction attribute value editing command; Value editing area 701 ; send the edited custom instruction to the application module 601 in the client module 600 of the data interaction framework.

In an optional embodiment, according to the edited attribute value obtained in the custom instruction attribute value editing area 701, the script data information of the edited custom instruction is generated in the custom instruction script generation area 702, including: The edited attribute value obtained by the terminal according to the custom instruction attribute value editing area 701 is then transmitted to the custom instruction script generation area 702; the script function generates script data information according to the attribute value; wherein, the script function represents specific script data Information generation rules.

In the embodiments provided in this application, it should be understood that the disclosed apparatus and method may be implemented in other manners. The apparatus embodiments described above are only illustrative. For example, the division of units is only a logical function division. In actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated. to another system, or some features can be ignored, or not implemented. On the other hand, the shown or discussed mutual coupling or direct coupling or communication connection may be through some communication interfaces, indirect coupling or communication connection of devices or units, which may be in electrical, mechanical or other forms.

In addition, units described as separate components may or may not be physically separated, and components shown as units may or may not be physical units, that is, may be located in one place, or may be distributed to multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution in this embodiment.

Furthermore, each functional module in each embodiment of the present application may be integrated together to form an independent part, or each module may exist alone, or two or more modules may be integrated to form an independent part.

Alternatively, it may be implemented in whole or in part by software, hardware, firmware, or any combination thereof. When implemented in software, it can be implemented in whole or in part in the form of a computer program product. A computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, the procedures or functions according to the embodiments of the present invention result in whole or in part.

The computer may be a general purpose computer, a special purpose computer, a computer network, or other programmable device. Computer instructions may be stored on or transmitted from one computer-readable storage medium to another computer-readable storage medium, for example, the computer instructions may be transmitted from a website site, computer, server, or data center over a wire (e.g. coaxial cable, fiber optic, digital subscriber line (DSL)) or wireless (eg, infrared, wireless, microwave, etc.) to another website site, computer, server, or data center.

In this document, relational terms such as first and second, etc. are used only to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such existence between these entities or operations. The actual relationship or sequence. Moreover, the terms "comprising", "comprising" or any other variation thereof are intended to encompass a non-exclusive inclusion such that a process, method, article or device that includes a list of elements includes not only those elements, but also includes not explicitly listed or other elements inherent to such a process, method, article or apparatus. Without further limitation, an element defined by the phrase "comprising" does not preclude the presence of additional identical elements in the process, method, article or device that includes the element.

The above are only examples of the present application, and are not intended to limit the protection scope of the present application. For those skilled in the art, the present application may have various modifications and changes. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of this application shall be included within the protection scope of this application.

Claims (10)

1. A method for developing a custom instruction, wherein the method is applied to a client, and the method comprises: Determine whether the custom instruction contains an edit path; wherein, the edit path points to the custom instruction attribute value editing area; If so, issue a custom command attribute value editing command to the developer; From the development terminal, receive the edited custom command attribute value, and save it into the custom command; obtaining script data information of the edited custom instruction; and A script command of the program is generated according to the edited custom instruction and script data information of the edited custom instruction. 2. The method according to claim 1, wherein before judging whether the custom instruction contains an editing path, the method further comprises: The custom instruction is added according to the custom instruction adding specification; wherein, the custom instruction includes a single instruction and a basic framework instruction; the single instruction is configured to implement the script function of a single instruction; the basic framework instruction is configured to implement the basic framework instruction The interaction function between the script function of the framework directive and other directive scripts; generating data in the specified format according to the custom instruction; and Send the data in the specified format to the development terminal. 3. The method according to claim 2, wherein the adding the custom instruction according to the custom instruction adding specification comprises: receiving the input of basic instruction information; wherein, the basic instruction information includes an instruction name and an instruction type; receiving input of path information; wherein the path information includes edit path information and script path information; and Attribute information of the instruction is added; wherein, the attribute information includes attribute name, attribute type, and attribute value. 4. The method according to claim 2, wherein after the data in the specified format is sent to the development terminal, the method further comprises: Determine the attribute information of the instruction according to the data in the specified format; Sequence generating attribute modules according to the attribute information; wherein, the attribute modules include the user-defined instruction information; and The custom instruction is formed according to the attribute module. 5. A method for developing a custom instruction, wherein the method is applied to a development terminal, and the development terminal comprises: a custom instruction attribute value editing area and a custom instruction script generation area; the method comprises: Receive the custom command attribute value editing command issued by the client; Editing the attribute value of the custom instruction in the custom instruction attribute value editing area according to the custom instruction attribute value editing command, and sending the edited attribute value to the client; Generate script data information of the edited custom command in the custom command script generation area according to the edited attribute value; send the edited script data information of the custom command to the client . 6. The method according to claim 5, wherein the sending the edited attribute value to the client comprises: The custom instruction attribute value editing area receives the custom instruction attribute value editing command; Enter the custom command attribute value editing area; Send the edited custom instruction to the client. 7. The method according to claim 5, wherein the script data information of the edited custom command is generated in the custom command script generation area according to the edited attribute value, include: transmitting the attribute value from the custom instruction attribute value editing area to the client; receiving the attribute value sent by the client; Script data information is generated according to the attribute value by a script function; wherein, the script function represents a specific script data information generation rule. 8. A method for developing a custom instruction, wherein the method for developing a custom instruction is applied to a system comprising a client and a development terminal, and the method comprises: By the client, it is judged whether the custom instruction contains an edit path; wherein, the edit path points to the custom instruction attribute value editing area; if so, a custom instruction attribute value editing command is sent to the development terminal; The development terminal receives the custom instruction attribute value editing command; enters the custom instruction attribute value editing area; sends the edited attribute value to the client; receiving the edited custom command attribute value by the client, and saving it into the custom command; The development terminal generates script data information of the edited custom command in the custom command script generation area according to the edited attribute value; and sends the edited custom command to the client script data information; and The client obtains script data information of the edited custom instruction; and generates a script command of the program according to the edited custom instruction and the script data information of the edited custom instruction. 9. A data interaction framework, characterized in that, applied to a client, the data interaction framework comprises: an application program module; The application module is used to judge whether the custom instruction contains an edit path; wherein, the edit path points to the custom instruction attribute value editing area; if so, send a custom instruction attribute value editing command to the development terminal; The application program module is further configured to receive the edited custom command attribute value from the development terminal, and save it into the custom command; obtain script data information of the edited custom command; and A script command of the program is generated according to the edited custom instruction and script data information of the edited custom instruction. 10. A data interaction framework, characterized in that, applied to a development end, the data interaction framework comprises: a custom command attribute value editing module and a custom command script generation module; wherein, The self-defined command attribute value editing module is used to receive the self-defined command attribute value editing command issued by the client; The custom instruction attribute value editing module is further configured to edit the command according to the custom instruction attribute value, edit the attribute value of the custom instruction in the custom instruction attribute value editing area, and edit the The attribute value after is sent to the client; The custom instruction script generation module is configured to generate script data information of the edited custom instruction in the custom instruction script generation area according to the edited attribute value; Describe the script data information of the edited custom instruction.

Images