La différence de syntaxe entre PHP et Go

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.

Types 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 de structure similaire à celui d'un objet.

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

Variable

Go utilise var pour déclarer des variables globales et une fonction variables . 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

rrree

Conversion de type

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

Tableau

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

Type d'objet

Go ne prend pas en charge les objets. Cependant, vous pouvez utiliser des structures pour implémenter une syntaxe de type objet.

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

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

Instruction de contrôle

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

Selon le document du didacticiel officiel de Golang :

Les commutateurs de Go sont similaires à ceux 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, les instructions break sont requises après chaque cas dans ces langages, alors qu'en Go, elles sont automatiquement ajoutées. 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"
)
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 Loop

Go lui-même n'a pas la syntaxe de la boucle while. En conséquence, Go utilise des boucles for au lieu de boucles while.

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

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.

Tutoriels recommandés : "Tutoriel PHP" "Go Tutorial"

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!