WO2018228211A1

WO2018228211A1 - Application conversion method, apparatus and device

Info

Publication number: WO2018228211A1
Application number: PCT/CN2018/089363
Authority: WO
Inventors: 龚澄
Original assignee: 腾讯科技（深圳）有限公司
Priority date: 2017-06-13
Filing date: 2018-05-31
Publication date: 2018-12-20
Also published as: CN107239318B; CN107239318A

Abstract

The present application provides an application conversion method, an apparatus and a device. The method comprises: acquiring a file of a sub-application program, the sub-application program being an application program relying on the running of a main application program; generating, according to the file of the sub-application program, an executable file that can be run on a Web terminal; and generating a file of the Web application according to the executable file and a second entry file that can be run on the Web terminal, the executable file being cited in the second entry file. The present application provides a technical solution of converting the file of a sub-application program into a file of a Web application, so that there is no need to independently develop a Web application having the same function as the sub-application program, thereby saving manual power and time costs required for developing the Web application, improving the development efficiency, enabling the Web application and the sub-application program which have the same function to share a set of basic source codes, improving the reusability of codes.

Description

Application conversion method, device and device

This application claims the priority of the Chinese Patent Application of the National Intellectual Property Office of the People's Republic of China, Application No. 201710443627.8, and the name of the application "Application Conversion Method, Apparatus and Equipment" on June 13, 2017, the entire contents of which are incorporated by reference. In this application.

Technical field

The embodiments of the present invention relate to the field of computer technologies, and in particular, to an application conversion method, apparatus, and device.

Background technique

At present, some applications depend on other applications, and the applications that depend on other applications can be called "mini programs". Applets cannot run independently, but they do not need to be downloaded and installed.

Since the implementation principle of the applet is not the same as the implementation principle of the Web (web) application, for a certain function, if it is necessary to develop a small program for implementing the function, it is also developed to implement the function. Web applications require developers to write two separate sets of code files. One set of code files is a small program version file, which is suitable for running on the running platform of the applet, and another set of code files is a Web version file, which is suitable for running on the web side.

Therefore, for an application that implements a certain function, writing two separate sets of code files separately results in a low code reuse rate, and the labor and time cost of the development process increases.

Summary of the invention

The embodiment of the present application provides an application conversion method, device, and device, which are used to solve the problem that the code reuse rate of the related art is low, and the manpower and time cost are large. The technical solution is as follows:

In one aspect, an embodiment of the present application provides an application conversion method, where the method includes:

Obtaining a file of a sub-application, the sub-application is an application running by the parent application, the file of the sub-application includes: a first entry file, a global configuration file, and a logical code file of each page;

Generating an executable file running on the web side according to the file of the sub-application;

Generating a file of the web application according to the executable file and a second entry file supported on the web side, the executable file being referenced in the second entry file.

On the other hand, an embodiment of the present application provides an application conversion method, where the method includes:

The computer device acquires a file of the sub-application, the sub-application is an application that depends on the parent application, the file of the sub-application includes: a first entry file, a global configuration file, and a logical code file of each page ;

The computer device generates an executable file that is run on a webpage webpage according to a file of the sub-application;

The computer device generates a file of the web application according to the executable file and a second entry file supported on the web end, and the executable file is referenced in the second entry file.

In another aspect, an embodiment of the present application provides an application conversion apparatus, where the apparatus includes:

a file obtaining module, configured to acquire a file of a sub-application, the sub-application is an application that depends on the parent application, and the file of the sub-application includes: a first entry file, a global configuration file, and each page Logical code file;

a first generating module, configured to support an executable file running on the web end according to the file of the sub-application;

And a second generating module, configured to generate a file of the web application according to the executable file and a second import file that supports running on the web end, where the executable file is referenced in the second entry file.

In still another aspect, an embodiment of the present application provides a computer device, where the computer device includes a processor and a memory, where the memory stores at least one instruction, at least one program, a code set, or a set of instructions, the at least one instruction, The at least one program, the set of codes, or a set of instructions is loaded and executed by the processor to implement an application conversion method as described in the first aspect.

In still another aspect, an embodiment of the present application provides a computer readable storage medium, where the computer readable storage medium stores at least one instruction, at least one program, a code set, or a set of instructions, the at least one instruction, the at least one instruction A program, the set of codes, or a set of instructions is loaded and executed by a processor to implement the application conversion method as described in the first aspect.

In still another aspect, an embodiment of the present application provides a computer program product for performing the application conversion method described in the above first aspect when the computer program product is executed.

The technical solution provided by the embodiment of the present application can bring the following beneficial effects:

By providing a technical solution for converting a file of a sub-application into a file of a web application, the web application having the same function as the sub-application does not need to be separately developed, thereby saving the labor and time cost required for developing the above-mentioned web application. Improve development efficiency, and enable web applications and sub-applications with the same function to share a basic set of source code to improve code reuse rate.

DRAWINGS

In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings used in the description of the embodiments will be briefly described below. It is obvious that the drawings in the following description are only some embodiments of the present application. Other drawings may also be obtained from those of ordinary skill in the art in light of the inventive work.

1 is a flowchart of an application conversion method provided by an embodiment of the present application;

2 is a schematic diagram of a syntax structure provided by an embodiment of the present application;

FIG. 3 is a schematic diagram of generating an executable file supporting the running of a web terminal according to an embodiment of the present application; FIG.

4 is a schematic diagram of generating a second view file code provided by an embodiment of the present application;

FIG. 5A is a flowchart of an application conversion method according to another embodiment of the present application; FIG.

FIG. 5B is a flowchart of an application conversion method according to another embodiment of the present application; FIG.

6 is a schematic diagram of multiple public interfaces provided by an embodiment of the present application;

FIG. 7 is a block diagram of an application conversion apparatus according to an embodiment of the present application; FIG.

FIG. 8 is a structural block diagram of an application conversion device according to an embodiment of the present application.

detailed description

In order to make the objects, technical solutions and advantages of the present application more clear, the embodiments of the present application will be further described in detail below with reference to the accompanying drawings.

Before describing the embodiments of the present application, related nouns related to the embodiments of the present application are introduced.

(1) sub-application

A sub-application is an application that depends on the parent application to run. The sub-application may specifically be a social application, a file management application, a mail application, or a game application. The above sub-applications can be called applets. The user can directly open the sub-application by scanning the QR code corresponding to the sub-application or searching for the name of the sub-application. Sub-applications can be easily accessed and propagated in the parent application.

The developer completes the development, debugging, previewing, and uploading of the sub-applications in the sub-application development tool. The above sub-application development tool can be called WePY. WePY is a componentized development framework. All the business and functions of a component are implemented in the component itself, and the components and components are isolated from each other. After the developer releases the code file of the sub-application to the server, the parent application can request the file of the sub-application from the server through an HTTP (HyperText Transfer Protocol) request or a WebSocket request, and then the parent application passes Load the above file to display the page of the sub-application.

(2) parent application

A parent application is an application that hosts a child application, providing an environment for the implementation of the child application. The parent application is a native application. Native applications are applications that run directly on the operating system. The parent application can be a social application, a dedicated application that specifically supports the sub-application, a file management application, a mail application, or a game application. Social applications include instant messaging applications, SNS (Social Network Service) applications, or live applications.

(3) Web application

A web application is an application that can be accessed via the web. Its typical architecture is the browser/server architecture. The web application runs on the server, and the browser of the terminal can obtain the functions provided by the web application from the server through the HTTP request. Web application development frameworks include the React framework, the Vue.js framework, and more.

Since the development framework of sub-applications and web applications is not the same, and the implementation principles of the two are not the same, the sub-applications are implemented based on the client/server architecture, and the web applications are implemented based on the browser/server architecture. So the sub-application can't run directly on the web side.

In the embodiment of the present application, a technical solution for converting a file of a sub-application into a file of a web application is provided, so that the web version of the application does not need to be separately developed, thereby saving the manpower required for developing the web version of the application. Time cost, improve development efficiency, and make the application web application file and sub-application file share a basic source code to improve the code reuse rate.

The method provided by the embodiment of the present application, the execution subject of each step is an application conversion device, which is also a computer device. Alternatively, the application conversion device may be a computer, a server, or the like.

Please refer to FIG. 1 , which is a flowchart of an application conversion method provided by an embodiment of the present application. The method can include the following steps.

Step 101: Acquire a file of the sub-application.

A sub-application is an application that depends on the parent application to run. Among them, the sub-application depends on the parent application running, which means that the sub-application cannot run directly in the operating system, but runs in the environment provided by the parent application. That is, the sub-application cannot run independently, but must rely on the parent application to run. The parent application obtains the logical code file of the sub-application, parses the logical code file, and displays the page of the sub-application.

The sub-application files include: a first entry file, a global configuration file, and a logical code file for each page.

The first entry file is used to listen for and process the lifecycle functions of the sub-application and declare global variables. Optionally, the first entry file is a file with a suffix of .js. Illustratively, the first entry file is app.js.

A global configuration file is a file that configures a sub-application as a whole. It can configure global configuration information such as the path of the sub-application page configuration file, the sub-application window representation, and the network timeout threshold of the sub-application. Optionally, the global configuration file is a file with a suffix of .json, and illustratively, the global configuration file is app.json. During the application conversion process, the global profile supply is read by the conversion device so that the application conversion device can determine which pages of the sub-application need to be converted by the logical code files. In addition, it should be noted that, in the running process of the converted web application file, the above global configuration file is not needed, so there is no need to convert the global configuration file. In addition, each page corresponds to a logical code file. Logic code is recorded in the logic code file, and the logic code can be used to process events triggered in the corresponding sub-application page, and can also be used for other logic processing including data processing. The logic code file can be a script file, such as a JavaScript script file. Optionally, the logical code file is a file with a suffix of .js. Illustratively, the logical code file is page.js.

Optionally, the sub-application's file also includes a global style file and a style file for each page. The global style file includes the page's overall style data. The page overall style data may include at least one of a page size of the corresponding sub-application page and an attribute such as a page background color. The inline style corresponding to each page supports the style of the component using the style and class attributes. Optionally, the global style file is a file with a .wxss suffix, and illustratively, the global style file is app.wxss. The style file for each page is used to configure the presentation of the page. The style file includes component style data for the public components rendered by the page. The component style data may include at least one of attributes such as position, size, color, font, and font size of the corresponding common component in the sub-application page to which it belongs. For an introduction to common components, reference may be made to the method embodiment provided in FIG. 5A. Optionally, the style file is a file with a .wxss suffix. Illustratively, the style file is page.wxss.

Optionally, the sub-application's file also includes a view file for each page. View files are used to configure the structure of common components in this page. Optionally, the view file is a file with a .wxml suffix. Illustratively, the view file is page.wxml.

Optionally, the sub-application's file also includes a configuration file for each page. The configuration file is used to configure the file for the page, such as configuring the window behavior of the page. The configuration file can be source code or a file obtained by compiling the source code. Optionally, the configuration file is a file with a .json suffix, and illustratively, the configuration file is page.json.

Step 102: Support an executable file running on the web side according to the file of the sub-application.

Executable files that support running on the web include script logic that supports execution on the web. Optionally, the executable file running on the web side is a file with a .js suffix. For example, the executable file is all.js.

In the embodiment of the present application, the executable file supported on the web side is converted by the file of the sub-application, and the labor and time cost required for developing the web application having the same function as the sub-application is saved compared with the related technology. Improve development efficiency, and enable web applications and sub-applications with the same function to share a basic set of source code to improve code reuse rate.

The executable file running on the web side can directly implement the operation on the view, and the file of the sub-application realizes the operation on the view through data binding. Among them, data binding refers to a method of binding the attributes of a user interface element (control) to an attribute on a type instance. Therefore, when generating an executable that supports running on the web, you need to simulate data binding.

In the embodiment of the present application, data binding is simulated by introducing a view layer framework. Wherein, the above view layer framework may be a Vue.js framework. The Vue.js framework provides efficient data binding and flexible component systems through a simple Application Programming Interface (API). Since the WePY framework is very similar to the syntax and functional features of the Vue.js framework, it is possible to make the sub-application files written in the WePY framework compatible with the Vue.js framework by simply encapsulating the WePY framework.

Referring to FIG. 2, a schematic diagram of a syntax architecture shown by an exemplary embodiment of the present application is shown. The file of the sub-application is written by using the WePY framework. The file of the above sub-application supports running on the server of the related application (such as the open platform server of the social application), and is also compatible by converting the file of the sub-application. The file of the web application of the Vue.js framework and having the same function as the sub-application, the file support of the above web application is run on the web side.

Optionally, step 102 includes the following sub-step 102a.

Step 102a: Generate logic code supporting execution on the web end according to a logic code file of each page in the file of the sub-application;

The above-mentioned logic code (hereinafter referred to as "logic code of the web application") supported on the web side is used to implement the function of the target application. The difference between the logic code of the web application and the logic code of the sub-application is that the logic code of the sub-application supports the require function, and the logic code of the web application does not support the require function. Among them, the require function refers to the function that can be called between each logic code module.

When converting the logic code of a sub-application into the logic code of a web application, it is necessary to simulate the require function to implement the call between the various logic code modules of the web application. Optionally, the logic code of the web application may be obtained by: obtaining, for each page, a plurality of logic code modules included in the logic code file of the page, and calling relationships between the respective logic code modules; The logic code modules are sequentially added to the executable file, and numbers are added to the respective logic code modules of the page; the entry code of the page is added to the executable file according to the calling relationship and number between the respective logic code modules of the page.

The entry code of the page is used to indicate the calling relationship between the various logical code modules of the page. The calling relationship between the above various logic code modules can be called a dependency relationship, and the dependency relationship can be directly read from the logical code files of each page of the sub-application.

Optionally, adding each logical code module of the page to the executable file in order refers to adding each logical code module of the page to the executable file in the form of a queue. When a logic code module needs to be called, it is only necessary to read the entry code of the page from the executable file to obtain the number of the logic code module, and call the above logic code module from the queue according to the number. In the above way, the require function is simulated on the web side.

Referring to FIG. 3, there is shown a schematic diagram of generating an executable file supported for execution on the web side, shown by an exemplary embodiment of the present application. Part (a) of Figure 3 illustrates the dependencies between the various logical code modules of a page in the sub-application's file. Among them, page.js depends on a.js and e.js, a.js depends on b.js, e.js depends on d.js and f.js, b.js depends on c.js, and c.js depends on d.js. Part (b) of Figure 3 is the logical code of the generated web side. Add the page entry code, a.js, b.js, c.js, d.js, e.js, and f.js to the executable as a queue, where a.js, b.js, c The numbers for .js, d.js, e.js, and f.js are 1, 2, 3, 4, 5, and 6, respectively, and the entry code for the page depends on a.js and e.js, and a.js depends on b. Js, e.js depends on d.js and f.js, b.js depends on c.js, and c.js depends on d.js.

Optionally, if the file of the sub-application further includes a global style file and a page style file of each page, the executable file includes a second style file code that supports recognition on the web side. Step 102 can also include the following step 102b.

Step 102b, generating a second style file code that supports recognition on the web end according to the global style file in the file of the sub-application and the style file of each page;

The second style file code is used to configure the presentation form of each page when the target application is running on the web side. The difference between the style file code of a web application and the style file code of a sub-application is that the size units used are different. Therefore, the style file code of the web application can be obtained by converting the size unit used by the sub-application's style file code. Optionally, the second style file code is obtained by: obtaining a global style file and a first style file code included in a style file of each page; and the size unit in the first style file code is determined by the first unit Convert to the second unit and get the second style file code. The first unit refers to the unit of size identified by the parent application, and the second unit refers to the unit of size identified on the web side.

In conjunction with the explanation in step 101, the size unit identified by the parent application is rpx. The unit of size recognized by the web side is px. Optionally, the conversion relationship between the first unit and the second unit is obtained by: specifying a screen width of 750 rpx, such as on device A, the screen width is 375 px, and there are 750 physical pixels, then 750 rpx=375px=750 physical pixels. , 1rpx = 0.5px = 1 physical pixel. Illustratively, in a sub-application, an input box is 100 rpx in length, and after conversion, the input box is 50 px in the web application.

Optionally, the file of the sub-application further includes a page view file of each page, and the executable file includes a second view file code that supports recognition on the web side. Step 102 can also include the following step 102c.

Step 102c: Generate, according to the view file of each page in the file of the sub-application, a second view file code that supports identification on the web end;

The second view file code is used to describe the structure of the common components of each page when the target application runs on the web side. The difference between the view file code of a web application and the view file code of a sub-application is that the syntax for writing the view file code is different. Therefore, the view file code of the web application can be obtained by converting the writing syntax adopted by the view code file in the file of the sub-application. Optionally, the second view file code is obtained by: obtaining a first view file code included in a view file of each page and written according to a syntax of the sub-application; converting the first view file code into a web according to the web The second view file code written by the end-supported syntax.

Optionally, the application conversion device pre-stores a mapping relationship between the syntax of the sub-application and the syntax supported by the web, and the application conversion device can search for the mapping relationship, thereby implementing the first view file code and the second view file code. Conversion between. Illustratively, the "view" in the first view file code is replaced with "div". Referring to FIG. 4, a schematic diagram of generating a second view file code, shown by an exemplary embodiment of the present application, is shown. Wherein (a) in FIG. 4 is the first view file code written in accordance with the syntax of the sub-application, and part (b) in FIG. 4 is the second view file code written in accordance with the syntax supported by the web-side.

Optionally, step 102 further includes the following step 102d.

Step 102d, the foregoing supporting the logic code executed on the web side, the second style file code supported on the web end, and the first item or the first item in the second view file code supported on the web end and any other one A combination of items or multiples is added to a file in a preset format to generate an executable file that supports running on the web side.

The file in the preset format may be a file in the format of js (JavaScript).

Step 103: Generate a file of the web application according to the executable file and a second entry file that supports running in the web application, and reference the executable file in the second entry file.

The web application's files are all the files needed to support the application running on the web. In the embodiment of the present application, the sub-application has the same function as the web application, that is, the function implemented by the logic code of the sub-application is the same as the function implemented by the logic code of the web application. For example, both the sub-application and the web application have the function of refilling the mobile phone number. For example, the files of the sub-application and the files of the web application have the function of purchasing movie tickets online.

The files of the web application include: a second entry file and an executable file supported on the web side, and the executable file is referenced in the second entry file. The second entry file in the web application's file is a file with a .html extension. However, the explanation in step 101 mentions that the first entry file in the file of the sub-application is a file with a suffix of .js. In the embodiment of the present application, the file identifier of the executable file is written into the template file of the second entry file, thereby generating a second entry file. The file identifier of the executable file may be a file name.

In summary, the method provided by the embodiment of the present application provides a technical solution for converting a file of a sub-application into a file of a web application, so that the web application having the same function as the sub-application does not need to be separately developed. It saves the manpower and time cost required to develop the above-mentioned web application, improves development efficiency, and enables a web application and a sub-application that implement the same function to share a basic source code and improve the code reuse rate.

The parent application provides a library of common component libraries and application programming interfaces. The common component library includes a rich set of common components. The application programming interface library includes a rich application programming interface (which can be called a public interface) for developers. Used when developing sub-applications. However, web applications are not able to invoke the above common components and public interfaces. Therefore, in addition to the conversion of the sub-application's files, the common components and public interfaces referenced by the sub-application's files need to be converted. The conversion method of the common component and the common interface will be described in detail below with reference to FIGS. 5A and 5B.

In an alternative embodiment based on the embodiment shown in FIG. 1, please refer to FIG. 5A, the application conversion method further includes the following steps.

Step 501: Select a Web component for implementing the first function from the Web component set for the common component referenced in the file of the sub-application for implementing the first function.

A common component is a component that can be shared by different sub-applications, has a visual form, and is a component of a sub-application page. The common component can also be packaged with logic code for handling events triggered for the common component. Different sub-applications share common components, which can be called the same common component at the same time or at different times. Common components include, but are not limited to, a button component, a progress component, a text component, a form component, a slider component, and the like.

The web component set includes at least one component that is supported on the web side. There are no components on the web side, and the parent application provides a large number of components for developers to use when developing sub-applications. In order to overcome the above problems, in the embodiment of the present application, a plurality of Web components for implementing different functions are written by using the Vue.js framework. The above Web components may also be referred to as Vue components, and are added to the WePY framework, using Vue. The component emulates the functionality of the common component so that the web application runtime with the same functionality as the sub-application can reference the Vue component to implement the functionality of the common component.

Step 502, changing the reference relationship from a common component for implementing the first function to a Web component for implementing the first function.

If the reference relationship in the file of the web application also refers to a common component that implements the first function, the web application cannot implement the first function when it runs. Therefore, it is necessary to change the reference relationship in the file of the sub-application so that the reference relationship in the file of the web application generated according to the file of the sub-application refers to the component in the set of the Web component, not the parent application. Common components in the common component library, so that the files of subsequent web applications can be implemented to achieve the functions of common components.

In summary, the method provided by the embodiment of the present application can implement the common component of the web application by adding a web component in the sub-application development framework and modifying the reference relationship in the file of the sub-application. Features. In an alternative embodiment based on the embodiment shown in FIG. 1, please refer to FIG. 5B, the application conversion method further includes the following steps.

Step 503: Select, for the public interface for implementing the second function, in the file of the sub-application, select a web interface for implementing the second function from the web interface set.

The public interface is an interface that can be shared by different sub-applications. The public interface can be used for network operations, data processing, media operations, operating terminal hardware, or operating sub-application pages. The page logic code in the page logic code file may record the correspondence between the event type and the public interface, or the correspondence between the event type, the common component identifier, and the public interface, so that it may be recorded according to the page logic code in the page logic code file. Correspondence, select the public required to process the event in the public interface library. Referring to Figure 6, there is shown a plurality of common interfaces shown by embodiments of the present application.

The web interface set includes at least one interface supported on the web side. There is no interface on the web side, and the parent application or operating system provides a large number of public interfaces for developers to use when developing sub-applications. In order to overcome the above problem, in the embodiment of the present application, a Web interface supported by the Web is used to write a plurality of Web interfaces for implementing different functions, and is added to the WePY framework, and the Web interface is used to simulate the functions of the public interface.

It should be noted that some public interfaces are not supported on the web, such as payment interfaces. In the embodiment of the present application, only the interface supported by the web terminal is considered, and the interface that cannot be supported by the web end needs to be actively circumvented during the development process.

Step 504, changing the reference relationship from a public interface for implementing the second function to a web interface for implementing the second function.

If the reference relationship in the file of the web application also refers to the public interface that implements the second function, the web application cannot implement the second function when it runs. Therefore, it is necessary to change the reference relationship in the file of the sub-application so that the reference relationship in the file of the web application generated according to the file of the sub-application refers to the interface in the set of the web interface, and is not provided by the parent application. Common components in the public interface library, so that the files of subsequent web applications can be implemented to implement the functions of the public interface.

In summary, the method provided by the embodiment of the present application can implement a public interface by supporting a web application runtime by adding a web interface in a sub-application development framework and modifying a reference relationship in a sub-application file. Features.

The following is an embodiment of the apparatus of the present application, which may be used to implement the method embodiments of the present application. For details not disclosed in the device embodiments of the present application, please refer to the method embodiments of the present application.

Please refer to FIG. 7, which shows a block diagram of an application conversion apparatus provided by an embodiment of the present application. The apparatus has a function of implementing the above-described method examples, and the functions may be implemented by hardware or by hardware to execute corresponding software. The apparatus may include a file obtaining module 701, a first generating module 702, and a second generating module 703.

The file obtaining module 701 is configured to acquire a file of the sub-application.

The sub-application is an application that depends on the parent application; the files of the sub-application include: a first entry file, a global configuration file, and a logical code file for each page.

The first generation module 702 is configured to support an executable file running on the web end according to the file of the sub-application.

The second generation module 703 is configured to generate a file of the web application according to the executable file and a second entry file that is supported to run on the web end, where the executable file is referenced in the second entry file.

Optionally, the executable file includes logic code that supports execution on the web side;

The first generating module 702 is specifically configured to:

For each page, acquiring a plurality of logic code modules included in the logic code file of the page, and calling relationships between the respective logic code modules;

Adding each logical code module of the page to the executable file in order, and adding a number to each logical code module of the page;

Adding an entry code of the page to the executable file according to a call relationship and a number between each logical code module of the page, where an entry code of the page is used to indicate each logical code module of the page The calling relationship between.

Optionally, the file of the sub-application further includes a global style file and a style file of each page, and the executable file further includes a second style file code that supports recognition on the web side;

The first generating module 702 is specifically configured to:

Obtaining the first style file code included in the global style file and the style file of each page;

Converting a size unit in the first style file code from a first unit to a second unit to obtain the second style file code; wherein the first unit is a size unit recognized by the parent application The second unit refers to a unit of size identified on the web side.

Optionally, the file of the sub-application further includes a view file of each page, where the executable file further includes a second view file code that supports recognition on the web end;

The first generating module 702 is specifically configured to:

Obtaining a first view file code included in a view file of each page and written according to a syntax of the sub-application;

Transcoding the first view file into a second view file code written in accordance with a syntax supported by the web.

Optionally, the device further includes: a component selection module and a first modification module (not shown).

a component selection module, configured to select a web component for implementing the first function from a set of web components for a common component referenced in a file of the sub-application for implementing the first function, where the web component set includes At least one component that is supported on the web side.

a first change module for changing a reference relationship from a common component for implementing the first function to a web component for implementing the first function.

Optionally, the device further includes: an interface selection module and a second modification module (not shown).

An interface selection module, configured to select, from a web interface set, a web interface for implementing the second function, for the public interface referenced in the file of the sub-application for implementing the second function, where the web interface includes At least one interface supported on the web side.

And a second change module, configured to change the reference relationship from a public interface for implementing the second function to a web interface for implementing the second function.

In summary, the method provided by the embodiment of the present application provides a technical solution for converting a file of a sub-application into a file of a web application, so that the web application having the same function as the sub-application does not need to be separately developed, thereby It saves the manpower and time cost required for web applications, improves development efficiency, and enables web applications and sub-applications to share a basic set of source code to improve code reuse rate.

It should be noted that, when the device provided by the foregoing embodiment implements its function, only the division of each functional module described above is illustrated. In actual applications, the function distribution may be completed by different functional modules as needed. The internal structure of the device is divided into different functional modules to perform all or part of the functions described above. In addition, the apparatus and method embodiments provided in the foregoing embodiments are in the same concept, and the specific implementation process is described in detail in the method embodiment, and details are not described herein again.

Please refer to FIG. 8 , which is a structural block diagram of an application conversion device 800 (hereinafter referred to as “device 800 ”) provided by an embodiment of the present application. The apparatus 800 includes a central processing unit (CPU) 801, a system memory 804 including a random access memory (RAM) 802 and a read only memory (ROM) 803, and a system bus 805 that connects the system memory 804 and the central processing unit 801. The apparatus 800 also includes a basic input/output system (I/O system) 806 that facilitates transfer of information between various devices within the computer, and mass storage for storing the operating system 813, applications 814, and other program modules 815. Device 807.

The basic input/output system 806 includes a display 808 for displaying information and an input device 809 such as a mouse or keyboard for user input of information. The display 808 and input device 809 are both connected to the central processing unit 801 via an input and output controller 810 that is coupled to the system bus 805. The basic input/output system 806 can also include an input output controller 810 for receiving and processing input from a plurality of other devices, such as a keyboard, mouse, or electronic stylus. Similarly, input and output controller 810 also provides output to a display screen, printer, or other type of output device.

The mass storage device 807 is connected to the central processing unit 801 by a mass storage controller (not shown) connected to the system bus 805. The mass storage device 807 and its associated computer readable medium provide non-volatile storage for the device 800. That is, the mass storage device 807 can include a computer readable medium (not shown) such as a hard disk or a CD-ROM drive.

Without loss of generality, the computer readable medium can include computer storage media and communication media. Computer storage media includes volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Computer storage media include RAM, ROM, EPROM, EEPROM, flash memory or other solid state storage technologies, CD-ROM, DVD or other optical storage, tape cartridges, magnetic tape, magnetic disk storage or other magnetic storage devices. Of course, those skilled in the art will appreciate that the computer storage medium is not limited to the above. The system memory 804 and mass storage device 807 described above may be collectively referred to as a memory.

In accordance with various embodiments of the present application, the apparatus 800 can also be operated by a remote computer connected to the network via a network such as the Internet. That is, the device 800 can be connected to the network 812 through a network interface unit 811 connected to the system bus 805, or can be connected to other types of networks or remote computer systems (not shown) using the network interface unit 811. .

Storing at least one instruction, at least one program, code set or instruction set in the memory, the at least one instruction, the at least one program, the code set or the instruction set being loaded and executed by the processor to implement the above Apply the conversion method.

In an exemplary embodiment, there is also provided a computer readable storage medium having stored therein at least one instruction, at least one program, a code set or a set of instructions, the at least one instruction, the at least one program The code set or instruction set is loaded and executed by a processor of the application conversion device to implement the various steps in the above method embodiments. Alternatively, the computer readable storage medium described above may be a ROM, a random access memory (RAM), a CD-ROM, a magnetic tape, a floppy disk, and an optical data storage device.

In an exemplary embodiment, there is also provided a computer program product for performing the functions of the various steps in the above method embodiments when the computer program product is executed.

It should be understood that "a plurality" as referred to herein means two or more. "and/or", describing the association relationship of the associated objects, indicating that there may be three relationships, for example, A and/or B, which may indicate that there are three cases where A exists separately, A and B exist at the same time, and B exists separately. The character "/" generally indicates that the contextual object is an "or" relationship. The words "first," "second," and similar terms used herein do not denote any order, quantity, or importance, but are used to distinguish different components.

The serial numbers of the embodiments of the present application are merely for the description, and do not represent the advantages and disadvantages of the embodiments.

The above description is only exemplary embodiments of the present application, and is not intended to limit the present application. Any modifications, equivalents, improvements, etc. made within the spirit and principles of the present application are included in the protection of the present application. Within the scope.

Claims

An application conversion method, characterized in that the method comprises:

Obtaining a file of a sub-application, the sub-application is an application running by the parent application, the file of the sub-application includes: a first entry file, a global configuration file, and a logical code file of each page;

Generating an executable file running on the web side of the webpage according to the file of the sub-application;

Generating a file of the web application according to the executable file and supporting a second entry file running on the web side, wherein the executable file is referenced in the second entry file.
The method according to claim 1, wherein the executable file includes logic code supporting execution on the web side;

The generating, according to the file of the sub-application, supports an executable file running on a webpage of the webpage, including:

For each page, acquiring a plurality of logic code modules included in the logic code file of the page, and calling relationships between the respective logic code modules;

Adding each logical code module of the page to the executable file in order, and adding a number to each logical code module of the page;

Adding an entry code of the page to the executable file according to a call relationship and a number between each logical code module of the page, where an entry code of the page is used to indicate each logical code module of the page The calling relationship between.
The method according to claim 1, wherein the file of the sub-application further comprises a global style file and a style file for each page, and the executable file further includes a second style that supports recognition on the web side. File code

The generating, according to the file of the sub-application, supports an executable file running on a webpage of the webpage, including:

Obtaining the first style file code included in the global style file and the style file of each page;

Converting a size unit in the first style file code from a first unit to a second unit to obtain the second style file code; wherein the first unit is a size unit recognized by the parent application The second unit refers to a unit of size identified on the web side.
The method according to claim 1, wherein the file of the sub-application further includes a view file of each page, and the executable file further includes a second view file code that supports recognition on the web side;

The generating, according to the file of the sub-application, supports an executable file running on a webpage of the webpage, including:

Obtaining a first view file code included in a view file of each page and written according to a syntax of the sub-application;

Transcoding the first view file into a second view file code written in accordance with a syntax supported by the web.
The method according to any one of claims 1 to 4, wherein after the obtaining the file of the sub-application, the method further comprises:

For a common component referenced in the file of the sub-application for implementing the first function, a web component for implementing the first function is selected from a set of web components, the web component set including at least one supported on the web side s component;

The reference relationship is changed by a common component for implementing the first function to a web component for implementing the first function.
The method according to any one of claims 1 to 4, wherein after the obtaining the file of the sub-application, the method further comprises:

For the public interface for implementing the second function referenced in the file of the sub-application, the web interface for implementing the second function is selected from the web interface set, and the web interface set includes at least one supported on the web end. Interface;

The reference relationship is changed from a public interface for implementing the second function to a web interface for implementing the second function.
An application conversion method, characterized in that the method comprises:

The computer device acquires a file of the sub-application, the sub-application is an application that depends on the parent application, the file of the sub-application includes: a first entry file, a global configuration file, and a logical code file of each page ;

The computer device generates an executable file that is run on a webpage webpage according to a file of the sub-application;

The computer device generates a file of the web application according to the executable file and a second entry file supported on the web end, and the executable file is referenced in the second entry file.
The method according to claim 7, wherein the executable file includes logic code supporting execution on the web side;

The computer device generates an executable file that is run on the webpage of the webpage according to the file of the sub-application, and includes:

For each page, the computer device acquires a plurality of logic code modules included in a logic code file of the page, and a call relationship between the respective logic code modules;

The computer device adds each logical code module of the page to the executable file in order, and adds a number to each logical code module of the page;

The computer device adds an entry code of the page to the executable file according to a call relationship and a number between each logical code module of the page, where an entry code of the page is used to indicate each page of the page The calling relationship between logical code modules.
The method according to claim 7, wherein the file of the sub-application further comprises a global style file and a style file for each page, and the executable file further includes a second style that supports recognition on the web side. File code

The computer device generates an executable file that is run on the webpage of the webpage according to the file of the sub-application, and includes:

The computer device acquires the first style file code included in the global style file and the style file of each page;

Converting, by the computer device, a unit of size in the first style file code from a first unit to a second unit to obtain the second style file code; wherein the first unit refers to the parent application The identified unit of size, the second unit being the unit of size identified on the web side.
The method according to claim 7, wherein the file of the sub-application further includes a view file of each page, and the executable file further includes a second view file code that supports recognition on the web side;

The computer device generates an executable file that is run on the webpage of the webpage according to the file of the sub-application, and includes:

The computer device acquires a first view file code included in a view file of each page and written according to a syntax of the sub-application;

The computer device transcodes the first view file into a second view file code written in accordance with a syntax supported by the web.
The method according to any one of claims 7 to 10, wherein after the computer device acquires the file of the sub-application, the method further comprises:

For a common component referenced in the file of the sub-application for implementing the first function, the computer device selects a web component for implementing the first function from a set of web components, the web component set including at least one Components supported on the web side;

The computer device changes a reference relationship from a common component for implementing the first function to a web component for implementing the first function.
The method according to any one of claims 7 to 10, wherein after the computer device acquires the file of the sub-application, the method further comprises:

For a public interface for implementing a second function referenced in a file of the sub-application, the computer device selects a web interface for implementing the second function from a set of web interfaces, the web interface set including at least one Interface supported on the web side;

The computer device changes the reference relationship from a public interface for implementing the second function to a web interface for implementing the second function.
An application conversion device, characterized in that the device comprises:

a file obtaining module, configured to acquire a file of a sub-application, where the sub-application is dependent on an application running by the parent application, where the file of the sub-application includes: a first entry file, a global configuration file, and each page Logic code file;

a first generating module, configured to support an executable file running on the web end according to the file of the sub-application;

And a second generating module, configured to generate a file of the web application according to the executable file and a second import file that supports running on the web end, where the executable file is referenced in the second entry file.
The apparatus according to claim 13, wherein said executable file includes logic code supporting execution on the web side;

The first generating module is specifically configured to:

For each page, acquiring a plurality of logic code modules included in the logic code file of the page, and calling relationships between the respective logic code modules;

Adding each logical code module of the page to the executable file in order, and adding a number to each logical code module of the page;

Adding an entry code of the page to the executable file according to a call relationship and a number between each logical code module of the page, where an entry code of the page is used to indicate each logical code module of the page The calling relationship between.
The device according to claim 13, wherein the file of the sub-application further comprises a global style file and a style file for each page, and the executable file further includes a second style that supports recognition on the web side. File code

The first generating module is specifically configured to:

Obtaining the first style file code included in the global style file and the style file of each page;

Converting a unit of size in the first style file code from a first unit to a second unit to obtain the second style file code; wherein the first unit refers to a size recognized by the parent application Unit, the second unit refers to the unit of size identified on the web side.
The device according to claim 13, wherein the file of the sub-application further includes a view file of each page, and the executable file further includes a second view file code that supports recognition on the web side;

The first generating module is specifically configured to:

Obtaining a first view file code included in a view file of each page and written according to a syntax of the sub-application;

Transcoding the first view file into a second view file code written in accordance with a syntax supported by the web.
The device according to any one of claims 13 to 16, wherein the device further comprises:

a component selection module, configured to select a web component for implementing the first function from a set of web components for a common component referenced in a file of the sub-application for implementing the first function, where the web component set includes At least one component supported on the web;

a first change module for changing a reference relationship from a common component for implementing the first function to a web component for implementing the first function.
The device according to any one of claims 13 to 16, wherein the device further comprises:

An interface selection module, configured to select, from a web interface set, a web interface for implementing the second function, for the public interface referenced in the file of the sub-application for implementing the second function, where the web interface includes At least one interface supported on the web side;

And a second change module, configured to change the reference relationship from a public interface for implementing the second function to a web interface for implementing the second function.
A computer device, comprising: a processor and a memory, wherein the memory stores at least one instruction, at least one program, a code set or a set of instructions, the at least one instruction, the at least one program The code set or instruction set is loaded and executed by the processor to implement the application conversion method according to any one of claims 1 to 6.
A computer readable storage medium, wherein the computer readable storage medium stores at least one instruction, at least one program, a code set or a set of instructions, the at least one instruction, the at least one program, the The code set or instruction set is loaded and executed by the processor to implement the application conversion method according to any one of claims 1 to 6.