Target service node determination method, electronic equipment, storage medium and product

Abstract

The embodiment of the invention provides a target business node determination method, electronic equipment, a storage medium and a product, and the method comprises the steps: obtaining a logic expression corresponding to a business process, the logic expression comprises a plurality of expression items, and each expression item corresponds to at least one business node; under the condition that the overall processing result of the business process does not meet the first preset value, according to the local processing result corresponding to each expression item, determining a target expression item of which the local processing result does not meet a second preset value; and determining a target service node according to the target expression item. The target service node determination method provided by the embodiment of the invention aims to accurately and efficiently identify the target service node causing the failure of the service process.

Description

Technical Field

[0001] This application relates to the field of data analysis technology, and in particular to a method for determining target business nodes, electronic devices, storage media, and products. Background Technology

[0002] In many business scenarios involving complex systems and applications, business rules, validation conditions, and decision-making processes are typically translated into logical expressions for definition and evaluation. Examples include enterprise process management, automated testing, and data validation. The correctness of these logical expressions is crucial for the proper functioning of the system.

[0003] In related technologies, when analyzing logical expressions to determine the cause of failure in the corresponding business process, the common approach is to execute all branches of the business process in parallel, returning the results and all failed nodes. However, this method only provides a set containing all failed nodes, but cannot identify which nodes are the key nodes causing the overall business process failure. How to accurately and efficiently identify the target business nodes causing business process failure is a problem that urgently needs to be discussed and solved. Summary of the Invention

[0004] This application provides a method, electronic device, storage medium, and product for determining target business nodes, which are designed to accurately and efficiently identify target business nodes that cause business processes to fail.

[0005] In a first aspect, embodiments of this application provide a method for determining a target business node. The method includes: obtaining a logical expression corresponding to a business process, wherein the logical expression includes multiple expression items, each expression item corresponding to at least one business node; when the overall processing result of the business process does not meet a first preset value, determining a target expression item whose local processing result does not meet a second preset value based on the local processing result corresponding to each expression item; and determining a target business node based on the target expression item.

[0006] In a second aspect, embodiments of this application provide an electronic device, including: at least one processor; at least one memory for storing at least one program; and when at least one of the programs is executed by at least one of the processors, implementing the target service node determination method as described in the first aspect.

[0007] Thirdly, embodiments of this application provide a computer-readable storage medium, characterized in that the computer-readable storage medium stores computer-executable instructions, which are used to execute the target service node determination method as described in the first aspect.

[0008] Fourthly, embodiments of this application provide a computer program product, including a computer program or computer instructions, characterized in that the computer program or computer instructions are stored in a computer-readable storage medium, a processor of a computer device reads the computer program or computer instructions from the computer-readable storage medium, and the processor executes the computer program or computer instructions, causing the computer device to perform the target service node determination method as described in the first aspect.

[0009] In this embodiment, the business process is converted into a corresponding logical expression. By analyzing the local processing results of each expression item in the logical expression, target expression items whose local processing results do not meet the requirements are identified. Finally, the corresponding target business nodes are determined based on the target expression items. By decomposing the logical expression into each expression item and analyzing them separately, only target expression items whose local processing results do not meet the requirements are processed to determine the target business nodes. Expression items whose local processing results meet the requirements are skipped without processing. This saves time in the overall process of analyzing the logical expression and ensures that the final extracted target business nodes are all key factors affecting the overall result.

[0010] Other features and advantages of this application will be set forth in the description which follows, and will be apparent in part from the description, or may be learned by practicing the application. The objectives and other advantages of this application may be realized and obtained by means of the structures particularly pointed out in the description, claims and drawings. Attached Figure Description

[0011] Figure 1 A system architecture diagram illustrating a target service node determination method provided in an embodiment of this application;

[0012] Figure 2 A schematic diagram of an enterprise approval process provided as an example for this application;

[0013] Figure 3 A flowchart illustrating a method for determining a target service node according to an embodiment of this application;

[0014] Figure 4 A schematic diagram illustrating the process of identifying target representations as an example of this application;

[0015] Figure 5 A flowchart illustrating the splitting of the first candidate expression term as an example provided in this application;

[0016] Figure 6 This is a flowchart illustrating the verification process for a PCB design application document, provided as an example in this application.

[0017] Figure 7A schematic diagram of the structure of a target service node determination device provided in an embodiment of this application;

[0018] Figure 8 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Detailed Implementation

[0019] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0020] It should be noted that although functional modules are divided in the device schematic diagram and a logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in a different order than the module division in the device or the order in the flowchart. The terms "first," "second," etc., in the specification, claims, and the aforementioned drawings are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence.

[0021] In the description of the embodiments of this application, unless otherwise expressly limited, terms such as setting, installing, and connecting should be interpreted broadly, and those skilled in the art can reasonably determine the specific meaning of the above terms in the embodiments of this application in combination with the specific content of the technical solution.

[0022] In this application, the terms "furthermore," "exemplarily," or "optionally" are used as examples, illustrations, or descriptions and should not be construed as being more preferred or advantageous than other embodiments or designs. The use of terms such as "furthermore," "exemplarily," or "optionally" is intended to present the relevant concepts in a specific manner.

[0023] In related technologies, logical expressions are used to define and evaluate business rules, verify conditions, and make decisions in many business scenarios involving complex systems and applications, such as in enterprise process management, automated testing, and data validation. Therefore, the correctness of logical expressions is crucial for the normal operation of business systems. Typically, these logical expressions consist of multiple sub-conditions and logical operators to ensure that data or processes conform to preset standards. However, in complex scenarios, when the final result of a logical expression is false, determining which specific conditions or process nodes caused the failure is often a complex and time-consuming process. Conventional analysis methods mainly fall into two categories: Method 1, merging all branches of the business process, serializing all processes, executing them one by one, and returning upon encountering a failure; Method 2, executing all process branches in parallel, returning the results and all failure nodes. Method 1 is inefficient, while Method 2 often only provides a list of all failed items, failing to clearly identify the specific failure path or critical node, resulting in inefficient localization. How to accurately and efficiently identify the target business node causing the business process failure is a problem that urgently needs to be discussed and solved.

[0024] To address the aforementioned issues, this application provides a method, electronic device, storage medium, and product for determining target business nodes. The method converts a business process into a corresponding logical expression. By analyzing the local processing results of each term in the logical expression, target terms whose local processing results do not meet the requirements are identified. Finally, the corresponding target business nodes are determined based on these target terms. By decomposing the logical expression into its individual terms for analysis, only target terms whose local processing results do not meet the requirements are processed to determine the target business nodes. Terminators whose local processing results meet the requirements are skipped, thus saving time on the overall logical expression analysis process and ensuring that the final extracted target business nodes are all key factors influencing the overall result.

[0025] In this embodiment, the logical expression is further analyzed by decomposing and analyzing its contents layer by layer. Only expressions or sub-expressions at the current level that fail (do not meet the second preset value) are further analyzed and decomposed. Since expressions or sub-expressions at the current level that succeed will not be the key factor causing the overall result to fail, even if they contain sub-expressions at the next level that fail, they will not be the key factor causing the overall result to fail. However, when an expression or sub-expression at the current level fails, all sub-expressions at the next level that fail are the cause of the failure of the expression or sub-expression at the current level. Therefore, by skipping expressions or sub-expressions that succeed and only analyzing those that fail, the analysis process can be streamlined, and the final extracted target business nodes are all key factors affecting the overall result.

[0026] The embodiments of this application will be further described below with reference to the accompanying drawings.

[0027] Figure 1 This is a system architecture diagram of the target service node determination method according to an embodiment of this application. It includes a server 110, an internet connection 120, and a terminal 130, etc.

[0028] Server 110 refers to a computer system capable of identifying target business nodes. For example, it can convert the business process from terminal 130 into a logical expression for analysis and identification to determine and output the target business node that causes the overall business process to fail. Compared to terminal 130, server 110 has higher requirements in terms of stability, security, and performance. Server 110 can be a single high-performance computer in a network platform, a cluster of multiple high-performance computers, a portion of a single high-performance computer (e.g., a virtual machine), or a combination of portions of multiple high-performance computers (e.g., virtual machines). Server 110 can also communicate with the Internet 120 via wired or wireless means to exchange data.

[0029] Terminal 130 is a device that displays the results of target business node determination to the target user, or provides an operation interface for the target user to input, select, or upload business processes that need to be analyzed. It includes various forms such as desktop computers, laptops, PDAs (Personal Digital Assistants), mobile phones, vehicle terminals, home theater terminals, and dedicated terminals. Furthermore, it can be a single device or a collection of multiple devices. For example, multiple devices can be connected via a local area network, sharing a single display device to work collaboratively, forming a single terminal. The terminal can also communicate with the Internet 120 via wired or wireless means to exchange data.

[0030] In other embodiments, the target service node determination method can also be executed jointly by multiple servers 110, or by one or more terminals 130, or jointly by servers 110 and terminals 130.

[0031] The embodiments of this application can be applied in various scenarios, such as Figure 2 The enterprise approval process is shown below. Figure 2 As shown, assume the company's approval process includes business nodes A, B1, B2, B3, and C; where approval is granted at any one of business nodes B1, B2, or B3. Converting this process into a logical expression yields the following expression: A&&(B1||B2||B3)&&C.

[0032] Assuming that the results of A, B1, and B2 are all true, and the results of B3 and C are all false, the overall result of the logical expression is false, meaning that the overall processing result of the business process does not meet the first preset value.

[0033] First, we analyze the first-level expressions, which include: A, (B1||B2||B3), and C. Correspondingly, the local processing result of expression A is true, the local processing result of expression (B1||B2||B3) is true, and the local processing result of expression C is false. Therefore, we determine that the local processing result of expression C does not meet the second preset value. Since expression C does not contain any sub-expressions at the next level, we determine expression C as the target expression. Finally, based on the target expression (expression C), we determine the target business node as business node C. That is, business node C is the key influencing factor causing the overall processing result of the business process to fail (not meeting the first preset value).

[0034] Although the result of B3 is false, since the local processing result of expression (B1||B2||B3) is true as long as any one of B1, B2, or B3 is true, the false result of B3 alone does not cause the overall logical expression to be false. Therefore, in the analysis of the above expressions, because the local processing result of expression (B1||B2||B3) is true, further analysis of sub-expressions B1, B2, and B3 is skipped, excluding the non-critical influencing factor business node B3.

[0035] As can be seen, in this example's analysis of the enterprise approval business process, after converting the business process into a corresponding logical expression, the local processing results of each expression item in the logical expression are analyzed to identify target expression items whose local processing results do not meet the requirements. Finally, the corresponding target business nodes are determined based on these target expression items. By decomposing the logical expression into each expression item and analyzing them separately, only target expression items whose local processing results do not meet the requirements are processed to determine the target business nodes, while expression items whose local processing results meet the requirements are skipped. This saves time in the overall process of analyzing the logical expression and ensures that the final extracted target business nodes are all key factors affecting the overall result.

[0036] It should be understood that the above description only illustrates some application scenarios of this application. The business scenarios to which this application can be applied may include, but are not limited to, the specific embodiments described above.

[0037] Figure 3 A flowchart illustrating a target service node determination method provided in an embodiment of this application. This target service node determination method can be applied, but is not limited to, to computer devices, servers, etc. Figure 1 The server 110, terminal 130, etc., are shown. Figure 3 As shown, the method for determining the target service node includes, but is not limited to:

[0038] Step 310: Obtain the logical expression corresponding to the business process. The logical expression includes multiple expression items, and each expression item corresponds to at least one business node.

[0039] Step 320: If the overall processing result of the business process does not meet the first preset value, determine the target expression item whose local processing result does not meet the second preset value based on the local processing result corresponding to each expression item.

[0040] Step 330: Determine the target business node based on the target expression item.

[0041] In step 310, a business process refers to the process of business matters that require target business node analysis. Examples include enterprise approval processes, feasibility analysis of certain program code, and intelligent production lines in a factory. Then, using the target business node determination method of this application, the key influencing factors leading to the overall failure of the business process are identified, i.e., the business nodes that actually cause the business process to fail. A business node refers to a node that constitutes a business process.

[0042] A logical expression is an expression that represents the overall business process by converting each business node or branch into a relational expression or logical variable, and then connecting them using logical operators. After converting the business process into a corresponding logical expression, the overall processing result of the business process can be determined by calculating the result of the logical expression. If the result of the logical expression is false, the overall processing result of the corresponding business process is failure; if the result of the logical expression is true, the overall processing result of the corresponding business process is success.

[0043] An expression term refers to a sub-expression that makes up a logical expression. An expression term can correspond to a single business node, a branch of a business process composed of multiple business nodes, or a set of multiple related branches. When an expression term corresponds to a branch of a business process composed of multiple business nodes, or a set of multiple related branches, an expression term can further contain multiple sub-expressions at the next lower level. If the logical expression is considered as a top-level expression term, then the expression terms contained within the logical expression can be regarded as sub-expression terms of this top-level expression term.

[0044] For example, take the logical expression A&&(B1||B2||B3)&&C as an example, which includes the expression terms A, (B1||B2||B3) and C, and the expression term (B1||B2||B3) can be further decomposed into the next level of expression terms B1, B2 and B3.

[0045] In step 320, the first preset value refers to a pre-set value used to characterize the overall processing result as successful. For example, the first preset value can be set to 1, corresponding to the logical expression's calculation result being "true," and if the first preset value is not met, it is "false." When the business process is converted into a logical expression, if the calculated value is 1, it indicates that the overall processing result of the business process is successful. If the calculated value is 0, i.e., the first preset value is not met, it indicates that the overall processing result of the business process is unsuccessful.

[0046] The second preset value refers to a pre-set value used to characterize a successful local processing result. For example, the second preset value can be set to 1, corresponding to the calculation result of the expression item being "true". If the second preset value is not met, it is "false". After obtaining each expression item of the logical expression, if the calculated value of a certain expression item is 0, that is, the expression item does not meet the second preset value, that is, the result of the expression item is "false", and the local processing result of its corresponding business node or process branch is failure.

[0047] In step 330, the target expression term refers to the expression term obtained from the analysis that actually causes the result of its corresponding logical expression to be "false". The target business node refers to the business node corresponding to the target expression term, that is, the key influencing factor that actually causes the overall processing result of the business process to fail. Through the target business node, the cause of the business process failure can be determined.

[0048] In steps 310 to 330 above, the business process is converted into a corresponding logical expression. By analyzing the local processing results of each expression item in the logical expression, target expression items whose local processing results do not meet the requirements are identified. Finally, the corresponding target business nodes are determined based on the target expression items. By decomposing the logical expression into each expression item and analyzing them separately, only target expression items whose local processing results do not meet the requirements are processed to determine the target business nodes. Expression items whose local processing results meet the requirements are skipped without processing. This saves time in the overall process of analyzing the logical expression and ensures that the target business nodes extracted are all key factors affecting the overall result.

[0049] The above is a general description of steps 310 to 330. The following is a detailed description of the specific implementation process of steps 310 to 330.

[0050] In one embodiment, step 320 includes:

[0051] Based on the local processing results corresponding to each expression term, determine the first candidate expression term whose local processing result does not meet the second preset value;

[0052] If the first candidate expression does not contain any sub-expressions, the first candidate expression is determined as the target expression, wherein the sub-expression corresponds to at least one business node.

[0053] In this embodiment, the first candidate expression term refers to the expression term whose result is "false" among the multiple expression terms currently analyzed.

[0054] A sub-expression is a sub-expression that makes up an expression. A sub-expression can correspond to a single business node, a branch of a business process composed of multiple business nodes, or a set of multiple related branches. When a sub-expression corresponds to a branch of a business process composed of multiple business nodes, or a set of multiple related branches, a sub-expression can further contain multiple sub-expressions at the next lower level.

[0055] It should be noted that in the embodiments of this application, a one-level split refers to extracting only the sub-expressions of the next level of the current expression or logical expression. For example, taking A&&(B1||B2||B3)&&C as an example, after a one-level split, the expression items are A, (B1||B2||B3), and C. Then, after a one-level split of B1||B2||B3, the expression items are B1, B2, and B3. In the above example, A&&(B1||B2||B3)&&C is a logical expression, A, (B1||B2||B3), and C are the expression items of the logical expression, and B1, B2, and B3 are the sub-expressions of the expression item B1||B2||B3.

[0056] The first candidate expression not containing sub-expressions means that the first candidate expression is already the smallest level of expression and cannot be further broken down. By identifying the characters in the first candidate expression, if the first candidate expression does not contain parentheses or logical operators, it means that the first candidate expression does not contain sub-expressions.

[0057] If the first candidate expression is already the smallest level expression and its result is "false", then it means that the first candidate expression is one of the key influencing factors that cause the result of the logical expression to be "false".

[0058] In the above embodiments, expressions whose local processing results do not meet the requirements are designated as first candidate expressions. Only the first candidate expressions are processed to determine the target expression, while expressions whose local processing results meet the requirements are skipped without further processing. This saves time in the expression analysis process and improves the efficiency of identifying the target business node.

[0059] In one embodiment, step 320 further includes:

[0060] Step 321: Based on the local processing results corresponding to each expression item, determine the first candidate expression item whose local processing result does not meet the second preset value;

[0061] Step 322: If the first candidate expression item contains sub-expression items, determine the second candidate expression item whose sub-processing result does not meet the second preset value from each sub-expression item based on the sub-processing result of each sub-expression item in the first candidate expression item containing sub-expression items.

[0062] Step 323: Determine the target expression term based on the second candidate expression term.

[0063] In this embodiment, "the first candidate expression includes sub-expressions" means that the first candidate expression includes multiple sub-expressions that can be further decomposed. By recognizing the characters in the first candidate expression, if the first candidate expression contains parentheses or logical operators, it indicates that the first candidate expression contains sub-expressions.

[0064] If the local processing result of the first candidate expression is "false" and it contains sub-expressions, it means that the first candidate expression is not a key influencing factor that directly causes the logical expression result to be "false". Further analysis of the sub-expressions contained in the first candidate expression is needed to determine the smallest level sub-expression that actually directly causes the logical expression result to be "false".

[0065] Sub-processing result refers to the calculation result of the sub-expression. The second candidate expression refers to the expression that is "false" among the multiple sub-expressions obtained after splitting the first candidate expression by one level.

[0066] Determining the target expression based on the second candidate expression means analyzing and judging the second candidate expression to determine the smallest level expression that directly leads to the logical expression result being "false".

[0067] If the second candidate expression does not contain any sub-expressions, it means that the second candidate expression is already at the lowest level and is the expression that actually directly causes the logical expression result to be "false", which is the target expression.

[0068] If a second candidate expression contains a sub-expression, it indicates that the second candidate expression is not a key factor directly causing the logical expression result to be "false," and further analysis of the sub-expressions contained in the second candidate expression is required. These second candidate expressions containing sub-expressions are then used as new first candidate expressions, and steps 322 and 323 are executed recursively until all second candidate expressions obtained from the first candidate expressions do not contain sub-expressions.

[0069] In the above embodiments, recursive processing of the second candidate expression item containing sub-expression items ensures that the obtained target expression item is the smallest level expression item, thereby guaranteeing the accuracy of the target business node determined based on the target expression item. Furthermore, only expression items whose sub-processing results do not meet the second preset value (resulting in "false") are treated as second candidate expression items for subsequent processing. The remaining expression items with results of "true" are skipped without further sub-expression item decomposition and analysis. This dynamically determines whether to continue recursively delving into smaller sub-expression items, avoiding unnecessary recursive operations and ensuring both complete identification of the target expression item and high efficiency of the identification process.

[0070] For example, Figure 4 This is a schematic diagram illustrating the process of identifying target representations as an example of this application. Figure 4 As shown, the specific process for analyzing and identifying the target expression term from the logical expression is as follows:

[0071] Initialize the target expression list, which stores all expressions that cause the logical expression to result in "false".

[0072] Extract a list of expression items from the logical expression. The logical expression is derived from the transformation of the business process that needs to be analyzed. The list of expression items includes each expression item obtained by splitting the logical expression into layers.

[0073] Initialize the analyzed list, which records the expressions that have been analyzed. The analyzed list is empty after initialization.

[0074] Iterate through the list of expressions and analyze each expression in the list.

[0075] If there are unprocessed expressions in the list of expressions, retrieve the currently traversed expression, i.e., the current expression.

[0076] If the current expression is already in the analyzed list, skip the current expression to avoid duplicate analysis.

[0077] If the current expression is not in the parsed list, it is added to the parsed list, indicating that the subexpression has been parsed. The current expression is then executed, the result is calculated, and the result is converted to a Boolean type, i.e., "true" or "false".

[0078] If the result of the current expression is "true", then skip the current expression and do not continue the analysis, and continue to process the next expression.

[0079] If the result of the current expression is "false", then it is determined whether the current expression contains a grouping operator. In various examples or embodiments of this application, the grouping operators include left parentheses "(", right parentheses ")", and logical operators.

[0080] If the current expression does not contain a grouping operator, the current expression is added to the target expression list, and the next expression is processed.

[0081] If the current expression includes a grouping operator, it indicates that there may be nested sub-expressions within it. The target expression lookup process is recursively called to further analyze the sub-expressions within the current expression, continuing to search for sub-expressions that result in a "false" logical expression. The target expression lookup process refers to steps 321 to 323 in the above embodiment. If a sub-expression of the current expression has a result of "false" and includes a grouping operator, the recursion continues downwards. If a sub-expression does not contain a grouping operator, it indicates that it is already the most basic expression and does not require further splitting or recursive analysis. In this case, the sub-expression with a result of "false" is directly added to the target expression list, and the recursion for that path is terminated.

[0082] After iterating through all expressions in the expression list, the target expression list is returned. At this point, the target expression list contains all subexpressions that actually caused the logical expression to evaluate to "false".

[0083] In the above example, the strategy of hierarchical segmentation and recursive positioning is used to accurately identify the target expression. Taking the logical expression A&&(B1||B2||B3)&&C as an example, assuming that B3 and C are both False, in the first step, it is segmented into three sub-expressions [A, B1||B2||B3, C]. The overall B1||B2||B3 is True, which does not satisfy the recursive condition, so this interference term can be directly eliminated.

[0084] In the above example, by adding logic to dynamically adjust the balance between the depth and breadth of the verification, using recursion to ensure that all possibilities are exhausted, and using layering (i.e., checking for the existence of grouping operators) to dynamically decide whether to continue recursively delving into smaller sub-expressions, the efficiency of the recognition process is guaranteed while ensuring complete recognition. For example, for the complex logical expression "((A&&B)||(C&&(D||E)))&&(F||G&&(D||E))&&(H&&!(I||J))", where ABCGI is false and the others are true, it can be determined from the logical operators that the expressions "F||G&&(D||E)" and "H&&!(I||J)" are true. The method of this application can skip the analysis of “F||G&&(D||E)” and “H&&!(I||J)” in the identification process, limit the analysis scope to (A&&B)||(C&&(D||E)), and then continue to recursively evaluate the sub-formula.

[0085] In the example above, by setting an analyzed list to record the expressions that have been analyzed, such as A&&B&&(A||C), where A only needs to be calculated once, not only is performance improved, but also the potential infinite loop problem caused by recursion is prevented, while ensuring the uniqueness and accuracy of the results in the recursive process.

[0086] In one embodiment, determining a second candidate expression term whose sub-processing result does not satisfy a second preset value from among the sub-expression terms based on the sub-processing results of each sub-expression term in a first candidate expression term containing sub-expression terms includes:

[0087] The first candidate expression term containing sub-expression terms is split into multiple sub-expression terms;

[0088] Based on the sub-processing results of each sub-expression item, a second candidate expression item whose sub-processing result does not meet the second preset value is determined from each sub-expression item.

[0089] In this embodiment, splitting the first candidate expression term into multiple sub-expression terms means splitting the first candidate expression term into multiple sub-expression terms by one layer.

[0090] In one embodiment, a first candidate expression term containing sub-expression terms is split into multiple sub-expression terms, including:

[0091] Initialize the split index based on the position of the first character of the first candidate expression;

[0092] Start iterating from the first character of the first candidate expression;

[0093] If the currently traversed character is a logical operator and the parenthesis cache is empty, determine the sub-expression item based on the string between the split index and the currently traversed character, and update the split index to the position after the logical operator. The parenthesis cache is used to store parentheses.

[0094] If the currently traversed character is the outermost opening parenthesis, store the outermost opening parenthesis in the parenthesis cache, determine the sub-expression item based on the string between the split index and the position of the currently traversed character, and update the split index to the position of the currently traversed character;

[0095] If the currently traversed character is a parenthesis other than the outermost opening parenthesis, determine the outermost parenthesis pair corresponding to the parenthesis in the first candidate expression, determine the sub-expression based on the string between the outermost parenthesis pairs, and update the split index to the position after the closing parenthesis of the outermost parenthesis pair.

[0096] In this embodiment, the split index refers to the index used to indicate the split point of the sub-expression item. By setting and updating the split index, a sub-expression item is determined based on the character content between the split index and the currently traversed character position.

[0097] The bracket cache refers to the data space used to store the left brackets "(" that have been traversed. In this embodiment, the bracket cache is a stack structure. It should be noted that in other embodiments, the bracket cache can be other data storage structures, as long as the data storage and retrieval order is "last in first out". When the bracket cache is empty, it means that the currently traversed character is outside the outermost bracket pair of the current level; when the bracket cache is not empty, it means that the currently traversed character is inside the outermost bracket pair of the current level.

[0098] In the embodiments of this application, the current level refers to the level corresponding to the currently processed expression item. For example, taking A&&(B1||B2||B3)&&C as an example, assume that A &&(B1||B2||B3)&&C as a whole is the first level. Decomposing it by one level yields A, (B1||B2||B3), and C, at which point A, (B1||B2||B3), and C all belong to the second level. Decomposing B1||B2||B3 by another level yields B1, B2, and B3, at which point B1, B2, and B3 belong to the third level. If the expression item B1||B2||B3 is currently being decomposed, then the current level is the second level.

[0099] The opening parenthesis is the left parenthesis "(", and the closing parenthesis is the right parenthesis ")". The outermost opening parenthesis is the left parenthesis of the outermost nested parenthesis pair in the expression to be split. There can be multiple outermost opening parentheses, but there is no nesting relationship between the outermost opening parentheses.

[0100] The outermost parenthesis pair refers to the outermost parenthesis pair among multiple nested parenthesis pairs to which the currently traversed parenthesis belongs. If the currently traversed parenthesis is just one parenthesis in a parenthesis pair, and there are no multiple nested parenthesis pairs, then the parenthesis pair to which it belongs is the outermost parenthesis pair.

[0101] The above embodiments, through reasonable algorithm design, ensure accurate parsing of expression terms and can accurately extract sub-expression terms for multi-layered nested parentheses and complex relational expressions.

[0102] In one embodiment, when the currently traversed character is a parenthesis other than the outermost opening parenthesis, the outermost parenthesis pair corresponding to the parenthesis in the first candidate expression item is determined, the sub-expression item is determined based on the string between the outermost parenthesis pairs, and the split index is updated to the position of the closing parenthesis of the outermost parenthesis pair, including:

[0103] If the currently traversed character is a parenthesis, store the parenthesis in the parenthesis cache;

[0104] If the currently traversed character is a closing parenthesis, retrieve a parenthesis from the parenthesis cache. If the retrieved parenthesis cache is empty, determine the sub-expression based on the string between the split index and the position of the currently traversed character, and update the split index to the next position of the currently traversed character.

[0105] In this embodiment, the parenthesis buffer is a stack. The starting parenthesis (left parenthesis) is pushed onto the stack and stored in the buffer. When the closing parenthesis (right parenthesis) is reached, an element is popped from the buffer. When the parenthesis buffer is empty after popping an element from the right parenthesis, it can be determined that the currently traversed right parenthesis is the outermost right parenthesis in a multi-layered nested parenthesis structure. Based on the update method of the split index in various embodiments of this application, it can be determined that when the outermost right parenthesis is reached, the position of the split index should be the position of its corresponding outermost left parenthesis.

[0106] Because the Last-In-First-Out (LIFO) property of a stack aligns with the precedence of nested parentheses, we can match left and right parentheses in multi-level nested parenthesis pairs by pushing left parentheses onto the stack and popping left parentheses when they are encountered. By using an empty stack as the condition for determining if a given is a first-level sub-expression, we ensure that even with multiple levels of nested parentheses, the content of the outermost parenthesis pair can be accurately extracted as a sub-expression, guaranteeing that each split of a logical expression or expression item is performed at only one level.

[0107] In one embodiment, splitting a first candidate expression term containing sub-expression terms into multiple sub-expression terms further includes:

[0108] If the currently traversed character is a quotation mark and the quotation mark identifier is the first value, update the quotation mark identifier to the second value to determine that the quotation mark state has been entered. In the quotation mark state, characters in the logical expression are skipped.

[0109] If the currently traversed character is a quotation mark and the quotation mark identifier is the second value, update the quotation mark identifier to the first value and exit the quotation mark state.

[0110] In this embodiment, the quotation mark identifier is used to indicate whether the currently traversed character is within a pair of quotation marks. The first and second values ​​can be set to a Boolean pair, with the first value set to "false" and the second value set to "true". When the quotation mark identifier is the first value, it indicates that the currently traversed character is not within the quotation mark pair. When the quotation mark identifier is the second value, it indicates that the currently traversed character is within the quotation mark pair. The quotation mark state refers to the fact that the currently traversed character is within a pair of quotation marks. In logical expressions, the content within the quotation mark pair should be treated as a whole; therefore, the characters within the quotation mark pair need to be skipped.

[0111] The above embodiments, through the setting and updating of quotation mark identifiers, can intelligently skip characters within quotation marks, avoiding the mistaken parsing of content within quotation marks as part of a subexpression.

[0112] In one embodiment, splitting a first candidate expression term containing sub-expression terms into multiple sub-expression terms further includes:

[0113] Traverse to the last character of the first candidate expression. If the split index is less than the total length of the first candidate expression, determine the sub-expression based on the string between the split index and the last character of the first candidate expression.

[0114] In this embodiment, the split index is updated accordingly after each extraction of a sub-expression. Therefore, when the last character of the first candidate expression is reached, if the split index is less than the total length of the first candidate expression, it means that there is still content between the split index and the last character. This part of the content is extracted as a sub-expression to ensure the integrity of the split of the first candidate expression.

[0115] It should be noted that the splitting process of the first candidate expression item provided in the above embodiments of this application can also be used for splitting logical expressions. In the initial stage of identifying the target business node in this application, after obtaining the logical expression corresponding to the business process, the logical expression at this time can be regarded as the first candidate expression item.

[0116] For example, Figure 5 This is a flowchart illustrating the process of splitting the first candidate expression term as an example provided in this application.

[0117] like Figure 5 As shown, the expression list is used to store all sub-expressions extracted from the expression.

[0118] Parentheses cache: This is a stack structure used to handle nested parentheses and ensure that nested sub-expressions are correctly identified.

[0119] Split index: Records the starting position of the current sub-expression.

[0120] Quotation mark markers: Used to track whether the content is currently inside quotation marks, ensuring the integrity of the content within the quotation marks. For example, the expression "A=3&&C=="k=4&&kk==8"" should be split into [A=3,C=="k=4&&kk==8"], without splitting the content inside the quotation marks.

[0121] Key character processing includes:

[0122] Quotation marks ("): Used to identify string content; content within the quotation marks is skipped.

[0123] Left parenthesis (()): indicates the starting position of the sub-expression item. The first-in-last-out property of the stack is very suitable for processing multi-level nested items.

[0124] The right parenthesis () indicates the end position of a subexpression. When the stack is empty, it means that a complete subexpression has been identified.

[0125] Logical operators (&&, ||): used to separate logical expressions, identifying the parts on both sides as independent subexpressions. It should be noted that in the embodiments of this application, sub-expression terms and subexpressions are actually the same concept.

[0126] The specific process for splitting the first candidate expression term into multiple sub-expression terms is as follows:

[0127] 1) Initialize variables: Create an empty list of expressions to store the extracted sub-expressions; initialize an empty bracket cache to track bracket matching; initialize the split index to 0, which is used to identify the starting position of the current sub-expression; use a boolean-based quotation mark to indicate whether the currently traversed character is inside quotation marks, which is used to skip string literals.

[0128] 2) Traverse the first candidate expression string: Traverse every character in the first candidate expression string from beginning to end.

[0129] 2.1) Skip content within quotation marks: Initialize the quotation mark flag to "false". If a double quotation mark " is encountered, and the value represented by the quotation mark is toggled, entering the quotation mark content indicates entry into the quotation mark content, while exiting the quotation mark content indicates exiting the quotation mark content indicates exiting from the quotation mark content. All characters inside the quotation marks are skipped and will not be parsed as logical operators or parentheses.

[0130] 3) Processing each character:

[0131] 3.1) If the current character is "(" (left parenthesis) and the parenthesis cache is empty, it means that the left parenthesis encountered at this time is the left parenthesis of the outermost parenthesis pair. Process the content before the left parenthesis and push the index of the left parenthesis into the parenthesis cache, and continue to traverse the next character. Processing the content before the left parenthesis includes: if the split index is less than the current character position i, add the content between the split index and the current character position i to the expression list, and update the split index to the current character position i.

[0132] If the current character is "(" (left parenthesis) and the parenthesis cache is not empty, it means that the left parenthesis encountered at this time is not the left parenthesis of the outermost parenthesis pair. Push the index of the left parenthesis into the parenthesis cache and continue to traverse the next character.

[0133] 3.2) If the current character is “)” (right parenthesis), pop the corresponding left parenthesis from the parenthesis buffer;

[0134] If the parenthesis buffer following the corresponding left parenthesis is not empty, continue iterating to the next character;

[0135] If the parenthesis cache after the corresponding left parenthesis is empty, it means that the right parenthesis currently being traversed is the right parenthesis of the outermost parenthesis pair, and the sub-expressions between the parentheses are processed. Processing the sub-expressions between the parentheses includes: adding the content between the split index and the next position (i+1) of the current character position i as a sub-expression to the expression list, and updating the split index to the next character position (i.e., updating to i+).

[0136] 3.3) If the current character is a logical operator && or || (AND or OR operator), and the parenthesis cache is empty, it means that the character currently being traversed is the logical operator outside the outermost parenthesis. Sub-expression item extraction is required. The sub-expression item before the logical operator is identified, added to the expression item list, and the split index is updated to the position to skip the logical operator, that is, the position of the next character after the logical operator.

[0137] If the parenthesis cache is not empty, it means that the character currently being traversed is the logical operator inside the outermost parenthesis, which is part of the sub-expression and should not be extracted separately. Continue traversing the next character.

[0138] 4) Process the last subexpression:

[0139] After the traversal is complete, check if the split index `start` is less than the total length of the first candidate expression. If so, add the portion after `start` as the last sub-expression to the expression list.

[0140] 5) Remove outermost parentheses: Remove the outermost parentheses from each sub-expression in the expression list to make the sub-expressions more concise.

[0141] 6) Return the processed list of expressions.

[0142] In the above example, by setting up split index, bracket caching, and quotation mark identification, and based on the processing strategy for each traversed character provided in the example, the accurate parsing of the expression is ensured, and situations that may cause parsing difficulties, such as nested brackets and logical operators, are handled. This ensures that even with multiple levels of nested brackets and quotation marks, the sub-expression items can still be accurately extracted.

[0143] The following example provides a comprehensive and detailed description of the method for determining the target business process node in this application. It is understood that the following embodiments are merely illustrative examples to better illustrate the method for determining the target business process node in this application and are not intended to be specific or limiting.

[0144] In one example, within a hardware development scenario, the process of submitting a Printed Circuit Board (PCB) design request involves a series of verifications to ensure the request meets predefined conditions. The verification conditions for the submitted PCB design request documents include:

[0145] The document type must be "PCB Design Request";

[0146] All associated deliverables must be in check-in status and their versions must be up-to-date;

[0147] When the document status is "Confirmed and Verified", the associated outline drawing must be "Structural Design Completed";

[0148] When the document status is "process drafting", the PCB component code must exist, and the circuit schematic status must be "baselined" or "archived".

[0149] If the document status is any other value, no validation is required.

[0150] Convert the above verification conditions into a logical expression: (docType == 'PCB Design Application')&&(allDeliverablesCheckedIn&&deliverablesVersionLatest)&&(docStatus != 'Verification Confirmed'||associatedOutlineDrawing == 'Structural Design Completed')&&(docStatus != 'Process Drafting'||(pcbPartCode != null&&(circuitDiagramStatus == 'Baselined'||circuitDiagramStatus == 'Archived'))).

[0151] Assume the current variable value is as follows:

[0152] env.put("docType","PCB design application");

[0153] env.put("allDeliverablesCheckedIn",true);

[0154] env.put("deliverablesVersionLatest",true);

[0155] env.put("docStatus","Process formulation");

[0156] env.put("associatedOutlineDrawing","Design incomplete");

[0157] env.put("pcbPartCode",null);

[0158] `env.put("circuitDiagramStatus","Archived")`. Here, `env.put()` is used to set or update variable values.

[0159] Figure 6 The following is a flowchart illustrating the verification process for a PCB design application document, provided as an example in this application:

[0160] Input the logical expression obtained from the business process verification transformation: (docType == 'PCB Design Application')&&(allDeliverablesCheckedIn&&deliverablesVersionLatest)&&(docStatus != 'Confirmed Verification'||associatedOutlineDrawing == 'Structural Design Completed')&&(docStatus != 'Process Drafting'||(pcbPartCode != null&&(circuitDiagramStatus == 'Baselined'||circuitDiagramStatus == 'Archived'))).

[0161] The logical expression is parsed to extract its sub-expressions. For example... Figure 6 As shown, the list of expressions is: ["docType=='PCB Design Application'", "allDeliverablesCheckedIn&&deliverablesVersionLatest", "docStatus!='Confirmed Verification'||associatedOutlineDrawing=='Structural Design Completed'", "docStatus!='Process Drafting'||(pcbPartCode!=null&&(circuitDiagramStatus=='Baselined'||circuitDiagramStatus=='Archived'))"].

[0162] Calculate the result of each subexpression: Perform a Boolean value calculation on each subexpression:

[0163] The result of docType=='PCB Design Request' is true;

[0164] allDeliverablesCheckedIn&&deliverablesVersionLatest result is true;

[0165] docStatus! = 'Confirmed Verification' || associatedOutlineDrawing == 'Structural Design Completed' The result is true;

[0166] The result of docStatus! = 'Process drafting' || (pcbPartCode! = null && (circuitDiagramStatus == 'Baselined' || circuitDiagramStatus == 'Archived')) is false.

[0167] Based on the result of each subexpression, it can be determined that the overall result of the logical expression is false.

[0168] The subexpression that causes the result to be false is: docStatus! = 'Process formulation' || (pcbPartCode! = null && (circuitDiagramStatus == 'Baselined' || circuitDiagramStatus == 'Archived')).

[0169] Further breaking down the subexpression, we get subexpression 1: docStatus! = 'Flowchart', and subexpression 2: pcbPartCode! = null && (circuitDiagramStatus == 'Baselined' || circuitDiagramStatus == 'Archived').

[0170] The results of subexpression 1 and subexpression 2 are both false. Since subexpression 1 does not contain a grouping operator and cannot be further split, docStatus! = 'process formulation' is recorded as the subexpression that results in a false result.

[0171] Since subexpression 2 contains a grouping operator, it is further split into subexpressions, and the results of the split subexpressions are calculated:

[0172] The result of pcbPartCode! = null is false;

[0173] The result of circuitDiagramStatus=='Baselined'||circuitDiagramStatus=='Archived' is true.

[0174] Subexpressions that result in a true expression are skipped.

[0175] The expression `pcbPartCode! = null`, which results in a false expression, does not contain a grouping operator, meaning it cannot be further split. Therefore, `pcbPartCode! = null` is recorded as a subexpression that results in a false expression.

[0176] By summarizing the records, it was ultimately identified that [docStatus! = 'Process Design', pcbPartCode! = null] was the main reason for the overall result being false.

[0177] It should be noted that the specific implementation method for splitting the expression in the above example can be found in [reference needed]. Figure 5 The process of splitting the first candidate expression term provided.

[0178] In the example above, by decomposing and analyzing the sub-expressions (expression items) contained in the logical expression layer by layer, only the sub-expressions at the current level that result in false are further analyzed and decomposed. Since a sub-expression at the current level that results in true, even if its sub-expressions at the next level fail, will not be a key factor causing the overall result to fail. However, when the result of an expression item or sub-expression item at the current level fails, all sub-expressions at the next level that fail are the cause of the failure of the expression item or sub-expression item at the current level. Therefore, by skipping sub-expressions that result in true and only analyzing expression items or sub-expressions that result in failure, the analysis process can be streamlined, and it can be ensured that the target business nodes corresponding to the finally extracted sub-expressions are all key factors affecting the overall result.

[0179] Description of apparatus and devices in embodiments of this application

[0180] It is understood that although the steps in the above flowcharts are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated in this embodiment, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the above flowcharts may include multiple steps or multiple stages. These steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these steps or stages is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the steps or stages in other steps.

[0181] Figure 7 A schematic diagram of a target service node determination device provided in an embodiment of this application. The target service node determination device 700 includes, but is not limited to:

[0182] The expression conversion module 710 is used to obtain the logical expression corresponding to the business process. The logical expression includes multiple expression items, and each expression item corresponds to at least one business node.

[0183] The expression item analysis module 720 is used to determine the target expression item whose local processing result does not meet the second preset value when the overall processing result of the business process does not meet the first preset value, based on the local processing result corresponding to each expression item.

[0184] The node determination module 730 is used to determine the target business node based on the target expression item.

[0185] It should be noted that each module of the target service node determination device in this application embodiment can also be used to execute the specific implementation details of the target service node determination method provided in the above embodiments. That is, the target service node determination device in this application embodiment can also be used to execute any or a combination of the above embodiments, which will not be repeated here.

[0186] Figure 8 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. For example... Figure 8 As shown, the electronic device 2000 includes a memory 2100 and a processor 2200. The number of memory 2100 and processor 2200 can be one or more. Figure 8 Taking a memory 2101 and a processor 2201 as an example; the memory 2101 and processor 2201 in the network device can be connected via a bus or other means. Figure 8 Taking the example of a connection between China and Israel via a bus.

[0187] The memory 2101, as a computer-readable storage medium, can be used to store software programs, computer-executable programs, and modules, such as program instructions / modules corresponding to the methods provided in any embodiment of this application. The processor 2201 implements the target service node determination method provided in any of the above embodiments by running the software programs, instructions, and modules stored in the memory 2101.

[0188] Memory 2101 may primarily include a program storage area and a data storage area, wherein the program storage area may store the operating system and application programs required for at least one function. Furthermore, memory 2101 may include high-speed random access memory and may also include non-volatile memory, such as at least one disk storage device, flash memory device, or other non-volatile solid-state storage device. In some instances, memory 2101 further includes memory remotely located relative to processor 2201, and this remote memory can be connected to the device via a network. Examples of such networks include, but are not limited to, the Internet, intranets, local area networks, mobile communication networks, and combinations thereof.

[0189] One embodiment of this application also provides a computer-readable storage medium storing computer-executable instructions for performing the target service node determination method as provided in any embodiment of this application.

[0190] An embodiment of this application also provides a computer program product, including a computer program or computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer program or computer instructions from the computer-readable storage medium and executes the computer program or computer instructions, causing the computer device to perform the target service node determination method as provided in any embodiment of this application.

[0191] The system architecture and application scenarios described in this application are intended to more clearly illustrate the technical solutions of this application and do not constitute a limitation on the technical solutions provided in this application. Those skilled in the art will understand that as system architectures evolve and new application scenarios emerge, the technical solutions provided in this application are also applicable to similar technical problems.

[0192] Those skilled in the art will understand that all or some of the steps in the methods disclosed above, as well as the functional modules / units in the systems and devices, can be implemented as software, firmware, hardware, or suitable combinations thereof.

[0193] In hardware implementations, the division between functional modules / units mentioned in the above description does not necessarily correspond to the division of physical components; for example, a physical component may have multiple functions, or a function or step may be performed collaboratively by several physical components. Some or all physical components may be implemented as software executed by a processor, such as a central processing unit, digital signal processor, or microprocessor, or as hardware, or as an integrated circuit, such as an application-specific integrated circuit. Such software may be distributed on a computer-readable medium, which may include computer storage media (or non-transitory media) and communication media (or transient media). As is known to those skilled in the art, the term computer storage media includes volatile and non-volatile, removable and non-removable media implemented in any method or technology for storing information (such as computer-readable instructions, data structures, program modules, or other data). Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technologies, CD-ROM, digital versatile disc (DVD) or other optical disc storage, magnetic cartridges, magnetic tape, disk storage or other magnetic storage devices, or any other medium that can be used to store desired information and is accessible to a computer. Furthermore, as is known to those skilled in the art, communication media typically contain computer-readable instructions, data structures, program modules, or other data in modulated data signals such as carrier waves or other transmission mechanisms, and may include any information delivery medium.

[0194] The terms “component,” “module,” “system,” etc., used in this specification are used to refer to computer-related entities, hardware, firmware, combinations of hardware and software, software, or software in execution. For example, a component can be, but is not limited to, a process running on a processor, a processor, an object, an executable file, an execution thread, a program, or a computer. As illustrated, applications running on computing devices and computing devices can both be components. One or more components may reside in a process or execution thread, and components may be located on a single computer or distributed among two or more computers. Furthermore, these components can be executed from various computer-readable media on which various data structures are stored. Components can communicate, for example, via local or remote processes based on signals having one or more data packets (e.g., data from two components interacting with another component between a local system, a distributed system, or a network, such as the Internet interacting with other systems via signals).

[0195] The above description, with reference to the accompanying drawings, illustrates some embodiments of this application, but does not limit the scope of this application. Any modifications, equivalent substitutions, and improvements made by those skilled in the art without departing from the scope and spirit of this application shall be within the scope of this application.

Claims

1. A method for determining a target business node, characterized in that, The method includes: Obtain the logical expression corresponding to the business process, wherein the logical expression includes multiple expression items, and each expression item corresponds to at least one business node; If the overall processing result of the business process does not meet the first preset value, the target expression item whose local processing result does not meet the second preset value is determined based on the local processing result corresponding to each expression item. The target business node is determined based on the target expression item.

2. The method for determining the target service node according to claim 1, characterized in that, The step of determining the target expression term whose local processing result does not satisfy the second preset value based on the local processing result corresponding to each of the expression terms includes: Based on the local processing results corresponding to each of the expression terms, a first candidate expression term whose local processing result does not satisfy the second preset value is determined; If the first candidate expression does not contain any sub-expressions, the first candidate expression is determined as the target expression, wherein the sub-expression corresponds to at least one of the service nodes.

3. The method for determining the target service node according to claim 1, characterized in that, The step of determining the target expression term whose local processing result does not satisfy the second preset value based on the local processing result corresponding to each of the expression terms includes: Based on the local processing results corresponding to each of the expression terms, a first candidate expression term whose local processing result does not satisfy the second preset value is determined; When the first candidate expression term includes sub-expression terms, based on the sub-processing results of each of the sub-expression terms in the first candidate expression term that includes the sub-expression terms, a second candidate expression term whose sub-processing results do not satisfy the second preset value is determined from each of the sub-expression terms. The target expression term is determined based on the second candidate expression term.

4. The method for determining the target service node according to claim 3, characterized in that, The step of determining a second candidate expression term from among the sub-expression terms whose sub-processing results do not satisfy a second preset value based on the sub-processing results of each of the first candidate expression terms containing the sub-expression terms includes: The first candidate expression term containing the sub-expression terms is split into multiple sub-expression terms; Based on the sub-processing results of each of the sub-expressions, a second candidate expression is determined from each of the sub-expressions whose sub-processing results do not satisfy the second preset value.

5. The method for determining the target service node according to claim 4, characterized in that, The step of splitting the first candidate expression term containing the sub-expression terms into multiple sub-expression terms includes: Initialize the split index based on the position of the first character of the first candidate expression item; Start iterating from the first character of the first candidate expression; If the currently traversed character is a logical operator and the parenthesis cache is empty, the sub-expression item is determined based on the string between the split index and the currently traversed character, and the split index is updated to the position after the logical operator, wherein the parenthesis cache is used to store parentheses; If the currently traversed character is the outermost starting bracket, the outermost starting bracket is stored in the bracket cache. The sub-expression is determined based on the string between the split index and the position of the currently traversed character, and the split index is updated to the position of the currently traversed character. If the currently traversed character is a parenthesis other than the outermost starting parenthesis, determine the outermost parenthesis pair corresponding to the parenthesis in the first candidate expression item, determine the sub-expression item based on the string between the outermost parenthesis pairs, and update the split index to the position after the closing parenthesis of the outermost parenthesis pair.

6. The method for determining the target service node according to claim 5, characterized in that, If the currently traversed character is a parenthesis other than the outermost starting parenthesis, determine the outermost parenthesis pair corresponding to the parenthesis in the first candidate expression item, determine the sub-expression item based on the string between the outermost parenthesis pairs, and update the split index to the position of the closing parenthesis of the outermost parenthesis pair, including: If the currently traversed character is a starting parenthesis, the starting parenthesis is stored in the parenthesis cache; If the currently traversed character is a closing parenthesis, a parenthesis is retrieved from the parenthesis cache. If the parenthesis cache is empty after retrieval, the sub-expression is determined based on the string between the split index and the position of the currently traversed character, and the split index is updated to the next position of the currently traversed character.

7. The method for determining the target service node according to claim 5, characterized in that, The step of splitting the first candidate expression term containing the sub-expression terms into multiple sub-expression terms further includes: If the currently traversed character is a quotation mark and the quotation mark identifier is a first value, the quotation mark identifier is updated to a second value, and it is determined that the quotation mark state is entered. In the quotation mark state, the character processing of the logical expression is skipped. If the currently traversed character is a quotation mark and the quotation mark identifier is the second value, update the quotation mark identifier to the first value and exit the quotation mark state.

8. The method for determining the target service node according to claim 5, characterized in that, The step of splitting the first candidate expression term containing the sub-expression terms into multiple sub-expression terms further includes: Traverse to the last character of the first candidate expression item. If the split index is less than the total length of the first candidate expression item, determine the sub-expression item based on the string between the split index and the last character of the first candidate expression item.

9. An electronic device, characterized in that, include: At least one processor; At least one memory for storing at least one program; The target service node determination method as described in any one of claims 1 to 8 is implemented when at least one of the programs is executed by at least one of the processors.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-executable instructions for performing the target service node determination method as described in any one of claims 1 to 8.

11. A computer program product, comprising a computer program or computer instructions, characterized in that, The computer program or the computer instructions are stored in a computer-readable storage medium. The processor of the computer device reads the computer program or the computer instructions from the computer-readable storage medium and executes the computer program or the computer instructions, causing the computer device to perform the target service node determination method as described in any one of claims 1 to 8.

Images