indexof和子字符串的问题

本文关键字：问题 字符串 indexof | 更新日期: 2023-09-27 18:08:39

现在，在我通过帮助解决了这个问题之后，我在一个小文本文件中从两个标签之间获取文本，我为测试创建了只有4行。现在我想创建一个新的文本文件，它将包含原始文件的内容，但在我发现标签之间的文本的每个地方，我希望看到空格空字符串。那么如果原始文本文件现在是这样的:

daniel<Text>THISISOUTisthere</Text>
<Text>hellobye</Text>
<Text>danielTHISishereandnotthere</Text>
danie <Text> is THIS here and not THERE</Text>
所以新文件应该看起来像: 
daniel<Text>                </Text>
<Text>        </Text>
<Text>                            </Text>
danie <Text>                           </Text>

这是现在不能工作的代码。我使用了一些帮助变量，但在运行以下代码时出现了错误:

string hh = f.Substring(lastIndex, currentIndex);

错误提示:Index和length必须指向字符串中的某个位置。参数名称:长度

这是现在不能工作的完整代码:

private void test()
        {
            w = new StreamWriter(@"d:'testFile.txt");
            int currentLength;
            int currentIndex;
            int lastIndex = 0;
            string startTag = "<Text>";
            string endTag = "</Text>";
            int startTagWidth = startTag.Length;
            //int endTagWidth = endTag.Length;
            index = 0;
            while (true)
            {
                index = f.IndexOf(startTag, index);
                if (index == -1)
                {
                    break;
                }
                // else more to do - index now is positioned at first character of startTag    
                int start = index + startTagWidth;
                currentIndex = start;
                index = f.IndexOf(endTag, start+1);
                if (index == -1)
                {
                    break;
                }
                // found the endTag    
                string g = f.Substring(start, index - start - 1);
                currentLength = index - start - 1;
                string hh = f.Substring(lastIndex, currentIndex);
                w.WriteLine(hh);
                lastIndex = currentIndex + currentLength;
                listBox1.Items.Add(g);
            } 
        }

indexof和子字符串的问题

子字符串的第二个参数是长度，而不是索引位置，所以它应该是

string hh = f.Substring(lastIndex, currentIndex-lastIndex);

另外，你砍掉了太多的字符，你想把currentLength = index - start -1改成currentLength = index - start

最后使用Writeline将添加额外的换行符，使用Write代替

作为一种有趣的替代方法，您可以使用正则表达式为您完成替换:

string input = "daniel<Text>THISISOUTisthere</Text>'n<Text>hellobye</Text>'n<Text>danielTHISishereandnotthere</Text>'ndanie <Text> is THIS here and not THERE</Text>";
Regex re = new Regex("(?<=<Text>).*?(?=</Text>)");
string output = re.Replace(input, m => new string(' ', m.Length));
Console.WriteLine(input);
Console.WriteLine();
Console.WriteLine(output);

程序输出:

daniel<Text>THISISOUTisthere</Text>
<Text>hellobye</Text>
<Text>danielTHISishereandnotthere</Text>
danie <Text> is THIS here and not THERE</Text>
daniel<Text>                </Text>
<Text>        </Text>
<Text>                           </Text>
danie <Text>                           </Text>

另一个有趣的选择，因为我觉得我想尝试让它工作:一个自己动手的小解析器。

注意:这不是一个真正的HTML或XML解析器!它只涉及一个标签(例如<Text>)，并且没有任何属性…

那么，解析器需要什么呢?对，一个标记器。给你:

static IEnumerable<Token> Tokenize(string input, string tag)
{
    int index = 0;
    int lastIndex = 0;
    // Define the start and end tag and their common first character
    char tagChar = '<';
    string startTag = tag + '>';
    string endTag = '/' + tag + '>';
    while (true)
    {
        Token token = null;
        // Search for any new tag token
        index = input.IndexOf(tagChar, index) + 1;
        if (index <= 0)
            break;
        // Starttag or endtag token found
        if (input.Substring(index, startTag.Length) == startTag)
            token = new Token { Start = index - 1, Length = startTag.Length + 1, TypeOfToken = Token.TokenType.StartTag };
        else if (input.Substring(index, endTag.Length) == endTag)
            token = new Token { Start = index - 1, Length = endTag.Length + 1, TypeOfToken = Token.TokenType.EndTag };
        // Yield the text right before the tag and the tag itself
        if (token != null)
        {
            yield return new Token { Start = lastIndex, Length = index - lastIndex - 1, TypeOfToken = Token.TokenType.Text };
            yield return token;
            lastIndex = index + token.Length - 1;
        }
    }
    // Yield last text token
    yield return new Token { Start = lastIndex, Length = input.Length - lastIndex, TypeOfToken = Token.TokenType.Text };
}
class Token
{
    public int Start { get; set; }
    public int Length { get; set; }
    public TokenType TypeOfToken { get; set; }
    public enum TokenType
    {
        Text,
        StartTag,
        EndTag
    }
}

它甚至有些优化，因为它只搜索<，然后检查它是开始还是结束标记。

将字符串标记化后，其余的处理非常简单:

static string ProcessString(string input, string tag)
{
    var sb = new StringBuilder();
    int depth = 0;
    foreach (var token in Tokenize(input, tag))
    {
        // Append all tags, but only text tokens with depth level 0
        if (token.TypeOfToken != Token.TokenType.Text || 
            (token.TypeOfToken == Token.TokenType.Text && depth == 0))
            sb.Append(input.Substring(token.Start, token.Length));
        else
            sb.Append(new string(' ', token.Length));
        // Increment for each starttag, decrement for each endtag, never smaller than 0
        depth = Math.Max(0, depth + (token.TypeOfToken == Token.TokenType.StartTag ? 1 :
                                    (token.TypeOfToken == Token.TokenType.EndTag ? -1 : 0)));
    }
    return sb.ToString();
}

这比正则表达式解决方案更灵活，因为您可以赋予它更多的语义含义，比如深度。例如调用这个:

ProcessString("level0<Tag>level1<Tag>level2</Tag>level1again</Tag>level0again", "Tag");

将被处理为:

"level0<Tag>      <Tag>      </Tag>           </Tag>level0again"
相关文章：