CN116954611A - Front-end project compiling and packaging method, device and equipment - Google Patents
Front-end project compiling and packaging method, device and equipment Download PDFInfo
- Publication number
- CN116954611A CN116954611A CN202211174713.0A CN202211174713A CN116954611A CN 116954611 A CN116954611 A CN 116954611A CN 202211174713 A CN202211174713 A CN 202211174713A CN 116954611 A CN116954611 A CN 116954611A
- Authority
- CN
- China
- Prior art keywords
- array
- target object
- custom
- code
- target
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 140
- 238000004806 packaging method and process Methods 0.000 title claims abstract description 47
- 238000006243 chemical reaction Methods 0.000 claims abstract description 28
- 238000012856 packing Methods 0.000 claims description 19
- 230000006835 compression Effects 0.000 claims description 4
- 238000007906 compression Methods 0.000 claims description 4
- 238000005457 optimization Methods 0.000 abstract description 6
- 238000003491 array Methods 0.000 description 8
- 230000003068 static effect Effects 0.000 description 5
- 230000008569 process Effects 0.000 description 4
- 238000012545 processing Methods 0.000 description 4
- 230000008878 coupling Effects 0.000 description 3
- 238000010168 coupling process Methods 0.000 description 3
- 238000005859 coupling reaction Methods 0.000 description 3
- 238000004891 communication Methods 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000012546 transfer Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 238000004590 computer program Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000006870 function Effects 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000002093 peripheral effect Effects 0.000 description 1
- 230000009466 transformation Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/44—Encoding
- G06F8/443—Optimisation
- G06F8/4441—Reducing the execution time required by the program code
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The application provides a front-end project compiling and packaging method, device and equipment, and relates to the technical field of computers, wherein the method comprises the following steps: searching a target object in the code; the target Object is a self-defined Object which does not use an Object method in the code; converting the target object into an array; and compiling and packaging the code after the conversion of the plurality of groups. According to the scheme, the target Object which is not used in the code and is defined by the Object method is searched, the target Object is converted into the array, the code after the array conversion is compiled and packaged, the characteristic that the complexity of the access time of the array in js is lower than that of the Object is utilized, and the performance optimization operation of application operation is carried out in the project compiling and packaging stage, namely, the target Object in the js code is converted into the array, so that the access time is reduced, and the front-end project operation speed and the project operation performance are improved.
Description
Technical Field
The present application relates to the field of computer technologies, and in particular, to a method, an apparatus, and a device for compiling and packaging a front-end item.
Background
With the development of web front-end technology, the front-end gradually develops to engineering, and front-end projects are separated from the background and are compiled and deployed respectively. The front-end optimization is mainly divided into the following aspects: (1) The code writing stage is used for writing codes with higher performance and efficiency, and the operation which can be performed in the aspect is not very much at present; (2) And in the project packaging and compiling stage, operations such as compressing the combined codes and the like reduce the number and the size of application resource requests. The existing front-end optimization technical scheme mainly focuses on the second aspect.
The prior art mainly uses tools such as weback, gulp, group and the like to package and compile front-end projects. The compiling and optimizing mode mainly has the following aspects: (1) compressing static resources such as pictures and the like, and reducing the size of the static resources; (2) Compressing javascript (js) codes, removing line feed, naming variables by using initial letters, and reducing js file size; (3) The files with fewer js codes are combined according to the situation, so that the number of hypertext transfer protocol (Hyper Text Transfer Protocol, HTTP) requests during resource loading is reduced.
That is, in the situation that the front-end compiling and packaging improves the code performance, the prior art scheme only aims at the size of the static resource to operate, and the improvement of the application performance is basically limited to the code writing stage, and the technical scheme does not perform the performance optimization operation of the application operation in the project compiling and packaging stage, so that the speed of the front-end project application operation is low.
Disclosure of Invention
The embodiment of the application provides a front-end project compiling and packaging method, device and equipment, which are used for solving the problem of low speed of front-end project application in the prior art.
In order to solve the technical problems, the embodiment of the application provides the following technical scheme:
the embodiment of the application provides a front-end project compiling and packaging method, which comprises the following steps:
searching a target object in the code; the target Object is a self-defined Object which does not use an Object method in the code;
converting the target object into an array;
and compiling and packaging the code after the conversion of the plurality of groups.
Optionally, before the searching for the target object in the code to be compiled and packaged, the method further includes:
searching a target configuration item in a configuration file; the target configuration option is used for indicating that a target object in the code is converted into data; the configuration file is a file for configuring the codes to be compiled and packaged.
Optionally, the converting the target object into an array includes:
creating an array aiming at the target object;
defining the custom method of the target object into the array;
and converting the custom attribute of the target object into data in the array.
Optionally, the defining the custom method of the target object into the array includes:
writing a first custom method into the array;
converting the call of the first custom method into the method call of the array;
the first customization method is any one of the customization methods.
Optionally, the converting the custom attribute of the target object into the data in the array includes:
converting the first custom attribute into data in the array;
searching an access mode of the code using the first custom attribute in the code, and modifying the access mode into a plurality of groups of access;
wherein the first custom attribute is any one of the custom attributes.
Optionally, the method further comprises:
converting the target attribute into data in the array under the condition that the target attribute different from the custom attribute exists in a second custom method;
the second self-defining method is any one of the self-defining methods.
Optionally, the method further comprises:
and carrying out compression merging on the codes under the condition that the configuration file does not contain the target configuration item.
The embodiment of the application also provides a front-end project compiling and packaging device, which comprises:
the first searching module is used for searching a target object in the code; the target Object is a self-defined Object which does not use an Object method in the code;
the conversion module is used for converting the target object into an array;
and the compiling and packing module is used for compiling and packing the codes after the conversion of the groups.
Optionally, the apparatus further comprises:
the second searching module is used for searching the target configuration item in the configuration file; the target configuration option is used for indicating that a target object in the code is converted into data; the configuration file is a file for configuring the codes to be compiled and packaged.
Optionally, the conversion module includes:
an array creation unit for creating an array for the target object;
a method definition unit, configured to define a custom method of the target object into the array;
the first attribute conversion unit is used for converting the custom attribute of the target object into the data in the array.
Optionally, the method defines a unit, specifically for:
writing a first custom method into the array;
converting the call of the first custom method into the method call of the array;
the first customization method is any one of the customization methods.
Optionally, the first attribute conversion unit is specifically configured to:
converting the first custom attribute into data in the array;
searching an access mode of the code using the first custom attribute in the code, and modifying the access mode into a plurality of groups of access;
wherein the first custom attribute is any one of the custom attributes.
Optionally, the conversion module further comprises:
the second attribute conversion unit is used for converting the target attribute into the data in the array under the condition that the target attribute different from the custom attribute exists in a second custom method;
the second self-defining method is any one of the self-defining methods.
Optionally, the apparatus further comprises:
and the processing module is used for compressing and combining the codes under the condition that the configuration file does not contain the target configuration item.
The embodiment of the application also provides front-end project compiling and packaging equipment, which comprises: a processor, a memory and a program stored on the memory and executable on the processor, which when executed by the processor implements the steps of the front-end project compilation packaging method as described in any of the preceding claims.
The embodiment of the application also provides a readable storage medium, wherein a program is stored on the readable storage medium, and the program realizes the steps in the front-end project compiling and packaging method according to any one of the above when being executed by a processor.
The beneficial effects of the application are as follows:
according to the embodiment of the application, the target Object is converted into the array by searching the custom target Object which does not use the Object method in the code, the code after the array conversion is compiled and packaged, and the performance optimization operation of the application operation is carried out in the project compiling and packaging stage by utilizing the characteristic that the complexity of the access time of the array in js is lower than that of the Object, namely, the target Object in js code is converted into the array, so that the access time is reduced, and the front-end project operation speed and the project operation performance are improved.
Drawings
FIG. 1 shows one of the flowcharts of the front-end project compilation packaging method provided by the embodiment of the application;
FIG. 2 is a second flowchart of a front-end project compiling and packing method according to an embodiment of the present application;
fig. 3 is a schematic structural diagram of a front-end project compiling and packing device according to an embodiment of the present application;
fig. 4 is a schematic structural diagram of front-end project compiling and packaging equipment according to an embodiment of the present application.
Detailed Description
The present application will be described in detail below with reference to the drawings and the specific embodiments thereof in order to make the objects, technical solutions and advantages of the present application more apparent.
Aiming at the problem of low speed of front-end project application in the prior art, the application provides a front-end project compiling and packaging method, device and equipment.
As shown in fig. 1, an embodiment of the present application provides a front-end project compiling and packaging method, including:
step 101: searching a target object in the code; the target Object is a custom Object in the code that does not use the Object method.
It should be noted that, the code is a code configured by a configuration file and packaged to be compiled.
In this step, all target objects in the code (js code) are found, which are custom objects in the code that do not use the Object method, i.e. the target objects should meet the following conditions: the native method of the Object's Object is not called in the code.
Step 102: and converting the target object into an array.
The Object which is not used for defining the Object method in the code is taken as a target Object, and the target Object is converted into an array, so that the situation that the array and the Object have the same name but are inconsistent is avoided. But developer custom objects typically do not use Object methods.
For example, the Object method, such as a method for changing an Object data attribute by defining an attribute (defining property), uses a custom Object of a code, which does not use a method for changing an Object data attribute by defining an attribute, as a target Object, so as to avoid a situation that the data attributes of the target Object are inconsistent in a conversion process of converting the Object into an array.
It should be noted that, when converting the target object into an array, each target object is sequentially converted until each target object in the code is converted into an array.
Step 103: and compiling and packaging the code after the conversion of the plurality of groups.
After all target objects in the code are converted into arrays, the compiling and packing operation is continuously carried out on the code, specifically, a developer executes the compiling and packing operation, equipment executing the front-end project compiling and packing method reads configuration items corresponding to the compiling and packing operation in a configuration file, and operations such as compressing and merging js codes and other static resources are carried out according to the configuration items corresponding to the compiling and packing operation.
According to the embodiment of the application, by utilizing the characteristic that the complexity of the access time of the array in js is lower than that of the object, the performance optimization operation of application operation (converting the target object in js code into the array) is carried out in the project compiling and packaging stage, the access time is reduced, and the front-end project operation speed and the project operation performance are improved.
Optionally, before the searching for the target object in the code to be compiled and packaged, the method further includes:
searching a target configuration item in a configuration file; the target configuration option is used for indicating that a target object in the code is converted into data; the configuration file is a file for configuring the codes to be compiled and packaged.
Before searching the target object, the developer executes the compiling and packing command, and the device executing the front-end project compiling and packing method reads the configuration file configured by the developer for compiling and packing, searches the target configuration item in the configuration file, specifically, searches whether the target configuration item obj torar and a specific value thereof are configured in the configuration file, the value is used for indicating whether the subsequent operation of converting the target object into an array is performed according to the target configuration item, and if the target configuration item obj torar is found in the configuration file, and the corresponding value also indicates that the subsequent operation of converting the target object into the array can be performed according to the target configuration item, the subsequent operation of searching the target object and converting the target object into the array are performed.
By configuring the target configuration item in the configuration file, a developer is facilitated to configure whether to optimize the mode of converting the target object into the array by using the method and the device.
Optionally, the converting the target object into an array includes:
creating an array aiming at the target object;
defining the custom method of the target object into the array;
and converting the custom attribute of the target object into data in the array.
When converting a target object obj conforming to the condition in the target objects, initializing and establishing an array arr aiming at the target object obj, wherein the custom object described in the code can have a custom method, the custom method corresponding to the target object obj can be directly written on the newly established array arr, the custom method can be consistent with the original result, and the custom attribute of the target object obj is converted into the data of the newly established array arr.
It should be noted that, the steps of defining the custom method of the target object into the array and converting the custom attribute of the target object into the data in the array are not consecutive, the custom method of the target object may be defined into the array first, or the custom attribute of the target object may be converted into the data in the array first. The present embodiment is not limited thereto.
Optionally, the defining the custom method of the target object into the array includes:
writing a first custom method into the array;
converting the call of the first custom method into the method call of the array;
the first customization method is any one of the customization methods.
Taking the object obj as an example, the process of writing the custom method corresponding to the object obj into the array will be described below:
searching all custom methods corresponding to the object obj, defining the custom methods onto an array arr in sequence, for example, the obj. Functional nA is a custom method (a first custom method) and is defined onto the arr. Functional nA, because the array is also a special object, searching all calls of the obj. Functional nA, modifying the calls of the obj. Functional nA into new method calls of the array arr, and repeating the steps until all custom methods corresponding to the object obj are converted.
Optionally, the converting the custom attribute of the target object into the data in the array includes:
converting the first custom attribute into data in the array;
searching an access mode of the code using the first custom attribute in the code, and modifying the access mode into a plurality of groups of access;
wherein the first custom attribute is any one of the custom attributes.
The following describes a process of converting custom attributes of a target object obj into data of an array, taking the target object obj as an example:
searching all custom attributes of the object obj, converting each custom attribute into data in an array in turn, for example, searching a first custom attribute obj.a, that is, converting an attribute value of the custom attribute a of the object obj into the first data in an array arr, which can be realized by arr [0] =obj.a, if obj.a is an object, converting obj.a into an array, if obj.a is not an object, searching all codes using obj.a in the code to be compiled and packed, changing all codes using obj.a into an array access mode of arr [0], continuing searching a next custom attribute of the object obj, for example, a next custom attribute, for example, being obj.b, increasing an index of the attribute value of the custom attribute obj.b in the array arr by 1, realizing by arr [1] =obj.b, and repeating the steps of converting the rest of conversion and the transformation of the custom attribute j.a to be consistent, and completing the conversion of the object to the object, and completing the custom attributes.
Optionally, the method further comprises:
converting the target attribute into data in the array under the condition that the target attribute different from the custom attribute exists in a second custom method;
the second self-defining method is any one of the self-defining methods.
Taking the target object obj as an example, if there is a target attribute different from the custom attribute of the target object obj in a custom method (a second custom method) of the target object obj, that is, if there is a new attribute assignment, the target attribute is converted into data in the array, and when the target attribute is converted, the conversion may be performed according to the conversion sequence of the custom attributes, that is, after the custom attribute of the target object obj is sequentially converted into data in the array ar, if the second custom method is found that there is a new attribute assignment, after the custom attribute converted data, the data corresponding to the new attribute assignment is added in the array.
Optionally, the method further comprises:
and carrying out compression merging on the codes under the condition that the configuration file does not contain the target configuration item.
It should be further noted that, under the condition that the target configuration item does not exist in the configuration file, the developer executes the operations of compiling and packaging, and performs the operations of compressing and merging js code and other static resources according to the compiling and packaging configuration item in the configuration file.
The following specifically describes a front-end project compiling and packaging method according to an embodiment of the present application with reference to fig. 2:
and starting execution, reading whether a target configuration item (obj) is configured in the configuration file, if the target configuration item is configured in the configuration file, searching all custom objects (target objects) in the code, respectively creating corresponding arrays, searching a custom method of the custom objects, writing the custom objects into the corresponding arrays, searching custom attributes of the custom objects, constructing attribute values of the custom attributes as array indexes, searching codes with the custom attributes referenced in the code, modifying the codes into an access mode of the arrays, executing other compiling and packaging operations, and if the target configuration item is not configured in the configuration file, directly performing other compiling and packaging operations until the flow is ended.
The front-end project compiling and packaging method provided by the embodiment of the application is mainly used for optimizing the objects in js codes, converting object variables and object constants into js arrays according to conditions to improve the access performance of the js arrays, and compared with the existing method for compressing and combining front-end resources, the embodiment of the application utilizes the characteristic that the complexity of the access time of the arrays in js is lower than that of the objects, converts the objects in js codes into arrays as much as possible in the compiling and packaging stage, so as to improve the application runtime performance, avoid a developer from changing the code writing habit for better application runtime performance, and enable the developer to fully utilize the js improved performance. The complexity of the array access time is O (1), the complexity of the object access time is O (n), wherein n represents the number of attributes owned by the object, i.e. the complexity of the array access time is lower than the complexity of the object access time.
The scheme of the application optimizes the performance of the web application in the execution stage more in a further step, does not conflict with other optimizing methods, and can be performed before or after other optimizing methods.
As shown in fig. 3, an embodiment of the present application further provides a front-end project compiling and packaging device, including:
a first searching module 301, configured to search a target object in a code; the target Object is a self-defined Object which does not use an Object method in the code;
a conversion module 302, configured to convert the target object into an array;
and the compiling and packing module 303 is used for compiling and packing the code after the conversion of the plurality of groups.
Optionally, the apparatus further comprises:
the second searching module is used for searching the target configuration item in the configuration file; the target configuration option is used for indicating that a target object in the code is converted into data; the configuration file is a file for configuring the codes to be compiled and packaged.
Optionally, the conversion module 302 includes:
an array creation unit for creating an array for the target object;
a method definition unit, configured to define a custom method of the target object into the array;
the first attribute conversion unit is used for converting the custom attribute of the target object into the data in the array.
Optionally, the method defines a unit, specifically for:
writing a first custom method into the array;
converting the call of the first custom method into the method call of the array;
the first customization method is any one of the customization methods.
Optionally, the first attribute conversion unit is specifically configured to:
converting the first custom attribute into data in the array;
searching an access mode of the code using the first custom attribute in the code, and modifying the access mode into a plurality of groups of access;
wherein the first custom attribute is any one of the custom attributes.
Optionally, the conversion module 302 further includes:
the second attribute conversion unit is used for converting the target attribute into the data in the array under the condition that the target attribute different from the custom attribute exists in a second custom method;
the second self-defining method is any one of the self-defining methods.
Optionally, the apparatus further comprises:
and the processing module is used for compressing and combining the codes under the condition that the configuration file does not contain the target configuration item.
It should be noted that, the front-end project compiling and packaging device provided by the embodiment of the application is a device capable of executing the front-end project compiling and packaging method, so that all embodiments of the front-end project compiling and packaging method are applicable to the device and can achieve the same or similar technical effects.
As shown in fig. 4, an embodiment of the present application further provides a front-end project compiling and packaging device, including: a processor 400; and a memory 410 connected to the processor 400 through a bus interface, the memory 410 storing programs and data used by the processor 400 in performing operations, the processor 400 calling and executing the programs and data stored in the memory 410.
Wherein the front-end project compiling and packaging device further comprises a transceiver 420, the transceiver 420 is connected with the bus interface, and is used for receiving and transmitting data under the control of the processor 400;
specifically, the processor 400 performs the following process:
searching a target object in the code; the target Object is a self-defined Object which does not use an Object method in the code;
converting the target object into an array;
and compiling and packaging the code after the conversion of the plurality of groups.
Optionally, before the processor 400 searches for the target object in the code to be compiled and packaged, the processor 400 is further configured to:
searching a target configuration item in a configuration file; the target configuration option is used for indicating that a target object in the code is converted into data; the configuration file is a file for configuring the codes to be compiled and packaged.
Optionally, the processor 400 is specifically configured to:
creating an array aiming at the target object;
defining the custom method of the target object into the array;
and converting the custom attribute of the target object into data in the array.
Optionally, the processor 400 is specifically configured to:
writing a first custom method into the array;
converting the call of the first custom method into the method call of the array;
the first customization method is any one of the customization methods.
Optionally, the processor 400 is specifically configured to:
converting the first custom attribute into data in the array;
searching an access mode of the code using the first custom attribute in the code, and modifying the access mode into a plurality of groups of access;
wherein the first custom attribute is any one of the custom attributes.
Optionally, the processor 400 is further specifically configured to:
converting the target attribute into data in the array under the condition that the target attribute different from the custom attribute exists in a second custom method;
the second self-defining method is any one of the self-defining methods.
Optionally, the processor 400 is further configured to:
and carrying out compression merging on the codes under the condition that the configuration file does not contain the target configuration item.
Wherein in fig. 4, a bus architecture may comprise any number of interconnected buses and bridges, and in particular one or more processors represented by processor 400 and various circuits of memory represented by memory 410, linked together. The bus architecture may also link together various other circuits such as peripheral devices, voltage regulators, power management circuits, etc., which are well known in the art and, therefore, will not be described further herein. The bus interface provides a user interface 430. Transceiver 420 may be a number of elements, including a transmitter and a receiver, providing a means for communicating with various other apparatus over a transmission medium. The processor 400 is responsible for managing the bus architecture and general processing, and the memory 410 may store data used by the processor 400 in performing operations.
In addition, a specific embodiment of the present application also provides a readable storage medium, on which a computer program is stored, where the program, when executed by a processor, implements the steps in the front-end project compilation packaging method as described in any of the above.
In the several embodiments provided in the present application, it should be understood that the disclosed methods and apparatus may be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative, e.g., the division of the units is merely a logical function division, and there may be additional divisions when actually implemented, e.g., multiple units or components may be combined or integrated into another system, or some features may be omitted or not performed. Alternatively, the coupling or direct coupling or communication connection shown or discussed with each other may be an indirect coupling or communication connection via some interfaces, devices or units, which may be in electrical, mechanical or other form.
In addition, each functional unit in the embodiments of the present application may be integrated in one processing unit, or each unit may be physically included separately, or two or more units may be integrated in one unit. The integrated units may be implemented in hardware or in hardware plus software functional units.
The integrated units implemented in the form of software functional units described above may be stored in a computer readable storage medium. The software functional unit is stored in a storage medium, and includes several instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to perform part of the steps of the transceiving method according to the embodiments of the present application. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a Read-Only Memory (ROM), a random access Memory (Random Access Memory, RAM), a magnetic disk, or an optical disk, or other various media capable of storing program codes.
While the foregoing is directed to the preferred embodiments of the present application, it will be appreciated by those skilled in the art that various modifications and changes can be made without departing from the principles of the present application, and such modifications and changes are intended to be within the scope of the present application.
Claims (10)
1. The front-end project compiling and packing method is characterized by comprising the following steps of:
searching a target object in the code; the target Object is a self-defined Object which does not use an Object method in the code;
converting the target object into an array;
and compiling and packaging the code after the conversion of the plurality of groups.
2. The front-end project compilation packaging method according to claim 1, wherein before the searching for the target object in the code to be compiled and packaged, the method further comprises:
searching a target configuration item in a configuration file; the target configuration option is used for indicating that a target object in the code is converted into data; the configuration file is a file for configuring the codes to be compiled and packaged.
3. The front-end project compilation packaging method according to claim 1, wherein the converting the target object into an array comprises:
creating an array aiming at the target object;
defining the custom method of the target object into the array;
and converting the custom attribute of the target object into data in the array.
4. The method for compiling and packing a front-end item according to claim 3, wherein defining the custom method of the target object into the array comprises:
writing a first custom method into the array;
converting the call of the first custom method into the method call of the array;
the first customization method is any one of the customization methods.
5. The method of front-end project compilation packaging according to claim 3, wherein said converting custom properties of said target object into data in said array comprises:
converting the first custom attribute into data in the array;
searching an access mode of the code using the first custom attribute in the code, and modifying the access mode into a plurality of groups of access;
wherein the first custom attribute is any one of the custom attributes.
6. The front-end project compilation packaging method of claim 3 further comprising:
converting the target attribute into data in the array under the condition that the target attribute different from the custom attribute exists in a second custom method;
the second self-defining method is any one of the self-defining methods.
7. The front-end project compilation packaging method of claim 2, further comprising:
and carrying out compression merging on the codes under the condition that the configuration file does not contain the target configuration item.
8. Front-end project compiling and packing device is characterized by comprising:
the first searching module is used for searching a target object in the code; the target Object is a self-defined Object which does not use an Object method in the code;
the conversion module is used for converting the target object into an array;
and the compiling and packing module is used for compiling and packing the codes after the conversion of the groups.
9. A front-end project compilation packaging apparatus, comprising: a processor, a memory and a program stored on the memory and executable on the processor, which when executed by the processor implements the steps of the front-end project compilation packaging method of any of claims 1 to 7.
10. A readable storage medium, wherein a program is stored on the readable storage medium, which when executed by a processor, implements the steps in the front-end item compilation packaging method according to any of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211174713.0A CN116954611A (en) | 2022-09-26 | 2022-09-26 | Front-end project compiling and packaging method, device and equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211174713.0A CN116954611A (en) | 2022-09-26 | 2022-09-26 | Front-end project compiling and packaging method, device and equipment |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116954611A true CN116954611A (en) | 2023-10-27 |
Family
ID=88455331
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211174713.0A Pending CN116954611A (en) | 2022-09-26 | 2022-09-26 | Front-end project compiling and packaging method, device and equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116954611A (en) |
-
2022
- 2022-09-26 CN CN202211174713.0A patent/CN116954611A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN111209004B (en) | Code conversion method and device | |
| EP2827244A1 (en) | Extension mechanism for scripting language compiler | |
| US20050183071A1 (en) | Interaction with nested and non-nested streams | |
| CN111176791B (en) | Cross-virtual machine calling method based on multi-virtual machine blockchain platform | |
| US8336035B2 (en) | Customizable dynamic language expression interpreter | |
| CN113283613B (en) | Deep learning model generation method, optimization method, device, equipment and medium | |
| CN113067866B (en) | Batch file transmission method and device between heterogeneous systems | |
| CN113031966A (en) | Deep learning compilation optimization method for intelligently selecting compilation acceleration library | |
| CN110688096B (en) | Method and device for constructing application program containing plug-in, medium and electronic equipment | |
| CN100511140C (en) | Method for script language calling multiple output parameter interface by component software system | |
| US20150356131A1 (en) | Accessing an external table in parallel to execute a query | |
| CN114327477A (en) | Intelligent contract execution method and device, electronic device and storage medium | |
| CN109597825B (en) | Rule engine calling method, device, equipment and computer readable storage medium | |
| CN112925586B (en) | Applet routing method, device, computer equipment and storage medium | |
| CN113839902B (en) | Communication protocol adaptation method, device, computer equipment and storage medium | |
| CN109388406A (en) | Convert method and device, the storage medium, electronic device of java code | |
| CN112379886A (en) | Data format conversion system and method thereof | |
| CN116954611A (en) | Front-end project compiling and packaging method, device and equipment | |
| CN107168795A (en) | Codon deviation factor model method based on CPU GPU isomery combined type parallel computation frames | |
| CN111045793A (en) | Method and device for executing functional module in virtual machine | |
| CN103646015A (en) | Method and system for sending, receiving and transmitting XML message | |
| CN107643892B (en) | Interface processing method, device, storage medium and processor | |
| CN107357853B (en) | Method and device for operating REDIS console and computer system | |
| CN115328679A (en) | Automatic integration method of heterogeneous function library, computing equipment and system thereof | |
| CN112650512A (en) | Hardware driving method and device, terminal and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |