Aula 7 - Lendo múltiplas linhas | Go: a linguagem do Google

Pessoal, estou tentando seguir a aula em questão e como o pacote io/ioutil foi deprecado... a orientação é o uso do pacote OS para navegarmos dentro de estruturas de arquivos e fazer a leitura.

Mas estou com uma dúvida aqui quanto a ler o arquivo até o chamado "EOF" ou end-of-file.... fim do arquivo.

Eu executei o código a seguir e logo quando faço o comando go run nomedoarquivo.go ele aparece apenas os sites do arquivo que passei... mas eu chego no final dele com a clausula a seguir

    if err != nil {
            //fmt.Println("Ocorreu um erro:",err)
            break
        }

Na aula existe um comando (abaixo), mas não sei seu equivalente quando uso o package OS. Alguem sabe?

    if err== io.EOF {
            break
            }

Código que usei abaixo

package main

import ( "fmt" "net/http" "os" "time" "bufio" "strings" ) const monitoramentos = 2 const delay = 3 func main() { exibeIntroducao() leSitesdoArquivo() for { exibeMenu()

    comando := leComando()
    switch comando {
    case 1:
        iniciarMonitoramento()
        
    case 2:
        fmt.Println("Exibindo Logs...")
    case 0:
        fmt.Println("Saindo do programa...")
        os.Exit(0)
    default:
        fmt.Println("Não conheço este comando!")
        os.Exit(-1)
    }
}

}

func exibeIntroducao() { nome := "Rafael" versao := 1.1 fmt.Println("Olá, Sr.", nome) fmt.Println("Este programa está na versão", versao) }

func leComando() int { var comandoLido int fmt.Scan(&comandoLido) fmt.Println("O endereço da variavel comando é ", &comandoLido) fmt.Println("O comando escolhido foi", comandoLido) return comandoLido }

func exibeMenu(){ fmt.Println("1- Iniciar Monitoramento") fmt.Println("2- Exibir Logs") fmt.Println("0- Sair do Programa") }

func iniciarMonitoramento() { fmt.Println("Monitorando...") //sites := []string {"https://www.alura.com.br","https://www.google.com.br","https://www.amazon.com.br","https://www.caelum.com.br"}

sites := leSitesdoArquivo()

//fmt.Println(sites)
for i:=0; i<monitoramentos ;i++{
//for i:=0; i < len(sites); i++{
    for i, site := range sites{
        fmt.Println("Testando Site", i, " :", site)
        testaSite(site)

    }
    time.Sleep(delay *time.Second)
    fmt.Println(" ")
}	
fmt.Println(" ")

// site com URL inexistente
//site := "https://www.alura.com.br" // ou 200

}

func testaSite(site string){ resp, err := http.Get(site)

if err != nil {
   fmt.Println("ocorreu um erro:", err)	
}

if resp.StatusCode == 200 {
    fmt.Println("Site:", site, "foi carregado com sucesso!")
} else {
    fmt.Println("Site:", site, "está com problemas. Status Code:", resp.StatusCode)
}

}

func leSitesdoArquivo() [] string{

var sites [] string

arquivo, err := os.Open("sites.txt")
if err != nil {
    fmt.Println("Ocorreu um erro", err)
    
}

leitor := bufio.NewReader(arquivo)
for{
    linha, err := leitor.ReadString('\n')
    linha = strings.TrimSpace(linha)

    sites = append(sites, linha)

    if err != nil {
            //fmt.Println("Ocorreu um erro:",err)
            break
        }
        fmt.Println(linha)
    }

return sites }

E aí!

No caso do pacote OS, você não tem a constante io.EOF diretamente, mas pode usar uma abordagem diferente para verificar o final do arquivo.

No seu código atual, você já está verificando o erro durante a leitura do arquivo. Quando o arquivo chega ao final, o erro retornado é diferente de nil.

linha, err := leitor.ReadString('\n')

if err != nil {
    break
}

Se você quiser saber especificamente se atingiu o final do arquivo, você pode usar a constante io.EOF do pacote io. No entanto, já que você está usando bufio.NewReader, você pode usar io.EOF diretamente do pacote io:

if err == io.EOF {
    break
}

Então, teu código ficaria assim:

linha, err := leitor.ReadString('\n')

if err != nil {
    if err == io.EOF {
        break
    }
    fmt.Println("Ocorreu um erro:", err)
}

Se precisar de mais alguma coisa, só chamar.