CN116955875A

CN116955875A - Page updating method and device, electronic equipment and storage medium

Info

Publication number: CN116955875A
Application number: CN202210406932.0A
Authority: CN
Inventors: 黎敬茂; 罗广镇; 李鹏飞; 周俊锋; 杨雪平; 郑磊
Original assignee: Tencent Technology Shenzhen Co Ltd
Current assignee: Tencent Technology Shenzhen Co Ltd
Priority date: 2022-04-18
Filing date: 2022-04-18
Publication date: 2023-10-27

Abstract

The application provides a page updating method, a device, electronic equipment and a storage medium, which can be applied to various scenes such as cloud technology, artificial intelligence, intelligent traffic, auxiliary driving and the like, and the method comprises the following steps: receiving a target pseudo instruction object sent by compiling equipment; the target pseudo-instruction object is compiled by compiling equipment to obtain the original data to be updated, wherein the original data to be updated is data corresponding to a target page in a target application program; operating the target pseudo-instruction object based on a preset operating environment to obtain an operating result of the target pseudo-instruction object; the method comprises the steps that a preset running environment is set in a target application program, and the target application program with the preset running environment is compiled by compiling equipment and then issued to a local client; and updating the target page based on the operation result to obtain the updated target page. By adopting the technical scheme of the application, the cost and difficulty of page updating can be reduced, and the efficiency and coverage rate of page updating can be improved.

Description

Page updating method and device, electronic equipment and storage medium

Technical Field

The application belongs to the technical field of computers, and particularly relates to a page updating method, a page updating device, electronic equipment and a storage medium.

Background

In a page update scenario, the related art generally uses an operating system to provide a web page view (WebView) to load a page, uses an interpreted or just-in-time compilation type programming language (JavaScript, JS) to render a native User Interface (UI) to update the page, or issues a front-end compilation product abstract syntax tree (Abstract Syntax Tree, AST) to a client, and the AST is parsed and run by the client, thereby implementing the page update.

However, the JS mode needs to rely on a JS engine to execute dynamic codes, and needs to pre-embed labels, update or newly-added labels need version support, so that the cost of page update is higher and the update difficulty is higher, and in addition, the bridging communication of JS and a mobile terminal application UI open source frame (Flutter) has performance bottleneck; the AST mode needs to make symbol mapping for classes, methods and variables in the Flutter, and update along with the App in advance, so that the efficiency and the precision of page updating are lower, all the characteristics of grammar of a program development language (Dart) on which the Flutter depends cannot be supported, and the coverage rate of page updating is lower.

Disclosure of Invention

In order to solve the problems, the application provides a page updating method, a page updating device, electronic equipment and a storage medium.

In one aspect, the present application provides a method for updating a page, where the method includes:

receiving a target pseudo instruction object sent by compiling equipment; the target pseudo-instruction object is obtained by compiling original data to be updated through compiling by the compiling equipment, the target pseudo-instruction object is used for representing a pseudo-instruction and an object generated in the compiling process of the original data to be updated, and the original data to be updated is data corresponding to a target page in a target application program;

operating the target pseudo-instruction object based on a preset operating environment to obtain an operating result of the target pseudo-instruction object; the preset running environment is arranged in the target application program, and the target application program provided with the preset running environment is compiled by the compiling device and then issued to a local client;

and updating the target page based on the operation result to obtain an updated target page.

In another aspect, the present application provides a method for updating a page, including:

acquiring original data to be updated corresponding to a target page in a target application program;

compiling the original data to be updated to obtain a target pseudo instruction object corresponding to the original data to be updated; the target pseudo-instruction object is used for representing pseudo-instructions and objects generated in the compiling process of the original data to be updated;

Sending the target pseudo instruction object to a client; the client side runs the target pseudo-instruction object based on a preset running environment to obtain a running result of the target pseudo-instruction object; the preset running environment is arranged in the target application program, and the target application program provided with the preset running environment is compiled by the compiling device and then issued to the client; and updating the target page by the client based on the operation result to obtain an updated target page.

In another aspect, the present application provides a page update apparatus, including:

the receiving module is used for receiving the target pseudo instruction object sent by the compiling equipment; the target pseudo-instruction object is obtained by compiling original data to be updated through compiling by the compiling equipment, the target pseudo-instruction object is used for representing a pseudo-instruction and an object generated in the compiling process of the original data to be updated, and the original data to be updated is data corresponding to a target page in a target application program;

the operation module is used for operating the target pseudo-instruction object based on a preset operation environment to obtain an operation result of the target pseudo-instruction object; the preset running environment is arranged in the target application program, and the target application program provided with the preset running environment is compiled by the compiling device and then issued to a local client;

And the updating module is used for updating the target page based on the operation result to obtain an updated target page.

the acquisition module is used for acquiring the original data to be updated corresponding to the target page in the target application program;

the compiling module is used for compiling the original data to be updated to obtain a target pseudo instruction object corresponding to the original data to be updated; the target pseudo-instruction object is used for representing pseudo-instructions and objects generated in the compiling process of the original data to be updated;

the sending module is used for sending the target pseudo instruction object to the client; the client side runs the target pseudo-instruction object based on a preset running environment to obtain a running result of the target pseudo-instruction object; the preset running environment is arranged in the target application program, and the target application program provided with the preset running environment is compiled by the compiling device and then issued to the client; and updating the target page by the client based on the operation result to obtain an updated target page.

In another aspect, the present application provides an electronic device for updating a page, where the electronic device includes a processor and a memory, and at least one instruction or at least one program is stored in the memory, and the at least one instruction or at least one program is loaded and executed by the processor to implement a page updating method as described above.

In another aspect, the present application provides a computer readable storage medium having stored therein at least one instruction or at least one program loaded and executed by a processor to implement a page update method as described above.

In another aspect, the application provides a computer program product comprising a computer program which, when executed by a processor, implements the page updating method described above.

According to the page updating method, the device, the electronic equipment and the storage medium, the target pseudo-instruction object sent by the compiling equipment is received, the target pseudo-instruction object is operated based on the preset operation environment, the operation result of the target pseudo-instruction object is obtained, the target page in the target application program is updated based on the operation result, the updated target page is obtained, the original data to be updated are compiled into the target pseudo-instruction object, the effect of dynamically updating the page is achieved through distributing and operating the target pseudo-instruction object, and therefore the target page in the target application program can be updated under the condition that the target application program does not need to be updated, the cost and the difficulty of page updating are reduced, and the efficiency and the coverage rate of page updating are improved.

Drawings

In order to more clearly illustrate the embodiments of the application or the technical solutions and advantages of the prior art, the following description will briefly explain the drawings used in the embodiments or the description of the prior art, and it is obvious that the drawings in the following description are only some embodiments of the application, and other drawings can be obtained according to the drawings without inventive effort for a person skilled in the art.

FIG. 1 is a schematic diagram illustrating an implementation environment of a page update method according to an exemplary embodiment.

Fig. 2 is a flow diagram illustrating a method of page updating according to an exemplary embodiment.

FIG. 3 is a flowchart illustrating compiling raw data to be updated to obtain a target pseudo-instruction object corresponding to the raw data to be updated according to an example embodiment.

FIG. 4 is a flowchart illustrating a compiling of an abstract syntax tree to obtain a target pseudo-instruction object, according to an illustrative embodiment.

FIG. 5 is a schematic diagram of an abstract syntax tree, shown according to an example embodiment.

FIG. 6 is a second schematic diagram illustrating a flow of page updates according to an example embodiment.

FIG. 7 is a schematic diagram illustrating the integration of a pre-set operating environment with a target application according to an exemplary embodiment.

FIG. 8 is a flowchart illustrating a method for executing a target pseudo-instruction object based on a preset execution environment to obtain an execution result of the target pseudo-instruction object, according to an example embodiment.

FIG. 9 is a class diagram of a runtime environment illustrated in accordance with an example embodiment.

FIG. 10 is a flowchart illustrating a method for obtaining a result of execution of a pseudo instruction object corresponding to each of a plurality of nodes, according to an example embodiment.

FIG. 11 is a flowchart illustrating a method for executing a preset instruction based on a pseudo instruction corresponding to each of a plurality of nodes to obtain an execution result of a pseudo instruction object corresponding to each of the plurality of nodes according to an exemplary embodiment.

FIG. 12 is a schematic diagram illustrating the execution of an instruction according to an example embodiment.

FIG. 13 is a schematic diagram illustrating an update to a page according to an example embodiment.

Fig. 14 is a flow chart diagram two of a page update method according to an exemplary embodiment.

FIG. 15 is a flowchart illustrating a page update method according to an exemplary embodiment

FIG. 16 is a block diagram of a page updating apparatus showing pairs according to an example embodiment.

FIG. 17 is a block diagram of another page updating apparatus showing pairs according to an example embodiment.

Fig. 18 is a block diagram showing a hardware structure of a server for page update according to an exemplary embodiment.

Detailed Description

In order that those skilled in the art will better understand the present application, a technical solution in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings in which it is apparent that the described embodiments are only some embodiments of the present application, not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the present application without making any inventive effort, shall fall within the scope of the present application.

It should be noted that the terms "first," "second," and the like in the description and the claims of the present application and the above figures are used for distinguishing between similar objects and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used may be interchanged where appropriate such that the embodiments of the application described herein may be implemented in sequences other than those illustrated or otherwise described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or server that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed or inherent to such process, method, article, or apparatus, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.

FIG. 1 is a schematic diagram illustrating an implementation environment of a page update method according to an exemplary embodiment. As shown in fig. 1, the implementation environment may at least include a client 01 and a compiling device 02, where the client 01 and the compiling device 02 may be directly or indirectly connected through a wired or wireless communication manner, and the present application is not limited herein.

Specifically, the compiling device 02 is configured to obtain original data to be updated corresponding to a target page; the method comprises the steps of obtaining target pseudo instruction objects corresponding to original data to be updated by compiling the original data to be updated; and for sending the target pseudo-instruction object to the client. Alternatively, the compiling device 02 may be a smart phone, a tablet computer, a notebook computer, a desktop computer, a smart television, a smart watch, or the like, but is not limited thereto.

Specifically, the client 01 is configured to operate the target pseudo-instruction object based on a preset operation environment, so as to obtain an operation result of the target pseudo-instruction object; and updating the target page based on the operation result to obtain an updated target page. As an example, the compiling device 02 may be a smart phone, a tablet computer, a notebook computer, a desktop computer, a smart television, a smart watch, or the like. As another example, the compiling device 02 may be an independent physical server, a server cluster or a distributed system formed by a plurality of physical servers, or a cloud server that provides cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDNs, and basic cloud computing services such as big data and artificial intelligence platforms.

It should be noted that fig. 1 is only an example. In other scenarios, other implementation environments may also be included.

Technical terms used in the embodiments of the present application are described below:

flutter: the UI open source framework of the mobile terminal application can build a user interface in mobile applications such as a mobile operating system (Android) developed by Google corporation, a mobile operating system (iOS) developed by apple corporation and the like.

Dynamically updating: after the user installs the Application program (App), part of the user pages can be updated without updating the App in the Application market, so that the effects of saving flow and rapidly distributing are achieved.

Dart: a program development language on which Flutter depends. Which is an object-oriented, class-defined, single inherited programming language.

Dart VM: the Dart language runtime environment, i.e., the collection of components that execute the Dart language.

Pseudo-instruction: the Conch framework is an abstract class supporting a particular Dart grammar from the Dart grammar properties, and contains variables describing the properties and logic functions executing the properties. The Conch framework is a dynamic update framework, and comprises Conch pseudo instructions, a pseudo instruction compiling tool (Conch compiling tool) and a pseudo instruction running environment (Conch running environment).

Memory snapshot: the method is a technology for serializing an object in a certain state in a Dart VM memory into a file, the object in the memory can be serialized into a memory snapshot file of a corresponding platform (Android/iOS) in a compiling stage by using the technology, and the object in the serialized file can be rapidly loaded into the memory through the reverse serialization of the memory snapshot.

Fig. 2 is a flow diagram illustrating a method of page updating according to an exemplary embodiment. The method may be used in the implementation environment of fig. 1. The present specification provides method operational steps as described above, for example, in the examples or flowcharts, but may include more or fewer operational steps based on conventional or non-inventive labor. The order of steps set forth in the embodiments is merely one manner of a number of order of operation and does not represent a unique order of operation. When a system or server product in practice is running, it may run sequentially or in parallel (e.g., parallel processors or multi-threaded processing environments) according to the methods shown in the embodiments or figures. As shown in fig. 2, the method may include:

s101, acquiring original data to be updated corresponding to a target page in a target application program by compiling equipment.

In the embodiment of the application, when the target page in the target application program needs to be dynamically updated, the compiling device can acquire the original data to be updated corresponding to the target page in the target application program.

In one embodiment, the client may send an update request carrying identification information of the target page to the compiling device based on a preset frequency (for example, daily, weekly, monthly, etc.), and the compiling device obtains, in response to the update request, original data to be updated corresponding to the target page based on the identification information.

In another embodiment, when a target page in the client meets a preset condition, the client may send an update request carrying identification information of the target page to the compiling device, and the compiling device responds to the update request and obtains original data to be updated corresponding to the target page based on the identification information. As an example, the preset conditions may include, but are not limited to: product logic of the target page malfunctions, visual UI of the target page malfunctions, and the like.

Optionally, the target application is an application in a client, which may include, but is not limited to: gaming applications, short video applications, instant messaging applications, shopping applications, and the like. The target page may be part of the page or all of the pages in the target application.

Optionally, the original data to be updated may also be the data to be updated in the target page. As an example, the original data to be updated may be the Dart source code that needs to be dynamically updated.

Optionally, the original data to be updated may also be annotated with a Conch annotation, which is a specific annotation provided by the Conch framework for identifying the data that needs to be dynamically updated. By marking the Conch annotation, the compiling device can conveniently and accurately and rapidly identify the data to be compiled, and the compiling speed and the page updating speed are improved.

S103, compiling original data to be updated by the compiling equipment to obtain a target pseudo instruction object corresponding to the original data to be updated; the target pseudo-instruction object is used for representing pseudo-instructions and objects generated in the compiling process of the original data to be updated.

Alternatively, the pseudo-instruction may be a class of the Conch framework abstracted from the Dart grammar property that supports a particular Dart grammar, including variables describing the property and logic functions executing the property. The object may include, but is not limited to: class objects (Class objects) that record Class information, method objects (TMethod objects) that record method information, and the like.

Alternatively, the compiling device may compile the original data to be updated in a plurality of manners, and embodiments of the present application are not limited herein in detail.

Fig. 3 is a flowchart illustrating compiling raw data to be updated to obtain a target pseudo-instruction object corresponding to the raw data to be updated according to an exemplary embodiment, as shown in fig. 3, in an alternative embodiment, in step S103, the compiling device compiles the raw data to be updated to obtain the target pseudo-instruction object corresponding to the raw data to be updated, which may include:

s1031, compiling original data to be updated by compiling equipment to obtain an abstract syntax tree corresponding to the original data to be updated.

S1033, compiling the abstract syntax tree by compiling equipment to obtain the target pseudo instruction object.

Alternatively, in the above step S1031, the compiling apparatus may compile the original data to be updated into an AST through a front-end compiling tool provided by Flutter. Taking the example that the original data to be updated may be the Dart source code, the front-end compiling tool provided by Flutter may be used to compile the Dart source code using the Conch annotation tag into an AST.

In a specific embodiment, in S1031, the process of compiling the original data to be updated into the abstract syntax tree may be as follows:

1) The original data to be updated (for example, dart source code) is parsed in hypertext markup language (Hyper Text Markup Language, HTML) to obtain a corresponding object model. The original data to be updated is composed of many tags, which may include, for example, < html >, < head >, < body >, < div >, < span >, etc.

2) Traversing the subelements of each layer of nodes in the object model to obtain a label array corresponding to each layer of nodes. The tag array may include sub-elements of each layer of nodes, tags of the sub-elements of each layer of nodes, and attributes of the sub-elements of each layer of nodes.

3) And carrying out semantic analysis on the label array of each layer of nodes. Wherein the semantic analysis includes: and carrying out regular matching on the tag arrays of each layer of nodes to obtain an object array of each layer of nodes.

4) And determining the corresponding object array of the multi-layer node according to the object array corresponding to each layer of node, so as to convert the original data to be updated into AST.

Optionally, in the step S1033, the compiling device may further compile and link the abstract syntax tree through a pseudo instruction compiling tool to obtain the target pseudo instruction object.

In the embodiment of the application, the original data to be updated is compiled into the abstract syntax tree, and each node on the abstract syntax tree can represent a structure in the source code because the abstract syntax tree can represent the syntax structure of the programming language in a tree form, and the generation precision and efficiency of the target pseudo instruction object can be improved by further compiling and linking the abstract syntax tree, so that the precision and efficiency of page updating are improved.

FIG. 4 is a flowchart illustrating compiling an abstract syntax tree to obtain a target pseudo-instruction object according to an exemplary embodiment, and in a possible embodiment, as shown in FIG. 4, the abstract syntax tree includes a plurality of nodes, each node representing a data structure in original data to be updated, and in step S1033, the compiling apparatus compiles the abstract syntax tree to obtain the target pseudo-instruction object, and may include:

s10331, the compiling device creates respective object processing modules of the plurality of nodes according to respective types corresponding to the plurality of nodes.

S10333, the compiling device processes the data structures characterized by the nodes based on the object processing modules of the nodes respectively to obtain the objects corresponding to the nodes respectively.

S10335, endowing a pseudo instruction to each object processing module of the plurality of nodes by the compiling equipment to obtain each pseudo instruction corresponding to the plurality of nodes; the pseudo instruction is obtained by abstracting the grammar characteristics of a preset programming language.

S10337, the compiling device determines the pseudo instructions corresponding to the nodes and the objects corresponding to the nodes as pseudo instruction objects corresponding to the nodes.

S10339, the compiling device generates a target pseudo-instruction object according to the pseudo-instruction objects corresponding to the nodes.

Optionally, the abstract syntax tree includes a plurality of nodes, each node representing a data structure in the original data to be updated, and in the step S10331, the pseudo instruction compiling tool in the compiling device may create an object processor (Handler) of each node according to a type of each node.

Optionally, in the step S10333, the compiling device may process, according to the object processing module of each node, the data structure represented by each node to obtain the object corresponding to each node.

In a specific embodiment, in S10333, the compiling device processes, based on the object processing modules of the plurality of nodes, the data structures represented by the plurality of nodes, to obtain the objects corresponding to the plurality of nodes, and may include:

the compiling device obtains a hierarchical structure of each of the plurality of nodes in the abstract syntax tree.

The compiling device determines the object generation sequence corresponding to each of the plurality of nodes according to the hierarchical structure.

The compiling device processes the data structures characterized by the nodes according to the object processing modules of the nodes based on the object generating sequence, and obtains the objects corresponding to the nodes.

FIG. 5 is a schematic diagram of an abstract syntax tree, shown according to an example embodiment. As shown in fig. 5, the abstract syntax tree may include the following nodes: a first node (Class), a second node (Constructor), a third node (procedure), a fourth node (field), a fifth node (Initializer), a sixth node (function node), a seventh node (variable declaration), an eighth node (status), and a ninth node (expression).

In the compiling process, a pseudo instruction compiling tool in the compiling device may determine the object generating order according to the hierarchical structure of each node in the abstract syntax tree. For example, if the first node is a root node, the object generation sequence of the first node is the first bit; the second node, the third node and the fourth node are child nodes of the first node, and the object generation sequence of the second node, the third node and the fourth node is a second bit; the sixth node is a child node of the second node and the fifth node is a child node of the second node, and then the object generation sequence of the sixth node and the fifth node is a third bit; the seventh node is a child node of the sixth node, and the object generation sequence of the seventh node is a fourth bit; the object generation sequence of the eighth node is a fifth bit; the object generation order of the ninth node is the sixth bit.

And the object processing module of each node in the compiling device sequentially processes the data structure represented by each node according to the object generation sequence to obtain the corresponding object of each node. For example, according to the object processor corresponding to the first node, the data represented by the first node is processed to obtain a Class object (TClass object), which is used for recording information of the Class (Class). And processing the data represented by the second node through an object processor corresponding to the second node to obtain a method object (TMmethod) which is used for recording information of the construction method. And processing the data represented by the fourth node through an object processor corresponding to the fourth node to obtain a field object (TFfield object) which is used for recording corresponding variable information and the like. According to the object generation sequence determined by the hierarchical structure, objects corresponding to the nodes are generated sequentially according to the object processing modules of the nodes, the node depth and bifurcation complexity are not required to be considered, the accuracy and efficiency of object generation are improved, the determination accuracy and efficiency of the target pseudo instruction object are improved, and the speed and efficiency of page updating are improved.

Optionally, in the step S10335, the compiling device may assign a pseudo instruction to each of the object processing modules of the plurality of nodes, so as to obtain a pseudo instruction corresponding to each of the plurality of nodes. For example, a pseudo instruction is given to the object processing module of the first node in fig. 5, so as to obtain a pseudo instruction corresponding to the first node, a pseudo instruction is given to the object processing module of the second node in fig. 5, so as to obtain a pseudo instruction corresponding to the second node, and so on.

It should be noted that, the pseudo instruction may be abstracted in advance by using dynamic characteristics of a grammar of a preset programming language of an account corresponding to the compiling device. As an example, the preset programming language may be the Dart language, and a set of pseudo instructions of the Dart language are abstracted by utilizing dynamic characteristics of the Dart language and opening dynamic characteristics in the Flutter engine and the Dart VM. Accordingly, the pseudo instruction may include, but is not limited to:

tnewOpera: and creating an object instruction to cover all Dart object construction scenes.

TCallOperator: and a method calling instruction covers all the Dart method calling scenes.

TInitParamOperator: initializing parameter instructions, and initializing scenes corresponding to Dart variables.

Tinitttypeoperator: initializing a type instruction.

TinitFunctionOpera: initializing a method instruction and constructing a corresponding method.

TGetFieldOperator: and acquiring a variable instruction, and covering all variable acquisition scenes of Dart.

Tsetfield operator: and a variable setting instruction covers all variable setting scenes of Dart.

Tjumpoperater: conditional branch instruction, if true, jumps to the nth instruction.

Tcondionoperators: and a condition judgment instruction corresponding to if and a ternary operator in Dart.

TLogicalOperator: logic expression instructions, corresponding to all logic calculations of Dart, such as: and &, ||, = etc.

Tisospirator: an instruction (IS instruction) for adapting an IS keyword of the Dart grammar.

Tconcataoperator: and the character string connection instruction is used for matching the $ { } grammar in the character string in Dart.

Ttrycatchfinalyoperator: an exception capture instruction (try catch instruction) corresponds to the Dart try match syntax.

Tcatch operator: a signal capture instruction (Catch instruction) is specified.

Tthrowoperater: an exception cast instruction (thread instruction) corresponds to the Dart through key.

treturnOPERATER: a Return instruction (Return instruction) corresponds to the Dart Return key.

TBlockOperator: a Block instruction (Block instruction) is created corresponding to the { } key in Dart.

TLabel operator: a variable or symbol type definition instruction (Label instruction) for jumping to a specified code scenario.

TBreakOperator: and (3) exiting the instruction (Break instruction) from the circulating body weight, and corresponding to the Dart Break jump scene.

Tforooperator: and the For loop instruction is used For the For loop scene.

Tforine operator: and the ForIn circulation instruction is used for a ForIn circulation scene.

TLoopOpera: a while loop instruction for a while loop scenario.

TSwitchOperator: hostname/system name setting instruction (Switch instruction) for a Switch key scene.

Tawaitooperator: wait instructions (Await instructions) for an Await call scenario.

Alternatively, in the step S10337, since the pseudo instructions and the objects corresponding to the respective nodes have been obtained in the step, the pseudo instructions and the objects corresponding to the respective nodes of the compiling apparatus are obtained as the pseudo instruction objects corresponding to the respective nodes. In the step S10339, the compiling apparatus may merge and aggregate the pseudo-instruction objects corresponding to the nodes, to obtain the target pseudo-instruction object. Continuing taking fig. 4 as an example, the pseudo-instruction and class object corresponding to the first node may be used as the pseudo-instruction object corresponding to the first node, the determining manner of the pseudo-instruction objects of other nodes is similar to that of the first node, and finally the pseudo-instruction objects of the first node and the pseudo-instruction objects of other nodes are combined and summarized to obtain the target pseudo-instruction object.

In the embodiment of the application, the object processing module created based on the node type creates the respective object and pseudo instruction of each node, so that the problem of complex grammar is solved without considering the node depth and bifurcation complexity, the determination precision and efficiency of the pseudo instruction objects corresponding to each of a plurality of nodes are improved, the determination precision and efficiency of the target pseudo instruction objects are improved, and the speed and efficiency of page updating are further improved.

S105, the compiling device sends the target pseudo instruction object to the client.

Alternatively, the compiling device may send the target pseudo-instruction object to the client through a wired or wireless manner, which is not specifically limited in the embodiment of the present application.

FIG. 6 is a second schematic diagram illustrating a page update process according to an exemplary embodiment, as shown in FIG. 6, in a possible embodiment, the compiling device sends the target pseudo-instruction object to the client in the step S105, which may include:

s1051, the compiling device performs serialization processing on the target pseudo-instruction object to obtain the memory snapshot file corresponding to the target pseudo-instruction object.

S1053, the compiling device sends the memory snapshot file to the client.

Alternatively, serialization refers to a process of converting state information of an object into a form that can be stored or transmitted. During serialization, an object writes its current state to a temporary or persistent storage area. In the step S1051, a memory snapshot tool may be provided in the compiling apparatus, and the compiling apparatus may sequence the pseudo instruction and the object represented by the target pseudo instruction object into a memory snapshot file through the memory snapshot tool, that is, a process of converting the pseudo instruction and the object into a form that can be stored or transmitted.

Alternatively, in the step S1053, the compiling device may send the memory snapshot file to the client in a wireless or wired manner, which is not limited in particular by the embodiment of the present application.

In the embodiment of the application, the target pseudo-instruction object is subjected to serialization processing to obtain the memory snapshot file, so that the target pseudo-instruction object can be converted into data which can be transmitted and stored, the compiling equipment can conveniently send the target pseudo-instruction object to the client, and the transmission convenience and safety of the target pseudo-instruction object are improved.

Optionally, as further shown in fig. 6, after the step S105 and before the step S107, the method may further include:

S106, the client performs deserialization processing on the memory snapshot file to obtain a target pseudo-instruction object.

Wherein, the inverse serialization refers to the process of reconstructing the object of the serialized result.

For example, after the client receives the memory snapshot file, an anti-serialization tool may be set in the client, and the client performs anti-sequence processing on the memory snapshot file through the anti-serialization tool to obtain a target pseudo-instruction object, so that the target pseudo-instruction object is accurately loaded into the target application program.

S107, the client runs the target pseudo-instruction object based on a preset running environment to obtain a running result of the target pseudo-instruction object; the preset running environment is set in the target application program, and the target application program with the preset running environment is compiled by the compiling device and then issued to the client.

First, the release process of the target application is introduced:

in the embodiment of the application, the preset running environment can be predefined, and the preset running environment and Flutter Framework are issued along with the App version, so that a basic running environment is provided for page dynamic update. As an example, the preset running environment of the Dart language may be abstracted by utilizing the dynamic characteristics of the Dart language and opening the dynamic characteristics in the router engine and the Dart VM.

In the APP release phase, firstly, the APP needs a Flutter running environment, including a DartVm and a Flutter engine environment (Flutter engine) as basic running environments, the Flutter itself does not provide dynamic update capability, and the dynamic update capability is realized by a Conch framework, so that a preset running environment (i.e., a Conch running environment) can be predefined and integrated into the APP. FIG. 7 is a schematic diagram illustrating integration of a preset running environment and a target application program according to an exemplary embodiment, where, as shown in FIG. 7, fluterEngine, dart VM and preset running environment are integrated in an App release stage and released and updated in an application market along with an App version, and pages and business logic thereof in the App can be dynamically released without releasing with the App.

Optionally, in the step S107, after the client receives the target pseudo instruction object sent by the compiling device, the target pseudo instruction object may be executed according to a preset execution environment integrated in the target application program, so as to obtain an execution result of the target pseudo instruction object.

Alternatively, the client may operate the target pseudo-instruction object in a plurality of manners to obtain an operation result of the target pseudo-instruction object, and embodiments of the present application are not limited herein specifically.

FIG. 8 is a flowchart illustrating a method for obtaining an operation result of a target pseudo-instruction object based on a preset operation environment, where in a possible embodiment, as shown in FIG. 8, the preset operation environment includes an operation environment class, and in the step S107, the method may include:

s1071, the client stores parameter information of pseudo instructions corresponding to the nodes and objects corresponding to the nodes into an operation environment class; the objects corresponding to each of the plurality of nodes include method objects.

Optionally, the preset running environment may be predefined by the account corresponding to the trial compiling device, which may include a running environment class. FIG. 9 is a schematic diagram of a runtime environment class, as shown in FIG. 9, which may include, but is not limited to:

TClass: description information of Conch dynamic class.

TMethod: the description information of the Conch dynamic method, fang Fati, will be compiled into a pseudo instruction set (operator_list).

TField: conch variable description information.

TOperator: and the Conch pseudo instruction base class is used for recording the runtime information of each instruction.

TParam: conch parameter description information is used for recording parameters used by each pseudo instruction.

Optionally, the client may map and associate the target pseudo-instruction object with a running environment class in the preset running environment, so as to store parameter information of pseudo-instructions corresponding to each of the plurality of nodes and objects corresponding to each of the plurality of nodes in the running environment class, that is, establish a one-to-one correspondence between the target pseudo-instruction object and the running environment class in the preset running environment.

For example, a class within Dart may be compiled into a corresponding TClass object, a method within the corresponding class may be compiled into a TMmethod object and stored into a method list (method_LIest), and a variable declared within the class may be compiled into a TFfield object and stored into a variable list (field_list); all instructions compiled by the corresponding Dart method body are contained in the TMmethod object and can be stored in an operation list (operation_list) array, wherein parameters used by each pseudo instruction can be recorded on TParam; thus, a one-to-one correspondence between the target pseudo instruction object and the operation environment class in the preset operation environment is established.

S1073, the client calls the method objects in the objects corresponding to the nodes from the operation environment class based on the pseudo instructions corresponding to the nodes, and operation results of the pseudo instruction objects corresponding to the nodes are obtained.

Optionally, since the objects corresponding to the plurality of nodes respectively include method objects (i.e. TMethod objects), and the objects corresponding to the plurality of nodes respectively are stored in the operation environment class, after the association storage with the operation environment class is established, the client may call the method objects in the objects corresponding to the plurality of nodes respectively from the operation environment class through the pseudo instructions corresponding to the plurality of nodes respectively, so as to obtain the operation result of the pseudo instruction objects corresponding to the plurality of nodes respectively.

Fig. 10 is a flowchart illustrating an operation result of obtaining pseudo instruction objects corresponding to each of the plurality of nodes according to an exemplary embodiment, and in step S1073, the client invokes, from the operation environment class, a method object in an object corresponding to each of the plurality of nodes based on the pseudo instruction corresponding to each of the plurality of nodes, to obtain an operation result of the pseudo instruction object corresponding to each of the plurality of nodes, which may include:

S10731, the client acquires preset instructions included in the method objects corresponding to the nodes from the operation environment class; the preset instruction is obtained by compiling a method object.

S10733, the client runs the preset instruction based on the pseudo instruction corresponding to each of the plurality of nodes, and a running result of the pseudo instruction object corresponding to each of the plurality of nodes is obtained.

Optionally, since all preset instructions compiled by the Dart method body included in the method object corresponding to each of the plurality of nodes are stored in the operation list (operation_list) array, in step S10731, the client may obtain the preset instructions included in the method object corresponding to each of the plurality of nodes from the operation_list in the operation environment class. In the step S10733, the client may execute the preset instruction included in the method object corresponding to each of the plurality of nodes based on the pseudo instruction corresponding to each of the plurality of nodes, to obtain the execution result of the pseudo instruction object corresponding to each of the plurality of nodes. Therefore, the pseudo instructions corresponding to the nodes respectively obtain the running results of the corresponding method objects, and the calling of the corresponding method objects is completed.

In the embodiment of the application, based on the pseudo instructions corresponding to each of the plurality of nodes, the preset instructions included in the corresponding method object are operated to obtain the operation result of the corresponding pseudo instruction object, so that the dynamic characteristics of the Dart language are utilized, the dynamic characteristics of the Flutter engine and the Dart VM are opened, a set of pseudo instructions of the Dart language and the operation environment thereof are abstracted to dynamically update the page, the problem of bridging performance bottleneck of a JS scheme can be avoided, the defect that the front-end product cannot support all Dart grammar characteristics can be avoided, the difficulty and cost of page update are reduced, and the efficiency and coverage rate of page update are improved.

Fig. 11 is a flowchart illustrating a process of executing a preset instruction based on a pseudo instruction corresponding to each of a plurality of nodes to obtain an execution result of a pseudo instruction object corresponding to each of the plurality of nodes according to an exemplary embodiment, as shown in fig. 11, in an exemplary embodiment, in the step S10733, the number of preset instructions is a plurality of, the plurality of preset instructions are arranged in sequence, and the client executes the preset instruction based on a pseudo instruction corresponding to each of the plurality of nodes to obtain an execution result of a pseudo instruction object corresponding to each of the plurality of nodes, which may include:

s107331, the client takes the preset instruction which is the forefront of the preset instructions as the current instruction corresponding to each of the nodes, and removes the current instruction from the preset instructions.

S107333, the client runs the current instruction based on the pseudo instructions corresponding to the nodes respectively, and a running result of the current instruction is obtained.

S107335 the client repeats the operation of taking the forefront preset instruction in the preset instructions as the current instruction corresponding to each of the nodes, removing the current instruction from the preset instructions, and operating the current instruction based on the pseudo instructions corresponding to each of the nodes to obtain the operation result of the current instruction until the operation result of the preset instructions corresponding to each of the nodes is obtained.

S107337, the client generates an operation result of the pseudo instruction object corresponding to each of the plurality of nodes according to the operation result of the preset instructions corresponding to each of the plurality of nodes.

Alternatively, in the above step S107331, when the method object corresponding to each of the plurality of nodes is called, a temporary variable Map (temporary variable Map) may be created, by which the variable generated by the instruction execution process may be recorded. When the number of the preset instructions is a plurality of, a special pointer can be defined, and the current running instruction can be recorded through the pointer. For example, each of the plurality of nodes corresponds to a preset instruction, which is an instruction in a preset instruction set (the preset instruction set may be an operaott_list), and the pointer may point to a first instruction in the operaott_list recorded by the method object, that is, the terminal may take a preset instruction in the preset instruction set, which is the first to be ordered, as a current instruction, and remove the current instruction from the preset instruction set.

Optionally, in the step S107333, the client executes the corresponding current instruction based on the pseudo instructions corresponding to each of the plurality of nodes, so as to obtain an execution result of the current instruction. The variable generated in the current instruction running process can be recorded in a temporary variable Map.

Optionally, in the step S107335, the client may repeat the step S107331-the step S107333 until the running results of the plurality of preset instructions corresponding to the plurality of nodes are obtained. As an example, when the plurality of nodes each correspond to a preset instruction, which is an instruction in a preset instruction set (the preset instruction set may be an operaott_list), the above-mentioned repetition process may be stopped when an operation result corresponding to each preset instruction in the preset instruction set corresponding to the plurality of nodes is obtained.

Optionally, in the step S107337, the client may combine and aggregate the running results of the plurality of preset instructions corresponding to the plurality of nodes, to obtain the running result of the pseudo instruction object corresponding to the plurality of nodes.

Hereinafter, the above step S107331-the above step S107337 will be described by way of example:

continuing to refer to fig. 6, assuming that the plurality of nodes include a first node, a method body in a method object corresponding to the first node is compiled into an operator_list1, the operator_list1 includes an instruction 1, an instruction 2 and an instruction 3 which are arranged in sequence, when a pseudo instruction corresponding to the first node calls the method object corresponding to the first node, a pointer points to the instruction 1 first, the instruction 1 is used as a current instruction, the instruction 1 is removed from the operator_list1, and the client runs the instruction 1 based on the pseudo instruction corresponding to the first node, so as to obtain a running result of the instruction 1. At this time, the instruction 2 is the foremost ordered in the operator_list1, then the pointer may point to the instruction 2, the instruction 2 is taken as the current instruction, the instruction 2 is removed from the operator_list1, and the client executes the instruction 2 based on the pseudo instruction corresponding to the first node, so as to obtain the execution result of the instruction 2. At this time, the instruction 3 is the foremost ordered in the operator_list1, then the pointer may point to the instruction 3, the instruction 3 is taken as the current instruction, the instruction 3 is removed from the operator_list1, and the client executes the instruction 3 based on the pseudo instruction corresponding to the first node, so as to obtain the execution result of the instruction 3. And finally, taking the operation result of the instruction 1, the operation result of the instruction 2 and the operation result of the instruction 3 as the operation results of the pseudo instruction objects corresponding to the first node.

In the embodiment of the application, when the number of the preset instructions is a plurality of, each preset instruction can be sequentially executed according to the ordering sequence of each preset instruction, so that the execution precision and efficiency of the preset instruction are improved, the determination efficiency and precision of the running result of the pseudo instruction object corresponding to each node are improved, and the update efficiency and precision of each page are further improved.

In a specific embodiment, in the step S107333, the client executes the current instruction based on the pseudo instructions corresponding to the plurality of nodes, to obtain the execution result of the current instruction, and may include:

and under the condition that the current instruction comprises a target instruction set, the client sequentially operates the instructions in the target instruction set according to a preset sequence based on the pseudo instructions corresponding to the nodes, and an operation result of the current instruction is obtained.

Optionally, in the case that the current instruction includes the target instruction set, it is indicated that the current instruction itself includes a plurality of other instructions, i.e., the current instruction is nested with other instructions. The client can sequentially execute the instructions in the target instruction set according to a preset sequence based on the pseudo instructions corresponding to the nodes respectively, and an operation result of the current instruction is obtained. After the client executes all instructions in the target instruction set, the client returns to execute other instructions in the plurality of preset instructions.

Alternatively, the target instruction set may be an operator_list, i.e., the current instruction is nested with an operator_list. Accordingly, the predetermined order may be an order from top to bottom, that is, the instructions in the target instruction set are sequentially executed from top to bottom.

Hereinafter, the above step S107333 is described by way of example, and fig. 12 is a schematic instruction execution diagram according to an exemplary embodiment. As shown in fig. 12, the instruction 5 includes a target instruction set, when the current instruction is the instruction 5, the pointer points to the target instruction set corresponding to the instruction 5, then the instructions in the target instruction set are sequentially executed according to the sequence from top to bottom, after all the instructions in the target instruction set are executed, the pc pointer returns to the method object to continue to execute the subsequent preset instructions in the method object, so that the pseudo instruction obtains the running result of the method, and the call of a method is completed.

In the embodiment of the application, under the condition that the current instruction comprises the target instruction set, the current instruction can point to the instruction in the target instruction set, after the complete operation of the instructions in the target instruction set, the method object is returned to continue to operate the subsequent preset instructions, thereby avoiding the omission of the instructions, further improving the precision and efficiency of the instruction operation, further improving the determination efficiency and precision of the operation result of the pseudo instruction object corresponding to each node, and further improving the efficiency and precision of each update of the page.

S1075, the client generates an operation result of the target pseudo-instruction object according to the operation results of the pseudo-instruction objects corresponding to the nodes.

Optionally, after obtaining the running results of the pseudo instruction objects corresponding to the plurality of nodes, the running results of the pseudo instruction objects corresponding to the plurality of nodes may be combined and summarized to obtain the running result of the target pseudo instruction object.

S109, the client updates the target page based on the operation result to obtain an updated target page.

Optionally, the client may update the original data to be updated in the target page based on the operation result, to obtain an updated target page. As an example, after each preset instruction is logically executed, a corresponding Widget tree may be constructed and displayed according to the running results of the pseudo instruction objects corresponding to the multiple nodes, so as to update the target page and obtain the updated target page. Among these, the Widget tree is a tree of a way to create a UI.

Illustratively, in the step S109, the client updates the target page based on the operation result, and the obtaining the updated target page may include:

constructing a corresponding Widget tree according to the operation results of the pseudo instruction objects corresponding to the nodes, generating an Element tree according to the Widget tree, wherein the Element refers to an instantiation object of the Widget at a specific position of the UI tree, and finally generating a rendering tree according to the Element tree, thereby completing updating the target page.

According to the page updating method provided by the embodiment of the application, the dynamic characteristics of the Dart language are utilized, the dynamic characteristics are opened in the Flutter engine and the Dart VM, a set of pseudo instructions and the running environment thereof of the Dart language are abstracted, the Dart source code is compiled to obtain a pseudo instruction set, and the problem of dynamically updating the page by using the self-defined pseudo instructions is solved by distributing and running the pseudo instructions. The scheme in the embodiment of the application is used for dynamically updating the page, so that the target page in the target application program can be updated without updating the target application program, the bridging problem of using the JS scheme can be avoided, and the defect that the issuing front-end product cannot support all Dart grammar characteristics can be avoided, thereby having both the performance and the integrity of page updating. By using the scheme of the embodiment of the application to update the page, the size of the dynamic product of the page can be reduced by 20% -30%, and the page loading speed can be improved by about 30%.

FIG. 13 is a schematic diagram illustrating an update to a page according to an example embodiment. As shown in FIG. 13, the page updating method of the embodiment of the application can dynamically update the target page in the target application program under the condition of not updating the version of the target application program, thereby reducing the difficulty and cost of page updating and improving the efficiency and coverage rate of page updating.

The following describes a page update method in the embodiment of the present application with a client as an execution body:

fig. 14 is a flowchart diagram three illustrating a page update method according to an exemplary embodiment. As shown in fig. 14, the page update method may include:

s201, receiving a target pseudo instruction object sent by compiling equipment; the target pseudo instruction object is obtained by compiling original data to be updated through compiling of the compiling device, the target pseudo instruction object is used for representing a pseudo instruction and an object generated in the compiling process of the original data to be updated, and the original data to be updated is data corresponding to a target page in a target application program.

S203, operating the target pseudo-instruction object based on a preset operation environment to obtain an operation result of the target pseudo-instruction object; the preset running environment is set in the target application program, and the target application program provided with the preset running environment is compiled by the compiling device and then issued to the local client.

S205, updating the target page based on the operation result to obtain an updated target page.

In an optional embodiment, the target pseudo-instruction object is obtained by compiling, by the compiling device, an abstract syntax tree, where the abstract syntax tree includes a plurality of nodes, each node represents a data structure in the original data to be updated, the preset running environment includes a running environment class, and the running of the target pseudo-instruction object based on the preset running environment obtains a running result of the target pseudo-instruction object, and includes:

Storing parameter information of pseudo instructions corresponding to the nodes and objects corresponding to the nodes into the operation environment class; the objects corresponding to the nodes respectively comprise method objects.

And calling the method objects in the objects corresponding to the nodes from the running environment class based on the pseudo instructions corresponding to the nodes respectively, so as to obtain the running results of the pseudo instruction objects corresponding to the nodes respectively.

And generating the running result of the target pseudo-instruction object according to the running result of the pseudo-instruction object corresponding to each of the plurality of nodes.

The compiling device gives pseudo instructions to the object processing modules of the nodes respectively, wherein the pseudo instructions are corresponding to the nodes respectively and are obtained by the compiling device; the compiling device processes the data structures characterized by the nodes based on the object processing modules of the nodes; the object processing modules of the nodes are created by the compiling equipment according to the types corresponding to the nodes; the pseudo instruction objects corresponding to the nodes are determined by the compiling device based on the pseudo instructions corresponding to the nodes and the objects corresponding to the nodes.

In an optional embodiment, the calling, based on the pseudo instructions corresponding to the plurality of nodes, a method object in the objects corresponding to the plurality of nodes from the running environment class to obtain a running result of the pseudo instruction object corresponding to the plurality of nodes, includes:

acquiring preset instructions included in the method objects corresponding to the nodes from the operation environment class; the preset instruction is obtained by compiling the method object.

And operating the preset instruction based on the pseudo instruction corresponding to each of the plurality of nodes to obtain an operation result of the pseudo instruction object corresponding to each of the plurality of nodes.

In an optional embodiment, the number of the preset instructions is a plurality, the plurality of preset instructions are arranged in sequence, the executing the preset instructions based on the pseudo instructions corresponding to the plurality of nodes respectively, to obtain an execution result of the pseudo instruction objects corresponding to the plurality of nodes respectively, includes:

and taking the preset instruction which is the forefront of the preset instructions as the current instruction corresponding to each of the nodes, and removing the current instruction from the preset instructions.

And operating the current instruction based on the pseudo instructions corresponding to the nodes respectively to obtain an operating result of the current instruction.

Repeating the operation of taking the preset instruction which is the forefront of the preset instructions and corresponds to the nodes as the current instruction, and removing the current instruction from the preset instructions until the operation result of the current instruction is obtained, until the operation result of the preset instructions which correspond to the nodes is obtained.

And generating the operation results of the pseudo instruction objects corresponding to the nodes according to the operation results of the preset instructions corresponding to the nodes.

In an optional embodiment, the executing the current instruction based on the pseudo instructions corresponding to the plurality of nodes to obtain an execution result of the current instruction includes:

and under the condition that the current instruction comprises a target instruction set, sequentially operating the instructions in the target instruction set according to a preset sequence based on the pseudo instructions corresponding to the nodes respectively, and obtaining an operation result of the current instruction.

In an optional embodiment, the receiving the target pseudo instruction object sent by the compiling device includes:

receiving a memory snapshot file sent by the compiling equipment; the memory snapshot file is obtained by the compiling device through serializing the target pseudo instruction object.

Before the target pseudo-instruction object is executed based on the preset execution environment, the method further comprises:

and performing deserialization processing on the memory snapshot file to obtain the target pseudo instruction object.

The following describes a page update method in the embodiment of the present application with a compiling device as an execution body:

fig. 15 is a flow chart diagram four of a page update method according to an exemplary embodiment. As shown in fig. 15, the page update method may include:

s301, obtaining original data to be updated corresponding to a target page in a target application program.

S303, compiling the original data to be updated to obtain a target pseudo instruction object corresponding to the original data to be updated; the target pseudo instruction object is used for representing pseudo instructions and objects generated in the compiling process of the original data to be updated.

S305, the target pseudo instruction object is sent to a client; so that the client runs the target pseudo-instruction object based on a preset running environment to obtain a running result of the target pseudo-instruction object; the preset running environment is arranged in the target application program, and the target application program provided with the preset running environment is compiled by the compiling device and then issued to the client; and updating the target page by the client based on the operation result to obtain an updated target page.

In an optional embodiment, compiling the to-be-updated original data to obtain the target pseudo instruction object corresponding to the to-be-updated original data includes:

compiling the original data to be updated to obtain an abstract syntax tree corresponding to the original data to be updated.

Compiling the abstract syntax tree to obtain the target pseudo instruction object.

In an alternative embodiment, the abstract syntax tree includes a plurality of nodes, each node representing a data structure in the original data to be updated, and the compiling the abstract syntax tree to obtain the target pseudo-instruction object includes:

and creating object processing modules of the nodes according to the types corresponding to the nodes.

And processing the data structure characterized by each of the plurality of nodes based on the object processing module of each of the plurality of nodes to obtain the object corresponding to each of the plurality of nodes.

Giving a pseudo instruction to each object processing module of the plurality of nodes to obtain a pseudo instruction corresponding to each of the plurality of nodes; the pseudo instruction is obtained by abstracting the grammar characteristics of a preset programming language.

And determining the pseudo instruction corresponding to each of the plurality of nodes and the object corresponding to each of the plurality of nodes as pseudo instruction objects corresponding to each of the plurality of nodes.

And generating the target pseudo-instruction object according to the pseudo-instruction object corresponding to each of the plurality of nodes.

In an optional embodiment, the processing, based on the object processing module of each of the plurality of nodes, the data structure represented by each of the plurality of nodes to obtain the object corresponding to each of the plurality of nodes includes:

a hierarchical structure of each of the plurality of nodes in the abstract syntax tree is obtained.

And determining the object generation sequence corresponding to each of the plurality of nodes according to the hierarchical structure.

And processing the data structures characterized by the nodes according to the object processing modules of the nodes in turn based on the object generation sequence to obtain the objects corresponding to the nodes.

In an alternative embodiment, the sending the target pseudo-instruction object to the client includes:

and carrying out serialization processing on the target pseudo-instruction object to obtain a memory snapshot file corresponding to the target pseudo-instruction object.

Sending the memory snapshot file to the client; and the client performs deserialization processing on the memory snapshot file to obtain the target pseudo instruction object.

FIG. 16 is a block diagram of a page updating apparatus showing pairs, as shown in FIG. 16, according to an example embodiment, the page updating apparatus may include:

a receiving module 401, configured to receive a target pseudo instruction object sent by a compiling device; the target pseudo instruction object is obtained by compiling original data to be updated through compiling of the compiling device, the target pseudo instruction object is used for representing a pseudo instruction and an object generated in the compiling process of the original data to be updated, and the original data to be updated is data corresponding to a target page in a target application program.

An operation module 403, configured to operate the target pseudo-instruction object based on a preset operation environment, to obtain an operation result of the target pseudo-instruction object; the preset running environment is set in the target application program, and the target application program provided with the preset running environment is compiled by the compiling device and then issued to the local client.

And the updating module 405 is configured to update the target page based on the operation result, and obtain an updated target page.

In an alternative embodiment, the target pseudo-instruction object is obtained by compiling, by the compiling device, an abstract syntax tree, where the abstract syntax tree includes a plurality of nodes, each node represents a data structure in the original data to be updated, and the running module 403 includes:

A storage sub-module, configured to store parameter information of pseudo instructions corresponding to each of the plurality of nodes and objects corresponding to each of the plurality of nodes into the running environment class; the objects corresponding to the nodes respectively comprise method objects.

And the calling sub-module is used for calling the method objects in the objects corresponding to the nodes from the running environment class based on the pseudo instructions corresponding to the nodes respectively to obtain the running results of the pseudo instruction objects corresponding to the nodes respectively.

And the operation result generation sub-module is used for generating the operation result of the target pseudo-instruction object according to the operation result of the pseudo-instruction object corresponding to each of the plurality of nodes.

The compiling device gives pseudo instructions to the object processing modules of the nodes respectively, wherein the pseudo instructions are corresponding to the nodes respectively and are obtained by the compiling device; the compiling device processes the data structures characterized by the nodes based on the object processing modules of the nodes; and the object processing module of each of the plurality of nodes is created by the compiling device according to the type corresponding to each of the plurality of nodes.

In an alternative embodiment, the calling sub-module includes:

a preset instruction obtaining unit, configured to obtain preset instructions included in method objects corresponding to the plurality of nodes from the running environment class; the preset instruction is obtained by compiling the method object.

And the preset instruction running unit is used for running the preset instruction based on the pseudo instructions corresponding to the nodes respectively to obtain the running results of the pseudo instruction objects corresponding to the nodes respectively.

In an alternative embodiment, the number of the preset instructions is a plurality, the plurality of preset instructions are arranged in sequence, and the preset instruction running unit includes:

and the current instruction determining subunit is used for taking the preset instruction which is sequenced to the front in the preset instructions as the current instruction corresponding to each of the nodes and removing the current instruction from the preset instructions.

And the current running result determining subunit is used for running the current instruction based on the pseudo instructions corresponding to the nodes respectively to obtain the running result of the current instruction.

And the repeating subunit is used for repeating the operation of taking the preset instruction which is the forefront among the preset instructions as the current instruction corresponding to each of the nodes, removing the current instruction from the preset instructions until the operation result of the current instruction is obtained, and obtaining the operation result of the preset instructions corresponding to each of the nodes.

And the operation result generation subunit is used for generating the operation result of the pseudo instruction object corresponding to each of the plurality of nodes according to the operation result of the plurality of preset instructions corresponding to each of the plurality of nodes.

In an optional embodiment, the current running result determining subunit may be configured to, when the current instruction includes a target instruction set, sequentially run instructions in the target instruction set according to a preset order based on pseudo instructions corresponding to each of the plurality of nodes, to obtain a running result of the current instruction.

In an alternative embodiment, the receiving module includes:

the memory snapshot file receiving unit is used for receiving the memory snapshot file sent by the compiling equipment; the memory snapshot file is obtained by the compiling device through serializing the target pseudo instruction object.

Correspondingly, the device can further comprise:

and the deserialization processing module is used for deserializing the memory snapshot file to obtain the target pseudo instruction object.

FIG. 17 is a block diagram of another page updating apparatus showing pairs, as shown in FIG. 17, according to an example embodiment, the page updating apparatus may include:

The obtaining module 501 is configured to obtain original data to be updated corresponding to a target page in a target application program.

A compiling module 503, configured to compile the to-be-updated original data to obtain a target pseudo instruction object corresponding to the to-be-updated original data; the target pseudo instruction object is used for representing pseudo instructions and objects generated in the compiling process of the original data to be updated.

A sending module 505, configured to send the target pseudo instruction object to a client; so that the client runs the target pseudo-instruction object based on a preset running environment to obtain a running result of the target pseudo-instruction object; the preset running environment is arranged in the target application program, and the target application program provided with the preset running environment is compiled by the compiling device and then issued to the client; and updating the target page by the client based on the operation result to obtain an updated target page.

In an alternative embodiment, the compiling module 503 includes:

and the original data to be updated compiling sub-module is used for compiling the original data to be updated to obtain an abstract syntax tree corresponding to the original data to be updated.

And the target pseudo instruction object determining submodule is used for compiling the abstract syntax tree to obtain the target pseudo instruction object.

In an alternative embodiment, the abstract syntax tree includes a plurality of nodes, each node representing a data structure in the original data to be updated, and the target pseudo-instruction object determining submodule includes:

and the object processing module creating unit is used for creating the object processing modules of the nodes according to the types corresponding to the nodes.

And the object generating unit is used for processing the data structures characterized by the nodes based on the object processing modules of the nodes to obtain the objects corresponding to the nodes.

The instruction generating unit is used for giving a pseudo instruction to each object processing module of the plurality of nodes to obtain a pseudo instruction corresponding to each node; the pseudo instruction is obtained by abstracting the grammar characteristics of a preset programming language.

And the pseudo instruction object determining unit is used for determining the pseudo instructions corresponding to the nodes and the objects corresponding to the nodes as pseudo instruction objects corresponding to the nodes.

And the target pseudo instruction object generating unit is used for generating the target pseudo instruction object according to the pseudo instruction objects corresponding to the nodes.

In an alternative embodiment, the object generating unit comprises:

a hierarchical structure obtaining subunit, configured to obtain a hierarchical structure of each of the plurality of nodes in the abstract syntax tree.

And the object generation sequence determining subunit is used for determining the object generation sequence corresponding to each of the plurality of nodes according to the hierarchical structure.

And the processing subunit is used for processing the data structures characterized by the nodes according to the object processing modules of the nodes in sequence based on the object generation sequence to obtain the objects corresponding to the nodes.

In an alternative embodiment, the sending module includes:

and the serialization processing unit is used for carrying out serialization processing on the target pseudo-instruction object to obtain the memory snapshot file corresponding to the target pseudo-instruction object.

A memory snapshot file sending unit, configured to send the memory snapshot file to the client; and the client performs deserialization processing on the memory snapshot file to obtain the target pseudo instruction object.

It will be appreciated that in the specific embodiments of the present application, related data such as user information is involved, and when the above embodiments of the present application are applied to specific products or technologies, user permissions or consents need to be obtained, and the collection, use and processing of related data need to comply with related laws and regulations and standards of related countries and regions.

It should be noted that, the device embodiment provided by the embodiment of the present application and the method embodiment described above are based on the same inventive concept.

The embodiment of the application also provides a page updating system, which comprises compiling equipment and a client:

the compiling device is used for acquiring original data to be updated corresponding to a target page in the target application program; compiling original data to be updated to obtain a target pseudo instruction object corresponding to the original data to be updated; the target pseudo-instruction object is used for representing a pseudo-instruction and an object generated in the compiling process of the original data to be updated; and sending the target pseudo-instruction object to the client.

The client is used for operating the target pseudo-instruction object based on a preset operating environment to obtain an operating result of the target pseudo-instruction object; the method comprises the steps that a preset running environment is set in a target application program, and the target application program with the preset running environment is compiled by compiling equipment and then issued to a client; and updating the target page based on the operation result to obtain an updated target page.

The embodiment of the application also provides an electronic device for updating the page, which comprises a processor and a memory, wherein at least one instruction or at least one section of program is stored in the memory, and the at least one instruction or the at least one section of program is loaded and executed by the processor to realize the page updating method provided by any embodiment.

Embodiments of the present application also provide a computer readable storage medium that may be provided in a terminal to store at least one instruction or at least one program related to implementing a page update method in a method embodiment, where the at least one instruction or at least one program is loaded and executed by a processor to implement the page update method as provided in the method embodiment above.

Alternatively, in the present description embodiment, the storage medium may be located in at least one network server among a plurality of network servers of the computer network. Alternatively, in the present embodiment, the storage medium may include, but is not limited to: a U-disk, a Read-Only Memory (ROM), a random access Memory (Random Access Memory, RAM), a removable hard disk, a magnetic disk, or an optical disk, or other various media capable of storing program codes.

The memory of the embodiments of the present specification may be used for storing software programs and modules, and the processor may execute various functional applications and data processing by executing the software programs and modules stored in the memory. The memory may mainly include a storage program area and a storage data area, wherein the storage program area may store an operating system, application programs required for functions, and the like; the storage data area may store data created according to the use of the device, etc. In addition, the memory may include high-speed random access memory, and may also include non-volatile memory, such as at least one magnetic disk storage device, flash memory device, or other volatile solid-state storage device. Accordingly, the memory may also include a memory controller to provide access to the memory by the processor.

Embodiments of the present application also provide a computer program product or computer program comprising computer instructions stored in a computer readable storage medium. The processor of the computer device reads the computer instructions from the computer-readable storage medium, and the processor executes the computer instructions, so that the computer device executes the page update method provided by the above-mentioned method embodiment.

The page updating method provided by the embodiment of the application can be operated in a terminal, a computer terminal, a server or similar computing devices. Taking the example of running on a server, fig. 18 is a block diagram of the hardware architecture of a server showing a page update according to an exemplary embodiment. As shown in fig. 18, the server 600 may vary considerably in configuration or performance, and may include one or more central processing units (Central Processing Units, GPUs) 610 (the central processing units 610 may include, but are not limited to, a microprocessor MCU, a programmable logic device FPGA, etc.), a memory 630 for storing data, one or more storage mediums 620 (e.g., one or more mass storage devices) for storing applications 623 or data 622. Wherein the memory 630 and the storage medium 620 may be transitory or persistent storage. The program stored on the storage medium 620 may include one or more modules, each of which may include a series of instruction operations on a server. Still further, the central processor 610 may be configured to communicate with a storage medium 620 and run a series of instruction operations in the storage medium 620 on the server 600. The server 600 may also include one or more power supplies 660, one or more wired or wireless network interfaces 650, one or more input/output interfaces 640, and/or one or more operating systems 621, such as Windows ServerTM, mac OS XTM, unixTM, linuxTM, freeBSDTM, and the like.

The input-output interface 640 may be used to receive or transmit data via a network. The specific example of the network described above may include a wireless network provided by a communication provider of the server 600. In one example, the input-output interface 640 includes a network adapter (Network Interface Controller, NIC) that can connect to other network devices through a base station to communicate with the internet. In one example, the input/output interface 640 may be a Radio Frequency (RF) module for communicating with the internet wirelessly.

It will be appreciated by those skilled in the art that the configuration shown in fig. 18 is merely illustrative and is not intended to limit the configuration of the electronic device described above. For example, the server 600 may also include more or fewer components than shown in fig. 18, or have a different configuration than shown in fig. 18.

It should be noted that: the sequence of the embodiments of the present application is only for description, and does not represent the advantages and disadvantages of the embodiments. And the foregoing description has been directed to specific embodiments of this specification. Other embodiments are within the scope of the following claims. In some cases, the actions or steps recited in the claims can be performed in a different order than in the embodiments and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

In this specification, each embodiment is described in a progressive manner, and identical and similar parts of each embodiment are all referred to each other, and each embodiment mainly describes differences from other embodiments. In particular, for the device and server embodiments, since they are substantially similar to the method embodiments, the description is relatively simple, and references to the parts of the description of the method embodiments are only required.

It will be appreciated by those of ordinary skill in the art that all or part of the steps of implementing the above embodiments may be implemented by hardware, or may be implemented by a program to instruct related hardware, and the program may be stored in a computer readable storage medium, where the storage medium may be a read-only memory, a magnetic disk or an optical disk, etc.

The foregoing is only illustrative of the present application and is not to be construed as limiting thereof, but rather as various modifications, equivalent arrangements, improvements, etc., within the spirit and principles of the present application.

Claims

1. A method for updating a page, the method comprising:

2. The page updating method according to claim 1, wherein the target pseudo-instruction object is obtained by compiling an abstract syntax tree by the compiling device, the abstract syntax tree includes a plurality of nodes, each node represents a data structure in the original data to be updated, the preset running environment includes a running environment class, and the running of the target pseudo-instruction object based on the preset running environment obtains a running result of the target pseudo-instruction object, and the method includes:

storing parameter information of pseudo instructions corresponding to the nodes and objects corresponding to the nodes into the running environment class; the objects corresponding to the nodes respectively comprise method objects;

calling method objects in the objects corresponding to the nodes from the operation environment class based on the pseudo instructions corresponding to the nodes respectively to obtain operation results of the pseudo instruction objects corresponding to the nodes respectively;

Generating an operation result of the target pseudo-instruction object according to the operation result of the pseudo-instruction object corresponding to each of the plurality of nodes;

the compiling device gives pseudo instructions to the object processing modules of the nodes respectively, wherein the pseudo instructions correspond to the nodes respectively and are obtained by giving the pseudo instructions to the object processing modules of the nodes respectively; the compiling equipment processes the data structures characterized by the nodes based on the object processing modules of the nodes respectively to obtain the objects corresponding to the nodes respectively; the object processing modules of the nodes are created by the compiling equipment according to the types corresponding to the nodes; and determining the pseudo instruction objects corresponding to the nodes respectively by the compiling equipment based on the pseudo instructions corresponding to the nodes respectively and the objects corresponding to the nodes respectively.

3. The method for updating a page according to claim 2, wherein the calling, based on the pseudo-instruction corresponding to each of the plurality of nodes, a method object in the object corresponding to each of the plurality of nodes from the running environment class, to obtain a running result of the pseudo-instruction object corresponding to each of the plurality of nodes, includes:

Acquiring preset instructions included in the method objects corresponding to the nodes from the operation environment class; the preset instruction is obtained by compiling the method object;

4. The method for updating a page according to claim 3, wherein the number of the preset instructions is plural, the plural preset instructions are arranged in sequence, the executing the preset instructions based on the pseudo instructions corresponding to the plural nodes respectively, and an execution result of the pseudo instruction objects corresponding to the plural nodes respectively is obtained, and the method comprises:

taking the preset instruction which is the forefront of the plurality of preset instructions as the current instruction corresponding to each of the plurality of nodes, and removing the current instruction from the plurality of preset instructions;

operating the current instruction based on pseudo instructions corresponding to the nodes respectively to obtain an operation result of the current instruction;

repeating the operation of taking the forefront preset instruction in the preset instructions as the current instruction corresponding to each of the nodes, removing the current instruction from the preset instructions until the operation result of the current instruction is obtained, and obtaining the operation result of the preset instructions corresponding to each of the nodes;

5. The method for updating a page according to claim 4, wherein the executing the current instruction based on the pseudo instructions corresponding to the plurality of nodes to obtain the execution result of the current instruction includes:

6. The page updating method according to any one of claims 1 to 5, wherein the receiving the target pseudo-instruction object sent by the compiling apparatus includes:

receiving a memory snapshot file sent by the compiling device; the memory snapshot file is obtained by carrying out serialization processing on the target pseudo instruction object by the compiling equipment;

7. A method for updating a page, the method comprising:

8. The method for updating a page according to claim 7, wherein compiling the original data to be updated to obtain the target pseudo-instruction object corresponding to the original data to be updated comprises:

compiling the original data to be updated to obtain an abstract syntax tree corresponding to the original data to be updated;

Compiling the abstract syntax tree to obtain the target pseudo-instruction object.

9. The page updating method according to claim 8, wherein the abstract syntax tree comprises a plurality of nodes, each node representing a data structure in the original data to be updated, and the compiling the abstract syntax tree to obtain the target pseudo-instruction object comprises:

creating respective object processing modules of the plurality of nodes according to respective types of the plurality of nodes;

processing the data structure characterized by each of the plurality of nodes based on the object processing module of each of the plurality of nodes to obtain the object corresponding to each of the plurality of nodes;

giving a pseudo instruction to each object processing module of the plurality of nodes to obtain a pseudo instruction corresponding to each of the plurality of nodes; the pseudo instruction is obtained by abstracting the grammar characteristics of a preset programming language;

determining the pseudo instructions corresponding to the nodes and the objects corresponding to the nodes as pseudo instruction objects corresponding to the nodes;

10. The method for updating a page according to claim 9, wherein the processing, based on the object processing modules of the plurality of nodes, the data structure represented by each of the plurality of nodes to obtain the objects corresponding to each of the plurality of nodes, includes:

acquiring a hierarchical structure of each of the plurality of nodes in the abstract syntax tree;

determining the object generation sequence corresponding to each of the plurality of nodes according to the hierarchical structure;

11. The page update method according to any one of claims 7 to 10, wherein said sending the target pseudo-instruction object to a client comprises:

serializing the target pseudo-instruction object to obtain a memory snapshot file corresponding to the target pseudo-instruction object;

sending the memory snapshot file to the client; and enabling the client to perform deserialization processing on the memory snapshot file to obtain the target pseudo instruction object.

12. A page updating apparatus, the apparatus comprising:

13. A page updating apparatus, the apparatus comprising:

14. An electronic device for page updating, characterized in that it comprises a processor and a memory in which at least one instruction or at least one program is stored, the at least one instruction or the at least one program being loaded and executed by the processor to implement the page updating method according to any of claims 1 to 11.

15. A computer readable storage medium having stored therein at least one instruction or at least one program, the at least one instruction or the at least one program being loaded and executed by a processor to implement the page updating method of any of claims 1 to 11.