CN111625234A - Page skeleton screen generation method, device and equipment and readable storage medium - Google Patents
Page skeleton screen generation method, device and equipment and readable storage medium Download PDFInfo
- Publication number
- CN111625234A CN111625234A CN201910151887.7A CN201910151887A CN111625234A CN 111625234 A CN111625234 A CN 111625234A CN 201910151887 A CN201910151887 A CN 201910151887A CN 111625234 A CN111625234 A CN 111625234A
- Authority
- CN
- China
- Prior art keywords
- nodes
- node
- visible
- page
- skeleton screen
- 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/30—Creation or generation of source code
- G06F8/38—Creation or generation of source code for implementing user interfaces
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/451—Execution arrangements for user interfaces
Abstract
The invention discloses a page skeleton screen generation method, a page skeleton screen generation device, page skeleton screen generation equipment and a readable storage medium. The method comprises the following steps: acquiring nodes in a visible area in a request page; determining an entry node of the request page; traversing the nodes from the entry node, determining visible nodes in the nodes, and generating DOM nodes used in a skeleton screen of the request page according to the visible nodes, so as to generate the skeleton screen containing the DOM nodes; wherein the element characteristics of each visible node conform to a preset condition.
Description
Technical Field
The invention relates to the technical field of webpage development, in particular to a method, a device and equipment for generating a page skeleton screen and a readable storage medium.
Background
The Skeleton Screen (Skeleton Screen) displays the rough structure of the page for the user before the page data is loaded, and renders the page after the request data is returned, and supplements the data content to be displayed. Compared with a traditional page loading (loading) mode, the skeleton screen can improve user experience to a certain extent and reduce scorching emotion of a user waiting for page loading.
At present, there are several methods for generating skeleton screens:
one approach is to write skeletal screen code using pictures, SVG (Scalable Vector Graphics), or manually. This method can generate a skeleton screen quickly using HTML + CSS (Cascading Style Sheets). However, in the face of the change of visual design and the change of requirements, the follow-up modification of the skeleton screen by the method is very passive, and the mode of mechanical repeated operation is insufficient in maneuverability and seriously affects the efficiency.
Another approach is to generate the corresponding skeleton screen by pre-rendering the manually written code. A more mature scheme in this method is vue-skeeleton-webpack-plugin, which is to insert a prerendered DOM (Document Object Model) node and related styles into the final output HTML by using vueSSR in combination with webpack to render a written vue (a set of progressive framework for constructing a user interface) skeleton screen component at the time of construction. The premise of the scheme is that the skeleton screen component of the corresponding page needs to be written, and then DOM nodes required by the skeleton screen are pre-rendered. But the solution has poor flexibility and controllability since it is directly related to vue related technology.
The other method is to seamlessly integrate with project development by a web-sketon-web-plug-in mode, and can start a User Interface (UI) to specially adjust the skeleton screen. However, this method is not satisfactory in the face of complex pages, and the generated skeleton screen nodes are based on the structure and CSS of the page itself, so that the situation that the nesting is deep exists, the size is not too small, and only the history mode (a routing mode of a single-page application based on HTML5 in the front) is supported.
The above information disclosed in this background section is only for enhancement of understanding of the background of the invention and therefore it may contain information that does not constitute prior art that is already known to a person of ordinary skill in the art.
Disclosure of Invention
In view of this, the invention provides a page skeleton screen generation method, device, equipment and readable storage medium.
Additional features and advantages of the invention will be set forth in the detailed description which follows, or may be learned by practice of the invention.
According to an aspect of the present invention, a method for generating a page skeleton screen is provided, including: acquiring nodes in a visible area in a request page; determining an entry node of the request page; traversing the nodes from the entry node, determining visible nodes in the nodes, and generating DOM nodes used in a skeleton screen of the request page according to the visible nodes, so as to generate the skeleton screen containing the DOM nodes; wherein the element characteristics of each visible node conform to a preset condition.
According to an embodiment of the present invention, the preset condition includes: non-hidden elements, elements with width and height greater than 0, non-transparent elements, elements with content not being spaces, and some or all of the elements located in the visible area of the browse window.
According to an embodiment of the present invention, traversing the nodes from the entry node, determining a visible node in the nodes, and generating a DOM node for a skeleton screen of the request page according to the visible node includes: traversing the nodes from the entry node through a JavaScript program, determining visible nodes in the nodes, and generating DOM nodes used in a skeleton screen of the request page according to the visible nodes.
According to an embodiment of the present invention, acquiring a node in a visible area in a requested page includes: receiving a page request about the request page input by a user; and accessing the request page to acquire the node in the visible area of the request page.
According to an embodiment of the present invention, accessing the request page to obtain a node in a visible area of the request page includes: and accessing the request page by using a puppeteer tool as a crawler to acquire the nodes in the visible area of the request page.
According to an embodiment of the present invention, generating a DOM node for use in a skeleton screen of the request page according to the visible node includes: calculating the area information of the area occupied by the visible node; generating a corresponding color block according to the region information, thereby generating a DOM node containing the color block; wherein the region information includes: the width, height, and absolute distance of the region from the viewport.
According to an embodiment of the invention, the visible node comprises: some or all of the picture, text, form items, audio and video nodes.
According to another aspect of the present invention, there is provided a page skeleton screen generating apparatus, including: the node acquisition module is used for acquiring nodes in a visible area in a request page; the entry determining module is used for determining an entry node of the request page; the node generation module is used for traversing the nodes from the entry node, determining visible nodes in the nodes, and generating DOM nodes used in a skeleton screen of the request page according to the visible nodes so as to generate the skeleton screen containing the DOM nodes; wherein the element characteristics of each visible node conform to a preset condition.
According to still another aspect of the present invention, there is provided a computer apparatus comprising: a memory, a processor and executable instructions stored in the memory and executable in the processor, the processor implementing any of the methods described above when executing the executable instructions.
According to yet another aspect of the present invention, there is provided a computer-readable storage medium having stored thereon computer-executable instructions which, when executed by a processor, implement any of the methods described above.
According to the page framework screen generation method, the framework screen containing the flattened DOM nodes can be automatically generated according to the content of the request page, the size is small, and the simple DOM rendering is adopted without additional network requests; in addition, the method can improve the page loading performance and optimize the user experience. The method and the device can improve the user experience of the single-page application, and can be compatible with various single-page application modes.
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 above and other objects, features and advantages of the present invention will become more apparent by describing in detail exemplary embodiments thereof with reference to the attached drawings.
FIG. 1 is a flowchart illustrating a method for generating a page skeleton screen according to an exemplary embodiment.
FIG. 2 is a block diagram illustrating a page skeleton screen generation apparatus in accordance with an exemplary embodiment.
FIG. 3 is a block diagram illustrating a computer system in accordance with an exemplary embodiment.
Detailed Description
Example embodiments will now be described more fully with reference to the accompanying drawings. Example embodiments may, however, be embodied in many different forms and should not be construed as limited to the examples set forth herein; rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the concept of example embodiments to those skilled in the art. The drawings are merely schematic illustrations of the invention and are not necessarily drawn to scale. The same reference numerals in the drawings denote the same or similar parts, and thus their repetitive description will be omitted.
Furthermore, the described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments. In the following description, numerous specific details are provided to provide a thorough understanding of embodiments of the invention. One skilled in the relevant art will recognize, however, that the invention may be practiced without one or more of the specific details, or with other methods, components, devices, steps, and so forth. In other instances, well-known structures, methods, devices, implementations, or operations are not shown or described in detail to avoid obscuring aspects of the invention.
Further, in the description of the present invention, "a plurality" means at least two, e.g., two, three, etc., unless specifically limited otherwise.
FIG. 1 is a flowchart illustrating a method for generating a page skeleton screen according to an exemplary embodiment. The method as shown in fig. 1 may be performed by a client, such as a browser, for example, or may also be performed in a command line.
Referring to fig. 1, a page skeleton screen generation method 10 includes:
in step S102, a node in the visible area in the request page is obtained.
And acquiring nodes in a visible area in a page requested by a user. In some embodiments, a user-entered page request (e.g., http request) for the requested page may be first received, and then page information for the requested page, including node information in its visible region, may be crawled from a requesting background server according to the page request. For example, the page information may be crawled through a crawler tool puppeteer.
Puppieneer is a Node library of google official products that controls the interface-less (thread) Chrome via the DevTools protocol. Chrome can be directly controlled through an interface provided by Puppeteer, and most user operations are simulated to be used as crawlers to access pages to collect and acquire data.
In step S104, an entry node of the request page is determined.
For example, a rootNode is determined as an entry node, such as a document. Meanwhile, the method is convenient to expand to a local skeleton screen in the generated page, and is convenient to automatically generate and implant into a page specified by a project.
In step S106, all the acquired nodes are traversed from the entry node, a visible node in all the nodes is determined, and a DOM node used in the skeleton screen of the request page is generated according to the visible node, thereby generating the skeleton screen including the DOM node.
Wherein the element characteristics of each visible node conform to a preset condition. In some embodiments, the preset condition may include, for example: non-hidden elements, elements with width and height greater than 0, non-transparent elements, elements with content not being spaces, and some or all of the elements located in the visible area of the browse window.
For example, the node traversal and DOM node generation operations can be performed by a JavaScript script program written in advance and capable of running in a browser. The JavaScript script program written in advance can be injected into the request page, so that when the request page is run, the operation of traversing all the acquired nodes from the entry node, determining visible nodes in the nodes, and generating a DOM node of the framework screen of the request page according to the visible nodes is executed. The native JavaScript script has good compatibility and strong expandability, and can not depend on a specific framework.
During the process of traversing all the acquired nodes, invisible nodes can be preliminarily eliminated, and then the nodes are traversed according to the hierarchy to screen out visible nodes with element characteristics meeting the preset conditions. These visible nodes may include, for example: some or all of the picture, text, form items, audio and video nodes.
And generating a DOM node of the request page used in the skeleton screen according to the screened visible node with the element characteristics meeting the preset conditions, thereby generating the skeleton screen containing the DOM node.
Specifically, for example, area information of an area occupied by each visible node may be calculated first, and then, according to the area information, a corresponding color block may be generated, thereby generating a DOM node including the color block. The area information may include, for example: the width, height, and absolute distance of the region from the viewport. When the color block is generated, corresponding color blocks are generated in a way of looking at the same way for the area occupied by the visible nodes meeting the preset conditions. That is, the color blocks of the DIV are generated uniformly according to the calculated region information, regardless of the structure level and regardless of the style. The DOM node generated in the way is flat and small in size, and meanwhile, the appearance of the skeleton screen can be maintained by avoiding extra reading of the style sheet and drawing of the style. The unified generation mode enables the nodes of the skeleton screen to be more controllable.
After the DOM nodes containing the color blocks are generated, the color blocks are spliced to generate a skeleton screen containing the flattened DOM nodes, namely the skeleton screen generated by the method is spliced by pure DOM color blocks.
According to the page skeleton screen generation method provided by the embodiment of the invention, the skeleton screen containing the flattened DOM nodes can be automatically generated according to the content of the request page, the volume is small, and the simple DOM rendering is adopted without additional network requests; in addition, the method can improve the page loading performance and optimize the user experience. The method and the device can improve the user experience of the single-page application, and can be compatible with various single-page application modes.
It should be clearly understood that the present disclosure describes how to make and use particular examples, but the principles of the present disclosure are not limited to any details of these examples. Rather, these principles can be applied to many other embodiments based on the teachings of the present disclosure.
Those skilled in the art will appreciate that all or part of the steps implementing the above embodiments are implemented as computer programs executed by a CPU. The computer program, when executed by the CPU, performs the functions defined by the method provided by the present invention. The program may be stored in a computer readable storage medium, which may be a read-only memory, a magnetic or optical disk, or the like.
Furthermore, it should be noted that the above-mentioned figures are only schematic illustrations of the processes involved in the method according to exemplary embodiments of the invention, and are not intended to be limiting. It will be readily understood that the processes shown in the above figures are not intended to indicate or limit the chronological order of the processes. In addition, it is also readily understood that these processes may be performed synchronously or asynchronously, e.g., in multiple modules.
The following are embodiments of the apparatus of the present invention that may be used to perform embodiments of the method of the present invention. For details which are not disclosed in the embodiments of the apparatus of the present invention, reference is made to the embodiments of the method of the present invention.
FIG. 2 is a block diagram illustrating a page skeleton screen generation apparatus in accordance with an exemplary embodiment.
Referring to fig. 2, the page skeleton screen generating apparatus 20 includes: a node acquisition module 202, an entry determination module 204, and a node generation module 206.
The node obtaining module 202 is configured to obtain a node in a visible area in a request page.
The entry determination module 204 is configured to determine an entry node of the requested page.
The node generation module 206 is configured to traverse all the acquired nodes from the entry node, determine visible nodes in all the nodes, and generate a DOM node, which is used in the skeleton screen, of the request page according to the visible nodes, so as to generate the skeleton screen including the DOM node;
wherein the element characteristics of each visible node conform to a preset condition.
In some embodiments, the preset conditions include: non-hidden elements, elements with width and height greater than 0, non-transparent elements, elements with content not being spaces, and some or all of the elements located in the visible area of the browse window.
In some embodiments, the node generation module 206 includes: and the node generation unit is used for traversing the nodes from the entry node through a JavaScript program, determining visible nodes in the nodes and generating DOM nodes of the request page for the framework screen according to the visible nodes.
In some embodiments, the node acquisition module 202 includes: a request receiving unit and a node obtaining unit. The request receiving unit is used for receiving a page request which is input by a user and is related to the requested page. The node acquiring unit is used for accessing the page request to acquire the node in the visible area of the requested page.
In some embodiments, the node acquisition unit comprises: and the node acquiring subunit is used for accessing the request page by using a puppeteer tool as a crawler to acquire the node in the visible area of the request page.
In some embodiments, the node generation module 206 includes: an area calculation unit and a color block generation unit. The area calculation unit is used for calculating area information of the area occupied by the visible node. The color generation unit is used for generating a corresponding color block according to the region information, so as to generate a DOM node containing the color block. Wherein the region information includes: the width, height, and absolute distance of the region from the viewport.
In some embodiments, the visible node comprises: some or all of the picture, text, form items, audio and video nodes.
According to the page skeleton screen generation device provided by the embodiment of the invention, the skeleton screen containing the flattened DOM nodes can be automatically generated according to the content of the request page, the volume is small, and the simple DOM rendering is adopted without additional network requests; in addition, the method can improve the page loading performance and optimize the user experience. The method and the device can improve the user experience of the single-page application, and can be compatible with various single-page application modes.
It is noted that the block diagrams shown in the above figures are functional entities and do not necessarily correspond to physically or logically separate entities. These functional entities may be implemented in the form of software, or in one or more hardware modules or integrated circuits, or in different networks and/or processor devices and/or microcontroller devices.
FIG. 3 is a block diagram illustrating a computer system in accordance with an exemplary embodiment. It should be noted that the computer system shown in fig. 3 is only an example, and should not bring any limitation to the function and the scope of the application of the embodiment of the present invention.
As shown in fig. 3, the computer system 800 includes a Central Processing Unit (CPU)801 that can perform various appropriate actions and processes in accordance with a program stored in a Read Only Memory (ROM)802 or a program loaded from a storage section 808 into a Random Access Memory (RAM) 803. In the RAM 803, various programs and data necessary for the operation of the system 800 are also stored. The CPU 801, ROM 802, and RAM 803 are connected to each other via a bus 804. An input/output (I/O) interface 805 is also connected to bus 804.
The following components are connected to the I/O interface 805: an input portion 806 including a keyboard, a mouse, and the like; an output section 807 including a signal such as a Cathode Ray Tube (CRT), a Liquid Crystal Display (LCD), and the like, and a speaker; a storage portion 808 including a hard disk and the like; and a communication section 809 including a network interface card such as a LAN card, a modem, or the like. The communication section 809 performs communication processing via a network such as the internet. A drive 810 is also connected to the I/O interface 805 as necessary. A removable medium 811 such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, or the like is mounted on the drive 810 as necessary, so that a computer program read out therefrom is mounted on the storage section 808 as necessary.
In particular, according to an embodiment of the present invention, the processes described above with reference to the flowcharts may be implemented as computer software programs. For example, embodiments of the invention include a computer program product comprising a computer program embodied on a computer-readable medium, the computer program comprising program code for performing the method illustrated in the flow chart. In such an embodiment, the computer program can be downloaded and installed from a network through the communication section 809 and/or installed from the removable medium 811. The computer program executes the above-described functions defined in the system of the present invention when executed by the Central Processing Unit (CPU) 801.
It should be noted that the computer readable medium shown in the present invention can be a computer readable signal medium or a computer readable storage medium or any combination of the two. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples of the computer readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the present invention, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In the present invention, however, a computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wire, fiber optic cable, RF, etc., or any suitable combination of the foregoing.
The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams or flowchart illustration, and combinations of blocks in the block diagrams or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
The units described in the embodiments of the present invention may be implemented by software or hardware. The described units may also be provided in a processor, and may be described as: a processor includes a transmitting unit, an obtaining unit, a determining unit, and a first processing unit. The names of these units do not in some cases constitute a limitation to the unit itself, and for example, the sending unit may also be described as a "unit sending a picture acquisition request to a connected server".
As another aspect, the present invention also provides a computer-readable medium that may be contained in the apparatus described in the above embodiments; or may be separate and not incorporated into the device. The computer readable medium carries one or more programs which, when executed by a device, cause the device to comprise:
acquiring nodes in a visible area in a request page;
determining an entry node of the request page; and
traversing the nodes from the entry node, determining visible nodes in the nodes, and generating DOM nodes used in a skeleton screen of the request page according to the visible nodes, thereby generating the skeleton screen containing the DOM nodes;
wherein the element characteristics of each visible node conform to a preset condition.
Exemplary embodiments of the present invention are specifically illustrated and described above. It is to be understood that the invention is not limited to the precise construction, arrangements, or instrumentalities described herein; on the contrary, the invention is intended to cover various modifications and equivalent arrangements included within the spirit and scope of the appended claims.
Claims (10)
1. A page skeleton screen generation method is characterized by comprising the following steps:
acquiring nodes in a visible area in a request page;
determining an entry node of the request page; and
traversing the nodes from the entry node, determining visible nodes in the nodes, and generating DOM nodes used in a skeleton screen of the request page according to the visible nodes, thereby generating the skeleton screen containing the DOM nodes;
wherein the element characteristics of each visible node conform to a preset condition.
2. The method according to claim 1, wherein the preset condition comprises: non-hidden elements, elements with width and height greater than 0, non-transparent elements, elements with content not being spaces, and some or all of the elements located in the visible area of the browse window.
3. The method of claim 1, wherein traversing the nodes from the entry node, determining visible nodes of the nodes, and generating a DOM node for the requested page in the skeletal screen from the visible nodes comprises: traversing the nodes from the entry node through a JavaScript program, determining visible nodes in the nodes, and generating DOM nodes used in a skeleton screen of the request page according to the visible nodes.
4. The method of claim 1, wherein obtaining nodes in the visible area of the requested page comprises:
receiving a page request about the request page input by a user; and
and accessing the request page to acquire the nodes in the visible area of the request page.
5. The method of claim 4, wherein accessing the requested page to obtain nodes within a visible area of the requested page comprises: and accessing the request page by using a puppeteer tool as a crawler to acquire the nodes in the visible area of the request page.
6. The method of claim 1, wherein generating a DOM node for the requested page in a skeletal screen from the visible node comprises:
calculating the area information of the area occupied by the visible node; and
generating a corresponding color block according to the region information, thereby generating a DOM node containing the color block;
wherein the region information includes: the width, height, and absolute distance of the region from the viewport.
7. The method of claim 1, wherein the visible node comprises: some or all of the picture, text, form items, audio and video nodes.
8. A page skeleton screen generation device, comprising:
the node acquisition module is used for acquiring nodes in a visible area in a request page;
the entry determining module is used for determining an entry node of the request page; and
a node generation module, configured to traverse the nodes from the entry node, determine a visible node in the nodes, and generate a DOM node, which is used in a skeleton screen, of the request page according to the visible node, so as to generate the skeleton screen including the DOM node;
wherein the element characteristics of each visible node conform to a preset condition.
9. A computer device, comprising: memory, processor and executable instructions stored in the memory and executable in the processor, characterized in that the processor implements the method according to any of claims 1-7 when executing the executable instructions.
10. A computer-readable storage medium having stored thereon computer-executable instructions, which when executed by a processor, implement the method of any one of claims 1-7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910151887.7A CN111625234A (en) | 2019-02-28 | 2019-02-28 | Page skeleton screen generation method, device and equipment and readable storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910151887.7A CN111625234A (en) | 2019-02-28 | 2019-02-28 | Page skeleton screen generation method, device and equipment and readable storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN111625234A true CN111625234A (en) | 2020-09-04 |
Family
ID=72272459
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910151887.7A Pending CN111625234A (en) | 2019-02-28 | 2019-02-28 | Page skeleton screen generation method, device and equipment and readable storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111625234A (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112286525A (en) * | 2020-09-25 | 2021-01-29 | 长沙市到家悠享网络科技有限公司 | Skeleton screen generation method, device and equipment |
| CN113076504A (en) * | 2021-06-03 | 2021-07-06 | 北京达佳互联信息技术有限公司 | Skeleton screen generation method, device, equipment and storage medium |
-
2019
- 2019-02-28 CN CN201910151887.7A patent/CN111625234A/en active Pending
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112286525A (en) * | 2020-09-25 | 2021-01-29 | 长沙市到家悠享网络科技有限公司 | Skeleton screen generation method, device and equipment |
| CN113076504A (en) * | 2021-06-03 | 2021-07-06 | 北京达佳互联信息技术有限公司 | Skeleton screen generation method, device, equipment and storage medium |
| CN113076504B (en) * | 2021-06-03 | 2021-10-01 | 北京达佳互联信息技术有限公司 | Skeleton screen generation method, device, equipment and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US11030392B2 (en) | Optimization for rendering web pages | |
| CN106991154B (en) | Webpage rendering method and device, terminal and server | |
| US10346013B2 (en) | Manipulating graphical objects | |
| US8194075B2 (en) | Method and system for generating and displaying an interactive dynamic list view of multiply connected objects | |
| US8886669B2 (en) | File access via conduit application | |
| EP3896567A1 (en) | Page pre-rendering method and apparatus, electronic device, and storage medium | |
| CN111209721A (en) | Bitmap font realization method and device, electronic equipment and storage medium | |
| CN110874172B (en) | Method, device, medium and electronic equipment for amplifying APP interface | |
| CN111767100A (en) | Image processing method, device, system and medium applied to browser | |
| CN111625234A (en) | Page skeleton screen generation method, device and equipment and readable storage medium | |
| CN113688341B (en) | Dynamic picture decomposition method and device, electronic equipment and readable storage medium | |
| US9501812B2 (en) | Map performance by dynamically reducing map detail | |
| US10614158B2 (en) | Methods and systems for state-based web framework architecture | |
| CN115268904A (en) | User interface design file generation method, device, equipment and medium | |
| CN111460342B (en) | Page rendering display method and device, electronic equipment and computer storage medium | |
| CN113010582A (en) | Data processing method and device, computer readable medium and electronic equipment | |
| CN115391692A (en) | Video processing method and device | |
| CN113676677A (en) | Dynamic picture synthesis method and device, electronic equipment and readable storage medium | |
| EP3298507A1 (en) | Document presentation qualified by conditions evaluated on rendering | |
| CN106991167B (en) | Web application migration method and device | |
| CN112418902A (en) | Multimedia synthesis method and system based on webpage | |
| EP2883214B1 (en) | Manipulating graphical objects | |
| CN109710355B (en) | WEB interaction-based TIP display content processing method and device and electronic equipment | |
| CN113947651A (en) | Vector animation generation method, device, system, equipment and storage medium | |
| CN115526951A (en) | Flow chart drawing method, apparatus, storage medium, and program product |
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 |