Detecting Request Type in PHP (GET, POST, PUT, or DELETE)

When building web applications, it’s important to handle different types of HTTP requests—such as GET, POST, PUT, and DELETE. These methods are used for different operations: retrieving data, submitting forms, updating records, or deleting them. In PHP, detecting the request type is a common task, especially when creating RESTful APIs or handling complex form submissions.

Here’s a post detailing how to detect the request type in PHP and how to handle it in different ways.

1. Using $_SERVER['REQUEST_METHOD']

The most straightforward way to detect the request method in PHP is by using the $_SERVER superglobal. This variable contains server and execution environment information, including the request method.

<?php
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    // Handle POST request
    echo "This is a POST request!";
} elseif ($_SERVER['REQUEST_METHOD'] === 'GET') {
    // Handle GET request
    echo "This is a GET request!";
} elseif ($_SERVER['REQUEST_METHOD'] === 'PUT') {
    // Handle PUT request
    echo "This is a PUT request!";
} elseif ($_SERVER['REQUEST_METHOD'] === 'DELETE') {
    // Handle DELETE request
    echo "This is a DELETE request!";
} else {
    // Handle unknown request
    echo "Unknown request method!";
}
?>

This approach works well for detecting common HTTP methods like GET and POST, and also supports methods like PUT and DELETE.

2. Using a Switch Statement

For cleaner code, you can use a switch statement to handle each request type separately. This structure is particularly useful for handling RESTful API calls, where each method corresponds to a specific action (like retrieving, creating, updating, or deleting data).

<?php
$method = $_SERVER['REQUEST_METHOD'];

switch ($method) {
    case 'GET':
        // Handle GET request
        echo "Handling GET request.";
        break;
    case 'POST':
        // Handle POST request
        echo "Handling POST request.";
        break;
    case 'PUT':
        // Handle PUT request
        echo "Handling PUT request.";
        break;
    case 'DELETE':
        // Handle DELETE request
        echo "Handling DELETE request.";
        break;
    default:
        // Handle unknown methods
        echo "Unknown request method.";
        break;
}
?>

Using a switch statement makes your code more maintainable, especially when dealing with multiple request types.

3. Handling PUT and DELETE Requests in HTML Forms

In HTML, forms only support GET and POST methods natively. To simulate PUT or DELETE requests, a common practice is to use a hidden field to pass the method as a parameter. Here’s how you can mimic PUT and DELETE methods with a hidden input field.

<!-- Simulating DELETE method -->
<form action="handler.php" method="POST">
    <input type="hidden" name="_METHOD" value="DELETE">
    <button type="submit">Delete</button>
</form>

<!-- Simulating PUT method -->
<form action="handler.php" method="POST">
    <input type="hidden" name="_METHOD" value="PUT">
    <button type="submit">Update</button>
</form>

In your PHP code, you can then detect the hidden _METHOD parameter and treat the request accordingly.

<?php
$method = $_SERVER['REQUEST_METHOD'];

if ($method === 'POST' && isset($_POST['_METHOD'])) {
    $method = $_POST['_METHOD'];  // Override the method with the hidden field
}

switch ($method) {
    case 'PUT':
        // Handle PUT request
        echo "Handling PUT request.";
        break;
    case 'DELETE':
        // Handle DELETE request
        echo "Handling DELETE request.";
        break;
    default:
        // Handle other request methods
        echo "Handling other request methods.";
        break;
}
?>

4. Security and Input Validation

While handling requests, especially in REST APIs, it’s important to ensure that you sanitize and validate user input. This is particularly relevant for PUT and DELETE methods, where incorrect input can lead to data loss or other security vulnerabilities.

You can use PHP’s filter_input function to sanitize the request method:

<?php
$method = filter_input(INPUT_SERVER, 'REQUEST_METHOD', FILTER_SANITIZE_STRING);

if ($method === 'POST') {
    // Handle POST request
    echo "Safe POST method detected!";
}
?>

This will ensure that you are handling valid data and that malicious input does not get through.

5. Alternative: Using getenv() Function

An alternative to using $_SERVER is the getenv() function, which retrieves the value of environment variables, including REQUEST_METHOD.

<?php
$method = getenv('REQUEST_METHOD');

if ($method === 'GET') {
    echo "This is a GET request!";
}
?>

This method might be useful if you’re working in a custom environment or when $_SERVER is not available.

Conclusion

Detecting the request type in PHP is essential when building APIs or handling complex form submissions. By using $_SERVER['REQUEST_METHOD'], PHP allows you to easily distinguish between GET, POST, PUT, DELETE, and other HTTP methods. This makes your application more flexible and capable of handling different types of requests securely and efficiently.

Whether you’re building a simple form or a full-fledged RESTful API, understanding how to detect and handle various HTTP methods is a fundamental skill in PHP development.

Further Reading:

• PHP Manual: Superglobals - $_SERVER
• HTTP Protocol’s PUT and DELETE Methods