Làm cách nào tôi có thể tải lên tên tệp của mình trong Laravel?

Route::post['/files/add', 'FilesController@store']->name['files.store'];

/**
* Store a newly created resource in storage.
*
* @param  Request  $request
* @return \Illuminate\Http\Response
*/
public function store[Request $request]
{
    echo $request->file->extension[];
}

     @csrf
     
         
     

Vào chế độ toàn màn hình Thoát chế độ toàn màn hình

Tôi hy vọng hướng dẫn này có thể giúp bạn. Vui lòng truy cập tại đây https. // mã và triển khai. com/blog/laravel/how-to-get-file-extension-on-uploaded-file-in-laravel-8 nếu bạn muốn tải mã này

Một trong những điều mà tôi thấy nhiều người gặp khó khăn là tải tệp lên. Làm cách nào để chúng tôi tải tệp lên trong Laravel?

Để bắt đầu, hãy xem cách chúng ta có thể làm điều này trong Laravel và Blade tiêu chuẩn. Có một vài gói mà bạn có thể sử dụng cho việc này - tuy nhiên, tôi không phải là người thích cài đặt gói cho một thứ đơn giản như tải tệp lên. Tuy nhiên, giả sử bạn muốn tải lên một tệp và liên kết tệp đó với một mô hình và có các bộ sưu tập phương tiện khác nhau cho mô hình của bạn. Trong trường hợp đó, Spatie có một gói tuyệt vời có tên là MediaLibrary và MediaLibrary Pro, giúp bạn loại bỏ rất nhiều rắc rối khỏi quy trình này

Giả sử chúng ta muốn tự làm việc này và không dựa vào một gói cho việc này. Chúng tôi sẽ muốn tạo một biểu mẫu cho phép chúng tôi tải tệp lên và gửi tệp đó - và bộ điều khiển sẽ chấp nhận biểu mẫu này, xác thực đầu vào và xử lý tải lên

Tuy nhiên, trước đó, chúng ta hãy tạo một bảng cơ sở dữ liệu trong đó chúng ta có thể lưu trữ các tệp tải lên của mình. Hãy tưởng tượng một kịch bản mà chúng tôi muốn tải lên và đính kèm tệp vào các mô hình khác nhau. Chúng tôi muốn có một bảng tập trung cho phương tiện của mình mà chúng tôi có thể đính kèm thay vì tải lên nhiều phiên bản cho từng kiểu máy

Hãy tạo cái này trước bằng cách sử dụng lệnh artisan sau

php artisan make:model Media -m

Điều này sẽ tạo mô hình và di chuyển để chúng tôi bắt đầu. Chúng ta hãy xem phương thức up trong quá trình di chuyển để chúng ta có thể hiểu những gì chúng ta sẽ muốn lưu trữ và hiểu

Schema::create['media', function [Blueprint $table] {
    $table->id[];
 
    $table->string['name'];
    $table->string['file_name'];
    $table->string['mime_type'];
    $table->string['path'];
    $table->string['disk']->default['local'];
    $table->string['file_hash', 64]->unique[];
    $table->string['collection']->nullable[];
 
    $table->unsignedBigInteger['size'];
 
    $table->timestamps[];
}];

Phương tiện của chúng tôi sẽ yêu cầu một tên để chúng tôi có thể lấy tên ban đầu của khách hàng từ tải lên. Sau đó, chúng tôi muốn có một tên tệp, đây sẽ là tên được tạo. Lưu trữ các tệp đã tải lên bằng tên tệp gốc có thể là một vấn đề quan trọng liên quan đến bảo mật, đặc biệt nếu bạn không xác thực đủ mạnh. Sau đó, loại mime được yêu cầu để chúng tôi có thể hiểu nội dung đã được tải lên, cho dù đó là tệp CSV hay hình ảnh. Đường dẫn đến tệp tải lên cũng rất tiện để lưu trữ vì nó cho phép chúng tôi tham khảo dễ dàng hơn. Chúng tôi ghi lại đĩa mà chúng tôi đang lưu trữ đĩa này để chúng tôi có thể tự động làm việc với nó trong Laravel. Tuy nhiên, chúng ta có thể đang tương tác với ứng dụng của mình. Chúng tôi lưu trữ tệp băm dưới dạng một cột duy nhất để đảm bảo chúng tôi không tải lên cùng một tệp nhiều lần. Nếu tệp thay đổi, đây sẽ là một biến thể mới và bạn có thể tải lên lại. Cuối cùng, chúng tôi có bộ sưu tập và kích thước, nơi chúng tôi có thể lưu tệp vào bộ sưu tập, chẳng hạn như "bài đăng trên blog", tạo cấu trúc thư mục/phân loại ảo. Kích thước chủ yếu dành cho mục đích thông tin nhưng sẽ cho phép bạn đảm bảo rằng tài sản kỹ thuật số của mình không quá lớn

Bây giờ chúng tôi biết nơi chúng tôi muốn lưu trữ những video tải lên này, chúng tôi có thể xem cách chúng tôi muốn tải chúng lên. Chúng tôi sẽ bắt đầu với một triển khai đơn giản bên trong tuyến đường/bộ điều khiển và mở rộng từ đó

Hãy tạo bộ điều khiển đầu tiên của chúng ta bằng lệnh artisan sau

php artisan make:controller UploadController --invokable

Hiện tại, đây sẽ là nơi chúng tôi định tuyến các tệp tải lên đến một bộ điều khiển không thể gọi được sẽ xử lý đồng bộ tệp tải lên. Thêm điều này như một tuyến đường trong

Schema::create['media', function [Blueprint $table] {
    $table->id[];
 
    $table->string['name'];
    $table->string['file_name'];
    $table->string['mime_type'];
    $table->string['path'];
    $table->string['disk']->default['local'];
    $table->string['file_hash', 64]->unique[];
    $table->string['collection']->nullable[];
 
    $table->unsignedBigInteger['size'];
 
    $table->timestamps[];
}];

Route::post['upload', App\Http\Controllers\UploadController::class]->name['upload'];

Sau đó, chúng ta có thể xem cách chúng ta muốn quy trình này hoạt động. Để bắt đầu, giống như tất cả các điểm cuối khác - chúng tôi muốn xác thực đầu vào sớm. Tôi thích làm điều này trong một yêu cầu biểu mẫu vì nó giúp mọi thứ được gói gọn một cách độc đáo. Bạn có thể làm phần này theo cách bạn cảm thấy phù hợp;

Vì vậy, chúng tôi phải gửi một

Schema::create['media', function [Blueprint $table] {
    $table->id[];
 
    $table->string['name'];
    $table->string['file_name'];
    $table->string['mime_type'];
    $table->string['path'];
    $table->string['disk']->default['local'];
    $table->string['file_hash', 64]->unique[];
    $table->string['collection']->nullable[];
 
    $table->unsignedBigInteger['size'];
 
    $table->timestamps[];
}];

class UserUploadValidator
{
    public function avatars[]: array
    {
        return [
            'required',
           File::types[['png', 'jpg']]
               ->max[5 * 1024],
        ];
    }
}

  

Khi bạn đã xác thực xong, bạn có thể xử lý việc này trong bộ điều khiển của mình tuy nhiên bạn cần. Tuy nhiên, giả sử rằng tôi đang sử dụng Yêu cầu biểu mẫu và đưa nó vào bộ điều khiển của mình. Bây giờ chúng tôi đã xác nhận, chúng tôi cần xử lý. Cách tiếp cận chung của tôi với bộ điều khiển là

• xác thực
• Tiến trình
• Trả lời

Trong một API, tôi xử lý ở chế độ nền, điều này thường có nghĩa là gửi một công việc - nhưng trên web, điều đó không phải lúc nào cũng thuận tiện. Hãy xem cách chúng tôi có thể xử lý tệp tải lên

class UploadController
{
    public function __invoke[UploadRequest $request]
    {
        Gate::authorize['upload-files'];
 
        $file = $request->file['file'];
        $name = $file->hashName[];
 
        $upload = Storage::put["avatars/{$name}", $file];
 
        Media::query[]->create[
            attributes: [
                'name' => "{$name}",
                'file_name' => $file->getClientOriginalName[],
                'mime_type' => $file->getClientMimeType[],
                'path' => "avatars/{$name}"
,
                'disk' => config['app.uploads.disk'],
                'file_hash' => hash_file[
                    config['app.uploads.hash'],
                    storage_path[
                        path: "avatars/{$name}",
                    ],
                ],
                'collection' => $request->get['collection'],
                'size' => $file->getSize[],
            ],
        ];
 
        return redirect[]->back[];
    }
}

Vì vậy, những gì chúng tôi đang làm ở đây trước tiên là đảm bảo rằng người dùng đã đăng nhập được phép tải tệp lên. Sau đó, chúng tôi muốn lấy tệp đã tải lên và tên được băm để lưu trữ. Sau đó, chúng tôi tải tệp lên và lưu trữ bản ghi trong cơ sở dữ liệu, lấy thông tin chúng tôi cần cho mô hình từ chính tệp đó

Tôi sẽ gọi đây là cách tiếp cận mặc định để tải tệp lên và tôi thừa nhận không có gì sai với cách tiếp cận này. Nếu mã của bạn trông giống như thế này rồi thì bạn đang làm rất tốt. Tuy nhiên, tất nhiên, chúng ta có thể đưa điều này đi xa hơn - theo một số cách khác nhau

Cách đầu tiên chúng ta có thể đạt được điều này là trích xuất logic tải lên thành

Schema::create['media', function [Blueprint $table] {
    $table->id[];
 
    $table->string['name'];
    $table->string['file_name'];
    $table->string['mime_type'];
    $table->string['path'];
    $table->string['disk']->default['local'];
    $table->string['file_hash', 64]->unique[];
    $table->string['collection']->nullable[];
 
    $table->unsignedBigInteger['size'];
 
    $table->timestamps[];
}];

class File
{
    public function __construct[
        public readonly string $name,
        public readonly string $originalName,
        public readonly string $mime,
        public readonly string $path,
        public readonly string $disk,
        public readonly string $hash,
        public readonly null|string $collection = null,
    ] {}
 
    public function toArray[]: array
    {
        return [
            'name' => $this->name,
            'file_name' => $this->originalName,
            'mime_type' => $this->mime,
            'path' => $this->path,
            'disk' => $this->disk,
            'file_hash' => $this->hash,
            'collection' => $this->collection,
        ];
    }
}

Bây giờ chúng ta có thể xem dịch vụ tải lên và tìm ra cách chúng ta muốn nó hoạt động. Nếu chúng ta nhìn vào logic bên trong bộ điều khiển, chúng ta biết rằng chúng ta sẽ muốn tạo một tên mới cho tệp và lấy tên ban đầu của tệp tải lên. Sau đó, chúng tôi muốn đưa tệp vào lưu trữ và trả lại Đối tượng dữ liệu. Như với hầu hết các mã tôi viết, dịch vụ sẽ triển khai một giao diện mà sau đó chúng ta có thể liên kết với vùng chứa

class UploadService implements UploadServiceContract
{
    public function avatar[UploadedFile $file]: File
    {
        $name = $file->hashName[];
 
        $upload = Storage::put["{$name}", $file];
 

  

        return new File[
            name: "{$name}",
            originalName: $file->getClientOriginalName[],
            mime: $file->getClientMimeType[],
            path: $upload->path[],
            disk: config['app.uploads.disk'],
            hash: file_hash[
                    config['app.uploads.hash'],
                    storage_path[
                        path: "avatars/{$name}",
                    ],
            ],
            collection: 'avatars',
        ];
    }
}

Hãy để chúng tôi cấu trúc lại UploadController của chúng tôi ngay bây giờ để nó đang sử dụng dịch vụ mới này

class UploadController
{
    public function __construct[
        private readonly UploadServiceContract $service,
    ] {}
 
    public function __invoke[UploadRequest $request]
    {
        Gate::authorize['upload-files'];
 
        $file = $this->service->avatar[
            file: $request->file['file'],
        ];
 
        Media::query[]->create[
            attributes: $file->toArray[],
        ];
 
        return redirect[]->back[];
    }
}

Đột nhiên, bộ điều khiển của chúng tôi sạch hơn rất nhiều và logic của chúng tôi đã được trích xuất sang dịch vụ mới của chúng tôi - vì vậy, nó có thể lặp lại bất kể chúng tôi cần tải tệp lên ở đâu. Tất nhiên, chúng ta cũng có thể viết các bài kiểm tra cho điều này, bởi vì tại sao bạn không thể kiểm tra bất cứ điều gì?

Schema::create['media', function [Blueprint $table] {
    $table->id[];
 
    $table->string['name'];
    $table->string['file_name'];
    $table->string['mime_type'];
    $table->string['path'];
    $table->string['disk']->default['local'];
    $table->string['file_hash', 64]->unique[];
    $table->string['collection']->nullable[];
 
    $table->unsignedBigInteger['size'];
 
    $table->timestamps[];
}];

Chúng tôi đang giả mạo mặt tiền lưu trữ, tạo một tệp giả để tải lên, sau đó nhấn vào điểm cuối của chúng tôi và gửi tệp. Sau đó, chúng tôi khẳng định rằng mọi thứ đều ổn và chúng tôi đã được chuyển hướng. Cuối cùng, chúng tôi muốn khẳng định rằng tệp hiện tồn tại trên đĩa của chúng tôi

Làm thế nào chúng ta có thể đưa điều này đi xa hơn? . Ví dụ: giả sử trong ứng dụng của bạn, có nhiều loại tải lên khác nhau mà bạn có thể cần thực hiện. Chúng tôi muốn dịch vụ tải lên của mình phản ánh điều đó mà không quá phức tạp, phải không? . Mẫu này cho phép bạn đưa vào một dịch vụ duy nhất nhưng gọi nhiều hành động thông qua dịch vụ đó - giữ cho mã của bạn rõ ràng và tập trung, đồng thời dịch vụ của bạn chỉ là một proxy tiện dụng

Trước tiên chúng ta hãy tạo hành động

Schema::create['media', function [Blueprint $table] {
    $table->id[];
 
    $table->string['name'];
    $table->string['file_name'];
    $table->string['mime_type'];
    $table->string['path'];
    $table->string['disk']->default['local'];
    $table->string['file_hash', 64]->unique[];
    $table->string['collection']->nullable[];
 
    $table->unsignedBigInteger['size'];
 
    $table->timestamps[];
}];

Bây giờ chúng ta có thể cấu trúc lại dịch vụ của mình để gọi hành động, hoạt động như một proxy hữu ích

Schema::create['media', function [Blueprint $table] {
    $table->id[];
 
    $table->string['name'];
    $table->string['file_name'];
    $table->string['mime_type'];
    $table->string['path'];
    $table->string['disk']->default['local'];
    $table->string['file_hash', 64]->unique[];
    $table->string['collection']->nullable[];
 
    $table->unsignedBigInteger['size'];
 
    $table->timestamps[];

  

}];

Điều này giống như kỹ thuật quá mức cho một ứng dụng nhỏ. Tuy nhiên, đối với các ứng dụng tập trung vào phương tiện mở rộng hơn, điều này sẽ cho phép bạn xử lý các tệp tải lên thông qua một dịch vụ có thể được ghi lại đầy đủ thay vì kiến ​​thức rời rạc trong toàn bộ nhóm của bạn

Chúng ta có thể lấy nó từ đâu? . ?]. Với Livewire, chúng tôi có một cách tiếp cận hơi khác trong đó Livewire sẽ xử lý việc tải lên cho bạn và lưu trữ tệp này dưới dạng tệp tạm thời, cung cấp cho bạn một API hơi khác để hoạt động khi lưu trữ tệp

Trước tiên, chúng tôi cần tạo một thành phần Livewire mới mà chúng tôi có thể sử dụng để tải lên tệp của mình. Bạn có thể tạo cái này bằng lệnh artisan sau

Schema::create['media', function [Blueprint $table] {
    $table->id[];
 
    $table->string['name'];
    $table->string['file_name'];
    $table->string['mime_type'];
    $table->string['path'];
    $table->string['disk']->default['local'];
    $table->string['file_hash', 64]->unique[];
    $table->string['collection']->nullable[];
 
    $table->unsignedBigInteger['size'];
 
    $table->timestamps[];
}];

Bây giờ chúng ta có thể thêm một vài thuộc tính vào thành phần của mình và thêm một đặc điểm để thành phần biết nó xử lý tải tệp lên

Schema::create['media', function [Blueprint $table] {
    $table->id[];
 
    $table->string['name'];
    $table->string['file_name'];
    $table->string['mime_type'];
    $table->string['path'];
    $table->string['disk']->default['local'];
    $table->string['file_hash', 64]->unique[];
    $table->string['collection']->nullable[];
 
    $table->unsignedBigInteger['size'];
 
    $table->timestamps[];
}];

Livewire đi kèm với một tính năng hữu ích cho phép chúng tôi làm việc với Tệp tải lên một cách dễ dàng. Chúng tôi có thuộc tính tệp có thể là null, chuỗi cho đường dẫn hoặc Tệp tạm thời đã được tải lên. Đây có lẽ là một phần về tải lên tệp trong Livewire mà tôi không thích

Bây giờ chúng ta đã có sẵn một thành phần cơ bản, chúng ta có thể xem xét việc di chuyển logic từ bộ điều khiển của chúng ta sang thành phần. Một điều chúng tôi sẽ làm ở đây là chuyển cổng kiểm tra từ bộ điều khiển sang giao diện người dùng để chúng tôi không hiển thị biểu mẫu nếu người dùng không thể tải tệp lên. Điều này đơn giản hóa logic thành phần của chúng tôi một cách độc đáo

Bước tiếp theo của chúng tôi là đưa

Schema::create['media', function [Blueprint $table] {
    $table->id[];
 
    $table->string['name'];
    $table->string['file_name'];
    $table->string['mime_type'];
    $table->string['path'];
    $table->string['disk']->default['local'];
    $table->string['file_hash', 64]->unique[];
    $table->string['collection']->nullable[];
 
    $table->unsignedBigInteger['size'];
 
    $table->timestamps[];
}];

Schema::create['media', function [Blueprint $table] {
    $table->id[];
 
    $table->string['name'];
    $table->string['file_name'];
    $table->string['mime_type'];
    $table->string['path'];
    $table->string['disk']->default['local'];
    $table->string['file_hash', 64]->unique[];
    $table->string['collection']->nullable[];
 
    $table->unsignedBigInteger['size'];
 
    $table->timestamps[];
}];

Phương thức xác thực

php artisan make:controller UploadController --invokable

Schema::create['media', function [Blueprint $table] {
    $table->id[];
 
    $table->string['name'];
    $table->string['file_name'];
    $table->string['mime_type'];
    $table->string['path'];
    $table->string['disk']->default['local'];
    $table->string['file_hash', 64]->unique[];
    $table->string['collection']->nullable[];
 
    $table->unsignedBigInteger['size'];
 
    $table->timestamps[];
}];

Chúng tôi cần những thay đổi tối thiểu đối với cách logic của chúng tôi hoạt động - chúng tôi có thể di chuyển nó gần như thẳng vào vị trí và nó sẽ hoạt động

Đây là cách tôi thấy việc tải tệp lên phù hợp với mình; . Nó sẽ không phải là một bài hướng dẫn của Steve nếu tôi không có một chút cố chấp và quá nhiệt tình, phải không?

Bạn muốn xử lý các tệp tải lên như thế nào?

Làm cách nào để tải tệp lên bằng Laravel?

Làm cách nào để lấy tên tệp bằng Laravel?

Làm cách nào để lấy tên tệp không có phần mở rộng trong Laravel?

Làm cách nào để lưu trữ tệp trong Laravel?