Duplicate Code refers to instances where identical or very similar code appears multiple times in a program. It is considered a bad practice because it can lead to issues with maintainability, readability, and error-proneness.

Types of Duplicate Code

1. Exact Duplicates: Code that is completely identical. This often happens when developers copy and paste the same code in different locations.

Example:

def calculate_area_circle(radius):
    return 3.14 * radius * radius

def calculate_area_sphere(radius):
    return 3.14 * radius * radius  # Identical code

2. Structural Duplicates: Code that is not exactly the same but has similar structure and functionality, with minor differences such as variable names.

Example:

def calculate_area_circle(radius):
    return 3.14 * radius * radius

def calculate_area_square(side):
    return side * side  # Similar structure

3. Logical Duplicates: Code that performs the same task but is written differently.

Example:

def calculate_area_circle(radius):
    return 3.14 * radius ** 2

def calculate_area_circle_alt(radius):
    return 3.14 * radius * radius  # Same logic, different style

Disadvantages of Duplicate Code

1. Maintenance Issues: Changes in one location require updating all duplicates, increasing the risk of errors.
2. Increased Code Size: More code leads to higher complexity and longer development time.
3. Inconsistency Risks: If duplicates are not updated consistently, it can lead to unexpected bugs.

How to Avoid Duplicate Code

1. Refactoring: Extract similar or identical code into a shared function or method.

Example:

def calculate_area(shape, dimension):
    if shape == 'circle':
        return 3.14 * dimension * dimension
    elif shape == 'square':
        return dimension * dimension

2. Modularization: Use functions and classes to reduce repetition.

3. Apply the DRY Principle: "Don't Repeat Yourself" – avoid duplicating information or logic in your code.

4. Use Tools: Tools like SonarQube or CodeClimate can automatically detect duplicate code.

Reducing duplicate code improves code quality, simplifies maintenance, and minimizes the risk of bugs in the software.

PSR-12 is a coding style guideline defined by the PHP-FIG (PHP Framework Interoperability Group). It builds on PSR-1 (Basic Coding Standard) and PSR-2 (Coding Style Guide), extending them to include modern practices and requirements.

Purpose of PSR-12

PSR-12 aims to establish a consistent and readable code style for PHP projects, facilitating collaboration between developers and maintaining a uniform codebase.

Key Guidelines of PSR-12

1. Indentation

• Use 4 spaces for indentation (no tabs).

2. Line Length

• Maximum line length should not exceed 120 characters.
• Code may be broken into multiple lines for better readability.

3. Namespace and Use Statements

• Add one blank line after the namespace declaration.
• use statements should follow the namespace declaration.
• Imported classes, functions, and constants should be alphabetically sorted without blank lines between them.

namespace App\Controller;

use App\Service\MyService;
use Psr\Log\LoggerInterface;

4. Classes

• The opening { for a class or method must be placed on the next line.
• Visibility (public, protected, private) is mandatory for all methods and properties.

class MyClass
{
    private string $property;

    public function myMethod(): void
    {
        // code
    }
}

5. Methods and Functions

• Each parameter must be placed on a new line if the parameter list is wrapped.
• Return types should be explicitly declared.

public function myFunction(
    int $param1,
    string $param2
): string {
    return 'example';
}

6. Control Structures (if, while, for, etc.)

• The opening { must be on the same line as the control structure.
• A space is required between the control structure and the condition.

if ($condition) {
    // code
} elseif ($otherCondition) {
    // code
} else {
    // code
}

7. Arrays

• Use the short syntax ([]) for arrays.
• In multiline arrays, each element should appear on a new line.

$array = [
    'first' => 'value1',
    'second' => 'value2',
];

8. Type Declarations

• Parameter, return, and property types are mandatory (where possible).
• Nullable types are prefixed with ?.

public function getValue(?int $id): ?string
{
    return $id !== null ? (string) $id : null;
}

9. Files

• PHP files must start with the <?php tag and must not include a closing ?> tag.
• Add blank lines between declarations like classes or functions.

Differences from PSR-2

PSR-12 extends PSR-2 by:

• Supporting modern PHP features (e.g., nullable types, declare(strict_types=1), traits, type hinting).
• Clarifying rules for line lengths, wrapped method parameters, and arrays.
• Requiring explicit type declarations.

Benefits of PSR-12

• Simplifies code reviews.
• Improves readability and maintainability.
• Enhances interoperability between PHP projects.
• Ensures consistency with modern PHP practices.

Summary

PSR-12 is the standard for modern and consistent PHP code. It improves code quality and simplifies collaboration, especially in team environments. Tools like PHP_CodeSniffer or PHP-CS-Fixer can help ensure adherence to PSR-12 effortlessly.

PSR-11 is a PHP Standard Recommendation (PHP Standard Recommendation) that defines a Container Interface for dependency injection. It establishes a standard way to interact with dependency injection containers in PHP projects.

Purpose of PSR-11

PSR-11 was introduced to ensure interoperability between different frameworks, libraries, and tools that use dependency injection containers. By adhering to this standard, developers can switch or integrate various containers without modifying their code.

Core Components of PSR-11

PSR-11 specifies two main interfaces:

1. ContainerInterface
   This is the central interface providing methods to retrieve and check services in the container.

namespace Psr\Container;

interface ContainerInterface {
    public function get(string $id);
    public function has(string $id): bool;
}

• • get(string $id): Returns the instance (or service) registered in the container under the specified ID.
  • has(string $id): Checks whether the container has a service registered with the given ID.

• 2. NotFoundExceptionInterface
  This is thrown when a requested service is not found in the container.

namespace Psr\Container;

interface NotFoundExceptionInterface extends ContainerExceptionInterface {
}

3. ContainerExceptionInterface
A base exception for any general errors related to the container.

Benefits of PSR-11

• Interoperability: Enables various frameworks and libraries to use the same container.
• Standardization: Provides a consistent API for accessing containers.
• Extensibility: Allows developers to create their own containers that comply with PSR-11.

Typical Use Cases

PSR-11 is widely used in frameworks like Symfony, Laravel, and Zend Framework (now Laminas), which provide dependency injection containers. Libraries like PHP-DI or Pimple also support PSR-11.

Example

Here’s a basic example of using PSR-11:

use Psr\Container\ContainerInterface;

class MyService {
    public function __construct(private string $message) {}
    public function greet(): string {
        return $this->message;
    }
}

$container = new SomePSR11CompliantContainer();
$container->set('greeting_service', function() {
    return new MyService('Hello, PSR-11!');
});

if ($container->has('greeting_service')) {
    $service = $container->get('greeting_service');
    echo $service->greet(); // Output: Hello, PSR-11!
}

Conclusion

PSR-11 is an essential interface for modern PHP development, as it standardizes dependency management and resolution. It promotes flexibility and maintainability in application development.

PSR-7 is a PHP Standard Recommendation (PSR) that focuses on HTTP messages in PHP. It was developed by the PHP-FIG (Framework Interoperability Group) and defines interfaces for working with HTTP messages, as used by web servers and clients.

Key Features of PSR-7:

1. Request and Response:
   PSR-7 standardizes how HTTP requests and responses are represented in PHP. It provides interfaces for:

   • RequestInterface: Represents HTTP requests.
   • ResponseInterface: Represents HTTP responses.

2. Immutability:
   All objects are immutable, meaning that any modification to an HTTP object creates a new object rather than altering the existing one. This improves predictability and makes debugging easier.

3. Streams:
   PSR-7 uses stream objects to handle HTTP message bodies. The StreamInterface defines methods for interacting with streams (e.g., read(), write(), seek()).

4. ServerRequest:
   The ServerRequestInterface extends the RequestInterface to handle additional data such as cookies, server parameters, and uploaded files.

5. Middleware Compatibility:
   PSR-7 serves as the foundation for middleware architectures in PHP. It simplifies the creation of middleware components that process HTTP requests and manipulate responses.

Usage:

PSR-7 is widely used in modern PHP frameworks and libraries, including:

• Zend Diactoros
• Guzzle
• Slim Framework
• Laravel (via middleware)

Purpose:

The goal of PSR-7 is to improve interoperability between different PHP libraries and frameworks by defining a common standard for HTTP messages.

PSR-6 is a PHP-FIG (PHP Framework Interoperability Group) standard that defines a common interface for caching in PHP applications. This specification, titled "Caching Interface," aims to promote interoperability between caching libraries by providing a standardized API.

Key components of PSR-6 are:

1. Cache Pool Interface (CacheItemPoolInterface): Represents a collection of cache items. It's responsible for managing, fetching, saving, and deleting cached data.

2. Cache Item Interface (CacheItemInterface): Represents individual cache items within the pool. Each cache item contains a unique key and stored value and can be set to expire after a specific duration.

3. Standardized Methods: PSR-6 defines methods like getItem(), hasItem(), save(), and deleteItem() in the pool, and get(), set(), and expiresAt() in the item interface, to streamline caching operations and ensure consistency.

By defining these interfaces, PSR-6 allows developers to easily switch caching libraries or integrate different caching solutions without modifying the application's core logic, making it an essential part of PHP application development for caching standardization.

PSR-4 is a PHP standard recommendation that provides guidelines for autoloading classes from file paths. It is managed by the PHP-FIG (PHP Framework Interop Group) and defines a way to map the fully qualified class names to the corresponding file paths. This standard helps streamline class loading, especially in larger projects and frameworks.

Key Principles of PSR-4:

1. Namespace Mapping: PSR-4 requires that the namespace and class name match the directory structure and file name. Each namespace prefix is associated with a base directory, and within that directory, the namespace hierarchy corresponds directly to the directory structure.

2. Base Directory: For each namespace prefix, a base directory is defined. Classes within that namespace are located in subdirectories of the base directory according to their namespace structure. For example:

   • If the namespace is App\Controllers, the file would be located in a folder like /path/to/project/src/Controllers.

3. File Naming: The class name must match the filename exactly, including case sensitivity, and end with .php.

4. Autoloader Compatibility: Implementing PSR-4 ensures compatibility with modern autoloaders like Composer’s, allowing PHP to locate and include classes automatically without manual require or include statements.

Example of PSR-4 Usage:

Suppose you have the namespace App\Controllers\UserController. According to PSR-4, the directory structure would look like:

/path/to/project/src/Controllers/UserController.php

In Composer’s composer.json, this mapping is specified like so:

{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

This configuration tells Composer to load classes in the App namespace from the src/ directory. When you run composer dump-autoload, it sets up the autoloading structure to follow PSR-4 standards.

Advantages of PSR-4:

• Consistency: Enforces a clear and organized file structure.
• Ease of Use: Allows seamless autoloading in large projects.
• Compatibility: Works well with frameworks and libraries that follow the PSR-4 standard.

PSR-4 has replaced the older PSR-0 standard, which had more restrictive rules on directory structure, making PSR-4 the preferred autoloading standard for modern PHP projects.

Monolog is a popular PHP logging library that implements the PSR-3 logging interface standard, making it compatible with PSR-3-compliant frameworks and applications. Monolog provides a flexible and structured way to log messages in PHP applications, which is essential for debugging and application maintenance.

Key Features and Concepts of Monolog:

1. Logger Instance: The core of Monolog is the Logger class, which provides different log levels (e.g., debug, info, warning, error). Developers use these levels to capture log messages of varying severity in their PHP applications.

2. Handlers: Handlers are central to Monolog’s functionality and determine where and how log entries are stored. Monolog supports a variety of handlers, including:

   • StreamHandler: Logs messages to a file or stream.
   • RotatingFileHandler: Manages daily rotating log files.
   • FirePHPHandler and ChromePHPHandler: Send logs to the browser console (via specific browser extensions).
   • SlackHandler, MailHandler, etc.: Send logs to external platforms like Slack or via email.

3. Formatters: Handlers can be paired with Formatters to customize the log output. Monolog includes formatters for JSON output, simple text formatting, and others to suit specific logging needs.

4. Processors: In addition to handlers and formatters, Monolog provides Processors, which attach additional contextual information (e.g., user data, IP address) to each log entry.

Example of Using Monolog:

Here is a basic example of initializing and using a Monolog logger:

use Monolog\Logger;
use Monolog\Handler\StreamHandler;

$logger = new Logger('name');
$logger->pushHandler(new StreamHandler(__DIR__.'/app.log', Logger::WARNING));

// Creating a log message
$logger->warning('This is a warning');
$logger->error('This is an error');

Advantages of Monolog:

• Modularity: Handlers allow Monolog to be highly flexible, enabling logs to be sent to different destinations.
• PSR-3 Compatibility: As it conforms to PSR-3, Monolog integrates easily into PHP projects following this standard.
• Extensibility: Handlers, formatters, and processors can be customized or extended with user specific classes to meet unique logging needs.

Widespread Usage:

Monolog is widely adopted in the PHP ecosystem and is especially popular with frameworks like Symfony and Laravel.

PSR-3 is a PHP-FIG (PHP Framework Interoperability Group) recommendation that establishes a standardized interface for logging libraries in PHP applications. This interface defines methods and rules that allow developers to work with logs consistently across different frameworks and libraries, making it easier to replace or change logging libraries within a project without changing the codebase that calls the logger.

Key Points of PSR-3:

1. Standardized Logger Interface: PSR-3 defines a Psr\Log\LoggerInterface with a set of methods corresponding to different log levels, such as emergency(), alert(), critical(), error(), warning(), notice(), info(), and debug().

2. Log Levels: The standard specifies eight log levels (emergency, alert, critical, error, warning, notice, info, and debug), which follow an escalating level of severity. These are based on the widely used RFC 5424 Syslog protocol, ensuring compatibility with many logging systems.

3. Message Interpolation: PSR-3 includes a basic formatting mechanism known as message interpolation, where placeholders (like {placeholder}) within log messages are replaced with actual values. For instance:
   $logger->error("User {username} not found", ['username' => 'johndoe']);
   This allows for consistent, readable logs without requiring complex string manipulation.

4. Flexible Implementation: Any logging library that implements LoggerInterface can be used in PSR-3 compatible code, such as Monolog, which is widely used in the PHP ecosystem.

5. Error Handling: PSR-3 also allows the log() method to be used to log at any severity level dynamically, by passing the severity level as a parameter.

Example Usage

Here’s a basic example of how a PSR-3 compliant logger might be used:

use Psr\Log\LoggerInterface;

class UserService
{
    private $logger;

    public function __construct(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    public function findUser($username)
    {
        $this->logger->info("Searching for user {username}", ['username' => $username]);
        // ...
    }
}

Benefits of PSR-3:

• Interoperability: You can switch between different logging libraries without changing your application’s code.
• Consistency: Using PSR-3, developers follow a unified structure for logging, which simplifies code readability and maintainability.
• Adaptability: With its flexible design, PSR-3 supports complex applications that may require different logging levels and log storage mechanisms.

For more details, you can check the official PHP-FIG documentation for PSR-3.

PSR-2 is a coding style guideline for PHP developed by the PHP-FIG (Framework Interop Group) to make code more readable and consistent, allowing development teams to collaborate more easily. The abbreviation “PSR” stands for “PHP Standards Recommendation”.

Key Points in PSR-2:

1. Indentation: Use four spaces for indentation instead of tabs.
2. Line Length: Code should ideally not exceed 80 characters per line, with an absolute maximum of 120 characters.
3. File Structure: Each PHP file should either contain only classes, functions, or executable code, but not a mix.
4. Braces: Opening braces { for classes and methods should be on the next line, whereas braces for control structures (like if, for) should be on the same line.
5. Spaces: Place a space between control keywords and parentheses, as well as around operators (e.g., =, +).

Example

Here’s a simple example following these guidelines:

<?php

namespace Vendor\Package;

class ExampleClass
{
    public function exampleMethod($arg1, $arg2 = null)
    {
        if ($arg1 === $arg2) {
            throw new \Exception('Arguments cannot be equal');
        }

        return $arg1;
    }
}

PSR-2 has since been expanded and replaced by PSR-12, which includes additional rules to further improve code consistency.

PSR-1 is a PHP Standards Recommendation created by the PHP-FIG (Framework Interop Group) that defines basic coding standards for PHP code style and structure to ensure interoperability between different PHP projects and frameworks. Its main purpose is to establish a consistent baseline for PHP code, making it easier to understand and collaborate on projects across the PHP ecosystem. PSR-1, also known as the Basic Coding Standard, includes several key guidelines:

1. File Formatting:

   • All PHP files should use only <?php or <?= tags.
   • Files should use UTF-8 encoding without BOM (Byte Order Mark).

2. Namespace and Class Names:

   • Class names must be declared in StudlyCaps (PascalCase).
   • PHP classes should follow the “one class per file” rule and be defined within namespaces that match the directory structure.

3. Constants, Properties, and Method Naming:

   • Constants should be written in all uppercase letters with underscores (e.g., CONST_VALUE).
   • Method names should follow camelCase.

4. Autoloading:

   • PSR-1 encourages using PSR-4 or PSR-0 autoloading standards to make class loading automatic and avoid manual include or require statements.

PSR-1 is considered a foundational standard, and it works in tandem with PSR-2 and PSR-12, which define more detailed code formatting guidelines. Together, these standards help improve code readability and consistency across PHP projects.