I like learning different programming languages. Sometime I learn alternate ways to do things which might be useful in my usual language, sometimes I get a feel for how another language might be better for certain tasks and gives me more options for developing apps. I recently started learning the language Go, so this is my first of several posts on what I’ve learned.<\/p>\n
Note: I’m literally just learning this, so I suspect any posts on the subject will be pretty basic, but hopefully, might be of use to others (as well as myself).<\/em><\/p>\n Why Go?<\/strong><\/p>\n Probably the first question many of us might ask is why pick a specific language. For example, is the language all about speed, or writing application in a specific paradigm like a functional language. <\/p>\n So Why Go? Where does it fit into?<\/p>\n Before we look to answer that question, we should note that Go was designed by Google<\/a> as an open source, compiled and statically typed language.<\/p>\n So we might view Go as a possibly modern take on C but with features, such as concurrency as primitives as well as being a garbage collected language. It’s cross platform and compiles to native. The language is a general purpose language, so it can do many things, but I’ve not found anything to suggest it’s aimed at GUI work. I’ve seen lots of talk about supporting distributed code, and services\/microservices etc. but not yet done anything with these, so cannot confirm how good it is as such things.<\/p>\n Let’s get started and download Go<\/strong><\/p>\n Okay, so you can read a brief history of Go from Wikipedia etc., let’s instead download Go and install it from Downloads<\/a>.<\/p>\n On Windows (as I’m currently running it) by default the installation is into C:\\Go and this is what the environment variable %GOROOT% should be set to (either during installation or manually assigned if need be). <\/p>\n You’ll need to set up the %GOPATH% environment variable (or via your preferred IDE, I’m using JetBrains Gogland (1.0 Preview)) to point to your workspace, i.e. where you’ll be writing your application(s) to. So, for example, C:\\Development\\GoglandProjects on my installation is where I’m writing my Go projects to at the moment.<\/p>\n Note: You do seem to be able to get away without a GOPATH.<\/em><\/p>\n Hello World<\/strong><\/p>\n Yes, this one’s on The Go Programming Language<\/a> website, but we’ll recreate here.<\/p>\n or even simpler (if you’re in the code’s folder), just run<\/p>\n This command compiled the Go code into a native EXE\n<\/li>\n<\/ul>\n At this point you’ll have a binary (hello-world.exe) that you can run or if you delete this and run the following line from the command prompt in your workspace<\/p>\n then Go will compiled to a temporary EXE, i.e. no EXE is create in our workspace, it just runs the go code.<\/p>\n In the hello-world.go code, you’ll see standard looking constructs, for example we have an include\/import\/using type line which imports the fmt package, you have a func main, which is obviously a function\/method (and should be in a package named main) and some call on the fmt package which ouputs to the console the string “Hello World”.<\/p>\n So all pretty recognisable.<\/p>\n Note: I mentioned fmt is a package and at first site this appears to be like an object\/class, but Go is not an object oriented language. There’s no inheritance for example, or base object but there are constructs that can give us some OO like capabilities, instead of objects we have structures “struct” types like in C as well as interfaces.<\/em><\/p>\n Basics<\/strong><\/p>\n Here’s a quick list of some of the basics we expect to see in a language.<\/p>\n Commenting<\/em><\/p>\n The standard C++ \/\/ and \/* *\/ operators are used for single line and multi line comments respectively.<\/p>\n Namespace\/Package<\/em><\/p>\n Analogous to a namespace, we have the package – for example<\/p>\n Creating your own types<\/em><\/p>\n As mentioned, Go is not an OO language, but like C with typedef and struct we can create our own custom types, for example<\/p>\n or a struct using<\/p>\n Declaring variables<\/em><\/p>\n We define variables using the var keyword (like the optional usage in C#), i.e.<\/p>\n In the case of situations where we want to declare the type. We declare the type after the variable name, i.e.<\/p>\n We could also use <\/p>\n Basic types<\/em><\/p>\n Ofcourse Go includes the basic types (see builtin.go) which include string, int, unit, byte, float, bool etc.<\/p>\n Loops<\/em><\/p>\n Ofcourse we for loops (see below), but interestingly no while loops<\/p>\n with the := reminds me of a Pascal crossed with C style. Notice no parenthesis are required around the for loop but braces are required.<\/p>\n Also parenthesis must be placed (opening parenthesis {) on the same line as the loop (of if statements).<\/p>\n Using a for loop like a while loop just means writing the following<\/p>\n A while(true) infinite loop can be written as <\/p>\n Flow control with if..else and switch statements<\/em><\/p>\n We can also declare\/assign variables as part of the if statement, for example<\/p>\n else statements must be on the closing brace line and their opening brace on the same line also, for example<\/p>\n Switch statements are pretty much as per C# etc.<\/p>\n like if statements, we can also assign variables and test them after the switch keyword and before the opening brace.<\/p>\n Functions<\/em><\/p>\n As mentioned already, we create functions using the func keyword. Functions can take arguments and return values (as you’d expect). For example<\/p>\n Note: we declare the return type after the function (or no type for the equivalent of a void function) and we use the return<\/em> keyword as per many C like languages.<\/p>\n We can pass multiple arguments into a function in the standard way<\/p>\n we can also group arguments of the same type like so<\/p>\n We’ve shown code returning a single value, but we can also return tuples easily using the following syntax<\/p>\n and assigning this we would have something like<\/p>\n We can create anonymous functions using the func() syntax, for example<\/p>\n will return a function which returns a string.<\/p>\n We can also pass variable arguments to a function (like vargs or params) using <\/p>\n Note: in this example the _ is used as range returns a tuple of index (int) and the value (i.e. value[index]), The _ can be used in situations where we want to ignore a value and is special in that it will not cause an unused variable compile time error.<\/p>\n Anonymous and named returns<\/em><\/p>\n In the above we looked at declaring return values like this<\/p>\n in that the return (string, string) has no variable name associated with it, but we can also return named variables, for example<\/p>\n at this point the named returns only really demonstrate a use as a form of documentation, but they also get automatically initialized to the defaults for the type and can be used in a similar way to the out keyword in C#, i.e. we can assign to them.<\/p>\n Here’s an example<\/p>\n so here we assign the named return a value and then we must still use a return. This allows us to build up the return tuple during the flow of the function, instead of storing as a local variable until we return the tuple.<\/p>\n Arrays<\/em><\/p>\n Let’s end this post with arrays. The standard [] syntax is used, here we declare an array and initialize it<\/p>\n arrays are base 0 index, hence<\/p>\n will result in Hello output to the console.<\/p>\n Package visibility<\/em><\/p>\n Functions and methods with a capitalized first letter (i.e. Pascal case) are public, whereas a lowercase first letter (i.e. Camel case) are private to the package. <\/p>\n In other words the public functions are visible globally whereas private are visible only within the package.<\/p>\n References<\/strong><\/p>\n The Go Programming Language<\/a> I like learning different programming languages. Sometime I learn alternate ways to do things which might be useful in my usual language, sometimes I get a feel for how another language might be better for certain tasks and gives me more options for developing apps. I recently started learning the language Go, so this is […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[178],"tags":[],"class_list":["post-5025","post","type-post","status-publish","format-standard","hentry","category-go"],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/5025","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/comments?post=5025"}],"version-history":[{"count":20,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/5025\/revisions"}],"predecessor-version":[{"id":5150,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/5025\/revisions\/5150"}],"wp:attachment":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/media?parent=5025"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/categories?post=5025"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/tags?post=5025"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\n
\r\npackage main\r\n\r\nimport "fmt"\r\n\r\nfunc main() {\r\n fmt.Println("Hello World")\r\n}\r\n<\/pre>\n<\/li>\n\r\ngo build hello-world.go\r\n<\/pre>\n
\r\ngo build\r\n<\/pre>\n
\r\ngo run hello-world.go\r\n<\/pre>\n
\r\npackage fmt\r\n<\/pre>\n
\r\ntype MyInteger int\r\n<\/pre>\n
\r\ntype MyStructure struct {\r\n\ta MyInteger\r\n\tb MyInteger\r\n}\r\n<\/pre>\n\r\nvar myInteger = 3\r\n<\/pre>\n
\r\nvar myInteger MyInteger = 3\r\n<\/pre>\n
\r\nvar myInteger = MyInteger(3)\r\n<\/pre>\n
\r\nfor i := 0; i < 3; i++ {\r\n fmt.Println("Hello")\r\n}\r\n<\/pre>\n\r\ni := 0\r\nfor i < 3 {\r\n fmt.Println("Hello")\r\n i++\r\n}\r\n<\/pre>\n\r\nfor {\r\n fmt.Println("Hello")\r\n}\r\n<\/pre>\n\r\nif i % 2 > 0 {\r\n fmt.Println(strconv.Itoa(i) + " Odd")\r\n}\r\n<\/pre>\n\r\nif isOdd := i % 2; isOdd > 0 {\r\n fmt.Println(strconv.Itoa(i) + " Odd")\r\n}\r\n<\/pre>\n\r\nif isOdd := i % 2; isOdd > 0 {\r\n fmt.Println(strconv.Itoa(i) + " Odd")\r\n} else {\r\n fmt.Println(strconv.Itoa(i) + " Even")\r\n}\r\n<\/pre>\n\r\nswitch i % 2 {\r\ncase 0:\r\n fmt.Println(strconv.Itoa(i) + " Odd")\r\ndefault:\r\n fmt.Println(strconv.Itoa(i) + " Even")\r\n}\r\n<\/pre>\n\r\nfunc isOdd(i int) bool {\r\n\treturn i % 2 != 0\r\n}\r\n<\/pre>\n\r\nfunc doSomething(i int, test bool) bool {\r\n\/\/ do something\r\n}\r\n<\/pre>\n\r\nfunc doSomething(a, b, c int) bool {\r\n\/\/ do something\r\n}\r\n<\/pre>\n\r\nfunc doSomething() (string, string) {\r\n\treturn "Hello", "World"\r\n}\r\n<\/pre>\n\r\na, b := doSomething()\r\n<\/pre>\n
\r\nfunc doSomething() func() string {\r\n\treturn func() string {\r\n\t\treturn "Hello World"\r\n\t}\r\n}\r\n<\/pre>\n\r\nfunc doSomething(args ...string) {\r\n\tfor _, arg := range args {\r\n\t\tfmt.Println(arg)\r\n\t}\r\n}\r\n<\/pre>\n\r\nfunc doSomething() (string, string) {\r\n\treturn "Hello", "World"\r\n}\r\n<\/pre>\n\r\nfunc doSomething() (a string, b string) {\r\n\treturn "Hello", "World"\r\n}\r\n<\/pre>\n\r\nfunc doSomething() (a string, b string) {\r\n\ta = "Hello"\r\n\tb = "World"\r\n\treturn\r\n}\r\n<\/pre>\n\r\na := [2]string{"Hello", "World"}\r\n<\/pre>\n\r\nfmt.Println(a[0]) \r\n<\/pre>\n
\nGo by example<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"