Slackjeff Wiki

Bits que significam

Ferramentas do usuário

Ferramentas do site

Você está aqui: start » utils » ed
utils:ed

Diferenças

Aqui você vê as diferenças entre duas revisões dessa página.

Link para esta página de comparações

Ambos lados da revisão anteriorRevisão anterior
Próxima revisão		Revisão anterior
utils:ed [2025/01/09 22:17] – [Expressões regulares] alerta para falsos positivos hrcerqutils:ed [2025/01/19 13:26] (atual) – [Uma nota sobre alertas] transformado em nota hrcerq
Linha 196: Linha 196:
 Muito bem, já vimos os conceitos principais, agora é hora de um pouco de prática. Vamos começar pelo básico que é iniciar e encerrar o editor __ed__. A propósito, não saber encerrar um editor pode causar um certo pânico, então vamos tratar disso logo. Muito bem, já vimos os conceitos principais, agora é hora de um pouco de prática. Vamos começar pelo básico que é iniciar e encerrar o editor __ed__. A propósito, não saber encerrar um editor pode causar um certo pânico, então vamos tratar disso logo.
  
-Para iniciar o editor __ed__, vamos começar com um exemplo simples, sem abrir nenhum arquivo, apenas iniciar o editor com um //buffer// vazio. Você verá uma linha vazia, na qual um comando pode ser inserido. Então você aprenderá o seu primeiro comando agora, o comando ''q'' (//quit//), que encerra o editor. Nessa linha vazia, digite ''q'', e o editor será encerrado.+Para iniciar o editor __ed__, vamos começar com um exemplo simples, sem abrir nenhum arquivo, apenas iniciar o editor com um //buffer// vazio. Você verá uma linha vazia, na qual um comando pode ser inserido. Então você aprenderá o seu primeiro comando agora, o comando **q** (//quit//), que encerra o editor. Nessa linha vazia, digite **q**, e o editor será encerrado.
  
 <code> <code>
Linha 204: Linha 204:
 </code> </code>
  
-Ufa! Agora você já sabe encerrar o editor, quando precisar. Mas vou além: o comando ''q'' só vai encerrar o editor mesmo se ele não tiver sofrido nenhuma mudança. Se você tiver feito quaisquer alterações no //buffer//, um alerta será emitido e você terá de usar o comando ''q'' novamente para confirmar que deseja encerrar. Outra opção, se tiver conteúdo não salvo que queira descartar é usar o comando ''Q''. Nesse caso nenhum alerta será emitido e ele será prontamente encerrado.+Ufa! Agora você já sabe encerrar o editor, quando precisar. Mas vou além: o comando **q** só vai encerrar o editor mesmo se ele não tiver sofrido nenhuma mudança. Se você tiver feito quaisquer alterações no //buffer//, um alerta será emitido e você terá de usar o comando **q** novamente para confirmar que deseja encerrar. Outra opção, se tiver conteúdo não salvo que queira descartar é usar o comando **Q**. Nesse caso nenhum alerta será emitido e ele será prontamente encerrado.
  
-É importante frisar que digitar ''Ctrl+c'' não encerra o editor. Sinais de interrupção apenas emitem uma mensagem de erro (veremos mais sobre mensagens de erro e alertas depois).+É importante frisar que digitar **Ctrl+c** não encerra o editor. Sinais de interrupção apenas emitem uma mensagem de erro (veremos mais sobre mensagens de erro e alertas depois).
  
-Agora, um outro ponto que é importante aprender desde cedo é sobre a configuração e uso de um //prompt//. Como falei antes, ele é um meio de evitar a confusão entre o modo de comandos e o modo de entrada. Para iniciar o editor já com o uso de um //prompt// você deve usar o parâmetro ''-p'', como a seguir:+Agora, um outro ponto que é importante aprender desde cedo é sobre a configuração e uso de um //prompt//. Como falei antes, ele é um meio de evitar a confusão entre o modo de comandos e o modo de entrada. Para iniciar o editor já com o uso de um //prompt// você deve usar o parâmetro **-p**, como a seguir:
  
 <code> <code>
Linha 218: Linha 218:
 Aqui usei um asterisco seguido de espaço, mas fica a seu critério qual texto acha melhor como //prompt//. Desaconselho o uso de interrogação, pois esse sinal já é usado para emitir mensagens de diagnóstico, e também é útil usar um espaço como último caractere do prompt, para não misturar com o comando. Aqui usei um asterisco seguido de espaço, mas fica a seu critério qual texto acha melhor como //prompt//. Desaconselho o uso de interrogação, pois esse sinal já é usado para emitir mensagens de diagnóstico, e também é útil usar um espaço como último caractere do prompt, para não misturar com o comando.
  
-Para não ter que usar esse parâmetro ''-p'' toda vez que iniciar o __ed__, você pode configurar um //alias// para o ele (dependendo de qual shell utilizar, pode haver variações na forma de fazer isso):+Para não ter que usar esse parâmetro **-p** toda vez que iniciar o __ed__, você pode configurar um //alias// para o ele (dependendo de qual shell utilizar, pode haver variações na forma de fazer isso):
  
 <code> <code>
Linha 226: Linha 226:
 Nos exemplos seguintes partirei da premissa de que o //alias// do exemplo acima está configurado. Nos exemplos seguintes partirei da premissa de que o //alias// do exemplo acima está configurado.
  
-Antes de prosseguir, tenho apenas mais um assunto para comentar sobre //prompts//: você pode, a qualquer momento dentro do editor, desabilitar ou reabilitar o //prompt// com o comando ''P'':+Antes de prosseguir, tenho apenas mais um assunto para comentar sobre //prompts//: você pode, a qualquer momento dentro do editor, desabilitar ou reabilitar o //prompt// com o comando **P**:
  
 <code> <code>
Linha 238: Linha 238:
 Para quê desabilitar o //prompt//? Eu realmente não consigo imaginar um bom motivo, mas caso você tenha se esquecido de configurá-lo previamente, e esteja editando um arquivo, pode ser útil lembrar que ele pode ser ativado a qualquer momento.  Para quê desabilitar o //prompt//? Eu realmente não consigo imaginar um bom motivo, mas caso você tenha se esquecido de configurá-lo previamente, e esteja editando um arquivo, pode ser útil lembrar que ele pode ser ativado a qualquer momento. 
  
-Apenas tenha em mente que por padrão o prompt usado é um asterisco (''*'') sem um espaço depois, o que visualmente pode causar algum desconforto por misturar o //prompt// ao comando, então é mais interessante configurá-lo antes de iniciar o editor, como apontei antes.+Apenas tenha em mente que por padrão o prompt usado é um asterisco (*****) sem um espaço depois, o que visualmente pode causar algum desconforto por misturar o //prompt// ao comando, então é mais interessante configurá-lo antes de iniciar o editor, como apontei antes.
 ===== Abrindo e trocando de arquivos ===== ===== Abrindo e trocando de arquivos =====
  
Linha 277: Linha 277:
 "Espere! Nome do arquivo memorizado? Como assim?" Já imagino que esteja se perguntando. Lembra-se do conceito de nome de arquivo que expliquei antes? Pois bem, ao carregar um arquivo, o __ed__ memoriza o nome dele, para que futuras escritas no //buffer// possam ser feitas sem que você precise informar novamente esse nome como parâmetro. "Espere! Nome do arquivo memorizado? Como assim?" Já imagino que esteja se perguntando. Lembra-se do conceito de nome de arquivo que expliquei antes? Pois bem, ao carregar um arquivo, o __ed__ memoriza o nome dele, para que futuras escritas no //buffer// possam ser feitas sem que você precise informar novamente esse nome como parâmetro.
  
-Ao iniciar o editor com um //buffer// vazio, essa informação não existe. Porém, ao iniciar com um arquivo, ou ao carregar um arquivo, como feito nos exemplos anteriores, essa informação é preenchida, com o nome do arquivo carregado (neste exemplo, "poema_ed.txt").+Ao iniciar o editor com um //buffer// vazio, essa informação não existe. Porém, ao iniciar com um arquivo, ou ao carregar um arquivo, como feito nos exemplos anteriores, essa informação é preenchida, com o nome do arquivo carregado (neste exemplo, //poema_ed.txt//).
  
 Para visualizar o nome memorizado, usamos o comando **f**. Um erro será emitido se o nome não estiver preenchido ainda. Para visualizar o nome memorizado, usamos o comando **f**. Um erro será emitido se o nome não estiver preenchido ainda.
Linha 373: Linha 373:
  
  
-==== Uma nota sobre alertas ==== +<note important> 
- +**Atenção**\\ 
-No __ed__, há uma diferença sutil entre erros e alertas. Os alertas são emitidos quando você pode perder dados do //buffer// por fechar o editor ou carregar algum outro arquivo. Como mostrei no exemplo anterior, se você insistir em uma ação desse tipo, o __ed__ entenderá que você sabe o que está fazendo e não entrará no seu caminho. +\\ 
- +No __ed__, há uma diferença sutil entre erros e alertas. Os alertas são emitidos quando você pode perder dados do //buffer// por fechar o editor ou carregar algum outro arquivo. Como mostrei no exemplo anterior, se você insistir em uma ação desse tipo, o __ed__ entenderá que você sabe o que está fazendo e não entrará no seu caminho.\\ 
-Mas há uma detalhe que pode te pegar de surpresa: depois que o __ed__ emite o alerta de que o //buffer// foi alterado, ele considera que o alerta já foi dado. Se você continuar a editar o //buffer// depois disso e mais tarde resolver fechar o editor, ele não emitirá outro alerta e encerrará. +\\ 
 +Mas há uma detalhe que pode te pegar de surpresa: depois que o __ed__ emite o alerta de que o //buffer// foi alterado, ele considera que o alerta já foi dado. Se você continuar a editar o //buffer// depois disso e mais tarde resolver fechar o editor, ele não emitirá outro alerta e encerrará.\\ 
 +\\
 Portanto, é uma boa prática salvar as modificações feitas logo depois do alerta, caso realmente queira salvar. Mais à frente veremos como modificar um arquivo e como salvar modificações. Quando você salva o conteúdo do //buffer// o __ed__ volta a considerar que precisa te alertar, se houver mais modificações e você tentar executar outra ação que possa ocasionar perda. Portanto, é uma boa prática salvar as modificações feitas logo depois do alerta, caso realmente queira salvar. Mais à frente veremos como modificar um arquivo e como salvar modificações. Quando você salva o conteúdo do //buffer// o __ed__ volta a considerar que precisa te alertar, se houver mais modificações e você tentar executar outra ação que possa ocasionar perda.
 +</note>
 ===== Indo e voltando ===== ===== Indo e voltando =====
  
Linha 963: Linha 965:
 ===== Substituindo texto ===== ===== Substituindo texto =====
  
-Vamos voltar a falar sobre comandos que alteram o conteúdo do //buffer//. Já tínhamos visto o comando ''c'', que altera todo o conteúdo da linha (ou das linhas) pelo texto fornecido. Isso resolve muita coisa, mas às vezes pode ser pouco prático. Em alguns casos, você só quer substituir alguns caracteres dentro de uma linha, um ajuste mais pontual.+Vamos voltar a falar sobre comandos que alteram o conteúdo do //buffer//. Já tínhamos visto o comando **c**, que altera todo o conteúdo da linha (ou das linhas) pelo texto fornecido. Isso resolve muita coisa, mas às vezes pode ser pouco prático. Em alguns casos, você só quer substituir alguns caracteres dentro de uma linha, um ajuste mais pontual.
  
-Nesse caso, usamos o comando ''s'', que opera "dentro" das linhas. No ed, ao contrário de editores de texto visuais, não existe a noção de posição do cursor dentro de uma linha. Não avançamos ou retrocedemos entre caracteres de uma linha, pois a noção de posição está restrita a linhas.+Nesse caso, usamos o comando **s**, que opera "dentro" das linhas. No __ed__, ao contrário de editores de texto visuais, não existe a noção de posição do cursor dentro de uma linha. Não avançamos ou retrocedemos entre caracteres de uma linha, pois a noção de posição está restrita a linhas.
  
-Porém, com o auxílio de expressões regulares, podemos determinar qual (ou quais) caracteres serão editados dentro da linha. Podemos usar uma expressão que abrange toda a linha também (''^.*$''), mas nesse caso faria mais sentido usar o comando ''c'', provavelmente.+Porém, com o auxílio de expressões regulares, podemos determinar qual (ou quais) caracteres serão editados dentro da linha. Podemos usar uma expressão que abrange toda a linha também (**^.*$**), mas nesse caso faria mais sentido usar o comando **c**, provavelmente.
  
-A estrutura do comando ''s'' é um pouco diferente dos comandos que vimos até aqui. Nele, informamos primeiro um termo a ser pesquisado dentro da linha, depois o termo que o substituirá (podendo ser vazio), e ao fim podemos anexar um comando de visualização (''p'', ''l'' ou ''n''), para ver o resultado da substituição.+A estrutura do comando **s** é um pouco diferente dos comandos que vimos até aqui. Nele, informamos primeiro um termo a ser pesquisado dentro da linha, depois o termo que o substituirá (podendo ser vazio), e ao fim podemos anexar um comando de visualização (**p**, **l** ou **n**), para ver o resultado da substituição.
  
 Esses três argumentos (termo pesquisado, texto substituto e comando de visualização) são geralmente separados por barras. Então temos a seguinte estrutura: Esses três argumentos (termo pesquisado, texto substituto e comando de visualização) são geralmente separados por barras. Então temos a seguinte estrutura:
Linha 977: Linha 979:
 </code> </code>
  
-O comando ''s'' é muito versátil. Ele pode ser usado tanto para adicionar conteúdo novo (sem remover nada), substituir algo, ou apenas remover uma parte da linha (sem adicionar nada no lugar). Vejamos um exemplo de remoção. Se reparar no programa ''area.c'' (e tiver conhecimento de C), há uma linha com um erro lógico, a linha 22. Nela, temos uma função ''printf'' com um argumento sobrando (''raio''). Vamos tratar de arrumar isso.+O comando **s** é muito versátil. Ele pode ser usado tanto para adicionar conteúdo novo (sem remover nada), substituir algo, ou apenas remover uma parte da linha (sem adicionar nada no lugar). Vejamos um exemplo de remoção. Se reparar no programa //area.c// (e tiver conhecimento de C), há uma linha com um erro lógico, a linha 22. Nela, temos uma função **printf** com um argumento sobrando (//raio//). Vamos tratar de arrumar isso.
  
 <code> <code>
Linha 986: Linha 988:
 </code> </code>
  
-O que aconteceu aqui? Na linha 22, usei o comando ''s'' para procurar pelo termo "raio, " (note o espaço ao fim), e substituí-lo por nada (daí o motivo de haver duas barras consecutivas), e por fim uso o comando ''p'' para mostrar o resultado da substituição.+O que aconteceu aqui? Na linha 22, usei o comando **s** para procurar pelo termo "raio, " (note o espaço ao fim), e substituí-lo por nada (daí o motivo de haver duas barras consecutivas), e por fim uso o comando **p** para mostrar o resultado da substituição.
  
-E se eu quiser substituir várias linhas de uma vez só, é possível? Sim. Por exemplo, talvez eu pense que o nome da função ''area_do_circulo'' é mais longa do que o necessário e queira trocar todas as suas ocorrências por ''area_circulo''. Simples:+E se eu quiser substituir várias linhas de uma vez só, é possível? Sim. Por exemplo, talvez eu pense que o nome da função //area_do_circulo// é mais longa do que o necessário e queira trocar todas as suas ocorrências por //area_circulo//. Simples:
  
 <code> <code>
Linha 996: Linha 998:
 </code> </code>
  
-"Mas pode isso?" Claro que pode. As linhas que não possuem o termo ''area_do_circulo'' apenas ignoram a instrução, enquanto as que possuem fazem a alteração instruída. Note que eu omiti o comando de visualização, e ao omitir também a barra que antecede o comando, o ed entende que deve executar a ação padrão (''p''), porém apenas a última linha alterada é exibida.+"Mas pode isso?" Claro que pode. As linhas que não possuem o termo ''area_do_circulo'' apenas ignoram a instrução, enquanto as que possuem fazem a alteração instruída. Note que eu omiti o comando de visualização, e ao omitir também a barra que antecede o comando, o __ed__ entende que deve executar a ação padrão (**p**), porém apenas a última linha alterada é exibida.
  
-Lembrando mais uma vez, a vírgula que antecede o comando, na prática equivale a ''1,$''. Eu poderia definir qualquer intervalo de linhas para passar por esse processo, não necessariamente o //buffer// inteiro.+Lembrando mais uma vez, a vírgula que antecede o comando, na prática equivale a **1,$**. Eu poderia definir qualquer intervalo de linhas para passar por esse processo, não necessariamente o //buffer// inteiro.
  
 Enfim, vamos salvar o arquivo com as modificações que fizemos até aqui. Enfim, vamos salvar o arquivo com as modificações que fizemos até aqui.
Linha 1011: Linha 1013:
 Se eu quisesse mostrar a alteração de cada uma das linhas, seria possível também, mas para isso teria que usar um comando global, assunto que ainda vamos explorar. Se eu quisesse mostrar a alteração de cada uma das linhas, seria possível também, mas para isso teria que usar um comando global, assunto que ainda vamos explorar.
  
-O comando ''s'' é seu principal aliado no momento de remover os caracteres de controle inseridos acidentalmente:+O comando **s** é um grande aliado no momento de remover os caracteres de controle inseridos acidentalmente:
  
 <code> <code>
Linha 1031: Linha 1033:
 </code> </code>
  
-No comando de substituição demonstrado acima, removemos quais quer ocorrências de quaisquer caracteres de controle (classe ''cntrl''), em qualquer quantidade, e ao fim do comando usamos o sufixo ''g'', que significa que a substituição será refeita para toda ocorrência dentro da linha (do contrário, a substituição se limitaria à primeira ocorrência de cada linha).+No comando de substituição demonstrado acima, removemos quaisquer ocorrências de quaisquer caracteres de controle (classe **cntrl**), em qualquer quantidade, e ao fim do comando usamos o sufixo **g**, que significa que a substituição será refeita para toda ocorrência dentro da linha (do contrário, a substituição se limitaria à primeira ocorrência de cada linha).
  
-Note que após a substituição, os caracteres de controle não aparecem nem mesmo após exibir a linha de modo inequívoco, com '',l''.+<note warning> 
 +**Cuidado!**\\ 
 +\\ 
 +Como alertei antes, caracteres de tabulação se enquadram na classe **cntrl**, portanto evite fazer esse tipo de substituição irrestrita quando houver tabulações que queira preservar.\\ 
 +\\ 
 +Nestes casos será mais interessante fazer substituições pontuais. Comandos globais interativos (explicado mais adiante) também podem ajudar nesses casos. 
 +</note> 
 + 
 +Note no exemplo acima que após a substituição, os caracteres de controle não aparecem nem mesmo após exibir a linha de modo inequívoco, com **,l**.
  
 Do mesmo modo, o comando de substituição pode servir para eliminar os espaços sobrando no fim da linha: Do mesmo modo, o comando de substituição pode servir para eliminar os espaços sobrando no fim da linha:
Linha 1060: Linha 1070:
 </code> </code>
  
-Agora, usamos a classe ''blank'' para remover quaisquer espaços vazios em qualquer quantidade, que antecedam o fim da linha. Nesse caso não é necessário usar o sufixo ''g'', pois a pesquisa está ancorada no fim da linha (''$''), isto é, só há um fim de linha por linha. E nesse caso é importante que haja essa âncora, pois do contrário removeria todos os espaços no arquivo, independente da posição.+Agora, usamos a classe **blank** para remover quaisquer espaços vazios em qualquer quantidade, que antecedam o fim da linha. Nesse caso não é necessário usar o sufixo **g**, pois a pesquisa está ancorada no fim da linha (**$**), isto é, só há um fim de linha por linha. E nesse caso é importante que haja essa âncora, pois do contrário removeria todos os espaços no arquivo, independente da posição.
  
-No lugar do sufixo ''g'', podemos usar também um número inteiro, caso quiséssemos substituir a //n-ésima// ocorrência (caso haja; se não houver, um erro é retornado), onde N é o número informado.+No lugar do sufixo **g**, podemos usar também um número inteiro, caso quiséssemos substituir a //n-ésima// ocorrência (caso haja; se não houver, um erro é retornado), onde N é o número informado.
  
 <code> <code>
Linha 1076: Linha 1086:
 </code> </code>
  
-Ainda sobre substituições, lembra-se quando eu disse que a estrutura do comando ''s'' //geralmente// é separada por barras? Pois então, geralmente mas nem sempre. Se você precisar substituir algum texto que possua barras dentro dele, talvez fique desconfortável ou confuso.+Ainda sobre substituições, lembra-se quando eu disse que a estrutura do comando **s** //geralmente// é separada por barras? Pois então, geralmente mas nem sempre. Se você precisar substituir algum texto que possua barras dentro dele, talvez fique desconfortável ou confuso.
  
 Imagine, por exemplo, substituir um texto que representa caminhos em um sistema de arquivos (sendo que no UNIX os diretórios são separados por barras). Facilmente você se confundiria, ou na melhor das hipóteses, teria que adicionar uma barra invertida para cada uma das barras do texto, para que sejam tratadas literalmente. Imagine, por exemplo, substituir um texto que representa caminhos em um sistema de arquivos (sendo que no UNIX os diretórios são separados por barras). Facilmente você se confundiria, ou na melhor das hipóteses, teria que adicionar uma barra invertida para cada uma das barras do texto, para que sejam tratadas literalmente.
  
-Por isso, podemos usar outros caracteres no lugar da barra. Por exemplo, você pode preferir, em alguns casos, usar o caractere //pipe// (''|''), ou talvez um ponto de exclamação (''!'').+Por isso, podemos usar outros caracteres no lugar da barra. Por exemplo, você pode preferir, em alguns casos, usar o caractere //pipe// (**|**), ou talvez um ponto de exclamação (**!**).
  
 Exemplo: Exemplo:
Linha 1871: Linha 1881:
 Eu havia comentado brevemente sobre a integração do __ed__ com os comandos do sistema. Vamos detalhar como isso funciona. Sendo o editor padrão do UNIX, seria até estranho que ele não tirasse vantagem dos demais comandos disponíveis no sistema. É parte da filosofia UNIX, afinal. É nessa integração que reside o maior potencial do editor, pois qualquer comando disponível no sistema pode ser utilizado dentro do ed. Eu havia comentado brevemente sobre a integração do __ed__ com os comandos do sistema. Vamos detalhar como isso funciona. Sendo o editor padrão do UNIX, seria até estranho que ele não tirasse vantagem dos demais comandos disponíveis no sistema. É parte da filosofia UNIX, afinal. É nessa integração que reside o maior potencial do editor, pois qualquer comando disponível no sistema pode ser utilizado dentro do ed.
  
-Para executar comandos do sistema no __ed__, usamos o comando ''!''. Por exemplo:+Para executar comandos do sistema no __ed__, usamos o comando **!**. Por exemplo:
  
 <code> <code>
Linha 1889: Linha 1899:
 E você não precisa se restringir apenas aos comandos padrão do sistema. Qualquer comando disponível e que funcionaria normalmente no shell pode ser usado dessa forma. E você não precisa se restringir apenas aos comandos padrão do sistema. Qualquer comando disponível e que funcionaria normalmente no shell pode ser usado dessa forma.
  
-<note> +<note warning> 
-Não use o comando __cd__ no lançador de comandos do __ed__. Isto não surtirá o efeito que você possivelmente espera. Os comandos são executados em um contexto isolado, então a troca de diretórios ocorreria em uma nova sessão, que encerraria logo em seguida, e para todos os efeitos você continua no mesmo diretório de antes (use o __pwd__ e verá que não houve alteração alguma). Em outras palavras, não há persistência de contexto entre a execução dos comandos do sistema no __ed__.+**Não se iluda!**\\ 
 +\\ 
 +Usar o comando __cd__ no lançador de comandos do __ed__ não surtirá o efeito que você possivelmente espera. Os comandos são executados em um contexto isolado, então a troca de diretórios ocorreria em uma nova sessão, que encerraria logo em seguida, e para todos os efeitos você continua no mesmo diretório de antes.\\ 
 +\\ 
 +Se duvida, compare a saída de __pwd__ antes e depois de executar __cd__ e verá que não houve alteração alguma. Em outras palavras, não há persistência de contexto entre a execução dos comandos do sistema no __ed__.
 </note> </note>
  
-Se quiser repetir o último comando utilizado, basta usar o atalho ''!!'' (duas exclamações).+Se quiser repetir o último comando utilizado, basta usar o atalho **!!** (duas exclamações).
  
 <code> <code>
Linha 1903: Linha 1917:
 </code> </code>
  
-Nesse caso, como houve uma substituição no comando (isto é, do comando fornecido, ''!!'' pelo comando efetivo, ''ls''), ele é exibido logo antes de ser executado, para que você possa ter certeza de qual foi o comando executado.+Nesse caso, como houve uma substituição no comando (isto é, do comando fornecido, **!!** pelo comando efetivo, **ls**), ele é exibido logo antes de ser executado, para que você possa ter certeza de qual foi o comando executado.
  
-Podemos também usar o sinal de percentual (''%'') em comandos como referência ao nome de arquivo memorizado. Isso pode ser útil, por exemplo quando estamos editando um arquivo-fonte e queremos então acionar um compilador ou interpretador para testá-lo logo em seguida. Nesse caso, é necessário salvar o conteúdo do //buffer// antes de acionar o comando.+Podemos também usar o sinal de percentual (**%**) em comandos como referência ao nome de arquivo memorizado. Isso pode ser útil, por exemplo quando estamos editando um arquivo-fonte e queremos então acionar um compilador ou interpretador para testá-lo logo em seguida. Nesse caso, é necessário salvar o conteúdo do //buffer// antes de acionar o comando.
  
 <code> <code>
Linha 1920: Linha 1934:
 </code> </code>
  
-Veja que nesse caso sinal de percentual foi substituído por ''area.c'', e tal como no caso anterior, o comando é exibido logo antes da execução, por ter havido uma substituição, nesse caso, do nome de arquivo. Esse é um programa simples, então apenas compilei e executei. Mas poderia, em um programa mais complexo, acionar o comando __make__ ou qualquer que fosse o comando de construção do programa.+Veja que nesse caso sinal de percentual foi substituído por //area.c//, e tal como no caso anterior, o comando é exibido logo antes da execução, por ter havido uma substituição, nesse caso, do nome de arquivo. Esse é um programa simples, então apenas compilei e executei. Mas poderia, em um programa mais complexo, acionar o comando __make__ ou qualquer que fosse o comando de construção do programa.
  
 Igualmente, poderia estar manipulando o código de um programa interpretado, e então acionar o interpretador para testá-lo. E para além disso, poderia estar manipulando outros tipos de arquivos, como logs, por exemplo, e usando um comando externo como __awk__ ou __sed__ para interpretar o arquivo segundo alguma regra definida. Igualmente, poderia estar manipulando o código de um programa interpretado, e então acionar o interpretador para testá-lo. E para além disso, poderia estar manipulando outros tipos de arquivos, como logs, por exemplo, e usando um comando externo como __awk__ ou __sed__ para interpretar o arquivo segundo alguma regra definida.
utils/ed.1736471851.txt.gz · Última modificação: 2025/01/09 22:17 por hrcerq