apply go fmt

Author: mfbmina

array.go

@@ -14,13 +14,13 @@ import "fmt"
 // - TYPE: any of default types in Go or structs that you've created.
 // - DEFAULT_VALUES: this is optional but it is used when you want to create an array with default values on it.
 func main() {
-  var words [2]string // declaring an array called words with 2 elements.
-  words[0] = "Hello" // assign the word "Hello" to the first element into the array
-  words[1] = "World" // assign the word "World" to the second element into the array
+	var words [2]string // declaring an array called words with 2 elements.
+	words[0] = "Hello"  // assign the word "Hello" to the first element into the array
+	words[1] = "World"  // assign the word "World" to the second element into the array
 
-  fmt.Println(words[0], words[1]) // Prints the first and the second element of the array.
-  fmt.Println(words) // Prints the whole array
+	fmt.Println(words[0], words[1]) // Prints the first and the second element of the array.
+	fmt.Println(words)              // Prints the whole array
 
-  primes := [6]int{2, 3, 5, 7, 11, 13} // declaring an array for the 6 prime numbers.
-  fmt.Println(primes)
+	primes := [6]int{2, 3, 5, 7, 11, 13} // declaring an array for the 6 prime numbers.
+	fmt.Println(primes)
 }

conditional_statements.go

@@ -21,42 +21,42 @@ import "fmt"
 //
 // In Golang we have two ways of doing conditional statements: `if/else` and `switch/case`.
 func main() {
-  var age int
-  var country string
-  fmt.Println("How old are you?")
-  fmt.Scanln(&age)
-  fmt.Println("Where are you from?")
-  fmt.Scanln(&country)
+	var age int
+	var country string
+	fmt.Println("How old are you?")
+	fmt.Scanln(&age)
+	fmt.Println("Where are you from?")
+	fmt.Scanln(&country)
 
-  // One good example is asking your age before visiting some websites.
-  // If the person is a minor, we shouldn't allow him/her to visit the page.
-  // This case is what we call `if/else` statement because it should choose between actions by evaluating expressions as true or false.
-  // It will always execute the first true condition and if no condition is satisfied, it will execute the else.
-  if age >= 21 {
-    // If the provided age is equal or higher to 21, it will print "Welcome!"
-    fmt.Println("Welcome!")
-  } else if age >= 18 && country != "US" {
-    // If the provided age is equal or higher to 18 and the user is not from the US it will print the message.
-    fmt.Println("Quite young but still welcome!")
-  } else {
-    // If the age is below 18 it will print the following message.
-    fmt.Println("hmmm... maybe you should not be allowed on here!")
-  }
+	// One good example is asking your age before visiting some websites.
+	// If the person is a minor, we shouldn't allow him/her to visit the page.
+	// This case is what we call `if/else` statement because it should choose between actions by evaluating expressions as true or false.
+	// It will always execute the first true condition and if no condition is satisfied, it will execute the else.
+	if age >= 21 {
+		// If the provided age is equal or higher to 21, it will print "Welcome!"
+		fmt.Println("Welcome!")
+	} else if age >= 18 && country != "US" {
+		// If the provided age is equal or higher to 18 and the user is not from the US it will print the message.
+		fmt.Println("Quite young but still welcome!")
+	} else {
+		// If the age is below 18 it will print the following message.
+		fmt.Println("hmmm... maybe you should not be allowed on here!")
+	}
 
-  var animal string
-  fmt.Println("What is your favorite animal?")
-  fmt.Scanln(&animal)
+	var animal string
+	fmt.Println("What is your favorite animal?")
+	fmt.Scanln(&animal)
 
-  // Sometimes, we do not want to check if something is true or false, but to check if it has a specific value.
-  // This is the best option to use the switch statement.
-  switch animal {
-  case "dog":
-    fmt.Println("Dogs bark, right?")
-  case "cat":
-    fmt.Println("Meow!")
-  case "fish":
-    fmt.Println("I've no clue how a fish sounds...")
-  default:
-    fmt.Println("Hm... I need to upgrady my animal list...")
-  }
+	// Sometimes, we do not want to check if something is true or false, but to check if it has a specific value.
+	// This is the best option to use the switch statement.
+	switch animal {
+	case "dog":
+		fmt.Println("Dogs bark, right?")
+	case "cat":
+		fmt.Println("Meow!")
+	case "fish":
+		fmt.Println("I've no clue how a fish sounds...")
+	default:
+		fmt.Println("Hm... I need to upgrady my animal list...")
+	}
 }

constants_and_variables.go

@@ -35,17 +35,17 @@ import "fmt"
 const hello = "Hello, World." // Defining a constant
 
 func main() {
-  var number int // Declaring an integer variable
-  number = 10 // Assign 10 to this variable
-  fmt.Println("Number =", number) // Printing number to the screen
-  // number = "maybe?" // if you un-comment, it will raise a compilation error.
+	var number int                  // Declaring an integer variable
+	number = 10                     // Assign 10 to this variable
+	fmt.Println("Number =", number) // Printing number to the screen
+	// number = "maybe?" // if you un-comment, it will raise a compilation error.
 
-  var name = "Matheus"  // Declaring a string variable and assigning a text to it.
-  fmt.Println(hello, "I'm", name) // Printing the constant hello and the variable name to the screen
-  // hello = "hm..." // if you un-comment, it will raise a compilation error.
-  name = "Mina"
-  fmt.Println(hello, "I'm", name) // Printing the constant hello and the variable name to the screen
+	var name = "Matheus"            // Declaring a string variable and assigning a text to it.
+	fmt.Println(hello, "I'm", name) // Printing the constant hello and the variable name to the screen
+	// hello = "hm..." // if you un-comment, it will raise a compilation error.
+	name = "Mina"
+	fmt.Println(hello, "I'm", name) // Printing the constant hello and the variable name to the screen
 
-  pi := 3.1415 // Declaring a variable called pi and assigning a value to it
-  fmt.Println("Pi =", pi) // Printing pi to the screen
+	pi := 3.1415            // Declaring a variable called pi and assigning a value to it
+	fmt.Println("Pi =", pi) // Printing pi to the screen
 }

functions.go

@@ -21,52 +21,52 @@ import "fmt"
 // To run a Go code, we always define a function called main, which will be executed when you call:
 // $ go run file.go
 func main() {
-   // This is how a function can be called.
-  hi()
+	// This is how a function can be called.
+	hi()
 
-  // The return of functions can be stored as variables.
-  // Also, to provide the arguments to the functions you don't need to say the type.
-  value := add(1, 1)
-  fmt.Println("1 + 1 =", value)
+	// The return of functions can be stored as variables.
+	// Also, to provide the arguments to the functions you don't need to say the type.
+	value := add(1, 1)
+	fmt.Println("1 + 1 =", value)
 
-  x := 1
-  y := 2
-  // This is how we call a function with pointers.
-  // We can see the variables from main function got their value changed.
-  swap(&x, &y)
-  fmt.Println("x =", x)
-  fmt.Println("y =", y)
+	x := 1
+	y := 2
+	// This is how we call a function with pointers.
+	// We can see the variables from main function got their value changed.
+	swap(&x, &y)
+	fmt.Println("x =", x)
+	fmt.Println("y =", y)
 
-  // Passing array to a function.
-  array := []int{1, 2, 3, 4, 5}
-  print_elements(array, 5)
+	// Passing array to a function.
+	array := []int{1, 2, 3, 4, 5}
+	print_elements(array)
 }
 
 // We are declaring a function called `hi`, which will add two numbers.
 // As you can see, it receives no parameters and will not return anything to the main function.
 func hi() {
-  fmt.Println("Hello!")
+	fmt.Println("Hello!")
 }
 
 // We are declaring a function called `add`, which will add two numbers.
 // As you can see, it receives two parameters of `int` type: `x` and `y`.
 // It will always returns another `int`.
 func add(x int, y int) int {
-  return x + y
+	return x + y
 }
 
 // Functions can receive pointers as arguments.
 // This is really useful when we want to change values in variables from different contexts.
 // In this case, we are receive pointers for two integers and we are swaping their values.
 func swap(x *int, y *int) {
-  temp := *x
-  *x = *y
-  *y = temp
+	temp := *x
+	*x = *y
+	*y = temp
 }
 
 // Functions can receive arrays as arguments.
-func print_elements(array []int, size int) {
-  for i := 0; i < size; i++ {
-    fmt.Println(array[i])
-  }
+func print_elements(array []int) {
+	for _, v := range array {
+		fmt.Println(v)
+	}
 }

pointers.go

@@ -9,32 +9,32 @@ import "fmt"
 // Unlike C, Go has no pointer arithmetic.
 
 type Rectangle struct {
-  lenght int
-  width int
+	lenght int
+	width  int
 }
 
 func main() {
-  // Defining a pointer p.
-  var p *int
-  i := 42
+	// Defining a pointer p.
+	var p *int
+	i := 42
 
-  // If you want to get the pointer for another variable you can use the & operator.
-  p = &i
+	// If you want to get the pointer for another variable you can use the & operator.
+	p = &i
 
-  // To access value from pointer you should use the * operator.
-  fmt.Println("Value holded by p", p)
-  fmt.Println("Reading i through p", *p)
+	// To access value from pointer you should use the * operator.
+	fmt.Println("Value holded by p", p)
+	fmt.Println("Reading i through p", *p)
 
-  // setting i through the pointer p
-  // This is known as "dereferencing" or "indirecting".
-  *p = 21
-  fmt.Println("New value at i through p", *p)
+	// setting i through the pointer p
+	// This is known as "dereferencing" or "indirecting".
+	*p = 21
+	fmt.Println("New value at i through p", *p)
 
-  r := Rectangle{1, 2}
-  // Defining a pointer for r
-  r_pointer := &r
+	r := Rectangle{1, 2}
+	// Defining a pointer for r
+	r_pointer := &r
 
-  // If you have a pointer for a struct, you can call its attributes in the same way if it was not a pointer.
-  area := r_pointer.lenght * r_pointer.width
-  fmt.Println("rectangle area's:", area)
+	// If you have a pointer for a struct, you can call its attributes in the same way if it was not a pointer.
+	area := r_pointer.lenght * r_pointer.width
+	fmt.Println("rectangle area's:", area)
 }

stdin_stdout.go

@@ -6,13 +6,13 @@ import "fmt"
 // In basic programs like ours, we do that by reading information from the terminal and printing it back there.
 // This is what we call "reading from the `stdin`" and "printing to the `stdout`"
 func main() {
-  var name string
+	var name string
 
-  // We are printing a question to the stdout
-  fmt.Println("What is your name?")
+	// We are printing a question to the stdout
+	fmt.Println("What is your name?")
 
-  // We are reading the awnser from the user and storing it in a variable called name.
-  fmt.Scanln(&name)
+	// We are reading the awnser from the user and storing it in a variable called name.
+	fmt.Scanln(&name)
 
-  fmt.Println("Hello", name)
+	fmt.Println("Hello", name)
 }

structs.go

@@ -13,23 +13,23 @@ import "fmt"
 // - FIELD_NAME: the name that you're gonna use for the field.
 // - FIELD_TYPE: any of default types in Go or structs that you've created.
 type Rectangle struct {
-  lenght int
-  width int
+	lenght int
+	width  int
 }
 
 func main() {
-  var rectangle_1 Rectangle // Declaring a struct without any default value.
-  fmt.Println(rectangle_1)
+	var rectangle_1 Rectangle // Declaring a struct without any default value.
+	fmt.Println(rectangle_1)
 
-  // To set the fields of the struct, you use `variable.field_name` and then the operator =
-  rectangle_1.width = 1
-  rectangle_1.lenght = 2
-  fmt.Println(rectangle_1)
+	// To set the fields of the struct, you use `variable.field_name` and then the operator =
+	rectangle_1.width = 1
+	rectangle_1.lenght = 2
+	fmt.Println(rectangle_1)
 
-  rectangle_2 := Rectangle{3, 2} // Declaring a struct with default values.
+	rectangle_2 := Rectangle{3, 2} // Declaring a struct with default values.
 
-  // To get the fields of the struct, you use `variable.field_name`
-  area := rectangle_2.lenght * rectangle_2.width
+	// To get the fields of the struct, you use `variable.field_name`
+	area := rectangle_2.lenght * rectangle_2.width
 
-  fmt.Println("rectangle_2 area's:", area)
+	fmt.Println("rectangle_2 area's:", area)
 }