1. Visit
Request Instance
To get the current HTTP request instance through dependency injection, you need to type-prompt the class in the Controller's constructor or method so that the Illuminate\Http\Request
current request instance is automatically injected by the service container:
<?phpnamespace App\http\controllers;use Illuminate\http\request;use Illuminate\routing\controller;class Usercontroller extends controller{ /** * Store new user * * @param Request $request * @return Response * /Public function store (Request $request) { $name = $request->input (' name '); // }}
Dependency Injection & Routing Parameters
If your controller method also expects to get the routing parameters, simply place the route parameters after other dependencies, for example, if your route is defined as follows:
Route::p ut (' User/{id} ', ' [email protected] ');
You can still Illuminate\Http\Request
access routing parameters for type hinting and to define controller methods as follows id
:
<?phpnamespace app\http\controllers;use illuminate\http\request;classuser Controller extends controller{ /** * Update specified user * * @param Request $request * @param int $id * @return Response */Public function Update (Request $request, $id) { // }}
Access requests by routing closures
You can also type a hint class on the routing closure Illuminate\Http\Request
, and the service container will automatically inject the input request to the closure at execution time:
Use Illuminate\http\request; Route::get ('/', function (Request $request) { //});
Request Path & method
Illuminate\Http\Request
The instance provides several methods to detect an application's HTTP request, Laravel Illuminate\Http\Request
inherits from the Symfony\Component\HttpFoundation\Request
class, and illustrates some useful ways that the class provides:
Get Request Path
path
Method will return the requested path information, so if the requested path is entered, the http://domain.com/foo/bar
method will path
return foo/bar
:
$uri = $request->path ();
is
method allows you to verify that incoming requests match the given pattern. You can use the wildcard character when using this method *
:
if ($request->is (' admin/* ')) { //}
Get Request URL
To get the full URL, not just the path information, you can use the or method provided by the request instance, and the method returns the url
fullUrl
url
URL without the query string, and fullUrl
the method returns the result that contains the query string:
Does not contain the query string $url= $request->url ();//contains the query string, \ n = $request->fullurl ();
Get Request method
method
Method will return the HTTP request mode. You can also use isMethod
methods to verify that HTTP requests match the given string:
$method = $request->method (), if ($request->ismethod (' post ')) { //}
PSR-7 Request
The PSR-7 standard specifies the HTTP message interface, including requests and responses. If you want to get a PSR-7 request instance, first you need to install some libraries, Laravel use the Symfony HTTP Message Bridge component to translate the typical Laravel request and response into a compatible PSR-7 implementation:
Composer require symfony/psr-http-message-bridgecomposer require Zendframework/zend-diactoros
After installing these libraries, you only need to get the PSR-7 request in the routing or controller by typing the type hint on the request type:
Use Psr\http\message\serverrequestinterface; Route::get ('/', function (Serverrequestinterface $request) { //});
Note: If the PSR-7 response instance is returned from the route or controller, it will automatically be converted to the Laravel response instance and displayed.
2. Get request Input
Get all input values
You can use all
the method to get all the input values in an array format:
$input = $request->all ();
Get a single input value
With some simple methods, you can Illuminate\Http\Request
access user input from an instance. You do not need to care about the HTTP request method used by the request, because the input to all requests is through the input
method to get user input:
$name = $request->input (' name ');
You can also pass a default value as the second parameter to input
the method, and the value will be returned if the requested input value does not appear in the current request:
$name = $request->input (' name ', ' Sally ');
When working with table singular group input, you can use the "." To access the array input:
$input = $request->input (' products.0.name '); $names = $request->input (' products.*.name ');
Getting input with dynamic properties
In addition, you can Illuminate\Http\Request
access user input by using dynamic properties on the instance. For example, if your app form contains name
fields, you can access the submitted values like this:
$name = $request->name;
With dynamic properties, Laravel first looks for the value of the parameter in the request, and if it does not, it is also found in the route parameter.
Get JSON input values
When sending a JSON request to the app, Content-Type
you can get the JSON data through the method as long as the request header is set to, application/json
input
or through the "." Number resolved array:
$name = $request->input (' User.Name ');
Get the input part of the data
If you need to take out a subset of the input data, you can use the only
or except
method, both of which receive an array or a dynamic list as the unique parameter:
$input = $request->only ([' username ', ' password ']), $input = $request->only (' username ', ' password '); $input = $ Request->except ([' Credit_card ']); $input = $request->except (' Credit_card ');
Determine if the input value appears
Determine whether the value appears in the request, you can use has
the method, if the value has occurred and is not empty, the has
method returns true
:
if ($request->has (' name ')) { //}
Last Request input
Laravel allows you to save input data between two requests, which is useful if you need to repopulate the form data after a failure to detect checksum data, but you do not need to use these methods manually if you are using Laravel built-in authentication services, because some Laravel The built-in check settings automatically call them.
Store input to a one-time Session
Illuminate\Http\Request
The method of the instance flash
stores the current input in a one-time session (so-called one-off refers to the data being taken from the session and the corresponding data is destroyed from the session) so that the data remains valid on the next request:
$request->flash ();
You can also use flashOnly
and flashExcept
methods to store the subset of input data in the session, which is useful for storing sensitive information outside the session:
$request->flashonly (' username ', ' email '), $request->flashexcept (' password ');
Store input to a one-time Session and redirect
If you often need to store input once and redirect to the previous page, you can simply use withInput
the method to link the input data to the redirect
following:
Return redirect (' form ')->withinput (), return redirect (' form ')->withinput ($request->except (' password '));
Remove Last Request data
To remove the last requested input data from the Session, you can use the method of the request instance old
. old
method provides a convenient way to remove one-time data from the Session:
$username = $request->old (' username ');
Laravel also provides a global helper function that, old
if you are displaying the last input data in the Blade template, it is more convenient to use the helper function old
, and NULL is returned if there is no corresponding input for the given parameter:
<input type= "text" name= "username" value= "{{old (' username ')}}" >
Cookies
Remove cookies from the request
All cookies created by the Laravel framework are encrypted and signed with an authentication code, which means that they need to be validated if the client modifies them. We use Illuminate\Http\Request
the method of the instance to cookie
get the value of the cookie from the request:
$value = $request->cookie (' name ');
New Cookie to response
You can use the cookie
method to append a cookie to an instance of the output Illuminate\Http\Response
, and you need to pass the name, value, and cookie expiration date (minutes) to this method:
Return response (' Hello World ')->cookie ( ' name ', ' value ', $minutes);
cookie
The method can receive some parameters that are less frequently used, and in general, these parameters are consistent with the PHP native function Setcookie function and meaning:
Return response (' Hello World ')->cookie ( ' name ', ' value ', $minutes, $path, $domain, $secure, $httpOnly);
Generate Cookie Instance
If you want to generate an Symfony\Component\HttpFoundation\Cookie
instance for subsequent attaching to the response instance, you can use a global helper function cookie
that is sent to the client only if it is attached to the response instance:
$cookie = Cookie (' name ', ' value ', $minutes); return response (' Hello World ')->cookie ($cookie);
3. File Upload
get the uploaded file
You can use Illuminate\Http\Request
the method provided by the instance file
or the dynamic property to access the upload file, and file
the method returns an instance of the Illuminate\http\uploadedfile class that inherits from the class that provides the file interaction method from the PHP standard library SplFileInfo
:
$file = $request->file (' photo '); $file = $request->photo;
You can use hasFile
the method to determine whether a file exists in the request:
if ($request->hasfile (' photo ')) { //}
Verify that the file is uploaded successfully
Use isValid
the method to determine if the file has errors during the upload process:
if ($request->file (' photo ')->isvalid ()) { //}
File path & Extension
UploadedFile
Class also provides methods for accessing the absolute path and extension of the uploaded file. extension
method can determine the file name extension based on the contents of the file, which may be inconsistent with the extension provided by the client:
$path = $request->photo->path (); $extension = $request->photo->extension ();
Additional file methods
UploadedFile
There are many other methods available on the instance to view the API documentation for this class for more information.
Save the uploaded file
To save an uploaded file, you typically need to use one of the file systems you have configured, and UploadedFile
the class has a store
method that moves the uploaded file to the appropriate disk path, either somewhere on the local file system or a path on a cloud storage such as Amazon S3.
store
The MD5 method receives a file-saved relative path (relative to the root of the file system configuration) and the path should not contain a file name because the file name is automatically generated by the content of the files.
store
The method also receives an optional parameter--the disk name that is used to store the file as the second parameter, which returns the file path relative to the root directory:
$path = $request->photo->store (' images '); $path = $request->photo->store (' images ', ' S3 ');
If you do not want to generate the file name automatically, you can use the storeAs
method, which receives the save path, file name, and disk name as parameters:
$path = $request->photo->storeas (' images ', ' filename.jpg ');
$path = $request->photo->storeas (' images ', ' filename.jpg ', ' S3 ');
HTTP Layer--Request