Como pegar 1ª e última linha de um arquivo ?

Cacilda @eldermarco rsrs :)
Neste caso você usou o cat e carregou o arquivo inteiro no memória. Neste momento passou a tratar o arquivo ?

Deixa eu ser mais claro. Se possível ler aqui antes: http://www.vivaolinux.com.br/topico/Shell-Script/Melhores-comandos-para-tarefa-de-monitoramento./

Vários arquivos envolvidos neste monitoramento tem 5.000 linhas por padrão. Se você falar que qualquer comando vai carregar sempre os arquivos 100% em memória e não usar algum tipo de ponteiro, acho que o sed pode ser a saída ideal.

Você já percebeu a função que preciso executar e o retorno.

Qualquer ajuda é bem vinda :)

@eldermarco A solução com sed já está se mostrando ser melhor, veja os tempos.
Ambos usando funções:

usando head e tail (sem funcionar corretamente) real 0.089 user 0.000 sys 0.000 pcpu 0.12
usando sed (funcionando correto ) real 0.022 user 0.000 sys 0.000 pcpu 0.04

Que diferença animal rsrs :)

A escolha dos comandos pode fazer uma diferença enorme no trabalho final.
Sugestões ?

oops, com o sed não consigo pegar as últimas duas linhas do final, só a última. tem algum macete ?

O sed é um editor de fluxos de texto. É muito bom, mas dependendo da situação, pode ser melhor usar outros. Nesse caso, ele parece ser melhor mesmo.

Para imprimir um intervalo de linhas no sed, você pode fazer:

$ sed -n '1,5 p' arquivo.txt

E ele irá imprimir da linha 1 até a linha 5. Se quiser imprimir da linhas 1 a 5 e depois da linhas 7 a 9, poderia fazer:

$ sed -n -e '1,5 p' -e '7,9 p' arquivo.txt

Se quiser imprimir apenas as linhas que contém a palavra Bel (mesmo que faça parte de outra palavra) faça:

$ sed -n '/Bel/ p' arquivo.txt

E assim segue. Isso é apenas o básico sed. Ele também pode imprimir as n últimas linhas de um arquivo, mas infelizmente não saberia te dizer como, já que no que diz respeito ao sed, ainda sou também um aprendiz =]

Creio que uma pesquisada a respeito poderá lhe ajudar. Para pegar a primeira e a última, é como já te passei. Para referenciar a última linha, você usa um $, como eu fiz.

Pois é :)
No caso, para pegar a 1ª e última linha eu já cheguei a conclusão que vai ser de sed porque o rendimento dele é animal comparado com os demais.
Já para pegar as últimas duas linhas do final ainda tô pesquisando rrs. Sem sucesso por enquanto.

Acho que se for preciso pegar mais de uma linha do final, vou usar o tail que parece ser especializado para esta tarefa.

Continuo aguardando novas sugestões. :)

Para pegar as primeiras duas linhas o sed consegue ser mais rápido que o head. Se outros puderem confirmar seria bom.

Para pegar as últimas, você pode fazer assim:

$ sed -e :a -e '$q;N;3,$D;ba' teste.txt
09. Gardineu Marques
10. Romário Belleza

Isso pega as duas últimas linhas do arquivo. Só substituir o 3 pelo números de linhas que você quer pegar mais um.

EDIT: Ops, tirei daqui:

http://sed.sourceforge.net/local/docs/emulating_unix.txt

eita! eu nunca tinha me preocupado muito com sed e agora vejo que e é muito bom.... de cara a resposta do @eldermarco pra min foi a mais plausível... com base nesse tópico vou tomar vergonha na cara e aprender a usar o sed ( dei uma lida por cima e vi que antigamente os programadores usavam o sed e o ed pra editar seus arquivos fontes, imagino como era dolorido programar naquela época rsrsrsr) bom é osso ai... vivendo, programando e aprendendo... falowww

Senhores, não tenho boas notícias para relatar sobre o sed com arquivos grandes.

Estou fazendo um script tipo lib que irá fazer os testes de units para alguns tipos de comandos com comparativos.
O danado será sh_unit.sh e irá pegar alguns mini-scripts / comandos e executar em um ambiente controlado x mil vezes para tomar os tempos de processamento, memória e I/O.

Hoje foi meio corrido mas de cara com um arquivo de 20.000 linhas o sed abriu o bico.

Estou montando testes de 100.000 interações e vou reportar a solução em breve e fechar este tópico.

Obrigado a todos que ajudaram, mas a saída será ler início com sed e final com tail.

Quando retornar com os testes irão entender e poderão até questionar o que estou constatando.

Igual esta música: http://www.youtube.com/watch?v=uEBOiQ9ss0w

Pode ser assim:
awk -v linha=1 -F "\n" 'NR<=linha{ print }END{ print }' arquivo.txt

Pode ser assim tb:
awk -v linha=2 -F "\n" 'NR<=linha{ print }END{ print }' arquivo.txt

hi @foxbit3r , a opção em awk funciona bem para pegar as primeiras linhas e a última.
carece do mesmo problema do sed para dar um retorno rápido e aceitável.

Em uma única interação em um arquivo de 20.000 linhas gastou:

real 0.025 user 0.010 sys 0.000 pcpu 40.58

Acho que o "problema", tanto com o sed quanto com o awk é que eles processam as linhas sempre se cima para baixo e esquerda para a direita. Eles não sabem qual é a última linha até que cheguem nela. No caso so sed, acho que ele ainda consome mais memória para retornar as últimas linhas. Pode ser que nesse caso, o tail seja melhor para pegar as últimas linhas.

No entanto, verifique se realmente faz tanta diferença assim o desempenho em termos práticos. Um script que demore 0.01 s para ser executado e outro que demore 0.1 s, não faz diferença na prática, por exemplo. Nesse intervalo de tempo não dá nem pra piscar os olhos.. da mesma maneira, 1 min a mais ou a menos pode não ser um problema também. Depende muito do que se está fazendo.

Veja se agora melhora.


awk -F "\n" -v line=1 -v lastLine=2 '
function ultimaLinha(lastLine){
strCmd=sprintf("%s\t%s\t%s","tail -n",lastLine,FILENAME)
system(strCmd)
}

{
if(NR>line){
exit
}
print
}
END{
ultimaLinha(lastLine)
}' arquivo.txt

@foxbit3r Melhorou e muito :)

====================================
time ./pegalinhas_awk.sh
-rw-r--r-- 1 administrador administrador 50414 2011-08-17 10:19 adminusuaruis.sh
-rwxr-xr-x 1 penultimaador administrador 168 2011-08-12 15:50 teste.sh
-rw-r--r-- 1 ultimastrador administrador 2924 2011-08-29 07:26 transfer_copy.sh
real 0.011 user 0.000 sys 0.000 pcpu 0.00
====================================

Em uma interação com o arquivo de 20.000 linhas.

Sua técnica (POG) foi muito interessante :) E depois o pessoal fala que eu sou chegado em uma gambiarra. Sou totalmente a favor de uma boa POG se ela faz redução no processamento e de I/O em 70% :)

A solução que encontrei para ESTE caso em especial foi:

1 - Com head pego as 5 primeiras linhas. (( time head -n 5 lidos.txt ))
2 - Com tail eu pego as últimas 2 linhas. ((time tail -n 2 lidos.txt ))
3 - Arquivo tem 20.000 linhas.

Tempo total de ambos processos + salvamento das infos:
real 0.004 user 0.000 sys 0.000 pcpu 0.00

O melhor rendimento só consegui fazendo em separado. 0.001 do tail. 0.002 do head e 0.001 para gravar o arquivo.
Quando ajustar a função que faz os testes de unidades vou colocar em outro tópico.

Em 100.000 processamentos que será o equivalente a 5% de minha necessidade diária, o ganho de tempo em relação a segunda melhor opção é de 60%. Se alguém quiser testar e comprovar, veja todas as soluções que os colegas forneceram até então.
O único caso foi o do @foxbit3r que fez um truque legal usando o tail combinado :) e assim tem um retorno na casa de 0.013 no processo completo. Mesmo assim fica próximo aos 50% de diferença.
Em horas de processamento e acesso a disco, irei economizar pelo menos 30% da máquina. Se desejar, 4 horas para ser mais correto.