Der Syntaxunterschied zwischen PHP und Go

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.

Datentypen

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. Allerdings hat Go einen Strukturtyp ähnlich dem Objekt.

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

Variable

Go verwendet var, um globale Variablen und Funktionen zu deklarieren Variablen. Es unterstützt jedoch auch eine Kurzsyntax mit einem Initialisierer, jedoch 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

rrree

Typkonvertierung

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

Array

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

Objekttyp

Go unterstützt keine Objekte. Sie können Strukturen jedoch verwenden, um eine objektähnliche Syntax zu implementieren.

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

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

Kontrollanweisung

If-Else

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

Switch

Laut dem offiziellen Golang-Tutorialdokument :

Die Schalter von Go ähneln denen in C, C+, Java, JavaScript und PHP, mit der Ausnahme, dass Go nur den ausgewählten Fall und nicht alle nachfolgenden Fälle ausführt. Tatsächlich sind in diesen Sprachen nach jedem Fall break-Anweisungen erforderlich, während sie in Go automatisch hinzugefügt werden. 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"
)
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);

While-Schleife

Go selbst hat nicht die Syntax einer While-Schleife. Dementsprechend verwendet Go for-Schleifen anstelle von while-Schleifen.

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

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.

Empfohlene Tutorials: „PHP-Tutorial“ „Go-Tutorial“

Das obige ist der detaillierte Inhalt vonDer Syntaxunterschied zwischen PHP und Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!