CN111045682A - Method, device and medium for realizing asynchronous processing of components - Google Patents
Method, device and medium for realizing asynchronous processing of components Download PDFInfo
- Publication number
- CN111045682A CN111045682A CN201911229945.XA CN201911229945A CN111045682A CN 111045682 A CN111045682 A CN 111045682A CN 201911229945 A CN201911229945 A CN 201911229945A CN 111045682 A CN111045682 A CN 111045682A
- Authority
- CN
- China
- Prior art keywords
- component
- components
- module
- dependent
- file corresponding
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/90—Details of database functions independent of the retrieved data types
- G06F16/95—Retrieval from the web
- G06F16/958—Organisation or management of web site content, e.g. publishing, maintaining pages or automatic linking
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
Abstract
The document discloses a method, a device and a medium for realizing asynchronous processing of components, wherein the method for realizing asynchronous processing of the components comprises the following steps: writing components in a development environment, the development environment including a runtime system and a common base component library; compiling the components into a dependent file conforming to a target format; the target format refers to a format which can be directly introduced by a browser; determining the corresponding relation between the components and the dependent files; when the browser needs to refer to a component, the dependent file corresponding to the component to be referred to is called. The developed components are converted into appropriate dependent files, and the dependent files of the corresponding components are called during application, so that the distributed asynchronous front-end components are realized on the premise of being compatible with most browsers, and the reuse range of the components is effectively expanded.
Description
Technical Field
The present disclosure relates to the field of mobile terminal data processing technologies, and in particular, to a method, an apparatus, and a medium for implementing asynchronous processing of components.
Background
In order to make reasonable use of web page resources, web page resources are often processed in a distributed manner and in a componentized manner in web page processing technology. With the development of webpage technology, webpage functions are increasingly complex, a large number of technical frameworks with a componentization idea appear in the market, and the technical frameworks become the preferred scheme for webpage front-end development gradually.
In a large web page front end project, there are typically hundreds of components. In the processing process, a plurality of components need to be uniformly organized and compiled, and the mutual influence among the components is restrained, so that the waste of development resources is often caused.
Disclosure of Invention
To overcome the problems in the related art, a method, an apparatus, and a medium for implementing asynchronous processing of components are provided.
According to a first aspect of embodiments herein, there is provided a method of implementing asynchronous processing of components, comprising:
writing components in a development environment, the development environment including a runtime system and a common base component library;
compiling the components into a dependent file conforming to a target format; the target format refers to a format which can be directly introduced by a browser;
determining the corresponding relation between the components and the dependent files;
when the browser needs to refer to a component, the dependent file corresponding to the component to be referred to is called.
In another embodiment, the method further comprises:
constructing a software development kit; the software development kit comprises functions corresponding to the components;
the calling of the dependency file corresponding to the component to be referred comprises the following steps: and calling a function corresponding to the component to be quoted in the software development kit, wherein the function is used for instantiating the component by using the dependency file corresponding to the component to be quoted.
In another embodiment, the method further comprises: constructing a component distribution platform; the component distribution platform is used for distributing a dependent file corresponding to the identification of the component;
the building software development kit comprises: and acquiring a dependency file corresponding to the component from the component distribution platform, and instantiating the component by using the dependency file.
In another embodiment, the method further comprises: and packaging the developed components into modules for release, and setting the identifier of each component to comprise a combination of the name of the module and the name of the component.
In another embodiment, the categories of the components include: structural formula and paged formula; the method further comprises the following steps: when the developed components are packaged into modules and released, the category of each component is declared, and when the category of the component is a structural formula and a transfer function is needed, the transfer parameters of the transfer function are also declared.
According to a second aspect of embodiments herein, there is provided an apparatus for implementing asynchronous processing of components, comprising:
a development module for writing components in a development environment, the development environment comprising a runtime system and a common base component library;
the compiling module is used for compiling the components into a dependent file conforming to a target format; the target format refers to a format which can be directly introduced by a browser;
the determining module is used for determining the corresponding relation between the components and the dependent files;
the first calling module is used for calling the dependent file corresponding to the component to be referred when the browser needs to refer to the component.
In another embodiment, the apparatus further comprises:
the first building module is used for building a software development kit; the software development kit comprises functions corresponding to the components;
the first calling module comprises:
and the second calling module is used for calling a function corresponding to the component to be quoted in the software development kit, and the function is used for instantiating the component by using the dependency file corresponding to the component to be quoted.
In another embodiment, the apparatus further comprises:
the second building module is used for building the component distribution platform; the component distribution platform is used for distributing a dependent file corresponding to the identification of the component;
the first building block comprises:
and the third building module is used for acquiring the dependency file corresponding to the component from the component distribution platform and instantiating the component by using the dependency file.
In another embodiment, the apparatus further comprises:
the release module is used for packaging the developed components into modules to release the modules;
and the setting module is used for setting the identification of each component to comprise a combination formed by the name of the module and the name of the component.
In another embodiment, the apparatus further comprises:
and the declaration module is used for declaring the category of each component and declaring the transfer parameter of the transfer function when the category of the component is a structural formula and the transfer function is needed.
Wherein the categories of the components include: structural formula and page formula.
According to a third aspect of embodiments herein, there is provided a non-transitory computer readable storage medium having instructions which, when executed by a processor of a mobile terminal, enable the mobile terminal to perform a method of implementing component asynchronization processing, the method comprising:
writing components in a development environment, the development environment including a runtime system and a common base component library; compiling the components into a dependent file conforming to a target format; the target format refers to a format which can be directly introduced by a browser;
determining the corresponding relation between the components and the dependent files;
when the browser needs to refer to a component, the dependent file corresponding to the component to be referred to is called.
The technical solutions provided by the embodiments herein may include the following beneficial effects: by converting the developed components into appropriate dependent files and calling the dependent files of the corresponding components during application, the distributed asynchronous front-end components are realized on the premise of being compatible with most browsers, and the reuse range of the components is effectively expanded, for example, the component can be expanded from one project to any project using the same framework.
It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the invention as claimed.
Drawings
The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present disclosure and together with the description, serve to explain the principles of the disclosure.
FIG. 1 is a flow diagram illustrating a method of implementing asynchronous processing of components in accordance with an illustrative embodiment;
FIG. 2 is a block diagram illustrating an apparatus that implements asynchronous processing of components in accordance with an exemplary embodiment;
FIG. 3 is a block diagram illustrating an apparatus to implement asynchronous processing of components in accordance with an exemplary embodiment;
FIG. 4 is a block diagram illustrating an apparatus to implement asynchronous processing of components in accordance with an exemplary embodiment;
FIG. 5 is a block diagram illustrating an apparatus to implement asynchronous processing of components in accordance with an exemplary embodiment;
FIG. 6 is a block diagram illustrating an apparatus to implement asynchronous processing of components in accordance with an example embodiment.
Detailed Description
Reference will now be made in detail to the exemplary embodiments, examples of which are illustrated in the accompanying drawings. When the following description refers to the accompanying drawings, like numbers in different drawings represent the same or similar elements unless otherwise indicated. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with the present disclosure. Rather, they are merely examples of apparatus and methods consistent with certain aspects herein, as detailed in the appended claims.
The embodiment of the disclosure provides a method for realizing asynchronous processing of components. Referring to FIG. 1, FIG. 1 is a flow diagram illustrating a method of implementing asynchronous processing of components in accordance with an exemplary embodiment. As shown in fig. 1, the method includes:
step S11, writing components in a development environment, wherein the development environment comprises a runtime system and a public basic component library;
step S12, compiling the components into a dependent file conforming to the target format; the target format refers to a format which can be directly introduced by a browser;
step S13, determining the corresponding relation between the component and the dependent file;
step S14, when the browser needs to refer to a component, the dependent file corresponding to the component to be referred to is called.
The development environment in step S11 is a development environment for writing components, and includes a Runtime (Runtime) system and a common basic component library. The basic components are components with basic functions, and when the components are written in a development environment, a plurality of related basic components can be selected from a common basic component library according to functions to be realized by the components to be written, and the components are written by using the plurality of basic components. After writing is completed, the component is previewed and debugged in the development environment.
The dependent file conforming to the object format in step S12 is a JavaScript script file (i.e., a file suffixed by js) for defining the functions of the component. Alternatively, the dependent files conforming to the target format are a JavaScript script file (i.e., js file) for defining the functionality of the component and a CSS style file (i.e., a file suffixed by CSS) for defining the style of the component.
The method converts the developed components into proper dependent files, calls the dependent files of the corresponding components when in application, thereby realizing the distributed asynchronous front-end components on the premise of being compatible with most browsers, and effectively expanding the reuse range of the components, such as: and can be extended from one item to any item using the same framework.
The embodiment of the disclosure provides a method for realizing asynchronous processing of components. The method in this embodiment is based on the method shown in fig. 1, and further includes: constructing a software development kit; the software development kit includes functions corresponding to the components. In step S14 shown in fig. 1, the calling of the file corresponding to the component to be referred includes: and calling a function corresponding to the component to be referred in the software development tool package, wherein the function is used for instantiating the component by using the dependency file corresponding to the component to be referred.
The process of instantiating a component includes: introducing a dependent file, creating necessary variables, allocating memory space, and converting the dependent file of the component into an instance. The implementation of the component can be referred to by the page and rendered as part of the page, implementing the corresponding functionality of the component.
For example: the Software Development Kit is a Software Development Kit (SDK), and when the common language in the front-end processing of the web page is JavaScript, the SDK in the method corresponds to the JavaScript SDK. The SDK includes APIs and example code.
The embodiment of the disclosure provides a method for realizing asynchronous processing of components. The method in this embodiment is based on the method shown in the previous embodiment, and further includes: constructing a component distribution platform; this component distribution platform is used to distribute dependent files corresponding to the identification of the component. The step of constructing the software development kit in the above embodiment includes: and acquiring a dependency file corresponding to the component from the component distribution platform, and instantiating the component by using the dependency file.
The component distribution platform introduced in the embodiment can simplify the use mode of the asynchronous component, shield bottom-layer details, facilitate the use of page developers, unify the use modes of the asynchronous component and reduce the difference problem caused by different use modes.
The embodiment of the disclosure provides a method for realizing asynchronous processing of components. The method in this embodiment is based on the method shown in fig. 1, and further includes: and packaging the developed components into modules for release, and setting the identifier of each component to comprise a combination of the names of the modules and the names of the components. For example: the identification names of the components are: name of module-name of component. Specific examples are: Form-Login, Form-Register, Table-Users.
In the embodiment, the components are published in a mode of packaging into modules, the identifiers of the components are defined in a mode of combining the module names and the component names, and reasonable and easy-to-use unique identifiers are set for the components.
The embodiment of the disclosure provides a method for realizing asynchronous processing of components. The classes of components in this embodiment include: structural formula and page formula. On the basis of the method shown in fig. 1, the method further comprises: when the developed components are packaged into modules and released, the category of each component is declared, and when the category of the component is a structural formula and a transfer function is needed, the transfer parameters of the transferred function are also declared.
Wherein the transfer function includes two types:
the type one is as follows: an attribute. The component may dynamically change the rendered content according to the incoming attributes. The description information of the attribute includes: meaning, type, required or not, optional scope, etc.
Type two: an event. A series of events may be triggered during a user interaction with a component of a page, which may listen for events thrown by the component. The description information of the event includes: event name, description, event parameters.
In the embodiment, the category of the component is stated, and the classified processing is performed according to different functional components. Based on the characteristic that the page-type component can be directly used for constructing the page and the structural component cannot be directly used for constructing the page, the transfer parameter of the transfer function is particularly stated for the structural component, so that components with different functions are reasonably applied.
An apparatus for implementing asynchronous processing of a component is further provided in the disclosed embodiment, and referring to fig. 2, fig. 2 is a structural diagram illustrating an apparatus for implementing asynchronous processing of a component according to an exemplary embodiment. As shown in fig. 2, the apparatus includes:
a development module 201 for writing components in a development environment, the development environment including a runtime system and a common base component library;
a compiling module 202, configured to compile the component into a dependent file conforming to a target format; the target format refers to a format which can be directly introduced by a browser;
a determining module 203, configured to determine a correspondence between the component and the dependent file;
the first calling module 204 is configured to call, when the browser needs to refer to a component, a dependent file corresponding to the component to be referred to.
An apparatus for implementing asynchronous processing of a component is further provided in the disclosed embodiment, and referring to fig. 3, fig. 3 is a structural diagram illustrating an apparatus for implementing asynchronous processing of a component according to an exemplary embodiment. As shown in fig. 3, the apparatus further includes, on the basis of fig. 2:
a first building module 301 for building a software development kit; the software development kit comprises functions corresponding to the components.
The first calling module 204 includes: a second calling module 302, configured to call a function in the software development kit, where the function corresponds to the component to be referred to, and the function is configured to instantiate the component using a dependency file corresponding to the component to be referred to.
An apparatus for implementing asynchronous processing of a component is further provided in the disclosed embodiment, and referring to fig. 4, fig. 4 is a structural diagram illustrating an apparatus for implementing asynchronous processing of a component according to an exemplary embodiment. As shown in fig. 4, the apparatus further includes, on the basis of fig. 3:
a second building module 401 for building a component distribution platform; the component distribution platform is to distribute a dependent file corresponding to an identification of a component.
The first building module 301 comprises a third building module 402 for obtaining a dependency file corresponding to a component from the component distribution platform, and instantiating the component using the dependency file.
An apparatus for implementing asynchronous processing of a component is further provided in the disclosed embodiment, and referring to fig. 5, fig. 5 is a structural diagram illustrating an apparatus for implementing asynchronous processing of a component according to an exemplary embodiment. As shown in fig. 5, the apparatus further includes, on the basis of fig. 1:
the publishing module 501 is used for packaging the developed components into modules to be published;
the publishing module 501 includes: a setting module 502, configured to set an identifier of each component to include a combination of a name of the module and a name of the component.
The embodiment of the present disclosure further provides a device for implementing asynchronous processing of a component, where the device includes: and the declaration module is used for declaring the category of each component and declaring the transfer parameter of the transfer function when the category of the component is a structural formula and the transfer function is needed.
Wherein the categories of the components include: structural formula and page formula.
The transfer function includes two types:
the type one is as follows: an attribute. The component may dynamically change the rendered content according to the incoming attributes. The description information of the attribute includes: meaning, type, required or not, optional scope, etc.
Type two: an event. A series of events may be triggered during a user interaction with a component of a page, which may listen for events thrown by the component. The description information of the event includes: event name, description, event parameters.
Also provided in an embodiment of the present disclosure is a non-transitory computer-readable storage medium, wherein instructions, when executed by a processor of a mobile terminal, enable the mobile terminal to perform a method of implementing asynchronous processing of components, the method including:
developing a component;
converting the component into a dependent file conforming to a target format; the target format refers to a format which can be directly introduced by a browser;
determining the corresponding relation between the components and the dependent files;
when the browser needs to refer to a component, the dependent file corresponding to the component to be referred to is called.
FIG. 6 is a block diagram illustrating an apparatus 600 for implementing component asynchronization processing in accordance with an exemplary embodiment. For example, the apparatus 600 may be a mobile phone, a computer, a digital broadcast terminal, a messaging device, a game console, a tablet device, a medical device, an exercise device, a personal digital assistant, and the like.
Referring to fig. 6, apparatus 600 may include one or more of the following components: processing component 602, memory 604, power component 606, multimedia component 608, audio component 610, input/output (I/O) interface 612, sensor component 614, and communication component 616.
The processing component 602 generally controls overall operation of the device 600, such as operations associated with display, telephone calls, data communications, camera operations, and recording operations. The processing component 602 may include one or more processors 620 to execute instructions to perform all or a portion of the steps of the methods described above. Further, the processing component 602 can include one or more modules that facilitate interaction between the processing component 602 and other components. For example, the processing component 602 may include a multimedia module to facilitate interaction between the multimedia component 605 and the processing component 602.
The memory 604 is configured to store various types of data to support operation at the device 600. Examples of such data include instructions for any application or method operating on device 600, contact data, phonebook data, messages, pictures, videos, and so forth. The memory 604 may be implemented by any type or combination of volatile or non-volatile memory devices such as Static Random Access Memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic or optical disks.
The multimedia component 605 includes a screen that provides an output interface between the device 600 and the user. In some embodiments, the screen may include a Liquid Crystal Display (LCD) and a Touch Panel (TP). If the screen includes a touch panel, the screen may be implemented as a touch screen to receive an input signal from a user. The touch panel includes one or more touch sensors to sense touch, slide, and gestures on the touch panel. The touch sensor may not only sense the boundary of a touch or slide action, but also detect the duration and pressure associated with the touch or slide operation. In some embodiments, the multimedia component 605 includes a front facing camera and/or a rear facing camera. The front camera and/or the rear camera may receive external multimedia data when the device 600 is in an operating mode, such as a shooting mode or a video mode. Each front camera and rear camera may be a fixed optical lens system or have a focal length and optical zoom capability.
The audio component 610 is configured to output and/or input audio signals. For example, audio component 610 includes a Microphone (MIC) configured to receive external audio signals when apparatus 600 is in an operational mode, such as a call mode, a recording mode, and a voice recognition mode. The received audio signal may further be stored in the memory 604 or transmitted via the communication component 616. In some embodiments, audio component 610 further includes a speaker for outputting audio signals.
The I/O interface 612 provides an interface between the processing component 602 and peripheral interface modules, which may be keyboards, click wheels, buttons, etc. These buttons may include, but are not limited to: a home button, a volume button, a start button, and a lock button.
The sensor component 614 includes one or more sensors for providing status assessment of various aspects of the apparatus 600. For example, the sensor component 614 may detect an open/closed state of the device 600, the relative positioning of components, such as a display and keypad of the apparatus 600, the sensor component 614 may also detect a change in position of the apparatus 600 or a component of the apparatus 600, the presence or absence of user contact with the apparatus 600, orientation or acceleration/deceleration of the apparatus 600, and a change in temperature of the apparatus 600. The sensor assembly 614 may include a proximity sensor configured to detect the presence of a nearby object without any physical contact. The sensor assembly 614 may also include a light sensor, such as a CMOS or CCD image sensor, for use in imaging applications. In some embodiments, the sensor assembly 614 may also include an acceleration sensor, a gyroscope sensor, a magnetic sensor, a pressure sensor, or a temperature sensor.
The communication component 616 is configured to facilitate communications between the apparatus 600 and other devices in a wired or wireless manner. The apparatus 600 may access a wireless network based on a communication standard, such as WiFi, 2G or 3G, or a combination thereof. In an exemplary embodiment, the communication component 616 receives broadcast signals or broadcast related information from an external broadcast management system via a broadcast channel. In an exemplary embodiment, the communication component 616 further includes a Near Field Communication (NFC) module to facilitate short-range communications. For example, the NFC module may be implemented based on Radio Frequency Identification (RFID) technology, infrared data association (IrDA) technology, Ultra Wideband (UWB) technology, Bluetooth (BT) technology, and other technologies.
In an exemplary embodiment, the apparatus 600 may be implemented by one or more Application Specific Integrated Circuits (ASICs), Digital Signal Processors (DSPs), Digital Signal Processing Devices (DSPDs), Programmable Logic Devices (PLDs), Field Programmable Gate Arrays (FPGAs), controllers, micro-controllers, microprocessors or other electronic components for performing the above-described methods.
In an exemplary embodiment, a non-transitory computer readable storage medium comprising instructions, such as the memory 604 comprising instructions, executable by the processor 620 of the apparatus 600 to perform the above-described method is also provided. For example, the non-transitory computer readable storage medium may be a ROM, a Random Access Memory (RAM), a CD-ROM, a magnetic tape, a floppy disk, an optical data storage device, and the like.
Other embodiments of the invention herein will be apparent to those skilled in the art from consideration of the specification and practice of the invention disclosed herein. This application is intended to cover any variations, uses, or adaptations of the invention following, in general, the principles herein and including such departures from the present disclosure as come within known or customary practice in the art to which the invention pertains. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the disclosure being indicated by the following claims.
It will be understood that the present disclosure is not limited to the precise arrangements described above and shown in the drawings, and that various modifications and changes may be made without departing from the scope thereof. The scope of the present disclosure is to be limited only by the terms of the appended claims.
Claims (11)
1. A method for realizing asynchronous processing of components is characterized by comprising the following steps:
writing components in a development environment, the development environment including a runtime system and a common base component library;
compiling the components into a dependent file conforming to a target format; the target format refers to a format which can be directly introduced by a browser;
determining the corresponding relation between the components and the dependent files;
when the browser needs to refer to a component, the dependent file corresponding to the component to be referred to is called.
2. The method of claim 1,
the method further comprises the following steps:
constructing a software development kit; the software development kit comprises functions corresponding to the components;
the calling of the dependency file corresponding to the component to be referred comprises the following steps:
and calling a function corresponding to the component to be quoted in the software development kit, wherein the function is used for instantiating the component by using the dependency file corresponding to the component to be quoted.
3. The method of claim 2,
the method further comprises the following steps:
constructing a component distribution platform; the component distribution platform is used for distributing a dependent file corresponding to the identification of the component;
the building software development kit comprises:
and acquiring a dependency file corresponding to the component from the component distribution platform, and instantiating the component by using the dependency file.
4. The method of claim 1,
the method further comprises the following steps:
and packaging the developed components into modules for release, and setting the identifier of each component to comprise a combination of the name of the module and the name of the component.
5. The method of claim 4,
the method further comprises the following steps: when the developed components are packaged into modules and issued, the category of each component is declared, and when the category of the component is a structural formula and a transfer function is needed, the transfer parameters of the transfer function are also declared; the categories of the components include: structural formula and page formula.
6. An apparatus for implementing asynchronous processing of components, comprising:
a development module for writing components in a development environment, the development environment comprising a runtime system and a common base component library;
the compiling module is used for compiling the components into a dependent file conforming to a target format; the target format refers to a format which can be directly introduced by a browser;
the determining module is used for determining the corresponding relation between the components and the dependent files;
the first calling module is used for calling the dependent file corresponding to the component to be referred when the browser needs to refer to the component.
7. The apparatus of claim 6,
the device further comprises:
the first building module is used for building a software development kit; the software development kit comprises functions corresponding to the components;
the first calling module comprises:
and the second calling module is used for calling a function corresponding to the component to be quoted in the software development kit, and the function is used for instantiating the component by using the dependency file corresponding to the component to be quoted.
8. The apparatus of claim 7,
the device further comprises:
the second building module is used for building the component distribution platform; the component distribution platform is used for distributing a dependent file corresponding to the identification of the component;
the first building block comprises:
and the third building module is used for acquiring the dependency file corresponding to the component from the component distribution platform and instantiating the component by using the dependency file.
9. The apparatus of claim 6,
the device further comprises:
the release module is used for packaging the developed components into modules to release the modules;
and the setting module is used for setting the identification of each component to comprise a combination formed by the name of the module and the name of the component.
10. The apparatus of claim 9,
the device further comprises:
the declaration module is used for declaring the category of each component and declaring the transfer parameter of the transfer function when the category of the component is a structural formula and the transfer function is needed;
the categories of the components include: structural formula and page formula.
11. A non-transitory computer readable storage medium having instructions therein which, when executed by a processor of a mobile terminal, enable the mobile terminal to perform a method of implementing component asynchronization processing, the method comprising:
writing components in a development environment, the development environment including a runtime system and a common base component library; compiling the components into a dependent file conforming to a target format; the target format refers to a format which can be directly introduced by a browser;
determining the corresponding relation between the components and the dependent files;
when the browser needs to refer to a component, the dependent file corresponding to the component to be referred to is called.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911229945.XA CN111045682A (en) | 2019-12-04 | 2019-12-04 | Method, device and medium for realizing asynchronous processing of components |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911229945.XA CN111045682A (en) | 2019-12-04 | 2019-12-04 | Method, device and medium for realizing asynchronous processing of components |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN111045682A true CN111045682A (en) | 2020-04-21 |
Family
ID=70234666
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201911229945.XA Pending CN111045682A (en) | 2019-12-04 | 2019-12-04 | Method, device and medium for realizing asynchronous processing of components |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111045682A (en) |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107992723A (en) * | 2017-11-29 | 2018-05-04 | 南京莱斯信息技术股份有限公司 | A kind of Java protection of source codes methods based on dynamic link library |
| CN109189388A (en) * | 2018-08-15 | 2019-01-11 | 深圳市轱辘汽车维修技术有限公司 | Page configuration method, server and computer-readable medium |
| CN109670129A (en) * | 2018-11-27 | 2019-04-23 | 广东耐思智慧科技有限公司 | A kind of method and device for switching to html web page to be adapted to MIP format |
| CN109857405A (en) * | 2019-02-02 | 2019-06-07 | Oppo广东移动通信有限公司 | Compilation Method, device, storage medium and the terminal of application program installation kit |
-
2019
- 2019-12-04 CN CN201911229945.XA patent/CN111045682A/en active Pending
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107992723A (en) * | 2017-11-29 | 2018-05-04 | 南京莱斯信息技术股份有限公司 | A kind of Java protection of source codes methods based on dynamic link library |
| CN109189388A (en) * | 2018-08-15 | 2019-01-11 | 深圳市轱辘汽车维修技术有限公司 | Page configuration method, server and computer-readable medium |
| CN109670129A (en) * | 2018-11-27 | 2019-04-23 | 广东耐思智慧科技有限公司 | A kind of method and device for switching to html web page to be adapted to MIP format |
| CN109857405A (en) * | 2019-02-02 | 2019-06-07 | Oppo广东移动通信有限公司 | Compilation Method, device, storage medium and the terminal of application program installation kit |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN106569800B (en) | Front-end interface generation method and device | |
| CN109032606B (en) | Native application compiling method and device and terminal | |
| CN107423106B (en) | Method and apparatus for supporting multi-frame syntax | |
| CN109117144B (en) | Page processing method, device, terminal and storage medium | |
| CN111240694B (en) | Application detection method, application detection device and storage medium | |
| CN111736916A (en) | Dynamic expansion method and device based on Java language, electronic equipment and storage medium | |
| CN111222014B (en) | Request processing method, request processing device, electronic equipment and storage medium | |
| CN107463372B (en) | Data-driven page updating method and device | |
| CN110704053B (en) | Style information processing method and device | |
| CN110704030A (en) | Interface configuration information generation method and device, electronic equipment and storage medium | |
| EP3416070A1 (en) | Page display method and device and storage medium | |
| CN111090463A (en) | Resource identification method and device and computer storage medium | |
| CN111221613B (en) | Program calling method and device and storage medium | |
| CN111131000B (en) | Information transmission method, device, server and terminal | |
| CN111045682A (en) | Method, device and medium for realizing asynchronous processing of components | |
| CN114546436A (en) | Micro front-end service updating method and device, electronic equipment and storage medium | |
| CN112631695A (en) | Data verification method and device, electronic equipment and storage medium | |
| CN111597106A (en) | Point burying management method and device | |
| CN111596949B (en) | Method and device for developing application program | |
| CN112445484A (en) | Register processing method and device, electronic equipment and storage medium | |
| CN111240757B (en) | Quick application control method, device and storage medium | |
| CN113867992B (en) | Call chain resource isolation method and device, storage medium and electronic equipment | |
| CN113778385B (en) | Component registration method, device, terminal and storage medium | |
| CN111273910B (en) | Method, device and storage medium for acquiring resource number identifier | |
| CN114531493B (en) | Request processing method and device, electronic equipment and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |