A method, apparatus, electronic device and storage medium for component development

Abstract

The application discloses a kind of component development method, device, electronic equipment and storage medium, it is related to computer technical field, the method includes: obtaining the dependent data corresponding to the component to be developed, the dependent data includes: the general attribute corresponding to the component to be developed and the method of attribute processing, then when determining that there is the pre-stored dependent object matched with dependent data, the dependent object is obtained.Further, the pre-stored dependent object is saved to the component source code file under the component to be developed, obtains new component source code file, and runs new component source code file, obtains the corresponding target component;Then, the function of target component is debugged, and debugging result is obtained, so that when determining that debugging result meets preset condition, the target component after debugging is output.It can be seen that based on the method, the dependent object containing same dependent data can be transmitted only once, so as to improve the efficiency of overall development component.

Description

Technical Field

[0001] This invention relates to the field of computer technology, and more particularly to a method, apparatus, electronic device, and storage medium for component development. Background Technology

[0002] With the rapid development of science and technology, various websites and applications have brought great convenience to life and production. In order to enable various websites and applications to meet the increasingly rich usage needs, it is often necessary to develop various components for websites and applications. A component is a simple encapsulation of data and operation methods. Components can be set with dedicated attributes and methods. Using components, functions such as quickly processing access and designing software development methods can be realized.

[0003] For example, for marketing and promotion business, a component for displaying promotion strategies can be developed; for payment business, a component for payment selection can be developed.

[0004] Specifically, in the process of component development, it is necessary to perform the development, release or complete simulation of the production environment before the initially developed component can be debugged in the production environment. In other words, in related technologies, the component development process is cumbersome and complex, resulting in low component development efficiency.

[0005] In view of this, related technologies provide a framework based on templates, scripts, and Integrated Drive Electronics (IDE) plugins to improve component development efficiency.

[0006] However, component development based on the above framework requires retrieving component data and setting the corresponding dependency objects for the component every time a component is developed. This means that the dependency objects need to be determined every time a component is developed. Furthermore, when debugging a component that has been initially developed, if the same component data is needed, the dependency object setting process still needs to be performed again before the component data included in the dependency object can be used. That is, the dependency objects are set multiple times for the same component data, resulting in the problem of passing the component data contained in the same dependency object multiple times, thus affecting the overall efficiency of component development. Summary of the Invention

[0007] This application provides a method, apparatus, electronic device, and storage medium for component development, which can improve component development efficiency.

[0008] On the one hand, a method for component development is provided, the method comprising:

[0009] Obtain the dependency data corresponding to the component to be developed, wherein the dependency data includes: the general attributes corresponding to the component to be developed and the methods for processing the attributes;

[0010] When it is determined that there is a pre-stored dependency object that matches the dependency data, the dependency object is obtained, wherein the dependency object is generated based on the dependency data corresponding to the pre-defined component function usage requirements;

[0011] The pre-stored dependency objects are saved to the component source code file corresponding to the component to be developed, a new component source code file is obtained, and the new component source code file is run to obtain the corresponding target component;

[0012] The target component is functionally debugged to obtain the debugging results; when the debugging results are determined to meet the preset conditions, the debugged target component is output.

[0013] On one hand, an apparatus for component development is provided, the apparatus comprising:

[0014] The first acquisition unit is used to acquire the dependency data corresponding to the component to be developed. The dependency data includes: the general attributes corresponding to the component to be developed and the methods for processing the attributes.

[0015] The second acquisition unit is used to acquire the dependency object when it is determined that there is a pre-stored dependency object that matches the dependency data, wherein the dependency object is generated based on the dependency data corresponding to the pre-set component function usage requirements;

[0016] The first obtaining unit is used to save the pre-stored dependency object to the component source code file corresponding to the component to be developed, obtain a new component source code file, and run the new component source code file to obtain the corresponding target component;

[0017] The second obtaining unit is used to perform functional debugging on the target component and obtain debugging results; when it is determined that the debugging results meet the preset conditions, the debugged target component is output.

[0018] Optionally, before obtaining the dependency data corresponding to the development component, the device further includes a processing unit, configured to:

[0019] Determine the component identifier and target template corresponding to the component to be developed;

[0020] The target template is used by a script command to initialize the component to be developed, thereby obtaining the component to be developed containing the file corresponding to the target template. The component to be developed containing the file corresponding to the target template includes at least a directory of function debugging case files, source code files containing implementation dependencies, and files for exporting the component to be developed.

[0021] On one hand, an electronic device is provided, including a processor and a memory, wherein the memory stores program code that, when executed by the processor, causes the processor to perform the method developed by the aforementioned components.

[0022] On one hand, a computer program product or computer program is provided, comprising computer instructions stored in a computer-readable storage medium. A processor of an electronic device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the electronic device to perform the method developed by the aforementioned components.

[0023] This application provides a computer-readable storage medium including program code. When the program product is run on an electronic device, the program code is used to cause the electronic device to perform the steps of any of the above-described component development methods.

[0024] The beneficial effects of this application are as follows:

[0025] The component development method, apparatus, electronic device, and storage medium provided in this application embodiment can obtain the dependency object when the electronic device determines that a pre-stored dependency object exists in the dependency data matching, and then save the pre-stored dependency object to the component source code file corresponding to the component to be developed, obtain a new component source code file, run the new component source code file, obtain the corresponding target component, and perform functional debugging on the target component to obtain the debugging result. When the electronic device determines that the debugging result meets the preset conditions, it outputs the debugged target component, thereby quickly completing the development of the component to be developed.

[0026] In this way, electronic devices do not need to frequently generate corresponding dependency objects based on the same dependency data. Instead, they only need to generate and save the dependency object corresponding to the dependency data when the dependency data first appears, and then call it during component development. This effectively reduces the multiple transmission of the same dependency data and significantly improves the efficiency of developing components.

[0027] Other features and advantages of this application will be set forth in the description which follows, and will be apparent in part from the description, or may be learned by practicing the application. The objectives and other advantages of this application may be realized and obtained by means of the structures particularly pointed out in the written description, claims, and drawings. Attached Figure Description

[0028] To more clearly illustrate the technical solutions in the embodiments of this application or related technologies, the drawings used in the description of the embodiments or related technologies will be briefly introduced below. Obviously, the drawings described below are only embodiments of this application. For those skilled in the art, other drawings can be obtained based on the provided drawings without creative effort.

[0029] Figure 1 This is an optional schematic diagram of an application scenario in an embodiment of this application;

[0030] Figure 2 This is a schematic diagram of an exemplary component development system architecture in an embodiment of this application;

[0031] Figure 3 This is a flowchart illustrating a component development method according to an embodiment of this application;

[0032] Figure 4 This is a schematic diagram of a target template in an embodiment of this application;

[0033] Figure 5 This is a schematic diagram of the method flow for generating dependent objects in an embodiment of this application;

[0034] Figure 6 This is a schematic diagram of a data storage class in an embodiment of this application;

[0035] Figure 7 This is another schematic diagram illustrating the generation of dependent objects in an embodiment of this application;

[0036] Figure 8 This is a schematic diagram illustrating one method of obtaining the target component in an embodiment of this application;

[0037] Figure 9 This is a schematic diagram illustrating a scene update of a target component in an embodiment of this application;

[0038] Figure 10 This is a schematic diagram showing the first product form of the target component in this application embodiment;

[0039] Figure 11 This is a schematic diagram of the interface of the second product form of the target component in the embodiments of this application;

[0040] Figure 12 This is a schematic diagram of the third product form interface of the target component in the embodiments of this application;

[0041] Figure 13 This is a schematic diagram of the fourth product form interface of the target component in the embodiments of this application;

[0042] Figure 14This is a schematic diagram of the interface of the target component in the embodiments of this application developed in a production environment;

[0043] Figure 15 A schematic diagram of the composition structure of a component development device according to an embodiment of this application;

[0044] Figure 16 This is a schematic diagram of an electronic device according to an embodiment of this application;

[0045] Figure 17 This is a schematic diagram of the hardware structure of an electronic device according to an embodiment of this application. Detailed Implementation

[0046] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions in the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application. Unless otherwise specified, the embodiments and features in the embodiments of this application can be arbitrarily combined with each other. Furthermore, although a logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in a different order than that shown here.

[0047] To facilitate understanding of the technical solutions provided in the embodiments of this application, some key terms used in the embodiments of this application will be explained below:

[0048] 1. Component: A component is a simple encapsulation of data and methods. Specifically, a component can have its own properties and methods; properties are the accessors of the component's data, and methods are some functionalities corresponding to the component.

[0049] 2. Production Environment: This refers to the environment where services are officially provided to the public. Error reporting is typically disabled, while error logging is enabled. Specifically, the production environment can be understood as an environment containing all functionalities. Any project's environment is based on this, but during implementation, the functionality of components can be adjusted according to the client's individual needs.

[0050] 3. Class: A class is the foundation for information encapsulation in Object-Oriented Programming (OOP). Specifically, a class encapsulates attributes and methods for manipulating its own members. A class defines a type of object and possesses behavior; it describes what an object can do and the methods it can use—the programs and procedures that can manipulate that object. It contains information about the object's behavior, including its name, attributes, methods, and events.

[0051] For example, in this application embodiment, the data cache class includes the name corresponding to the dependent object, a method for obtaining dependent data from the object, and a method for overwriting and updating dependent data on the object.

[0052] The word “exemplary” as used below means “serving as an example, embodiment, or illustration.” Any embodiment illustrated as an “exemplary” need not be construed as superior to or better than other embodiments.

[0053] The terms "first" and "second" used in this document are for descriptive purposes only and should not be construed as indicating relative importance or implying the number of technical features indicated. Therefore, a feature defined as "first" or "second" may explicitly or implicitly include one or more of that feature. In the description of the embodiments of this application, unless otherwise stated, "multiple" means two or more.

[0054] Among related technologies, a framework based on templates, scripts, and Integrated Drive Electronics (IDE) plugins is provided to improve component development efficiency.

[0055] However, component development based on the above framework requires retrieving component data and setting the corresponding dependency objects for the component every time a component is developed. This means that the dependency objects need to be determined every time a component is developed. Furthermore, when debugging a component that has been initially developed, if the same component data is needed, the dependency object setting process still needs to be performed again before the component data included in the dependency object can be used. That is, the dependency objects are set multiple times for the same component data, resulting in the problem of passing the component data contained in the same dependency object multiple times, thus affecting the overall efficiency of component development.

[0056] On the other hand, when developing components based on the above framework, it is not possible to develop them directly in the production environment. It is necessary to rely on a lot of intermediate environment proxies to debug the initially developed components in the production environment. This will result in low overall efficiency of component development.

[0057] Therefore, this application provides a new solution for developing components, which eliminates the need to repeatedly transmit the same dependency data. Specifically, the dependency data corresponding to the pre-defined component functional requirements can be saved to a data cache class. Then, the dependency data in the data cache class can be retrieved, and corresponding dependency objects can be generated and saved based on this dependency data. Thus, when it is determined that the dependency data corresponding to the component to be developed matches the dependency data in the aforementioned data cache class, the dependency data in the data cache class can be directly used as the dependency object corresponding to the component to be developed. This effectively reduces the number of times the same dependency object is generated and avoids the repeated transmission of the same dependency data, thereby effectively improving the development efficiency of the component to be developed.

[0058] Specifically, because the data cache class supports the storage of dependent data—that is, the data storage class supports storing the first dependent data for the current situation and the second dependent data for the next situation—if the second dependent data differs from the first, the first dependent data can be updated directly. In other words, the data storage class supports saving and updating dependent data. Therefore, when the dependent data differs, the dependent data in the data cache class can be updated directly, thus determining the new dependent object. This speeds up the determination of dependent objects and improves the efficiency of developing related components.

[0059] After introducing the design concept of the embodiments of this application, the following is a brief introduction to the application scenarios to which the technical solutions of the embodiments of this application can be applied. It should be noted that the application scenarios described below are only for illustrating the embodiments of this application and are not intended to limit the scope. In specific implementation, the technical solutions provided by the embodiments of this application can be flexibly applied according to actual needs.

[0060] See Figure 1 The diagram illustrates an optional application scenario in an embodiment of this application. The solution provided in this embodiment is applicable to most component development scenarios. This scenario may include a terminal device 100 and a server 200. The terminal device 100 and the server 200 can communicate via a communication network. Optionally, the communication network can be a wired network or a wireless network. The terminal device 100 and the server 200 can be directly or indirectly connected via wired or wireless communication, which is not limited herein.

[0061] In this embodiment, the terminal device 100 is an electronic device that can be used by the user. This electronic device can be a personal computer, smartphone, tablet computer, laptop, e-book reader, smart home device, in-vehicle terminal, etc. Each terminal device 100 may include one or more processors 1011, a memory 1012, and I / O interfaces 1013 for interacting with the server. A component development platform or component development system may be installed in the terminal device 100. The server 200 can be an independent physical server, a server cluster or distributed system composed of multiple physical servers, or a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDN (Content Delivery Network), and big data and artificial intelligence platforms.

[0062] In this embodiment of the application, the developer can determine the name of the component to be developed based on the component development platform or system on the terminal device 100, and perform development and debugging of the component to be developed. When obtaining the dependency data or other information of the component to be developed, the developer can send a request to the server 200, and then complete the development and debugging of the component to be developed based on the information responded by the server 200, thereby obtaining the debugged target component.

[0063] For example, each developer can use the corresponding component development platform or system on the corresponding terminal device 100, and execute the development of the component to be developed on the component development platform. When specific information is needed during the development process, the developer can send an information request to the server 200. Similarly, the server 200 will process the requests sent by each terminal device 100, so that the terminal device 100 can realize the development and debugging of the component to be developed based on the information fed back by the server 200, and obtain the debugged target component.

[0064] Of course, the methods provided in the embodiments of this application are not limited to... Figure 1 The application scenarios shown can also be used in other possible scenarios, and this application embodiment does not impose any limitations. Figure 1 The functions that each device in the application scenario shown can achieve will be described in subsequent method embodiments, and will not be elaborated on here.

[0065] Please see Figure 2 , Figure 2 This is a schematic diagram of the system framework provided for an embodiment of this application. The system framework includes: a component initialization module, a component mode module, and a production environment module. Specifically, this system can be deployed on the aforementioned terminal device 100.

[0066] In this embodiment, the component initialization module is used to quickly create the template files required by the component to be developed through a script command, thereby completing the initialization of the component to be developed. The script command is, for example, "npm runcreate{component name}". Specifically, the initialized component to be developed includes at least the component source code file, capability output file, and a directory of example files.

[0067] In this embodiment, for each different business component, considering that in addition to the component's own capabilities, it also frequently uses common gateway interface (CGI) request methods, user information, and other component capability data from real-world scenarios—that is, the dependency data corresponding to the component to be developed—please refer to [the relevant documentation / reference]. Figure 2 As shown, in this embodiment of the application, the component mode module provides a component dependency unit, which can inject dependency data into the component source code file.

[0068] For example, this component dependency unit can be called a "setup Loader". Specifically, the component dependency unit is used as follows: before using the target component, component dependencies need to be injected in advance through the "create dependency object" method in the setupLoader; for example, the aforementioned "create dependency object" method can be called the "setConfig" method. Furthermore, at runtime, the component obtains the dependency data included in the injected dependency object through the "get dependency object" method of the setupLoader; for example, the aforementioned "get dependency object" method can be called the "getConfig" method.

[0069] In the embodiments of this application, please continue to refer to Figure 2 The component source code files provide the corresponding functionality to the capability export files, and the capability export files provide the corresponding applications to the case file directory. Specifically, the case file directory contains files representing the actual use cases of the component to be developed. For example, if the component to be developed, A, includes product forms such as a basic version, an industry version, and a regular status version, then component A includes three types of case files.

[0070] In this embodiment of the application, the terminal device can debug and run the target component based on the production environment module.

[0071] Of course, the methods provided in the embodiments of this application are not limited to... Figure 1 The application scenarios shown can also be used in other possible application scenarios, and the embodiments of this application do not impose any limitations.

[0072] See Figure 3The diagram shown is a flowchart illustrating an implementation of a component development method according to an embodiment of this application. This method can be executed by an electronic device, such as the aforementioned terminal device 100. The specific implementation process is as follows:

[0073] Step 301: Obtain the dependency data corresponding to the component to be developed. The dependency data includes: the common properties of the component to be developed and the methods for processing the properties.

[0074] In this embodiment, before executing step 301, the electronic device determines the component identifier and target template corresponding to the component to be developed. Specifically, the component identifier of the component to be developed can be the corresponding set component name. It should be noted that the component name can consist of letters, numbers, or any other characters, and this embodiment does not impose any limitations. For example, the component name can be "campaign".

[0075] In this embodiment of the application, after the electronic device determines the component identifier and target template corresponding to the component to be developed, it can use the target template through script commands to initialize the component to be developed and obtain the component to be developed containing the file corresponding to the target template.

[0076] Please see Figure 4 The diagram shown is an exemplary target template illustrated in an embodiment of this application. The target template includes at least a unit test file directory, a case file directory, source code files, function export files, package description files, and component description files.

[0077] In this embodiment, the electronic device can initialize the component to be developed by running "npm runcreate demo" in the directory of the component to be developed. In this embodiment, after the electronic device has completed the initialization of the component to be developed, it can obtain the dependency data corresponding to the component.

[0078] In this embodiment, the dependency data includes: common attributes corresponding to the component to be developed and methods for processing those attributes. Specifically, dependency data can be understood as methods or configurations used by the component to be developed. For example, methods that are outside the component to be developed during component development but within the larger project to which the component belongs can be used as dependency data. Alternatively, the dependency data of the component to be developed can be determined based on the actual implementation. For instance, if a project needs to report user click behavior for analysis, then clicking certain buttons within the component also needs to be reported, and the electronic device can use the click reporting method as dependency data.

[0079] Step 302: When it is determined that there is a pre-stored dependency object that matches the dependency data, obtain the dependency object, wherein the dependency object is generated based on the dependency data corresponding to the pre-defined component function usage requirements.

[0080] In this embodiment of the application, when the electronic device determines that there is a pre-stored dependency object that matches the dependency data, it can obtain the dependency object, that is, there is no need to generate the dependency object again based on the dependency data.

[0081] In the embodiments of this application, please refer to Figure 5 The diagram shown is a flowchart illustrating the steps involved in generating pre-stored dependency objects as provided in this application.

[0082] Step 501: Obtain the corresponding dependency data based on the pre-defined component function usage requirements.

[0083] In this embodiment, the electronic device can determine the pre-defined component function usage requirements based on historical usage needs or the large projects corresponding to the components to be developed. This allows for the acquisition of corresponding dependency data based on these pre-defined component function usage requirements. It should be noted that, in actual implementation, the dependency data can be updated based on actual usage needs.

[0084] Step 502: Build a data cache class based on the dependency data; the data cache class is used to support the storage of dependency data.

[0085] In this embodiment, after the electronic device determines the dependency data corresponding to the preset component function usage requirements, a data cache class can be constructed using a class approach. Specifically, this data cache class is used to support the storage of dependency data. The data cache class supports the storage of dependency data for each instance, that is, it supports the saving and updating of each piece of dependency data.

[0086] Please see Figure 6 As shown, this data cache class may include an initialization method, a method for retrieving dependency data, and a method for updating and setting dependency data. The initialization method stores the object identifier and dependency data onto the dependent object; the method for retrieving dependency data retrieves the dependency data from the dependent object; and the method for updating and setting dependency data overwrites and updates the dependency data on the dependent object. It should be noted that in actual implementation, the object identifier can be understood as an identifier identical to the component name; however, it can also be other identifiers, and this application does not impose any restrictions on this.

[0087] Step 503: Based on the preset object creation method, obtain the dependency data in the data cache class.

[0088] In this embodiment of the application, after the electronic device constructs a data cache class based on the dependency data, it can obtain the dependency data in the data cache class based on a preset object creation method.

[0089] Step 504: Generate and save the corresponding dependency objects based on the dependency data and object identifiers.

[0090] In this embodiment, after the electronic device obtains the dependency data from the data cache class, it can generate and save the corresponding dependency object based on the dependency data and object identifier. Specifically, the electronic device can construct a dependency object for the component to be developed based on the dependency data and object identifier using the singleton design pattern in the component to be developed. The dependency object includes an object identifier, attributes, and methods that support setting dependency data during initialization, updating dependency data on demand, and retrieving dependency data on demand.

[0091] As can be seen, the solution provided in this application supports setting dependency data during initialization or updating dependency data on demand using the setConfig method, thus enabling the expansion of dependency data. Furthermore, in subsequent target crime scenarios, the getConfig method can be called to retrieve the current dependency data from the dependency object according to the actual situation. That is, the dependency data in this application can be dynamically updated, and the latest dependency data is obtained.

[0092] Please see Figure 7 As shown, Figure 7 This is a schematic diagram illustrating a process for generating a dependency object in an embodiment of this application. Specifically, the electronic device can be based on a data cache class, i.e. Figure 6 The shown dependency object generation class and dependency object generation method generate component dependency objects.

[0093] Optionally, when the electronic device determines that there is no pre-stored dependency object that matches the dependency data corresponding to the component to be developed, a new data cache class is constructed based on the dependency data corresponding to the component to be developed. The new data cache class is used to support the storage of the dependency data corresponding to the component to be developed. Then, the dependency data in the new data cache class can be obtained based on the preset object creation method, and a corresponding new dependency object can be generated and saved based on the dependency data corresponding to the component to be developed and the new object identifier.

[0094] Obviously, in this embodiment of the application, the electronic device does not need to frequently generate corresponding dependency objects based on the same dependency data. Instead, it only needs to generate and save the dependency object corresponding to the dependency data when the dependency data first appears, so that it can be called during the component development process. This effectively reduces the multiple transmission of the same dependency data and significantly improves the efficiency of the components to be developed.

[0095] Step 303: Save the pre-stored dependency objects to the component source code file corresponding to the component to be developed, obtain the new component source code file, and run the new component source code file to obtain the corresponding target component.

[0096] In this embodiment, the electronic device can save pre-stored dependency objects to the component source code file corresponding to the component to be developed, thereby obtaining a new component source code file. Specifically, after obtaining the dependency objects corresponding to the component to be developed, the electronic device can match these dependency objects with the setup.ts file in the source code file corresponding to the component to be developed, which is used to save dependency objects. That is, the pre-stored dependency objects are saved to the component source code file corresponding to the component to be developed, thereby realizing the injection of default declaration dependency data of the component to be developed, and thus completing the initialization of the dependencies of the component to be developed.

[0097] Please see Figure 8 The diagram shown is a schematic representation of obtaining a target component according to an embodiment of this application. Specifically, it is assumed that the component name to be developed is "campaign," and the data dependent on the component to be developed is a click-to-report method. Figure 8 As shown, the setup.ts file in the source code file, which is used to save dependency objects, includes the component name and a click-to-report method that provides a reporting method for the production environment. When the electronic device determines that the dependency object corresponding to the component to be developed matches the setup.ts file in the source code file, it will obtain a new component source code file. After running the new component source code file, the electronic device can obtain the corresponding target component.

[0098] In this embodiment of the application, after the electronic device obtains a new source code file, that is, after the dependency object is injected into the component to be developed, it can also obtain dependency data by calling the dependency object, that is, it can obtain dependency data from the dependency object when the target component is running.

[0099] In this embodiment, since the component obtains dependent object data at runtime, the dependent data can be adjusted beforehand using the `setConfig` method provided by the dependent object, enabling dynamic adjustment of the dependent data as needed. Therefore, the electronic device sets at least one application scenario for the component to be developed based on the method of updating dependent data on demand; that is, different application scenarios can be set for the component before the target component runs using the `setConfig` method.

[0100] For example, please see Figure 9 As shown, Figure 9 This is a schematic diagram illustrating a scene update for a target component according to an embodiment of this application. When the target component is obtained... Figure 9 After the planned components are completed, the electronic device can also determine the application scenario requirements of the components based on the customer's product form requirements. That is, it can report the application scenario information selected by the user. Then, the electronic device can determine new dependency data based on the application scenario requirements of the components, thereby updating the application scenario of the target components.

[0101] To facilitate understanding by those skilled in the art, the following lists several possible methods to illustrate how to set up application scenarios for components to be developed based on the method of updating dependency data on demand. It should be understood that the following examples are merely illustrative and do not constitute a limitation on the embodiments of the present invention. In addition to the methods listed below, other determination methods may be used in specific implementation processes, which are not exhaustive in this document.

[0102] Method 1:

[0103] In this embodiment of the application, it is assumed that the target component is a planned promotion component, and the dependency parameters corresponding to the planned promotion component are the basic version dependency parameters of the newly created promotion plan state, that is, all functions corresponding to the planned promotion component are displayed in a fully expanded state. Then, the electronic device can set or update the dependency parameters of the planned promotion component based on the method of updating dependency data on demand, so as to execute the aforementioned steps 301-303 to determine the target planned promotion component.

[0104] For details, please refer to Figure 10 The diagram shown is a schematic representation of a target component's display interface provided in an embodiment of this application. Figure 10 As shown, the campaign type display unit includes two sub-display units: Display Ads Campaign and Search Ads Campaign; the promotion objective display unit includes product promotion, app promotion, sales lead collection, brand campaign promotion, website promotion, and mini-game promotion; the delivery method display unit includes standard delivery and accelerated delivery; and the campaign daily budget includes unlimited and specified daily budget sub-display units.

[0105] Method 2:

[0106] In this embodiment of the application, it is assumed that the target component is a planned promotion component, and the dependency parameters corresponding to the planned promotion component are the industry version dependency parameters of the newly created promotion plan state. That is, each function corresponding to the planned promotion component is displayed in a single expanded state. Then, the electronic device can set or update the dependency parameters of the planned promotion component based on the method of updating dependency data on demand, so as to execute the aforementioned steps 301-303 to determine the target planned promotion component.

[0107] For details, please refer to Figure 11 The diagram shown is another illustration of a target component provided in an embodiment of this application. Figure 11As shown, the campaign type display unit includes the display advertising campaign sub-display unit; the promotion goal display unit includes the sales lead collection sub-display unit; the delivery method display unit includes the standard delivery sub-display unit and the accelerated delivery sub-display unit; and the campaign daily budget includes the unlimited sub-display unit and the specified daily budget sub-display unit.

[0108] Obviously, Figure 10 The display interface shown and Figure 11 The interface shown presents each unit in a different way.

[0109] Method 3:

[0110] In this embodiment, it is assumed that the target component is a planned promotion component, and the dependency parameters corresponding to the planned promotion component are normal dependency parameters, that is, all functions corresponding to the planned promotion component are fully expanded and clickable. Then, the electronic device can set or update the dependency parameters of the planned promotion component based on the method of updating dependency data on demand, thereby executing the aforementioned steps 301-303 to determine the target planned promotion component.

[0111] For details, please refer to Figure 12 The diagram shown is a schematic representation of a target component's display interface provided in an embodiment of this application. Figure 12 As shown, the campaign type display unit includes two sub-display units: Display Ads Campaign and Search Ads Campaign; the promotion objective display unit includes product promotion, app promotion, sales lead collection, brand campaign promotion, website promotion, and mini-game promotion; the delivery method display unit includes standard delivery and accelerated delivery; and the campaign daily budget includes unlimited and specified daily budget sub-display units.

[0112] Method 4:

[0113] In this embodiment, it is assumed that the target component is a planned promotion component, and the dependency parameters corresponding to the components that this plan depends on are in an editable state, meaning that some functions corresponding to the planned promotion component cannot be displayed. The electronic device can then set or update the dependency parameters of the planned promotion component based on the method of updating dependency data on demand, thereby executing the aforementioned steps 301-303 to determine the target planned promotion component.

[0114] For details, please refer to Figure 13 The diagram shown is a schematic representation of a target component's display interface provided in an embodiment of this application. Figure 13As shown, the delivery method display unit includes a standard delivery sub-display unit and an accelerated delivery sub-display unit; and the planned daily budget includes an unlimited sub-display unit and a designated daily budget sub-display unit.

[0115] As can be seen, the electronic device in this application sets at least one application scenario for the component to be developed based on the method of updating dependency data on demand, thereby enabling the rapid setting of different product forms for the component to be developed and realizing the development of various different product forms of the component to be developed.

[0116] Step 304: Perform functional debugging on the target component and obtain the debugging results; when it is determined that the debugging results meet the preset conditions, output the debugged target component.

[0117] In this embodiment of the application, after the electronic device obtains the target component, it can package the target component into a target component that conforms to the production environment deployment, debug the target component that conforms to the production environment deployment, obtain debug files, then switch the save path of the debug files to the save path in the production environment, and develop and debug the target component in the production environment to obtain debug results.

[0118] For example, an electronic device can run the case directory of the target component through a front-end resource modular management and packaging tool, thereby generating corresponding debug files in the case directory. The front-end resource modular management and packaging tool can be, for example, wepbackjs, but it can also be other tools; this application does not limit its use. Specifically, the save path of the aforementioned debug files is, for example, component / demo / index.html. Furthermore, the electronic device can use a preset tool to proxy the corresponding debug files to the production environment path, that is, switch the save path of the debug files to the production environment's save path, thereby enabling the development and debugging of the target component in the production environment to obtain debugging results. The aforementioned preset tool can be a whistle packet capture tool, or wepbackjs, or other tools; this application does not limit its use.

[0119] In this embodiment, considering that user authentication is usually involved when calling real CGI requests in a production environment, the authentication method can be treated as a prerequisite dependency of the component to be developed and dynamically injected into the component in advance through a dependency object. This ensures that the component's authentication method is consistent with the production environment, and the authentication method used by the subsequent execution of the corresponding case of the target component is no different from that of the real page. It should be noted that other production environment dependency methods can also be treated as dependency data and dynamically injected into the component to be developed in advance through a dependency object, so that the subsequent running environment of the target component is consistent with the real production environment.

[0120] In this embodiment, after the electronic device performs functional debugging on the target component using the aforementioned method and obtains the debugging result, it is necessary to determine whether the debugging result meets preset conditions. When it is determined that the debugging result meets the preset conditions, the debugged target component is output. It should be noted that the preset conditions can be updated based on the actual implementation settings, and this embodiment does not impose any restrictions on this.

[0121] Please see Figure 14 As shown, Figure 14 This application embodiment provides a schematic diagram of the interface of the target component developed in a production environment. As can be seen, this application embodiment provides a component development solution that links independent component development with real-world usage scenarios. This solution allows for direct component development in a production environment, effectively reducing component development and debugging costs. Furthermore, dynamic dependency injection allows for the grouping and management of shared dependencies within components, facilitating scenario building and capability customization, thereby improving component development efficiency.

[0122] Based on the same inventive concept, embodiments of this application also provide an apparatus for component development. For example... Figure 15 As shown, this is a structural schematic diagram of the device 1500 for component development, which may include:

[0123] The first acquisition unit 1501 is used to acquire the dependency data corresponding to the component to be developed. The dependency data includes: the general attributes corresponding to the component to be developed and the methods for processing the attributes.

[0124] The second acquisition unit 1502 is used to acquire the dependency object when it is determined that there is a pre-stored dependency object that matches the dependency data, wherein the dependency object is generated based on the dependency data corresponding to the pre-set component function usage requirements.

[0125] The first obtaining unit 1503 is used to save the pre-stored dependency object to the component source code file corresponding to the component to be developed, obtain a new component source code file, and run the new component source code file to obtain the corresponding target component;

[0126] The second obtaining unit 1504 is used to perform functional debugging on the target component and obtain debugging results; when it is determined that the debugging results meet the preset conditions, the debugged target component is output.

[0127] Optionally, the second obtaining unit 1504 is specifically used for:

[0128] The target component is packaged into a target component that conforms to production environment deployment, and the target component that conforms to production environment deployment is debugged to obtain debug files;

[0129] The save path of the debug file is switched to the save path in the production environment, and the target component is developed and debugged in the production environment to obtain the debug results.

[0130] Optionally, the pre-stored dependency objects are determined based on the following method:

[0131] Based on the pre-defined component functionality requirements, obtain the corresponding dependency data;

[0132] A data cache class is constructed based on the dependent data; the data cache class is used to support the storage of the dependent data.

[0133] Based on a preset object creation method, obtain the dependency data in the data cache class;

[0134] The corresponding dependency objects are generated and saved based on the dependency data and object identifiers.

[0135] Optionally, the dependent object includes an object identifier, attributes, and methods that support setting dependent data during initialization, updating dependent data on demand, and retrieving dependent data on demand.

[0136] Optionally, the device further includes a processing unit for:

[0137] Based on the method of updating dependency data on demand, at least one application scenario is set for the component to be developed.

[0138] Optionally, the second acquisition unit 1502 is further configured to:

[0139] When it is determined that there is no pre-stored dependency object that matches the dependency data corresponding to the component to be developed, a new data cache class is constructed based on the dependency data corresponding to the component to be developed; the new data cache class is used to support the storage of the dependency data corresponding to the component to be developed.

[0140] Based on the preset object creation method, the dependency data in the new data cache class is obtained, and a corresponding new dependency object is generated and saved based on the dependency data and new object identifier of the component to be developed.

[0141] Optionally, before obtaining the dependency data corresponding to the development component, the device further includes a processing unit, configured to:

[0142] Determine the component identifier and target template corresponding to the component to be developed;

[0143] The target template is used by a script command to initialize the component to be developed, thereby obtaining the component to be developed containing the file corresponding to the target template; the component to be developed containing the file corresponding to the target template includes at least a unit test file directory, a case file directory, source code files, and function export files.

[0144] In the above implementation, a solution is provided to link the independent development of components with real-world usage scenarios. This solution allows components to be developed directly in a production environment, effectively reducing the development and debugging costs of components. Furthermore, the dynamic dependency injection method can be used to summarize and manage the same dependencies of components, which is beneficial for the scenario construction and capability customization of components.

[0145] For ease of description, the above sections are divided into modules (or units) according to their functions and described separately. Of course, in implementing this application, the functions of each module (or unit) can be implemented in one or more software or hardware components.

[0146] Having described the method and apparatus for developing components according to exemplary embodiments of this application, we will now describe an electronic device according to another exemplary embodiment of this application.

[0147] Those skilled in the art will understand that various aspects of this application can be implemented as a system, method, or program product. Therefore, various aspects of this application can be specifically implemented in the following forms: a completely hardware implementation, a completely software implementation (including firmware, microcode, etc.), or a combination of hardware and software implementations, collectively referred to herein as a "circuit," "module," or "system."

[0148] Regarding the apparatus in the above embodiments, the specific execution methods of each module have been described in detail in the embodiments related to the method, and will not be elaborated here.

[0149] Based on the same inventive concept as the above-described method embodiments, this application also provides an electronic device. The principle of this electronic device in solving the problem is similar to that of the above-described method. Therefore, the implementation of this electronic device can refer to the implementation of the above-described method, and repeated details will not be described again.

[0150] See Figure 16 As shown, Figure 16 This is a block diagram illustrating an electronic device 1600 according to an exemplary embodiment. The electronic device in this embodiment includes at least one processor 1601 and a memory 1602 connected to the at least one processor 1601. This embodiment does not limit the specific connection medium between the processor 1601 and the memory 1602. Figure 16Taking the connection between processor 1601 and memory 1602 via bus 1600 as an example, bus 1600 in... Figure 16 The connections between other components are shown in thick lines only and are not intended to be limiting. The Bus 1600 can be divided into address bus, data bus, control bus, etc., for ease of representation. Figure 16 The bus is represented by a single thick line, but this does not mean that there is only one bus or one type of bus.

[0151] In this embodiment of the application, the memory 1602 stores instructions that can be executed by at least one processor 1601. By executing the instructions stored in the memory 1602, at least one processor 1601 can perform the steps included in the aforementioned component development method.

[0152] The processor 1601 serves as the control center of the electronic device, connecting various parts of the fault detection device via various interfaces and lines. It monitors the electronic device as a whole by running or executing instructions stored in the memory 1602 and calling data stored in the memory 1602, thus controlling various functions and processing data. Optionally, the processor 1601 may include one or more processing units. The processor 1601 may integrate an application processor and a modem processor. The processor 1601 primarily handles the operating system, user interface, and applications, while the modem processor primarily handles wireless communication. It is understood that the modem processor may not be integrated into the processor 1601. In some embodiments, the processor 1601 and the memory 1602 may be implemented on the same chip; in other embodiments, they may be implemented on separate chips.

[0153] Processor 1601 can be a general-purpose processor, such as a central processing unit (CPU), digital signal processor, application-specific integrated circuit, field-programmable gate array or other programmable logic device, discrete gate or transistor logic device, or discrete hardware component, capable of implementing or executing the methods, steps, and logic block diagrams disclosed in the embodiments of this application. The general-purpose processor can be a microprocessor or any conventional processor. The steps of the methods disclosed in the embodiments of this application can be directly manifested as being executed by a hardware processor, or executed by a combination of hardware and software modules within the processor.

[0154] Memory 1602, as a non-volatile computer-readable storage medium, can be used to store non-volatile software programs, non-volatile computer-executable programs, and modules. Memory 1602 may include at least one type of storage medium, such as flash memory, hard disk, multimedia card, card-type memory, random access memory (RAM), static random access memory (SRAM), programmable read-only memory (PROM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), magnetic storage, magnetic disk, optical disk, etc. Memory 1602 can be any other medium capable of carrying or storing desired program code in the form of instructions or data structures that can be accessed by a computer, but is not limited thereto. In the embodiments of this application, memory 1602 can also be a circuit or any other device capable of implementing storage functions for storing program instructions and / or data.

[0155] Based on the same inventive concept, this application also provides another schematic diagram of an electronic device, see reference. Figure 17 As shown, the electronic device 100 includes a display unit 1740, a processor 1780, and a memory 1720. The display unit 1740 includes a display panel 1741, used to display information input by the user or information provided to the user, as well as various object selection interfaces of the electronic device 100. In this embodiment, it is mainly used to display the relevant operation interfaces and shortcut windows of social software installed in the electronic device 100. Optionally, the display panel 1741 can be configured using an LCD (Liquid Crystal Display) or OLED (Organic Light-Emitting Diode) display.

[0156] The processor 1780 is used to read a computer program and then execute the methods defined by the computer program. For example, the processor 1780 reads the application of social media software, thereby running the social media software on the electronic device 100 and displaying the relevant operation interface of the social media software on the display unit 1740. The processor 1780 may include one or more general-purpose processors, and may also include one or more DSPs (Digital Signal Processors) for performing related operations to implement the technical solutions provided in the embodiments of this application.

[0157] The memory 1720 generally includes main memory and secondary storage. Main memory can be random access memory (RAM), read-only memory (ROM), and cache, etc. Secondary storage can be a hard disk, optical disk, USB flash drive, floppy disk, or tape drive, etc. The memory 1720 is used to store computer programs and other data. The computer programs include application programs corresponding to various software programs, and other data may include data generated after the operating system or application programs are run, including system data (e.g., operating system configuration parameters) and user data. In this embodiment, program instructions are stored in the memory 1720, and the processor 1780 executes the program instructions stored in 1720 to implement the functions of the component development method discussed above.

[0158] In addition, the electronic device 100 may also include a display unit 1740 for receiving input digital information, character information, or contact touch operations / non-contact gestures, and generating signal inputs related to user settings and function control of the electronic device 100. Specifically, in this embodiment, the display unit 1740 may include a display panel 1741. The display panel 1741, for example, is a touch screen, which can collect touch operations performed by the user on or near it (such as operations performed by the target object using a finger, stylus, or any suitable object or accessory on or near the display panel 1741), and drive the corresponding connection device according to a pre-set program. Optionally, the display panel 1741 may include two parts: a touch detection device and a touch controller. The touch detection device detects the user's touch position and the signal generated by the touch operation, and transmits the signal to the touch controller; the touch controller receives touch information from the touch detection device, converts it into touch point coordinates, sends it to the processor 1780, and can receive and execute commands sent by the processor 1780. In this embodiment, if a user selects an associated subroutine, the touch detection device in the display panel 1741 detects the touch operation and sends the signal corresponding to the detected touch operation to the touch controller. The touch controller converts the signal into touch point coordinates and sends them to the processor 1780. The processor 1780 determines the associated subroutine selected by the user based on the received touch point coordinates and controls the display panel 1741 to display an interface for entering the login account and password, or controls the display panel 1741 to display an interface indicating successful login to the associated subroutine.

[0159] The display panel 1741 can be implemented using various types such as resistive, capacitive, infrared, and surface acoustic wave. In addition to the display unit 1740, the electronic device 100 may also include an input unit 1730, which may include, but is not limited to, one or more of the following: physical keyboard, function keys (such as volume control buttons, power buttons, etc.), trackball, mouse, joystick, etc. Figure 17The example given is an input unit 1730 that includes an image input device 1731 and other input devices 1732.

[0160] In addition to the above, the electronic device 100 may also include a power supply 1790 for powering other modules, an audio circuit 1760, a near-field communication module 1770, and an RF circuit 1710. The electronic device 100 may also include one or more sensors 1750, such as an accelerometer, a light sensor, a pressure sensor, etc. The audio circuit 1760 specifically includes a speaker 1761 and a microphone 1762, etc. For example, a user can use voice control; the electronic device 100 can collect the user's voice through the microphone 1762, control the device based on the user's voice, and play corresponding prompts through the speaker 1761 when necessary.

[0161] In an exemplary embodiment, a storage medium including operations is also provided, such as a memory 1602 including operations, the operations of which can be executed by a processor 1601 of an electronic device 1600 to complete the above-described method. Optionally, the storage medium may be a non-transitory computer-readable storage medium, such as a ROM, random access memory (RAM), CD-ROM, magnetic tape, floppy disk, and optical data storage device.

[0162] Based on the same inventive concept as the above-described method embodiments, various aspects of the component development method provided in this application can also be implemented as a program product, which includes program code. When the program product is run on an electronic device, the program code is used to cause the electronic device to perform the steps in the component development method according to the various exemplary embodiments of this application described above. For example, the electronic device can perform actions such as... Figure 3 The steps are shown.

[0163] The program product may employ any combination of one or more readable media. A readable medium may be a readable signal medium or a readable storage medium. A readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples (a non-exhaustive list) of readable storage media include: electrical connections having one or more wires, portable disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof.

[0164] The program product of the embodiments of this application can be a portable compact disc read-only memory (CD-ROM) and include program code, and can run on a server. However, the program product of this application is not limited thereto. In this document, the readable storage medium can be any tangible medium that contains or stores a program that can be used by or in conjunction with a command execution system, apparatus, or device.

[0165] A readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, carrying readable program code. This propagated data signal may take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A readable signal medium may also be any readable medium other than a readable storage medium, capable of sending, propagating, or transmitting a program for use by or in conjunction with a command execution system, apparatus, or device.

[0166] The program code contained on the readable medium may be transmitted using any suitable medium, including but not limited to wireless, wired, optical fiber, RF, etc., or any suitable combination thereof.

[0167] Although preferred embodiments of this application have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including the preferred embodiments as well as all changes and modifications falling within the scope of this application.

[0168] Obviously, those skilled in the art can make various modifications and variations to this application without departing from the spirit and scope of this application. Therefore, if such modifications and variations fall within the scope of the claims of this application and their equivalents, this application also intends to include such modifications and variations.

Claims

1. A method for component development, characterized in that, The method includes: Obtain the dependency data corresponding to the component to be developed. The dependency data includes: the general attributes of the component to be developed and the methods for processing the attributes, as well as the information on the expected display state of the component to be developed and the production environment dependency methods corresponding to the component to be developed. When it is determined that there is a pre-stored dependency object that matches the dependency data, the dependency object is obtained. The dependency object is generated based on the dependency data corresponding to the pre-defined component function usage requirements. The dependency object includes: object identifier, attributes, and methods that support setting the corresponding dependency data during initialization, updating the corresponding dependency data as needed, and obtaining the corresponding dependency data as needed. The pre-stored dependency objects are saved to the component source code file corresponding to the component to be developed, a new component source code file is obtained, and the new component source code file is run to obtain the corresponding target component; Based on the method of updating dependency data on demand, at least one application scenario is set for the component to be developed; Based on at least one of the application scenarios, the target component is functionally debugged to obtain debugging results; When it is determined that the debugging result meets the preset conditions, the debugged target component is output; The pre-stored dependency objects are determined based on the following method: Based on the pre-defined component functionality requirements, obtain the corresponding dependency data; A data cache class is constructed based on the dependent data; the data cache class is used to support the storage of the dependent data. Based on a preset object creation method, obtain the dependency data in the data cache class; The corresponding dependency objects are generated and saved based on the dependency data and object identifiers.

2. The method as described in claim 1, characterized in that, The step of performing functional debugging on the target component and obtaining debugging results includes: The target component is packaged into a target component that conforms to production environment deployment, and the target component that conforms to production environment deployment is debugged to obtain debug files; The save path of the debug file is switched to the save path in the production environment, and the target component is developed and debugged in the production environment to obtain the debug results.

3. The method as described in claim 1, characterized in that, After obtaining the dependency data corresponding to the component to be developed, the method further includes: When it is determined that there is no pre-stored dependency object that matches the dependency data corresponding to the component to be developed, a new data cache class is constructed based on the dependency data corresponding to the component to be developed; the new data cache class is used to support the storage of the dependency data corresponding to the component to be developed. Based on the preset object creation method, the dependency data in the new data cache class is obtained, and a corresponding new dependency object is generated and saved based on the dependency data and new object identifier of the component to be developed.

4. The method as described in claim 1, characterized in that, Before obtaining the dependency data corresponding to the development component, the method further includes: Determine the component identifier and target template corresponding to the component to be developed; The target template is used by a script command to initialize the component to be developed, thereby obtaining the component to be developed containing the file corresponding to the target template. The component to be developed containing the file corresponding to the target template includes at least a directory of function debugging case files, source code files containing implementation dependencies, and files for exporting the component to be developed.

5. An apparatus for component development, characterized in that, The device includes: The first acquisition unit is used to acquire the dependency data corresponding to the component to be developed. The dependency data includes: the general attributes corresponding to the component to be developed and the methods for processing the attributes, as well as the information on the expected display state of the component to be developed and the production environment dependency methods corresponding to the component to be developed. The second acquisition unit is used to acquire the dependency object when it is determined that there is a pre-stored dependency object that matches the dependency data. The dependency object is generated based on the dependency data corresponding to the pre-set component function usage requirements. The dependency object includes: object identifier, attributes, and methods that support setting the corresponding dependency data during initialization, updating the corresponding dependency data as needed, and acquiring the corresponding dependency data as needed. The first obtaining unit is used to save the pre-stored dependency objects to the component source code file corresponding to the component to be developed, obtain a new component source code file, run the new component source code file, and obtain the corresponding target component; and set at least one application scenario for the component to be developed based on the method of updating dependency data on demand. The second obtaining unit is used to perform functional debugging on the target component based on the at least one application scenario and obtain debugging results; when it is determined that the debugging results meet preset conditions, the debugging target component is output. The pre-stored dependency objects are determined in the following way: based on the pre-defined component function usage requirements, corresponding dependency data is obtained; a data cache class is constructed based on the dependency data; the data cache class is used to support the storage of the dependency data; the dependency data in the data cache class is obtained based on a preset object creation method; and corresponding dependency objects are generated and saved based on the dependency data and object identifiers.

6. The apparatus as claimed in claim 5, characterized in that, The second obtaining unit is specifically used for: The target component is packaged into a target component that conforms to production environment deployment, and the target component that conforms to production environment deployment is debugged to obtain debug files; The save path of the debug file is switched to the save path in the production environment, and the target component is developed and debugged in the production environment to obtain the debug results.

7. The apparatus as claimed in claim 5, characterized in that, The second acquisition unit is further configured to: When it is determined that there is no pre-stored dependency object that matches the dependency data corresponding to the component to be developed, a new data cache class is constructed based on the dependency data corresponding to the component to be developed. The new data cache class is used to support the storage of dependency data corresponding to the component to be developed; Based on the preset object creation method, the dependency data in the new data cache class is obtained, and a corresponding new dependency object is generated and saved based on the dependency data and new object identifier of the component to be developed.

8. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the program, it implements the steps of the method according to any one of claims 1 to 4.

9. A computer-readable storage medium, characterized in that, It includes program code that, when the program product is run on an electronic device, causes the electronic device to perform the steps of the method described in any one of claims 1 to 4.

Images