Laravel 11.34.0 - Access Laravel Request Data as an Object

• Laravel 11.34.0 - Request::fluent Method
• What is the Fluent class?
• Why Use Request::fluent?
• How Does It Work?
• Advantages of Request::fluent
• Conclusion

Laravel 11.34.0 - Request::fluent Method

In Laravel 11.34.0, a new method, Request::fluent, was introduced by Steve Bauman to simplify handling request data. This method transforms the request into a Fluent instance, making it easier to access values dynamically. It offers a cleaner and more efficient way to interact with request input, improves null safety, and enhances code readability. By eliminating the need for traditional array-style access, it streamlines working with request data, especially in larger, more complex applications.

What is the Fluent class?

In Laravel, the Fluent class provides an easy way to interact with data by allowing dynamic property access. Instead of using traditional array or object notation, you can access request data as if it were an object. This enhances readability and reduces boilerplate code.

Why Use Request::fluent?

Before Laravel 11.34.0, accessing request data required using the Request facade with array-style access, like this:

$request->input('name');

While this approach works, it has some limitations, especially when dealing with deeply nested or nullable data. The Request::fluent method simplifies these interactions and adds some extra benefits:

1. Null-Safety: It makes your code more resilient to missing or null values, which is especially useful when handling optional data.

2. Readable Code: It allows accessing request data in a cleaner, more concise way.

3. Improved Testing: Since it returns a Fluent instance, it's easier to test and mock request data in your tests.

How Does It Work?

The new fluent method allows you to convert your request data into a Fluent instance, which provides a cleaner API for accessing values. Here's how you might use it:

Example Usage:

use Illuminate\Http\Request;
 
public function store(Request $request)
{
    // Convert the request to a Fluent instance
    $data = $request->fluent();
 
    // Access data with dynamic properties
    $name = $data->name;  // instead of $request->input('name')
    $email = $data->email;  // instead of $request->input('email')
}

In the example above, $data is now a Fluent instance. You can access the data directly using properties ($data->name, $data->email), making the code easier to read and understand.

Advantages of Request::fluent

• Null-Safe Access: Instead of worrying about checking if a value exists in the request, the Fluent instance makes it easier to safely access data. If the value doesn’t exist, it won’t throw an error but return null instead.

• Cleaner Code: It reduces the verbosity of checking for values in request arrays or objects, making your code cleaner and less error-prone.

• Flexible and Convenient: Using dynamic properties to access request input is more intuitive and can be especially handy when working with complex request structures, such as nested data.

Conclusion

The Request::fluent method is a simple but powerful addition to Laravel. It enhances the way developers handle request data, making code more readable, safer, and easier to work with. If you're building applications with Laravel 11.34.0 or higher, try this new method to streamline your request handling and make your codebase cleaner and more maintainable.

For more information on check out the Pull Request #53662.