Automate-the-Boring-Stuff-With-Go on t0ul

Automate the Boring Stuff with Go, Ch. 11: Web Requests

Fri, 16 Jun 2023 00:00:00 +0000

Part of Automate the Boring Stuff with Go, a beginner-friendly guide to programming in Go.

Request

package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"net/http"
	"os"
)

func main() {

	pwdDir, _ := os.Getwd()
	fLog, err := os.OpenFile(pwdDir+"/log.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0640)
	check(err, fLog)

	url := "http://www.gutenberg.org/cache/epub/1112/pg1112.txt"

	resp, err := http.Get(url)
	check(err, fLog)

	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	check(err, fLog)

	fmt.Println(string(body))
}

// err check to log
func check(err error, fLog *os.File) {
	if err != nil {
		log.Fatalln(err)
	}
	log.SetOutput(io.MultiWriter(fLog, os.Stdout))
}

Search Term

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"os"

	"github.com/jackdanger/collectlinks"
)

func main() {

	pwdDir, _ := os.Getwd()
	fLog, err := os.OpenFile(pwdDir+"/log.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0640)
	check(err, fLog)

	resp, err := http.Get("https://automatetheboringstuffwithgo.com")
	check(err, fLog)
	defer resp.Body.Close()

	links := collectlinks.All(resp.Body)

	for _, link := range links {
		fmt.Println(link)
	}
}

// err check to log
func check(err error, fLog *os.File) {
	if err != nil {
		log.Fatalln(err)
	}
	log.SetOutput(io.MultiWriter(fLog, os.Stdout))
}

Request Save

package main

import (
	"io"
	"io/ioutil"
	"log"
	"net/http"
	"os"
)

func main() {
	pwdDir, _ := os.Getwd()
	fLog, err := os.OpenFile(pwdDir+"/log.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0640)
	check(err, fLog)

	fSave, err := os.OpenFile(pwdDir+"/save.txt", os.O_CREATE|os.O_WRONLY, 0600)
	check(err, fLog)

	url := "http://www.gutenberg.org/cache/epub/1112/pg1112.txt"

	resp, err := http.Get(url)
	check(err, fLog)
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	check(err, fLog)

	fSave.Write(body)
}

// err check to log
func check(err error, fLog *os.File) {
	if err != nil {
		log.Fatalln(err)
	}
	log.SetOutput(io.MultiWriter(fLog, os.Stdout))
}

Download XKCD

package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"regexp"

	"strings"

	"strconv"

	"sort"

	"github.com/opesun/goquery"
)

func main() {
	pwdDir, _ := os.Getwd()
	fLog, err := os.OpenFile(pwdDir+"/log.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0640)
	check(err, fLog)

	url := `http://xkcd.com`

	err = os.Mkdir(pwdDir+"/xkcd", 0775)
	check(err, fLog)

	resp, err := http.Get(url)
	log.Printf("URL:	%v", url)
	check(err, fLog)
	defer resp.Body.Close()

	x, err := goquery.Parse(resp.Body)
	check(err, fLog)

	var urlInt []int
	regLastLink, _ := regexp.Compile(`\/[0-9]{1,}\/`)
	for _, i := range x.Find("a").Attrs("href") {
		if regLastLink.MatchString(i) {
			a, err := strconv.Atoi(strings.Trim(i, "/"))
			check(err, fLog)
			urlInt = append(urlInt, a)
		}
	}
	sort.Ints(urlInt)
	fmt.Println(urlInt[len(urlInt)-1])

	for k := urlInt[len(urlInt)-1] + 1; k >= 1; k-- {
		resp, err := http.Get(url + "/" + strconv.Itoa(k))
		log.Printf("URL: 	%v", url+"/"+strconv.Itoa(k))
		check(err, fLog)
		defer resp.Body.Close()

		x, err := goquery.Parse(resp.Body)
		check(err, fLog)

		regStr, _ := regexp.Compile(`comics`)
		for _, i := range x.Find("img").Attrs("src") {
			if regStr.MatchString(i) {

				nameFile := strings.Split(i, "/comics/")

				name := pwdDir + "/xkcd/" + nameFile[1]
				fSave, err := os.OpenFile(name, os.O_CREATE|os.O_WRONLY, 0640)
				check(err, fLog)

				respImg, err := http.Get("http:" + i)
				log.Printf("http	%v", "http:"+i)
				check(err, fLog)

				defer respImg.Body.Close()

				bodyImg, err := ioutil.ReadAll(respImg.Body)
				check(err, fLog)

				log.Printf("name:	%v", name)
				fSave.Write(bodyImg)
			}
		}
	}

	log.SetOutput(io.MultiWriter(fLog, os.Stdout))
}

// err check to log
func check(err error, fLog *os.File) {
	if err != nil {
		log.Println(err)
	}
	log.SetOutput(io.MultiWriter(fLog, os.Stdout))
}

Selenium

package main

import (
	"encoding/csv"
	"github.com/tebeka/selenium"
	"github.com/tebeka/selenium/chrome"
	"log"
	"os"
)

// define a custom data type for the scraped data
type Product struct {
	name, price string
}

func main() {
	// where to store the scraped data
	var products []Product

	// initialize a Chrome browser instance on port 4444
	service, err := selenium.NewChromeDriverService("./chromedriver/chromedriver", 4444)
	if err != nil {
		log.Fatal("Error:", err)
	}

	defer service.Stop()

	// configure the browser options
	caps := selenium.Capabilities{}
	caps.AddChrome(chrome.Capabilities{Args: []string{
		"--headless", // comment out this line for testing
	}})

	// create a new remote client with the specified options
	driver, err := selenium.NewRemote(caps, "")
	if err != nil {
		log.Fatal("Error:", err)
	}

	// maximize the current window to avoid responsive rendering
	err = driver.MaximizeWindow("")
	if err != nil {
		log.Fatal("Error:", err)
	}

	// visit the target page
	err = driver.Get("https://scrapingclub.com/exercise/list_infinite_scroll/")
	if err != nil {
		log.Fatal("Error:", err)
	}

	// select the product elements
	productElements, err := driver.FindElements(selenium.ByCSSSelector, ".post")
	if err != nil {
		log.Fatal("Error:", err)
	}

	// iterate over the product elements
	// and extract data from them
	for _, productElement := range productElements {
		// select the name and price nodes
		nameElement, err := productElement.FindElement(selenium.ByCSSSelector, "h4")
		priceElement, err := productElement.FindElement(selenium.ByCSSSelector, "h5")
		// extract the data of interest
		name, err := nameElement.Text()
		price, err := priceElement.Text()
		if err != nil {
			log.Fatal("Error:", err)
		}

		// add the scraped data to the list
		product := Product{}
		product.name = name
		product.price = price
		products = append(products, product)
	}

	// export the scraped data to CSV
	file, err := os.Create("products.csv")
	if err != nil {
		log.Fatal("Error:", err)
	}

	defer file.Close()

	// initialize a file writer
	writer := csv.NewWriter(file)

	// define the CSV headers
	headers := []string{
		"name",
		"price",
	}

	// write the column headers
	writer.Write(headers)

	// adding each product to the CSV output file
	for _, product := range products {

		// converting a Product to an array of strings
		record := []string{
			product.name,
			product.price,
		}

		// writing a new CSV record
		writer.Write(record)
	}

	defer writer.Flush()
}

Google Search

package main

import (
	"fmt"
	"github.com/PuerkitoBio/goquery"
	"log"
	"net/http"
	"os"
)

func getData() {
	// change the query t be a var
	// pass in single search term
	url := fmt.Sprintf("https://www.google.com/search?q=%s&gl=us&hl=en", os.Args[1])
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		log.Fatal(err)
	}

	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36")
	client := &http.Client{}
	res, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer res.Body.Close()

	doc, err := goquery.NewDocumentFromReader(res.Body)
	if err != nil {
		log.Fatal(err)
	}
	c := 0
	doc.Find("div.g").Each(func(i int, result *goquery.Selection) {
		title := result.Find("h3").First().Text()
		link, _ := result.Find("a").First().Attr("href")
		snippet := result.Find(".VwiC3b").First().Text()

		fmt.Printf("Title: %s\n", title)
		fmt.Printf("Link: %s\n", link)
		fmt.Printf("Snippet: %s\n", snippet)
		fmt.Printf("Position: %d\n", c+1)
		fmt.Println()

		c++
	})
}

func main() {
	getData()
}

Automate the Boring Stuff with Go, Ch. 10: PDFs

Fri, 26 May 2023 00:00:00 +0000

Part of Automate the Boring Stuff with Go, a beginner-friendly guide to programming in Go.

Pdf Test

package main

import (
	"bytes"
	"fmt"

	"github.com/jung-kurt/gofpdf"
	"github.com/ledongthuc/pdf"
)

func main() {

	content, err := readPdf("basic.pdf") // Read local pdf file
	if err != nil {
		panic(err)
	}
	fmt.Println(content)

	pdf := gofpdf.New("P", "mm", "A4", "")
	pdf.AddPage()
	pdf.SetFont("Garamond", "B", 16)
	pdf.Cell(40, 10, content)
	err = pdf.OutputFileAndClose("hello.pdf")

	return
}

func readPdf(path string) (string, error) {
	_, r, err := pdf.Open(path)
	if err != nil {
		return "", err
	}
	totalPage := r.NumPage()

	var textBuilder bytes.Buffer
	for pageIndex := 1; pageIndex <= totalPage; pageIndex++ {
		p := r.Page(pageIndex)
		if p.V.IsNull() {
			continue
		}
		s, err := p.GetPlainText(nil)
		if err != nil {
			fmt.Printf("Error: ", err)
		}

		textBuilder.WriteString(s)
	}
	return textBuilder.String(), nil
}

Combine PDFs

package main

import (
	"fmt"
	"log"
	"os"
	"strings"

	"github.com/jung-kurt/gofpdf"
	pdfL "github.com/ledongthuc/pdf"
)

func main() {

	pwdDir, _ := os.Getwd()
	fLog, err := os.OpenFile(pwdDir+`/.log`, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0640)
	if err != nil {
		log.Fatalln(err)
	}
	defer fLog.Close()

	log.SetOutput(fLog)

	dir, err := os.Open(pwdDir)
	if err != nil {
		log.Fatalln(err)
	}
	defer dir.Close()

	fileInfos, err := dir.Readdir(-1)
	if err != nil {
		log.Fatalln(err)
	}
	
	pdf := gofpdf.New("P", "mm", "A4", "")
	pdf.AddPage()
	pdf.SetFont("Arial", "B", 16)
	pdf.Cell(40, 10, "combinePdfs")
	log.Printf("Saving... %v", "save.pdf")

	for _, fi := range fileInfos {
		if strings.HasSuffix(fi.Name(), ".pdf") {
			log.Printf("File name %v", fi.Name())
			_, r, err := pdfL.Open(fi.Name())
			if err != nil {
				log.Fatalln(err)
			}
			totalPage := r.NumPage()
			log.Printf("num of pages: %v", totalPage)

			for pageIndex := 1; pageIndex <= totalPage; pageIndex++ {
				log.Printf("index %v", pageIndex)
				p := r.Page(pageIndex)
				if p.V.IsNull() {
					continue
				}
				pdf.AddPage()
				pdf.SetFont("Arial", "B", 16)
				txt, err := p.GetPlainText(nil)
				if err != nil {
					fmt.Printf("error: ", err)
				}
				pdf.Cell(40, 10, txt)
			}
		}
	}
	err = pdf.OutputFileAndClose("saved.pdf")
}

Automate the Boring Stuff with Go, Ch. 9: Excel Files

Fri, 05 May 2023 00:00:00 +0000

Part of Automate the Boring Stuff with Go, a beginner-friendly guide to programming in Go.

XLSX GO

package main

import (
	"fmt"
	"io"
	"log"
	"os"

	"github.com/tealeg/xlsx"
)

func main() {
	pwdDir, _ := os.Getwd()
	os.Mkdir(pwdDir+"/log", 0740)
	fLog, err := os.OpenFile(pwdDir+"/log/log.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0640)
	check(err, fLog)

	excelFileName := pwdDir + "/example.xlsx"

	xlFile, err := xlsx.OpenFile(excelFileName)
	check(err, fLog)

	i := xlFile.Sheets[0]
	fmt.Println(i.Name)

	y := i.Cell(0, 0)
	a := y.String()
	fmt.Println(a)

	k := i.MaxRow
	for u := 0; u < k; u++ {
		sd := i.Cell(u, 1)
		ss := sd.String()
		fmt.Println(ss)
	}
}

// err check to log
func check(err error, fLog *os.File) {
	if err != nil {
		log.Println(err)
	}
	log.SetOutput(io.MultiWriter(fLog, os.Stdout))
}

Census Population Data

package main

import (
	"encoding/json"
	"flag"
	"github.com/tealeg/xlsx"
	"log"
	"os"
)

func main() {
	openExcelPtr := flag.String("open", "census_pop_data.xlsx", "for opening excel files.")
	saveToJson := flag.String("save", "data_to.json", "json file to save the excel file data to.")
	pwdDir, _ := os.Getwd()
	flag.Parse()

	fLog, err := os.OpenFile(pwdDir+`/.log`, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0640)
	if err != nil {
		log.Fatalln(err)
	}
	defer fLog.Close()

	log.SetOutput(fLog)

	exitData, err := os.OpenFile(pwdDir+`/`+*saveToJson, os.O_WRONLY|os.O_CREATE, 0640)
	if err != nil {
		log.Fatalln(err)
	}
	defer exitData.Close()

	excelFileName := pwdDir + "/" + *openExcelPtr

	log.Printf("excel file name: %v", excelFileName)

	wb, err := xlsx.OpenFile(excelFileName)
	if err != nil {
		log.Fatalf("Error opening file %v", err)
	}

	sheet := wb.Sheet["Population by Census Tract"]
	log.Printf("Sheet name: %v", sheet.Name)

	k := sheet.MaxRow

	type Key struct {
		State, Country string
	}
	popData := make(map[Key]float64)
	tractsData := make(map[Key]int)

	for u := 1; u < k; u++ {
		state := sheet.Cell(u, 1)
		country := sheet.Cell(u, 2)
		pop := sheet.Cell(u, 3)
		nameStateStr := state.String()
		countryStr := country.String()

		popFl, err := pop.Float()
		if err != nil {
			log.Fatalf("error %v", err)
		}

		popData[Key{nameStateStr, countryStr}] += popFl

		tractsData[Key{nameStateStr, countryStr}]++
	}

	type SaveData struct {
		Name Key `json:"state and country name"`
		Pop float64 `json:"populations"`
		Tracts int `json:"tracts"`
	}

	log.Printf("saving json JSON %s", exitData.Name())

	newStr := "\n"
	for keys := range popData {
		saveData2D := &SaveData{
			Name: keys,
			Pop: popData[keys],
			Tracts: tractsData[keys]}
		saveData2B, _ := json.Marshal(saveData2D)
		saveData2B = append(saveData2B, newStr...)

		if _, err := exitData.Write(saveData2B); err != nil {
			log.Panicf("error savying json %v", err)
		}
	}
	log.Println("done ")
}

Save Excel

package main

import (
	"flag"
	"github.com/tealeg/xlsx"
	"log"
	"os"
)

func main() {

	saveFilePtr := flag.String("save", "files.xlsx", "")
	flag.Parse()

	pwdDir, _ := os.Getwd()

	fLog, err := os.OpenFile(pwdDir+`/.log`, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0640)
	if err != nil {
		log.Fatalln(err)
	}
	defer fLog.Close()

	log.SetOutput(fLog)

	var (
		file *xlsx.File
		sheet *xlsx.Sheet
		row *xlsx.Row
		cell *xlsx.Cell
	)

	file = xlsx.NewFile()
	sheet, err = file.AddSheet("Sheet")
	log.Printf("Added Sheet: %v", sheet)
	if err != nil {
		log.Printf("Err adding sheet: %v", err)
	}

	for i := 0; i < 50; i++ {
		row = sheet.AddRow()
		log.Printf("Adding row %v", row)
		row.AddCell().SetString("Col A")
		row.AddCell().SetString("Col B")
		row.AddCell().SetString("Col C")
		cell = row.AddCell()
		log.Printf("Added columns: %v", cell)
		cell.Value = "Loren ipsum"
	}
	err = file.Save(pwdDir + "/" + *saveFilePtr)
	if err != nil {
		log.Printf("Err saving: %v", err)
	}
	log.Printf("Name of file:%v", *saveFilePtr)

}

Update Produce

package main

import (
	"flag"
	"github.com/tealeg/xlsx"
	"log"
	"os"
)

func main() {
	openFilePtr := flag.String("open", "produceSales.xlsx", "Excel file to open")
	flag.Parse()
	pwdDir, _ := os.Getwd()

	fLog, err := os.OpenFile(pwdDir+`/.log`, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0640)
	if err != nil {
		log.Fatalln(err)
	}
	defer fLog.Close()

	log.SetOutput(fLog)

	excelFileName := pwdDir + "/" + *openFilePtr

	log.Printf("Excel file opened: %v", *openFilePtr)

	wb, err := xlsx.OpenFile(excelFileName)
	if err != nil {
		log.Fatalf("error opening file%v", err)
	}

	sheet := wb.Sheet["Sheet"]

	priceUpdates := map[string]float64{
		"Lemon": 4.99,
		"Celery": 10.99,
		"Garlic": 7.47,
	}

	for rowNum := 1; rowNum < sheet.MaxRow; rowNum++ {
		produceName := sheet.Cell(rowNum, 0).Value
		if _, ok := priceUpdates[produceName]; ok {
			sheet.Cell(rowNum, 1).SetFloat(priceUpdates[produceName])
			log.Printf("Row: %v Produce: %v", rowNum, produceName)
		}
	}

	wb.Save("update" + *openFilePtr)

}

Multiplication Table

package main

import (
	"flag"
	"github.com/tealeg/xlsx"
	"log"
	"os"
	"strconv"
)

func main() {

	nPtr := flag.Int("number", 12, "how far to go on the table")
	savePtr := flag.String("save", "multiplication_table.xlsx", "for creating a multiplication table")
	flag.Parse()

	pwdDir, _ := os.Getwd()

	fLog, err := os.OpenFile(pwdDir+`/.log`, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0640)
	if err != nil {
		log.Fatalln(err)
	}
	defer fLog.Close()

	log.SetOutput(fLog)

	var (
		file *xlsx.File
		sheet *xlsx.Sheet
		row *xlsx.Row
		cell *xlsx.Cell
	)

	style := xlsx.NewStyle()

	border := *xlsx.NewBorder("thin", "thin", "thin", "thin")
	style.Border = border
	style.ApplyBorder = true

	fill := *xlsx.NewFill("solid", "00FF0000", "FF000000")
	style.Fill = fill
	style.ApplyFill = true

	font := *xlsx.NewFont(10, "Verdana")
	style.Font = font
	style.ApplyFont = true

	file = xlsx.NewFile()
	sheet, err = file.AddSheet("Sheet")
	log.Printf("Sheet Name: %v", sheet.Name)
	if err != nil {
		log.Printf("Error: %v", err)
	}

	for i := 1; i <= *nPtr; i++ {
		if i == 1 {
			row = sheet.AddRow()
			cell = row.AddCell()
		}

		cell = row.AddCell()
		cell.SetStyle(style)
		cell.SetInt(i)
	}

	for i := 1; i <= *nPtr; i++ {
		row = sheet.AddRow()
		cell = row.AddCell()
		cell.SetStyle(style)
		cell.SetInt(i)
	}

	for i := 1; i <= *nPtr; i++ {
		for j := 1; j <= *nPtr; j++ {
			cell = sheet.Cell(i, j)
			cell.SetInt(i * j)
			log.Printf("times %v", strconv.Itoa(i)+" * "+strconv.Itoa(j))
		}
	}

	err = file.Save(pwdDir + "/" + *savePtr)
	if err != nil {
		log.Printf("Error: %v", err)
	}
	log.Printf("save %v", *savePtr)

}

txt To XLSX

package main

import (
	"bufio"
	"flag"
	"github.com/tealeg/xlsx"
	"log"
	"os"
	"strings"
)

func main() {
	savePtr := flag.String("save", "table.xlsx", "convert txt file to an excel file")

	pwdDir, _ := os.Getwd()

	fLog, err := os.OpenFile(pwdDir+`/.log`, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0640)
	if err != nil {
		log.Fatalln(err)
	}
	defer fLog.Close()

	log.SetOutput(fLog)

	file := xlsx.NewFile()

	sheet, err := file.AddSheet("Sheet")
	log.Printf("Sheet name %v", sheet.Name)
	if err != nil {
		log.Printf("Error adding sheet %v", err)
	}

	dir, err := os.Open(pwdDir)
	if err != nil {
		return
	}
	defer dir.Close()

	fileInfos, err := dir.Readdir(-1)
	if err != nil {
		return
	}

	dataFiles := make(map[string][]string)

	for _, fi := range fileInfos {
		if strings.HasSuffix(fi.Name(), ".txt") {
			log.Printf("File name: %v", fi.Name())
			fileOpen, err := os.Open(fi.Name())
			if err != nil {
				log.Fatalln(err)
			}
			var arr []string
			scanner := bufio.NewScanner(fileOpen)
			for scanner.Scan() {
				arr = append(arr, scanner.Text())
			}
			if err := scanner.Err(); err != nil {
				log.Fatal(err)
			}
			defer fileOpen.Close()

			dataFiles[fi.Name()] = arr
		}
	}

	i := 0
	for keys, prs := range dataFiles {
		sheet.Cell(0, i).SetValue(keys)
		l := 1
		for _, str := range prs {
			sheet.Cell(l, i).SetValue(str)
			l++
		}
		i++
	}

	err = file.Save(pwdDir + "/" + *savePtr)
	if err != nil {
		log.Printf("Error: %v", err)
	}
	log.Printf("Saving as...%v", *savePtr)
}

XLSX to TXT

package main

import (
	"flag"
	"github.com/tealeg/xlsx"
	"log"
	"os"
	"strconv"
)

var opts struct {
	FileOPEN string `short:"o" long:"open" default:"table.xlsx" description:"Файл таблицы"`
}

func main() {
	openPtr := flag.String("open", "table.xlsx", "file to open")
	flag.Parse()

	pwdDir, _ := os.Getwd()

	fLog, err := os.OpenFile(pwdDir+`/.log`, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0640)
	if err != nil {
		log.Fatalln(err)
	}
	defer fLog.Close()

	log.SetOutput(fLog)

	excelFileName := pwdDir + "/" + *openPtr

	log.Printf("File to open: %v", excelFileName)

	wb, err := xlsx.OpenFile(excelFileName)
	if err != nil {
		log.Fatalf("Error: %v", err)
	}

	i := wb.Sheets[0]
	log.Printf("Name: %v", i.Name)

	for m := 0; m < i.MaxCol; m++ {
		strName := "saveFile" + strconv.Itoa(m+1) + ".txt"
		saveFile, err := os.Create(strName)
		log.Printf("File name: %v", saveFile.Name())
		if err != nil {
			log.Fatalf("Error: %v", err)
		}
		defer saveFile.Close()

		for u := 0; u < i.MaxRow; u++ {
			sd := i.Cell(u, m)
			ss := sd.String()
			saveFile.WriteString(ss)
			saveFile.WriteString("\n")
		}
	}
}

Conclusion

Automate the Boring Stuff with Go, Ch. 8: Files

Fri, 14 Apr 2023 00:00:00 +0000

Part of Automate the Boring Stuff with Go, a beginner-friendly guide to programming in Go.

In this chapter we’re going to focus on working with files. In particular, we’ll focus on the management of local files on your laptop or computer.

Think of all the mundane tasks you typically do with file management; backing up files, removing large files, renaming a bunch of files, and selectively backing up files.

Automate the Boring Stuff with Go, Ch. 7: Strings

Fri, 24 Mar 2023 00:00:00 +0000

Part of Automate the Boring Stuff with Go, a beginner-friendly guide to programming in Go.

Think of all the times you’ve used cmd + f or ctrl + f on your computer to search for a phrase or string on a webpage or huge document.

It’s also possible to do the same in programming but rather than matching a word character for character we can search for the pattern of the string.

Automate the Boring Stuff with Go, Ch. 6: Syntax

Fri, 03 Mar 2023 00:00:00 +0000

Part of Automate the Boring Stuff with Go, a beginner-friendly guide to programming in Go.

Like in real life, a map is a way of containing data that defines something. Think of the map of New York City. It is a piece of paper that includes data about the city’s layout– depending on the map type. Maps are typically handy when you combine different data types because a slice will only permit one data type per-use. We’ll briefly cover Maps so the reader can be aware of them and see when they might be useful.

Automate the Boring Stuff with Go, Ch. 5: Slices

Fri, 10 Feb 2023 00:00:00 +0000

Part of Automate the Boring Stuff with Go, a beginner-friendly guide to programming in Go.

Slices in Golang are the same as dynamic arrays. An array is the first data structure you’ll probably learn about in any book related to learning a programming language. Slices can contain any data type, including a slice itself, making arranging data into hierarchical structures simpler. In this chapter, we’ll go over the basics of Slices, and I’ll teach you about some of the most useful methods available to slices.

Automate the Boring Stuff with Go, Ch. 4: Functions

Fri, 20 Jan 2023 00:00:00 +0000

Part of Automate the Boring Stuff with Go, a beginner-friendly guide to programming in Go.

You’ve already seen func’s multiple times so far, but let’s take this chapter to understand them better and when to use them when automating work.

Functions are reusable work units for a program to use, and they save programmers from repeating themselves.

You might hear this paradigm as D.R.Y. when speaking with other coders, which stands for “Don’t repeat yourself”.

Automate the Boring Stuff with Go, Ch. 3: Control Flow

Fri, 30 Dec 2022 00:00:00 +0000

Part of Automate the Boring Stuff with Go, a beginner-friendly guide to programming in Go.

In the previous chapter, we covered the basics of GO data types and, in a few examples, used flow control to print messages.

In this chapter, we’ll use what we learned about comparison operators and boolean values to learn more about flow control.

Elements of Flow control

Programs are like water in a river because they tend to flow in one direction. And like water in a river, parts of it can go off into separate outlets based upon the river’s conditions, such as a boulder in the stream or a dam.

Automate the Boring Stuff with Go, Ch. 2: Go Basics

Fri, 09 Dec 2022 00:00:00 +0000

Part of Automate the Boring Stuff with Go, a beginner-friendly guide to programming in Go.

In this chapter, I’ll cover the basics you’ll need for writing programs in GO. Things like using the toolchain, data types, and some handy conversions. I will use plenty of examples in the upcoming sections. It’s okay if they do not make sense; we aim for familiarity, not mastery. That said, the best way to learn any programming language is to code along to build muscle memory, so crack open your new installation, Visual Studio Code editor.

Automate the Boring Stuff with Go, Ch. 1: Introduction

Fri, 18 Nov 2022 00:00:00 +0000

Part of Automate the Boring Stuff with Go, a beginner-friendly guide to programming in Go.

A developer environment can mean several things, but for you, it means getting your laptop or desktop configured to write GO and run GO programs.

I’ll show you the easiest ways of installing GO for the two most common personal computer operating systems; Windows and macOS.

Introducing Automate the Boring Stuff with GO

Fri, 04 Nov 2022 00:00:00 +0000

The beginner-friendly guide to programming with GO/GoLang. No prior experience is required!

Welcome to the Free E-book for Beginner Coders Interested in GO

If you’re new to GO and a Beginner in programming then there are not really books or learning resources for you. Most GO related books expect you to have some programming experience and involve complex topics such as Web Application building.