Skip to content

Instantly share code, notes, and snippets.

@npotier
Created September 6, 2016 10:13
Show Gist options
  • Star 4 You must be signed in to star a gist
  • Fork 1 You must be signed in to fork a gist
  • Save npotier/593b645025173ef8bbb5c59d3fd455fa to your computer and use it in GitHub Desktop.
Save npotier/593b645025173ef8bbb5c59d3fd455fa to your computer and use it in GitHub Desktop.
PSR-2 traduit en français
Guide du style de code
Ce guide étend et agrandit le PSR-1, le standard basique de codage
Le but de ce guide est de réduire la complexité de lecture du code d'auteurs différents. Il le fait en listant un ensemble de règles et d'explication à propos du format du code PHP.
Les règles de styles sont issues de points communs entre les différents membre du projet. Quans plusieurs auteurs collaborents ensemble sur différents projets, la mise en place de bonnes pratiques est une aide. Cependant, les avantages de ce guide ne sont pas les règles en elle-mêmes, mais le fait de partager ces règles.
Les mots clés "DOIT", "NE DOIT PAS", "REQUIS", "DEVRAIT", "NE DEVRAIT PAS", "RECOMMANDE", "POURAIT", "OPTIONNEL", dans ce document doivent être interprétés comme décrit dans la RFC 2119.
1. Présentation
Le code "DOIT" suivre le standard PSR 1.
Le code "DOIT" utiliser 4 espaces pour l'indentation, pas les tabulations.
il NE DOIT PAS y avoir de limite dure à la longueur de ligne. La limite de base est de 120 caractères; les lignes DEVRAIENT être de 80 caractères ou moins.
Il DOIT y avoir une ligne blanche après la déclaration du namespace, et il DOIT y avoir une ligne blanche après le block des déclarations use.
Les accolades ouvrantes pour les classes DOIVENT être sur la ligne suivante, et les accolades fermantes DOIVENT être sur la ligne suivante.
Les accolades ouvrantes pour les méthodes DOIVENT être sur la ligne suivante, et les accolades fermantes DOIVENT être sur la ligne suivante.
la visibilité DOIT être déclarées sur toutes les proprités et les méthodes; abstract et final DOIVENT être déclarées avant la visibilité; static DOIT être déclaré après la visibilité.
Les mots clés de contrôle de structure DOIVENT avoir un espace après eux; les appels aux méthodes et fonction NE DOIVENT PAS.
Les accolades ouvrantes pour les structures de contrôle DOIVENT être sur la même ligne, et les accolades fermantes DOIVENT aller sur la ligne suivante.
Les parenthèses ouvrantes des structures de contrôle NE DOIVENT PAS avoir d'espace après elles, et les parenthèses de fermeture NE DOIVENT PAS avoir d'espace avant.
1.1. Exemple
Cet exemple présente une partie des règles énoncées ci-dessus:
<?php
namespace Vendor\Package;
use FooInterface;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;
class Foo extends Bar implements FooInterface
{
public function sampleMethod($a, $b = null)
{
if ($a === $b) {
bar();
} elseif ($a > $b) {
$foo->bar($arg1);
} else {
BazClass::bar($arg2, $arg3);
}
}
final public static function bar()
{
// method body
}
}
2. Géneral
2.1. Standard de code basique
Le Code DOIT suivre toutes les règles énnoncées dans PSR-1.
2.2. Fichiers
Tous les fichiers PHP DOIVENT utiliser le linefeed Unix LF (fin de ligne).
Tous les fichiers PHP DOIVNET finir avec une seule ligne blanche.
Le tag de fermeture ?> peut ne pas être présent dans les fichiers ne contenant que du PHP.
2.3. Lignes
Il ne DEVRAIT PAS y avoir une limite dure à la longeur de ligne.
La limite de base DOIT être de 120 caractères; les outils automatique de vérification DOIVENT avertir mais NE DOIVENT pas lever d'erreur en ca de dépassement de la limite de base.
les lignes NE DEVRAIENT pas être plus longues que 80 caractères; les lignes plus longues DEVRAIENT être coupées en plusieurs lignes inférieures à 80 caractères.
il NE DOIT PAS y avoir de d'espaces blancs à la fin de lignes non vides.
des lignes blanches PEUVENT être ajoutées pour amélioerer la lisibilité et indiquer des blocs de code.
il ne DOIT PAS y avoir plus d'une instruction par ligne.
2.4. Indentation
le code DOIT utiliser une indentation de 4 espaces, et NE DOIT PAS utiliser de tabulation pour l'indentation.
NB : l'utilisation d'espaces uniquement, et pas d'un mélange d'espaces et de tabulation, aide à réduire les problèmes de diff, patch, historique et annotation. L'utilisation d'espaces aide ausi à insérer une sous indentation détaillées pour des alignements inter-ligne.
2.5. Mots clés et True/False/Null
Les mots clés PHP DOIVENT être en minuscule.
les constantes php true, false et null doivent être en minuscule.
3. Déclarations de Namespace et Use
Une seule ligne blanche DOIT être présente après la déclaration du namespace.
Toutes les déclaration de use DOIVENT être situées après la déclaration du namespace.
il ne DOIT y avoir qu'un seul mot clé use par déclaration.
Il DOIT y avoir une ligne blanche après chaque bloc de déclaration use.
Par exemple:
<?php
namespace Vendor\Package;
use FooClass;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;
// ... Code PHP additionnel ...
4. Classes, Propriétés et Méthodes
Le terme "Classe" fait références aux classes, interfaces et traits.
4.1. Extends et Implements
Le mot clés extends et implements DOIT être déclaré sur la même ligne que le nom de la classe.
L'accolade ouvrante de la classe DOIT être sur sa propre ligne; l'accolade fermante doit être sur la ligne suivant le corps de la classe.
<?php
namespace Vendor\Package;
use FooClass;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;
class ClassName extends ParentClass implements \ArrayAccess, \Countable
{
// constants, properties, methods
}
La liste des implements PEUT être coupée sur plusieurs lignes, où chaque ligne est identée une fois. Dans ce cas, le premier élément de la liste DOIT être sur la ligne suivante, et il ne DOIT y avoir qu'un interface par ligne.
<?php
namespace Vendor\Package;
use FooClass;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;
class ClassName extends ParentClass implements
\ArrayAccess,
\Countable,
\Serializable
{
// constants, properties, methods
}
4.2. Propriétés
La visibilité DOIT être déclarée sur chaque propriété.
le mot clé var NE DOIT PAS être utilisé pour déclarer une propriété.
il NE DOIT PAS y avoir plus d'une propriété définie par déclaration.
les noms des propriétés NE DEVRAIENT PAS être préfixés par un underscode pour indiquer les visibilité.
Les déclarations de propriétés peuvent ressembler à ceci :
<?php
namespace Vendor\Package;
class ClassName
{
public $foo = null;
}
4.3. Méthodes
la visibilité DOIT être déclarée sur toutes les méthodes.
Les noms des méthodes NE DEVRAIENT pas être préfixés par un underscode pour indiquer les visibilité.
Les noms des méthodes NE DOIVENT PAS être déclarés avec un espace après le nom de la méthode. L'accolade ouvrant DOIT être sur sa propre ligne, et l'accolade germande DOIT aller sur la ligne suivant le corps de la méthode. Il ne DOIT pas y avoir d'espace après une parenthèse ouvrante, et il NE DOIT PAS y avoir d'espace avant la parenthèse fermante.
La déclaration d'une méthode ressemble à l'exemple suivant. Notez le positionnement des parenthèses, virgules, espaces et accolades :
<?php
namespace Vendor\Package;
class ClassName
{
public function fooBarBaz($arg1, &$arg2, $arg3 = [])
{
// method body
}
}
4.4. Arguments de Méthodes
Dans la liste des arguments, il NE DOIT PAS y avoir d'espace avant chaque virgule, et il DOIT y avoir un espace après chaque virgule.
Les arguments de méthodes avec des valeurs par défaut DOIVENT aller à la fin de la liste des arguments.
<?php
namespace Vendor\Package;
class ClassName
{
public function foo($arg1, &$arg2, $arg3 = [])
{
// method body
}
}
La liste des arguments PEUT être coupée en plusieurs ligne, où chaque ligne est identée une fois. Dans ce cas, le premier élément de la liste DOIT être sur la ligne suivante, et il ne DOIT y avoir qu'un argument par ligne.
Quand la liste des arguments est coupée en plusieurs lignes, la parenthèse d'ouverture et de fin DOIVENT être placées sur leur propre ligne, avec un espace entre elles.
<?php
namespace Vendor\Package;
class ClassName
{
public function aVeryLongMethodName(
ClassTypeHint $arg1,
&$arg2,
array $arg3 = []
) {
// method body
}
}
4.5. abstract, final, et static
Quand présentes, les déclarations abstract et final DOIVENT précéder la déclaration de la visibilité.
Quand présente, la déclaration static DOIT venir après la déclaration de visibilité.
<?php
namespace Vendor\Package;
abstract class ClassName
{
protected static $foo;
abstract protected function zim();
final public static function bar()
{
// method body
}
}
4.6. Méthodes et appels de Fonction
Lors d'un appel à une méthode ou fonction, il NE DOIT PAS y avoir d'espace entre le nom de la fonction ou méthode et la parenthèse d'ouverture. Il ne DOIT PAS y avoir d'espace après la parenthèse d'ouverture, et il NE DOIT PAS y avoir d'espace avant la parenthèse de fermeture. Dans la liste des arguments, il NE DOIT PAS y avoir d'espace avant chaque virgule, et il DOIT y avoir un espace après chaque virgule.
<?php
bar();
$foo->bar($arg1);
Foo::bar($arg2, $arg3);
La liste des arguments PEUT être coupée en plusieurs ligne, où chaque ligne est identée une fois. Dans ce cas, le premier élément de la liste DOIT être sur la ligne suivante, et il ne DOIT y avoir qu'un argument par ligne.
<?php
$foo->bar(
$longArgument,
$longerArgument,
$muchLongerArgument
);
5. Structures de contrôle
Le règles générales de styles pour les structures de contrôle sont les suivantes:
Il DOIT y avoir un espace après le mot clé de la structure de contrôle
Il NE DOIT PAS y avoir un espace après le mot clé de la structure de contrôle
Il NE DOIT PAS y avoir d'espace après l'ouverture de la parenthèse
Il DOIT y avoir un espace entre la parenthèse de fermeture et l'ouverture de l'accolade
Le corps de la structure doit être indenté une seule fois
L'accolade de fermeture doit être sur la ligne suivant le corps de la structure
Le corps de chaque structure DOIT être entouré par des accolades. Cela standardise représentation des structures, et réduit la possibilités d'ajout d'erreur quand de nouvelles lignes sont ajoutées au corps de la structure.
5.1. if, elseif, else
Une structure en if ressemble à l'exemple suivant. Notez le positionnement des parenthèses, virgules, espaces et accolades, et que les instructions else et elseif sont sur la même ligne que l'accolade de fermeture du précédent corps.
<?php
if ($expr1) {
// if body
} elseif ($expr2) {
// elseif body
} else {
// else body;
}
Le mot clé elseif DEVRAIT être utilisé plutôt que else if de façon à ce que chaque mot de contrôle ressemble à un mot unique.
5.2. switch, case
Une structure en switch ressemble à l'exemple suivant. Notez le positionnement des parenthèses, virgules, espaces et accolades. l'instruction case DOIT être indentée une fois par rapport au switch, et le mot clés break (ou tout autre mot clé de terminaison) DOIT être indenté au même niveau que le corps du case. il DOIT y avoir un commentaire tels que // no break quand celui-ci est intentionnel dans un case non vide.
<?php
switch ($expr) {
case 0:
echo 'First case, with a break';
break;
case 1:
echo 'Second case, which falls through';
// no break
case 2:
case 3:
case 4:
echo 'Third case, return instead of break';
return;
default:
echo 'Default case';
break;
}
5.3. while, do while
Une déclaration while ressemble à l'exemple suivant. Notez le positionnement des parenthèses, virgules, espaces et accolades.
<?php
while ($expr) {
// structure body
}
De façon similaire, une déclaration do while ressemble à l'exemple suivant. Notez le positionnement des parenthèses, virgules, espaces et accolades.
<?php
do {
// structure body;
} while ($expr);
5.4. for
Une déclaration for ressemble à l'exemple suivant. Notez le positionnement des parenthèses, virgules, espaces et accolades.
<?php
for ($i = 0; $i < 10; $i++) {
// for body
}
5.5. foreach
Une déclaration foreach ressemble à l'exemple suivant. Notez le positionnement des parenthèses, virgules, espaces et accolades.
<?php
foreach ($iterable as $key => $value) {
// foreach body
}
5.6. try, catch
Une déclaration try catch ressemble à l'exemple suivant. Notez le positionnement des parenthèses, virgules, espaces et accolades.
<?php
try {
// try body
} catch (FirstExceptionType $e) {
// catch body
} catch (OtherExceptionType $e) {
// catch body
}
6. Closures
Les closures DOIVENT être déclarées avec un espace après le mot clé function, et un espace avant et après le mot clé use.
L'accolade d'ouverture DOIT être sur la même ligne et l'accolade de fermeture DOIT être sur la ligne suivant le corps de la fonction.
il ne DOIT PAs y avoir d'espace après la parenthèse d'ouverture de la liste des arguments, et il ne DOIT PAS y avoir d'espace avant la parenthèse de fermeture de la liste des arguments et de la liste des variables.
Dans la liste des arguments et des variables, il ne DOIT PAS y avoir d'espace avant chaque virgule, et il DOIT y avoir un espace après chaque virgule.
Les arguments de la closure avec des valeurs par défaut DOIVENT se situer à la fin de la liste des arguments.
Une déclaration de closure ressemble à l'exemple suivant. Notez le positionnement des parenthèses, virgules, espaces et accolades.
<?php
$closureWithArgs = function ($arg1, $arg2) {
// body
};
$closureWithArgsAndVars = function ($arg1, $arg2) use ($var1, $var2) {
// body
};
La liste des arguments et des variables PEUT être coupée en plusieurs ligne, où chaque ligne est identée une fois. Dans ce cas, le premier élément de la liste DOIT être sur la ligne suivante, et il ne DOIT y avoir qu'un argument par ligne.
Quand la liste des arguments est coupée en plusieurs lignes, la parenthèse d'ouverture et de fin DOIVENT être placées sur leur propre ligne, avec un espace entre elles.
Une déclaration try catch ressemble à l'exemple suivant. Notez le positionnement des parenthèses, virgules, espaces et accolades.
Les exemples ci-dessous montrent des closures avec ou sans liste d'arguments et une liste coupée en plusieurs lignes.
<?php
$longArgs_noVars = function (
$longArgument,
$longerArgument,
$muchLongerArgument
) {
// body
};
$noArgs_longVars = function () use (
$longVar1,
$longerVar2,
$muchLongerVar3
) {
// body
};
$longArgs_longVars = function (
$longArgument,
$longerArgument,
$muchLongerArgument
) use (
$longVar1,
$longerVar2,
$muchLongerVar3
) {
// body
};
$longArgs_shortVars = function (
$longArgument,
$longerArgument,
$muchLongerArgument
) use ($var1) {
// body
};
$shortArgs_longVars = function ($arg) use (
$longVar1,
$longerVar2,
$muchLongerVar3
) {
// body
};
Noter que les règles de formattage s'appliquent également quand la closure est utilisée directement dans un appel de fonction ou de méthode en tant qu'argument.
<?php
$foo->bar(
$arg1,
function ($arg2) use ($var1) {
// body
},
$arg3
);
7. Conclusion
Il y a de nombreux élements de style ou bonnes pratiques exclus de ce guide. Cela inclut mais ne se limite pas à:
Déclaration de variables globales et constantes globales
Déclaration de fonctions
Déclarration et assignation
Alignement inter-ligne
Commentaires et blocs de documentation
Préfixes et sufixes de noms de classes
Bonnes pratiques
De futures recommandations PEUVENT réviser ou étendre ce guide pour adresser de nouveaux éléments de guide ou pratiques.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment