Some basic notes and small projects in golang - 10/23/2024

coding in go

Project 1

To parse an HTML file to count the number of words and pictures:

package main

import (
	"fmt"
	"golang.org/x/net/html"
	"io"
	"net/http"
	"strings"
)

// Function to count words and images in the HTML
func countWordsAndImages(r io.Reader) (int, int) {
	doc, err := html.Parse(r)
	if err != nil {
		fmt.Println("Error parsing HTML:", err)
		return 0, 0
	}

	var wordCount,imageCount int
  dfs(doc, &wordCount, &imageCpunt)
  return wordCount,inmageCount
}

func dfs(*html.Node, *wordCount,*imageCount ){

		if n.Type == html.TextNode {
			words := strings.Fields(n.Data)
			wordCount += len(words)
		}
		if n.Type == html.ElementNode && n.Data == "img" {
			imageCount++
		}
		// Recursively traverse the HTML nodes
		for c := n.FirstChild; c != nil; c = c.NextSibling {
      dfs(c,wordsCount,imageCount)
		}

}

func main() {
	// Example: Fetch an HTML page (or you can parse from a file)
	resp, err := http.Get("https://example.com")
	if err != nil {
		fmt.Println("Error fetching page:", err)
		return
	}
  // The caller must close the response body when finished with it:
	defer resp.Body.Close()

	// Count words and images in the page
	wordCount, imageCount := countWordsAndImages(resp.Body)

	fmt.Printf("Word Count: %d\n", wordCount)
	fmt.Printf("Image Count: %d\n", imageCount)
}

Basic to know

var m map[string]string vs m = map[string]string{}

var m map[string]string: Declares a nil map (safe to read, but will panic if you write to it).
m = map[string]string{} or m = make(map[string]string): Initializes an empty, non-nil map (safe for both reading and writing).

var m map[string]string Declaring a map like this creates a nil map. A nil map behaves like an empty map when reading values, but any attempt to write to it (e.g., adding a key-value pair) will result in a runtime panic.

var m map[string]string
fmt.Println(m == nil) // true

// Reading from it is fine, but it returns the zero value
value := m["key"] // value is ""

m["key"] = "value" // PANIC: assignment to entry in nil map

Use Case: var m map[string]string is often used when you don’t need to initialize the map right away or will initialize it later, such as in a function.

m = map[string]string{} Using m = map[string]string{} creates an empty map and allocates memory for it, meaning it is ready for both reading and writing. You can safely add key-value pairs to this map without causing a panic.

m := map[string]string{} // or m = make(map[string]string)
m["key"] = "value"       // This is fine; no panic
fmt.Println(m["key"])    // Outputs: value

Use Case: This form is used when you want a map that is ready to use immediately, allowing both reads and writes without risk of runtime errors.

Slice Initialization

package main

import "fmt"

func main() {
    a := make([]int, 0) // Empty slice
    b := []int{}        // Empty slice

    // Attempting to assign to a[0] will panic
    a[0] = 2 // PANIC: runtime error: index out of range [0] with length 0
    b[0] = 2 // PANIC: runtime error: index out of range [0] with length 0
}

To modify or assign to a[0], the slice must have at least one element. You can achieve this by either:

// use make to create a slice with a specific length:
a := make([]int, 1) // Length = 1, Capacity = 1
a[0] = 2            // Valid
fmt.Println(a)      // Output: [2]
// use append
a := make([]int, 0) // Or a := []int{}
a = append(a, 2)    // Add an element
a[0] = 3            // Now valid
fmt.Println(a)      // Output: [3]

python encapsulation vs go

Python is a dynamic language, and that makes it difficult for the interpreter to enforce some of the safeguards that languages like Go do. That’s why encapsulation in Python is achieved mostly by convention rather than by force.

Prefixing methods and properties with a double underscore is a strong suggestion to the users of your class that they shouldn’t be touching that stuff. If a developer wants to break convention, there are ways to get around the double underscore rule.

1.Double underscore __ (name mangling)

class Book:
    def __init__(self, title, author):
        self.__title = title  # more "private"
				book = Book("1984", "Orwell")

book = Book("1984", "Orwell")
print(book.__title)  # AttributeError
print(book._Book__title)  # Access via name mangling

l 2.Use @property to control access

class Book:
    def __init__(self, title, author):
        self.__title = title

    @property
    def title(self):
        return self.__title

    @title.setter
    def title(self, new_title):
        if not new_title:
            raise ValueError("Title can't be empty")
        self.__title = new_title

book = Book("1984", "Orwell")
print(book.title)        # OK
book.title = "Animal Farm"  # OK
book.title = ""          # Raises ValueError

In Go: Capitalization = Visibility Uppercase = Exported (public) Lowercase = Unexported (private)