What are the differences between PHP syntax and Go syntax? Comparative introduction

This article will compare PHP syntax and Go syntax, and show you the differences between PHP syntax and Go syntax. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to everyone.

#Go is a statically typed compiled language designed by Google. It is somewhat similar to C, but it includes more advantages such as garbage collection, memory safety, structural types, and concurrency. Its concurrency mechanism enables multi-core and network machines to get the most out of them. This is one of GoLang’s best selling points. Additionally, Go is fast, expressive, clean, and efficient. This is why Go is so attractive for developers to learn.

PHP is a dynamically typed language that makes coding easier for newbies. 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.

Data types

• Go supports both signed and unsigned integers, while PHP only supports signed integers.
• Another major difference is arrays. Go has separate types for arrays and maps, whereas 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 variables and function variables. However, it also supports a shorthand syntax with an initializer, but only within a function. PHP, on the other hand, only supports variable declaration with an initializer.

// 变量声明
// 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
// 简短的变量声明
// 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 structs to implement syntax like 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;
// 或使用类型转换
$person = (object) [
    'Name' => "Foo bar",
    'Address' => "Sydney, Australia"
];
echo $person->Name;

Functions

The main difference between Go and PHP functions is; Go functions can return any number of results, while PHP functions can only return one result. However, PHP can emulate 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;

// 返回多个结果
// 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
// 返回一个数组以获得多个结果
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 Golang official tutorial document:

Go's switch and C, Similar in C, Java, JavaScript and PHP, except Go only runs the selected case instead of all subsequent cases. In fact, the break statement is required after every case in these languages, while in Go it is automatically added. 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 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 itself does not have the syntax of while loop. Correspondingly, Go uses for loops instead of implementing while loops.

// 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 arrays and objects. Correspondingly, Go uses range to iterate over slices or maps.

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

Related tutorial recommendations: "PHP Tutorial", "Go Tutorial"

The above is the detailed content of What are the differences between PHP syntax and Go syntax? Comparative introduction. For more information, please follow other related articles on the PHP Chinese website!