Episode Post & Video Links: 1, 2, 3, 4, 5 (this post), 6, 7, and 8. Non-linked are in the works! Videos available now on Youtube however, so check em’ out!
In this session we covered a host of topics around Go Functions. Along with some troubleshooting, debugging, and other features in Jetbrains Goland IDE.
If you’d like to go through this material too in book form, I highly suggest “The Go Programming Language” by Alan A.A. Donovan & Brian W. Kernighan as a starting point. I’m using it as a simple guideline, but also doing a lot more in each stream that includes ecosystem, dependency management with godep, IDE use of Goland from Jetbrains, and more. In this session I get specifically into: functions, signatures, declarations, recursion, return values, and more.
Video Time Points & Topics
2:50 – Introduction to the snowy wonderland of Seattle and episode 5 of the Learning Go series. Introduction to the various screen transitions and such.
6:40 – Getting started, opening up JetBrains Goland and creating a new project. The project exists on Github as https://github.com/adron/learning-go-….
12:18 – Starting with functions in Go. See the blog entry I wrote on the topic for more additional information around this first code session within the episode 5 session.
Code – This first example I setup a basic function in Go that is called by the main function. The sample function below I’ve named exampleExecutor, and the signature is made up of an int parameter called this, a string parameter called that, and a return parameter of type int and one of type string. In summary for the function signature we have two input parameters going in and two return parameters coming out.
The function does very little besides print the parameters passed in and then return the parameters back out as the return parameters.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| package main | |
| import "fmt" | |
| func main() { | |
| var this, result int | |
| var that, message string | |
| this = 2 | |
| that = "42" | |
| result, message = exampleExecutor(this, that) | |
| fmt.Printf("%s\n%d", message, result) | |
| } | |
| func exampleExecutor(this int, that string) (int, string) { | |
| fmt.Printf("Numbers: %d, %s\n", this, that) | |
| return this, "This is the result: " + that | |
| } |
Recursion with Go & HTML Parsing
28:10 – Here I get into recursion and the application example, largely taken from the book but with some very distinctive modifications, that parses HTML and the various nodes within an HTML document.
For the recursion section I use an example from the book with an expanded sample set of HTML. The HTML is included in the repo under the function-recursion branch. For this example I setup a set of types and variables up that are needed throughout the code.
First a type setup called NodeType of type int32. A constant array of ErrorNode, TextNode, DocumentNode, ElementNode, CommentNode, and DoctypeNode for determining the different nodes within an HTML document. Then a general struct called Node with Type, Data, Attr for attribute, and FirstChild with NextSibling setup as a pointer to *Node, which gives a type of memory recursion to the underlying type. Then finally the Attribute struct with a Key a Value.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| type NodeType int32 | |
| const ( | |
| ErrorNode NodeType = iota | |
| TextNode | |
| DocumentNode | |
| ElementNode | |
| Commentnode | |
| DoctypeNode | |
| ) | |
| type Node struct { | |
| Type NodeType | |
| Data string | |
| Attr []Attribute | |
| FirstChild, NextSibling *Node | |
| } | |
| type Attribute struct { | |
| Key, Val string | |
| } |
One of the first functions I then end up with is the visit function. It turns out as shown below. Here the function takes a links parameter that is of type string array, a parameter name n that is a pointer reference to an a node within html, and then the function returns a parameter of type string array.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| func visit(links []string, n *html.Node) []string { | |
| if n.Type == html.ElementNode && n.Data == "a" { | |
| for _, a := range n.Attr { | |
| if a.Key == "href" { | |
| links = append(links, a.Val) | |
| } | |
| } | |
| } | |
| for c := n.FirstChild; c != nil; c = c.NextSibling { | |
| links = visit(links, c) | |
| } | |
| return links | |
| } |
After that function I worked through and created two additional functions, one for countsWordsAndImages and one called CountWordsAndImages. The casing being specific to scope and use of the functions, and they respectively look like this in completion.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| func CountWordsAndImages(url string) (words, images int, err error) { | |
| resp, err := http.Get(url) | |
| if err != nil { | |
| return | |
| } | |
| doc, err := html.Parse(resp.Body) | |
| resp.Body.Close() | |
| if err != nil { | |
| err = fmt.Errorf("parsing HTML: %s", err) | |
| } | |
| words, images = countWordsAndImages(doc) | |
| return | |
| } | |
| func countWordsAndImages(n *html.Node) (words, images int) { | |
| if n.Type == html.TextNode { | |
| words += len(strings.Split(n.Data, " ")) | |
| return | |
| } | |
| if n.Data == "img" { | |
| images++ | |
| } else { | |
| if n.FirstChild != nil { | |
| w, i := countWordsAndImages(n.FirstChild) | |
| words += w | |
| images += i | |
| } | |
| if n.NextSibling != nil { | |
| w, i := countWordsAndImages(n.NextSibling) | |
| words += w | |
| images += i | |
| } | |
| } | |
| return | |
| } |
Then all that is wrapped up, with recursive calls and more, in the main function for program execution.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| func main() { | |
| htmlContent, err := ioutil.ReadFile("compositecode.html") | |
| if err != nil { | |
| fmt.Println(err) | |
| } | |
| htmlData := string(htmlContent) | |
| r := strings.NewReader(htmlData) | |
| doc, err := html.Parse(r) | |
| if err != nil { | |
| fmt.Fprintf(os.Stderr, "find links: %v\n", err) | |
| os.Exit(1) | |
| } | |
| for _, link := range visit(nil, doc) { | |
| fmt.Println(link) | |
| } | |
| w, i, _ := CountWordsAndImages("https://compositecode.blog") | |
| fmt.Printf("Words: %d\nImages: %d\n", w, i) | |
| } |
Starting Error Handling && Anonymous Functions
1:32:40 – At this point in the episode 5 session I get into a simple Error handling function, and further into function signatures and how to set them up.
1:52:24 – Setting up some anonymous functions and reviewing what they are.
1:59:00 – Introduction to panics in Go. After this short introduction I also discuss some of the pedantic specifics of methods vs functions and related verbiage around the Go language. Additionally I provide more examples around these specifics for declaring functions, various scope, and other types for function calls and related usage.
With that done the wrap up of the session is then a short introduction to anonymous functions.
Apache Cassandra
DataStax Enterprise
Schema Migration
Take the language we choose to build an application in. JavaScript is a great example. It has become the singular language of the web, at least on the client side. This was long ago, a form of lock-in that browser makers (and standards bodies) chose that dictated how and in which direction the web – at least web pages – would progress.
JavaScript is merely one example, and a relatively positive one that expands one’s options in more ways than limits one’s efforts. But let’s say the decision is made to build a high speed trading platform and choose SQL Server, .NET C#, and Windows Server. Immediately this is a technology combination that has notoriously illuminated in the past * how lock-in can be extremely dangerous.
One common statement is, “the right tool for the job”. This is of course for the ideal world where ideal decisions can be made all the time. This doesn’t exist and we have to strive for balance between decisions that will wreck the ship or decisions that will give us clear waters ahead.
You must be logged in to post a comment.