Comment les syntaxes de Go et PHP se comparent-elles ?

                                                                                                                                      

Go est un langage compilé à typage statique conçu par Google. Il est quelque peu similaire au C, mais il inclut plus d'avantages, tels que le garbage collection, la sécurité de la mémoire, les types structurels et la concurrence. Son mécanisme de concurrence permet aux machines multicœurs et en réseau d'en tirer le meilleur parti. C’est l’un des meilleurs arguments de vente de GoLang. De plus, Go est rapide, expressif, propre et efficace. C’est pourquoi Go est si attrayant pour les développeurs.

PHP est un langage typé dynamiquement qui facilite le codage pour les débutants. La question est maintenant : les développeurs PHP peuvent-ils passer d'un langage typé dynamiquement à un langage typé statiquement comme Go ? Pour le savoir, comparons les différences de syntaxe entre Go et PHP.

Type de données

• Go prend en charge les entiers signés et non signés, tandis que PHP ne prend en charge que les entiers signés.
• Une autre différence majeure concerne les tableaux. Go a des types distincts pour les tableaux et les cartes, alors que les tableaux PHP sont en fait des cartes ordonnées.
• Go n'a pas d'objets par rapport à PHP. Cependant, Go a un type object similaire à struct.

Type de données PHP :

boolean
string
integer // Signed integer, PHP does not support unsigned integers.
float (also known as "floats", "doubles", or "real numbers")
array
object
null
resource

Type de données Go :

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

Variables

Go utilise var pour déclarer des variables globales et des variables de fonction . Cependant, il prend également en charge une syntaxe abrégée avec un initialiseur, mais uniquement au sein d'une fonction. PHP, en revanche, ne prend en charge que la déclaration de variable avec un initialiseur.

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

Conversion de type

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

Type d'objet

Go ne prend pas en charge les objets. Cependant, vous pouvez implémenter une syntaxe telle que structs en utilisant 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;

Fonction

La principale différence entre les fonctions Go et PHP est : les fonctions Go peuvent renvoyer n'importe quel nombre de résultats, tandis que les fonctions PHP ne peuvent renvoyer qu'un seul résultat. Cependant, PHP peut émuler la même fonctionnalité en renvoyant un tableau.

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

Instruction de contrôle

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

Selon le document tutoriel officiel de Golang :

Go's switch Similaire à celui de C, C++, Java, JavaScript et PHP, sauf que Go n'exécute que le cas sélectionné au lieu de tous les cas suivants. En fait, l'instruction break est requise après chaque cas dans ces langues, alors qu'en Go, elle est automatiquement complétée. Une autre différence importante est que les cas de commutation de Go n'ont pas besoin d'être des constantes et que les valeurs impliquées n'ont pas besoin d'être des nombres entiers.

// 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 lui-même n'a pas la syntaxe de la boucle while. En conséquence, Go utilise des boucles for au lieu d'implémenter des boucles while

// 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 utilise foreach pour itérer des tableaux et des objets. En conséquence, Go utilise range pour parcourir des tranches ou des cartes.

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

C'est tout pour aujourd'hui. J'essaie de garder les articles petits et concis. En tant que développeur PHP, j'essaie de partager mes connaissances tout en pratiquant Go. N'hésitez pas également à partager vos réflexions. J'espère que vous avez apprécié la lecture de cet article.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!