Method and device for characteristic branches to rapidly exit from integration area under branch model

Abstract

The embodiment of the invention discloses a method and a device for a characteristic branch to quickly exit from an integration area under a branch model. In the embodiment of the invention, a target characteristic branch rapid exit instruction is received, and the rapid exit instruction carries a serial number of a target characteristic branch; according to the number of the target characteristic branch, obtaining code change content of the integrated branch when the target characteristic branch is combined to the integrated branch where the target characteristic branch is located; determining the updated code content of the integrated branch after the target characteristic branch exits from the integrated branch according to the code change content; receiving an exit confirmation instruction; and according to the exit confirmation instruction, the target characteristic branch rapidly exits the integrated branch. Through the method, any characteristic branch can be simply and efficiently quitted from the integration region, and other residual characteristic branches in the integration region are not influenced.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and more specifically, to a method and device for quickly exiting an integrated area for a characteristic branch under a branch model. Background Art

[0002] In the R&D delivery platform, code branch lifecycle management, branch integration, deployment, testing, and release are required during the R&D process. Code branches are a general term for multiple branches under the branch R&D model. The above branch R&D model is to adapt to the rapid changes in R&D scenarios. Each requirement or task needs to be developed on a separate branch. Under the above R&D model, the main branches involved are trunk branches, feature branches, and integration branches. After multiple feature branches are added to an integration area, an integration branch is created.

[0003] In the prior art, in the branch development mode, each time any feature branch exits from the integration area, it will cause the integration branch of the integration area to be rebuilt. The developer needs to resolve the full conflicts caused by the reintegration of all the remaining feature branches in the integration area, which affects the development efficiency. Moreover, since the above-mentioned full conflicts may not belong to the same developer, the current developer is prone to processing errors when resolving conflicts of other developers.

[0004] In summary, how to simply and efficiently withdraw any feature branch from the integration area without affecting other remaining feature branches in the integration area is a problem that needs to be solved at present. Summary of the invention

[0005] In view of this, an embodiment of the present invention provides a method and apparatus for quickly exiting a feature branch from an integrated area under a branch model, which can simply and efficiently exit any feature branch from the integrated area without affecting other remaining feature branches in the integrated area.

[0006] In a first aspect, an embodiment of the present invention provides a method for quickly exiting an integrated region for a feature branch under a branch model, the method comprising:

[0007] Receiving a target feature branch quick exit instruction, wherein the quick exit instruction carries the number of the target feature branch;

[0008] According to the number of the target feature branch, obtain the code change content of the integration branch when the target feature branch is merged into the integration branch where the target feature branch is located;

[0009] Determine, according to the code change content, the updated code content of the integration branch after the target feature branch exits the integration branch;

[0010] Receive confirmation exit instruction;

[0011] According to the confirmed exit instruction, the target feature branch quickly exits the integration branch.

[0012] Optionally, determining the updated code content of the integration branch after the target feature branch exits the integration branch according to the code change content specifically includes:

[0013] Determine the code negation content of the code change content, wherein the code negation content is the opposite content of the code change content;

[0014] The inverted code content is merged into the current code content of the integration branch to generate updated code content of the integration branch.

[0015] Optionally, the method further includes:

[0016] Determine whether the target feature branch meets the rules for quickly exiting the integration branch.

[0017] Optionally, the method further includes:

[0018] The current code content of the integration branch and the updated code content of the integration branch are displayed.

[0019] Optionally, the method further includes:

[0020] After the target feature branch quickly exits the integration branch, the content of the integration area corresponding to the integration branch is displayed, wherein the integration area includes at least one feature branch merged into the integration branch.

[0021] Optionally, the method further includes:

[0022] Receiving the target feature branch rejoining instruction, wherein the target feature branch is a feature branch that has quickly exited the integration branch, and the rejoining instruction carries the encoding of the target feature branch;

[0023] Determine, according to the encoding of the target feature branch, the version number of the integration branch where the target feature branch is located when the integration branch is quickly exited;

[0024] Determining the object code content of the integration branch according to the version number of the integration branch;

[0025] The current code content of the integration branch is restored to the target code content.

[0026] Optionally, the method further includes:

[0027] Merge the target feature branch back into the integration branch.

[0028] Optionally, the method further includes:

[0029] In response to a conflict existing after restoring the current code content of the integration branch to the target code content, displaying the conflicting content of the integration branch;

[0030] Conflict resolution instructions received.

[0031] Optionally, the method further includes:

[0032] Display the content of the integration area corresponding to the integration branch after the target feature branch is rejoined to the integration branch.

[0033] In a second aspect, an embodiment of the present invention provides a device for quickly exiting an integrated region of a feature branch under a branch model, the device comprising:

[0034] A receiving unit, configured to receive a target feature branch quick exit instruction, wherein the quick exit instruction carries the number of the target feature branch;

[0035] An acquisition unit, configured to acquire, according to the number of the target feature branch, the code change content of the integration branch when the target feature branch is merged into the integration branch to which it belongs;

[0036] An updating unit, configured to determine, according to the code change content, the updated code content of the integration branch after the target feature branch exits the integration branch;

[0037] The receiving unit is further configured to, upon receiving a confirmation exit instruction,

[0038] A confirmation unit is used to enable the target feature branch to quickly exit the integration branch according to the confirmation exit instruction.

[0039] Optionally, the updating unit is specifically used for:

[0040] Determine the code negation content of the code change content, wherein the code negation content is the opposite content of the code change content;

[0041] The inverted code content is merged into the current code content of the integration branch to generate updated code content of the integration branch.

[0042] Optionally, the device further comprises:

[0043] The detection unit is used to determine whether the target feature branch meets the rules for quickly exiting the integration branch.

[0044] Optionally, the device further comprises:

[0045] The display unit is used to display the current code content of the integration branch and the updated code content of the integration branch.

[0046] Optionally, the display unit is further used for:

[0047] After the target feature branch quickly exits the integration branch, the content of the integration area corresponding to the integration branch is displayed, wherein the integration area includes at least one feature branch merged into the integration branch.

[0048] Optionally, the receiving unit is further used for:

[0049] Receiving the target feature branch rejoining instruction, wherein the target feature branch is a feature branch that has quickly exited the integration branch, and the rejoining instruction carries the encoding of the target feature branch;

[0050] The device also includes:

[0051] A determination unit, configured to determine, according to the encoding of the target feature branch, a version number of the integration branch where the target feature branch is located when the target feature branch is quickly exited from the integration branch;

[0052] The determining unit is further used to: determine the target code content of the integration branch according to the version number of the integration branch;

[0053] The updating unit is further used for restoring the current code content of the integration branch to the target code content.

[0054] Optionally, the device further comprises:

[0055] A merging unit is used to merge the target feature branch back into the integration branch.

[0056] Optionally, the display unit is further used for:

[0057] In response to a conflict existing after restoring the current code content of the integration branch to the target code content, displaying the conflicting content of the integration branch;

[0058] The receiving unit is further used for: receiving a conflict resolution instruction.

[0059] Optionally, the display unit is further used for:

[0060] Display the content of the integration area corresponding to the integration branch after the target feature branch is rejoined to the integration branch.

[0061] In a third aspect, an embodiment of the present invention provides an electronic device, comprising a memory and a processor, the memory being used to store one or more computer program instructions, wherein the one or more computer program instructions are executed by the processor to implement a method as described in the first aspect or any possible embodiment of the first aspect.

[0062] In a fourth aspect, an embodiment of the present invention provides a computer-readable storage medium storing computer program instructions, which, when executed by a processor, implement a method as described in the first aspect or any possible embodiment of the first aspect.

[0063] In an embodiment of the present invention, a target feature branch quick exit instruction is received, wherein the quick exit instruction carries the number of the target feature branch; based on the number of the target feature branch, the code change content of the integrated branch when the target feature branch is merged into the integrated branch where it is located is obtained; based on the code change content, the updated code content of the integrated branch after the target feature branch exits the integrated branch is determined; a confirmation exit instruction is received; and based on the confirmation exit instruction, the target feature branch quickly exits the integrated branch. Through the above method, the code content of any feature branch can be simply and efficiently stripped from the code content of the integrated branch, that is, any feature branch can exit from the integrated branch, that is, exit from the integrated area corresponding to the integrated branch, without affecting other remaining feature branches in the integrated area. BRIEF DESCRIPTION OF THE DRAWINGS

[0064] The above and other objects, features and advantages of the present invention will become more apparent through the following description of the embodiments of the present invention with reference to the accompanying drawings, in which:

[0065] Figure 1 This is a schematic diagram of the relationship between the branches in an embodiment of the present invention;

[0066] Figure 2 is a flow chart of a method for a characteristic branch to quickly exit an integrated area under a branch model in an embodiment of the present invention;

[0067] Figure 3 is a schematic diagram of a front-end interface of a research and development delivery platform in an embodiment of the present invention;

[0068] Figure 4 is a schematic diagram of a front-end interface of another R&D delivery platform in an embodiment of the present invention;

[0069] Figure 5 is a flow chart of a method for a characteristic branch to quickly exit an integrated area under another branch model in an embodiment of the present invention;

[0070] Figure 6is a flow chart of a method for a characteristic branch to quickly exit an integrated area under another branch model in an embodiment of the present invention;

[0071] Figure 7 It is a flow chart of a method for reintegrating a feature branch with rapid exit under a branch model in an embodiment of the present invention;

[0072] Figure 8 is a flow chart of a method for reintegrating a feature branch with rapid exit under another branch model in an embodiment of the present invention;

[0073] Fig. 9 is a schematic diagram of a front-end interface of a research and development delivery platform in an embodiment of the present invention;

[0074] Fig.10 is a flow chart of a method for reintegrating a feature branch with rapid exit under another branch model in an embodiment of the present invention;

[0075] Fig.11 It is a flow chart of a method for reintegrating a feature branch with rapid exit under another branch model in an embodiment of the present invention;

[0076] Fig.12 is a topological schematic diagram of an embodiment of the present invention;

[0077] Fig.13 is another topological schematic diagram in an embodiment of the present invention;

[0078] Fig.14 is another topological diagram in an embodiment of the present invention;

[0079] Fig.15 is a state diagram of a status field in an embodiment of the present invention;

[0080] Fig.16 It is a schematic diagram of a device for quickly exiting an integrated area of ​​a characteristic branch under a branch model in an embodiment of the present invention;

[0081] Fig.17 is a schematic diagram of an electronic device in an embodiment of the present invention. DETAILED DESCRIPTION

[0082] The present application is described below based on embodiments, but the present application is not limited to these embodiments. In the detailed description of the present application below, some specific details are described in detail. It is possible for those skilled in the art to fully understand the present application without the description of these details. In order to avoid confusing the essence of the present application, known methods, processes, flows, components and circuits are not described in detail.

[0083] In addition, persons of ordinary skill in the art will appreciate that the drawings provided herein are for illustration purposes and are not necessarily drawn to scale.

[0084] Unless the context clearly requires otherwise, the words "include", "comprising" and similar words throughout the application should be interpreted as including rather than exclusive or exhaustive; that is, the meaning is "including but not limited to".

[0085] In the description of this application, it should be understood that the terms "first", "second", etc. are only used for descriptive purposes and cannot be understood as indicating or implying relative importance. In addition, in the description of this application, unless otherwise specified, the meaning of "plurality" is two or more.

[0086] In the existing technology, the R&D delivery platform is a platform used by R&D staff when conducting R&D. The R&D delivery platform provides full-cycle capabilities in the R&D, delivery, and operation and maintenance processes, as well as code branch lifecycle management, branch integration, deployment, testing, and release during the R&D process; the above-mentioned R&D interaction platform can directly call the underlying code version control tool git, and is responsible for maintaining relevant operation records, etc.

[0087] The above code branches are a general term for multiple branches in the branch development model. The main branches involved are the master branch, feature branch (also called development branch) and integration branch (also called release branch). Among them, the master branch represents the latest online version, and the feature branch is pulled from the latest version of the master branch. After the official version is released, the integration branch will be merged into the master branch to ensure that the master branch is the latest online version; the feature branch is used to carry the repair of a defect, or the development of a requirement, or the development of a subtask after the requirement is decomposed; the integration branch is used for integration and release; because in the branch mode, multiple feature branches need to be submitted to the integration area first, the R&D delivery platform will create an integration branch based on the latest version of the master branch, and then merge the feature branches in the integration area into the integration branch for deployment and testing; specifically, each requirement or task is developed on a separate feature branch, and after unit testing and smoke testing, it is integrated with other feature branches. After the integration branch is generated, integration testing, regression testing, grayscale testing, performance testing and other processes are carried out, and finally released.

[0088] The relationship between the above trunk branches, feature branches and integration branches can be Figure 1 To illustrate with an example, Figure 1It includes multiple versions of the main branch, for example, Tag1.0, Tag1.1 and Tag2.0. After the feature branch is pulled from the latest main branch Tag1.0, iteration 1, requirement R1 development, iteration 1, requirement R2 development, test problem fixes, pre-release problem fixes, iteration 2, requirement R3 development, etc. are carried out; the development branch is merged into the integration branch, code merging, integration testing, pre-release regression testing and production environment release are carried out, and finally the main branch Tag2.0 is updated; the development process is carried out on the feature branch, and the integration branch is automatically created during testing, pre-release and production environment release, and the feature branch is automatically merged into the integration branch. When the production is finally released, the integration branch code is automatically merged into the main branch. In the above Figure 1 In the example, the main branch Tag1.1 is updated after the patch branch fixes the online problem, which will not be described in detail here. When the production is rolled back, the code is automatically rolled back, and can be rolled back from Tag2.0 to Tag1.1. This is just an example.

[0089] In the branch development mode of the R&D delivery platform, since multiple feature branches are added to an integration area to create an integration branch, each time any feature branch is withdrawn from the integration area, it will cause the integration branch of the integration area to be rebuilt. Developers need to resolve the full conflicts caused by reintegration of all the remaining feature branches in the integration area, which affects the R&D efficiency. In addition, since the above full conflicts may not belong to the same developer, the current developer is prone to processing errors when resolving conflicts of other developers. Therefore, how to simply and efficiently withdraw any feature branch from the integration area without affecting the remaining other feature branches in the integration area is a problem that needs to be solved at present.

[0090] In order to solve the above problems, an embodiment of the present invention proposes a method for a feature branch to quickly exit an integrated area under a branch model, specifically: Figure 2 As shown, the method includes:

[0091] Step S201: receiving a target feature branch quick exit instruction, wherein the quick exit instruction carries the number of the target feature branch.

[0092] Specifically, the R&D delivery platform receives a target feature branch quick exit instruction, wherein the quick exit instruction carries information such as the number of the target feature branch or the name of the target feature branch.

[0093] In a possible implementation, the target feature branch is displayed in an integrated area of ​​the front-end interface of the R&D delivery platform. A simple schematic diagram of the front-end interface of the R&D delivery platform is as follows: Figure 3As shown, the integrated area includes feature branch 1, feature branch 2, feature branch 3, feature branch 4 and feature branch 5, and feature branch 5 is selected for quick exit, that is, feature branch 5 is the target feature branch.

[0094] Step S202: According to the number of the target feature branch, the code change content of the integration branch when the target feature branch is merged into the integration branch where the target feature branch is located is obtained.

[0095] Specifically, the R&D delivery platform calls the code version control tool git to calculate the historical version, and calculates the code changes of the integration branch when the target feature branch is merged into the integration branch where it is located.

[0096] In the embodiment of the present invention, the code version control tool git provides a complete version management function for storing and tracking the modification history of directories and files, and can perform management, tracing, version comparison, change replay and other operations on versions; the git is an open source distributed version control system that can effectively and quickly manage project versions. The R&D delivery platform uses git to perform version operations on user-related codes to implement solution-related logic.

[0097] In an embodiment of the present invention, the git includes a git merge instruction for indicating branch merging. In the integration area, the R&D delivery platform calls the git merge instruction to merge the feature branches into the integration branch one by one; the git also includes a git diff instruction, which determines the code change content of the integration branch through the git diff instruction, wherein the gitdiff instruction runs a difference function on the Git data source, and the data source can be files, branches, submissions, etc.; the git diff instruction is used to display changes between submissions, etc. In the above steps, the git diff command is used to calculate the changes of the current feature branch relative to the integration branch, that is, the code change content of the integration branch, for example, the number of changed files and the changed content of each file, and save the code change content of the integration branch to a patch file.

[0098] Step S203: Determine the updated code content of the integration branch after the target feature branch exits the integration branch according to the code change content.

[0099] Specifically, determine the code negation content of the code change content, wherein the code negation content is the opposite content of the code change content; merge the code negation content into the current code content of the integration branch to generate the updated code content of the integration branch.

[0100] In an embodiment of the present invention, the git merges the inverted code content into the current code content of the integration branch through the git apply-R instruction; the git apply-R instruction reversely applies the code changes contained in a patch file to the code content of the current integration branch. In the above steps, the git apply-R instruction is used to reversely apply the changes of the target feature branch relative to the integration branch to the integration branch, that is, to separate the changes of the target feature branch from the integration branch; for example, if a new section of content is added to the target feature branch, it will be deleted on the integration branch; if a section of content is deleted on the development branch, it will be added to the integration branch; if a section of content is modified on the development branch, it will be restored to the content before the modification.

[0101] Step S204: receiving a confirmation exit instruction.

[0102] Specifically, the WebIDE interface of the R&D delivery platform receives a confirmation exit instruction triggered by the user, indicating that the updated code content is the code content corresponding to the target feature branch stripped away.

[0103] Step S205: According to the confirmation exit instruction, the target feature branch quickly exits the integration branch.

[0104] Specifically, after the target feature branch quickly exits the integration branch, in the front-end interface of the R&D delivery platform, the target feature branch has been removed from the integration area of ​​the front-end interface of the R&D delivery platform. A simple schematic diagram of the front-end interface of the R&D delivery platform is shown as follows: Figure 4 As shown, the integrated area includes feature branch 1, feature branch 2, feature branch 3 and feature branch 4.

[0105] In a possible implementation, after step S203, other steps are further included, specifically: Figure 5 As shown, the following steps are included:

[0106] Step S206: display the current code content of the integration branch and the updated code content of the integration branch.

[0107] Specifically, the WebIDE interface of the R&D delivery platform simultaneously displays the current code content of the integration branch and the updated code content of the integration branch. At the same time, a "Confirm and Submit" box is set in the WebIDE interface. After the user confirms the current code content of the integration branch and the updated code content of the integration branch, the user can click the "Confirm and Submit" box to trigger the confirmation exit instruction.

[0108] The following is a complete example to describe in detail how to quickly exit the integration branch from the target feature branch. Figure 6 The method comprises the following steps:

[0109] Step S601: The R&D delivery platform receives a target feature branch quick exit instruction triggered by a user.

[0110] Specifically, the quick exit instruction carries the number of the target feature branch or the name of the target feature branch.

[0111] In a possible implementation, the R&D delivery platform may also be a processor or a server.

[0112] Step S602, determine whether the target feature branch meets the rules for quickly exiting the integration branch, if so, execute step S603, if not, execute step S606.

[0113] In a possible implementation, the rules for quickly exiting the integration branch are shown in Table 1 below:

[0114] Table 1

[0115]

[0116] In the above Table 1, the value of N may be 3, or other positive integers greater than 0, which is determined according to actual conditions.

[0117] Step S603, in response to the target feature branch meeting the rule of quickly exiting the integration branch, determining the current code content of the integration branch and the updated code content of the integration branch after the target feature branch exits the integration branch, and displaying the current code content of the integration branch and the updated code content in the webIDE interface.

[0118] In a possible implementation, the webIDE interface is the development environment of the R&D delivery platform. In addition to displaying the current code content of the integration branch and the updated code content, the webIDE interface can also display a list of modified files of the target feature branch.

[0119] In an embodiment of the present invention, the R&D delivery platform calls git to determine the current code content of the integration branch and the updated code content of the integration branch after the target feature branch exits the integration branch.

[0120] Step S604: the webIDE interface receives a confirmation exit instruction.

[0121] Specifically, the confirmation exit instruction is triggered by the user and is used to confirm the stripping of the code content of the target feature branch.

[0122] Step S605: The R&D delivery platform quickly exits the target feature branch from the integration branch according to the confirmation exit instruction.

[0123] In a possible implementation, the webIDE interface calls back to the R&D delivery platform, and after the target feature branch quickly exits the integration branch, the target feature branch in the R&D delivery platform interface has exited the integration area.

[0124] Step S606: The pipeline of the integration branch of the R&D delivery platform is redeployed, and subsequent operations are continued.

[0125] In a possible implementation, after the webIDE interface determines the updated code content of the integration branch, the updated code content is sent to the code repository through the git for storage.

[0126] In the embodiment of the present invention, after the target feature branch exits the integrated branch, it can be processed separately, for example, the problem existing in the target feature branch is repaired. After the modification is completed, the litigation target feature branch needs to be merged back into the integrated branch from which it exited quickly. Specifically, a method for reintegrating feature branches that exit quickly under a branch model is proposed, specifically as follows: Figure 7 As shown, the method includes:

[0127] Step S701: receiving the target feature branch rejoining instruction, wherein the target feature branch is a feature branch that has quickly exited the integration branch, and the rejoining instruction carries the encoding of the target feature branch.

[0128] Specifically, the R&D delivery platform receives a rejoining instruction triggered by a user for a target feature branch that has quickly exited an integration branch, and the rejoining instruction carries the code or name of the target feature branch.

[0129] Step S702: Determine, according to the code of the target feature branch, the version number of the integration branch where the target feature branch is located when the integration branch is quickly exited.

[0130] Specifically, since the R&D delivery platform stores the code of the target feature branch at each change and the version number of the integrated branch where the target feature branch is located when it quickly exits the integrated branch, the version number of the integrated branch where the target feature branch is located when it quickly exits the integrated branch can be determined based on the code of the target feature branch.

[0131] Step S703: Determine the target code content of the integration branch according to the version number of the integration branch.

[0132] Specifically, the R&D delivery platform obtains the target code content of the integration branch from the code repository according to the version number of the integration branch.

[0133] Step S704: restore the current code content of the integration branch to the target code content.

[0134] Specifically, the integration branch reverts (reverts) from the current code content the commit of the code of the target feature branch that was stripped off when the quick exit branch was used last time.

[0135] In an embodiment of the present invention, the R&D delivery platform calls git to recover the code content. Specifically, git uses the git revert instruction to undo the changes of the specified target feature branch. The git revert instruction will not delete any historical data, but will create a new submission with the opposite changes, thereby undoing the specified submission.

[0136] In a possible implementation, after step S704, other steps are further included, specifically: Figure 8 As shown, the following steps are included:

[0137] Step S705: merge the target feature branch back into the integration branch.

[0138] Step S706: Display the content of the integration area corresponding to the integration branch after the target feature branch is rejoined to the integration branch.

[0139] Specifically, after the target feature branch is merged back into the integration branch, the target feature branch is added back into the integration area of ​​the front-end interface of the R&D delivery platform. Before the target feature branch is added back, the front-end interface of the R&D delivery platform is in the integration area. Figure 4 As shown, after the re-merger, the simple schematic diagram of the front-end interface of the R&D delivery platform is as follows Fig. 9 As shown, the integrated area includes feature branch 1, feature branch 2, feature branch 3, feature branch 4 and feature branch 5, wherein feature branch 5 is a target feature branch.

[0140] In a possible implementation, after step S704, other steps are further included, specifically: Fig.10 As shown, the following steps are included:

[0141] Step S707 : In response to a conflict existing when restoring the current code content of the integration branch to the target code content, displaying the conflicting content of the integration branch.

[0142] Specifically, when the integration branch withdraws the last time the quick exit branch is used from the current code content, that is, when the current code content of the integration branch is restored to the target code content, there may be a conflict, and the conflict of the code in the integration branch can be displayed in the webIDE interface.

[0143] Step S708: receiving a conflict resolution instruction.

[0144] Specifically, the user observes the code conflict in the integration branch in the webIDE interface and resolves it. After the conflict is resolved, a conflict resolution instruction is triggered and sent to the R&D delivery platform. The conflict resolution instruction is used to indicate that the code conflict in the integration branch regarding the target feature branch has been resolved, and the R&D delivery platform can continue to perform subsequent operations.

[0145] In one possible implementation, after the target feature branch is merged into the integration branch, the integration branch continues to merge other feature branches in the integration area, which may cause conflicts with other feature branches in the integration branch. The conflicts in the code in the integration branch can be displayed in the webIDE interface.

[0146] The following is a complete example to describe in detail the method for reintegrating a feature branch that is quickly exited under the branch model. Fig.11 The method comprises the following steps:

[0147] Step S1101: The R&D delivery platform receives a submission instruction and submits a target feature branch to the integration area of ​​the R&D delivery platform.

[0148] Specifically, the commit instruction is used to submit the feature branch to the integration area of ​​the R&D delivery platform.

[0149] For example, the target characteristic branch is branch Q.

[0150] Step S1102: the integrated area in the R&D delivery platform merges the feature branches in the integrated area one by one, the integrated area merges branches to the target feature branch, and the R&D delivery platform receives the target feature branch re-joining instruction.

[0151] For example, the integrated region merges into the branch Q.

[0152] Step S1103, determine whether the target feature branch has used the quick exit function in the current integration branch, if so, execute step S1104, if not, execute step S1112.

[0153] Specifically, it is determined whether the branch Q has previously used the fast exit branch capability.

[0154] Step S1104: The R&D delivery platform determines, according to the code of the target feature branch, the version number of the integration branch where the target feature branch is located when it quickly exits the integration branch.

[0155] Step S1105: The R&D delivery platform determines the target code content of the integration branch according to the version number of the integration branch.

[0156] Step S1106: The R&D delivery platform restores the current code content of the integration branch to the target code content.

[0157] Specifically, the R&D delivery platform calls git, and git revokes the submission record of the code stripping action when the target feature branch exits the integration area from the integration branch through the git revert instruction.

[0158] Step S1107, determine whether there is a conflict in the target code content, if so, execute step S1108, if not, execute step S1112.

[0159] Step S1108: In response to a conflict existing after restoring the current code content of the integration branch to the target code content, the webIDE interface displays the conflicting content of the integration branch.

[0160] Step S1109: receiving a conflict resolution instruction in the webIDE interface.

[0161] Specifically, the conflict resolution instruction is triggered by the user, indicating that the user has resolved the conflict.

[0162] Step S1110: The R&D delivery platform merges the target feature branch back into the integration branch.

[0163] Step S1111: The front-end interface of the R&D delivery platform displays the content of the integration area corresponding to the integration branch after the target feature branch is rejoined to the integration branch.

[0164] Step S1112: The R&D delivery platform continues to merge the remaining feature branches in the integration area.

[0165] In a possible implementation, the restored target code content is saved in a code repository.

[0166] In the embodiment of the present invention, the rapid exit and re-merging of the target feature branch can also be exemplified by a topology diagram, as shown in the following example: Fig.12 As shown, it includes: a trunk branch M, an integration branch R, a feature branch Q to be withdrawn, and another feature branch F; wherein, the version of the trunk branch M is variable, specifically divided into M0 and M1; the version of the feature branch Q to be withdrawn is variable, specifically divided into Q1 and Q2; the version of the other feature branch F is variable, specifically divided into F1 and F2; the version of the integration branch R is variable, specifically divided into R1, R2, R3, R4, R5 and R6; it is specifically divided into two links, as follows:

[0167] The first step is to separate the feature branches to be exited.

[0168] Specifically, as above Fig.12 As shown, M0 is the initial trunk branch, and a feature branch F and a feature branch Q to be exited are pulled out based on M1; the feature branch F generates an integration branch R1 after being submitted and released based on F1. Similarly, the feature branch Q1 is submitted and released and merged into the integration branch to generate the R2 version. The code changes of the Q branch are removed from the integration branch through the quick exit branch function, and the integration branch is iterated to the R3 version; at this time, the code of the feature branch Q to be exited has been removed from the integration branch.

[0169] The second step is to reintegrate the exited feature branch.

[0170] Specifically, based on the exited feature branch Q1, the problem has been fixed and it has been iterated to Q2; it is resubmitted to the integration area for integration, and the integration branch merges the code in sequence. First, the F2 node of another feature branch F is integrated, and then the integration branch is iterated to version R4; when the integration branch needs to merge the feature branch Q, the git revert operation should be executed first to revert the last exit branch R3. After the revert is completed, the latest version of the integration branch is now R5, and then the integration branch continues to merge the latest code version Q2 of branch Q to generate the latest version of the integration branch R6; at this time, the process of reintegrating the exited feature branch ends, and the complete process of quickly exiting the branch for the feature branch Q ends.

[0171] In a possible implementation, when a feature branch that has used the fast exit branch capability is merged back into an integration branch, the specific topology diagram can also be as follows: Fig.13As shown, it includes: a trunk branch M, a feature branch F and an integration branch R, wherein the trunk branch M will cause version changes according to changes in the timeline, specifically M1, the version of the feature branch F is variable, specifically divided into F1, F2 and F3; the version of the integration branch R is variable, specifically divided into R1, R2, R3 and R4; after the integration branch R1 merges the F2 version of the feature branch F, the integration branch is updated to the R2 version, at this time R2 contains the contents Foo and Bar of F1 and F2; by quickly exiting the branch, the content of the feature branch F is removed from R2 , and the integration branch is updated to R3. At this time, Foo and Bar are not included in R3. The new F3 node is continued to be developed on the feature branch and merged back to the integration branch. The integration branch is updated to R4. At this time, the R4 node only contains Zeg, but not Foo and Bar. The above result is completely correct from the perspective of git, because when R3 merges F3, it calculates mergeBase and performs a three-way merge based on mergeBase. At this time, mergeBase is F2, so the three-way merge based on F2 will retain the +Zeg of the F3 node and the current situation that the R3 node does not contain Foo and Bar.

[0172] From the user's perspective, due to the use of the quick branch exit capability, the R&D delivery platform also shows the user that the feature branch has been exited from the integration area. Therefore, when the user intends to submit the feature branch to the integration area again, the purpose is to merge all the contents of branch F into the integration branch R. Therefore, in order to solve the unexpected results of the user, after the feature branch quickly exits the integration area and is reintegrated again, it is necessary to revert the stripped code in the integration branch first. The specific topology diagram can also be shown as follows: Fig.14As shown: the main branch M, the feature branch F and the integration branch R, wherein the main branch M will cause version changes according to the changes in the timeline, specifically M1, the main branch M will cause version changes according to the changes in the timeline, specifically M1, the version of the feature branch F is variable, specifically divided into F1, F2 and F3; the version of the integration branch R is variable, specifically divided into R1, R2, R3, R4 and R5; first, after the integration branch R1 merges the F2 version of the feature branch F, the integration branch is updated to the R2 version. At this time, R2 contains the contents Foo and Bar of F1 and F2; the content of the F branch is removed from R2 by quickly exiting the branch, and the integration branch is updated to the R3 version. At this time, the R3 version does not contain Foo and Bar; continue to develop the new F3 node on the feature branch and merge it back into the integration branch. When the R&D delivery platform is responsible for merging branch F, if it is determined that branch F has used the quick exit branch before, then before executing the merge branch F, use git The revert command cancels the stripping code operation performed when the quick exit branch capability was used, that is, revertR3, and updates the integrated branch version to R4. At this time, if there is a conflict in the revert, the conflict needs to be resolved first; finally, the integrated branch continues to merge the feature branch F3, and the integrated branch is updated to version R5. Since R4 is equivalent to the reverse modification of the stripping code R3, the R5 version now includes the changes F1 and F2 of the F branch before R2, and also includes the modification of the F3 node.

[0173] In a possible implementation, if there are other feature branches in the integrated area, such as feature branch X, feature branch Y, etc., the feature branch X and feature branch Y are merged according to the same merging logic, which is not described here.

[0174] In the embodiment of the present invention, when the user uses the R&D delivery platform to complete the completion process of the quick exit branch, the R&D delivery platform is responsible for operating the underlying code version tool and ensuring the series connection of the overall process. In addition, the R&D delivery platform also stores relevant information in the corresponding data table, for example, the quick exit branch record. An example of the quick exit branch record table is shown in Table 2 below, which is as follows:

[0175] Table 2

[0176]

[0177]

[0178] In a possible implementation, the content in the fast exit branch record table is recorded according to actual conditions.

[0179] In the embodiment of the present invention, the relationship between the various states of the status field is shown in the figure: Fig.15As shown, specifically, the user clicks on the quick exit feature branch, the quick exit branch state enters initialization (INIT), after the code stripping is completed, the quick exit branch state enters code stripped (QUIT), the feature branch is reintegrated, and revert is executed. The quick exit branch state enters reintegration-code stripping revert in progress (REVERT ING), if there is no conflict, it enters reintegration-code stripping revert success (REVERT_SUCCESS), if there is a conflict, it enters reintegration-code stripping revert conflict (REVERT_CONFLICT), and the conflict is resolved, it enters reintegration-code stripping revert conflict resolution completed (REVERT_CONFLICT_SOLVED).

[0180] In a possible implementation, the fast exit branch record table may also be referred to as a data table or a data model. In the overall processing flow, the processing logic of the data table is as follows, which is divided into two cases:

[0181] Case 1: In the process of stripping the feature branch to be exited, when the conditions for using the fast exit branch are met, a new data is inserted to record the relevant fields. The new data includes: initialization id, gmt_create=now(), gmt_modified=now(), flow_inst_id=current integration area instance id, quit_branch_name=name of the branch to be exited, release_branch_name=current integration area branch name, status=INIT; when the user submits and pushes the stripped code, the commitId submitted this time is updated to the record, and the specific updated fields include: fast_quit_commit_id=commit Id of the stripped code, status=QUIT, gmt_modified=now().

[0182] Case 2: During the reintegration of the exited feature branch, when the user re-submits the exited feature branch to the integration, it will trigger a loop logic that merges the feature branches in the integration area into the integration branch one by one. When merged into the current feature branch, based on the name of the current integration branch and the name of the current feature branch, check whether the current feature branch has used the quick exit logic on the current integration branch; for example, query the database of the R&D delivery platform based on the conditions release_branch_name (integration branch name) and quit_branch_name (current feature branch name); if not, do not perform the revert operation, and if the previous record is found, the commit corresponding to the stripped feature branch at that time will be Id is reverted, and the status of the record is updated to REVERTING. The specific updated fields include: status = REVERTING, gmt_modified = now(); if there is a conflict in revert, the field status = REVERT_CONFLICT is updated, gmt_modified = now(); after the conflict is resolved, the conflict-resolved commitId is updated to the data store, and the status is updated to REVERT_CONFLICT_SOLVED. The specific updated fields include: status = REVERT_CONFLICT_SOLVED, revert_commit_id = the commit Id rolled back for fast_quit_commit_id, gmt_modified = now(); if there is no conflict in revert, the commit Id of this revert action is directly updated to the data store, and the status is updated to REVERT_SUCCESS. The specific updated fields include: status = REVERT_SUCCESS, revert_commit_id = the commit rolled back for fast_quit_commit_id Id,gmt_modified=now().

[0183] The field contents of Case 1 and Case 2 above are for illustrative purposes only and shall be determined based on actual circumstances.

[0184] In the embodiment of the present invention, the underlying principle of exiting and stripping the integrated area branch is achieved by comparing and reversely submitting the code branches through the code version control tool git; on the basis of using the code version control tool, combined with the R&D delivery platform, the processing flow of rapid exit and re-merge is made into a productized solution, and the user does not need to be aware of the underlying complex principles, nor does he need to maintain the relevant information by himself, and can be used directly on the R&D delivery platform. The underlying principle of stripping the branch code and reintegrating the branch is encapsulated in the operation process of the integrated area of ​​the R&D delivery platform, and the user does not need to understand the complex technical details and can operate on a white screen; the R&D delivery platform is responsible for operating the underlying code version control tool git, and is responsible for maintaining relevant operation records, the series connection of the overall link, etc.

[0185] Regarding the phase of stripping the branch to be exited, the principle is to remove the code of the branch to be exited from the integration branch, rather than re-creating a new integration branch and re-merging it. Through the above design, the conflict resolution between the remaining branches in the integration area is transferred to the conflict resolution between the branch to be exited and other branches. The number of conflict resolutions is reduced from the order of magnitude 0 (n) to the order of magnitude 0 (1), that is, the number of conflicts that originally need to be resolved is the order of magnitude of the number of branches in the integration area, and now only one revert conflict that may occur when resubmitting the feature branch needs to be resolved.

[0186] For the reintegration and exit branch stage, the R&D delivery platform can realize operation query and historical tracing by reading the quick exit branch records. After multiple deployments, continuous exit branches, and continuous reintegration, it can still correctly find relevant records and execute the corresponding revert operations.

[0187] In the embodiment of the present invention, the conflicts additionally generated by the exit branch operation processing are reduced, and the research and development efficiency is improved; and the collaboration of developers is reduced, saving labor costs.

[0188] In an embodiment of the invention, a device for quickly exiting an integrated area of ​​a characteristic branch under a branch model is provided, such as Fig.16As shown, it specifically includes: a receiving unit 1601, an acquisition unit 1602, an updating unit 16303 and a confirmation unit 1604; wherein the receiving unit 1601 is used to receive a target feature branch quick exit instruction, wherein the quick exit instruction carries the number of the target feature branch; the acquisition unit 1602 is used to obtain the code change content of the integration branch when the target feature branch is merged into the integration branch where it is located according to the number of the target feature branch; the updating unit 1603 is used to determine the updated code content of the integration branch after the target feature branch exits the integration branch according to the code change content; the receiving unit 1601 is also used to receive a confirmation exit instruction, and the confirmation unit 1604 is used for the target feature branch to quickly exit the integration branch according to the confirmation exit instruction.

[0189] Furthermore, the updating unit is specifically used for:

[0190] Determine the code negation content of the code change content, wherein the code negation content is the opposite content of the code change content;

[0191] The inverted code content is merged into the current code content of the integration branch to generate updated code content of the integration branch.

[0192] Furthermore, the device also includes:

[0193] The detection unit is used to determine whether the target feature branch meets the rules for quickly exiting the integration branch.

[0194] Furthermore, the device also includes:

[0195] The display unit is used to display the current code content of the integration branch and the updated code content of the integration branch.

[0196] Furthermore, the display unit is also used for:

[0197] After the target feature branch quickly exits the integration branch, the content of the integration area corresponding to the integration branch is displayed, wherein the integration area includes at least one feature branch merged into the integration branch.

[0198] Furthermore, the receiving unit is also used for:

[0199] Receiving the target feature branch rejoining instruction, wherein the target feature branch is a feature branch that has quickly exited the integration branch, and the rejoining instruction carries the encoding of the target feature branch;

[0200] The device also includes:

[0201] A determination unit, configured to determine, according to the encoding of the target feature branch, a version number of the integration branch where the target feature branch is located when the target feature branch is quickly exited from the integration branch;

[0202] The determining unit is further used to: determine the target code content of the integration branch according to the version number of the integration branch;

[0203] The updating unit is further used for restoring the current code content of the integration branch to the target code content.

[0204] Furthermore, the device also includes:

[0205] A merging unit is used to merge the target feature branch back into the integration branch.

[0206] Furthermore, the display unit is also used for:

[0207] In response to a conflict existing after restoring the current code content of the integration branch to the target code content, displaying the conflicting content of the integration branch;

[0208] The receiving unit is further used for: receiving a conflict resolution instruction.

[0209] Furthermore, the display unit is also used for:

[0210] Display the content of the integration area corresponding to the integration branch after the target feature branch is rejoined to the integration branch.

[0211] Fig.17 Schematic diagram of the structure of the electronic device in the embodiment of the present invention. Fig.17 As shown, it includes a general computer hardware structure, which at least includes a processor 1701 and a memory 1702. The processor 1701 and the memory 1702 are connected via a bus 1703. The memory 1702 is suitable for storing instructions or programs executable by the processor 1701. The processor 1701 can be an independent microprocessor or a collection of one or more microprocessors. Thus, the processor 1701 executes the instructions stored in the memory 1702, thereby executing the method flow of the embodiment of the present invention as described above to realize the processing of data and the control of other devices. The bus 1703 connects the above-mentioned multiple components together, and at the same time connects the above-mentioned components to the display controller 1704 and the display device and the input / output (I / O) device 1705. The input / output (I / O) device 1705 can be a mouse, a keyboard, a modem, a network interface, a touch input device, a somatosensory input device, a printer, and other devices known in the art. Typically, the input / output device 1705 is connected to the system through an input / output (I / O) controller 1706.

[0212] Among them, the instructions stored in the memory 1702 are executed by at least one processor 1701 to achieve: receiving a target feature branch quick exit instruction, wherein the quick exit instruction carries the number of the target feature branch; according to the number of the target feature branch, obtaining the code change content of the integration branch when the target feature branch is merged into the integration branch to which it is located; determining the updated code content of the integration branch after the target feature branch exits the integration branch according to the code change content; receiving a confirmation exit instruction; according to the confirmation exit instruction, the target feature branch quickly exits the integration branch.

[0213] Specifically, the electronic device includes: one or more processors 1701 and a memory 1702, Fig.17 Take a processor 1701 as an example. The processor 1701 and the memory 1702 may be connected via a bus or other means. Fig.17 In the example, the bus connection is used. The memory 1702 is a non-volatile computer-readable storage medium that can be used to store non-volatile software programs, non-volatile computer executable programs and modules. The processor 1701 executes various functional applications and data processing of the device by running the non-volatile software programs, instructions and modules stored in the memory 1702, that is, the method for quickly exiting the integrated area of ​​the feature branch under the above-mentioned determination branch model is realized.

[0214] The memory 1702 may include a program storage area and a data storage area, wherein the program storage area may store an operating system and applications required for at least one function; the data storage area may store a list of options, etc. In addition, the memory 1702 may include a high-speed random access memory, and may also include a non-volatile memory, such as at least one disk storage device, a flash memory device, or other non-volatile solid-state storage device. In some embodiments, the memory 1702 may optionally include a memory remotely arranged relative to the processor 1701, and these remote memories may be connected to an external device via a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

[0215] One or more modules are stored in the memory 1702, and when executed by one or more processors 1701, the method for quickly exiting the integrated area of ​​a feature branch under a branch model in any of the above method embodiments is executed.

[0216] As will be appreciated by those skilled in the art, various aspects of the embodiments of the present invention may be implemented as a system, method or computer program product. Therefore, various aspects of the embodiments of the present invention may take the form of a complete hardware implementation, a complete software implementation (including firmware, resident software, microcode, etc.), or an implementation that combines software aspects with hardware aspects, which may generally be referred to herein as a "circuit," "module," or "system." In addition, various aspects of the embodiments of the present invention may take the form of a computer program product implemented in one or more computer-readable media having a computer-readable program code implemented thereon.

[0217] Any combination of one or more computer-readable media can be utilized. Computer-readable media can be computer-readable signal media or computer-readable storage media. Computer-readable storage media can be, for example, (but not limited to) electronic, magnetic, optical, electromagnetic, infrared or semiconductor systems, devices or apparatuses, or any suitable combination of the foregoing. More specific examples (non-exhaustive enumeration) of computer-readable storage media will include the following: an electrical connection with one or more wires, a portable computer floppy disk, 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 disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of an embodiment of the present invention, a computer-readable storage medium can be any tangible medium that can contain or store a program used by an instruction execution system, device or apparatus or a program used in conjunction with an instruction execution system, device or apparatus.

[0218] A computer readable signal medium may include a propagated digital signal having a computer readable program code implemented therein, such as in baseband or as part of a carrier wave. Such propagated signals may take any of a variety of forms, including but not limited to electromagnetic, optical, or any suitable combination thereof. A computer readable signal medium may be any of the following computer readable media: not a computer readable storage medium, and may communicate, propagate, or transmit a program used by or in conjunction with an instruction execution system, device, or apparatus.

[0219] Program code embodied on a computer readable medium may be transmitted using any appropriate medium including, but not limited to, wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

[0220] The computer program code for performing operations for various aspects of the embodiments of the present invention can be written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Java, Smalltalk, C++, etc., and conventional process programming languages ​​such as "C" programming language or similar programming languages. The program code can be executed completely on the user's computer, partially on the user's computer as a stand-alone software package; partially on the user's computer and partially on a remote computer; or completely on a remote computer or server. In the latter case, the remote computer can be connected to the user's computer through any type of network including a local area network (LAN) or a wide area network (WAN), or can be connected to an external computer (e.g., by using the Internet of an Internet service provider).

[0221] The flowchart legend and / or block diagram of the method, device (system) and computer program product according to the embodiment of the present invention described above describe various aspects of the embodiment of the present invention.It will be understood that each block of the flowchart legend and / or block diagram and the combination of the blocks in the flowchart legend and / or block diagram can be implemented by computer program instructions.These computer program instructions can be provided to the processor of a general-purpose computer, a special-purpose computer or other programmable data processing device to produce a machine so that the instructions (executed by the processor of the computer or other programmable data processing device) create a device for implementing the function / action specified in the flowchart and / or block diagram block or block.

[0222] These computer program instructions may also be stored in a computer-readable medium that can direct a computer, other programmable data processing device, or other apparatus to operate in a particular manner, so that the instructions stored in the computer-readable medium produce an article of manufacture including instructions for implementing the functions / actions specified in the flowchart and / or block diagram blocks or blocks.

[0223] The computer program instructions may also be loaded onto a computer, other programmable data processing device or other apparatus so that a series of operable steps are performed on the computer, other programmable device or other apparatus to produce a computer-implemented process, so that the instructions executed on the computer or other programmable device provide a process for implementing the functions / actions specified in the flowchart and / or block diagram block or blocks.

[0224] The above description is only a preferred embodiment of the present application and is not intended to limit the present application. For those skilled in the art, the present application may have various modifications and variations. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application shall be included in the protection scope of the present application.

[0225] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of relevant data must comply with the relevant laws, regulations and standards of relevant countries and regions, and provide corresponding operation portals for users to choose to authorize or refuse. Users' refusal to process personal information other than the necessary information required for basic functions will not affect the user's use of basic functions.

Claims

1. A method for quickly exiting an integrated area for a feature branch under a branch model, characterized in that: The method comprises: Receiving a target feature branch quick exit instruction, wherein the quick exit instruction carries the number of the target feature branch; According to the number of the target feature branch, obtain the code change content of the integration branch when the target feature branch is merged into the integration branch where the target feature branch is located; Determine, according to the code change content, the updated code content of the integration branch after the target feature branch exits the integration branch; Receive confirmation exit instruction; According to the confirmed exit instruction, the target feature branch quickly exits the integration branch.

2. The method according to claim 1, characterized in that The determining, according to the code change content, the updated code content of the integration branch after the target feature branch exits the integration branch specifically includes: Determine the code negation content of the code change content, wherein the code negation content is the opposite content of the code change content; The inverted code content is merged into the current code content of the integration branch to generate updated code content of the integration branch.

3. The method according to claim 1, characterized in that The method further comprises: Determine whether the target feature branch meets the rules for quickly exiting the integration branch.

4. The method according to claim 1, characterized in that The method further comprises: The current code content of the integration branch and the updated code content of the integration branch are displayed.

5. The method according to claim 1, characterized in that The method further comprises: After the target feature branch quickly exits the integration branch, the content of the integration area corresponding to the integration branch is displayed, wherein the integration area includes at least one feature branch merged into the integration branch.

6. The method according to claim 1, characterized in that The method further comprises: Receiving the target feature branch rejoining instruction, wherein the target feature branch is a feature branch that has quickly exited the integration branch, and the rejoining instruction carries the encoding of the target feature branch; Determine, according to the encoding of the target feature branch, the version number of the integration branch where the target feature branch is located when the integration branch is quickly exited; Determining the object code content of the integration branch according to the version number of the integration branch; The current code content of the integration branch is restored to the target code content.

7. The method according to claim 6, characterized in that The method further comprises: Merge the target feature branch back into the integration branch.

8. The method according to claim 6, characterized in that The method further comprises: In response to a conflict existing after restoring the current code content of the integration branch to the target code content, displaying the conflicting content of the integration branch; Conflict resolution instructions received.

9. The method according to claim 6, characterized in that The method further comprises: Display the content of the integration area corresponding to the integration branch after the target feature branch is rejoined to the integration branch.

10. A device for quickly exiting an integrated area of ​​a characteristic branch under a branch model, characterized in that: The device comprises: A receiving unit, configured to receive a target feature branch quick exit instruction, wherein the quick exit instruction carries the number of the target feature branch; An acquisition unit, configured to acquire, according to the number of the target feature branch, the code change content of the integration branch when the target feature branch is merged into the integration branch to which it belongs; An updating unit, configured to determine, according to the code change content, the updated code content of the integration branch after the target feature branch exits the integration branch; The receiving unit is further used for receiving a confirmation exit instruction; A confirmation unit is used to enable the target feature branch to quickly exit the integration branch according to the confirmation exit instruction.

11. An electronic device comprising a memory and a processor, characterized in that: The memory is used to store one or more computer program instructions, wherein the one or more computer program instructions are executed by the processor to implement the method according to any one of claims 1 to 9.

12. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores a computer program, and when the computer program is executed by a processor, the method according to any one of claims 1 to 9 is implemented.

Images