Go is a statically typed and compiled language designed by Google. It is somewhat similar to C. However, it is packed with more goodies such as garbage collection, memory safety, structural typing and concurrency. Its concurrency mechanisms make it possible to get the most out of the multicore and network machines. This is one of the best-selling points for Golang. Furthermore, Go is fast, expressive, clean and efficient. This is what makes Go so appealing to the developers to learn it.

PHP is a dynamically typed language which makes coding easier for newcomers. Now the question is, can PHP developers switch from a dynamically typed language to a statically typed language like Go? To find out, let’s check the syntax differences between Go and PHP.

Data types

Go supports both signed and unsigned integers whereas PHP only supports signed integers.

Another major difference is the array. Go has separate types for array and map whereas a PHP array is actually an ordered map.

Go does not have objects compared to PHP. However, Go has a struct type which is similar to object .

PHP types:

boolean

string

integer // Signed integer, PHP does not support unsigned integers.

float (also known as "floats", "doubles", or "real numbers")

array

object

null

resource

Go types:

string

bool

int int8 int16 int32 int64 // Signed integer

uint uint8 uint16 uint32 uint64 uintptr // Unsigned integers

byte // alias for uint8

rune // alias for int32

float32 float64

complex64 complex128

array

slices

map

struct

Variables

Go uses var for declaring the global and function variables. However, it also supports shorthand syntax with initialisers but can only be used inside a function. On the other hand, PHP only supports variable declaration with initialisers.

// Variable declarations // Go // PHP var i int $i = 0 // integer

var f float64 $f = 0.0 // float

var b bool $b = false // boolean

var s string $s = "" // string

var a [2]string $a = [] // array // Short variable declarations // Go // PHP i := 0 $i = 0 // integer

f := 0.0 $f = 0.0 // float

b := false $b = false // boolean

s := "" $s = "" // string

a := [1]string{"hello"} $a = [] // array

Type conversions

// Go i := 42 // Signed integer

f := float64(i) // Float

u := uint(f) // Unsigned integer // PHP $i = 1;

$f = (float) $i; // 1.0

$b = (bool) $f // true

$s = (string) $b // "1"

Arrays

// Go var a [2]string

a[0] = "Hello"

a[1] = "World" // OR

a := [2]string{"hello", "world"} // PHP $a = [

"hello",

"world"

];

Maps

// Go m := map[string]string{

"first_name": "Foo",

"last_name": "Bar",

} // PHP $m = [

"first_name" => "Foo",

"last_name" => "Bar"

];

Objects

Go does not support objects. However, you can achieve object like syntax using structs .

// Go package main import "fmt" type Person struct {

Name string

Address string

} func main() {

person := Person{"Foo bar", "Sydney, Australia"}

fmt.Println(person.Name)

} // PHP $person = new stdClass;

$person->Name = "Foo bar";

$person->Address = "Sydney, Australia"; echo $person->Name; // Or using type casting

$person = (object) [

'Name' => "Foo bar",

'Address' => "Sydney, Australia"

]; echo $person->Name;

Functions

The main difference between Go and PHP function is; Go function can return any number of results whereas a PHP function can only return one result. However, PHP can mimic the same functionality by returning an array.

// Go package main import "fmt" func fullname(firstName string, lastName string) (string) {

return firstName + " " + lastName

} func main() {

name := fullname("Foo", "Bar")

fmt.Println(name)

} // PHP function fullname(string $firstName, string $lastName) : string {

return $firstName . " " . $lastName;

} $name = fullname("Foo", "Bar"); echo $name;

// Returning multiple results // Go package main import "fmt" func swap(x, y string) (string, string) {

return y, x

} func main() {

a, b := swap("hello", "world")

fmt.Println(a, b)

} // PHP // Returning an array to get multiple results function swap(string $x, string $y): array {

return [$y, $x];

} [$a, $b] = swap('hello', 'world'); echo $a, $b;

Control Statements

If-Else

// Go package main import (

"fmt"

) func compare(a int, b int) {

if a > b {

fmt.Println("a is bigger than b")

} else {

fmt.Println("a is NOT greater than b")

}

} func main() {

compare(12, 10);

} // PHP function compare(int $a, int $b) {

if ($a > $b) {

echo "a is bigger than b";

} else {

echo "a is NOT greater than b";

}

} compare(12, 10);

Switch

According to the official Golang tour doc:

Go’s switch is like the one in C, C++, Java, JavaScript, and PHP, except that Go only runs the selected case, not all the cases that follow. In effect, the break statement that is needed at the end of each case in those languages is provided automatically in Go. Another important difference is that Go's switch cases need not be constants, and the values involved need not be integers.

// Go package main import (

"fmt"

"runtime"

) func main() {

fmt.Print("Go runs on ")



os := runtime.GOOS;



switch os {

case "darwin":

fmt.Println("OS X.")

case "linux":

fmt.Println("Linux.")

default:

fmt.Printf("%s.

", os)

}

} // PHP echo "PHP runs on ";



switch (PHP_OS) {

case "darwin":

echo "OS X.";

break;

case "linux":

echo "Linux.";

break;

default:

echo PHP_OS;

}

For loop

// Go package main import "fmt" func main() {

sum := 0



for i := 0; i < 10; i++ {

sum += i

}



fmt.Println(sum)

} // PHP $sum = 0;



for ($i = 0; $i < 10; $i++) {

$sum += $i;

} echo $sum;

While loop

Go does not have a while loop syntax. Instead, Go uses a for loop to perform the while loop.

// Go package main import "fmt" func main() {

sum := 1



for sum < 100 {

sum += sum

}



fmt.Println(sum)

} // PHP $sum = 1; while ($sum < 100) {

$sum += $sum;

} echo $sum;

Foreach/Range

PHP uses foreach to iterate over arrays and objects. On the contrary, Go uses range to iterate over a slice or map.

// Go package main import "fmt" func main() {

colours := []string{"Maroon", "Red", "Green", "Blue"}



for index, colour := range colours {

fmt.Printf("index: %d, colour: %s

", index, colour)

}

} // PHP $colours = ["Maroon", "Red", "Green", "Blue"];



foreach($colours as $index => $colour) {

echo "index: {$index}, colour: {$colour}

";

}

That’s it for today. I kept it small and concise. As a PHP developer, I have tried to share my knowledge while practicing Go. Feel free to share your thoughts. I hope you guys enjoyed reading the post.