Introduction

Vous êtes-vous déjà retrouvé face à un vérificateur de style signalant qu'une ligne est trop longue, même si elle vous a semblée raisonnable ? Ce guide clarifie les directives de longueur de ligne de PSR-2, en abordant spécifiquement la distinction entre les limites strictes et les limites souples. Vous apprendrez ce que sont ces limites, comment elles affectent le formatage automatique du code, et vous comprendrez pourquoi votre code peut être signalé malgré une apparence visuellement acceptable. Nous démystifierons les nuances des recommandations de PSR-2 pour un code plus propre et plus lisible.

Règles de longueur de ligne PSR-2

## Style de codage PSR-2

Le style de codage PSR-2 définit des directives de longueur de ligne pour le code PHP, mais les règles peuvent être déroutantes. La norme établit deux limites de longueur de ligne : un maximum préféré de 80 caractères et une limite souple de 120 caractères. Les lignes allant jusqu'à 80 caractères sont considérées comme idéales et toujours acceptables.

La "limite souple" de 120 caractères signifie que les outils automatisés comme les linters et les IDE doivent émettre un avertissement si une ligne dépasse cette longueur. Cependant, ces outils ne doivent pas traiter le dépassement de 120 caractères comme une erreur qui empêche l'exécution du code. L'intention est d'encourager la lisibilité tout en permettant des exceptions occasionnelles où le fractionnement d'une ligne serait préjudiciable.

Essentiellement, privilégiez le fait de maintenir les lignes en dessous de 80 caractères autant que possible. Si une ligne dépasse 80 caractères mais reste en dessous de 120, elle est généralement acceptable, mais soyez attentif à la lisibilité. Les lignes de plus de 120 caractères nécessitent une attention particulière et déclenchent un avertissement des outils automatisés.

<?php

/**
 * Function to calculate the sum of two numbers.
 *
 * @param int $a First number.
 * @param int $b Second number.
 * @return int Sum of the two numbers.
 */
function addNumbers(int $a, int $b): int {
    return $a + $b;
}

// Example usage
$result = addNumbers(5, 3);
echo "The sum is: " . $result;

?>

Interpréter les limites souples et rigides

PSR-2 définit deux directives de longueur de ligne pour le code PHP, distinguées par leur sévérité pour les vérificateurs de style automatisés. La « limite souple » de 120 caractères agit comme une suggestion. Les vérificateurs de style sont invités à émettre des avertissements lorsque les lignes dépassent cette limite, mais ne doivent pas les signaler comme des erreurs qui interrompent le processus.

La « limite stricte » n'existe pas dans PSR-2. Les lignes devraient idéalement rester en dessous de 80 caractères, en particulier lors du fractionnement de longues lignes en plusieurs lignes suivantes. Cela favorise la lisibilité et la maintenabilité.

Essentiellement, visez des lignes de moins de 80 caractères, mais des lignes occasionnelles allant jusqu’à 120 sont autorisées, déclenchant seulement un avertissement des outils automatisés. La principale conclusion est que les directives « DOIT » et « DOIVENT » s’appliquent aux vérificateurs de style automatisés, et non aux actions de codage direct du programmeur.

<?php
/**
 * Function to interpret soft vs hard limits.
 *
 * @param int $softLimit Soft limit value.
 * @param int $hardLimit Hard limit value.
 * @return string Interpretation of the limits.
 */
function interpretLimits($softLimit, $hardLimit) {
    // Check if inputs are valid integers
    if (!is_int($softLimit) || !is_int($hardLimit)) {
        return "Error: Both soft and hard limits must be integers.";
    }

    // Compare soft and hard limits
    if ($softLimit > $hardLimit) {
        return "Soft limit exceeds hard limit. Please adjust.";
    } elseif ($softLimit == $hardLimit) {
        return "Soft and hard limits are equal.";
    } else {
        return "Soft limit is within the acceptable range of the hard limit.";
    }
}

// Example usage
$soft = 10;
$hard = 20;

$result = interpretLimits($soft, $hard);
echo $result; // Output: Soft limit is within the acceptable range of the hard limit.
?>

Implications pratiques pour les développeurs

## Directives de style PSR-2

Les directives de style PSR-2 établissent des recommandations de longueur de ligne pour le code PHP, mais la distinction entre les limites « souples » et « strictes » peut être source de confusion. La norme indique une limite souple de 120 caractères et un maximum préféré de 80 caractères. Ces limites concernent principalement les vérificateurs de style automatisés, et non le développeur directement.

La « limite souple » de 120 caractères signifie que le dépassement de cette limite ne déclenchera pas d'erreur de la part des outils automatisés. Au lieu de cela, ces outils sont tenus d'émettre un avertissement, indiquant un problème de lisibilité potentiel. Les lignes dépassant 80 caractères devraient idéalement être divisées en plusieurs lignes afin de maintenir la clarté du code.

Essentiellement, les développeurs devraient s'efforcer de maintenir les lignes à moins de 80 caractères chaque fois que cela est possible. Les lignes légèrement plus longues sont acceptables, mais les outils automatisés les signaleront comme un avertissement, invitant à envisager une refactorisation pour une meilleure lisibilité.

<?php
// Function to fetch user data from a database
function getUserData($userId) {
    // Database connection parameters
    $host = 'localhost';
    $dbname = 'example_db';
    $username = 'root';
    $password = '';

    try {
        // Create a new PDO instance
        $pdo = new PDO("mysql:host=$host;dbname=$dbname", $username, $password);
        $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

        // Prepare the SQL query to fetch user data
        $sql = "SELECT * FROM users WHERE id = :userId";
        $stmt = $pdo->prepare($sql);

        // Bind the parameter and execute the query
        $stmt->bindParam(':userId', $userId);
        $stmt->execute();

        // Fetch the result as an associative array
        $userData = $stmt->fetch(PDO::FETCH_ASSOC);

        if ($userData) {
            return $userData;
        } else {
            throw new Exception("User not found");
        }
    } catch (PDOException $e) {
        // Handle database connection or query errors
        echo "Database error: " . $e->getMessage();
        return null;
    }
}

// Example usage
$userId = 1;
$userData = getUserData($userId);

if ($userData) {
    echo "User ID: " . $userData['id'] . "<br>";
    echo "Username: " . $userData['username'] . "<br>";
} else {
    echo "Failed to retrieve user data.";
}
?>

Conclusion

Finalement, les directives PSR-2 concernant la longueur des lignes, notamment la limite « souple » de 80 caractères, privilégient la lisibilité et la collaboration. Bien qu’elle ne soit pas strictement appliquée, le respect de cette norme favorise un code plus propre et facilite les processus d’examen. Comprendre la distinction entre les limites souples et strictes permet aux développeurs de prendre des décisions éclairées concernant le formatage du code, en équilibrant les besoins du projet avec les conventions établies.