CN118626135A - File processing method, device, computer equipment and storage medium - Google Patents

Abstract

The present application relates to a file processing method, apparatus, computer device, storage medium and computer program product. The method comprises the following steps: the method comprises the steps of obtaining a code packaging script and a plurality of static resource files, wherein the code packaging script carries configuration files, executing the code packaging script, respectively matching static resource attributes of each static resource file based on the configuration resource attributes in the configuration files to obtain a target resource file and a basic resource file, uploading the target resource file to a server to obtain an online address of the target resource file in the server, and packaging files to be packaged, which contain the online address, the basic resource file and a local address of the basic resource file, to obtain a program package.

Description

File processing method, device, computer equipment and storage medium

Technical Field

The present application relates to the field of big data technology, and in particular to a file processing method, apparatus, computer equipment, storage medium and computer program product.

Background Art

The output of the code packaging process is a program package. In some scenarios, the size of the program package is limited, and the program package needs to be optimized during the development phase so that the space occupied by the program package meets the storage space requirements.

In the existing method, the code files are simplified, specifically by optimizing the code structure, deleting unnecessary code, and using compression algorithms to reduce the code size and the space occupied by the program package. Although this method reduces the code size to a certain extent, it also prolongs the packaging preparation time and reduces the packaging efficiency.

Summary of the invention

Based on this, it is necessary to provide a file processing method, device, computer equipment, computer-readable storage medium and computer program product that can improve packaging efficiency in response to the above technical problems.

In a first aspect, the present application provides a file processing method. The method comprises:

Obtain a code packaging script and multiple static resource files; the code packaging script carries a configuration file; execute the code packaging script, and based on the configuration resource attributes in the configuration file, match the static resource attributes of each of the static resource files respectively to obtain a target resource file and a basic resource file, the target resource file is a static resource file corresponding to the static resource attribute that successfully matches, and the basic resource file is a static resource file corresponding to the static resource attribute that fails to match; upload the target resource file to a server to obtain an online address of the target resource file on the server; package the files to be packaged that include the online address, the basic resource file, and the local address of the basic resource file to obtain a program package.

In one of the embodiments, the configuration resource attributes include resource type conditions and resource size conditions; the static resource attributes include static resource types and static resource sizes; the execution code packaging script, based on the configuration resource attributes in the configuration file, matches the static resource attributes of each of the static resource files respectively to obtain target resource files and basic resource files, including: executing the code packaging script, based on the resource type conditions in the configuration file, matches the static resource types of each of the static resource files respectively to obtain type matching results between the resource type conditions and each of the static resource files respectively; based on the resource size conditions in the configuration file, matches the static resource sizes of each of the static resource files respectively to obtain size matching results between the resource size conditions and each of the static resource files respectively; and dividing each of the static resource files into target resource files and basic resource files according to the type matching results and the size matching results.

In one of the embodiments, the static resource files are divided into target resource files and basic resource files according to the type matching results and the size matching results, including: screening the static resource files whose resource types are successfully matched in the static resource files according to the type matching results; screening the static resource files whose resource sizes are successfully matched in the static resource files according to the size matching results; merging the static resource files whose resource types are successfully matched and the static resource files whose resource sizes are successfully matched to obtain the target resource files; and determining the static resource files except the target resource files as basic resource files.

In one of the embodiments, uploading the target resource file to the server and obtaining the online address of the target resource file on the server includes: determining multiple candidate servers that match the static resource attributes of the target resource file; selecting a target server from each candidate server according to the load characteristics of each candidate server; uploading the target resource file to the target server, and receiving the online address of the target resource file on the target server sent by the target server.

In one of the embodiments, the packaging of the files to be packaged including the online address, the basic resource file, and the local address of the basic resource file to obtain a program package includes: extracting candidate resource files that have a resolution association relationship with the basic resource file from a resource file library; determining the basic local address of the basic resource file and the candidate local addresses of the candidate resource files; packaging the files to be packaged including the online address, the basic local address, the candidate local address, the basic resource file, and the candidate resource file to obtain a program package.

In one of the embodiments, the obtaining of multiple static resource files includes: obtaining a project code in a file to be packaged; scanning the project code to obtain multiple candidate resource files corresponding to the project code; performing file class optimization processing on each of the candidate resource files to obtain multiple static resource files; the packaging processing of the file to be packaged including the online address, the basic resource file, and the local address of the basic resource file to obtain a program package includes: packaging processing of the project code including the online address, the local address of the basic resource file, and the basic resource file to obtain a program package.

In a second aspect, the present application also provides a file processing device. The device comprises:

An acquisition module is used to acquire a code packaging script and multiple static resource files; the code packaging script carries a configuration file; a matching module is used to execute the code packaging script, and based on the configuration resource attributes in the configuration file, the static resource attributes of each of the static resource files are matched to obtain a target resource file and a basic resource file, the target resource file is a static resource file corresponding to a successfully matched static resource attribute, and the basic resource file is a static resource file corresponding to a failed matching static resource attribute; an upload module is used to upload the target resource file to a server to obtain an online address of the target resource file on the server; a packaging module is used to package and process the files to be packaged that include the online address, the basic resource file, and the local address of the basic resource file to obtain a program package.

In a third aspect, the present application further provides a computer device. The computer device includes a memory and a processor, the memory stores a computer program, and the processor implements the following steps when executing the computer program:

Obtain a code packaging script and multiple static resource files, wherein the code packaging script carries a configuration file; execute the code packaging script, and match the static resource attributes of each of the static resource files based on the configuration resource attributes in the configuration file to obtain a target resource file and a basic resource file, wherein the target resource file is a static resource file corresponding to a successfully matched static resource attribute, and the basic resource file is a static resource file corresponding to a failedly matched static resource attribute; upload the target resource file to a server to obtain an online address of the target resource file on the server; package the files to be packaged, which include the online address, the basic resource file, and the local address of the basic resource file, to obtain a program package.

In a fourth aspect, the present application further provides a computer-readable storage medium. The computer-readable storage medium stores a computer program, and when the computer program is executed by a processor, the following steps are implemented:

Obtain a code packaging script and multiple static resource files, wherein the code packaging script carries a configuration file; execute the code packaging script, and match the static resource attributes of each of the static resource files based on the configuration resource attributes in the configuration file to obtain a target resource file and a basic resource file, wherein the target resource file is a static resource file corresponding to a successfully matched static resource attribute, and the basic resource file is a static resource file corresponding to a failedly matched static resource attribute; upload the target resource file to a server to obtain an online address of the target resource file on the server; package the files to be packaged, which include the online address, the basic resource file, and the local address of the basic resource file, to obtain a program package.

In a fifth aspect, the present application further provides a computer program product. The computer program product includes a computer program, and when the computer program is executed by a processor, the following steps are implemented:

Obtain a code packaging script and multiple static resource files, wherein the code packaging script carries a configuration file; execute the code packaging script, and match the static resource attributes of each of the static resource files based on the configuration resource attributes in the configuration file to obtain a target resource file and a basic resource file, wherein the target resource file is a static resource file corresponding to a successfully matched static resource attribute, and the basic resource file is a static resource file corresponding to a failedly matched static resource attribute; upload the target resource file to a server to obtain an online address of the target resource file on the server; package the files to be packaged that include the online address, the basic resource file, and the local address of the basic resource file to obtain a program package.

The above-mentioned file processing method, device, computer equipment, storage medium and computer program product obtain a code packaging script and multiple static resource files. The code packaging script carries a configuration file. The code packaging script is executed. Based on the configuration resource attributes in the configuration file, the static resource attributes of each static resource file are matched respectively to obtain a target resource file and a basic resource file. The target resource file is a static resource file corresponding to the static resource attribute that successfully matches, and the basic resource file is a static resource file corresponding to the static resource attribute that fails to match. The configuration file carried by the packaging script is used to divide each static resource file, which is convenient for subsequent different processing of different static resource files. The target resource file is uploaded to the server, and the online address of the target resource file on the server is obtained. The files to be packaged containing the online address, the basic resource file, and the local address of the basic resource file are packaged and processed to obtain a program package. There is no need to package the target static resources, which reduces the space occupied by the program package. This method uses a script to divide each static resource file in an automated manner, which reduces the packaging time and improves the packaging efficiency.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG1 is an application environment diagram of a file processing method in one embodiment;

FIG2 is a schematic diagram of a flow chart of a file processing method in one embodiment;

FIG3 is a schematic diagram of a process of a static resource file packaging and replacement method in one embodiment;

FIG4 is a structural block diagram of a file processing device in one embodiment;

FIG. 5 is a diagram showing the internal structure of a computer device in one embodiment.

DETAILED DESCRIPTION

In order to make the purpose, technical solution and advantages of the present application more clearly understood, the present application is further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application and are not used to limit the present application.

The file processing method provided in the embodiment of the present application can be applied in the application environment shown in FIG1 . In which, the terminal 102 communicates with the server 104 through a network. The data storage system can store the data that the server 104 needs to process. The data storage system can be integrated on the server 104, or it can be placed on the cloud or other network servers.

Terminal 102 obtains a code packaging script and multiple static resource files. The code packaging script carries a configuration file. Terminal 102 executes the code packaging script. Based on the configuration resource attributes in the configuration file, the terminal 102 matches the static resource attributes of each static resource file respectively to obtain a target resource file and a basic resource file. The target resource file is a static resource file corresponding to the static resource attribute that is successfully matched, and the basic resource file is a static resource file corresponding to the static resource attribute that fails to match. Terminal 102 uploads the target resource file to server 104 to obtain an online address of the target resource file on server 104. Terminal 102 packages the files to be packaged that include the online address, the basic resource file, and the local address of the basic resource file to obtain a program package.

The terminal 102 may be, but is not limited to, various personal computers, laptops, smart phones, tablet computers, IoT devices, and portable wearable devices. The IoT devices may be smart speakers, smart TVs, smart air conditioners, smart car-mounted devices, etc. The portable wearable devices may be smart watches, smart bracelets, head-mounted devices, etc. The server 104 may be implemented as an independent server or a server cluster consisting of multiple servers.

In one embodiment, as shown in FIG. 2 , a file processing method is provided, which is described by taking the method applied to the terminal in FIG. 1 as an example, including:

S202, obtaining a code packaging script and multiple static resource files, where the code packaging script carries a configuration file.

The code packaging script may be a script used in the code packaging process, and the code packaging script has file processing functions such as file query, file screening, file upload, and file packaging. The objects of the code packaging script may be code files and various resource files. The code files contain specific codes, and the index relationships between the codes and various resource files.

Among them, the configuration file can be a file of the corresponding operation type in the code packaging script. Specifically, the resource file is processed accordingly through the configured attributes in the configuration file. For example, the configured attribute can be the file type of the resource file, such as JPG format, and multiple resource files in JPG format are screened from multiple resource files based on the file type of the resource file. For another example, the configured attribute can be the file size threshold of the resource file, and a resource file whose file size is greater than the file size threshold is selected from multiple resource files.

Among them, static resource files are files that do not change with the code logic or database status during the code development process. Static resource files usually represent predefined content, such as image files, video files, font files, etc. In order to reduce the storage space occupied by the program package, static resource files can be distributed to the server, and the static resource files can be retrieved from the server in real time when the program package is used.

Among them, font files include ttf, eot, woff, woff2, etc., which are used to display specific font styles on web pages. These font files can ensure that the required fonts can be displayed when browsing on different terminals.

Optimization of static resource files is an important part of the code development and packaging process. For example, some static resource files can be selected from multiple static resource files and uploaded to the server, thereby reducing the number of local static resources and the space occupied by local static resources, thereby reducing the storage space occupied by the package.

S204, execute the code packaging script, and match the static resource attributes of each static resource file based on the configuration resource attributes in the configuration file to obtain the target resource file and the basic resource file. The target resource file is the static resource file corresponding to the static resource attribute that is successfully matched, and the basic resource file is the static resource file corresponding to the static resource attribute that fails to match.

The configuration resource attribute refers to the attribute pre-configured or predetermined in the code packaging script. The attribute can describe the static characteristics of the file, which does not change with time or environment.

Exemplarily, the configuration resource attribute may be the type of static resource file, the size of the static resource file, etc. The type of static resource file may include image files, video files, font files, etc. The size of the static resource file indicates the size of the storage space occupied by the static resource file.

The static resource attributes represent the attributes corresponding to the static resource files, and the static resource attributes may also include the type of the static resource files, the size of the static resource files, and the like.

It should be noted that the configuration resource attributes are predefined resource attributes in the code packaging script, which can be one or more resource attributes. The configuration resource attributes can be adjusted according to the internal logic of the code script, and the static resource attributes are the resource attributes corresponding to each static resource file. This resource attribute generally does not change and can be understood as an inherent characteristic of a static resource file.

Among them, the target resource file is the static resource file corresponding to the successfully matched static resource attribute. Successful matching means that the static resource file is the extraction object of the code packaging script. The successfully matched static resource file is extracted and sent to the server, reducing the storage space occupied by the program package.

Among them, the basic resource file is the static resource file corresponding to the static resource attribute that failed to match. The matching failure indicates that the static resource file is not the extraction object of the code packaging script. The static resource file that failed to match is packaged together with other files to obtain a program package.

S206, uploading the target resource file to the server, and obtaining the online address of the target resource file on the server.

Among them, the server can be a server for storing target resource files, and the number of servers can be multiple. Specifically, according to certain server screening rules, a target server is selected from multiple servers, the target resource file is uploaded to the target server, and the server address of the target resource file on the target server is obtained.

Specifically, the code packaging script may be controlled to upload the target resource file to the server, wherein the code packaging script also carries the resource file server address, and the code packaging script is controlled to upload the target resource file to the server corresponding to the server address.

The online address indicates the calling address of the target resource file returned by the server after the target resource file is sent to the server. When the program package is running in the actual scenario, the target resource file is called in the server through the calling address.

Exemplarily, when the program package is running in the mini-program scenario, the pre-stored target resource file can be called in the server through the calling address, the target resource file can be parsed, the target resource can be obtained, and the target resource can be displayed on the corresponding page.

S208, packaging the files to be packaged including the online address, the basic resource file, and the local address of the basic resource file to obtain a program package.

The local address of the basic resource file indicates the index address of the basic resource in the code file. The basic resource file can be directly called according to the index address during the code file operation. Calling resource files from the local is faster than calling resource files from the server.

The program package may be an executable package including code files, static resource files, etc. The program package may be sent to a specific server, and in response to an interface confirmation operation corresponding to the program package, the program package may be obtained and run.

Exemplarily, in the mini-program usage scenario, in response to a user clicking on the mini-program, the program package corresponding to the mini-program is obtained and run. During the running process, the program package calls the basic resource files from the user terminal locally and calls the target resource files from the server.

In the above file processing method, a code packaging script and multiple static resource files are obtained. The code packaging script carries a configuration file. The code packaging script is executed. Based on the configuration resource attributes in the configuration file, the static resource attributes of each static resource file are matched respectively to obtain a target resource file and a basic resource file. The target resource file is a static resource file corresponding to the static resource attribute that is successfully matched, and the basic resource file is a static resource file corresponding to the static resource attribute that fails to match. The configuration file carried by the packaging script is used to divide each static resource file, which is convenient for subsequent different processing of different static resource files. The target resource file is uploaded to the server, and the online address of the target resource file on the server is obtained. The files to be packaged that include the online address, the basic resource file, and the local address of the basic resource file are packaged and processed to obtain a program package. There is no need to package the target static resources, which reduces the space occupied by the program package. This method uses a script to divide each static resource file in an automated manner, which reduces the time consumed by packaging and improves the packaging efficiency.

In one embodiment, the configuration resource attributes include resource type conditions and resource size conditions, the static resource attributes include static resource types and static resource sizes, and the code packaging script is executed to match the static resource attributes of each static resource file based on the configuration resource attributes in the configuration file to obtain the target resource file and the basic resource file, including:

Execute the code packaging script, match the static resource type of each static resource file based on the resource type conditions in the configuration file, and obtain the type matching results between the resource type conditions and each static resource file.

Based on the resource size conditions in the configuration file, the static resource sizes of the static resource files are matched respectively to obtain size matching results between the resource size conditions and the static resource files;

According to the type matching results and the size matching results, each static resource file is divided into a target resource file and a basic resource file.

The code packaging script may be a script used in the code packaging process, and the code packaging script has file processing functions such as file query, file screening, file upload, and file packaging. The objects of the code packaging script may be code files and various resource files. The code files contain specific codes, and the index relationships between the codes and various resource files.

The configuration file may be a file of a corresponding operation type in the code packaging script. Specifically, the resource file is processed accordingly through the configured attributes in the configuration file.

The configuration resource attribute refers to the attribute pre-configured or predetermined in the code packaging script. The attribute can describe the static characteristics of the file, which does not change with time or environment.

Specifically, the configuration resource attributes include a resource type condition and a resource size condition. The resource type condition may represent a pre-configured or pre-defined file type, for example, at least one of a JPG type file, a PNG type file, and a WOFF type file. The resource size condition may represent a pre-configured or pre-defined file size, for example, a single file size is greater than 50-100k.

The static resource attributes represent the attributes corresponding to the static resource files, and the static resource attributes may also include the type of the static resource files, the size of the static resource files, and the like.

Specifically, the static resource attributes include static resource type and static resource size. The static resource type indicates the file type of the static resource file, such as JPG, PNG, WOFF, etc. The static resource size indicates the size of the space occupied by the static resource file.

Among them, the type matching result describes the matching results between the resource type condition and each static resource file respectively. The matching results include successful matching and failed matching. Successful matching means that the static resource type of the static resource file is the same or similar to the resource type corresponding to the resource type condition. For example, the resource type condition can be a JPG type, and each static resource file of the JPG type can successfully match the resource type condition, and other types of static resource files can fail to match the resource type condition. It can also be that both JPG type and PNG type static resource files successfully match the resource type condition, and other types of static resource files fail to match the resource type condition. PNG type and JPG type are similar types.

Among them, the size matching result describes the matching result between the resource size condition and each static resource file. The matching result includes a successful match and a failed match. A successful match means that the static resource size of the static resource file is within the numerical range corresponding to the resource size condition. For example, the resource size condition can be that a single file is larger than 80kb. When the static resource size of a static resource file, that is, the size of the storage space occupied, is larger than 80kb, it is considered that the static resource file successfully matches the resource size condition, otherwise the match fails.

Among them, the type matching result includes a successful match and a failed match, and the size matching result includes a successful match and a failed match. It can be understood that for a static resource file, the static resource file corresponds to a type matching result and a size matching result.

Specifically, each static resource file may be divided into a target resource file or a basic resource file according to a type matching result and a size matching result corresponding to the static resource.

The target resource file is a resource file that will be stored in other locations and does not occupy the space of the program package. For example, the target resource file is sent to the server. The basic resource file is a resource file in the program package.

It can be understood that the type matching result and the size matching result corresponding to the target resource file may both be successful. In this case, at least one of the type matching result and the size matching result corresponding to the basic resource file is a matching failure.

At least one of the type matching result and the size matching result corresponding to the target resource file may be a successful match. In this case, both the type matching result and the size matching result corresponding to the basic resource file are failed matches.

In this embodiment, by executing the code packaging script, based on the resource type conditions in the configuration file, the static resource types of each static resource file are matched respectively, and the type matching results between the resource type conditions and each static resource file are obtained; based on the resource size conditions in the configuration file, the static resource sizes of each static resource file are matched respectively, and the size matching results between the resource size conditions and each static resource file are obtained; according to the type matching results and the size matching results, each static resource file is divided into a target resource file and a basic resource file, and each static resource file is accurately divided, which facilitates the subsequent different processing of the target resource file and the basic resource file, and provides a basis for reducing the packaging time and improving the packaging efficiency.

In one embodiment, each static resource file is divided into a target resource file and a basic resource file according to the type matching result and the size matching result, including: screening the static resource files whose resource types are successfully matched in each static resource file according to each type matching result, screening the static resource files whose resource sizes are successfully matched in each static resource file according to each size matching result, merging the static resource files whose resource types are successfully matched and the static resource files whose resource sizes are successfully matched to obtain the target resource file, and determining each static resource file except the target resource file as a basic resource file.

Among them, the type matching result includes a successful match and a failed match, and the size matching result includes a successful match and a failed match. It can be understood that for a static resource file, the static resource file corresponds to a type matching result and a size matching result.

Specifically, according to the matching results of each type, the static resource files whose resource types are successfully matched among the static resource files can be screened. The number of static resource files whose resource types are successfully matched can be multiple.

Specifically, according to the size matching results, the static resource files with successful resource size matching among the static resource files can be screened. The number of static resource files with successful resource size matching can be multiple.

The static resource file whose resource type matches successfully can be called a first static resource file, and the static resource file whose resource size matches successfully can be called a second static resource file.

Among them, merging the static resource files that successfully match the resource type and the static resource files that successfully match the resource size, that is, merging the first static resource file and the second static resource file. The merging representation will indicate that multiple first static resource files and multiple second static resource files are merged into a set, and any one of the first static resource files and the second static resource files representing the same static resource file is filtered out. Exemplarily, the first static resource file includes a, b, c, and the second static resource file includes b and d. The merging first merges a, b, c, and b, d to obtain a, b, b, c, d, and then any one of the two b is filtered out to obtain a, b, c, d. The target resource files include a, b, c, d.

Among them, the basic resource file refers to the resource file in the program package. The target resource file refers to the resource file that is not in the program package. It should be noted that the local index address of the basic resource file is stored in the code in the program package, and the index address corresponding to the target resource file is also stored in the code in the program package. When the code is running, the resource file is called according to the index address to the address corresponding to the index address.

In this embodiment, according to the results of each type matching, the static resource files whose resource types are successfully matched in each static resource file are screened, and according to the results of each size matching, the static resource files whose resource sizes are successfully matched in each static resource file are screened, and the static resource files whose resource types are successfully matched and the static resource files whose resource sizes are successfully matched are merged to obtain the target resource file, and each static resource file except the target resource file is determined as a basic resource file, and each static resource file is accurately divided, so as to facilitate the subsequent different processing of the target resource file and the basic resource file, respectively, and provide a basis for reducing the packaging time and improving the packaging efficiency.

In one embodiment, the target resource file is uploaded to the server to obtain the online address of the target resource file on the server, including: determining multiple candidate servers that match the static resource attributes of the target resource file, selecting a target server from each candidate server according to the load characteristics of each candidate server, uploading the target resource file to the target server, and receiving the online address of the target resource file on the target server sent by the target server.

The candidate server may be a server for storing various types of static resources. The target resource may be stored in different candidate servers, and then the target resource server may be called from the candidate server. In order to improve the efficiency of the server receiving and sending the target resource file, a specific server may be selected from multiple candidate servers, and the target resource file may be sent to the specific server.

The target server may be a server selected from the candidate servers according to the load characteristics of the candidate servers.

The load characteristics represent the server workload, and the load characteristics include: CPU load, memory load, and IO load.

Specifically, for the CPU load, memory load, and IO load of a candidate server, the CPU load, memory load, and IO load are scored according to certain rules to obtain the load characteristic value of the candidate server, and then according to the load characteristic values of each candidate server, the server with the largest load characteristic value is selected as the target server. The CPU load, memory load, and IO load of the candidate server are scored respectively to obtain the CPU load score, memory load score, and IO load score, and then the CPU load score, memory load score, and IO load score are averaged to obtain the load characteristic value of the candidate server. The higher the load characteristic value of the candidate server, the closer the candidate server is to the idle state, and the faster it is to receive and send the target resource file.

After the target server is determined, the target resource file is uploaded to the target server, and the online address of the target resource file on the target server sent by the target server is received. The online address represents the storage address of the target resource file in the server. When the program package is running, the storage address can be called to retrieve the target resource file.

In this embodiment, multiple candidate servers that match the static resource attributes of the target resource file are determined, and a target server is selected from each candidate server according to the load characteristics of each candidate server. The target resource file is uploaded to the target server, and the online address of the target resource file on the target server sent by the target server is received. A target server that is faster in receiving and sending the target resource file is selected, thereby improving the sending and receiving efficiency of the target resource file.

In one embodiment, the files to be packaged, which include an online address, a basic resource file, and a local address of the basic resource file, are packaged to obtain a program package, including: extracting candidate resource files that have a resolution association relationship with the basic resource file from a resource file library, determining a basic local address of the basic resource file and a candidate local address of the candidate resource file, and packaging the files to be packaged, which include an online address, a basic local address, a candidate local address, a basic resource file, and a candidate resource file, to obtain a program package.

The resource file library may be a database storing various resource files, wherein the database stores various resource files, and for a specific resource file, the database also stores candidate resource files having a resolution association relationship with the resource file. The type of database is not limited here.

The resolution association relationship indicates the relationship between multiple resource files representing the same resource content. The difference between multiple resource files with a resolution association relationship is that the resolutions of the resource files are different, and the sizes of space occupied by the resource files are different. The difference between the basic resource file and each candidate resource file is that the resolutions of the resource files are different, and the sizes of space occupied by the resource files are different.

Specifically, candidate resource files that have a resolution association relationship with basic resource files are extracted from the resource file library, and the basic resource files and candidate resource files can be packaged at the same time to obtain a program package, and multiple resolution display solutions are provided when the program package is running, providing users with a comprehensive reference.

The basic local address represents the local calling address of the basic resource file, and the basic resource file can be called according to the calling address, and the basic resource corresponding to the basic resource file is displayed. Similarly, the candidate local address represents the local calling address of the candidate resource file, and the candidate resource file can be called according to the calling address, and the candidate resource corresponding to the candidate resource file is displayed.

The resolution and space occupied by the candidate resource files can be larger than the basic resource files, so that the obtained program package contains clearer basic resource files, which improves the display accuracy. The resolution and space occupied by the candidate resource files can be smaller than the basic resource files, so that the obtained program package contains more blurred basic resource files, which can be applied to interfaces with different display accuracy requirements. By directly calling candidate resource files of different resolutions, there is no need to blur the basic resource files, which saves the time consumed by blurring the basic resource files and improves the file processing efficiency.

In this embodiment, candidate resource files that have a resolution association relationship with the basic resource files are extracted from the resource file library, the basic local address of the basic resource file and the candidate local addresses of the candidate resource files are determined, and the files to be packaged including the online address, the basic local address, the candidate local address, the basic resource file, and the candidate resource file are packaged to obtain a program package, which includes candidate resource files of different resolution sizes, thereby providing a basis for displaying resource files with different resolutions and improving the display effect.

In one embodiment, multiple static resource files are obtained, including: obtaining project codes in the files to be packaged, scanning the project codes to obtain multiple candidate resource files corresponding to the project codes, performing file class optimization processing on each candidate resource file to obtain multiple static resource files, and packaging the files to be packaged including online addresses, basic resource files, and local addresses of basic resource files to obtain a program package, including: packaging the project codes including online addresses, local addresses of basic resource files, and basic resource files to obtain a program package.

Among them, the files to be packaged refer to files that have not been packaged, and the files to be packaged include project codes and static resource files. Specifically, some static resource files are selected from multiple static resource files in the files to be packaged as target resource files, and the remaining static resource files are used as basic resource files. Then, the files to be packaged containing the basic resource files are packaged and processed to obtain a program package. In this way, by reducing the number of static resource files included in the files to be packaged, the size of the program package is reduced, so that the size of the program package meets the storage space requirements. For example, in the mini program scenario, the storage space corresponding to the program package requires that the program package size is less than 2~4MB.

Among them, project code can refer to the programming code used by any specific project. A project may contain multiple programming languages, libraries, frameworks, and tools, and these codes may be distributed in multiple files, directories, and modules. The project code contains the calling function addresses of various resource files, and the project code contains the calling addresses of static resource files.

Specifically, each calling address in the project code is scanned to obtain a plurality of candidate resource files corresponding to the project code.

Among them, the alternative resource file refers to the resource file that has a direct calling relationship with the project code.

In order to improve the running performance of the program package and the user experience, each candidate resource file is subjected to file class optimization processing to obtain the candidate resource files after each file class optimization processing, that is, each static resource file.

The file type optimization processing includes compression processing of candidate resource files, optimization processing of the format of candidate resource files, etc. Exemplarily, compression processing of candidate resource files may be to compress comments, blanks, unused CSS selectors, etc. in the resource files. Optimization processing of the format of candidate resource files may be to convert the format of the candidate resource files using a format conversion tool to reduce the file size.

Specifically, after obtaining multiple static resource files, the multiple static resource files are divided into target resource files and basic resource files through the above file processing method, and the target resource files are sent to the server to obtain the online address of the target resource files. At this time, the files to be packaged include project codes and basic resource files, and the local address of the basic resource files and the online address of the target resource files are stored in the project code. By packaging the project code and the basic resource files, a program package is obtained.

In this embodiment, the project code in the file to be packaged is obtained, the project code is scanned, and multiple candidate resource files corresponding to the project code are obtained. File class optimization processing is performed on each candidate resource file to obtain multiple static resource files, and the project code containing the online address, the local address of the basic resource file, and the basic resource file are packaged to obtain a program package, and file class optimization processing is performed on each candidate resource file to reduce the size of the space occupied by the resource file, and the size of the space occupied by the program package is reduced as much as possible, so that the size of the program package meets the storage space size requirement.

It should be noted that for the sake of operational efficiency and storage costs, WeChat Mini Programs have size requirements when uploading versions to the server. Currently, the uploaded code size cannot exceed 2M. Current customer acquisition activity projects have a large number of resource files, such as pictures and videos for display. These resource files are still subject to the upload code size limit. Currently, local resource files are generally used in the development phase for such resource files. When uploading the official version, they are replaced with resource files using online addresses. Developers need to manually perform this step to replace the path of the file used.

This manual operation brings some problems: for example, 1. Manual checking is required when uploading the official version, which is time-consuming and laborious; 2. The project maintenance cost is high, and it is more laborious to replace new resource files; 3. When new people are added to the project team, the cost for new developers to familiarize themselves with the project is high.

In one embodiment, as shown in FIG. 3 , the static resource file packaging and replacement method is a flowchart of the static resource file packaging and replacement method, which includes:

S302, obtaining a code packaging script, where the code packaging script carries a configuration file.

Among them, the processing tool for obtaining the code packaging script, executing the script, and adjusting the program package can be the WeChat Mini Program IDE. The WeChat Mini Program IDE is a tool to help developers develop and debug WeChat Mini Programs simply and efficiently.

Among them, the code packaging script is a script written by the webpack tool. Webpack is a code compilation tool with entry, exit, loader and plug-in. Webpack is a static module packaging tool for modern JavaScript applications.

S304, obtaining the project code in the file to be packaged.

S306, scanning the project code to obtain multiple candidate resource files corresponding to the project code.

Among them, the code packaging script has the function of code scanning.

S308, performing file type optimization processing on each candidate resource file to obtain multiple static resource files.

S310, executing the code packaging script, matching the static resource type of each static resource file based on the resource type condition in the configuration file, and obtaining the type matching results between the resource type condition and each static resource file.

The configuration resource attributes include resource type conditions and resource size conditions. The static resource attributes include static resource type and static resource size.

Exemplarily, the configuration file is configured with the data required for the packaging script, including: 1. The type conditions of the static resource files that need to be identified, for example, jpg, png, woff, etc.; 2. The size conditions of the static resource files, for example, the size of the static resource files is less than 100KB; 3. The server login account and password corresponding to the target resource file, and the storage path of the target resource file in the server.

S312, based on the resource size condition in the configuration file, respectively match the static resource size of each static resource file to obtain size matching results between the resource size condition and each static resource file.

S314, according to the matching results of each type, filter the static resource files whose resource types have successfully matched among the static resource files.

S316, according to the size matching results, filter the static resource files whose resource sizes have successfully matched among the static resource files.

S318, merging the static resource files whose resource types are successfully matched and the static resource files whose resource sizes are successfully matched, to obtain the target resource files and the basic resource files.

Among them, each static resource file except the target resource file is determined as a basic resource file.

The target resource file is a static resource file corresponding to a successfully matched static resource attribute, and the basic resource file is a static resource file corresponding to a failedly matched static resource attribute.

S320: Determine multiple candidate servers that match the static resource attributes of the target resource file.

S322: Select a target server from the candidate servers according to the load characteristics of the candidate servers.

S324, uploading the target resource file to the target server, and receiving the online address of the target resource file on the target server sent by the target server.

S326, extracting candidate resource files having a resolution association relationship with the basic resource file from the resource file library.

S328, determining the basic local address of the basic resource file and the candidate local addresses of the candidate resource files.

S330, packaging the files to be packaged including the online address, the basic local address, the candidate local address, the basic resource file, and the candidate resource file to obtain a program package.

The packaging process of the files to be packaged also includes: packaging the project codes including the online address, the basic local address, the candidate local address, and the files to be packaged including the basic resource files and the candidate resource files to obtain a program package.

S332, packaging the project code including the online address, the local address of the basic resource file, and the basic resource file to obtain a program package.

Among them, the program packages obtained in the above steps can all be used to run WeChat mini-programs. WeChat mini-programs are applications that run in the WeChat app and can be used without downloading and installing.

In this embodiment, a code packaging script and multiple static resource files are obtained. The code packaging script carries a configuration file. The code packaging script is executed. Based on the configuration resource attributes in the configuration file, the static resource attributes of each static resource file are matched respectively to obtain a target resource file and a basic resource file. The target resource file is a static resource file corresponding to the static resource attribute that successfully matches, and the basic resource file is a static resource file corresponding to the static resource attribute that fails to match. The configuration file carried by the packaging script is used to divide each static resource file, which is convenient for subsequent different processing of different static resource files. The target resource file is uploaded to the server, and the online address of the target resource file on the server is obtained. The files to be packaged containing the online address, the basic resource file, and the local address of the basic resource file are packaged and processed to obtain a program package. There is no need to package the target static resource, which reduces the space occupied by the program package. This method uses a script to divide each static resource file into an automated manner, which reduces the packaging consumption time and improves the packaging efficiency. In this method, the cumbersome, time-consuming and labor-intensive operations that need to be performed manually are automatically completed by the webpack packaging script, which reduces the workload of developers, reduces maintenance costs, and also reduces the project's start-up and learning costs. By writing webpack scripts, the resource files used are automatically identified and uploaded to the server, and the file paths in the code are automatically replaced, which reduces the workload of developers, reduces maintenance costs, and also reduces the cost of getting started and learning the project.

It should be understood that, although the various steps in the flowcharts involved in the above-mentioned embodiments are displayed in sequence according to the indication of the arrows, these steps are not necessarily executed in sequence according to the order indicated by the arrows. Unless there is a clear explanation in this article, the execution of these steps does not have a strict order restriction, and these steps can be executed in other orders. Moreover, at least a part of the steps in the flowcharts involved in the above-mentioned embodiments can include multiple steps or multiple stages, and these steps or stages are not necessarily executed at the same time, but can be executed at different times, and the execution order of these steps or stages is not necessarily carried out in sequence, but can be executed in turn or alternately with other steps or at least a part of the steps or stages in other steps.

Based on the same inventive concept, the embodiment of the present application also provides a file processing device for implementing the file processing method involved above. The implementation solution provided by the device to solve the problem is similar to the implementation solution recorded in the above method, so the specific limitations in one or more file processing device embodiments provided below can refer to the limitations on the file processing method above, and will not be repeated here.

In one embodiment, as shown in FIG. 4 , a file processing device is provided, including: an acquisition module 402, a matching module 404, an upload module 406 and a packaging module 408, wherein:

The acquisition module 402 is used to acquire a code packaging script and multiple static resource files, where the code packaging script carries a configuration file;

The matching module 404 is used to execute the code packaging script, and match the static resource attributes of each static resource file based on the configuration resource attributes in the configuration file to obtain a target resource file and a basic resource file, wherein the target resource file is a static resource file corresponding to the static resource attribute that successfully matches, and the basic resource file is a static resource file corresponding to the static resource attribute that fails to match;

The upload module 406 is used to upload the target resource file to the server and obtain the online address of the target resource file on the server;

The packaging module 408 is used to package the files to be packaged including the online address, the basic resource file, and the local address of the basic resource file to obtain a program package.

In one of the embodiments, the configuration resource attributes include resource type conditions and resource size conditions; the static resource attributes include static resource types and static resource sizes; the matching module 404 is also used to execute the code packaging script, and based on the resource type conditions in the configuration file, the static resource types of each static resource file are matched respectively to obtain type matching results between the resource type conditions and each static resource file; based on the resource size conditions in the configuration file, the static resource sizes of each static resource file are matched respectively to obtain size matching results between the resource size conditions and each static resource file; according to the type matching results and the size matching results, each static resource file is divided into a target resource file and a basic resource file.

In one of the embodiments, the matching module 404 is also used to filter the static resource files whose resource types are successfully matched in each static resource file according to the matching results of each type; filter the static resource files whose resource sizes are successfully matched in each static resource file according to the matching results of each size; merge the static resource files whose resource types are successfully matched and the static resource files whose resource sizes are successfully matched to obtain the target resource file; and determine each static resource file except the target resource file as the basic resource file.

In one of the embodiments, the upload module 406 is also used to determine multiple candidate servers that match the static resource attributes of the target resource file; select a target server from each candidate server according to the load characteristics of each candidate server; upload the target resource file to the target server, and receive the online address of the target resource file on the target server sent by the target server.

In one of the embodiments, the packaging module 408 is also used to extract candidate resource files that have a resolution association relationship with the basic resource files in the resource file library; determine the basic local address of the basic resource file and the candidate local address of the candidate resource file; and package the files to be packaged that include the online address, the basic local address, the candidate local address, the basic resource file, and the candidate resource file to obtain a program package.

In one of the embodiments, the acquisition module 402 is also used to obtain the project code in the file to be packaged; scan the project code to obtain multiple alternative resource files corresponding to the project code; perform file class optimization processing on each alternative resource file to obtain multiple static resource files; the packaging module 408 is also used to package the project code containing the online address, the local address of the basic resource file, and the basic resource file to obtain a program package.

Each module in the above-mentioned file processing device can be implemented in whole or in part by software, hardware or a combination thereof. Each module can be embedded in or independent of a processor in a computer device in the form of hardware, or can be stored in a memory in a computer device in the form of software, so that the processor can call and execute the operations corresponding to each module above.

In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be shown in FIG5. The computer device includes a processor, a memory, an input/output interface (Input/Output, referred to as I/O) and a communication interface. The processor, the memory and the input/output interface are connected via a system bus, and the communication interface is connected to the system bus via the input/output interface. The processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, a computer program and a database. The internal memory provides an environment for the operation of the operating system and the computer program in the non-volatile storage medium. The database of the computer device is used to store static resource file data. The input/output interface of the computer device is used to exchange information between the processor and an external device. The communication interface of the computer device is used to communicate with an external terminal via a network connection. When the computer program is executed by the processor, a file processing method is implemented.

Those skilled in the art will understand that the structure shown in FIG. 5 is merely a block diagram of a partial structure related to the solution of the present application, and does not constitute a limitation on the computer device to which the solution of the present application is applied. The specific computer device may include more or fewer components than shown in the figure, or combine certain components, or have a different arrangement of components.

In one embodiment, a computer device is provided, including a memory and a processor, wherein a computer program is stored in the memory, and the above method steps are implemented when the processor executes the computer program.

In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored, and when the computer program is executed by a processor, the above method steps are performed.

In one embodiment, a computer program product is provided, comprising a computer program, wherein the computer program performs the above method steps when executed by a processor.

It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties. In addition, the acquisition, storage, processing, and transmission of data are in compliance with relevant laws and regulations.

Those skilled in the art can understand that all or part of the processes in the above-mentioned embodiment methods can be completed by instructing the relevant hardware through a computer program, and the computer program can be stored in a non-volatile computer-readable storage medium. When the computer program is executed, it can include the processes of the embodiments of the above-mentioned methods. Among them, any reference to the memory, database or other medium used in the embodiments provided in this application can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical memory, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetoresistive random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory can include random access memory (RAM) or external cache memory, etc. As an illustration and not limitation, RAM can be in various forms, such as static random access memory (SRAM) or dynamic random access memory (DRAM). The database involved in each embodiment provided in this application may include at least one of a relational database and a non-relational database. Non-relational databases may include distributed databases based on blockchains, etc., but are not limited to this. The processor involved in each embodiment provided in this application may be a general-purpose processor, a central processing unit, a graphics processor, a digital signal processor, a programmable logic device, a data processing logic device based on quantum computing, etc., but are not limited to this.

The technical features of the above embodiments may be arbitrarily combined. To make the description concise, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

The above-described embodiments only express several implementation methods of the present application, and the descriptions thereof are relatively specific and detailed, but they cannot be understood as limiting the scope of the present application. It should be pointed out that, for a person of ordinary skill in the art, several variations and improvements can be made without departing from the concept of the present application, and these all belong to the protection scope of the present application. Therefore, the protection scope of the present application shall be subject to the attached claims.

Claims (10)

1. A file processing method, characterized in that the method comprises: Obtain a code packaging script and multiple static resource files; the code packaging script carries a configuration file; Execute the code packaging script, and match the static resource attributes of each of the static resource files based on the configuration resource attributes in the configuration file to obtain a target resource file and a basic resource file, wherein the target resource file is a static resource file corresponding to the static resource attribute that successfully matches, and the basic resource file is a static resource file corresponding to the static resource attribute that fails to match; Upload the target resource file to the server to obtain the online address of the target resource file on the server; The files to be packaged, which include the online address, the basic resource file, and the local address of the basic resource file, are packaged to obtain a program package. 2. The method according to claim 1, characterized in that the configuration resource attributes include resource type conditions and resource size conditions; the static resource attributes include static resource type and static resource size; The execution code packaging script matches the static resource attributes of each of the static resource files based on the configuration resource attributes in the configuration file to obtain the target resource file and the basic resource file, including: Execute the code packaging script, and match the static resource type of each of the static resource files based on the resource type condition in the configuration file, to obtain type matching results between the resource type condition and each of the static resource files; Based on the resource size condition in the configuration file, the static resource size of each of the static resource files is matched respectively to obtain size matching results between the resource size condition and each of the static resource files; According to the type matching result and the size matching result, each of the static resource files is divided into a target resource file and a basic resource file. 3. The method according to claim 2, characterized in that the step of dividing each of the static resource files into a target resource file and a basic resource file according to the type matching result and the size matching result comprises: According to the type matching results, the static resource files whose resource types match successfully in the static resource files are screened; According to the size matching results, the static resource files whose resource sizes have successfully matched are screened out from the static resource files; The static resource files with successful resource type matching and the static resource files with successful resource size matching are merged to obtain a target resource file; and each of the static resource files except the target resource file is determined as a basic resource file. 4. The method according to claim 1, characterized in that uploading the target resource file to a server to obtain an online address of the target resource file on the server comprises: Determining a plurality of candidate servers that match the static resource attribute of the target resource file; Selecting a target server from each of the candidate servers according to the load characteristics of each of the candidate servers; The target resource file is uploaded to the target server, and the online address of the target resource file on the target server sent by the target server is received. 5. The method according to claim 1, characterized in that the packaging process of the to-be-packaged file including the online address, the basic resource file, and the local address of the basic resource file to obtain a program package comprises: Extracting candidate resource files having a resolution association relationship with the basic resource file from a resource file library; Determine a basic local address of a basic resource file and a candidate local address of the candidate resource file; The files to be packaged, which include the online address, the basic local address, the candidate local address, the basic resource file, and the candidate resource file, are packaged to obtain a program package. 6. The method according to any one of claims 1 to 5, characterized in that the obtaining of multiple static resource files comprises: Get the project code in the file to be packaged; Scan the project code to obtain multiple candidate resource files corresponding to the project code; Performing file type optimization processing on each of the candidate resource files to obtain multiple static resource files; The step of packaging the file to be packaged including the online address, the basic resource file, and the local address of the basic resource file to obtain a program package includes: The project code including the online address, the local address of the basic resource file, and the basic resource file are packaged to obtain a program package. 7. A file processing device, characterized in that the device comprises: An acquisition module is used to acquire a code packaging script and multiple static resource files; the code packaging script carries a configuration file; A matching module is used to execute a code packaging script, and based on the configuration resource attributes in the configuration file, respectively match the static resource attributes of each of the static resource files to obtain a target resource file and a basic resource file, wherein the target resource file is a static resource file corresponding to the static resource attribute that successfully matches, and the basic resource file is a static resource file corresponding to the static resource attribute that fails to match; An uploading module, used for uploading the target resource file to a server and obtaining an online address of the target resource file on the server; The packaging module is used to package the files to be packaged including the online address, the basic resource file, and the local address of the basic resource file to obtain a program package. 8. A computer device, comprising a memory and a processor, wherein the memory stores a computer program, wherein the processor implements the steps of the method according to any one of claims 1 to 6 when executing the computer program. 9. A computer-readable storage medium having a computer program stored thereon, wherein when the computer program is executed by a processor, the steps of the method according to any one of claims 1 to 6 are implemented. 10. A computer program product, comprising a computer program, characterized in that when the computer program is executed by a processor, the steps of the method according to any one of claims 1 to 6 are implemented.