Парсинг строки, содержащей массив
Я хотел бы преобразовать строку, содержащую рекурсивный массив строк, в массив глубины один.
Пример:
StringToArray("[a, b, [c, [d, e]], f, [g, h], i]") == ["a", "b", "[c, [d, e]]", "f", "[g, h]", "i"]
Кажется довольно просто. Но я пришел из функционального фона, и я не очень хорошо знаком со стандартными библиотеками.NET Framework, поэтому каждый раз (я начинал с нуля, как 3 раза) я получал просто уродливый код. Моя последняя реализация здесь. Как вы видите, это ужасно ужасно.
Итак, что C# способ сделать это?
5 ответов
@ojlovecd имеет хороший ответ, используя регулярные выражения.
Однако его ответ слишком сложен, поэтому вот мой аналогичный, более простой ответ.
public string[] StringToArray(string input) {
var pattern = new Regex(@"
\[
(?:
\s*
(?<results>(?:
(?(open) [^\[\]]+ | [^\[\],]+ )
|(?<open>\[)
|(?<-open>\])
)+)
(?(open)(?!))
,?
)*
\]
", RegexOptions.IgnorePatternWhitespace);
// Find the first match:
var result = pattern.Match(input);
if (result.Success) {
// Extract the captured values:
var captures = result.Groups["results"].Captures.Cast<Capture>().Select(c => c.Value).ToArray();
return captures;
}
// Not a match
return null;
}
Используя этот код, вы увидите, что StringToArray("[a, b, [c, [d, e]], f, [g, h], i]") вернет следующий массив: ["a", "b", "[c, [d, e]]", "f", "[g, h]", "i"],
Для получения дополнительной информации о сбалансированных группах, которые я использовал для сопоставления сбалансированных фигурных скобок, ознакомьтесь с документацией Microsoft.
Обновление:
Согласно комментариям, если вы хотите также сбалансировать кавычки, вот возможная модификация. (Обратите внимание, что в C# " сбежал как "") Я также добавил описания шаблона, чтобы прояснить его:
var pattern = new Regex(@"
\[
(?:
\s*
(?<results>(?: # Capture everything into 'results'
(?(open) # If 'open' Then
[^\[\]]+ # Capture everything but brackets
| # Else (not open):
(?: # Capture either:
[^\[\],'""]+ # Unimportant characters
| # Or
['""][^'""]*?['""] # Anything between quotes
)
) # End If
|(?<open>\[) # Open bracket
|(?<-open>\]) # Close bracket
)+)
(?(open)(?!)) # Fail while there's an unbalanced 'open'
,?
)*
\]
", RegexOptions.IgnorePatternWhitespace);
С помощью Regex это может решить вашу проблему:
static string[] StringToArray(string str)
{
Regex reg = new Regex(@"^\[(.*)\]$");
Match match = reg.Match(str);
if (!match.Success)
return null;
str = match.Groups[1].Value;
List<string> list = new List<string>();
reg = new Regex(@"\[[^\[\]]*(((?'Open'\[)[^\[\]]*)+((?'-Open'\])[^\[\]]*)+)*(?(Open)(?!))\]");
Dictionary<string, string> dic = new Dictionary<string, string>();
int index = 0;
str = reg.Replace(str, m =>
{
string temp = "ojlovecd" + (index++).ToString();
dic.Add(temp, m.Value);
return temp;
});
string[] result = str.Split(',');
for (int i = 0; i < result.Length; i++)
{
string s = result[i].Trim();
if (dic.ContainsKey(s))
result[i] = dic[s].Trim();
else
result[i] = s;
}
return result;
}
Нет реального "стандартного" способа сделать это. Обратите внимание, что реализация может стать довольно грязной, если вы хотите рассмотреть все возможности. Я бы порекомендовал что-то рекурсивное, например:
private static IEnumerable<object> StringToArray2(string input)
{
var characters = input.GetEnumerator();
return InternalStringToArray2(characters);
}
private static IEnumerable<object> InternalStringToArray2(IEnumerator<char> characters)
{
StringBuilder valueBuilder = new StringBuilder();
while (characters.MoveNext())
{
char current = characters.Current;
switch (current)
{
case '[':
yield return InternalStringToArray2(characters);
break;
case ']':
yield return valueBuilder.ToString();
valueBuilder.Clear();
yield break;
case ',':
yield return valueBuilder.ToString();
valueBuilder.Clear();
break;
default:
valueBuilder.Append(current);
break;
}
Хотя вы не ограничены рекурсивностью и всегда можете прибегнуть к одному методу, такому как
private static IEnumerable<object> StringToArray1(string input)
{
Stack<List<object>> levelEntries = new Stack<List<object>>();
List<object> current = null;
StringBuilder currentLineBuilder = new StringBuilder();
foreach (char nextChar in input)
{
switch (nextChar)
{
case '[':
levelEntries.Push(current);
current = new List<object>();
break;
case ']':
current.Add(currentLineBuilder.ToString());
currentLineBuilder.Clear();
var last = current;
if (levelEntries.Peek() != null)
{
current = levelEntries.Pop();
current.Add(last);
}
break;
case ',':
current.Add(currentLineBuilder.ToString());
currentLineBuilder.Clear();
break;
default:
currentLineBuilder.Append(nextChar);
break;
}
}
return current;
}
Все, что пахнет хорошо для вас
Честно говоря, я бы просто написал этот метод в сборке F#, так как он, вероятно, намного проще. Если вы посмотрите на JavaScriptSerializer Реализация в C# (с таким декомпилятором, как dotPeek или рефлектор) позволяет увидеть, насколько беспорядочным является код разбора массива для аналогичного массива в JSON. Конечно, это должно обрабатывать гораздо более разнообразный набор токенов, но вы поняли идею.
Вот их DeserializeList реализация, более уродливая, чем обычно, как декомпилированная версия его dotPeek, а не оригинал, но вы поняли идею. DeserializeInternal вернется к списку детей.
private IList DeserializeList(int depth)
{
IList list = (IList) new ArrayList();
char? nullable1 = this._s.MoveNext();
if (((int) nullable1.GetValueOrDefault() != 91 ? 1 : (!nullable1.HasValue ? 1 : 0)) != 0)
throw new ArgumentException(this._s.GetDebugString(AtlasWeb.JSON_InvalidArrayStart));
bool flag = false;
char? nextNonEmptyChar;
char? nullable2;
do
{
char? nullable3 = nextNonEmptyChar = this._s.GetNextNonEmptyChar();
if ((nullable3.HasValue ? new int?((int) nullable3.GetValueOrDefault()) : new int?()).HasValue)
{
char? nullable4 = nextNonEmptyChar;
if (((int) nullable4.GetValueOrDefault() != 93 ? 1 : (!nullable4.HasValue ? 1 : 0)) != 0)
{
this._s.MovePrev();
object obj = this.DeserializeInternal(depth);
list.Add(obj);
flag = false;
nextNonEmptyChar = this._s.GetNextNonEmptyChar();
char? nullable5 = nextNonEmptyChar;
if (((int) nullable5.GetValueOrDefault() != 93 ? 0 : (nullable5.HasValue ? 1 : 0)) == 0)
{
flag = true;
nullable2 = nextNonEmptyChar;
}
else
goto label_8;
}
else
goto label_8;
}
else
goto label_8;
}
while (((int) nullable2.GetValueOrDefault() != 44 ? 1 : (!nullable2.HasValue ? 1 : 0)) == 0);
throw new ArgumentException(this._s.GetDebugString(AtlasWeb.JSON_InvalidArrayExpectComma));
label_8:
if (flag)
throw new ArgumentException(this._s.GetDebugString(AtlasWeb.JSON_InvalidArrayExtraComma));
char? nullable6 = nextNonEmptyChar;
if (((int) nullable6.GetValueOrDefault() != 93 ? 1 : (!nullable6.HasValue ? 1 : 0)) != 0)
throw new ArgumentException(this._s.GetDebugString(AtlasWeb.JSON_InvalidArrayEnd));
else
return list;
}
Рекурсивный разбор просто не управляется так же хорошо, как в C#, как в F#.
using System;
using System.Text;
using System.Text.RegularExpressions;
using Microsoft.VisualBasic.FileIO; //Microsoft.VisualBasic.dll
using System.IO;
public class Sample {
static void Main(){
string data = "[a, b, [c, [d, e]], f, [g, h], i]";
string[] fields = StringToArray(data);
//check print
foreach(var item in fields){
Console.WriteLine("\"{0}\"",item);
}
}
static string[] StringToArray(string data){
string[] fields = null;
Regex innerPat = new Regex(@"\[\s*(.+)\s*\]");
string innerStr = innerPat.Matches(data)[0].Groups[1].Value;
StringBuilder wk = new StringBuilder();
var balance = 0;
for(var i = 0;i<innerStr.Length;++i){
char ch = innerStr[i];
switch(ch){
case '[':
if(balance == 0){
wk.Append('"');
}
wk.Append(ch);
++balance;
continue;
case ']':
wk.Append(ch);
--balance;
if(balance == 0){
wk.Append('"');
}
continue;
default:
wk.Append(ch);
break;
}
}
var reader = new StringReader(wk.ToString());
using(var csvReader = new TextFieldParser(reader)){
csvReader.SetDelimiters(new string[] {","});
csvReader.HasFieldsEnclosedInQuotes = true;
fields = csvReader.ReadFields();
}
return fields;
}
}