Obter Substring até um carácter de parada.

Existem muitas implementações para retornar uma substring até um ponto de parada.
Neste artigo estou demonstrando algumas maneiras de resolver o problema.

Contexto do problema

Dada uma string de entrada, devemos retornar a substring que contenha todos os caracteres da original, até que esta atinja o carácter de parada informado. Caso o carácter não seja encontrado, a string retornada será idêntica a fornecida.

Resolvendo o problema – Solução 1

Nesta solução proposta é usando String.IndexOf e String.Substring. Primeiro deve-se obter o índice do carácter de parada e posteriormente usar esse valor para gerar a substring.

String.IndexOf: Relata o índice de base zero da primeira ocorrência de uma cadeia de caracteres ou um caractere Unicode especificado nesta instância. O método retorna -1 caso o caractere ou a cadeia de caracteres não seja encontrado nessa instância.

Resolvendo o problema – Solução 2

Nesta solução também usamos o índice do carácter informado e depois o a função String.Remove para retirar todos os caráteres que vem apos este índice.

String.Remove: Retorna uma nova cadeia de caracteres na qual um número especificado de caracteres da cadeia de caracteres atual é excluído.

Resolvendo o problema – Solução 3

Nesta solução foi utilizado LINQ para varrer a string e ‘pegar’ todos os caráteres até atingir aquele informado como parada.

Enumerable.TakeWhile: Retorna elementos de uma sequência contanto que uma condição especificada seja true e, em seguida, ignora os elementos restantes.

Resolvendo o problema – Solução 4

Nesta solução foi utilizado uma regra de expressão regular para então filtrar a string e retornar somente o trecho que requisitado.

Regex.Match: Pesquisa em uma cadeia de caracteres de entrada uma subcadeia de caracteres que corresponde a um padrão de expressão regular e retorna a primeira ocorrência como um único objeto Match.

Exemplo:

using System;
using System.Linq;
using System.Text.RegularExpressions;
namespace SubStringHelper
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] testCases = { "12345-678-9", "12345-678.123", "12345", "123:45-678", "12|345-678" };
            foreach (var testCase in testCases)
            {
                Console.WriteLine("-------- testCase :     " + testCase + " --------");
                Console.WriteLine("GetUntil_WithSubstring: " + testCase.GetUntil_WithSubstring());
                Console.WriteLine("GetUntil_WithRemove:    " + testCase.GetUntil_WithRemove());
                Console.WriteLine("GetUntil_WithTakeWhile: " + testCase.GetUntil_WithTakeWhile());
                Console.WriteLine("GetUntil_WithRegex:     " + testCase.GetUntil_WithRegex());
                Console.WriteLine();
            }
        }
    }

    public static class StringHelper
    {
        public static string GetUntil_WithSubstring(this string text, string stopAt = "-")
        {
            if (!string.IsNullOrWhiteSpace(text))
            {
                int charLocation = text.IndexOf(stopAt, StringComparison.Ordinal);
                return charLocation > 0 ? text.Substring(0, charLocation) : text;
            }
            return string.Empty;
        }

        public static string GetUntil_WithRemove(this string text, string stopAt = "-")
        {
            if (!string.IsNullOrWhiteSpace(text))
            {
                int charLocation = text.IndexOf(stopAt, StringComparison.Ordinal);
                return charLocation > 0 ? text.Remove(charLocation) : text;
            }
            return string.Empty;
        }

        public static string GetUntil_WithTakeWhile(this string text, string stopAt = "-")
        {
            if (!string.IsNullOrWhiteSpace(text))
            {
                return string.Concat(text.TakeWhile((_) => _.ToString() != stopAt));
            }
            return string.Empty;
        }

        public static string GetUntil_WithRegex(this string text, string stopAt = "-")
        {
            if (!string.IsNullOrWhiteSpace(text))
            {
                return new Regex("^(.*?)(" + Regex.Escape(stopAt) + "|$)").Match(text).Groups[1].Value;
            }
            return string.Empty;
        }
    }
}
/*  This will print
-------- testCase :     12345-678-9 --------
GetUntil_WithSubstring: 12345
GetUntil_WithRemove:    12345
GetUntil_WithTakeWhile: 12345
GetUntil_WithRegex:     12345

-------- testCase :     12345-678.123 --------
GetUntil_WithSubstring: 12345
GetUntil_WithRemove:    12345
GetUntil_WithTakeWhile: 12345
GetUntil_WithRegex:     12345

-------- testCase :     12345 --------
GetUntil_WithSubstring: 12345
GetUntil_WithRemove:    12345
GetUntil_WithTakeWhile: 12345
GetUntil_WithRegex:     12345

-------- testCase :     123:45-678 --------
GetUntil_WithSubstring: 123:45
GetUntil_WithRemove:    123:45
GetUntil_WithTakeWhile: 123:45
GetUntil_WithRegex:     123:45

-------- testCase :     12|345-678 --------
GetUntil_WithSubstring: 12|345
GetUntil_WithRemove:    12|345
GetUntil_WithTakeWhile: 12|345
GetUntil_WithRegex:     12|345
 */

Estas são apenas algumas maneiras de resolver o problema proposto. Estas soluções foram todas adaptadas de soluções encontradas na internet.

Qualquer dúvida ou dicas, entre em contato: leandrolt@gmail.com

Principais referências

– https://stackoverflow.com/questions/1857513/get-substring-everything-before-certain-char
– https://docs.microsoft.com/pt-br/dotnet/api/system.string.indexof?view=netcore-3.1
– https://docs.microsoft.com/pt-br/dotnet/api/system.string.remove?view=netcore-3.1
– https://docs.microsoft.com/pt-br/dotnet/api/system.linq.enumerable.takewhile?view=netcore-3.1
– https://docs.microsoft.com/pt-br/dotnet/api/system.text.regularexpressions.regex.match?view=netcore-3.1

Leave a Reply

Your email address will not be published. Required fields are marked *