CN110851355A

CN110851355A - Front-end engineering implementation method and device, storage medium and electronic equipment

Info

Publication number: CN110851355A
Application number: CN201911031831.4A
Authority: CN
Inventors: 陈思名; 刘佳诚; 黄靖鸿; 胡锦亮
Original assignee: Tencent Technology Shenzhen Co Ltd
Current assignee: Tencent Technology Shenzhen Co Ltd
Priority date: 2019-10-28
Filing date: 2019-10-28
Publication date: 2020-02-28
Anticipated expiration: 2039-10-28
Also published as: CN110851355B

Abstract

The invention provides a front-end engineering implementation method and device, electronic equipment and a storage medium; relates to the technical field of computers. The implementation method of the front-end engineering comprises the following steps: creating a control branch node, and developing a branch node based on the control branch node creation characteristic; acquiring submitted target function characteristics, and directly deploying the characteristic development branch nodes to a test environment to perform functional test on the target function characteristics; after the target functional characteristic test is finished, determining a release branch node through the control branch node and the characteristic development branch node so as to release the target functional characteristic through the release branch node; and after the target functional characteristic is released, incorporating the characteristic development branch node into the control branch node to complete the release of the target functional characteristic. The invention can simplify the process of front-end engineering development, improve the efficiency of front-end development and improve the use experience of users.

Description

Front-end engineering implementation method and device, storage medium and electronic equipment

Technical Field

The present invention relates to the field of computer technologies, and in particular, to a front-end engineering implementation method, a front-end engineering implementation apparatus, an electronic device, and a computer-readable storage medium.

Background

With the rapid development of internet technology, front-end development (Web front-end development) is gaining more and more attention.

Currently, most workflows of front-end development are managed through Gitflow (a front-end development management tool) and gitubflow (a deployment-centric development management tool). However, the Gitflow workflow is suitable for cooperation of large and complex engineering teams, and has more flows and branches, more complex structures and lower working efficiency; and the Githubflow management is simpler, but no code submission standard is specified, how to evaluate the codes is not specified, and the branch release-based characteristics are not provided, so that the code auditing quality is reduced, the release functional characteristics are easy to leak, and the use experience of users is reduced.

It is to be noted that the information invented in the above background section is only for enhancing the understanding of the background of the present invention, and therefore, may include information that does not constitute prior art known to those of ordinary skill in the art.

Disclosure of Invention

The invention aims to provide a front-end engineering implementation method, a front-end engineering implementation device, electronic equipment and a computer readable storage medium, and further solves the problems that the workflow of front-end development in the related technology is complex and the development efficiency is low due to the limitations and defects of the related technology to a certain extent.

According to a first aspect of the present invention, there is provided a method for implementing front-end engineering, including:

creating a control branch node, and developing a branch node based on the control branch node creation characteristic;

acquiring submitted target function characteristics, and directly deploying the characteristic development branch nodes to a test environment to perform functional test on the target function characteristics;

after the target functional characteristic test is finished, determining a release branch node through the control branch node and the characteristic development branch node so as to release the target functional characteristic through the release branch node;

and after the target functional characteristic is released, incorporating the characteristic development branch node into the control branch node to complete the release of the target functional characteristic.

In an exemplary embodiment of the present invention, determining a distribution branch node by the control branch node and the feature development branch node to distribute the target functional feature by the distribution branch node includes:

determining a distribution branch node through the control branch node and the characteristic development branch node;

and based on the characteristic development branch node, a code review instruction is sent to the issuing branch node so that the issuing branch node generates issuing data and issues the target functional characteristic.

In an exemplary embodiment of the invention, after incorporating the feature development branch node into the control branch node to complete the release of the target functional feature, the method further comprises:

and performing code inspection on the issued target functional characteristics through an object code inspection platform to ensure the code quality of the target functional characteristics.

In an exemplary embodiment of the present invention, acquiring the submitted target function characteristic further includes:

performing local static code checking on the target functional characteristics;

if the target functional characteristic passes the local static code inspection, submitting the target functional characteristic to a target warehouse, and performing secondary incremental scanning inspection on the target functional characteristic through a third-party tool;

executing a log monitoring alarm instruction when the target function characteristic is determined not to pass the secondary incremental scanning check.

responding to the selection operation of the page template, and acquiring the configuration information of a target page template corresponding to the selection operation;

and creating a target page template according to the configuration information.

In an exemplary embodiment of the present invention, creating a target page template according to the configuration information further includes:

monitoring whether a submission instruction for constructing a branch node exists or not based on the monitoring script of the target warehouse;

when a submission instruction for constructing a branch node is monitored, determining the type of the branch node according to the submission instruction;

and calling the corresponding construction script through the type so as to trigger the corresponding server to construct the branch node through the construction script.

According to a second aspect of the present invention, there is provided a method for implementing front-end engineering, including:

in response to an operation of triggering a start command, creating a control branch node, and developing a branch node based on a characteristic created by the control branch node;

responding to the operation of triggering a test command, acquiring the submitted target function characteristics, and directly deploying the characteristic development branch nodes to a test environment to perform functional test on the target function characteristics;

in response to an operation of triggering an issuing command, determining an issuing branch node through the control branch node and the characteristic development branch node to issue the target functional characteristic through the issuing branch node;

after the target function characteristic is released, the characteristic development branch node is combined into the control branch node to complete the release of the target function characteristic;

and in response to the operation of triggering the ending command, deleting the local branch node or the remote branch node, and emptying the test environment.

According to a third aspect of the present invention, there is provided a front end engineering implementation apparatus, including:

the characteristic development branch node creating module is used for creating a control branch node and creating a characteristic development branch node based on the control branch node;

the target functional characteristic testing module is used for acquiring submitted target functional characteristics and directly deploying the characteristic development branch nodes to a testing environment so as to perform functional testing on the target functional characteristics;

the target functional characteristic issuing module is used for determining issuing branch nodes through the control branch nodes and the characteristic development branch nodes after the target functional characteristic test is finished so as to issue the target functional characteristics through the issuing branch nodes;

and the characteristic development branch node merging module is used for merging the characteristic development branch node into the control branch node to complete the release of the target functional characteristic after the release of the target functional characteristic is completed.

In an exemplary embodiment of the invention, the target functional characteristic publication module is further configured to:

In an exemplary embodiment of the invention, the apparatus for implementing front-end engineering further comprises a code checking unit configured to:

In an exemplary embodiment of the present invention, the target functional characteristic test module further includes a static code automatic check unit configured to:

performing local static code checking on the target functional characteristics;

In an exemplary embodiment of the present invention, the apparatus for implementing front-end engineering further includes a page template creating module, where the page template creating module includes:

the device comprises a configuration information acquisition unit, a page template selection unit and a page template matching unit, wherein the configuration information acquisition unit is used for responding to selection operation of a page template and acquiring configuration information of a target page template corresponding to the selection operation;

and the target page template unit is used for creating a target page template according to the configuration information.

In an exemplary embodiment of the invention, the page template creation module further includes a server-side creation unit configured to:

According to a fourth aspect of the present invention, there is provided a front end engineering implementation apparatus, including:

a start command triggering unit configured to create a control branch node in response to an operation of triggering a start command, and develop a branch node based on a characteristic created by the control branch node;

the test command triggering unit is used for responding to the operation of triggering the test command, acquiring the submitted target function characteristics and directly deploying the characteristic development branch nodes to a test environment to perform functional test on the target function characteristics;

an issuing command triggering unit configured to determine, in response to an operation for triggering an issuing command, an issuing branch node through the control branch node and the characteristic development branch node, so as to issue the target functional characteristic through the issuing branch node;

the node merging unit is used for merging the characteristic development branch nodes into the control branch nodes to finish the release of the target functional characteristics after the release of the target functional characteristics is finished;

and the ending command triggering unit is used for responding to the operation of triggering the ending command, deleting the local branch node or the remote branch node and emptying the test environment.

According to a fifth aspect of the present invention, there is provided an electronic apparatus comprising: a processor; and a memory for storing executable instructions of the processor; wherein the processor is configured to perform the method of any one of the above via execution of the executable instructions.

According to a sixth aspect of the invention, there is provided a computer readable storage medium having stored thereon a computer program which, when executed by a processor, implements the method of any one of the above.

Exemplary embodiments of the present invention may have some or all of the following benefits:

in an implementation method of a front-end project provided by an exemplary embodiment of the present invention, a control branch node is created, and a branch node is developed based on a characteristic created by the control branch node; acquiring the submitted target function characteristics, and directly deploying the characteristic development branch nodes to a test environment to perform functional test on the target function characteristics; after the target function characteristic test is finished, determining a release branch node through the control branch node and the characteristic development branch node, so as to release the target function characteristic through the release branch node; and after the target functional characteristic is released, the characteristic development branch node is merged into the control branch node to complete the release of the target functional characteristic. On one hand, a characteristic development branch node (Defelop branch) in the Gitflow is cancelled, and the characteristic development branch node is directly deployed to a test environment to test the target functional characteristics, so that the front-end development flow and the branch structure are simplified, and the front-end development efficiency is improved; on the other hand, after the target functional characteristic is released, the characteristic development branch node is merged into the control branch node, and code inspection is carried out, so that the quality of the code corresponding to the target functional characteristic is ensured, and the use experience of a user is improved.

It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the invention, as claimed.

Drawings

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the invention and together with the description, serve to explain the principles of the invention. It is obvious that the drawings in the following description are only some embodiments of the invention, and that for a person skilled in the art, other drawings can be derived from them without inventive effort.

FIG. 1 is a diagram illustrating an exemplary system architecture of a method and apparatus for front-end engineering implementation to which embodiments of the present invention may be applied;

FIG. 2 illustrates a schematic structural diagram of a computer system suitable for use with the electronic device to implement an embodiment of the invention;

FIG. 3 is a diagram schematically illustrating a workflow for front-end development by Gitflow in the related art according to one embodiment of the present invention;

FIG. 4 schematically shows a flow diagram of a method of implementation of front-end engineering according to one embodiment of the invention;

FIG. 5 schematically illustrates a flow diagram for performing static code checking, according to one embodiment of the invention;

FIG. 6 schematically illustrates a flow diagram of static code inspection instrumentation, according to one embodiment of the invention;

FIG. 7 is a schematic diagram illustrating an application scenario of a method for implementing front-end engineering according to an embodiment of the present invention;

FIG. 8 schematically illustrates a flow diagram for page template tooling according to one embodiment of the invention;

FIG. 9 schematically illustrates a flow diagram of server-side build instrumentation and optimization according to one embodiment of the invention;

FIG. 10 schematically illustrates a flow diagram of a method of implementation of front-end engineering according to another embodiment of the present invention;

FIG. 11 schematically illustrates a flow diagram for tooling packaging of a method of implementation of front end engineering, in accordance with one embodiment of the present invention;

FIG. 12 schematically shows a block schematic diagram of an implementation apparatus of front-end engineering according to an embodiment of the present invention;

fig. 13 schematically shows a block schematic diagram of an implementation arrangement of a front-end engineering according to another embodiment of the present invention.

Detailed Description

Example embodiments will now be described more fully with reference to the accompanying drawings. Example embodiments may, however, be embodied in many different forms and should not be construed as limited to the examples set forth herein; rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the concept of example embodiments to those skilled in the art. The described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments. In the following description, numerous specific details are provided to provide a thorough understanding of embodiments of the invention. One skilled in the relevant art will recognize, however, that the invention may be practiced without one or more of the specific details, or with other methods, components, devices, steps, and so forth. In other instances, well-known technical solutions have not been shown or described in detail to avoid obscuring aspects of the invention.

Furthermore, the drawings are merely schematic illustrations of the invention and are not necessarily drawn to scale. The same reference numerals in the drawings denote the same or similar parts, and thus their repetitive description will be omitted. Some of the block diagrams shown in the figures are functional entities and do not necessarily correspond to physically or logically separate entities. These functional entities may be implemented in the form of software, or in one or more hardware modules or integrated circuits, or in different networks and/or processor devices and/or microcontroller devices.

Fig. 1 is a schematic diagram illustrating a system architecture of an exemplary application environment to which a method and an apparatus for implementing front-end engineering according to an embodiment of the present invention may be applied.

As shown in fig. 1, the system architecture 100 may include one or more of

terminal devices

101, 102, 103, a network 104, and a server 105. The network 104 serves as a medium for providing communication links between the

terminal devices

101, 102, 103 and the server 105. Network 104 may include various connection types, such as wired, wireless communication links, or fiber optic cables, to name a few. The

terminal devices

101, 102, 103 may be various electronic devices having a display screen, including but not limited to desktop computers, portable computers, smart phones, tablet computers, and the like. It should be understood that the number of terminal devices, networks, and servers in fig. 1 is merely illustrative. There may be any number of terminal devices, networks, and servers, as desired for implementation. For example, server 105 may be a server cluster comprised of multiple servers, or the like.

The method for implementing the front-end engineering provided by the embodiment of the present invention is generally executed by the server 105, and accordingly, the device for implementing the front-end engineering is generally disposed in the server 105. However, it is easily understood by those skilled in the art that the method for implementing the front-end engineering provided in the embodiment of the present invention may also be executed by the

terminal devices

101, 102, and 103, and accordingly, the apparatus for implementing the front-end engineering may also be disposed in the

terminal devices

101, 102, and 103, which is not particularly limited in this exemplary embodiment.

FIG. 2 illustrates a schematic structural diagram of a computer system suitable for use with the electronic device to implement an embodiment of the invention.

It should be noted that the computer system 200 of the electronic device shown in fig. 2 is only an example, and should not bring any limitation to the functions and the scope of the application of the embodiment of the present invention.

As shown in fig. 2, the computer system 200 includes a Central Processing Unit (CPU)201 that can perform various appropriate actions and processes in accordance with a program stored in a Read Only Memory (ROM)202 or a program loaded from a storage section 208 into a Random Access Memory (RAM) 203. In the RAM 203, various programs and data necessary for system operation are also stored. The CPU201, ROM 202, and RAM 203 are connected to each other via a bus 204. An input/output (I/O) interface 205 is also connected to bus 204.

The following components are connected to the I/O interface 205: an input portion 206 including a keyboard, a mouse, and the like; an output section 207 including a display such as a Cathode Ray Tube (CRT), a Liquid Crystal Display (LCD), and the like, and a speaker; a storage section 208 including a hard disk and the like; and a communication section 209 including a network interface card such as a LAN card, a modem, or the like. The communication section 209 performs communication processing via a network such as the internet. A drive 210 is also connected to the I/O interface 205 as needed. A removable medium 211 such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, or the like is mounted on the drive 210 as necessary, so that a computer program read out therefrom is mounted into the storage section 208 as necessary.

In particular, according to an embodiment of the present invention, the processes described below with reference to the flowcharts may be implemented as computer software programs. For example, embodiments of the invention include a computer program product comprising a computer program embodied on a computer-readable medium, the computer program comprising program code for performing the method illustrated in the flow chart. In such an embodiment, the computer program may be downloaded and installed from a network through the communication section 209 and/or installed from the removable medium 211. The computer program, when executed by a Central Processing Unit (CPU)201, performs various functions defined in the methods and apparatus of the present application.

It should be noted that the computer readable medium shown in the present invention can be a computer readable signal medium or a computer readable storage medium or any combination of the two. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples of the computer readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the present invention, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In the present invention, however, a computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wire, fiber optic cable, RF, etc., or any suitable combination of the foregoing.

The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams or flowchart illustration, and combinations of blocks in the block diagrams or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

The units described in the embodiments of the present invention may be implemented by software, or may be implemented by hardware, and the described units may also be disposed in a processor. Wherein the names of the elements do not in some way constitute a limitation on the elements themselves.

As another aspect, the present application also provides a computer-readable medium, which may be contained in the electronic device described in the above embodiments; or may exist separately without being assembled into the electronic device. The computer readable medium carries one or more programs which, when executed by an electronic device, cause the electronic device to implement the method as described in the embodiments below. For example, the electronic device may implement the steps shown in fig. 4 to 10, and the like.

The technical scheme of the embodiment of the invention is explained in detail as follows:

in the related technology, the engineering scheme is mainly concentrated in a certain stage or flow of front-end development, a complete development engineering scheme from requirement development to requirement completion is rarely covered, a unified tool-oriented or software-oriented means is not provided for solving the problem, the utilized static code inspection scheme, Git (which is an open-source distributed version control system and can effectively and quickly process the management of small to very large project versions) workflow scheme, and the page construction scheme can not completely meet the business requirements of the front-end performance, stability, availability, maintainability, testability and accessibility. The technical scheme mainly optimizes the problems that the Git workflow existing in the existing scheme is not applicable, the specification cannot fall to the ground and is forcedly executed, the local construction is too slow, the local construction is inconsistent, corresponding notification and monitoring are lacked in the construction and submission project, the front-end project test and the document are not standardized and the like from the aspects of the standardization, the encapsulation process, the server-side construction and the like.

Fig. 3 schematically shows a schematic diagram of a workflow of front-end development by Gitflow in the related art according to an embodiment of the present invention. Referring to fig. 3, in the Gitflow, a Master branch 301 and a Develop branch 304 are always present, the Master branch 301 can be regarded as a stable branch, the Develop branch 304 is a relatively stable branch, Feature development is performed on Feature (functional Feature)

branches

305 and 306, issue operation is performed on Release branch 303, and bug repair is performed on Hotfix branch 302 branch. The Gitflow workflow is suitable for cooperation of large and complex engineering teams, but has more flows and branches, is complex, and reduces the development efficiency.

The Githubflow workflow is a lightweight workflow based on branches, is suitable for open source projects, is simple to manage, merges and submits the characteristics through Pull Request, does not specify how to release versions and record changes, does not specify how to merge PR, does not specify which tool is used, does not specify a code submission standard, does not specify how to review codes, and does not also specify based on the characteristics of branch release, so that the quality of the codes is reduced, and the use experience of users is influenced.

Based on one or more of the problems described above, the present example embodiment provides a front-end engineering implementation method. The implementation method of the front-end engineering may be applied to the server 105, and may also be applied to one or more of the

terminal devices

101, 102, and 103, which is not particularly limited in this exemplary embodiment, and the following description will take the server as an example to execute the method. Referring to fig. 4, the front end engineering implementation method may include the following steps S410 to S440:

and S410, creating a control branch node, and developing a branch node based on the control branch node creation characteristic.

And step S420, acquiring the submitted target function characteristics, and directly deploying the characteristic development branch nodes to a test environment to perform functional test on the target function characteristics.

Step S430, after the target functional characteristic test is completed, determining a release branch node through the control branch node and the characteristic development branch node, so as to release the target functional characteristic through the release branch node.

Step S440, after the target functional characteristic is released, merging the characteristic development branch node into the control branch node to complete the release of the target functional characteristic.

In the implementation method of the front-end engineering provided by the present exemplary embodiment, on one hand, a property development branch node (devilop branch) in the Gitflow is cancelled, and the property development branch node is directly deployed to a test environment to perform a test on a target functional property, so that a front-end development flow and a branch structure are simplified, and the efficiency of front-end development is improved; on the other hand, after the target functional characteristic is released, the characteristic development branch node is merged into the control branch node, and code inspection is carried out, so that the quality of the code corresponding to the target functional characteristic is ensured, and the use experience of a user is improved. .

The above steps of the present exemplary embodiment will be described in more detail below.

In step S410, a control branch node is created, and a branch node is developed based on the control branch node creation characteristic.

In an example embodiment of the present invention, the control branch node may refer to a Master branch in the front-end development project, is a branch used for releasing the version in the front-end development project, and is a main branch in a workflow corresponding to the front-end development project. The Feature development branch node may refer to a Feature branch in a front-end development project, and is a specific functional Feature development branch. In the related art, the Feature development branch node interacts only with the Develop branch, but in the present exemplary embodiment, the Develop branch is deleted, and thus the Feature branch is directly cut out from the Master branch without interacting with the Develop branch.

In step S420, the submitted target functional characteristics are obtained, and the characteristic development branch nodes are directly deployed to a test environment to perform a functional test on the target functional characteristics.

In an example embodiment of the present invention, the target function characteristic may refer to a new function that is developed locally by a developer and uploaded to the characteristic development branch node, for example, the target function characteristic may be a browsing display form of a WEB page or a magnifying glass auxiliary tool of the WEB page, and of course, the target function characteristic may also be a new function developed by another, which is not particularly limited in this example embodiment. The test environment may refer to a virtual environment that is constructed according to related test tools and tests the target functional characteristics, for example, the test environment may refer to an environment that is deployed in an automated test Continuity Integration (CI) and tests the target functional characteristics, and the exemplary embodiment is not limited thereto. The latest functional properties in the control branch node will be incorporated each time the test environment is deployed.

FIG. 5 schematically shows a flow diagram for performing static code checking according to one embodiment of the invention.

Referring to fig. 5, in step S510, a local static code check is performed on the target functional characteristic.

In an example embodiment of the present invention, when an event that submits a target functional property to a property development branch node or any event that submits code from local to branch is detected, local static code checking is performed on the target functional property or code that is submitted from local to branch, i.e., static code checking is performed through githook for each Git submission based on a static code checking engineering tool. The static code inspection engineering tool is used for inspecting the code submitted each time, so that the maintainability and the robustness of the code can be ensured.

In step S520, if the target functional characteristic passes the local static code check, submitting the target functional characteristic to a target repository, and performing a secondary incremental scan check on the target functional characteristic through a third-party tool.

In an example embodiment of the present invention, the target warehouse may refer to a central warehouse in Git, or may also be a central warehouse in other version control systems, for example, a worker bee warehouse in TGit, and this example embodiment is not particularly limited to this. The third party tool may refer to a tool that checks the submitted code in the target repository to ensure the quality of the code. For example, the third party tool may be Codecc, and the exemplary embodiment is not limited thereto. And performing secondary incremental scanning inspection on the target functional characteristics through a third-party tool, further ensuring the quality of the codes, and ensuring the maintainability and the robustness of the codes.

Optionally, if the target functional characteristic does not pass the local static code inspection, the submission of the target functional characteristic or the code is prevented, and a submitter is reminded to perform code logic inspection, so as to further ensure the correctness and quality of the code.

In step S530, upon determining that the target functional characteristic does not pass the secondary incremental scan check, executing a log monitoring alarm instruction.

In an exemplary embodiment of the present invention, when performing the secondary incremental scanning inspection on the target functional characteristics or codes submitted to the target repository, the target functional characteristics or codes do not pass the secondary incremental scanning inspection, and at this time, it is considered that the target functional characteristics or codes have a quality problem, and cannot be issued, and need to be recompiled, so that a log monitoring alarm instruction is executed, an alarm is given to related personnel, the issue of the problematic target functional characteristics or codes is avoided, and the quality of the target functional characteristics or codes is ensured.

FIG. 6 schematically shows a flow diagram of static code inspection instrumentation, according to one embodiment of the invention.

Step S601, monitoring each Git submission operation;

step S602, when it is monitored that a Git submit operation is performed, performing local static code check on the submitted target function characteristic or code, for example, the submitted target function characteristic or code may be checked by Etilit (which is a checking tool for JavaScript syntax rules and code styles that are plug-in and configurable) and/or Styleint (which is a css code checking tool);

step S603, determining whether the static code check passes, if so, executing step S604, otherwise, executing step S601;

step S604, submitting the target function characteristics or codes checked by the static codes to a target warehouse;

step S605, when the target functional characteristics or codes which pass the static code inspection are submitted to a target warehouse, triggering a third party tool (Codecc) to carry out secondary increment scanning inspection on the target functional characteristics or codes;

step S606, the checking process is ended when the target functional characteristics or codes pass the secondary increment scanning check, otherwise, the step S607 is executed;

and step S607, executing a log monitoring alarm instruction on the target functional characteristics or codes which are not checked through the secondary incremental scanning, and giving an alarm to related personnel.

In step S430, after the target functional characteristic test is completed, a distribution branch node is determined by the control branch node and the characteristic development branch node, so as to distribute the target functional characteristic by the distribution branch node.

In an example embodiment of the present invention, a Release branch node (Release branch) may refer to a branch that releases a target functional characteristic or code submitted in a control branch node or a characteristic development branch node. After the target function characteristic test is completed, the control branch nodes or the characteristic development branch nodes are combined into the release branch nodes together, and when the release branch nodes receive the uploaded target function characteristics, an ARS (automatic request system) list is generated and the target function characteristics are released.

Specifically, the release branch node is determined by controlling the branch node and the characteristic development branch node; and developing the branch node based on the characteristics, and initiating a code review instruction to the issuing branch node to enable the issuing branch node to generate issuing data and issue the target functional characteristics. The Code Review instruction (Code Review) may refer to an instruction to check the source Code for compliance with an encoding standard and the quality of the Code by reading the Code. The issue data may refer to data (for example, ARS sheet) generated after the issue branch node issues the target functional characteristic through an issue system (for example, ARS system).

In step S440, after the target functional characteristic release is completed, the characteristic development branch node is incorporated into the control branch node to complete the release of the target functional characteristic.

In one example embodiment of the present invention, after target functional feature issuance is complete and present network validation is complete, the feature development branch node submits a Merge request instruction (Merge request) to Merge the feature development branch node into the control branch node.

Specifically, the target code inspection platform performs code inspection on the issued target functional characteristics to ensure the code quality of the target functional characteristics. The object code inspection platform may refer to a third party platform that inspects the submitted or issued object functional characteristics or codes, for example, the object code inspection platform may be codec, and this example embodiment is not limited thereto.

Fig. 7 schematically shows an application scenario diagram of an implementation method of front-end engineering according to an embodiment of the present invention.

Referring to fig. 7, in step S701, a Feature development branch node (Feature branch) is directly cut out from a control branch node (Master branch), and a constraint submission specification is forcibly checked in each submission;

step S702, a test environment for testing target functional characteristics is deployed through automatic test Continuity Integration (CI), a characteristic development branch node (Feature branch) is directly deployed to the test environment and tests the target functional characteristics, and engineering tools ensure the synchronism of the characteristic development branch node (Feature branch) and a control branch node (Master branch) during the branch test;

step S703, after performing gray level verification on the functional characteristics in the hot repair branch node (Hotfix branch), directly merging the hot repair branch node (Hotfix branch) into the control branch node (Master branch), and submitting the repaired functional characteristics to the control branch node (Master branch);

step S704, issuing the repaired functional characteristics in step S703 to a Release branch node (Release branch);

step S705, after the target function characteristic test is completed, the characteristic development branch node (Feature branch) pre-issues (newly-built ARS list and issues through ARS) the target function characteristic, a Code Review instruction (Code Review) is initiated to the issue branch node (Release branch), the target function characteristic is submitted to the issue branch node (Release branch) after the Review is passed, and the issue branch node (Release branch) generates issue data (ARS list) and issues the target function characteristic to the upper line;

step S706, after the target functional Feature is released, the Feature development branch node (Feature branch) submits a merge request (merge request), merges the Feature development branch node (Feature branch) back to the control branch node (Master branch), and triggers the codec check.

The workflow simplifies the flow of develop branches, ensures the consistency of branch characteristics by engineering tools, provides the capability of branch release, and is compatible with an ARS release system and a worker bee warehouse.

In an example embodiment of the present invention, in response to a selection operation on a page template, configuration information of a target page template corresponding to the selection operation is acquired; and creating a target page template according to the configuration information. The page template may refer to template information constructed by a page created in advance by a developer, and the WEB page may be automatically and quickly created through the page template, for example, the page template may be a Weex template or an H5 template, which is not limited in this exemplary embodiment. The selection operation may refer to an operation in which the target object selects a page template to be created through an engineering tool of the specific template. The configuration information may refer to parameter information set when the page template is created, for example, the configuration information may be an entry file, an MVC/MVVM structure, a test suite, a Mock server interface, and the like of the page template, and this is not particularly limited in this example embodiment.

FIG. 8 schematically illustrates a flow diagram for page template toolization according to one embodiment of the present invention.

Referring to fig. 8, in step S801, in response to a template selection command of a target object, a page template is obtained and provided to the target object for selection by the target object;

step S802, obtaining a selection operation of a target object selection page template, and determining a target page template corresponding to the selection operation;

step S803, if the selection operation of the target object corresponds to a Weex template, setting a Weex page template through a polyfile or shim 801 corresponding to Weex, and configuring the Weex page template through a configuration parameter page speed measurement/dotting report 803, an entry file 804, an MVC/MVVM structure 805, a test suite 806, a Mock server 807 and a jsDoc 808;

step S804, if the selection operation of the target object corresponds to an H5 template, setting an H5 page template through a polyfil or shim 802 corresponding to H5, and configuring an H5 page template through a configuration parameter page speed/dotting report 803, an entry file 804, an MVC/MVVM structure 805, a test suite 806, a Mock server 807, and a jsDoc 808.

In an example embodiment of the invention, whether a submission instruction for constructing a branch node exists is monitored based on a monitoring script of a target warehouse; when a submission instruction for constructing a branch node is monitored, determining the type of the branch node according to the submission instruction; and calling the corresponding construction script through the type so as to trigger the corresponding server side to construct the branch node through the construction script. For a front-end page construction flow, the local construction is transferred to a server side for construction, the Web hook of worker bees is used for monitoring the submission of the branch Git to be constructed, different server sides are triggered to construct workflows according to different gittools, the server side docker is used for stabilizing and constructing the environment, the consistency of constructed products is ensured, and the availability and the stability of the front end are improved.

FIG. 9 schematically shows a flow diagram of server-side build instrumentation and optimization according to one embodiment of the invention.

The server-side construction process when selecting the test command is as follows:

step S901, detecting a target object selection test command; step S902, monitoring whether a submission instruction for constructing a branch node exists or not based on a monitoring script of a target warehouse, and determining the type of the branch node according to the submission instruction when the submission instruction for constructing the branch node is monitored; step S903, pulling a Docker (an application container engine with an open source, so that a developer can package an application and a dependency package into a portable mirror image and then release the portable mirror image to any Linux or Windows machine, and can also realize virtualization) mirror image; step S904, detecting whether a packet cache exists in the Docker image, if so, executing step S906, otherwise, executing step S905; step S905, downloading the dependent package from the Docker mirror image; step S906, checking whether a control branch needs to be merged, if so, performing step S908, otherwise, performing step S907; step S907, interrupting the test; step S908, checking the incremental static code; step S909, triggering the corresponding server to construct a test branch node (Feature development branch node); step S910, deploying the test branch node to a test environment; step S911, log and monitoring notification alarm for step S908, step S909 and step S910;

step S912, detecting a target object selection and release command; step S913, monitoring whether a submission instruction for constructing the branch node exists or not based on the monitoring script of the target warehouse, and determining the type of the branch node according to the submission instruction when the submission instruction for constructing the branch node is monitored; step S914, pull Docker (is an application container engine of open source, let the developer pack the application and rely on the package to a portable mirror image, then release to any Linux or Windows machine, can also realize the virtualization) mirror image; step S915, detecting whether a packet cache exists in the Docker mirror image, if so, executing step S917, otherwise, executing step S916; step S916, downloading the dependent package from the Docker image; step S917, checking whether a control branch needs to be merged, if yes, performing step S919, otherwise, performing step S918; step S918, interrupting the issuing; step S919, checking the incremental static code; step S920, triggering a corresponding server end to construct a test branch node (Feature development branch node); step S921, deploying the test branch node to a test environment; step S922 performs a log and monitoring notification alarm for step S919, step S920, and step S921.

The embodiment of the example also provides an implementation method of the front-end engineering. The implementation method of the front-end engineering may be applied to the server 105, and may also be applied to one or more of the

terminal devices

101, 102, and 103, which is not particularly limited in this exemplary embodiment. The implementation method of the front end engineering in this exemplary embodiment may be considered as a tooled packaging of the implementation method of the front end engineering shown in fig. 4. Referring to fig. 10, the front end engineering implementation method may include steps S1010 to S1040:

in step S1010, in response to an operation that triggers a start command, a control branch node is created, and a branch node is developed based on the control branch node creation characteristic.

In step S1020, in response to the operation of triggering the test command, the submitted target functional characteristics are obtained, and the characteristic development branch nodes are directly deployed to the test environment to perform the functional test on the target functional characteristics.

In step S1030, in response to an operation of triggering an issue command, an issue branch node is determined by the control branch node and the characteristic development branch node to issue the target functional characteristic by the issue branch node.

In step S1040, after the target functional property is released, the property development branch node is merged into the control branch node to complete the release of the target functional property.

In step S1050, in response to an operation of triggering an end command, deleting a local branch node or a remote branch node, and emptying the test environment.

For the workflow mentioned in fig. 4, in the present exemplary embodiment, four commands are encapsulated, collected as start, tested, issued, and ended, and Node-Git is used as Git agent, and the client user lets the engineering tool proxy local Git, automated Merge branch, Checkout branch, detect conflict, initiate Merge request, submit specification check, and monitor Git change through Git authorization.

Fig. 11 schematically shows a flowchart of tooled packaging of an implementation method of front-end engineering according to an embodiment of the present invention.

Referring to fig. 11, step S1101, in response to a target object selection start instruction, performs step S1102; step S1102, acquiring a branch name selected and created by a target object and creating a corresponding branch; step S1103, in response to the target object selection test instruction, executing step S1104; step S1104, determining whether to merge the created branch into a control branch (Master branch), if yes, executing step 1109, otherwise executing step S1105; step S1105, log and monitor the created branch; step S1106, performing Git submission monitoring on the created branches; step S1107, Merge request monitoring is carried out on the created branch; step S1108, page publishing and page testing monitoring are carried out on the created branches; step S1109, in response to the target object selecting the issue instruction, executing step S1110 and step S1113 at the same time; step S1110, initiating an MR test; step S1111, submitting the functional characteristics in the branch nodes; step S1112, determining whether the functional characteristic meets the submission criterion, if yes, performing step S1103, otherwise, performing step S1111, i.e. re-submitting; step S1113, determining whether there is a Release branch, if yes, executing step S1115, otherwise executing step S1114; step S1114, building a local/remote branch; step S1115, a target object selection start instruction, and step S1116 is executed; step S1116, delete local/far-end branch, and clear the context.

It should be noted that although the steps of the methods of the present invention are depicted in the drawings in a particular order, this does not require or imply that the steps must be performed in this particular order, or that all of the depicted steps must be performed, to achieve desirable results. Additionally or alternatively, certain steps may be omitted, multiple steps combined into one step execution, and/or one step broken down into multiple step executions, etc.

Further, in the present exemplary embodiment, an apparatus for implementing front end engineering is also provided. The implementation device of the front-end engineering can be applied to a server or terminal equipment. Referring to fig. 12, the front-end engineering implementation apparatus 1200 may include a feature development branch node creation module 1210, a target functional feature test module 1220, a target functional feature issuance module 1230, and a feature development branch node merger module 1240. Wherein:

the characteristic development branch node creation module 1210 is configured to create a control branch node and create a characteristic development branch node based on the control branch node;

the target functional characteristic testing module 1220 is configured to obtain the submitted target functional characteristics, and directly deploy the characteristic development branch nodes to a testing environment to perform a functional test on the target functional characteristics;

the target functional characteristic issuing module 1230 is configured to determine, after the target functional characteristic test is completed, an issuing branch node through the control branch node and the characteristic development branch node, so as to issue the target functional characteristic through the issuing branch node;

the property development branch node merging module 1240 is used for merging the property development branch node into the control branch node after the target functional property is released, so as to complete the release of the target functional property.

In an exemplary embodiment of the invention, the target functional characteristic publication module 1230 is further configured to:

In an exemplary embodiment of the invention, the implementation apparatus 1200 of the front-end engineering further comprises a code checking unit configured to:

In an exemplary embodiment of the present invention, the target functional characteristic test module 1220 further includes a static code automatic check unit configured to:

performing local static code checking on the target functional characteristics;

In an exemplary embodiment of the present invention, the implementation apparatus 1200 of the front-end engineering further includes a page template creation module, where the page template creation module includes:

Further, in the present exemplary embodiment, an apparatus for implementing front end engineering is also provided. The implementation device of the front-end engineering can be applied to a server or terminal equipment. Referring to fig. 13, the front-end engineering apparatus 1300 may include a feature development branch node creation module 1310, a target functional feature test module 1320, a target functional feature publishing module 1330, and a feature development branch node merge module 1340. Wherein:

the start command triggering unit 1310 is configured to create a control branch node in response to an operation of triggering a start command, and develop a branch node based on a control branch node creation characteristic;

the test command triggering unit 1320 is configured to, in response to an operation of triggering a test command, obtain a submitted target functional characteristic, and directly deploy the characteristic development branch node to a test environment to perform a functional test on the target functional characteristic;

the issue command triggering unit 1330 is configured to, in response to an operation of triggering an issue command, determine an issue branch node through the control branch node and the characteristic development branch node to issue the target functional characteristic through the issue branch node;

the node merging unit 1340 is configured to merge the feature development branch node into the control branch node after the target functional feature is released, so as to complete the release of the target functional feature;

the end command triggering unit 1350 is configured to delete the local branch node or the remote branch node and empty the test environment in response to an operation of triggering the end command.

The specific details of each module or unit in the implementation apparatus of the front-end engineering have been described in detail in the implementation method of the corresponding front-end engineering, and therefore are not described herein again.

It should be noted that although in the above detailed description several modules or units of the device for action execution are mentioned, such a division is not mandatory. Indeed, the features and functionality of two or more modules or units described above may be embodied in one module or unit, according to embodiments of the invention. Conversely, the features and functions of one module or unit described above may be further divided into embodiments by a plurality of modules or units.

Other embodiments of the invention will be apparent to those skilled in the art from consideration of the specification and practice of the invention disclosed herein. This application is intended to cover any variations, uses, or adaptations of the invention following, in general, the principles of the invention and including such departures from the present disclosure as come within known or customary practice within the art to which the invention pertains. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the invention being indicated by the following claims.

It will be understood that the invention is not limited to the precise arrangements described above and shown in the drawings and that various modifications and changes may be made without departing from the scope thereof. The scope of the invention is limited only by the appended claims.

Claims

1. A front-end engineering implementation method is characterized by comprising the following steps:

2. The front-end engineering implementation method of claim 1, wherein determining a distribution branch node by the control branch node and the property development branch node to distribute the target functional property by the distribution branch node comprises:

3. The front-end engineering implementation method of claim 1, wherein after incorporating the property development branch node into the control branch node to complete the release of the target functional property, the method further comprises:

4. The method of claim 1, wherein obtaining submitted target functional characteristics, further comprises:

performing local static code checking on the target functional characteristics;

5. The front-end engineering implementation method of claim 1, wherein after incorporating the property development branch node into the control branch node to complete the release of the target functional property, the method further comprises:

and creating a target page template according to the configuration information.

6. The front-end engineering implementation method of any one of claims 4 or 5, wherein creating a target page template according to the configuration information further comprises:

7. A front-end engineering implementation method is characterized by comprising the following steps:

8. An implementation device of front end engineering is characterized by comprising:

9. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the method of any one of claims 1 to 7.

10. An electronic device, comprising:

a processor; and

a memory for storing executable instructions of the processor;

wherein the processor is configured to perform the method of any of claims 1-7 via execution of the executable instructions.