Was sind die Unterschiede zwischen der PHP-Syntax und der Go-Syntax? Vergleichende Einführung

Dieser Artikel vergleicht die PHP-Syntax und die Go-Syntax und zeigt Ihnen die Unterschiede zwischen der PHP-Syntax und der Go-Syntax. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird für alle hilfreich sein.

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. 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

Variable

Go verwendet var, um globale Variablen und Funktionsvariablen zu deklarieren . 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
// 简短的变量声明
// 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 structs verwenden, um eine Syntax wie object zu 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;

Steueranweisung

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

Laut dem offiziellen Golang-Tutorialdokument:

Go's switch und C, Ähnlich in 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 zu implementieren, um über Arrays und Objekte zu iterieren. Dementsprechend verwendet Go foreach, um über Slices oder Maps zu iterieren. range

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

Empfohlene verwandte Tutorials: „

PHP-Tutorial“, „Go-Tutorial“

Das obige ist der detaillierte Inhalt vonWas sind die Unterschiede zwischen der PHP-Syntax und der Go-Syntax? Vergleichende Einführung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!