Solucionado (ver solução)
Solucionado
(ver solução)
7
respostas

pattern para pegar espaços entre "|"

Preciso aplicar uma expressão regular no caso abaixo onde vou substituir e os espaços entre os "|" no html.

Caso 1
antes  #### <p>|                             | dade  |</span></p>
depois #### <p>|<span style="padding-left:32px;">| dade  |</span></p>

Caso 2

<p>|             SAUDE CAIXA - DESENVOLVIMENTO|</span></p>
<p>|<span style="padding-left:10px;">SAUDE CAIXA - DESENVOLVIMENTO|</span></p>

os valores de padding-left:10px pelo tamanho do Match do espaço.

7 respostas

Sérgio, você quer substituir somente o espaço do primeiro campo, ou de todos? De um jeito ou de outro, um começo para a expressão que vai capturar o grupo de espaços que você procura seria

(?:(?<=\|)( *+)[^|]*?( *+)(?=\|))*

Em detalhes:

<p>|                             | dade  |</p>
<p>|             SAUDE CAIXA - DESENVOLVIMENTO|</p>
( *+)[^|]*?( *+)
# dois grupos capturáveis de zero ou mais espaços com qualquer caractere que
# não seja uma barra vertical entre eles. os + após o * indicam greedyness
# (espaços são caracteres que não são barras verticais, mas por causa do + os
# espaços após a palavra "dade" são inclusos no grupo de espaços)

(?<=\|)XXXXX(?=\|)
# envolvendo os grupos anteriores, existem dois grupos não capturáveis que
# conferem se o conteúdo é precedido ou sucedido por barras verticais,
# indicando que é um trecho onde devemos procurar por espaços em branco

(?:XXXXX)*
# tudo isso é encapsulado em um grupo não capturável para permitir que o
# conteúdo seja buscado mais de uma vez.

Para ver uma explicação mais detalhada, utilize o site Regex 101 (<--- clique ali), já com os casos de uso e a regex inseridas.

Fiquei na dúvida tbm se era só o primeiro grupo ou não. Acho que sim, pelo seu exemplo (se não for, só colocar /g).

Meu código:

var depois = antes.replace(/(\|\s+)/, function(match){
  return '|<span style="padding-left:'+ match.length +';">';
});

Rodando aqui: http://jsbin.com/fexikuqugu/edit?js,console

Resposta do Sérgio bem mais prática. Espero que ajude a resolver seu problema e que você consiga aprender algo novo!

Marco e Sérgio obrigado pelo retorno :)

Eu preciso de uma expressão genérica para aplicar exatamente na quantidade de espaço que eu preciso. Eu tenho vários arquivos .xaml cada um com sua particularidade, cada intervalo de espaço eu preciso substituir pela Tag que vai aplicar esse espaço com o valor de "px" flexível como o Sérgio fez.

Eu preciso pegar grupo a grupo separado e fazer o replace, dinamicamente.

Segue abaixo dois exemplo.

Exemplo 01:
<p>|              NOME                          FONE                 |</p>
<p>|              XXXXXXX                      (XX)XXXX-XXXX         |</p>


Exemplo 02:
<p>Mes              faturamento                  faturamento</p>
<p>Janeiro          99999999999                  99999999999</p>

Hoje esta assim a minha função em c#

public string SpaceInXaml(string xaml)
        {
            string patternTab = @"\t+";
            int valorDoTab = 47;
            // verifica primeiro os espaços com TAB
            string xamlTratado = Space(patternTab, xaml, valorDoTab);

            string patternEspaco = @"\s\s\s+";
            int valorDoEspaco = 4;
            // verifica segundo os espaços normais.
            return Space(patternEspaco, xamlTratado, valorDoEspaco);
        }

        public string Space(string pattern, string xaml, int valueSpace)
        {
            var xamlLine = string.Empty;
            var xamlFinal = string.Empty;

            using (StringReader line = new StringReader(xaml))
            {
                xamlLine = line.ReadLine();

                while ((xamlLine != string.Empty) && (xamlLine != null))
                {
                    if (Regex.IsMatch(xamlLine, pattern))
                    {
                        MatchCollection matches = Regex.Matches(xamlLine, pattern);

                        //atribui a tag <Span ...> em na variavel.
                        var span = Regex.Match(xamlLine, @"Span\b[^>]*");

                        foreach (Match match in matches)
                        {
                            // valor do espaço
                            int spaceValue = match.Length * valueSpace;

                            // monta a tag <Span ...> para subistituir os espaços no meio da linha
                            string spanEntrePalavras = "</Span><" + span.Value + " Space=\"" + spaceValue.ToString() + "\">";

                            // monta a tab <Span ...> para subistituir os espaços de inicio.
                            string spanInicio = "\" Space=\"" + spaceValue.ToString() + "\">";

                            // verifica espaços pelo Regex no inicio
                            string patternIninio = "\">" + match.Value + @"(?=(\b|\S))";
                            xamlLine = Regex.Replace(xamlLine, patternIninio, spanInicio);

                            // verifica espaços pelo Regex entre palavras 
                            string patternEntrePalavras = @"(?=(\b|\S))(" + match.Value + @")(?=(\b|\S))";
                            xamlLine = Regex.Replace(xamlLine, patternEntrePalavras, spanEntrePalavras);
                        }
                    }

                    xamlFinal += xamlLine + "\n";
                    xamlLine = line.ReadLine();
                }
            }

            return xamlFinal;
        }
solução!

Resolvi com esse Pattern :)

(?<=\S)xxxxxxxxxxxx(?=\S)

Obrigado pela ajuda

Deixa eu ver se entendi direito.

O que você quer é alinhar os elementos da sua "lista" ou "tabela" à esquerda, utilizando espaçamento em pixels via regex, mas cada elemento tem uma largura diferente pré-determinada?

Que bom que resolveu seu problema! Marque a resposta que te ajudou como solução (pode ser até a sua, se você descobriu por si mesmo) para que outros com dificuldade semelhante consigam se guiar sozinhos também!

Quer mergulhar em tecnologia e aprendizagem?

Receba a newsletter que o nosso CEO escreve pessoalmente, com insights do mercado de trabalho, ciência e desenvolvimento de software