函数调用过程中所有参数的提取

1. 引言

曾经遇到一个面试题：如何将函数调用看作一个字符串，提取出所有的参数并构建成一个树。

比如输入字符串 func1(123, 456)， 输出是

func1(123, 456)
|
---------123
|
---------456

输入字符串 func1(123, 456, func2(78, 99)) 输出则是

func1(123, 456, func2(78, 99))
|
-----------------------------123
|
----------------------------456
|
----------------------------func2(78, 99)
|
--------------78
|
--------------99

面试过程中，假设了函数调用肯定是合法的，即函数左右括号肯定匹配，函数参数都是double 或者 int 等数值类型。

由于存在这样的假设前提，题目已经变得相对简单多，但是实际项目中函数的参数是多种多样的，参数可以是String 类型，并且实参包含逗号或者左右括号都是可能的。

非常巧的是最近在项目中就遇到了类似的算法，需要将函数调用过程中所有满足一定格式的参数提取出来，当然参数有字符串并以单引号为开头结尾。但是单引号不再包含单引号。

今天就给出一个针对函数所有参数提取的C#实现。

2. 代码实现

首先给出了一个简单的Tree类的定义，熟悉C++的同学肯定不陌生，这里用C#实现：

public class TreeNode
{
public string Text { get; set; }
public List<TreeNode> ChildNodes { get; set; }
}

定义函数：判断参数是不是嵌套的函数调用，例如函数参数只可能是以下类型，

数值类型： 123 或者 56.87

字符类型： ‘fake parameter’ 或者 ‘fake paramter with left bracket ( or right bracket ).’

嵌套函数： funcx(34,78, ‘dd’) 或者 funcy()

public static bool IsFunctionCall(string str)
{
if (string.IsNullOrEmpty(str))
{
return false;
}

if (str.Trim().First( ) == '\'' && str.Trim().Last() == '\'')
{
return false;
}

int leftBracketIndex = str.IndexOf("(", StringComparison.OrdinalIgnoreCase);
int rightBracketIndex = str.LastIndexOf(")", StringComparison.OrdinalIgnoreCase);

if (leftBracketIndex < 0 && rightBracketIndex < 0)
{
return false;
}

return true;
}

定义函数：获取函数所有未分割的参数，例如

“func1(123, 456)”=> “123, 456”

“func1(123, 456, func2(78, 99))”=> “123, 456, func2(78, 99)”

public static string GetParameterString(string function)
{
int leftBracketIndex = function.IndexOf("(", StringComparison.OrdinalIgnoreCase);
int rightBracketIndex = function.LastIndexOf(")", StringComparison.OrdinalIgnoreCase);

string value = function.Substring(leftBracketIndex + 1, rightBracketIndex - leftBracketIndex - 1).Trim();

return (string.IsNullOrEmpty(value) || string.IsNullOrWhiteSpace(value)) ? null : value;
}

调用函数：

public static TreeNode Parse(string input)
{
if (string.IsNullOrEmpty(input))
return null;

if (IsFunctionCall(input))
{
return ParseFunction(input);
}
else
{
return new TreeNode() {Text = input};
}
}

最后是提取Function 所有参数的函数实现：

/// <summary>
/// 通过递归提取所有参数
/// </summary>
/// <param name="input">输入参数肯定是一个函数调用比如： func1(123, 456, func2(78, 'abc'))</param>
/// <returns>返回一个树</returns>
public static TreeNode ParseFunction(string input)
{
if (string.IsNullOrEmpty(input))
return null;

//构建顶层树节点并且得到所有的未分割的参数
TreeNode rootNode = new TreeNode() {Text = input};
var paramStr = GetParameterString(input);
if (paramStr == null)
{
return rootNode;
}

//存放所有参数的List
List<string> result = new List<string>();
string tmp = "";

//可以用Stack 来实现括号的匹配，这里简单的记录左括号的个数
int bracketCount = 0;

//参数是否是字符串
bool hasSingleQuote = false;

foreach (char c in paramStr)
{
if (c == '\'')
{
tmp += c;

//字符串结尾
if (hasSingleQuote)
{
hasSingleQuote = false;
continue;
}

//字符串开始
hasSingleQuote = true;
continue;
}

//只有参数不是字符串的时候 左括号才加一
if (c == '(' && !hasSingleQuote)
{
bracketCount++;
tmp += c;
}
//只有参数不是字符串的时候 右括号才减一
else if (c == ')' && !hasSingleQuote)
{
bracketCount--;
tmp += c;
}
//参数参数满足的条件
else if (c == ',' && bracketCount == 0 && !hasSingleQuote)
{
result.Add(tmp.Trim());
tmp = "";
}
else
{
tmp += c;
}
}

//最后一个参数
if (tmp != "")
{
result.Add(tmp.Trim());
}

//递归的提取
rootNode.ChildNodes = result.Select(parm => Parse(parm)).ToList();
return rootNode;
}

测试用例：

static void Main(string[] args)
{
TreeNode testTree = Parse("func1(123, 456, func2(78, 'abc'))");
testTree = Parse(" func1(func4(), 123, '(abc', func3(')dj'), 456, func2(78, 'dev', func5('xx)(x', 99)))");
}

3. 结论

这道题目其实考察的是对递归和Stack的理解。首先如果直接用逗号分隔只会把问题弄得复杂，只要想到左右括号匹配等条件再利用Stack的思想，问题也就变得简单多了。

如果给出的算法有错误或者有更好的算法 请各位支出。

欢迎访问我的个人网站 51zhang.net 网站还在不断开发中…