¿Cómo leer archivos palabra por palabra en Golang?

La lectura de archivos es un aspecto tan importante de un lenguaje de programación. Necesitamos realizar ciertas operaciones mediante programación, el uso de la automatización en la lectura/escritura de archivos nos permite crear ciertos programas/proyectos que de otro modo podrían parecer imposibles.

Entrada de archivo

Para trabajar con archivos, tenemos que ingresar un archivo existente mientras leemos de un archivo. Seguramente podemos tomar entradas usando el nombre del archivo, pero aquí lo estamos tomando de manera simple y leyendo desde un archivo predefinido. Podemos abrir un archivo para leer usando el paquete/módulo os en Golang. La función Abrir en el paquete os nos permite darle el nombre del archivo como parámetro. 

// Golang program to open file
package main
import (
    "os"
    "log"
)
func main() {
    file, err := os.Open("sample.txt")
    if err != nil {
        log.Fatal(err)
    }
}

La función Abrir devuelve una referencia de puntero al archivo o devuelve un error en caso de que no se encuentre el archivo, no se pueda abrir para lectura, etc. Por lo tanto, almacenamos cualquiera de los valores, cualquiera sea el aplicable. Si tenemos un error, simplemente queremos registrar el error como Fatal y salir del programa a través del paquete de registro en Go.

Producción:

&{0x11934420} 

Usando bufio para escanear archivos

Para obtener realmente el contenido del puntero del archivo, necesitamos usar las funciones del escáner que tienen funcionalidades para leer el contenido del archivo línea por línea, palabra por palabra, carácter por carácter (runa), etc. 

Antes de eso, necesitamos un Reader para leer de una transmisión, usamos la función NewScanner que toma un parámetro como una transmisión. Como queremos leer de un archivo, analizaremos el puntero del archivo como un parámetro. Esto creará un escáner que puede leer el archivo proporcionado. 

Una vez que hayamos inicializado nuestro escáner, podemos proporcionar un divisor (función de división) o un tipo de formato que se leerá de acuerdo con un patrón específico. Como queremos leer palabra por palabra analizaremos la función bufio.ScanWords. Esta función actúa como un divisor de la secuencia dada, es decir, dividirá el archivo completo en la función de división proporcionada en nuestro caso en palabras. 

// Golang program to scan files
package main
 
import (
    "fmt"
    "os"
    "log"
    "bufio"
)
 
func main() {
    file, err := os.Open("sample.txt")
    if err != nil {
        log.Fatal(err)
    }else{
        fmt.Println(file)
    }
    Scanner := bufio.NewScanner(file)
    Scanner.Split(bufio.ScanWords)
    fmt.Println(Scanner)
}

Producción:

&{0x11864420}
&{0x118061a8 0x48e410 65536 [] [] 0 0 <nil> 0 false false}

Entonces, usando bufio Scanner y sus funciones relevantes como NewScanner, Split y ScanWords, podemos configurar el escáner de archivos. Ahora podemos leer desde el escáner cada palabra del archivo. 

Escaneo de palabras

Para iterar sobre el archivo, creamos el escáner y toda la información sobre el archivo se almacena en el escáner. Podemos acceder al contenido del archivo con otra función llamada Scan. Esta función hace avanzar el Escáner a la siguiente ficha dividida. Por lo tanto, devolverá verdadero si hay contenido/tokens en el escáner; de lo contrario, devolverá falso si llegamos al final del archivo, pero cuando es EOF, el mensaje de error es nulo y, por lo tanto, salimos sin ningún error válido. Dentro del ciclo, podemos usar la función Texto. Esta función devuelve los bytes del escáner asignado recientemente en nuestro caso, es el archivo que proporcionamos. Entonces, básicamente obtiene el texto para el token actual en el que se está iterando la función Escanear. Así podemos imprimir el valor devuelto por la función Texto.

// Go program to scan the words
package main
 
import (
    "fmt"
    "os"
    "bufio"
    "log"
)
 
func main() {
 
    file, err := os.Open("sample.txt")
    if err != nil {
        log.Fatal(err)
    }
 
    Scanner := bufio.NewScanner(file)
    Scanner.Split(bufio.ScanWords)
 
    for Scanner.Scan() {
        fmt.Println(Scanner.Text())
    }
    if err := Scanner.Err(); err != nil {
        log.Fatal(err)
    }
}

Como podemos ver, podemos iterar sobre el archivo palabra por palabra. La verificación de errores usando la variable err, primero almacenamos el error en la variable err, y luego, si y solo si el err no es nulo, eso se considera un error y tenemos una salida del programa después de registrar el error. El punto y coma (;) se usa para enstringr declaraciones en go lang antes de evaluar una condición. 

Agregar a un segmento de string

Simplemente hemos impreso el contenido del archivo palabra por palabra, lo que podría no ser un buen caso de uso del paquete. Incluso podemos almacenar el contexto en forma de segmento, en este caso un segmento de string donde cada elemento es una palabra. 

// Go program to append to a String slice
package main
 
import (
    "fmt"
    "os"
    "bufio"
    "log"
)
 
func main() {
 
    file, err := os.Open("sample.txt")
 
    var words []string
 
    if err != nil {
        log.Fatal(err)
    }
 
    Scanner := bufio.NewScanner(file)
    Scanner.Split(bufio.ScanWords)
 
    for Scanner.Scan() {
        words = append(words, Scanner.Text())
    }
 
    fmt.Println(words)
    for _, word := range words {
        fmt.Println(word)
    }
    if err := Scanner.Err(); err != nil {
        log.Fatal(err)
    }
 
}

Las cosas que cambiaron en este código son solo la forma en que agregamos e iteramos sobre el segmento de string creado. Primero inicializamos un segmento de string con el nombre de sintaxis []string , después de inicializar Scanner y estamos iterando con la función Scan, simplemente agregamos el valor devuelto por la función Scanner.Text() en el segmento de string. Podemos imprimir la rebanada o iterar sobre ella y hacer el procesamiento requerido en ella. Así es como podemos agregar el contenido de un archivo palabra por palabra a un segmento de string en Golang.