Bem-vindos ao blog Preciso Estudar Sempre. Meu nome é João Paulo Maida e minha paixão é estudar.
Como todos sabemos, a leitura tradicional de um arquivo em qualquer linguagem de programação é a criação de um ponteiro em memória para uma representação do arquivo. Após isso, é aberta uma conexão de leitura/escrita e a partir daí toda a mágica que já conhecemos acontece. Se o seu programa deseja ler ou escrever informações do ou no arquivo, ele consegue. Contudo, devemos agora nos concentrar mais no processo de leitura de arquivos.
Geralmente, ele acontece linha a linha e a linguagem de programação usada para tal tarefa oferece métodos para recuperar esta em forma de string. Com o dado em nossas mãos podemos fazer o que quiser, por exemplo: aplicar uma expressão regular, concatenar dados, realizar análises e etc. Se concentre no primeiro exemplo, a aplicação de uma expressão regular.
Este assunto aqui no blog não é nenhuma novidade, pois já estudamos em outros post diversas expressões regulares ou regexs para infinitas utilidades. Mas, e se desejássemos capturar um bloco de texto oriundo de um arquivo através delas ? Como faríamos ?
A princípio parece uma tarefa que dá um nó na cabeça, pois como já citamos nos parágrafos acima a leitura acontece linha a linha, e isso não vai mudar. Então, precisamos de uma lógica boa que consiga capturar este bloco através de várias expressões passadas para ele.
Para a solução deste problema, utilizarei mais uma vez a linguagem de programação Java pois possuo um alto nível de afinidade com ela, mas esta solução é estendível para qualquer uma.
Antes de montar o algoritmo precisamos chegar a um acordo de como será nossa estrutura de regexs. Para que um bloco inteiro, onde quem define a quantidade de linhas desse bloco é a sua necessidade, possa ser capturado, precisamos mapear como é cada linha. Então, para fins de estudos utilizaremos um arquivo XML, pois este tipo de arquivo possui uma estrutura hierárquica que neste momento nos facilita a enxergar a solução. Então, no fim teremos.
Arquivo precisoestudarsempre.xml
precisoestudarsempre.xml
<blog>
<nome>Preciso Estudar Sempre</nome>
<email>precisoestudarsempre@gmail.com</email>
<descricao>Melhor blog do mundo :)</descricao>
</blog>
Nossas expressões regulares:
private final String[] arrayOfRegex = {"<nome>([a-zA-Z]+\s*)*</nome>",
"<email>.*</email>",
"<descricao>.*</descricao>"};
IMPORTANTE: É importante deixar claro aqui que neste post não destrincharei cada regex como já fiz em outros post. Nosso foco aqui é o algoritmo e não o estudo de expressões. Deixarei no fim do post vários links para outros post aqui do blog onde já expliquei várias vezes como e o que são as expressões regulares.
Agora que já montamos o nosso arquivo e sua respectiva estrutura de regexs, já temos o necessário para construir nosso algoritmo.
private void evaluateTextBlockRegex(BufferedReader bf){
try{
int regexCounter;
int lineNumber;
regexCounter = lineNumber = 0;
boolean isMatchedRegex = true;
Pattern pattern = null;
while (bf.ready()) {
String line = bf.readLine();
lineNumber++;
if(regexCounter == arrayOfRegex.length){
//só para pular linha
System.out.println();
regexCounter = 0;
}
while (isMatchedRegex) {
String regex = arrayOfRegex[regexCounter];
try {
pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(line);
isMatchedRegex = matcher.find();
if(isMatchedRegex){
//exibo a linha capturada
System.out.println("Linha " + lineNumber + " capturada: " + line);
regexCounter++;
break;
}
} catch (java.util.regex.PatternSyntaxException pse) {
//talvez que a regex não seja compilada
isMatchedRegex = false;
}
}
if(!isMatchedRegex){
isMatchedRegex = true;
regexCounter = 0;
}
}
} catch(java.io.IOException e){
System.out.println("An I/O error occurs!");
}
}
O funcionamento dele é o seguinte: o arquivo é lido linha após linha, e para cada uma é testada sempre a primeira regex. Caso esta tenha sucesso, o contador regexCounter é incrementado e uma nova linha é carregada na variável line, e assim o algoritmo testa a segunda regex, repetindo este processo até o array de regex chegar ao seu fim. Para que um bloco de texto seja capturado a correspondência entre linhas do arquivo e expressões regulares devem ser linha a linha, ou seja, a primeira regex corresponde a primeira linha do bloco e assim sucessivamente. A figura 1 esclarece tal relacionamento.
 |
| Figura 1 - Relacionamento linha - regex |
Todo este procedimento citado neste dois últimos parágrafos se repetem até o final do arquivo.
Para um bom conhecedor de Java uma pergunta pode surgir. Porque não usar a opção multiline da classe Pattern ? Sim, é verdade, existe uma opção pronta para este tipo de avaliação. Contudo, como no nosso caso estamos recuperando texto direto de um arquivo seria necessário transformar todo o arquivo em uma única string, para depois poder usar tal artifício. Tal processo pode apresentar problemas de tamanho de memória visto que o arquivo pode ser muito grande. Um outro ponto que torna nosso algoritmo mais interessante é que ele se encaixa mais facilmente em abordagens tradicionais da leitura de arquivos. Através de pesquisa é possível coletar relatos que esta opção traz problemas para programas que operam em multiplataformas, visto que cada plataforma tem um caractere de quebra de linha próprio. Lembra que já falamos disso aqui ?
Como eu sempre digo, não existem balas de prata. Não existe uma única solução correta. Devemos medir os prós e contras, e assim tomar nossa decisão.
Bem amigos, acabamos mais um post. Espero que vocês tenham gostado.
Baixe o código-fonte
Link do GitHub: https://github.com/PrecisoEstudarSempre/EvaluateTextBlockRegex.git
Link no Dropbox: https://www.dropbox.com/sh/trgchzdjr198ja7/AABCqIPsGPe15OC43IKKxiAga?dl=0
Link no GoogleDrive: https://drive.google.com/drive/folders/0BzDmhBY6luU6ZUR1d0tXRk91QkU?usp=sharing
Dúvidas !? Sugestões ?! Críticas ou elogios ?!
Deixe aí nos comentários, me mande um e-mail ou, na nossa página do facebook.
E-mail: precisoestudarsempre@gmail.com
Facebook: https://www.facebook.com/precisoestudarsempre/
Canal Preciso Estudar Sempre: https://www.youtube.com/channel/UCUoW8dS38rXr0a5jWU57etA
Referências
Classe Pattern - https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html
Outros posts
Regex para aceitar acentos - http://precisoestudarsempre.blogspot.com.br/2013/08/regex-para-aceitar-acentos.html
Nenhum comentário:
Postar um comentário