CN115328478A - Page embedding method, device, electronic device and medium - Google Patents

Abstract

The disclosure provides a page point burying method, a page point burying device, electronic equipment and a medium, wherein the method comprises the following steps: acquiring a first page file and setting information, wherein the setting information comprises at least one key value pair, an attribute key in each key value pair is an element identifier, and the attribute value is a buried point identifier; for any key value pair, determining a to-be-buried point element corresponding to an element identifier in the key value pair from the first page file; adding a buried point event corresponding to a buried point identifier in a key value pair to a to-be-buried point element in a first page file; writing the set embedded point function into a first page file, and writing each embedded point identifier into the embedded point function to obtain a target page file; and the embedded point function is used for acquiring user behavior information associated with the corresponding embedded point event according to each embedded point identifier. Therefore, the embedded points can be automatically added to the elements of the to-be-embedded points in the page file, developers do not need to manually add the embedded points to the elements of the page, the workload of the developers can be reduced, and the development efficiency of the page is improved.

Description

Page embedding method, device, electronic equipment and medium

technical field

The present disclosure relates to the technical field of the Internet, and in particular to a method, device, electronic equipment and media for burying a page.

Background technique

Pages or APPs (Applications) can collect user behavior information using point-buying technology, so as to make precise recommendations to users based on user behavior information, improve user activity and increase user volume.

In the related technology, the developer manually sets the buried point in the page or APP. However, due to the large number of DOM (Document Object Model, Document Object Model) elements that need to be embedded in the page, manual embedding requires a large amount of code and low development efficiency.

Contents of the invention

The present disclosure aims to solve one of the technical problems in the related art at least to a certain extent.

The present disclosure proposes a page burying method, device, electronic equipment, and media to automatically add burying points for each element to be burying in a page file, without the need for developers to manually add burying points for each page element, which can reduce the cost of developers. workload and improve page development efficiency.

The embodiment of the first aspect of the present disclosure proposes a page burying method, including:

Obtaining the first page file and setting information, wherein the setting information includes at least one key-value pair, the attribute key in each key-value pair is an element identifier, and the attribute value is a buried point identifier;

For any of the key-value pairs, determine from the first page file the element to be embedded corresponding to the element identifier in the key-value pair;

For the element to be buried in the first page file, add a buried point event corresponding to the buried point identifier in the key-value pair;

Writing the set buried point function into the first page file, and writing each buried point identifier into the buried point function to obtain the target page file; wherein, the buried point function is used for According to each buried point identifier, user behavior information associated with a corresponding buried point event is collected.

The embodiment of the second aspect of the present disclosure proposes a page embedding device, including:

An acquisition module, configured to acquire the first page file and setting information, wherein the setting information includes at least one key-value pair, the attribute key in each key-value pair is an element identifier, and the attribute value is a buried point identifier;

A determining module, configured to, for any of the key-value pairs, determine from the first page file the element to be embedded corresponding to the element identifier in the key-value pair;

An adding module, configured to add a buried point event corresponding to the buried point identifier in the key-value pair to the to-be-buried point element in the first page file;

A writing module, configured to write the set buried point function into the first page file, and write each buried point identifier into the buried point function to obtain the target page file; wherein, the The buried point function is used to collect user behavior information associated with the corresponding buried point event according to each buried point identifier.

The embodiment of the third aspect of the present disclosure proposes an electronic device, including: at least one processor; and a memory connected in communication with the at least one processor; wherein, the memory stores information that can be executed by the at least one processor. instructions, the instructions are executed by the at least one processor, so that the at least one processor can execute the page buried method proposed in the embodiment of the first aspect of the present disclosure.

The embodiment of the fourth aspect of the present disclosure provides a non-transitory computer-readable storage medium storing computer instructions, the computer instructions are used to enable the computer to execute the page burying method proposed by the embodiment of the first aspect of the present disclosure.

The embodiment of the fifth aspect of the present disclosure provides a computer program, including a computer program. When the computer program is executed by a processor, the page burying method described in the embodiment of the first aspect of the present disclosure is implemented.

An embodiment of the above-mentioned present disclosure has at least the following advantages or beneficial effects:

By obtaining the first page file and setting information, wherein the setting information includes at least one key-value pair, the attribute key in each key-value pair is an element identifier, and the attribute value is a buried point identifier; for any key-value pair, from Determine the element to be buried point corresponding to the element identifier in the key-value pair in the first page file; add the buried point event corresponding to the buried point identifier in the key-value pair to the buried point element in the first page file; The set buried point function is written into the first page file, and each buried point identifier is written into the buried point function to obtain the target page file; wherein, the buried point function is used to collect the corresponding buried point according to each buried point identifier User behavior information associated with the event. In this way, it is possible to automatically add embedding points for each element to be embedding in the page file, without the need for developers to manually add embedding points for each page element, which can reduce the workload of developers and improve the development efficiency of the page.

Additional aspects and advantages of the disclosure will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of the disclosure.

Description of drawings

The above and/or additional aspects and advantages of the present disclosure will become apparent and understandable from the following description of the embodiments in conjunction with the accompanying drawings, wherein:

FIG. 1 is a schematic flow chart of a page burying method provided in Embodiment 1 of the present disclosure;

FIG. 2 is a schematic flow chart of the page embedding method provided by Embodiment 2 of the present disclosure;

FIG. 3 is a schematic flow chart of the page embedding method provided by Embodiment 3 of the present disclosure;

FIG. 4 is a schematic diagram of a buried point adding process provided by an embodiment of the present disclosure;

FIG. 5 is a schematic flow chart of the page burying method provided by Embodiment 4 of the present disclosure;

FIG. 6 is a schematic structural diagram of a page embedding device provided in Embodiment 5 of the present disclosure;

FIG. 7 shows a block diagram of an exemplary electronic device suitable for use in implementing embodiments of the present disclosure.

Detailed ways

Embodiments of the present disclosure are described in detail below, examples of which are illustrated in the drawings, in which the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below by referring to the figures are exemplary and are intended to explain the present disclosure and should not be construed as limiting the present disclosure.

Due to the rapid development of big data technology, the acquisition of big data has become particularly urgent. At present, in some web sites or APPs, operators are collecting more and more data, so as to analyze user behavior habits and hobbies based on the collected data, so as to better optimize wab and APP based on the analysis results. Optimization. Among them, the most effective way to collect user behavior habits is to bury points. Therefore, a large number of burying points are configured in each web and APP.

In related technologies, buried points can be added to the page in the following two ways:

The first way is to bury the point by setting JSSDK (JavaScript Software Development Kit, JavaScript Software Development Kit). When the developer clicks or enters the page, he manually calls the burying function and passes the data into the burying function. Call the back-end interface to achieve the purpose of burying the point.

The second method is to bury points by setting custom attributes. When the page is rendered, query all DOM elements with custom attributes, and manually add click events for burying points in the above DOM elements to add burying points , and transmit the buried point data to the backend.

However, in the above-mentioned first method of manually calling the buried point function, developers need to manually input a large amount of code, which is not only cumbersome to write, but also causes code redundancy.

The above-mentioned second method of manually adding buried points not only requires developers to add buried points to each DOM element in turn, but also is not conducive to later page upgrade and maintenance.

In view of at least one of the above-mentioned problems, the present disclosure proposes a page embedding method, device, electronic equipment, and storage medium.

The method, device, electronic device, and storage medium of the embodiments of the present disclosure will be described below with reference to the accompanying drawings. Before specifically describing the embodiments of the present disclosure, for ease of understanding, firstly, commonly used technical terms are introduced:

Buried point: It is a commonly used data collection method for website analysis. Data embedding points are divided into three ways: primary, intermediate, and advanced. Data burying is a good way to collect data for privatization deployment.

Webpack: The core concept of Webpack is a static resource packager for JavaScript. Its main goal is to package js files together, and the packaged files are used in browsers. Webpack is also capable of conversion, packaging and other functions.

Puppeteer: Puppeteer is an automated testing tool that can be set up to control a full (non-headless) browser.

FIG. 1 is a schematic flow chart of a page burying method provided by Embodiment 1 of the present disclosure.

Embodiments of the present disclosure are illustrated by taking the page tracking method configured in a page tracking device as an example, and the page tracking device can be applied to any electronic device, so that the electronic device can perform a page tracking function.

Among them, the electronic device can be any device with computing power, such as a computer, a mobile terminal, a server, etc., and the mobile terminal can be a mobile phone, a tablet computer, a personal digital assistant, a wearable device, a vehicle-mounted device, etc. Hardware devices for systems, touchscreens, and/or displays.

As shown in Figure 1, the page burying method may include the following steps:

Step 101, acquire the first page file and setting information, wherein the setting information includes at least one key-value pair, the attribute key in each key-value pair is an element identifier, and the attribute value is a buried point identifier.

In the embodiment of the present disclosure, the first page file and setting information may be provided for developers, wherein the setting information includes at least one key-value pair, wherein the attribute key key in each key-value pair is an element identifier , the attribute value value is the buried point identifier.

As an example, a developer can add a unique element identifier for an element that needs to be buried in the page file (that is, the element to be embedded) during page development, where the element identifier can be a digital identifier, or can also be The identification may be in the form of letters, or may also be in the form of a combination of letters and numbers, or may also be in the form of a character string, etc., which is not limited in the present disclosure.

In addition, the developer can also set a corresponding buried point identifier for the element to be embedded, where the buried point identifier can also be a digital identifier, or a letter identifier, or a combination of letters and numbers , or may be an identifier in the form of a character string, etc., which is not limited in the present disclosure. Therefore, in the present disclosure, the element identifier can be used as the attribute key, the buried point identifier can be used as the attribute value, and a key-value pair can be generated according to the key and value.

Step 102, for any key-value pair, determine from the first page file the element to be embedded corresponding to the element identifier in the key-value pair.

In the embodiment of the present disclosure, for any key-value pair in the at least one key-value pair, the point element to be buried corresponding to the element identifier in the key-value pair may be determined from the first page file.

Step 103, add a buried point event corresponding to the buried point identifier in the key-value pair to the to-be-buried point element in the first page file.

In the embodiment of the present disclosure, the point-burying event may be a point-burying click event, a slide event, etc., which is not limited in the present disclosure.

In the embodiment of the present disclosure, a burying event corresponding to the burying point identifier in the above key-value pair may be added to the burying point element in the first page file.

Step 104, write the set buried point function into the first page file, and write each buried point identifier into the buried point function to obtain the target page file; wherein, the buried point function is used to collect User behavior information associated with the corresponding buried event.

In the embodiment of the present disclosure, the buried point function is preset.

In the embodiments of the present disclosure, user behavior information refers to relevant information obtained by statistics of user behaviors, where user behaviors may include actions such as clicking, acting, dragging, long pressing, commenting, following, saving, sharing, and the like. For example, user behavior information may include the number of clicks, views, comments, attention, favorites, shares, etc.

In the embodiment of the present disclosure, the set buried point function may be written into the first page file, and the buried point identifiers in each key-value pair may be written or passed into the buried point function, so as to obtain the target page file. Among them, the buried point function is used to collect the user behavior information associated with the buried point event corresponding to each buried point identifier, that is, in this disclosure, the buried point function is used to collect the buried point corresponding to each buried point function according to each buried point identifier. User behavior information associated with point events.

The page burying method of the embodiment of the present disclosure obtains the first page file and setting information, wherein the setting information includes at least one key-value pair, the attribute key in each key-value pair is an element identifier, and the attribute value is Buried point identification; for any key-value pair, determine the element to be buried point corresponding to the element ID in the key-value pair from the first page file; The buried point event corresponding to the buried point identifier; the set buried point function is written into the first page file, and each buried point mark is written into the buried point function to obtain the target page file; wherein, the buried point function is used according to Each buried point is identified, and the user behavior information associated with the corresponding buried point event is collected. In this way, it is possible to automatically add embedding points for each element to be embedding in the page file, without the need for developers to manually add embedding points for each page element, which can reduce the workload of developers and improve the development efficiency of the page.

It should be noted that the collection, storage, use, processing, transmission, provision, and disclosure of user personal information involved in the technical solution of the disclosure is in compliance with relevant laws and regulations, and does not violate public order and good customs.

In order to clearly illustrate how to determine the elements to be buried from the first page file in the above embodiments of the present disclosure, the present disclosure also proposes a page burying method.

FIG. 2 is a schematic flow chart of a page burying method provided by Embodiment 2 of the present disclosure.

As shown in Figure 2, the page burying method may include the following steps:

Step 201, acquire the first page file and setting information, wherein the setting information includes at least one key-value pair, the attribute key in each key-value pair is an element identifier, and the attribute value is a buried point identifier.

For the explanation of step 201, reference may be made to relevant descriptions in any embodiment of the present disclosure, and details are not repeated here.

In any embodiment of the present disclosure, the second page file in the first format provided by the developer may be obtained, and the second page file may be packaged to obtain the first page file in the second format.

It should be noted that the user may not be able to directly access the page file provided by the developer. Therefore, in this disclosure, in order to enable the user to normally access the page file provided by the developer, the above page file can be packaged to obtain a user-accessible paging file. Specifically, the second page file in the first format provided by the developer may be packaged to obtain the first page file in the second format, and the first page file is a page file accessible to users. For example, the second page file may be a js file provided by the developer, and the first page file may be a packaged HTML (Hyper Text Markup Language, hypertext markup language) file accessible to users.

As an example, the second page file may be packaged by the static resource packer Webpack to obtain the first page file.

Step 202, access the first page file through the browser.

In the embodiment of the present disclosure, the first page file can be accessed through a browser.

As an example, a browser may be opened by an automated testing tool (such as a Puppeteer tool), and the first page file may be accessed.

Step 203, for any key-value pair, traverse each page element in the first page file to determine from each page element the point element to be buried corresponding to the element identifier in the key-value pair.

In the embodiment of the present disclosure, for any key-value pair in the setting information, each page element in the first page file can be traversed to determine the to-be-embedded element corresponding to the element identifier in the key-value pair from each page element point element.

Still using the above example as an example, an automated testing tool (such as a Puppeteer tool) can be used to traverse each page element (such as a DOM element) in the first page file, and determine from each page element the corresponding element identifier in the key-value pair Elements to be embedded.

Step 204, add a burying event corresponding to the burying point identifier in the key-value pair to the burying point element in the first page file.

Step 205, write the set buried point function into the first page file, and write each buried point identifier into the buried point function, so as to obtain the target page file.

Wherein, the buried point function is used to collect user behavior information associated with a corresponding buried point event according to each buried point identifier.

For explanations of steps 204 to 205, reference may be made to relevant descriptions in any embodiment of the present disclosure, and details are not repeated here.

The page burying method of the embodiment of the present disclosure, by traversing each page element in the first page file, determines the element to be buried corresponding to the element identifier in each key-value pair from each page element, which can avoid Missing detection of elements to be buried, so as to avoid the situation of missing and adding buried points on the page, so that the buried page can meet the actual development needs of developers and improve the developer's experience.

In order to clearly illustrate how to obtain the first page file in any embodiment of the present disclosure, an embodiment of the present disclosure further proposes a page burying method.

FIG. 3 is a schematic flow chart of a page burying method provided by Embodiment 3 of the present disclosure.

As shown in Figure 3, the page burying method may include the following steps:

Step 301 , obtaining setting information, wherein the setting information includes at least one key-value pair, the attribute key in each key-value pair is an element identifier, and the attribute value is a buried point identifier.

For an explanation of step 301, reference may be made to relevant descriptions in any embodiment of the present disclosure, and details are not repeated here.

Step 302, acquire the second page file in the first format.

In the embodiment of the present disclosure, the second page file in the first format is provided by the developer, and the second page file may be a code file that cannot be directly accessed by the user.

Step 303, pack the second page file.

As an example, the second page file may be packaged by using the static resource packager Webpack.

Step 304, monitor the packaging completion event of the second page file.

Step 305, in response to monitoring the package completion event, acquire the packaged first page file in the second format.

In the embodiment of the present disclosure, the packaging completion event (such as compiler.hooks.done.tap event) of the second page file can be monitored, and when the packaging completion event of the second page file is monitored, the packaged first page file can be obtained. The first page file of the second format.

Step 306, for any key-value pair, determine from the first page file the element to be embedded corresponding to the element identifier in the key-value pair.

Step 307, add a buried point event corresponding to the buried point identifier in the key-value pair to the to-be-buried point element in the first page file.

Step 308, write the set buried point function into the first page file, and write the buried point identifiers into the buried point function, so as to obtain the target page file.

Wherein, the buried point function is used to collect user behavior information associated with a corresponding buried point event according to each buried point identifier.

For explanations of steps 306 to 308, reference may be made to relevant descriptions in any embodiment of the present disclosure, and details are not repeated here.

As an example, when developing a page, a developer can add a custom attribute (that is, an element ID) to an element that needs to add a buried point in the page file, and the attribute value corresponding to the custom attribute is the buried point identifier (that is, the buried point ID) , so that at least one key-value pair can be generated based on the custom attribute and attribute value.

Take the example of using Webpack to package page files, as shown in Figure 4, you can pass each key-value pair into Webpack, and Webpack will package the page files provided by the developer. After listening to the page file packaging completion event When starting the static resource server to access the packaged page files, for example, you can use the Puppeteer tool to open the browser and access the packaged page files (such as HTML files), and then traverse all the page elements (DOM elements) in the HTML file ) to get all the DOM elements with custom attributes, after that, you can add embedded events (such as click events for embedded points) to DOM elements with custom attributes, and use the attribute values of custom attributes as buried The point identifier is passed into the buried point function to get the final HTML file.

Among them, due to the characteristics of the Puppeteer tool, the above burying method is suitable for multi-page applications. When Webpack packs page files, it can be set to a multi-page mode.

It should be noted that there may be the same page elements in the page file, and a unique identifier needs to be added to each page element. The reason why the unique identifier is a custom attribute set by the developer rather than the original identifier of the page element is: custom attribute It is only used for burying points to avoid conflicts with the business, that is, it does not conflict with or be mixed with business development.

Therefore, the combination of Webpack and Puppeteer can realize automatic injection and generate high-quality tracking events, minus the time and labor costs caused by development and post-maintenance, and can achieve the effect comparable to handwritten tracking. In addition, Webpack and Puppeteer automatically inject embedded events into page files, which can realize the configurability and generalization of embedded points, and can adapt to multiple terminals, so as to reduce the development costs of different users such as manpower and time.

That is to say, in this disclosure, by adding custom attributes to DOM elements to add embedded points, compared with the traditional method of writing embedded points, the writing efficiency is effectively improved, that is, compared to manually writing embedded points, it can be extremely Greatly improve the development efficiency of the page, reduce some meaningless mechanical labor, save a lot of development time, and facilitate later modification and maintenance; by combining Webpack and Puppeteer, the purpose of engineering injection buried point can be achieved, which can be well combined The existing mainstream engineering packaging tool Webpack simplifies developers' getting started and configuration costs; it is suitable for multi-terminal applications such as h5 and small programs, and is easy to maintain and upgrade, which improves the versatility of the method.

The page burying method of the embodiment of the present disclosure obtains the second page file in the first format; packages the second page file; monitors the package completion event of the second page file; and obtains The first page file in the second format obtained by packaging. In this way, the page file can be packaged into a user-accessible page file by means of packaging, so that the user can normally access the page file.

In order to clearly describe any of the above embodiments, the present disclosure also proposes a page burying method.

FIG. 5 is a schematic flow chart of a page burying method provided by Embodiment 4 of the present disclosure.

As shown in Figure 5, on the basis of any of the above-mentioned embodiments, the page burying method may also include the following steps:

Step 501, obtain the first page file and setting information, wherein the setting information includes at least one key-value pair, the attribute key in each key-value pair is an element identifier, and the attribute value is a buried point identifier.

For an explanation of step 501, reference may be made to relevant descriptions in any embodiment of the present disclosure, and details are not repeated here.

Step 502, inject configuration information into the first page file.

In an embodiment of the present disclosure, configuration information may be injected into the first page file, where the configuration information may be used to indicate at least one of the following:

The first item: the target interface of the buried function call; among them, the target interface is used to report user behavior information; that is, the configuration information is used to indicate which interface the buried function calls to report the collected user behavior information;

The second item: the calling method of the target interface; that is, the configuration information is used to indicate how the embedded function calls the target interface;

The third item: the target node to which the user behavior information is reported. The target node can be any node in the background system (that is, the backend); that is, the configuration information is used to instruct the buried point function to report the collected user behavior information to the backend. which node.

It should be noted that the present disclosure does not limit the timing of execution of step 502. For example, step 502 may be executed in parallel with steps 503-505, or step 502 may also be executed sequentially with steps 503-505, or may also be executed in the future After the point function is written into the first page file, the configuration information is injected into the first page file, or, after each buried point identifier is written into the buried point function, the configuration information is injected into the first page file, and so on. There is no limit to this.

Step 503, for any key-value pair, determine the element to be embedded corresponding to the element identifier in the key-value pair from the first page file.

Step 504, add a burying event corresponding to the burying point identifier in the key-value pair to the burying point element in the first page file.

Step 505, write the set buried point function into the first page file, and write each buried point identifier into the buried point function to obtain the target page file; wherein, the buried point function is used to collect The user behavior information associated with the corresponding buried event, and report the user behavior information.

For explanations of steps 503 to 505, reference may be made to relevant descriptions in any embodiment of the present disclosure, and details are not repeated here.

As an example, use Webpack to package page files, as shown in Figure 4, during the process of Webpack packaging page files provided by developers, listen to the page package completion event compiler.hooks.done.tap, and respond After listening to the packaging completion event, access the packaged page file, such as an HTML file, through a static resource server (such as a local node server), and inject the buried point JSSDK (that is, configuration information) into the HTML file, and then traverse the HTML file All page elements (DOM elements) in , get all the DOM elements with custom attributes, and add embedded events (such as embedded click events) to the DOM elements with custom attributes to get the final HTML file.

The page burying method of the embodiment of the present disclosure injects configuration information into the first page file; wherein the configuration information is used to indicate at least one of the following: the target interface of the burying function call, wherein the target interface is used to report to the user Behavior information; the calling method of the target interface; the target node to which user behavior information is reported. Therefore, by injecting configuration information into the page file, it is possible to instruct the embedded function how to report the collected user behavior information.

Corresponding to the page burying method provided by the above-mentioned embodiments in FIGS. 1 to 5 , the present disclosure also provides a page burying device. Therefore, the implementation of the page burying method is also applicable to the page burying device provided in the embodiments of the present disclosure, which will not be described in detail in the embodiments of the present disclosure.

FIG. 6 is a schematic structural diagram of a page embedding device provided by Embodiment 5 of the present disclosure.

As shown in FIG. 6 , the page embedding device 600 may include: an acquiring module 601 , a determining module 602 , an adding module 603 and a writing module 604 .

Wherein, the obtaining module 601 is used to obtain the first page file and setting information, wherein the setting information includes at least one key-value pair, the attribute key in each key-value pair is an element identifier, and the attribute value is a buried point identifier .

The determining module 602 is configured to, for any key-value pair, determine from the first page file the point element to be buried corresponding to the element identifier in the key-value pair.

The adding module 603 is configured to add a buried point event corresponding to the buried point identifier in the key-value pair to the to-be-buried point element in the first page file.

The writing module 604 is used to write the set buried point function into the first page file, and write each buried point identifier into the buried point function to obtain the target page file; wherein, the buried point function is used to Point identification, collect the user behavior information associated with the corresponding buried point event.

In a possible implementation manner of the embodiment of the present disclosure, the determination module is specifically configured to: access the first page file through a browser; traverse each page element in the first page file; determine and key value from each page element The element in the pair identifies the corresponding point element to be buried.

In a possible implementation manner of the embodiment of the present disclosure, the acquiring module is specifically configured to: acquire the second page file in the first format; pack the second page file to obtain the first page file in the second format.

In a possible implementation of the embodiment of the present disclosure, the acquisition module is specifically configured to: package the second page file; monitor the packaging completion event of the second page file; and acquire The first page file obtained by packaging.

In a possible implementation of the embodiment of the present disclosure, the burying function is also used to report user behavior information; the page burying device 600 may also include:

The injection module is used to inject configuration information into the first page file;

Among them, the configuration information is used to indicate at least one of the following:

The target interface of the buried point function call; among them, the target interface is used to report user behavior information;

The calling method of the target interface;

The target node to which user behavior information is reported.

The page embedding device of the embodiment of the present disclosure obtains the first page file and setting information, wherein the setting information includes at least one key-value pair, the attribute key in each key-value pair is an element identifier, and the attribute value is Buried point identification; for any key-value pair, determine the element to be buried point corresponding to the element ID in the key-value pair from the first page file; The buried point event corresponding to the buried point identifier; the set buried point function is written into the first page file, and each buried point mark is written into the buried point function to obtain the target page file; wherein, the buried point function is used according to Each buried point is identified, and the user behavior information associated with the corresponding buried point event is collected. In this way, it is possible to automatically add embedding points for each element to be embedding in the page file, without the need for developers to manually add embedding points for each page element, which can reduce the workload of developers and improve the development efficiency of the page.

In order to realize the above embodiments, the present disclosure also proposes an electronic device, including: a memory, a processor, and a computer program stored in the memory and operable on the processor. When the processor executes the program, the The page burying method proposed by any one of the foregoing embodiments is disclosed.

In order to realize the above-mentioned embodiments, the present disclosure also proposes a non-transitory computer-readable storage medium on which a computer program is stored, and when the program is executed by a processor, the page burying method as proposed in any of the foregoing embodiments of the present disclosure is implemented. .

In order to implement the above embodiments, the present disclosure further proposes a computer program product, when the instructions in the computer program product are executed by a processor, execute the page burying method as provided in any one of the foregoing embodiments of the present disclosure.

FIG. 7 shows a block diagram of an exemplary electronic device suitable for use in implementing embodiments of the present disclosure. The electronic device 12 shown in FIG. 7 is only an example, and should not limit the functions and scope of use of the embodiments of the present disclosure.

As shown in FIG. 7, electronic device 12 takes the form of a general-purpose computing device. Components of electronic device 12 may include, but are not limited to: one or more processors or processing units 16, system memory 28, bus 18 connecting various system components including system memory 28 and processing unit 16.

Bus 18 represents one or more of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, a processor, or a local bus using any of a variety of bus structures. For example, these architectures include but are not limited to Industry Standard Architecture (Industry Standard Architecture; hereinafter referred to as: ISA) bus, Micro Channel Architecture (Micro Channel Architecture; hereinafter referred to as: MAC) bus, enhanced ISA bus, video electronics standard Association (Video Electronics Standards Association; hereinafter referred to as: VESA) local bus and peripheral component interconnection (Peripheral Component Interconnection; hereinafter referred to as: PCI) bus.

Electronic device 12 typically includes a variety of computer system readable media. These media can be any available media that can be accessed by electronic device 12 and include both volatile and nonvolatile media, removable and non-removable media.

The memory 28 may include a computer system readable medium in the form of a volatile memory, such as a random access memory (Random Access Memory; hereinafter referred to as: RAM) 30 and/or a cache memory 32 . The electronic device 12 may further include other removable/non-removable, volatile/nonvolatile computer system storage media. By way of example only, storage system 34 may be used to read and write to non-removable, non-volatile magnetic media (not shown in FIG. 7, commonly referred to as a "hard drive"). Although not shown in FIG. 7, a disk drive for reading and writing to a removable nonvolatile disk (such as a "floppy disk") may be provided, as well as a disk drive for removable nonvolatile disks (such as a CD-ROM (Compact Disc Read Only Memory (hereinafter referred to as: CD-ROM), Digital Video Disc Read Only Memory (hereinafter referred to as: DVD-ROM) or other optical media) read and write optical disc drives. In these cases, each drive may be connected to bus 18 via one or more data media interfaces. Memory 28 may include at least one program product having a set (eg, at least one) of program modules configured to perform the functions of various embodiments of the present disclosure.

A program/utility 40 having a set (at least one) of program modules 42 may be stored, for example, in memory 28, such program modules 42 including but not limited to an operating system, one or more application programs, other program modules, and program data , each or some combination of these examples may include implementations of network environments. The program modules 42 generally perform the functions and/or methods of the embodiments described in this disclosure.

The electronic device 12 may also communicate with one or more external devices 14 (e.g., a keyboard, pointing device, display 24, etc.), may also communicate with one or more devices that enable a user to interact with the electronic device 12, and/or communicate with Any device (eg, network card, modem, etc.) that enables the electronic device 12 to communicate with one or more other computing devices. Such communication may occur through input/output (I/O) interface 22 . Moreover, the electronic device 12 can also communicate with one or more networks (such as a local area network (Local Area Network; hereinafter referred to as: LAN), a wide area network (Wide Area Network; hereinafter referred to as: WAN) and/or public networks, such as the Internet, through the network adapter 20. ) communication. As shown in FIG. 7 , network adapter 20 communicates with other modules of electronic device 12 via bus 18 . It should be appreciated that although not shown, other hardware and/or software modules may be used in conjunction with electronic device 12, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives And data backup storage system, etc.

The processing unit 16 executes various functional applications and data processing by running the programs stored in the system memory 28 , such as implementing the methods mentioned in the foregoing embodiments.

In the description of this specification, descriptions referring to the terms "one embodiment", "some embodiments", "example", "specific examples", or "some examples" mean that specific features described in connection with the embodiment or example , structure, material or characteristic is included in at least one embodiment or example of the present disclosure. In this specification, the schematic representations of the above terms are not necessarily directed to the same embodiment or example. Furthermore, the described specific features, structures, materials or characteristics may be combined in any suitable manner in any one or more embodiments or examples. In addition, those skilled in the art can combine and combine different embodiments or examples and features of different embodiments or examples described in this specification without conflicting with each other.

In addition, the terms "first" and "second" are used for descriptive purposes only, and cannot be interpreted as indicating or implying relative importance or implicitly specifying the quantity of indicated technical features. Thus, the features defined as "first" and "second" may explicitly or implicitly include at least one of these features. In the description of the present disclosure, "plurality" means at least two, such as two, three, etc., unless otherwise specifically defined.

Any process or method descriptions in flowcharts or otherwise described herein may be understood to represent a module, segment or portion of code comprising one or more executable instructions for implementing custom logical functions or steps of a process , and the scope of preferred embodiments of the present disclosure includes additional implementations in which functions may be performed out of the order shown or discussed, including substantially concurrently or in reverse order depending on the functions involved, which shall It is understood by those skilled in the art to which the embodiments of the present disclosure pertain.

The logic and/or steps represented in the flowcharts or otherwise described herein, for example, can be considered as a sequenced listing of executable instructions for implementing logical functions, can be embodied in any computer-readable medium, For use with instruction execution systems, devices, or devices (such as computer-based systems, systems including processors, or other systems that can fetch instructions from instruction execution systems, devices, or devices and execute instructions), or in conjunction with these instruction execution systems, devices or equipment for use. For the purposes of this specification, a "computer-readable medium" may be any device that can contain, store, communicate, propagate or transmit a program for use in or in conjunction with an instruction execution system, device or device. More specific examples (non-exhaustive list) of computer-readable media include the following: electrical connection with one or more wires (electronic device), portable computer disk case (magnetic device), random access memory (RAM), Read Only Memory (ROM), Erasable and Editable Read Only Memory (EPROM or Flash Memory), Fiber Optic Devices, and Portable Compact Disc Read Only Memory (CDROM). In addition, the computer-readable medium may even be paper or other suitable medium on which the program can be printed, since the program can be read, for example, by optically scanning the paper or other medium, followed by editing, interpretation or other suitable processing if necessary. The program is processed electronically and stored in computer memory.

It should be understood that various parts of the present disclosure may be implemented in hardware, software, firmware or a combination thereof. In the embodiments described above, various steps or methods may be implemented by software or firmware stored in memory and executed by a suitable instruction execution system. For example, if implemented in hardware as in another embodiment, it can be implemented by any one or a combination of the following techniques known in the art: a discrete Logic circuits, ASICs with suitable combinational logic gates, Programmable Gate Arrays (PGA), Field Programmable Gate Arrays (FPGA), etc.

Those of ordinary skill in the art can understand that all or part of the steps carried by the methods of the above embodiments can be completed by instructing related hardware through a program, and the program can be stored in a computer-readable storage medium. During execution, one or a combination of the steps of the method embodiments is included.

In addition, each functional unit in each embodiment of the present disclosure may be integrated into one processing module, each unit may exist separately physically, or two or more units may be integrated into one module. The above-mentioned integrated modules can be implemented in the form of hardware or in the form of software function modules. If the integrated modules are realized in the form of software function modules and sold or used as independent products, they can also be stored in a computer-readable storage medium.

The storage medium mentioned above may be a read-only memory, a magnetic disk or an optical disk, and the like. Although the embodiments of the present disclosure have been shown and described above, it can be understood that the above embodiments are exemplary and should not be construed as limitations on the present disclosure, and those skilled in the art can understand the above-mentioned embodiments within the scope of the present disclosure. The embodiments are subject to changes, modifications, substitutions and variations.

Claims (12)

1. A page dot burying method is characterized by comprising the following steps:

acquiring a first page file and setting information, wherein the setting information comprises at least one key value pair, an attribute key in each key value pair is an element identifier, and the attribute value is a buried point identifier;

for any key value pair, determining a to-be-buried point element corresponding to an element identifier in the key value pair from the first page file;

adding a buried point event corresponding to a buried point identifier in the key value pair to the element of the point to be buried in the first page file;

writing a set embedded point function into the first page file, and writing each embedded point identifier into the embedded point function to obtain the target page file; and the embedded point function is used for acquiring user behavior information associated with the corresponding embedded point event according to each embedded point identifier.

2. The method according to claim 1, wherein the determining, for any of the key-value pairs, a to-be-buried point element from the first page file corresponding to an element identifier in the key-value pair comprises:

accessing the first page file through a browser;

traversing each page element in the first page file;

and determining a to-be-buried point element corresponding to the element identification in the key value pair from each page element.

3. The method of claim 1, wherein obtaining the first page file comprises:

acquiring a second page file in a first format;

and packaging the second page file to obtain the first page file in a second format.

4. The method of claim 3, wherein said packaging said second pagefile to obtain said first pagefile in a second format comprises:

packaging the second page file;

monitoring a packaging completion event of the second page file;

and responding to the monitored packaging completion event, and acquiring the first page file obtained by packaging.

5. The method of any one of claims 1-4, wherein the buried point function is further configured to report the user behavior information;

the method further comprises the following steps:

injecting configuration information into the first page file;

wherein the configuration information is used to indicate at least one of:

a target interface for the buried point function call; the target interface is used for reporting the user behavior information;

the calling mode of the target interface;

and the user behavior information is reported to the target node.

6. A page pointing device, the device comprising:

the device comprises an acquisition module, a storage module and a display module, wherein the acquisition module is used for acquiring a first page file and setting information, the setting information comprises at least one key value pair, an attribute key in each key value pair is an element identifier, and the attribute value is a buried point identifier;

a determining module, configured to determine, for any one of the key value pairs, a to-be-buried point element corresponding to an element identifier in the key value pair from the first page file;

the adding module is used for adding a buried point event corresponding to the buried point identifier in the key value pair to the element of the point to be buried in the first page file;

the writing module is used for writing the set embedded point function into the first page file and writing each embedded point identifier into the embedded point function to obtain the target page file; and the embedded point function is used for acquiring user behavior information associated with the corresponding embedded point event according to each embedded point identifier.

7. The apparatus of claim 6, wherein the determining module is specifically configured to:

accessing the first page file through a browser;

traversing each page element in the first page file;

and determining a to-be-buried point element corresponding to the element identification in the key value pair from each page element.

8. The apparatus of claim 6, wherein the obtaining module is specifically configured to:

acquiring a second page file in a first format;

and packaging the second page file to obtain the first page file in a second format.

9. The apparatus of claim 8, wherein the obtaining module is specifically configured to:

packaging the second page file;

monitoring a packaging completion event of the second page file;

and responding to the monitored packaging completion event, and acquiring the first page file obtained by packaging.

10. The apparatus according to any one of claims 6-9, wherein the embedding function is further configured to report the user behavior information;

the device, still include:

the injection module is used for injecting configuration information into the first page file;

wherein the configuration information is used to indicate at least one of:

a target interface for the buried point function call; the target interface is used for reporting the user behavior information;

the calling mode of the target interface;

and the user behavior information is reported to the target node.

11. An electronic device, comprising:

at least one processor; and

a memory communicatively coupled to the at least one processor; wherein,

the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of any one of claims 1-5.

12. A non-transitory computer readable storage medium having stored thereon computer instructions for causing the computer to perform the method of any one of claims 1-5.

Images