0Pricing
Go Academy · Aula

Transmissão de arquivos grandes

Processe arquivos sem carregar tudo

Transmissão de arquivos grandes é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

O problema de carregar tudo

Ler um arquivo de vários gigabytes na memória com os.ReadFile pode esgotar a RAM. Em vez disso, processe-o em fluxo: processe os blocos à medida que chegam.

Conceito de processamento em fluxo

Processar em fluxo significa manter apenas uma pequena janela de dados na memória por vez. Combinado com o uso de memória intermediária, isso permite processar entradas de tamanho arbitrário usando memória constante.

Linha por linha com Scanner

Para texto, um bufio.Scanner sobre um leitor processa uma linha por vez, independentemente do tamanho do arquivo. Aqui, simulamos um arquivo com um strings.Reader.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	src := strings.NewReader("alpha\nbeta\ngamma")
	s := bufio.NewScanner(src)
	for s.Scan() {
		fmt.Println("processed:", s.Text())
	}
}

Contando sem carregar tudo

Você pode calcular estatísticas sobre um fluxo enorme mantendo quase nada na memória.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	s := bufio.NewScanner(strings.NewReader("a\nbb\nccc"))
	total := 0
	for s.Scan() {
		total += len(s.Text())
	}
	fmt.Println("total chars:", total)
}

Blocos de tamanho fixo

Para dados binários, leia em uma memória intermediária fixa usando Read. n informa quantos bytes foram preenchidos.

package main

import (
	"fmt"
	"io"
	"strings"
)

func main() {
	src := strings.NewReader("0123456789")
	buf := make([]byte, 4)
	for {
		n, err := src.Read(buf)
		if n > 0 {
			fmt.Printf("chunk: %s\n", buf[:n])
		}
		if err == io.EOF {
			break
		}
	}
}

io.Copy para processamento em fluxo

io.Copy(dst, src) transmite tudo de um leitor para um gravador usando uma pequena memória intermediária interna — sem carregar tudo.

package main

import (
	"io"
	"os"
	"strings"
)

func main() {
	src := strings.NewReader("streamed straight through\n")
	io.Copy(os.Stdout, src)
}

Combinando memórias intermediárias de leitura e gravação

Envolva as duas extremidades em bufio para obter transformações eficientes em fluxo: leitura com memória intermediária, processamento, gravação com memória intermediária e descarregamento.

package main

import (
	"bufio"
	"os"
	"strings"
)

func main() {
	r := bufio.NewScanner(strings.NewReader("one\ntwo"))
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	for r.Scan() {
		w.WriteString(r.Text() + "!\n")
	}
}

Garantia de memória constante

Como o tamanho da memória intermediária é fixo, o uso de memória permanece constante, seja a entrada de 1KB ou de 1TB. Essa é a principal vantagem do processamento em fluxo.

Evitando erros comuns

  • Não chame os.ReadFile para arquivos enormes
  • Trate sempre os n bytes antes de verificar o erro
  • Lembre-se de chamar Flush() para gravadores com memória intermediária

Transformando um fluxo

Aqui, convertemos cada linha para letras maiúsculas à medida que ela passa pelo fluxo, mantendo apenas uma linha na memória por vez.

package main

import (
	"bufio"
	"os"
	"strings"
)

func main() {
	s := bufio.NewScanner(strings.NewReader("hi\nthere"))
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	for s.Scan() {
		w.WriteString(strings.ToUpper(s.Text()) + "\n")
	}
}

Quando processar em fluxo

Processe em fluxo quando o tamanho da entrada for grande ou desconhecido, ou quando puder processá-la incrementalmente. Carregue tudo apenas para dados pequenos e limitados que você precise ter por completo de uma vez.

Verificação rápida

Verifique seus conhecimentos sobre processamento em fluxo.

Recapitulação

Você aprendeu a processar dados grandes sem carregá-los por completo.

  • Scanner para texto linha por linha
  • Read de tamanho fixo para blocos binários
  • io.Copy para transferências de um fluxo para outro
  • Memória intermediária nas duas extremidades, gravadores descarregados e memória constante

Perguntas Frequentes

A aula “Transmissão de arquivos grandes” é grátis?

Sim — o texto completo de “Transmissão de arquivos grandes” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Transmissão de arquivos grandes”?

Processe arquivos sem carregar tudo Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Transmissão de arquivos grandes”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Leitores com buffer
  2. Scanners
  3. Gravadores com buffer
  4. Transmissão de arquivos grandes
← Voltar para Go Academy