Wie vergleichen sich die Syntaxen von Go und PHP?

                                                                                                                                     

Go ist eine statisch typisierte kompilierte Sprache, die von Google entwickelt wurde. Es ähnelt in gewisser Weise C, bietet jedoch weitere Vorteile wie Garbage Collection, Speichersicherheit, Strukturtypen und Parallelität. Sein Parallelitätsmechanismus ermöglicht es Multicore- und Netzwerkmaschinen, das Beste aus ihnen herauszuholen. Dies ist eines der besten Verkaufsargumente von GoLang. Darüber hinaus ist Go schnell, ausdrucksstark, sauber und effizient. Aus diesem Grund ist Go für Entwickler so attraktiv zum Erlernen.

PHP ist eine dynamisch typisierte Sprache, die das Codieren für Neulinge einfacher macht. Die Frage ist nun: Können PHP-Entwickler von einer dynamisch typisierten Sprache zu einer statisch typisierten Sprache wie Go wechseln? Um das herauszufinden, vergleichen wir die Syntaxunterschiede zwischen Go und PHP.

Datentyp

• Go unterstützt sowohl vorzeichenbehaftete als auch vorzeichenlose Ganzzahlen, während PHP nur vorzeichenbehaftete Ganzzahlen unterstützt.
• Ein weiterer großer Unterschied sind Arrays. Go verfügt über separate Typen für Arrays und Maps, wohingegen PHP-Arrays eigentlich geordnete Maps sind.
• Go hat im Vergleich zu PHP keine Objekte. Go hat jedoch einen object-Typ, der struct ähnelt.

PHP-Datentyp:

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-Datentyp:

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

Variablen

Go verwendet var, um globale Variablen und Funktionsvariablen zu deklarieren . Es unterstützt jedoch auch eine Kurzsyntax mit einem Initialisierer, allerdings nur innerhalb einer Funktion. PHP hingegen unterstützt die Variablendeklaration nur mit einem Initialisierer.

// 变量声明
// 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

Typkonvertierung

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

Objekttyp

Go unterstützt keine Objekte. Sie können jedoch eine Syntax wie structs mit object implementieren.

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

Funktion

Der Hauptunterschied zwischen Go- und PHP-Funktionen besteht darin, dass Go-Funktionen eine beliebige Anzahl von Ergebnissen zurückgeben können, während PHP-Funktionen nur ein Ergebnis zurückgeben können. PHP kann jedoch dieselbe Funktionalität emulieren, indem es ein Array zurückgibt.

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

Kontrollanweisung

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

Schalter

Laut dem offiziellen Golang-Tutorialdokument:

Go's Schalter Ähnlich wie in C, C++, Java, JavaScript und PHP, außer dass Go nur den ausgewählten Fall ausführt und nicht alle nachfolgenden Fälle. Tatsächlich ist die break-Anweisung in diesen Sprachen nach jedem Fall erforderlich, während sie in Go automatisch vervollständigt wird. Ein weiterer wichtiger Unterschied besteht darin, dass Gos Switch-Fälle keine Konstanten sein müssen und die beteiligten Werte keine ganzen Zahlen sein müssen.

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

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

Go selbst hat nicht die Syntax einer while-Schleife. Dementsprechend verwendet Go for-Schleifen, anstatt

// 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 verwendet foreach, um Arrays und Objekte zu iterieren. Dementsprechend verwendet Go range, um über Slices oder Maps zu iterieren.

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

Das war’s für heute. Ich versuche, die Artikel klein und prägnant zu halten. Als PHP-Entwickler versuche ich, mein Wissen beim Üben von Go weiterzugeben. Bitte zögern Sie auch nicht, Ihre Gedanken mitzuteilen. Ich hoffe, Ihnen hat die Lektüre dieses Artikels gefallen.

Das obige ist der detaillierte Inhalt vonWie vergleichen sich die Syntaxen von Go und PHP?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!