CN114936021A - Data processing method, device, equipment and medium - Google Patents

Abstract

The disclosed embodiments relate to a data processing method, apparatus, device and medium, wherein the method comprises: responding to a reference request for a preset type function, and determining a target function corresponding to the reference request; acquiring function information of a target function, wherein the function information comprises current version information and a reference identifier of the target function, and acquiring a calling code segment corresponding to the reference identifier; and establishing a calling relation between the calling code segment and the function information so as to call the target function of the current version information according to the calling relation. Therefore, the function version called in the running process is guaranteed to be the function version in the compiling process, the running error caused by version incompatibility is avoided, cross-script multiplexing of the functions is achieved, and the script running success rate is guaranteed on the basis of improving script running and compiling efficiency.

Description

Data processing method, device, equipment and medium

Technical Field

The present disclosure relates to the field of communications technologies, and in particular, to a data processing method, apparatus, device, and medium.

Background

With the development of computer application technology, an integrated service providing platform can be configured with integrated streams on the platform to complete integrated tasks. The integration flow comprises a plurality of integration components, and the integration components are matched with each other to realize the development of integration tasks.

In the related art, in order to implement development of an integration task, a plurality of integration components of the integration task are written, each integration component having a script writing capability, and thus, a user implements the integration task by writing script code of each integration component.

However, when the integration task includes a large number of integration components, the user needs to write a large number of scripts, which takes a long time, and thus, the writing efficiency of the task is low.

Disclosure of Invention

In order to solve the technical problems or at least partially solve the technical problems, the disclosure provides a data processing method, device, equipment and medium, which ensure that a function version called during running is a function version during writing, avoid running errors caused by version incompatibility, realize cross-script multiplexing of functions, and ensure a script running success rate on the basis of improving script running and writing efficiency.

The embodiment of the disclosure provides a data processing method, which comprises the following steps: responding to a reference request for a preset type function, and determining a target function corresponding to the reference request; acquiring function information of the target function, wherein the function information comprises current version information and a reference identifier of the target function, and acquiring a calling code segment corresponding to the reference identifier; and establishing a calling relation between the calling code segment and the function information so as to call the target function of the current version information according to the calling relation.

An embodiment of the present disclosure further provides a data processing apparatus, where the apparatus includes: the determining module is used for responding to a reference request for a preset type function and determining a target function corresponding to the reference request; the acquisition module is used for acquiring function information of the target function, wherein the function information comprises current version information and a reference identifier of the target function, and acquiring a calling code segment corresponding to the reference identifier; and the calling module is used for establishing the calling relation between the calling code segment and the function information so as to call the target function of the current version information according to the calling relation.

An embodiment of the present disclosure further provides an electronic device, which includes: a processor; a memory for storing the processor-executable instructions; the processor is used for reading the executable instructions from the memory and executing the instructions to realize the data processing method provided by the embodiment of the disclosure.

The embodiment of the disclosure also provides a computer readable storage medium, which stores a computer program for executing the data processing method provided by the embodiment of the disclosure.

Compared with the prior art, the technical scheme provided by the embodiment of the disclosure has the following advantages:

the function calling scheme provided by the embodiment of the disclosure, in response to a reference request for a preset type of function, determines a target function corresponding to the reference request, obtains function information of the target function, wherein the function information includes current version information and a reference identifier, obtains a calling code segment corresponding to the reference identifier, and further establishes a calling relationship between the calling code segment and the function information so as to call the target function of the current version information according to the calling relationship. Therefore, the function version called in the running process is guaranteed to be the function version in the compiling process, the running error caused by version incompatibility is avoided, cross-script multiplexing of the functions is achieved, and the script running success rate is guaranteed on the basis of improving script running and compiling efficiency.

Drawings

The above and other features, advantages, and aspects of embodiments of the present disclosure will become more apparent by referring to the following detailed description when taken in conjunction with the accompanying drawings. Throughout the drawings, the same or similar reference numbers refer to the same or similar elements. It should be understood that the drawings are schematic and that elements and components are not necessarily drawn to scale.

Fig. 1 is a schematic flowchart of a data processing method according to an embodiment of the present disclosure;

fig. 2 is a schematic diagram of a call scenario of a function according to an embodiment of the present disclosure;

fig. 3 is a schematic structural diagram of a custom module provided in the embodiment of the present disclosure;

fig. 4 is a schematic diagram of a call scenario of another function provided in the embodiment of the present disclosure;

fig. 5 is a schematic flow chart of another data processing method provided in the embodiments of the present disclosure;

fig. 6 is a schematic diagram of a call scenario of another function according to an embodiment of the present disclosure;

fig. 7 is a schematic structural diagram of a data processing apparatus according to an embodiment of the present disclosure;

fig. 8 is a schematic structural diagram of an electronic device according to an embodiment of the present disclosure.

Detailed Description

Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While certain embodiments of the present disclosure are shown in the drawings, it is to be understood that the present disclosure may be embodied in various forms and should not be construed as limited to the embodiments set forth herein, but rather are provided for a more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the disclosure are for illustration purposes only and are not intended to limit the scope of the disclosure.

It should be understood that the various steps recited in the method embodiments of the present disclosure may be performed in a different order, and/or performed in parallel. Moreover, method embodiments may include additional steps and/or omit performing the illustrated steps. The scope of the present disclosure is not limited in this respect.

The term "include" and variations thereof as used herein are open-ended, i.e., "including but not limited to". The term "based on" is "based, at least in part, on". The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments". Relevant definitions for other terms will be given in the following description.

It should be noted that the terms "first", "second", and the like in the present disclosure are only used for distinguishing different devices, modules or units, and are not used for limiting the order or interdependence relationship of the functions performed by the devices, modules or units.

It is noted that references to "a", "an", and "the" modifications in this disclosure are intended to be illustrative rather than limiting, and that those skilled in the art will recognize that "one or more" may be used unless the context clearly dictates otherwise.

The names of messages or information exchanged between devices in the embodiments of the present disclosure are for illustrative purposes only, and are not intended to limit the scope of the messages or information.

In order to solve the above problem, embodiments of the present disclosure provide a data processing method, in which, on one hand, repeated code logic may occur in different scripts is considered in the method, and therefore, functions may be defined for the repeated code logic, and computation is called in different script frames, so that efficiency of encoding an integrated stream can be greatly improved;

on the other hand, in order to avoid that the running of the script is affected when the target function performs version iteration, for example, if the logic code of the custom function is subjected to incompatible modification, the running of the user conversion script is affected, so that the logic code of the relevant custom function is difficult to iterate, and the robustness of the convertible script is also affected. In some embodiments of the present disclosure, a function version that the script is expected to be loaded is specified, and it is ensured that the script can load and run a function of a corresponding version according to the specified version when running, so that the iteration difficulty of the version of the target function can be effectively reduced, and at the same time, the user script is prevented from being affected by upgrading, and the robustness of the user script is improved.

The method is described below with reference to specific examples.

Fig. 1 is a flowchart illustrating a data processing method according to an embodiment of the present disclosure, where the method may be executed by a data processing apparatus, where the apparatus may be implemented by software and/or hardware, and may be generally integrated in an electronic device. As shown in fig. 1, the method includes:

step 101, responding to a reference request for a preset type function, and determining a target function corresponding to the reference request.

In some embodiments of the present disclosure, a reference request for a preset type function may be obtained in a scenario such as script writing, and the preset type function in this embodiment may be understood as: in the embodiment, the related integrated task platform can accept the self-definition of the preset type function by a user, and after the self-defined preset type function is released, the preset type function is persistently stored.

For example, the preset type function "myAdd" may be logic that defines that the logic of the preset type function is logic that controls an addition operation of two input parameters, for example, the input parameters are num1 and num2, and the code logic of the "myAdd" is used to calculate a value of num1+ num 2.

In some embodiments of the present disclosure, at the time of script writing, it is detected whether there is a reference request for a function of a preset type, so as to determine whether the current script has a code writing request for a function of a preset type.

It should be noted that, in different application scenarios, the manner of monitoring the reference request for the preset type function is different, and the following example is given:

in one embodiment of the present disclosure, monitoring a reference request for a preset type function includes: and acquiring the current input field when the script is written. And then, monitoring whether the current input field is a preset key field.

In some embodiments of the present disclosure, a current input field when a script is written is obtained, and whether the current input field is a preset key field is monitored, wherein if the current input field is the preset key field, a reference request is monitored.

The preset key field may be any predefined field for calling a preset type function, for example, if the calling field is predefined to be "require", when it is detected that the current input field is "require", the current input field is considered to be the preset field.

In another embodiment of the present disclosure, a "preset type function call control" is provided on a preset script writing interface, and if it is detected that the control is triggered by a user, the reference request is obtained.

Further, the target function corresponding to the reference request is determined so as to reuse the code logic of the predefined target function, manual writing by a user is not needed, script writing efficiency is improved, and accordingly writing efficiency of the integrated task is improved.

For example, when the target function is the myadd function, the running logic of the corresponding myadd function may be multiplexed, and the corresponding summation code does not need to be written manually.

In the actual execution process, considering that some custom functions have strong correlation with each other, a plurality of custom functions together complete one function, for example, the function of obtaining the employee identity card number is commonly used with the function of the employee age to complete the function of managing the employee information, and therefore, after the citation request of the user is detected, one or more obtained target functions may be used.

In some possible embodiments, a specific function corresponding to the reference request may be obtained, where the specific function may be a single preset type function currently referenced by the user, for example, in response to the reference request, a plurality of candidate function tags as shown in fig. 2 may be displayed, the plurality of candidate functions may be displayed in a sliding manner in a list form, and the like, the plurality of candidate function tags correspond to the plurality of custom functions, and further, in response to a trigger request of the user for the target function tag, the specific function corresponding to the target function tag is determined. In fig. 2, the user designates the objective function label corresponding to the function as S3.

For another example, if the current input field is a preset key field, the relevant input function identifier of the current input key field is obtained, where the relevant input function identifier is an identifier that is stored in the database in advance and corresponds to a preset type function, and therefore, in this embodiment, the preset database may be queried to obtain a specified function corresponding to the relevant input function identifier. For example, if the input preset key field is detected to be required, and the detected associated input function identifier is myAdd, it is determined that myAdd is a corresponding associated input function identifier, and generally, the associated input function identifier is adjacent to the preset key field.

Further, after the designated function is obtained, the target function corresponding to the designated function is determined, in an embodiment of the present disclosure, a corresponding relationship between the custom functions may be stored, a preset corresponding relationship is queried according to the designated function, and if the associated function corresponding to the designated function is queried, the designated function and the associated function are determined to be the target function.

In other possible embodiments, a custom module is defined to implement the definition and publication of the preset type function.

The user-defined module is used for providing user-defined service of the preset type functions, the user-defined preset type functions can be renamed, a group of user-defined preset type functions are often used together to solve the same problem, and the user-defined preset type functions have certain relevance.

For example, as shown in fig. 3, the custom module defines 2 custom functions and corresponding custom constants, the custom module defines the custom module derived content by using a keyword of modules, ports { }, modules, ports { "myAdd": myAdd, "mycconst": myConst }, and the module derived content is defined as myAdd and myConst by setting modules, ports as an object of { "myAdd": myAdd, "mycconst": myConst }.

In this example, a custom module is newly created and a custom module identifier is defined, and then a service logic for writing a custom preset function is defined in the custom module, a lead-out item of the custom module is specified, the custom module is released, the custom module is persisted after being released and is used for loading and calling in the later operation.

Therefore, in some embodiments of the present disclosure, a custom module identifier corresponding to the citation request may be obtained, for example, a matched custom module identifier is determined according to a function identifier input by the citation request, and then, a preset corresponding relationship is queried according to the custom module identifier, so as to determine the target function corresponding to the custom module identifier.

Step 102, acquiring function information of the target function, wherein the function information comprises current version information and a reference identifier, and acquiring a calling code segment corresponding to the reference identifier.

The current version information can be used for indicating the current logic code of the target function in the writing process and the like, limiting the logic code of the target function quoted in the current writing process, and avoiding the problem that the script written according to the current version cannot run due to the fact that the logic code of the subsequent target function is updated and iterated.

The reference identifier in the function information may be a function identifier of the target function, or a module identifier of the custom module, or the like. In this embodiment, a calling code segment corresponding to the target function is generated according to the reference identifier, and the corresponding calling code segment is added to the corresponding script to replace writing of the logic code of the target function, so that the corresponding target function is called conveniently according to the calling code segment. In order to facilitate the user to write other script codes in the integrated component, the logic code of the target function corresponding to the calling code segment can be displayed in the preset area to be referred to when the user writes the code.

The calling code segment can be input by a user or automatically generated according to a preset calling rule and a reference identifier, and if the calling code segment is automatically generated, the code compiling efficiency is further improved.

For example, if the application is identified as "mymodule.

In some embodiments of the present disclosure, when a user wishes to reuse a code module, a require and other preset key fields are developed for the user to input a function name as a reference identifier for loading, for referencing a custom function for script writing, a module loader is called during running, and in combination with cache optimization, a persistent custom function module in the foregoing is loaded and analyzed as a corresponding run-time object, that is, a machine is an execution code segment available for script running, and is used for calling other scripts during running. For example, in the above example, the service script of the user loads a module myModule through a require keyword, and then performs service calculation using a myAdd function in the myModule.

It should be emphasized that the call of the target function in this embodiment may be multiplexed between different scripts, and the corresponding call code segment may be generated only by acquiring the reference identifier, for example, as shown in fig. 4, when the integrated component includes a component a and a component B, because the preset type function is stored persistently on the platform before, the custom function Si may be multiplexed not only when the script code of a is written, but also when the script code of B is written, thereby improving the publishing efficiency of the integration task.

And 103, establishing a calling relation between the calling code segment and the function information so as to call the target function of the current version information according to the calling relation.

In some embodiments of the present disclosure, in order to avoid the problem that the version iteration of the target function causes the running of the related script, a calling relationship between the calling code segment and the function information is established, that is, the calling code segment is associated with the current version information in the function information and the query interface of the reference identifier, and the like, so as to call the target function of the current version information according to the calling relationship.

In an embodiment of the present disclosure, the configuration file may be generated according to the current version information and the reference identifier, for example, when the reference identifier is modela and the corresponding current version information is 1.0.0 version, the configuration file may be generated according to the current version information and the reference identifier, where the configuration file is { "modela": 1.0.0 "}. The example specifies that a version 1.0.0 of modelea is to be used. In this embodiment, a calling relationship between a calling code segment and a configuration file is constructed, so that when the calling code segment is run, the configuration file is analyzed to determine version information of a corresponding target function, so as to call the target function of the corresponding version.

In an embodiment of the present disclosure, in order to further improve the script running efficiency, the loader may be further controlled to load the corresponding configuration file first when loading, and the loader may analyze the corresponding configuration file when running, so as to load the target function of the corresponding version according to the analyzed configuration file when running.

In summary, the data processing method according to the embodiment of the present disclosure, in response to a reference request for a function of a preset type, determines a target function corresponding to the reference request, obtains function information of the target function, where the function information includes current version information and a reference identifier, obtains a calling code segment corresponding to the reference identifier, and further establishes a call relationship between the calling code segment and the function information, so as to call the target function of the current version information according to the call relationship. Therefore, the function version called in the running process is guaranteed to be the function version in the compiling process, the running error caused by version incompatibility is avoided, cross-script multiplexing of the functions is achieved, and the script running success rate is guaranteed on the basis of improving script running and compiling efficiency.

Based on the above embodiment, when the actual script runs, multiplexing of the logic code of the target function can be realized based on the calling code segment, and repeated writing of related codes is not needed.

In one embodiment of the present disclosure, as shown in fig. 5, the method further comprises:

step 501, responding to a loading request to a calling code segment, and judging whether the calling code segment is loaded for the first time.

In some embodiments of the present disclosure, in order to improve the execution efficiency of the related task, the execution result of the objective function may be further multiplexed, for example, the output constant of the objective function may be taken.

In an embodiment of the present disclosure, before determining whether the calling code segment is first loaded, a function type of the target function may be further obtained, and the function type is determined to be a preset type, where the preset type function does not include a variable parameter, or input parameters of the preset type function during each operation in the current integrated component are all the same.

Step 502, if the loading is the first time, loading the calling code segment to read the corresponding target version information and the target reference identifier according to the calling relationship.

Step 503, obtaining the source code corresponding to the target function according to the target reference identifier and the target version information.

In some embodiments of the present disclosure, if the loading is for the first time, the calling code segment is loaded to read the corresponding target version information and the target reference identifier according to the calling relationship, so as to obtain the source code corresponding to the target function according to the target reference identifier and the target version information, that is, obtain the source code of the target function used when the script is written, instead of the newly issued source code of the current target function.

Step 504, parsing the source code to obtain and store an execution code segment in a preset storage location, and running the execution code segment to call the target function.

In some embodiments of the present disclosure, the source code is parsed to obtain and store the execution code segment in a preset storage location, and the execution code segment is executed to call the target function.

In some embodiments of the present disclosure, an execution code segment is run to call a target function. In an embodiment of the present disclosure, the operation parameter value and the result data may also be stored in a preset storage location, so that when the target function is called subsequently, if it is determined that the operation parameters are the same, the operation result data is multiplexed.

In an embodiment of the disclosure, if the loading is not the first time, the calling execution code segment is acquired at the preset storage position, so that the corresponding source code is not required to be executed, analyzed and compiled again, and the corresponding execution result can be acquired according to the corresponding execution code segment, thereby greatly improving the execution efficiency of the related tasks.

Referring to fig. 6 in some embodiments of the present disclosure, when the execution code segment is run to a preset execution code segment, for example, when the execution code segment is run to a require key field, the target version information and the reference identifier are obtained by parsing, and then the module loader is invoked to perform loading processing on a logic code segment of the target version information of the target function, the module loader first determines whether the execution code segment has been loaded, if the execution code segment has been loaded, the execution code segment is directly returned to a runtime object of the module, that is, the execution code segment, if the execution code segment has not been loaded, the corresponding source code is loaded from the persistent storage, then the source code is parsed/compiled into the runtime object, and finally the execution code segment is returned, and the loaded execution code segment is returned for script operation, so that after the self-defined module is defined, the reference call is performed across script boxes, thereby solving the problem of repeatedly compiling the same self-defined function, and the problem that the scattered same custom function is difficult to modify.

In summary, according to the data processing method in the embodiments of the present disclosure, after a calling code segment including an application identifier is obtained, corresponding target version information and a target reference identifier are read according to a calling relationship, and a target function of the target version information is loaded, if the target function is loaded for the first time, the corresponding execution code segment is called to execute the target function, and if the target function is not loaded for the first time, operation result data after historical loading is multiplexed, so that script execution efficiency is improved.

In order to implement the above embodiments, the present disclosure also provides a data processing apparatus.

Fig. 7 is a schematic structural diagram of a data processing apparatus provided in an embodiment of the present disclosure, where the apparatus may be implemented by software and/or hardware, and may be generally integrated in an electronic device. As shown in fig. 7, the apparatus includes:

a determining module 710, configured to determine, in response to a reference request for a preset type function, a target function corresponding to the reference request;

an obtaining module 720, configured to obtain function information of the target function, where the function information includes current version information and a reference identifier, and obtain a calling code segment corresponding to the reference identifier;

the calling module 730 is configured to establish a calling relationship between the calling code segment and the function information, so as to call the target function of the current version information according to the calling relationship.

The data processing device provided by the embodiment of the disclosure can execute the data processing method provided by any embodiment of the disclosure, and has corresponding functional modules and beneficial effects of the execution method.

In order to implement the above embodiments, the present disclosure also proposes a computer program product comprising a computer program/instructions which, when executed by a processor, implements the data processing method in the above embodiments.

Fig. 8 is a schematic structural diagram of an electronic device according to an embodiment of the present disclosure.

Referring now specifically to fig. 8, a schematic diagram of a structure suitable for implementing an electronic device 800 in embodiments of the present disclosure is shown. The electronic device 800 in the disclosed embodiment may include, but is not limited to, a mobile terminal such as a mobile phone, a notebook computer, a digital broadcast receiver, a PDA (personal digital assistant), a PAD (tablet computer), a PMP (portable multimedia player), a vehicle terminal (e.g., a car navigation terminal), and the like, and a stationary terminal such as a digital TV, a desktop computer, and the like. The electronic device shown in fig. 8 is only an example, and should not bring any limitation to the functions and the scope of use of the embodiments of the present disclosure.

As shown in fig. 8, an electronic device 800 may include a processor (e.g., central processing unit, graphics processor, etc.) 801 that may perform various appropriate actions and processes in accordance with a program stored in a Read Only Memory (ROM)802 or a program loaded from a memory 808 into a Random Access Memory (RAM) 803. In the RAM 803, various programs and data necessary for the operation of the electronic apparatus 800 are also stored. The processor 801, the ROM 802, and the RAM 803 are connected to each other by a bus 804. An input/output (I/O) interface 805 is also connected to bus 804.

Generally, the following devices may be connected to the I/O interface 805: input devices 806 including, for example, a touch screen, touch pad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, etc.; output devices 807 including, for example, a Liquid Crystal Display (LCD), speakers, vibrators, and the like; memory 808 including, for example, magnetic tape, hard disk, etc.; and a communication device 809. The communication means 809 may allow the electronic device 800 to communicate wirelessly or by wire with other devices to exchange data. While fig. 8 illustrates an electronic device 800 having various means, it is to be understood that not all illustrated means are required to be implemented or provided. More or fewer devices may alternatively be implemented or provided.

In particular, according to an embodiment of the present disclosure, the processes described above with reference to the flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program carried on a non-transitory computer readable medium, the computer program containing program code for performing the method illustrated by the flow chart. In such an embodiment, the computer program may be downloaded and installed from a network through the communication means 809, or installed from the memory 808, or installed from the ROM 802. The computer program performs the above-described functions defined in the data processing method of the embodiment of the present disclosure when executed by the processor 801.

It should be noted that the computer readable medium in the present disclosure can be a computer readable signal medium or a computer readable storage medium or any combination of the two. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples of the computer readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, 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 disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the present disclosure, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In contrast, in the present disclosure, a computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: electrical wires, optical cables, RF (radio frequency), etc., or any suitable combination of the foregoing.

In some embodiments, the clients, servers may communicate using any currently known or future developed network Protocol, such as HTTP (HyperText Transfer Protocol), and may interconnect with any form or medium of digital data communication (e.g., a communications network). Examples of communication networks include a local area network ("LAN"), a wide area network ("WAN"), the Internet (e.g., the Internet), and peer-to-peer networks (e.g., ad hoc peer-to-peer networks), as well as any currently known or future developed network.

The computer readable medium may be embodied in the electronic device; or may exist separately without being assembled into the electronic device.

The computer readable medium carries one or more programs which, when executed by the electronic device, cause the electronic device to: responding to a reference request of a preset type function when a script is written, determining a target function corresponding to the reference request, acquiring current version information and a reference identifier of the target function, acquiring a calling code segment corresponding to the reference identifier, and further constructing a calling relation among the calling code segment, the current version information and the reference identifier so as to call the target function of the current version information according to the calling relation. Therefore, the function version called in the running process is guaranteed to be the function version in the compiling process, the running error caused by version incompatibility is avoided, cross-script multiplexing of the functions is achieved, and the script running success rate is guaranteed on the basis of improving script running and compiling efficiency.

Computer program code for carrying out operations for the present disclosure may be written in any combination of one or more programming languages, including but not limited to an object oriented programming language such as Java, Smalltalk, C + +, and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any type of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet service provider).

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 disclosure. 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 executable instructions for implementing the specified logical function(s). 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 shown 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 will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

The units described in the embodiments of the present disclosure may be implemented by software or hardware. Where the name of an element does not in some cases constitute a limitation on the element itself.

The functions described herein above may be performed, at least in part, by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: field Programmable Gate Arrays (FPGAs), Application Specific Integrated Circuits (ASICs), Application Specific Standard Products (ASSPs), system on a chip (SOCs), Complex Programmable Logic Devices (CPLDs), and the like.

In the context of this disclosure, a machine-readable medium may be a tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, 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 disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

The foregoing description is only exemplary of the preferred embodiments of the disclosure and is illustrative of the principles of the technology employed. It will be appreciated by those skilled in the art that the scope of the disclosure herein is not limited to the particular combination of features described above, but also encompasses other embodiments in which any combination of the features described above or their equivalents does not depart from the spirit of the disclosure. For example, the above features and (but not limited to) the features disclosed in this disclosure having similar functions are replaced with each other to form the technical solution.

Further, while operations are depicted in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order. Under certain circumstances, multitasking and parallel processing may be advantageous. Likewise, while several specific implementation details are included in the above discussion, these should not be construed as limitations on the scope of the disclosure. Certain features that are described in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination.

Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims.

Claims (10)

1. A data processing method, characterized by comprising the steps of:

responding to a reference request for a preset type function, and determining a target function corresponding to the reference request;

acquiring function information of the target function, wherein the function information comprises current version information and a reference identifier of the target function, and acquiring a calling code segment corresponding to the reference identifier;

and establishing a calling relation between the calling code segment and the function information so as to call the target function of the current version information according to the calling relation.

2. The method of claim 1, further comprising:

responding to a loading request for the calling code segment, and judging whether the calling code segment is loaded for the first time;

if the loading is the first time, loading the calling code segment to read corresponding target version information and target reference identification according to the calling relation;

acquiring a source code corresponding to the target function according to the target reference identifier and the target version information;

analyzing the source code to obtain and store an execution code segment in a preset storage position, and operating the execution code segment to call the target function.

3. The method of claim 2, further comprising:

if the loading is not the first time, acquiring the execution code segment at the preset storage position;

executing the executing code segment to call the target function.

4. The method of claim 1, wherein the determining an objective function corresponding to the quote request comprises:

displaying a plurality of candidate function tags in response to the quote request;

and responding to a trigger request for the target function label, and determining the target function corresponding to the target function label.

5. The method of claim 1, prior to said responding to a reference request for a function of a preset type, comprising:

acquiring a current input field when a script is compiled;

and if the current input field is a preset key field, acquiring the reference request.

6. The method of claim 5, wherein the determining an objective function corresponding to the quote request comprises:

if the current input key field is a preset key field, acquiring a relevant input function identifier of the current input key field;

and querying a preset database to obtain a target function corresponding to the associated input function identifier.

7. The method of claim 1, wherein said establishing a calling relationship between said calling code segment and said function information comprises:

generating a configuration file according to the current version information and the reference identifier;

and constructing a calling relation between the calling code segment and the configuration file.

8. A data processing apparatus, comprising:

the determining module is used for responding to a reference request for a preset type function and determining a target function corresponding to the reference request;

the acquisition module is used for acquiring function information of the target function, wherein the function information comprises current version information and a reference identifier of the target function, and acquiring a calling code segment corresponding to the reference identifier;

and the calling module is used for establishing a calling relation between the calling code segment and the function information so as to call the target function of the current version information according to the calling relation.

9. An electronic device, characterized in that the electronic device comprises:

a processor;

a memory for storing the processor-executable instructions;

the processor is used for reading the executable instructions from the memory and executing the executable instructions to realize the data processing method of any one of the claims 1 to 7.

10. A computer-readable storage medium, characterized in that the computer-readable storage medium stores a computer program for executing the data processing method of any one of the preceding claims 1 to 7.

Images