Como linguagem de programação, Go possui uma ampla variedade de recursos integrados, incluindo a capacidade de criar, ler e gravar arquivos como arquivos de texto (.txt).

Os arquivos são componentes importantes de nossas vidas diárias no mundo moderno. Os arquivos de texto são úteis para armazenar dados estruturados legíveis por humanos sem o uso de software ou bancos de dados externos.

Se você está se perguntando como pode começar a manipular arquivos de texto em Go, este artigo é o lugar certo para você.

O pacote bufio em Go

O bufio O pacote, que faz parte da biblioteca padrão do Go, é usado para operações de entrada e saída em buffer, daí o nome. O bufio pacote baseia-se no io. Leitor e io. Escritor interfaces, que são amplamente utilizadas na implementação da maioria dos pacotes padrão do Go.

O bufio O pacote vai um passo além ao implementar o buffering, tornando-o útil para operações de E/S envolvendo dados textuais.

Para usar o bufio pacote em seu programa, você deve importá-lo junto com outros pacotes.

importar (
"fmt"
"bufio"
)

Você provavelmente ouviu quando você começou com Go que ele vem com tudo o que você poderia precisar como programador. Para comunicação direta com seu sistema operacional, existe um pacote chamado os que fornece funções independentes de plataforma.

O os e bufio Os pacotes tornam a manipulação de arquivos de texto incrivelmente simples.

Embora a grande maioria dos os Como as funções do pacote são semelhantes ao Unix, todas elas empregam o estilo Go de tratamento de erros, o que simplifica a leitura de mensagens de erro e o código de depuração.

Então, como você manipula arquivos contendo texto em Go?

Como ler dados de um arquivo de texto

Para ler dados de arquivos de texto, você precisa chamar o os pacote de Abrir() função, que aceita como parâmetro o nome do arquivo a ser lido. Outro método para obter o arquivo é usando o método Abrir arquivo() função.

A grande diferença entre Abrir() e Abrir arquivo() está na sua implementação. Abrir() abre um arquivo em modo somente leitura (com o O_RDONLY bandeira), enquanto Abrir arquivo() dá mais flexibilidade ao aceitar três parâmetros, a saber:

  • Nome do arquivo
  • Modo de abertura de arquivo: Os modos de abertura de arquivo válidos são mostrados na tabela abaixo.
    Bandeira Significado
    O_RDONLY Abre o arquivo no modo somente leitura
    O_WRONLY Abre o arquivo no modo somente gravação
    O_RDWR Abre o arquivo no modo de leitura/gravação
    O_APPEND Acrescenta dados ao arquivo ao escrever
    O_CREATE Cria um novo arquivo se não existir nenhum
    O_EXCL Usado com O_CREATE, para indicar que o arquivo só deve ser criado se não existir
    O_SYNC Abre arquivo para E/S síncrona
    O_TRUNC Truncar o arquivo ao abrir, se possível
  • Permissões de arquivo: Igual ao bits de permissão de arquivo no Linux usado para especificar regras de acesso a arquivos, por exemplo, 0777 para conceder permissões de leitura, gravação e execução a todos os tipos de usuário.

O código abaixo mostra como ler dados de um arquivo de texto em Go usando os. Abrir(), e Varredura() que neste caso, roda em um Ir para loop.

pacote principal
importar (
"bufio"
"fmt"
"registro"
"os"
)
/**
 CONTEÚDO DO "arquivo de teste.txt" arquivo.
 lorem ipsum dolor sit amet
 LOREM IPSUM DOLOR SIT AMET
 Lorem ipsum dolor sit amet
 Lorem Ipsum Dolor Sit Amet
 IOREM iPSUM DOLOR SIT AMET
 LoReM IpSuM DoLoR SiT AmEt
*/
função principal(){
 arquivo, erro := os. Abrir("arquivo de teste.txt")
// outro método usando os. Abrir arquivo()
 // arquivo, erro = os. Abrir arquivo("arquivo de teste.txt", os. O_RDONLY, 0644)
 se errar != nil {
registro.Fatal(errar)
 }
adiararquivo.Fechar()
 fmt. Imprimirln("Arquivo aberto com sucesso. Agora lendo o conteúdo do arquivo linha por linha:")
 // criar scanner de o arquivoparalertextode
 scanner := bufio. NewScanner (arquivo)
// escaneia ou lê os bytes do texto linha por linha
parascanner.Varredura() {
fmt.Println(scanner.Texto())
 }
 se errar := scanner. Errar(); erro != nil {
registro.Fatal(errar)
 }
}

Quando você executa o código acima com vá executar filename.go, ele produz a saída mostrada abaixo:

Se você passar apenas o nome do arquivo e não o caminho para o Abrir() ou Abrir arquivo() função para operações de leitura, o Go assume que o arquivo está no diretório atual e retorna um erro se não o encontrar. Você deve passar o caminho para o arquivo se precisar trabalhar com arquivos fora do diretório atual.

Como gravar dados em um arquivo de texto

O bufio pacote fornece um buffer Escritor interface que armazena bytes de dados e os grava em um arquivo com a ajuda de um Rubor() função.

O próximo código de exemplo é uma continuação daquele para ler um arquivo. Neste exemplo, os dados são gravados no arquivo existente arquivo de teste.txt usando o O_WRONLY e O_APPEND bandeiras.

Adicione as seguintes linhas de código ao programa acima, antes da chave de fechamento do principal() função:

// grava os dados de saída no arquivo
arquivo, erro = os. OpenFile("testfile.txt", os. O_APPEND|os. O_WRONLY, 0644)
se erro != nada {
 registro. Fatal (err)
}
adiar arquivo. Fechar()
fmt. Println("Arquivo aberto com sucesso, agora preparando para gravar dados no arquivo...")
// cria um objeto Writer em buffer para gravar dados no arquivo
textWriter := bufio. NewWriter (arquivo)
// escreve string no buffer antes de salvar o arquivo.
_, erro = textWriter. WriteString("-Este é um novo texto adicionado ao arquivo.")
se erro != nada {
 registro. Fatal (err)
}
textWriter. Rubor()
fmt. Println("Dados gravados no arquivo com sucesso...")

A saída do seu programa completo deve ficar assim:

Quando você abre o arquivo de teste.txt arquivo, você também verá a nova linha anexada no final do arquivo, assim como na imagem abaixo:

O manuseio de arquivos em Go é fácil

Go permite que você trabalhe com uma variedade de arquivos, não apenas arquivos de texto. Existem várias bibliotecas e funções incorporadas adicionais para trabalhar com diferentes tipos de dados de arquivos, incluindo JSON e CSV.

Para ver como eles se comportam de maneira diferente dependendo da situação, você pode experimentar os vários sinalizadores e permissões de arquivo disponíveis para uso com Abrir arquivo().