Syntax comparison between Go and PHP

Go is a statically typed compiled language designed by Google. It's a bit like C, but it has more advantages, such as garbage collection, memory security, structure type and concurrency. Its concurrent mechanism enables multi-core and network machines to play the most role. This is one of the best selling points of GoLang. In addition, go is fast, expressive, clean and efficient. That's why go is so attractive to developers.

PHP is a dynamically typed language, which makes it easier for novices to write code. The question now is, can PHP developers switch from a dynamically typed language to a statically typed language like Go? To find out, let's compare the syntax differences between Go and PHP.

How to become an architect from a coder

data type

  • Go supports both signed and unsigned integers, while PHP only supports signed integers.
  • Another major difference is arrays. Go has separate types for array and map, while PHP arrays are actually ordered maps.
  • Go has no objects compared to PHP. However, go has a struct type similar to object.

PHP data type:

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 data type:

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

variable

Go uses var to declare global and function variables. However, it also supports shorthand syntax with initializers, but can only be used inside functions. PHP, on the other hand, only supports variable declarations with initializers.

// Variable declaration
// 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 declaration
// 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 conversion

// 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"

array

// 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"
];

object type

Go does not support objects. However, you can use structures to implement syntax such as object.

// 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 use type conversion
$person = (object) [
    'Name' => "Foo bar",
    'Address' => "Sydney, Australia"
];
echo $person->Name;

function

The main difference between Go and PHP functions is that Go functions can return any number of results, while PHP functions can only return one. However, PHP can simulate the same functionality by returning arrays.

// 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;

// Return 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
// Returns an array for multiple results
function swap(string $x, string $y): array {
    return [$y, $x];
}
[$a, $b] = swap('hello', 'world');
echo $a, $b;

Control statement

 

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 tutorial document of Golang:

Go's switch is similar to that in C, C +, Java, JavaScript and PHP, except that go only runs the selected case, not all subsequent cases. In fact, break statements are required after each case in these languages, and are automatically supplemented in go. Another important difference is that go's switch cases do not need to be constants, and the values involved do not need to 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.\n", 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 cycle

// 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 cycle

Go itself does not have the syntax of a while loop. Accordingly, go uses the for loop instead of 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 groups and objects. Correspondingly, Go uses range to iterate 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\n", index, colour)
    }
}
// PHP
$colours = ["Maroon", "Red", "Green", "Blue"];

foreach($colours as $index => $colour) {
    echo "index: {$index}, colour: {$colour}\n";
}

That's what we're talking about today. I try to keep the article short and concise. As a PHP developer, I try to share my knowledge while practicing Go. Please feel free to share your thoughts. I hope you enjoy reading this article.

How to become an architect from a coder

Tags: PHP Linux OS X Google

Posted on Thu, 16 Jan 2020 12:48:57 -0500 by Plxply