Laravel - คู่มือฉบับย่อ

Laravel เป็นเฟรมเวิร์ก PHP แบบโอเพนซอร์สซึ่งมีประสิทธิภาพและเข้าใจง่าย เป็นไปตามรูปแบบการออกแบบ Model-view-controller Laravel ใช้ส่วนประกอบที่มีอยู่ของเฟรมเวิร์กต่างๆซึ่งช่วยในการสร้างเว็บแอปพลิเคชัน เว็บแอปพลิเคชันที่ออกแบบมาจึงมีโครงสร้างและเป็นประโยชน์

Laravel นำเสนอชุดฟังก์ชันที่หลากหลายซึ่งรวมเอาคุณสมบัติพื้นฐานของเฟรมเวิร์ก PHP เช่น CodeIgniter, Yii และภาษาโปรแกรมอื่น ๆ เช่น Ruby on Rails Laravel มีชุดคุณสมบัติมากมายที่จะช่วยเพิ่มความเร็วในการพัฒนาเว็บ

หากคุณคุ้นเคยกับ Core PHP และ Advanced PHP Laravel จะทำให้งานของคุณง่ายขึ้น ช่วยประหยัดเวลาได้มากหากคุณวางแผนที่จะพัฒนาเว็บไซต์ตั้งแต่เริ่มต้น นอกจากนี้เว็บไซต์ที่สร้างขึ้นใน Laravel ยังปลอดภัยและป้องกันการโจมตีเว็บต่างๆ

ข้อดีของ Laravel

Laravel มอบข้อดีดังต่อไปนี้ให้กับคุณเมื่อคุณออกแบบเว็บแอปพลิเคชันตาม -

เว็บแอปพลิเคชันสามารถปรับขนาดได้มากขึ้นเนื่องจาก Laravel framework
ประหยัดเวลาได้มากในการออกแบบเว็บแอปพลิเคชันเนื่องจาก Laravel นำส่วนประกอบจากเฟรมเวิร์กอื่นมาใช้ในการพัฒนาเว็บแอปพลิเคชัน
ประกอบด้วยเนมสเปซและอินเทอร์เฟซจึงช่วยในการจัดระเบียบและจัดการทรัพยากร

นักแต่งเพลง

Composer เป็นเครื่องมือที่มีการอ้างอิงและไลบรารีทั้งหมด ช่วยให้ผู้ใช้สามารถสร้างโครงการที่เกี่ยวข้องกับกรอบงานที่กล่าวถึง (ตัวอย่างเช่นที่ใช้ในการติดตั้ง Laravel) ไลบรารีของบุคคลที่สามสามารถติดตั้งได้อย่างง่ายดายด้วยความช่วยเหลือของนักแต่งเพลง

การอ้างอิงทั้งหมดถูกบันทึกไว้ใน composer.json ไฟล์ที่อยู่ในโฟลเดอร์ต้นทาง

ช่าง

เรียกว่าอินเตอร์เฟสบรรทัดคำสั่งที่ใช้ใน Laravel Artisan. ประกอบด้วยชุดคำสั่งที่ช่วยในการสร้างเว็บแอปพลิเคชัน คำสั่งเหล่านี้รวมเข้าด้วยกันจาก Symphony framework ทำให้เกิดคุณสมบัติเสริมใน Laravel 5.1 (Laravel เวอร์ชันล่าสุด)

คุณสมบัติของ Laravel

Laravel นำเสนอคุณสมบัติหลักดังต่อไปนี้ซึ่งทำให้เป็นตัวเลือกที่เหมาะสำหรับการออกแบบเว็บแอปพลิเคชัน -

ความเป็นโมดูลาร์

Laravel มีไลบรารีและโมดูลในตัว 20 ตัวซึ่งช่วยในการปรับปรุงแอปพลิเคชัน ทุกโมดูลจะรวมเข้ากับ Composer dependency manager ซึ่งจะช่วยให้การอัปเดตง่ายขึ้น

ทดสอบได้

Laravel มีคุณสมบัติและตัวช่วยที่ช่วยในการทดสอบผ่านกรณีทดสอบต่างๆ คุณลักษณะนี้ช่วยในการรักษารหัสตามข้อกำหนด

การกำหนดเส้นทาง

Laravel มอบแนวทางที่ยืดหยุ่นให้กับผู้ใช้ในการกำหนดเส้นทางในเว็บแอปพลิเคชัน การกำหนดเส้นทางช่วยในการปรับขนาดแอปพลิเคชันในทางที่ดีขึ้นและเพิ่มประสิทธิภาพ

การจัดการการตั้งค่า

เว็บแอปพลิเคชันที่ออกแบบใน Laravel จะทำงานบนสภาพแวดล้อมที่แตกต่างกันซึ่งหมายความว่าจะมีการเปลี่ยนแปลงการกำหนดค่าอย่างต่อเนื่อง Laravel นำเสนอแนวทางที่สอดคล้องกันในการจัดการการกำหนดค่าอย่างมีประสิทธิภาพ

Query Builder และ ORM

Laravel ประกอบด้วยตัวสร้างแบบสอบถามซึ่งช่วยในการสืบค้นฐานข้อมูลโดยใช้วิธีการแบบโซ่ง่ายๆต่างๆ มันให้ORM (Object Relational Mapper) และ ActiveRecord การใช้งานที่เรียกว่า Eloquent

Schema Builder

Schema Builder รักษาข้อกำหนดฐานข้อมูลและสคีมาในโค้ด PHP นอกจากนี้ยังติดตามการเปลี่ยนแปลงเกี่ยวกับการย้ายฐานข้อมูล

Template Engine

Laravel ใช้ไฟล์ Blade Template เอนจิ้นซึ่งเป็นภาษาเทมเพลตแบบเบาที่ใช้ในการออกแบบบล็อกและเลย์เอาต์แบบลำดับชั้นด้วยบล็อกที่กำหนดไว้ล่วงหน้าซึ่งมีเนื้อหาแบบไดนามิก

อีเมล์

Laravel รวมถึงไฟล์ mail คลาสที่ช่วยในการส่งเมลที่มีเนื้อหาและไฟล์แนบจากเว็บแอปพลิเคชัน

การรับรองความถูกต้อง

การพิสูจน์ตัวตนผู้ใช้เป็นคุณสมบัติทั่วไปในเว็บแอปพลิเคชัน Laravel ช่วยลดความยุ่งยากในการออกแบบการรับรองความถูกต้องเนื่องจากมีคุณสมบัติต่างๆเช่นregister, forgot password และ send password reminders.

Redis

Laravel ใช้ Redisเพื่อเชื่อมต่อกับเซสชันที่มีอยู่และแคชวัตถุประสงค์ทั่วไป Redis โต้ตอบกับเซสชันโดยตรง

คิว

Laravel มีบริการคิวเช่นการส่งอีเมลถึงผู้ใช้จำนวนมากหรือที่ระบุ Cronงาน. คิวเหล่านี้ช่วยในการทำงานให้เสร็จสิ้นได้ง่ายขึ้นโดยไม่ต้องรอให้งานก่อนหน้านี้เสร็จสิ้น

เหตุการณ์และบัสคำสั่ง

Laravel 5.1 ประกอบด้วย Command Busซึ่งช่วยในการดำเนินการคำสั่งและจัดส่งเหตุการณ์ด้วยวิธีง่ายๆ คำสั่งใน Laravel ทำหน้าที่ตามวงจรชีวิตของแอปพลิเคชัน

สำหรับการจัดการการอ้างอิง Laravel ใช้ composer. ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง Composer ในระบบของคุณก่อนที่คุณจะติดตั้ง Laravel ในบทนี้คุณจะเห็นขั้นตอนการติดตั้ง Laravel

คุณจะต้องทำตามขั้นตอนด้านล่างเพื่อติดตั้ง Laravel ลงในระบบของคุณ -

Step 1 - ไปที่ URL ต่อไปนี้และดาวน์โหลดโปรแกรมแต่งเพลงเพื่อติดตั้งในระบบของคุณ

https://getcomposer.org/download/

Step 2 - หลังจากติดตั้ง Composer แล้วให้ตรวจสอบการติดตั้งโดยพิมพ์คำสั่ง Composer ในพรอมต์คำสั่งดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 3- สร้างไดเร็กทอรีใหม่ที่ใดก็ได้ในระบบของคุณสำหรับโปรเจ็กต์ Laravel ใหม่ของคุณ หลังจากนั้นย้ายไปยังพา ธ ที่คุณสร้างไดเร็กทอรีใหม่และพิมพ์คำสั่งต่อไปนี้เพื่อติดตั้ง Laravel

composer create-project laravel/laravel –-prefer-dist

ตอนนี้เราจะเน้นไปที่การติดตั้งเวอร์ชัน 5.7 ใน Laravel เวอร์ชัน 5.7 คุณสามารถติดตั้งเฟรมเวิร์กทั้งหมดได้โดยพิมพ์คำสั่งต่อไปนี้ -

composer create-project laravel/laravel test dev-develop

ผลลัพธ์ของคำสั่งดังแสดงด้านล่าง -

เฟรมเวิร์ก Laravel สามารถติดตั้งโดยตรงกับสาขาการพัฒนาซึ่งรวมถึงเฟรมเวิร์กล่าสุด

Step 4- คำสั่งดังกล่าวจะติดตั้ง Laravel ในไดเร็กทอรีปัจจุบัน เริ่มบริการ Laravel โดยดำเนินการคำสั่งต่อไปนี้

php artisan serve

Step 5 - หลังจากดำเนินการคำสั่งดังกล่าวแล้วคุณจะเห็นหน้าจอดังที่แสดงด้านล่าง -

Step 6- คัดลอก URL ที่ขีดเส้นใต้ด้วยสีเทาในภาพหน้าจอด้านบนและเปิด URL นั้นในเบราว์เซอร์ หากคุณเห็นหน้าจอต่อไปนี้แสดงว่า Laravel ได้รับการติดตั้งสำเร็จแล้ว

โครงสร้างแอปพลิเคชันใน Laravel เป็นโครงสร้างของโฟลเดอร์โฟลเดอร์ย่อยและไฟล์ที่รวมอยู่ในโปรเจ็กต์ เมื่อเราสร้างโครงการใน Laravel เราจะได้รับภาพรวมของโครงสร้างแอปพลิเคชันดังที่แสดงในภาพที่นี่

ภาพรวมที่แสดงที่นี่หมายถึงโฟลเดอร์รูทของ Laravel คือ laravel-project. ประกอบด้วยโฟลเดอร์ย่อยและไฟล์ต่างๆ การวิเคราะห์โฟลเดอร์และไฟล์รวมถึงแง่มุมการทำงานได้รับด้านล่าง -

แอป

เป็นโฟลเดอร์ของแอปพลิเคชันและมีซอร์สโค้ดทั้งหมดของโครงการ ประกอบด้วยเหตุการณ์ข้อยกเว้นและการประกาศมิดเดิลแวร์ โฟลเดอร์แอพประกอบด้วยโฟลเดอร์ย่อยต่างๆตามที่อธิบายไว้ด้านล่าง -

คอนโซล

คอนโซลมีคำสั่งช่างที่จำเป็นสำหรับ Laravel ประกอบด้วยไดเร็กทอรีชื่อCommandsโดยที่คำสั่งทั้งหมดจะถูกประกาศด้วยลายเซ็นที่เหมาะสม ไฟล์Kernal.php เรียกคำสั่งที่ประกาศใน Inspire.php.

หากเราต้องการเรียกใช้คำสั่งเฉพาะใน Laravel เราควรทำการเปลี่ยนแปลงที่เหมาะสมในไดเร็กทอรีนี้

เหตุการณ์

โฟลเดอร์นี้รวมเหตุการณ์ทั้งหมดสำหรับโครงการ

เหตุการณ์ถูกใช้เพื่อทริกเกอร์กิจกรรมเพิ่มข้อผิดพลาดหรือการตรวจสอบที่จำเป็นและให้ความยืดหยุ่นมากขึ้น Laravel เก็บเหตุการณ์ทั้งหมดไว้ในไดเรกทอรีเดียว รวมไฟล์เริ่มต้นคือevent.php ที่ซึ่งมีการประกาศเหตุการณ์พื้นฐานทั้งหมด

ข้อยกเว้น

โฟลเดอร์นี้มีวิธีการทั้งหมดที่จำเป็นในการจัดการข้อยกเว้น นอกจากนี้ยังมีไฟล์handle.php ที่จัดการข้อยกเว้นทั้งหมด

http

Httpโฟลเดอร์มีโฟลเดอร์ย่อยสำหรับคอนโทรลเลอร์มิดเดิลแวร์และคำขอแอปพลิเคชัน เนื่องจาก Laravel เป็นไปตามรูปแบบการออกแบบ MVC โฟลเดอร์นี้จึงมีโมเดลตัวควบคุมและมุมมองที่กำหนดไว้สำหรับไดเร็กทอรีเฉพาะ

Middleware โฟลเดอร์ย่อยประกอบด้วยกลไกมิดเดิลแวร์ซึ่งประกอบด้วยกลไกการกรองและการสื่อสารระหว่างการตอบกลับและคำร้องขอ

Requests โฟลเดอร์ย่อยประกอบด้วยคำขอทั้งหมดของแอปพลิเคชัน

งาน

Jobsไดเร็กทอรีเก็บกิจกรรมที่อยู่ในคิวสำหรับแอปพลิเคชัน Laravel คลาสพื้นฐานจะใช้ร่วมกันระหว่างงานทั้งหมดและจัดเตรียมตำแหน่งส่วนกลางเพื่อวางไว้ใต้หลังคาเดียวกัน

ผู้ฟัง

ผู้ฟังขึ้นอยู่กับเหตุการณ์และรวมถึงวิธีการที่ใช้จัดการเหตุการณ์และข้อยกเว้น ตัวอย่างเช่นไฟล์login เหตุการณ์ที่ประกาศรวมถึง LoginListener เหตุการณ์.

นโยบาย

นโยบายคือคลาส PHP ซึ่งรวมถึงตรรกะการอนุญาต Laravel มีคุณสมบัติในการสร้างตรรกะการอนุญาตทั้งหมดภายในคลาสนโยบายภายในโฟลเดอร์ย่อยนี้

ผู้ให้บริการ

โฟลเดอร์นี้รวมถึงผู้ให้บริการทั้งหมดที่จำเป็นในการลงทะเบียนเหตุการณ์สำหรับเซิร์ฟเวอร์หลักและกำหนดค่าแอปพลิเคชัน Laravel

Bootstrap

โฟลเดอร์นี้รวมสคริปต์ bootstrap ของแอปพลิเคชันทั้งหมด ประกอบด้วยโฟลเดอร์ย่อยคือcacheซึ่งรวมถึงไฟล์ทั้งหมดที่เกี่ยวข้องกับการแคชเว็บแอปพลิเคชัน คุณยังสามารถค้นหาไฟล์app.phpซึ่งเริ่มต้นสคริปต์ที่จำเป็นสำหรับการบูตสแตรป

Config

configโฟลเดอร์ประกอบด้วยการกำหนดค่าต่างๆและพารามิเตอร์ที่เกี่ยวข้องที่จำเป็นสำหรับการทำงานที่ราบรื่นของแอปพลิเคชัน Laravel ไฟล์ต่างๆที่รวมอยู่ในโฟลเดอร์ config มีดังที่แสดงในภาพที่นี่ ชื่อไฟล์ทำงานตามฟังก์ชันการทำงานที่เกี่ยวข้อง

ฐานข้อมูล

ตามชื่อที่แนะนำไดเร็กทอรีนี้มีพารามิเตอร์ต่างๆสำหรับฟังก์ชันฐานข้อมูล ประกอบด้วยไดเรกทอรีย่อยสามรายการตามที่ระบุด้านล่าง -

Seeds - ประกอบด้วยคลาสที่ใช้สำหรับฐานข้อมูลการทดสอบหน่วย
Migrations - โฟลเดอร์นี้ช่วยในการสอบถามสำหรับการย้ายฐานข้อมูลที่ใช้ในเว็บแอปพลิเคชัน
Factories - โฟลเดอร์นี้ใช้เพื่อสร้างบันทึกข้อมูลจำนวนมาก

สาธารณะ

เป็นโฟลเดอร์รูทที่ช่วยในการเริ่มต้นแอปพลิเคชัน Laravel ประกอบด้วยไฟล์และโฟลเดอร์ต่อไปนี้ -

.htaccess - ไฟล์นี้ให้การกำหนดค่าเซิร์ฟเวอร์
javascript and css - ไฟล์เหล่านี้ถือเป็นสินทรัพย์
index.php - ไฟล์นี้จำเป็นสำหรับการเริ่มต้นเว็บแอปพลิเคชัน

ทรัพยากร

ไดเร็กทอรีทรัพยากรมีไฟล์ที่ช่วยปรับปรุงเว็บแอปพลิเคชันของคุณ โฟลเดอร์ย่อยที่รวมอยู่ในไดเร็กทอรีนี้และวัตถุประสงค์ของโฟลเดอร์เหล่านี้ได้อธิบายไว้ด้านล่าง -

assets - โฟลเดอร์เนื้อหาประกอบด้วยไฟล์ต่างๆเช่น LESS และ SCSS ซึ่งจำเป็นสำหรับการจัดรูปแบบเว็บแอปพลิเคชัน
lang - โฟลเดอร์นี้มีการกำหนดค่าสำหรับการแปลหรือการทำให้เป็นภาษาท้องถิ่น
views - มุมมองคือไฟล์ HTML หรือเทมเพลตที่โต้ตอบกับผู้ใช้ปลายทางและมีบทบาทหลักในสถาปัตยกรรม MVC

สังเกตว่าไดเรกทอรีทรัพยากรจะแบนแทนที่จะมีโฟลเดอร์เนื้อหา การแสดงภาพที่เหมือนกันแสดงไว้ด้านล่าง -

การจัดเก็บ

นี่คือโฟลเดอร์ที่เก็บบันทึกและไฟล์ที่จำเป็นทั้งหมดซึ่งจำเป็นต้องใช้บ่อยครั้งเมื่อโปรเจ็กต์ Laravel กำลังทำงาน โฟลเดอร์ย่อยที่รวมอยู่ในไดเร็กทอรีนี้และวัตถุประสงค์ของโฟลเดอร์เหล่านี้ได้รับด้านล่าง -

app - โฟลเดอร์นี้มีไฟล์ที่เรียกต่อเนื่องกัน
framework - ประกอบด้วยเซสชันแคชและมุมมองที่เรียกบ่อย
Logs - มีการติดตามข้อยกเว้นและบันทึกข้อผิดพลาดทั้งหมดในโฟลเดอร์ย่อยนี้

การทดสอบ

กรณีการทดสอบหน่วยทั้งหมดรวมอยู่ในไดเร็กทอรีนี้ หลักการตั้งชื่อสำหรับการตั้งชื่อคลาสกรณีทดสอบคือcamel_case และปฏิบัติตามแบบแผนตามฟังก์ชันการทำงานของคลาส

ผู้ขาย

Laravel ขึ้นอยู่กับ Composer dependencies อย่างสมบูรณ์เช่นเพื่อติดตั้งการตั้งค่า Laravel หรือรวมไลบรารีของบุคคลที่สามเป็นต้นโฟลเดอร์ Vendor มีการอ้างอิงผู้แต่งทั้งหมด

นอกเหนือจากไฟล์ที่กล่าวถึงข้างต้น Laravel ยังมีไฟล์อื่น ๆ ที่มีบทบาทหลักในฟังก์ชันต่างๆเช่นการกำหนดค่า GitHub แพ็คเกจและไลบรารีของบุคคลที่สาม

ไฟล์ที่รวมอยู่ในโครงสร้างแอปพลิเคชันแสดงไว้ด้านล่าง -

ในบทที่แล้วเราได้เห็นว่าไฟล์การกำหนดค่าพื้นฐานของ Laravel รวมอยู่ในไฟล์ configไดเรกทอรี ในบทนี้ให้เราพูดถึงหมวดหมู่ที่รวมอยู่ในการกำหนดค่า

การกำหนดค่าสภาพแวดล้อม

ตัวแปรสภาพแวดล้อมคือตัวแปรที่ให้รายการบริการบนเว็บสำหรับเว็บแอปพลิเคชันของคุณ ตัวแปรสภาพแวดล้อมทั้งหมดถูกประกาศในไฟล์.env ไฟล์ซึ่งมีพารามิเตอร์ที่จำเป็นสำหรับการเริ่มต้นการกำหนดค่า

โดยค่าเริ่มต้นไฟล์ .env ไฟล์มีพารามิเตอร์ต่อไปนี้ -

APP_ENV = local
APP_DEBUG = true
APP_KEY = base64:ZPt2wmKE/X4eEhrzJU6XX4R93rCwYG8E2f8QUA7kGK8 =
APP_URL = http://localhost
DB_CONNECTION = mysql
DB_HOST = 127.0.0.1
DB_PORT = 3306
DB_DATABASE = homestead
DB_USERNAME = homestead
DB_PASSWORD = secret
CACHE_DRIVER = file
SESSION_DRIVER = file
QUEUE_DRIVER = sync
REDIS_HOST = 127.0.0.1
REDIS_PASSWORD = null
REDIS_PORT = 6379
MAIL_DRIVER = smtp
MAIL_HOST = mailtrap.ioMAIL_PORT = 2525
MAIL_USERNAME = null
MAIL_PASSWORD = null
MAIL_ENCRYPTION = null

จุดสำคัญ

ในขณะที่ทำงานกับไฟล์กำหนดค่าพื้นฐานของ Laravel ควรสังเกตประเด็นต่อไปนี้ -

.env ไม่ควรผูกมัดกับการควบคุมแหล่งที่มาของแอปพลิเคชันเนื่องจากผู้พัฒนาหรือผู้ใช้แต่ละรายมีการกำหนดค่าสภาพแวดล้อมที่กำหนดไว้ล่วงหน้าสำหรับเว็บแอปพลิเคชัน
สำหรับตัวเลือกการสำรองข้อมูลทีมพัฒนาควรรวมไฟล์ .env.example ซึ่งควรมีการกำหนดค่าเริ่มต้น

การดึงตัวแปรสภาพแวดล้อม

ตัวแปรสภาพแวดล้อมทั้งหมดที่ประกาศใน .env ไฟล์สามารถเข้าถึงได้โดย env-helperฟังก์ชันซึ่งจะเรียกพารามิเตอร์ตามลำดับ ตัวแปรเหล่านี้ยังแสดงอยู่ใน$_ENVตัวแปรส่วนกลางเมื่อใดก็ตามที่แอปพลิเคชันได้รับคำขอจากผู้ใช้ คุณสามารถเข้าถึงตัวแปรสภาพแวดล้อมดังที่แสดงด้านล่าง -

'env' => env('APP_ENV', 'production'),

env-helper ฟังก์ชันถูกเรียกใช้ในไฟล์ app.php รวมอยู่ในไฟล์ configโฟลเดอร์ ตัวอย่างข้างต้นกำลังเรียกหาพารามิเตอร์โลคัลพื้นฐาน

การเข้าถึงค่าการกำหนดค่า

คุณสามารถเข้าถึงค่าการกำหนดค่าได้อย่างง่ายดายจากที่ใดก็ได้ในแอปพลิเคชันโดยใช้ฟังก์ชัน global config helper ในกรณีที่ไม่ได้เตรียมใช้งานค่าคอนฟิกูเรชันค่าดีฟอลต์จะถูกส่งกลับ

ตัวอย่างเช่นในการตั้งค่าเขตเวลาเริ่มต้นจะใช้รหัสต่อไปนี้ -

config(['app.timezone' => 'Asia/Kolkata']);

แคชการกำหนดค่า

เพื่อเพิ่มประสิทธิภาพและเพิ่มแอปพลิเคชันเว็บสิ่งสำคัญคือต้องแคชค่าการกำหนดค่าทั้งหมด คำสั่งสำหรับแคชค่าคอนฟิกูเรชันคือ -

config:cache

ภาพหน้าจอต่อไปนี้แสดงการแคชอย่างเป็นระบบ -

โหมดการบำรุงรักษา

บางครั้งคุณอาจต้องอัปเดตค่าการกำหนดค่าบางอย่างหรือทำการบำรุงรักษาเว็บไซต์ของคุณ ในกรณีเช่นนี้ให้เก็บไว้maintenance modeทำให้ง่ายขึ้นสำหรับคุณ เว็บแอปพลิเคชันดังกล่าวซึ่งเก็บไว้ในโหมดการบำรุงรักษามีข้อยกเว้นคือMaintenanceModeException ด้วยรหัสสถานะ 503

คุณสามารถเปิดใช้งานโหมดการบำรุงรักษาบนเว็บแอปพลิเคชัน Laravel ของคุณโดยใช้คำสั่งต่อไปนี้ -

php artisan down

ภาพหน้าจอต่อไปนี้แสดงให้เห็นว่าเว็บแอปพลิเคชันมีลักษณะอย่างไรเมื่อไม่ทำงาน -

เมื่อคุณเสร็จสิ้นการอัปเดตและการบำรุงรักษาอื่น ๆ คุณสามารถปิดโหมดการบำรุงรักษาบนเว็บแอปพลิเคชันของคุณโดยใช้คำสั่งต่อไปนี้ -

php artisan up

ตอนนี้คุณจะพบว่าเว็บไซต์แสดงผลลัพธ์พร้อมการทำงานที่เหมาะสมและแสดงให้เห็นว่าขณะนี้โหมดการบำรุงรักษาถูกลบออกดังที่แสดงด้านล่าง -

ใน Laravel คำขอทั้งหมดจะถูกแมปด้วยความช่วยเหลือของเส้นทาง การกำหนดเส้นทางพื้นฐานกำหนดเส้นทางการร้องขอไปยังคอนโทรลเลอร์ที่เกี่ยวข้อง บทนี้จะกล่าวถึงการกำหนดเส้นทางใน Laravel

การกำหนดเส้นทางใน Laravel ประกอบด้วยหมวดหมู่ต่อไปนี้ -

การกำหนดเส้นทางพื้นฐาน
พารามิเตอร์เส้นทาง
ชื่อเส้นทาง

การกำหนดเส้นทางพื้นฐาน

เส้นทางแอปพลิเคชันทั้งหมดได้รับการลงทะเบียนภายในไฟล์ app/routes.phpไฟล์. ไฟล์นี้จะบอก Laravel สำหรับ URI ที่ควรตอบสนองและคอนโทรลเลอร์ที่เกี่ยวข้องจะโทรหามัน ตัวอย่างเส้นทางสำหรับหน้ายินดีต้อนรับสามารถดูได้ตามที่แสดงในภาพหน้าจอด้านล่าง -

Route::get ('/', function () {
   return view('welcome');});

ตัวอย่าง

ดูตัวอย่างต่อไปนี้เพื่อทำความเข้าใจเพิ่มเติมเกี่ยวกับการกำหนดเส้นทาง -

app/Http/routes.php

<?php
Route::get('/', function () {
   return view('welcome');
});

resources/view/welcome.blade.php

<!DOCTYPE html>
<html>
   <head>
      <title>Laravel</title>
      <link href = "https://fonts.googleapis.com/css?family=Lato:100" rel = "stylesheet" 
         type = "text/css">
      
      <style>
         html, body {
            height: 100%;
         }
         body {
            margin: 0;
            padding: 0;
            width: 100%;
            display: table;
            font-weight: 100;
            font-family: 'Lato';
         }
         .container {
            text-align: center;
            display: table-cell;
            vertical-align: middle;
         }
         .content {
            text-align: center;
            display: inline-block;
         }
         .title {
            font-size: 96px;
         }
      </style>
   </head>
   
   <body>
      <div class = "container">
         
         <div class = "content">
            <div class = "title">Laravel 5.1</div>
         </div>
			
      </div>
   </body>
</html>

กลไกการกำหนดเส้นทางแสดงในภาพด้านล่าง -

ตอนนี้ให้เราเข้าใจขั้นตอนที่เกี่ยวข้องกับกลไกการกำหนดเส้นทางโดยละเอียด -

Step 1 - เริ่มแรกเราควรเรียกใช้ URL รากของแอปพลิเคชัน

Step 2 - ตอนนี้ URL ที่เรียกใช้งานควรตรงกับวิธีการที่เหมาะสมในไฟล์ route.phpไฟล์. ในกรณีปัจจุบันควรตรงกับวิธีการและ URL รูท ('/') สิ่งนี้จะเรียกใช้ฟังก์ชันที่เกี่ยวข้อง

Step 3 - ฟังก์ชั่นเรียกไฟล์เทมเพลต resources/views/welcome.blade.php. ถัดไปฟังก์ชั่นเรียกใช้ view() ฟังก์ชันที่มีอาร์กิวเมนต์ ‘welcome’ โดยไม่ต้องใช้ blade.php.

สิ่งนี้จะสร้างผลลัพธ์ HTML ดังที่แสดงในภาพด้านล่าง -

พารามิเตอร์เส้นทาง

บางครั้งในเว็บแอปพลิเคชันคุณอาจต้องบันทึกพารามิเตอร์ที่ส่งมาพร้อมกับ URL สำหรับสิ่งนี้คุณควรแก้ไขรหัสในroutes.php ไฟล์.

คุณสามารถจับพารามิเตอร์ในรูปแบบ routes.php ไฟล์ได้สองวิธีตามที่กล่าวไว้ที่นี่ -

พารามิเตอร์ที่จำเป็น

พารามิเตอร์เหล่านี้เป็นพารามิเตอร์ที่ควรถูกจับเพื่อกำหนดเส้นทางเว็บแอปพลิเคชัน ตัวอย่างเช่นสิ่งสำคัญคือต้องจับหมายเลขประจำตัวของผู้ใช้จาก URL สิ่งนี้สามารถทำได้โดยการกำหนดพารามิเตอร์เส้นทางตามที่แสดงด้านล่าง -

Route::get('ID/{id}',function($id) {
   echo 'ID: '.$id;
});

พารามิเตอร์เสริม

บางครั้งนักพัฒนาสามารถสร้างพารามิเตอร์เป็นทางเลือกและเป็นไปได้ด้วยการรวมไฟล์ ?หลังชื่อพารามิเตอร์ใน URL สิ่งสำคัญคือต้องเก็บค่าเริ่มต้นที่กล่าวถึงเป็นชื่อพารามิเตอร์ ดูตัวอย่างต่อไปนี้ที่แสดงวิธีกำหนดพารามิเตอร์ทางเลือก -

Route::get('user/{name?}', function ($name = 'TutorialsPoint') { return $name;});

ตัวอย่างด้านบนตรวจสอบว่าค่าตรงกับหรือไม่ TutorialsPoint และตามเส้นทางไปยัง URL ที่กำหนด

ชื่อเส้นทาง

เส้นทางที่ตั้งชื่อช่วยให้สามารถสร้างเส้นทางได้อย่างสะดวก การเชื่อมโยงเส้นทางสามารถระบุได้โดยใช้เมธอด name บนนิยามเส้นทาง โค้ดต่อไปนี้แสดงตัวอย่างสำหรับการสร้างเส้นทางที่มีชื่อด้วยคอนโทรลเลอร์ -

Route::get('user/profile', 'UserController@showProfile')->name('profile');

ตัวควบคุมผู้ใช้จะเรียกใช้ฟังก์ชัน showProfile ด้วยพารามิเตอร์เป็น profile. พารามิเตอร์ใช้name วิธีการกำหนดเส้นทาง

มิดเดิลแวร์ทำหน้าที่เป็นสะพานเชื่อมระหว่างคำขอและการตอบกลับ เป็นกลไกการกรองประเภทหนึ่ง บทนี้อธิบายกลไกตัวกลางใน Laravel

Laravel มีมิดเดิลแวร์ที่ใช้ตรวจสอบว่าผู้ใช้แอปพลิเคชันได้รับการรับรองความถูกต้องหรือไม่ หากผู้ใช้ได้รับการพิสูจน์ตัวตนผู้ใช้จะเปลี่ยนเส้นทางไปยังโฮมเพจไม่เช่นนั้นระบบจะเปลี่ยนเส้นทางไปยังหน้าล็อกอิน

สามารถสร้างมิดเดิลแวร์ได้โดยดำเนินการคำสั่งต่อไปนี้ -

php artisan make:middleware <middleware-name>

แทนที่ <middleware-name>ด้วยชื่อมิดเดิลแวร์ของคุณ ตัวกลางที่คุณสร้างสามารถดูได้ที่app/Http/Middleware ไดเรกทอรี

ตัวอย่าง

สังเกตตัวอย่างต่อไปนี้เพื่อทำความเข้าใจกลไกตัวกลาง -

Step 1- ให้เราสร้าง AgeMiddleware ในการสร้างสิ่งนั้นเราต้องดำเนินการคำสั่งต่อไปนี้ -

php artisan make:middleware AgeMiddleware

Step 2 - หลังจากดำเนินการคำสั่งสำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 3 - AgeMiddleware จะถูกสร้างขึ้นที่ app/Http/Middleware. ไฟล์ที่สร้างใหม่จะมีโค้ดต่อไปนี้ที่สร้างไว้ให้คุณแล้ว

<?php

namespace App\Http\Middleware;
use Closure;

class AgeMiddleware {
   public function handle($request, Closure $next) { return $next($request);
   }
}

การลงทะเบียนมิดเดิลแวร์

เราจำเป็นต้องลงทะเบียนทุกตัวกลางก่อนใช้งาน มี Middleware สองประเภทใน Laravel

มิดเดิลแวร์ระดับโลก
เส้นทางมิดเดิลแวร์

Global Middleware จะทำงานตามคำขอ HTTP ทุกรายการของแอปพลิเคชันในขณะที่ไฟล์ Route Middlewareจะถูกกำหนดให้กับเส้นทางเฉพาะ สามารถลงทะเบียนมิดเดิลแวร์ได้ที่app/Http/Kernel.php. ไฟล์นี้มีคุณสมบัติสองอย่าง $middleware และ $routeMiddleware. $middleware ใช้เพื่อลงทะเบียน Global Middleware และ $routeMiddleware คุณสมบัติถูกใช้เพื่อลงทะเบียนมิดเดิลแวร์เฉพาะเส้นทาง

ในการลงทะเบียนมิดเดิลแวร์ส่วนกลางให้แสดงรายการคลาสที่ส่วนท้ายของคุณสมบัติ $ มิดเดิลแวร์

protected $middleware = [
   \Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode::class,
   \App\Http\Middleware\EncryptCookies::class,
   \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
   \Illuminate\Session\Middleware\StartSession::class,
   \Illuminate\View\Middleware\ShareErrorsFromSession::class,
   \App\Http\Middleware\VerifyCsrfToken::class,
];

ในการลงทะเบียนมิดเดิลแวร์เฉพาะเส้นทางให้เพิ่มคีย์และค่าให้กับคุณสมบัติ $ routeMiddleware

protected $routeMiddleware = [
   'auth' => \App\Http\Middleware\Authenticate::class,
   'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
   'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
];

ตัวอย่าง

เราได้สร้าง AgeMiddlewareในตัวอย่างก่อนหน้านี้ ตอนนี้เราสามารถลงทะเบียนได้ในคุณสมบัติมิดเดิลแวร์กำหนดเส้นทาง รหัสสำหรับการลงทะเบียนนั้นแสดงอยู่ด้านล่าง

ต่อไปนี้เป็นรหัสสำหรับ app/Http/Kernel.php -

<?php

namespace App\Http;
use Illuminate\Foundation\Http\Kernel as HttpKernel;

class Kernel extends HttpKernel {
   protected $middleware = [
      \Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode::class,
      \App\Http\Middleware\EncryptCookies::class,
      \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
      \Illuminate\Session\Middleware\StartSession::class,
      \Illuminate\View\Middleware\ShareErrorsFromSession::class,
      \App\Http\Middleware\VerifyCsrfToken::class,
   ];
  
   protected $routeMiddleware = [
      'auth' => \App\Http\Middleware\Authenticate::class,
      'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
      'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
      'Age' => \App\Http\Middleware\AgeMiddleware::class,
   ];
}

พารามิเตอร์มิดเดิลแวร์

เรายังสามารถส่งผ่านพารามิเตอร์ด้วยมิดเดิลแวร์ ตัวอย่างเช่นหากแอปพลิเคชันของคุณมีบทบาทที่แตกต่างกันเช่นผู้ใช้ผู้ดูแลระบบผู้ดูแลระบบขั้นสูงเป็นต้นและคุณต้องการตรวจสอบการดำเนินการตามบทบาทสามารถทำได้โดยการส่งผ่านพารามิเตอร์ด้วยมิดเดิลแวร์ มิดเดิลแวร์ที่เราสร้างมีฟังก์ชันต่อไปนี้และเราสามารถส่งผ่านอาร์กิวเมนต์ที่กำหนดเองของเราหลังจาก$next การโต้เถียง.

public function handle($request, Closure $next) {
   return $next($request);
}

ตัวอย่าง

Step 1 - สร้าง RoleMiddleware โดยดำเนินการคำสั่งต่อไปนี้ -

php artisan make:middleware RoleMiddleware

Step 2 - หลังจากดำเนินการสำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 3 - เพิ่มรหัสต่อไปนี้ในวิธีจัดการของ RoleMiddlewareat ที่สร้างขึ้นใหม่ app/Http/Middleware/RoleMiddleware.php.

<?php

namespace App\Http\Middleware;
use Closure;

class RoleMiddleware {
   public function handle($request, Closure $next, $role) { echo "Role: ".$role;
      return $next($request);
   }
}

Step 4 - ลงทะเบียน RoleMiddleware ใน app\Http\Kernel.phpไฟล์. เพิ่มบรรทัดที่ไฮไลต์ด้วยสีเทาในไฟล์นั้นเพื่อลงทะเบียน RoleMiddleware

Step 5 - ดำเนินการคำสั่งต่อไปนี้เพื่อสร้าง TestController -

php artisan make:controller TestController --plain

Step 6 - หลังจากดำเนินการขั้นตอนข้างต้นสำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 7 - คัดลอกโค้ดบรรทัดต่อไปนี้ไปที่ app/Http/TestController.php ไฟล์.

app/Http/TestController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class TestController extends Controller {
   public function index() {
      echo "<br>Test Controller.";
   }
}

Step 8 - เพิ่มบรรทัดของรหัสต่อไปนี้ใน app/Http/routes.php ไฟล์.

app/Http/routes.php

Route::get('role',[
   'middleware' => 'Role:editor',
   'uses' => 'TestController@index',
]);

Step 9 - ไปที่ URL ต่อไปนี้เพื่อทดสอบ Middleware ด้วยพารามิเตอร์

http://localhost:8000/role

Step 10 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

มิดเดิลแวร์ที่ยุติได้

มิดเดิลแวร์ที่บอกเลิกได้จะทำงานบางอย่างหลังจากที่ส่งการตอบกลับไปยังเบราว์เซอร์ สิ่งนี้สามารถทำได้โดยการสร้างมิดเดิลแวร์ด้วยterminateวิธีการในมิดเดิลแวร์ มิดเดิลแวร์ที่ยกเลิกได้ควรลงทะเบียนกับมิดเดิลแวร์ระดับโลก เมธอด terminate จะได้รับสองอาร์กิวเมนต์$request และ $response. สามารถสร้างเมธอด Terminate ได้ดังแสดงในโค้ดต่อไปนี้

ตัวอย่าง

Step 1 - สร้าง TerminateMiddleware โดยดำเนินการคำสั่งด้านล่าง

php artisan make:middleware TerminateMiddleware

Step 2 - ขั้นตอนข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -

Step 3 - คัดลอกรหัสต่อไปนี้ในสิ่งที่สร้างขึ้นใหม่ TerminateMiddleware ที่ app/Http/Middleware/TerminateMiddleware.php.

<?php

namespace App\Http\Middleware;
use Closure;

class TerminateMiddleware {
   public function handle($request, Closure $next) {
      echo "Executing statements of handle method of TerminateMiddleware.";
      return $next($request);
   }
   
   public function terminate($request, $response) {
      echo "<br>Executing statements of terminate method of TerminateMiddleware.";
   }
}

Step 4 - ลงทะเบียนไฟล์ TerminateMiddleware ใน app\Http\Kernel.phpไฟล์. เพิ่มบรรทัดที่เน้นด้วยสีเทาในไฟล์นั้นเพื่อลงทะเบียน TerminateMiddleware

Step 5 - ดำเนินการคำสั่งต่อไปนี้เพื่อสร้าง ABCController.

php artisan make:controller ABCController --plain

Step 6 - หลังจากดำเนินการ URL สำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 7 - คัดลอกรหัสต่อไปนี้ไปที่ app/Http/ABCController.php ไฟล์.

app/Http/ABCController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class ABCController extends Controller {
   public function index() {
      echo "<br>ABC Controller.";
   }
}

Step 8 - เพิ่มบรรทัดของรหัสต่อไปนี้ใน app/Http/routes.php ไฟล์.

app/Http/routes.php

Route::get('terminate',[
   'middleware' => 'terminate',
   'uses' => 'ABCController@index',
]);

Step 9 - ไปที่ URL ต่อไปนี้เพื่อทดสอบมิดเดิลแวร์ที่สามารถยุติได้

http://localhost:8000/terminate

Step 10 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

Namespaces สามารถกำหนดให้เป็นคลาสขององค์ประกอบซึ่งแต่ละองค์ประกอบมีชื่อเฉพาะสำหรับคลาสที่เกี่ยวข้องนั้น อาจใช้ร่วมกับองค์ประกอบในชั้นเรียนอื่น ๆ

การประกาศเนมสเปซ

use คีย์เวิร์ดช่วยให้นักพัฒนาสามารถย่อเนมสเปซได้

use <namespace-name>;

เนมสเปซเริ่มต้นที่ใช้ใน Laravel คือแอพอย่างไรก็ตามผู้ใช้สามารถเปลี่ยนเนมสเปซให้ตรงกับเว็บแอปพลิเคชันได้ การสร้างเนมสเปซที่ผู้ใช้กำหนดด้วยคำสั่ง artisan มีการกล่าวถึงดังนี้ -

php artisan app:name SocialNet

เนมสเปซที่สร้างครั้งเดียวสามารถรวมฟังก์ชันต่างๆที่สามารถใช้ในคอนโทรลเลอร์และคลาสต่างๆ

ในเฟรมเวิร์ก MVC ตัวอักษร 'C' ย่อมาจาก Controller ทำหน้าที่เป็นตัวกำกับการรับส่งข้อมูลระหว่างมุมมองและโมเดล ในบทนี้คุณจะได้เรียนรู้เกี่ยวกับคอนโทรลเลอร์ใน Laravel

การสร้างคอนโทรลเลอร์

เปิดพรอมต์คำสั่งหรือเทอร์มินัลตามระบบปฏิบัติการที่คุณใช้และพิมพ์คำสั่งต่อไปนี้เพื่อสร้างคอนโทรลเลอร์โดยใช้ Artisan CLI (Command Line Interface)

php artisan make:controller <controller-name> --plain

แทนที่ <controller-name> ด้วยชื่อคอนโทรลเลอร์ของคุณ สิ่งนี้จะสร้างตัวสร้างธรรมดาขณะที่เรากำลังส่งผ่านอาร์กิวเมนต์ -plain. หากคุณไม่ต้องการสร้างตัวสร้างธรรมดาคุณสามารถเพิกเฉยต่ออาร์กิวเมนต์ได้ ตัวสร้างที่สร้างขึ้นสามารถดูได้ที่app/Http/Controllers.

คุณจะเห็นว่ามีการเข้ารหัสพื้นฐานบางอย่างสำหรับคุณแล้วและคุณสามารถเพิ่มการเข้ารหัสที่กำหนดเองได้ ตัวควบคุมที่สร้างขึ้นสามารถเรียกใช้จาก route.php โดยใช้ไวยากรณ์ต่อไปนี้

ไวยากรณ์

Route::get(‘base URI’,’controller@method’);

ตัวอย่าง

Step 1 - ดำเนินการคำสั่งต่อไปนี้เพื่อสร้าง UserController.

php artisan make:controller UserController --plain

Step 2 - หลังจากดำเนินการสำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้

Step 3 - คุณสามารถดูคอนโทรลเลอร์ที่สร้างขึ้นได้ที่ app/Http/Controller/UserController.php ด้วยการเขียนโค้ดพื้นฐานบางอย่างที่เขียนไว้แล้วสำหรับคุณและคุณสามารถเพิ่มการเข้ารหัสของคุณเองได้ตามความต้องการของคุณ

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class UserController extends Controller {
   //
}

มิดเดิลแวร์คอนโทรลเลอร์

เราเคยเห็นมิดเดิลแวร์มาก่อนและสามารถใช้กับคอนโทรลเลอร์ได้ด้วย มิดเดิลแวร์ยังสามารถกำหนดเส้นทางของคอนโทรลเลอร์หรือภายในคอนสตรัคเตอร์ของคอนโทรลเลอร์ของคุณ คุณสามารถใช้วิธีมิดเดิลแวร์เพื่อกำหนดมิดเดิลแวร์ให้กับคอนโทรลเลอร์ มิดเดิลแวร์ที่ลงทะเบียนแล้วยังสามารถ จำกัด เฉพาะวิธีการบางอย่างของคอนโทรลเลอร์

การกำหนดมิดเดิลแวร์ให้กับเส้นทาง

Route::get('profile', [
   'middleware' => 'auth',
   'uses' => 'UserController@showProfile'
]);

ที่นี่เรากำลังกำหนดมิดเดิลแวร์การตรวจสอบสิทธิ์ให้กับ UserController ในเส้นทางโปรไฟล์

การกำหนดมิดเดิลแวร์ภายในคอนสตรัคเตอร์ของคอนโทรลเลอร์

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class UserController extends Controller {
   public function __construct() {
      $this->middleware('auth');
   }
}

ที่นี่เรากำลังกำหนด auth มิดเดิลแวร์โดยใช้วิธีมิดเดิลแวร์ในไฟล์ UserController ผู้สร้าง

ตัวอย่าง

Step 1 - เพิ่มบรรทัดของรหัสต่อไปนี้ในไฟล์ app/Http/routes.php ไฟล์และบันทึก

routes.php

<?php
Route::get('/usercontroller/path',[
   'middleware' => 'First',
   'uses' => 'UserController@showPath'
]);

Step 2 - สร้างตัวกลางที่เรียกว่า FirstMiddleware โดยเรียกใช้โค้ดบรรทัดต่อไปนี้

php artisan make:middleware FirstMiddleware

Step 3 - เพิ่มรหัสต่อไปนี้ในไฟล์ handle วิธีการของ FirstMiddleware ที่สร้างขึ้นใหม่ที่ app/Http/Middleware.

FirstMiddleware.php

<?php

namespace App\Http\Middleware;
use Closure;

class FirstMiddleware {
   public function handle($request, Closure $next) { echo '<br>First Middleware'; return $next($request);
   }
}

Step 4 - สร้างตัวกลางที่เรียกว่า SecondMiddleware โดยดำเนินการคำสั่งต่อไปนี้

php artisan make:middleware SecondMiddleware

Step 5 - เพิ่มรหัสต่อไปนี้ในวิธีจัดการของ SecondMiddleware ที่สร้างขึ้นใหม่ที่ app/Http/Middleware.

SecondMiddleware.php

<?php

namespace App\Http\Middleware;
use Closure;

class SecondMiddleware {
   public function handle($request, Closure $next) { echo '<br>Second Middleware'; return $next($request);
   }
}

Step 6 - สร้างตัวควบคุมที่เรียกว่า UserController โดยดำเนินการบรรทัดต่อไปนี้

php artisan make:controller UserController --plain

Step 7 - หลังจากดำเนินการ URL สำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 8 - คัดลอกรหัสต่อไปนี้ไปที่ app/Http/UserController.php ไฟล์.

app/Http/UserController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class UserController extends Controller {
   public function __construct() {
      $this->middleware('Second');
   }
   public function showPath(Request $request) { $uri = $request->path(); echo '<br>URI: '.$uri;
      
      $url = $request->url();
      echo '<br>';
      
      echo 'URL: '.$url; $method = $request->method(); echo '<br>'; echo 'Method: '.$method;
   }
}

Step 9 - ตอนนี้เปิดเว็บเซิร์ฟเวอร์ภายในของ php โดยดำเนินการคำสั่งต่อไปนี้หากคุณยังไม่ได้ดำเนินการ

php artisan serve

Step 10 - ไปที่ URL ต่อไปนี้

http://localhost:8000/usercontroller/path

Step 11 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

ตัวควบคุมทรัพยากรที่สงบ

บ่อยครั้งในขณะที่สร้างแอปพลิเคชันเราจำเป็นต้องดำเนินการ CRUD (Create, Read, Update, Delete)การดำเนินงาน Laravel ทำให้งานนี้ง่ายสำหรับเรา เพียงสร้างคอนโทรลเลอร์จากนั้น Laravel จะจัดเตรียมวิธีการทั้งหมดสำหรับการดำเนินการ CRUD โดยอัตโนมัติ คุณยังสามารถลงทะเบียนเส้นทางเดียวสำหรับวิธีการทั้งหมดในไฟล์ route.php

ตัวอย่าง

Step 1 - สร้างตัวควบคุมที่เรียกว่า MyController โดยดำเนินการคำสั่งต่อไปนี้

php artisan make:controller MyController

Step 2 - เพิ่มรหัสต่อไปนี้ใน

app/Http/Controllers/MyController.php ไฟล์.

app/Http/Controllers/MyController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class MyController extends Controller {
   public function index() {
      echo 'index';
   }
   public function create() {
      echo 'create';
   }
   public function store(Request $request) { echo 'store'; } public function show($id) {
      echo 'show';
   }
   public function edit($id) { echo 'edit'; } public function update(Request $request, $id) { echo 'update'; } public function destroy($id) {
      echo 'destroy';
   }
}

Step 3 - เพิ่มบรรทัดของรหัสต่อไปนี้ใน app/Http/routes.php ไฟล์.

app/Http/routes.php

Route::resource('my','MyController');

Step 4- ตอนนี้เรากำลังลงทะเบียนวิธีการทั้งหมดของ MyController โดยการลงทะเบียนคอนโทรลเลอร์พร้อมทรัพยากร ด้านล่างนี้คือตารางการดำเนินการที่จัดการโดยตัวควบคุมทรัพยากร

กริยา	เส้นทาง	หนังบู๊	ชื่อเส้นทาง
รับ	/ ของฉัน	ดัชนี	my.index
รับ	/ my / create	สร้าง	my.create
โพสต์	/ ของฉัน	เก็บ	my.store
รับ	/ my / {my}	แสดง	my.show
รับ	/ my / {my} / edit	แก้ไข	my.edit
PUT / PATCH	/ my / {my}	อัพเดต	my.update
ลบ	/ my / {my}	ทำลาย	my.destroy

Step 5 - ลองเรียกใช้ URL ที่แสดงในตารางต่อไปนี้

URL	คำอธิบาย	ภาพที่ส่งออก
http: // localhost: 8000 / ของฉัน	เรียกใช้เมธอดดัชนีของ MyController.php	ดัชนี
http: // localhost: 8000 / my / create	Executes สร้างวิธีการของ MyController.php	สร้าง
http: // localhost: 8000 / my / 1	Executes แสดงวิธีการของ MyController.php	แสดง
http: // localhost: 8000 / my / 1 / แก้ไข	เรียกใช้วิธีการแก้ไขของ MyController.php	แก้ไข

ตัวควบคุมโดยปริยาย

Implicit Controllers ช่วยให้คุณกำหนดเส้นทางเดียวเพื่อจัดการทุกการกระทำในคอนโทรลเลอร์ คุณสามารถกำหนดได้ในไฟล์ route.php ด้วยRoute:controller วิธีการดังแสดงด้านล่าง

Route::controller(‘base URI’,’<class-name-of-the-controller>’);

แทนที่ <class-name-of-the-controller> ด้วยชื่อคลาสที่คุณกำหนดให้กับคอนโทรลเลอร์ของคุณ

ชื่อวิธีการของคอนโทรลเลอร์ควรขึ้นต้นด้วยกริยา HTTP เช่น get หรือ post หากคุณเริ่มต้นด้วย get มันจะจัดการกับคำขอเท่านั้นและหากเริ่มต้นด้วยโพสต์ก็จะจัดการคำขอโพสต์ หลังจากคำกริยา HTTP คุณสามารถตั้งชื่อใด ๆ ให้กับเมธอดได้ แต่ควรเป็นไปตามเวอร์ชันกรณีชื่อของ URI

ตัวอย่าง

Step 1- ดำเนินการคำสั่งด้านล่างเพื่อสร้างคอนโทรลเลอร์ เรายังคงชื่อชั้นไว้ImplicitController. คุณสามารถตั้งชื่อชั้นเรียนได้ตามต้องการ

php artisan make:controller ImplicitController --plain

Step 2 - หลังจากดำเนินการขั้นตอนที่ 1 สำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 3 - คัดลอกรหัสต่อไปนี้ไปที่

app/Http/Controllers/ImplicitController.php ไฟล์.

app/Http/Controllers/ImplicitController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class ImplicitController extends Controller {
   /**
      * Responds to requests to GET /test
   */
   public function getIndex() {
      echo 'index method';
   }
   
   /**
      * Responds to requests to GET /test/show/1
   */
   public function getShow($id) {
      echo 'show method';
   }
   
   /**
      * Responds to requests to GET /test/admin-profile
   */
   public function getAdminProfile() {
      echo 'admin profile method';
   }
   
   /**
      * Responds to requests to POST /test/profile
   */
   public function postProfile() {
      echo 'profile method';
   }
}

Step 4 - เพิ่มบรรทัดต่อไปนี้ใน app/Http/routes.php ไฟล์เพื่อกำหนดเส้นทางการร้องขอไปยังคอนโทรลเลอร์ที่ระบุ

app/Http/routes.php

Route::controller('test','ImplicitController');

การฉีดคอนสตรัคเตอร์

คอนเทนเนอร์บริการ Laravel ใช้เพื่อแก้ไขคอนโทรลเลอร์ Laravel ทั้งหมด ด้วยเหตุนี้คุณจึงสามารถพิมพ์คำใบ้การอ้างอิงใด ๆ ที่คอนโทรลเลอร์ของคุณอาจต้องการในตัวสร้างได้ การอ้างอิงจะได้รับการแก้ไขและฉีดเข้าไปในอินสแตนซ์คอนโทรลเลอร์โดยอัตโนมัติ

ตัวอย่าง

Step 1 - เพิ่มรหัสต่อไปนี้ใน app/Http/routes.php ไฟล์.

app/Http/routes.php

class MyClass{
   public $foo = 'bar';
}
Route::get('/myclass','ImplicitController@index');

Step 2 - เพิ่มรหัสต่อไปนี้ใน

app/Http/Controllers/ImplicitController.php ไฟล์.

app/Http/Controllers/ImplicitController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class ImplicitController extends Controller {
   private $myclass; public function __construct(\MyClass $myclass) {
      $this->myclass = $myclass;
   }
   public function index() {
      dd($this->myclass);
   }
}

Step 3 - ไปที่ URL ต่อไปนี้เพื่อทดสอบการฉีดตัวสร้าง

http://localhost:8000/myclass

Step 4 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

วิธีการฉีด

นอกจากการฉีดคอนสตรัคเตอร์แล้วคุณยังสามารถพิมพ์ - คำใบ้ขึ้นต่อวิธีการดำเนินการของคอนโทรลเลอร์ของคุณ

ตัวอย่าง

Step 1 - เพิ่มรหัสต่อไปนี้ใน app/Http/routes.php ไฟล์.

app/Http/routes.php

class MyClass{
   public $foo = 'bar';
}
Route::get('/myclass','ImplicitController@index');

Step 2 - เพิ่มรหัสต่อไปนี้ใน

app/Http/Controllers/ImplicitController.php ไฟล์.

app/Http/Controllers/ImplicitController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class ImplicitController extends Controller {
   public function index(\MyClass $myclass) { dd($myclass);
   }
}

Step 3 - ไปที่ URL ต่อไปนี้เพื่อทดสอบการฉีดตัวสร้าง

http://localhost:8000/myclass

มันจะสร้างผลลัพธ์ต่อไปนี้ -

ในบทนี้คุณจะได้เรียนรู้โดยละเอียดเกี่ยวกับคำขอใน Laravel

การดึง URI คำขอ

“path”วิธีการใช้เพื่อดึงข้อมูล URI ที่ร้องขอ isวิธีการใช้เพื่อดึง URI ที่ร้องขอซึ่งตรงกับรูปแบบเฉพาะที่ระบุในอาร์กิวเมนต์ของวิธีการ ในการรับ URL แบบเต็มเราสามารถใช้ไฟล์url วิธี.

ตัวอย่าง

Step 1 - ดำเนินการคำสั่งด้านล่างเพื่อสร้างคอนโทรลเลอร์ใหม่ที่เรียกว่า UriController.

php artisan make:controller UriController –plain

Step 2 - หลังจากดำเนินการ URL สำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 3 - หลังจากสร้างคอนโทรลเลอร์แล้วให้เพิ่มโค้ดต่อไปนี้ในไฟล์นั้น

app/Http/Controllers/UriController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class UriController extends Controller {
   
   public function index(Request $request) { // Usage of path method $path = $request->path(); echo 'Path Method: '.$path;
      echo '<br>';
     
      // Usage of is method
      $pattern = $request->is('foo/*');
      echo 'is Method: '.$pattern; echo '<br>'; // Usage of url method $url = $request->url(); echo 'URL method: '.$url;
   }
}

Step 4 - เพิ่มบรรทัดต่อไปนี้ในไฟล์ app/Http/route.php ไฟล์.

app/Http/route.php

Route::get('/foo/bar','UriController@index');

Step 5 - ไปที่ URL ต่อไปนี้

http://localhost:8000/foo/bar

Step 6 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

กำลังดึงข้อมูลเข้า

สามารถดึงค่าอินพุตได้อย่างง่ายดายใน Laravel ไม่ว่าจะใช้วิธีใดก็ตาม“get” หรือ “post”เมธอด Laravel จะดึงค่าอินพุตสำหรับทั้งสองวิธีด้วยวิธีเดียวกัน มีสองวิธีที่เราสามารถดึงค่าอินพุตได้

ใช้วิธีการป้อนข้อมูล ()
การใช้คุณสมบัติของอินสแตนซ์คำขอ

ใช้วิธีการป้อนข้อมูล ()

input()method ใช้อาร์กิวเมนต์หนึ่งชื่อของฟิลด์ในรูปแบบ ตัวอย่างเช่นหากแบบฟอร์มมีช่องชื่อผู้ใช้เราสามารถเข้าถึงได้โดยวิธีต่อไปนี้

$name = $request->input('username');

การใช้คุณสมบัติของอินสแตนซ์คำขอ

ชอบ input() วิธีการเราสามารถรับคุณสมบัติชื่อผู้ใช้โดยตรงจากอินสแตนซ์คำขอ

$request->username

ตัวอย่าง

ดูตัวอย่างต่อไปนี้เพื่อทำความเข้าใจเพิ่มเติมเกี่ยวกับคำขอ -

Step 1 - สร้างแบบฟอร์มการลงทะเบียนโดยผู้ใช้สามารถลงทะเบียนด้วยตนเองและจัดเก็บแบบฟอร์มได้ที่ resources/views/register.php

<html>

   <head>
      <title>Form Example</title>
   </head>

   <body>
      <form action = "/user/register" method = "post">
         <input type = "hidden" name = "_token" value = "<?php echo csrf_token() ?>">
      
         <table>
            <tr>
               <td>Name</td>
               <td><input type = "text" name = "name" /></td>
            </tr>
            <tr>
               <td>Username</td>
               <td><input type = "text" name = "username" /></td>
            </tr>
            <tr>
               <td>Password</td>
               <td><input type = "text" name = "password" /></td>
            </tr>
            <tr>
               <td colspan = "2" align = "center">
                  <input type = "submit" value = "Register" />
               </td>
            </tr>
         </table>
      
      </form>
   </body>
</html>

Step 2 - ดำเนินการคำสั่งด้านล่างเพื่อสร้างไฟล์ UserRegistration ตัวควบคุม

php artisan make:controller UserRegistration --plain

Step 3 - หลังจากดำเนินการขั้นตอนข้างต้นสำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 4 - คัดลอกรหัสต่อไปนี้ในรูปแบบ

app/Http/Controllers/UserRegistration.php ตัวควบคุม

app/Http/Controllers/UserRegistration.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class UserRegistration extends Controller {
   public function postRegister(Request $request) {
      //Retrieve the name input field
      $name = $request->input('name');
      echo 'Name: '.$name; echo '<br>'; //Retrieve the username input field $username = $request->username; echo 'Username: '.$username;
      echo '<br>';
      
      //Retrieve the password input field
      $password = $request->password;
      echo 'Password: '.$password;
   }
}

Step 5 - เพิ่มบรรทัดต่อไปนี้ใน app/Http/routes.php ไฟล์.

app/Http/routes.php

Route::get('/register',function() {
   return view('register');
});
Route::post('/user/register',array('uses'=>'UserRegistration@postRegister'));

Step 6- ไปที่ URL ต่อไปนี้และคุณจะเห็นแบบฟอร์มการลงทะเบียนดังแสดงในรูปด้านล่าง พิมพ์รายละเอียดการลงทะเบียนและคลิกลงทะเบียนและคุณจะเห็นในหน้าที่สองที่เราได้เรียกค้นและแสดงรายละเอียดการลงทะเบียนผู้ใช้

http://localhost:8000/register

Step 7 - ผลลัพธ์จะมีลักษณะดังที่แสดงไว้ด้านล่างภาพต่อไปนี้

คุกกี้มีบทบาทสำคัญในขณะที่จัดการเซสชันของผู้ใช้บนเว็บแอปพลิเคชัน ในบทนี้คุณจะได้เรียนรู้เกี่ยวกับการทำงานกับคุกกี้ในเว็บแอปพลิเคชันที่ใช้ Laravel

การสร้างคุกกี้

คุกกี้สามารถสร้างได้โดยผู้ช่วยคุกกี้ระดับโลกของ Laravel มันเป็นตัวอย่างของSymfony\Component\HttpFoundation\Cookie. สามารถแนบคุกกี้กับการตอบกลับโดยใช้เมธอด withCookie () สร้างอินสแตนซ์การตอบกลับของIlluminate\Http\Responseคลาสเพื่อเรียกใช้เมธอด withCookie () คุกกี้ที่ Laravel สร้างขึ้นจะถูกเข้ารหัสและลงนามและไคลเอนต์ไม่สามารถแก้ไขหรืออ่านได้

นี่คือตัวอย่างโค้ดพร้อมคำอธิบาย

//Create a response instance
$response = new Illuminate\Http\Response('Hello World');

//Call the withCookie() method with the response method
$response->withCookie(cookie('name', 'value', $minutes));

//return the response
return $response;

วิธี Cookie () จะใช้ 3 อาร์กิวเมนต์ อาร์กิวเมนต์แรกคือชื่อของคุกกี้อาร์กิวเมนต์ที่สองคือมูลค่าของคุกกี้และอาร์กิวเมนต์ที่สามคือระยะเวลาของคุกกี้หลังจากนั้นคุกกี้จะถูกลบโดยอัตโนมัติ

สามารถตั้งค่าคุกกี้ได้ตลอดไปโดยใช้วิธีการตลอดไปตามที่แสดงในโค้ดด้านล่าง

$response->withCookie(cookie()->forever('name', 'value'));

การดึงคุกกี้

เมื่อเราตั้งค่าคุกกี้แล้วเราสามารถดึงข้อมูลคุกกี้ด้วยวิธีการคุกกี้ () เมธอด cookie () นี้จะใช้อาร์กิวเมนต์เดียวซึ่งจะเป็นชื่อของคุกกี้ สามารถเรียกวิธีการคุกกี้โดยใช้ตัวอย่างของIlluminate\Http\Request.

นี่คือตัวอย่างโค้ด

//’name’ is the name of the cookie to retrieve the value of
$value = $request->cookie('name');

ตัวอย่าง

ดูตัวอย่างต่อไปนี้เพื่อทำความเข้าใจเพิ่มเติมเกี่ยวกับคุกกี้ -

Step 1 - ดำเนินการคำสั่งด้านล่างเพื่อสร้างคอนโทรลเลอร์ที่เราจะจัดการกับคุกกี้

php artisan make:controller CookieController --plain

Step 2 - หลังจากดำเนินการสำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 3 - คัดลอกรหัสต่อไปนี้ในรูปแบบ

app/Http/Controllers/CookieController.php ไฟล์.

app/Http/Controllers/CookieController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Http\Response;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class CookieController extends Controller {
   public function setCookie(Request $request) { $minutes = 1;
      $response = new Response('Hello World'); $response->withCookie(cookie('name', 'virat', $minutes)); return $response;
   }
   public function getCookie(Request $request) { $value = $request->cookie('name'); echo $value;
   }
}

Step 4 - เพิ่มบรรทัดต่อไปนี้ใน app/Http/routes.php file.

app/Http/routes.php

Route::get('/cookie/set','CookieController@setCookie');
Route::get('/cookie/get','CookieController@getCookie');

Step 5 - ไปที่ URL ต่อไปนี้เพื่อตั้งค่าคุกกี้

http://localhost:8000/cookie/set

Step 6- ผลลัพธ์จะปรากฏดังภาพด้านล่าง หน้าต่างที่ปรากฏในภาพหน้าจอนั้นนำมาจาก firefox แต่ขึ้นอยู่กับเบราว์เซอร์ของคุณคุกกี้สามารถตรวจสอบได้จากตัวเลือกคุกกี้

Step 7 - ไปที่ URL ต่อไปนี้เพื่อรับคุกกี้จาก URL ด้านบน

http://localhost:8000/cookie/get

Step 8 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

เว็บแอปพลิเคชันตอบสนองคำขอของผู้ใช้ในหลาย ๆ วิธีขึ้นอยู่กับพารามิเตอร์หลายตัว บทนี้จะอธิบายรายละเอียดเกี่ยวกับการตอบสนองในเว็บแอปพลิเคชัน Laravel

การตอบสนองพื้นฐาน

Laravel มีหลายวิธีในการตอบกลับ การตอบกลับสามารถส่งได้จากเส้นทางหรือจากตัวควบคุม การตอบกลับพื้นฐานที่สามารถส่งได้คือสตริงธรรมดาดังที่แสดงในโค้ดตัวอย่างด้านล่าง สตริงนี้จะถูกแปลงโดยอัตโนมัติเป็นการตอบสนอง HTTP ที่เหมาะสม

ตัวอย่าง

Step 1 - เพิ่มรหัสต่อไปนี้ใน app/Http/routes.php ไฟล์.

app/Http/routes.php

Route::get('/basic_response', function () {
   return 'Hello World';
});

Step 2 - Visit URL ต่อไปนี้เพื่อทดสอบการตอบสนองพื้นฐาน

http://localhost:8000/basic_response

Step 3 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

การแนบส่วนหัว

การตอบกลับสามารถแนบกับส่วนหัวโดยใช้เมธอด header () นอกจากนี้เรายังสามารถแนบชุดของส่วนหัวดังที่แสดงในโค้ดตัวอย่างด้านล่าง

return response($content,$status)
   ->header('Content-Type', $type)
   ->header('X-Header-One', 'Header Value')
   ->header('X-Header-Two', 'Header Value');

ตัวอย่าง

ดูตัวอย่างต่อไปนี้เพื่อทำความเข้าใจเพิ่มเติมเกี่ยวกับการตอบสนอง -

Step 1 - เพิ่มรหัสต่อไปนี้ใน app/Http/routes.php ไฟล์.

app/Http/routes.php

Route::get('/header',function() {
   return response("Hello", 200)->header('Content-Type', 'text/html');
});

Step 2 - ไปที่ URL ต่อไปนี้เพื่อทดสอบการตอบสนองพื้นฐาน

http://localhost:8000/header

Step 3 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

การแนบคุกกี้

withcookie()วิธีการช่วยเหลือใช้ในการแนบคุกกี้ สามารถแนบคุกกี้ที่สร้างด้วยวิธีนี้ได้โดยการโทรwithcookie()วิธีการกับอินสแตนซ์การตอบสนอง โดยค่าเริ่มต้นคุกกี้ทั้งหมดที่สร้างโดย Laravel จะถูกเข้ารหัสและลงนามเพื่อไม่ให้ไคลเอ็นต์แก้ไขหรืออ่านได้

ตัวอย่าง

ดูตัวอย่างต่อไปนี้เพื่อทำความเข้าใจเพิ่มเติมเกี่ยวกับการแนบคุกกี้ -

Step 1 - เพิ่มรหัสต่อไปนี้ใน app/Http/routes.php ไฟล์.

app/Http/routes.php

Route::get('/cookie',function() {
   return response("Hello", 200)->header('Content-Type', 'text/html')
      ->withcookie('name','Virat Gandhi');
});

Step 2 - Visit URL ต่อไปนี้เพื่อทดสอบการตอบสนองพื้นฐาน

http://localhost:8000/cookie

Step 3 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

การตอบสนอง JSON

สามารถส่งการตอบกลับ JSON โดยใช้วิธี json วิธีนี้จะตั้งค่าส่วนหัวประเภทเนื้อหาเป็นโดยอัตโนมัติapplication/json. json วิธีการจะแปลงอาร์เรย์ให้เหมาะสมโดยอัตโนมัติ json การตอบสนอง

ตัวอย่าง

ดูตัวอย่างต่อไปนี้เพื่อทำความเข้าใจเพิ่มเติมเกี่ยวกับ JSON Response -

Step 1 - เพิ่มบรรทัดต่อไปนี้ใน app/Http/routes.php ไฟล์.

app/Http/routes.php

Route::get('json',function() {
   return response()->json(['name' => 'Virat Gandhi', 'state' => 'Gujarat']);
});

Step 2 - ไปที่ URL ต่อไปนี้เพื่อทดสอบการตอบสนองของ json

http://localhost:8000/json

Step 3 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

ในกรอบ MVC ตัวอักษร “V” หมายถึง Views. มันแยกตรรกะของแอปพลิเคชันและตรรกะการนำเสนอ มุมมองจะถูกเก็บไว้ในresources/viewsไดเรกทอรี โดยทั่วไปมุมมองประกอบด้วย HTML ซึ่งจะให้บริการโดยแอปพลิเคชัน

ตัวอย่าง

ดูตัวอย่างต่อไปนี้เพื่อทำความเข้าใจเพิ่มเติมเกี่ยวกับ Views -

Step 1 - คัดลอกรหัสต่อไปนี้และบันทึกที่ resources/views/test.php

<html>
   <body>
      <h1>Hello, World</h1>
   </body>
</html>

Step 2 - เพิ่มบรรทัดต่อไปนี้ใน app/Http/routes.php ไฟล์เพื่อกำหนดเส้นทางสำหรับมุมมองด้านบน

app/Http/routes.php

Route::get('/test', function() {
   return view('test');
});

Step 3 - ไปที่ URL ต่อไปนี้เพื่อดูผลลัพธ์ของมุมมอง

http://localhost:8000/test

Step 4 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

การส่งผ่านข้อมูลไปยังมุมมอง

ในขณะที่สร้างแอปพลิเคชันอาจจำเป็นต้องส่งข้อมูลไปยังมุมมอง ส่งอาร์เรย์เพื่อดูฟังก์ชันตัวช่วย หลังจากผ่านอาร์เรย์เราสามารถใช้คีย์เพื่อรับค่าของคีย์นั้นในไฟล์ HTML

ตัวอย่าง

ดูตัวอย่างต่อไปนี้เพื่อทำความเข้าใจเพิ่มเติมเกี่ยวกับการส่งข้อมูลไปยังมุมมอง -

Step 1 - คัดลอกรหัสต่อไปนี้และบันทึกที่ resources/views/test.php

<html>
   <body>
      <h1><?php echo $name; ?></h1>
   </body>
</html>

app/Http/routes.php

Route::get('/test', function() {
   return view('test',[‘name’=>’Virat Gandhi’]);
});

Step 3 - ค่าของชื่อคีย์จะถูกส่งไปยังไฟล์ test.php และ $ name จะถูกแทนที่ด้วยค่านั้น

Step 4 - ไปที่ URL ต่อไปนี้เพื่อดูผลลัพธ์ของมุมมอง

http://localhost:8000/test

Step 5 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

การแบ่งปันข้อมูลกับทุกมุมมอง

เราได้เห็นว่าเราสามารถส่งข้อมูลไปยังมุมมองได้อย่างไร แต่บางครั้งก็มีความจำเป็นที่จะต้องส่งข้อมูลไปยังมุมมองทั้งหมด Laravel ทำให้สิ่งนี้ง่ายขึ้น มีวิธีการที่เรียกว่าshare()ซึ่งสามารถใช้เพื่อวัตถุประสงค์นี้ share()วิธีการจะใช้สองอาร์กิวเมนต์คีย์และค่า โดยปกติshare()สามารถเรียกได้จากวิธีการบูตของผู้ให้บริการ เราสามารถใช้ผู้ให้บริการใดก็ได้AppServiceProvider หรือผู้ให้บริการของเราเอง

ตัวอย่าง

ดูตัวอย่างต่อไปนี้เพื่อทำความเข้าใจเพิ่มเติมเกี่ยวกับการแชร์ข้อมูลกับทุกมุมมอง -

Step 1 - เพิ่มบรรทัดต่อไปนี้ใน app/Http/routes.php ไฟล์.

app/Http/routes.php

Route::get('/test', function() {
   return view('test');
});

Route::get('/test2', function() {
   return view('test2');
});

Step 2 - สร้างสองไฟล์ดู - test.php และ test2.phpด้วยรหัสเดียวกัน นี่คือไฟล์สองไฟล์ที่จะแชร์ข้อมูล คัดลอกรหัสต่อไปนี้ในทั้งสองไฟล์resources/views/test.php & resources/views/test2.php

<html>
   <body>
      <h1><?php echo $name; ?></h1>
   </body>
</html>

Step 3 - เปลี่ยนรหัสวิธีการบูตในไฟล์ app/Providers/AppServiceProvider.phpดังแสดงด้านล่าง (ที่นี่เราใช้วิธีการแบ่งปันและข้อมูลที่เราส่งผ่านจะถูกแบ่งปันกับมุมมองทั้งหมด)app/Providers/AppServiceProvider.php

<?php

namespace App\Providers;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider {
   
   /**
      * Bootstrap any application services.
      *
      * @return void
   */

   public function boot() {
      view()->share('name', 'Virat Gandhi');
   }

   /**
      * Register any application services.
      *
      * @return void
   */

   public function register() {
      //
   }
}

Step 4 - Visit URL ต่อไปนี้

http://localhost:8000/test
http://localhost:8000/test2

Step 5 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

Laravel 5.1 แนะนำแนวคิดการใช้งาน Bladeซึ่งเป็นเครื่องมือสร้างเทมเพลตเพื่อออกแบบเค้าโครงที่ไม่เหมือนใคร เค้าโครงที่ออกแบบมานี้สามารถใช้กับมุมมองอื่น ๆ ได้และรวมถึงการออกแบบและโครงสร้างที่สอดคล้องกัน

เมื่อเปรียบเทียบกับเครื่องยนต์เทมเพลตอื่น ๆ Blade มีลักษณะเฉพาะดังต่อไปนี้ -

ไม่ จำกัด นักพัฒนาจากการใช้โค้ด PHP ธรรมดาในมุมมอง
มุมมองใบมีดได้รับการออกแบบรวบรวมและแคชไว้จนกว่าจะมีการแก้ไข

โครงสร้างไดเร็กทอรีที่สมบูรณ์ของ Laravel แสดงอยู่ในภาพหน้าจอที่ให้ไว้ที่นี่

คุณสามารถสังเกตได้ว่ามุมมองทั้งหมดถูกเก็บไว้ในไฟล์ resources/views ไดเร็กทอรีและมุมมองเริ่มต้นสำหรับ Laravel framework คือ welcome.blade.php.

โปรดทราบว่าแม่แบบใบมีดอื่น ๆ ก็สร้างขึ้นเช่นเดียวกัน

ขั้นตอนในการสร้างเลย์เอาต์เทมเพลต Blade

คุณจะต้องใช้ขั้นตอนต่อไปนี้เพื่อสร้างเค้าโครงเทมเพลตใบมีด -

ขั้นตอนที่ 1

สร้างโฟลเดอร์เลย์เอาต์ภายในไฟล์ resources/viewsโฟลเดอร์ เราจะใช้โฟลเดอร์นี้เพื่อจัดเก็บเค้าโครงทั้งหมดไว้ด้วยกัน
สร้างชื่อไฟล์ master.blade.php ซึ่งจะมีรหัสต่อไปนี้ที่เกี่ยวข้อง -

<html>
   <head>
      <title>DemoLaravel - @yield('title')</title>
   </head>
   <body>
      @yield('content')
   </body>
</html>

ขั้นตอนที่ 2

ในขั้นตอนนี้คุณควรขยายเค้าโครง การขยายเค้าโครงเกี่ยวข้องกับการกำหนดองค์ประกอบย่อย Laravel ใช้ไฟล์Blade @extends คำสั่งสำหรับการกำหนดองค์ประกอบย่อย

เมื่อคุณกำลังขยายเค้าโครงโปรดสังเกตประเด็นต่อไปนี้ -

มุมมองที่กำหนดไว้ใน Blade Layout จะฉีดคอนเทนเนอร์ด้วยวิธีที่ไม่เหมือนใคร
ส่วนต่างๆของมุมมองถูกสร้างขึ้นเป็นองค์ประกอบย่อย
องค์ประกอบลูกจะถูกเก็บไว้ในโฟลเดอร์เค้าโครงเป็น child.blade.php

ตัวอย่างที่แสดงการขยายโครงร่างที่สร้างขึ้นด้านบนแสดงไว้ที่นี่ -

@extends('layouts.app')
@section('title', 'Page Title')
@section('sidebar')
   @parent
<p>This refers to the master sidebar.</p>
@endsection
@section('content')
<p>This is my body content.</p>
@endsection

ขั้นตอนที่ 3

ในการนำองค์ประกอบลูกไปใช้ในมุมมองคุณควรกำหนดเค้าโครงตามที่ต้องการ

สังเกตภาพหน้าจอที่แสดงที่นี่ คุณจะพบว่าแต่ละลิงก์ที่กล่าวถึงในหน้า Landing Page เป็นไฮเปอร์ลิงก์ โปรดทราบว่าคุณยังสามารถสร้างเป็นองค์ประกอบลูกด้วยความช่วยเหลือของแม่แบบใบมีดโดยใช้ขั้นตอนที่ระบุข้างต้น

เส้นทางที่ตั้งชื่อใช้เพื่อตั้งชื่อเฉพาะให้กับเส้นทาง สามารถกำหนดชื่อโดยใช้“as” คีย์อาร์เรย์

Route::get('user/profile', ['as' => 'profile', function () {
   //
}]);

Note - ที่นี่เราให้ชื่อ profile ไปยังเส้นทาง user/profile.

กำลังเปลี่ยนเส้นทางไปยัง Named Routes

ตัวอย่าง

ดูตัวอย่างต่อไปนี้เพื่อทำความเข้าใจเพิ่มเติมเกี่ยวกับการเปลี่ยนเส้นทางไปยังเส้นทางที่ตั้งชื่อ -

Step 1 - สร้างมุมมองที่เรียกว่า test.php และบันทึกไว้ที่

resources/views/test.php.

<html>
   <body>
      <h1>Example of Redirecting to Named Routes</h1>
   </body>
</html>

Step 2 - ใน routes.phpเราได้ตั้งค่าเส้นทางสำหรับ test.phpไฟล์. เราได้เปลี่ยนชื่อเป็นtesting. เรายังได้กำหนดเส้นทางอื่นredirect ซึ่งจะเปลี่ยนเส้นทางคำขอไปยังเส้นทางที่ระบุ testing.

app/Http/routes.php

Route::get('/test', ['as'=>'testing',function() {
   return view('test2');
}]);

Route::get('redirect',function() {
   return redirect()->route('testing');
});

Step 3 - ไปที่ URL ต่อไปนี้เพื่อทดสอบตัวอย่างเส้นทางที่ตั้งชื่อ

http://localhost:8000/redirect

Step 4 - หลังจากดำเนินการตาม URL ข้างต้นคุณจะถูกเปลี่ยนเส้นทางไปยัง http: // localhost: 8000 / test ในขณะที่เรากำลังเปลี่ยนเส้นทางไปยังเส้นทางที่ตั้งชื่อ testing.

Step 5 - หลังจากดำเนินการ URL สำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

กำลังเปลี่ยนเส้นทางไปยัง Controller Actions

ไม่เพียง แต่ตั้งชื่อเส้นทาง แต่เรายังสามารถเปลี่ยนเส้นทางไปยังการทำงานของคอนโทรลเลอร์ได้ เราจำเป็นต้องส่งตัวควบคุมและชื่อของไฟล์actionไปยังวิธีการดำเนินการดังที่แสดงในตัวอย่างต่อไปนี้ หากคุณต้องการส่งผ่านพารามิเตอร์คุณสามารถส่งผ่านเป็นอาร์กิวเมนต์ที่สองของวิธีการดำเนินการ

return redirect()->action(‘NameOfController@methodName’,[parameters]);

ตัวอย่าง

Step 1 - ดำเนินการคำสั่งต่อไปนี้เพื่อสร้างตัวควบคุมที่เรียกว่า RedirectController.

php artisan make:controller RedirectController --plain

Step 2 - หลังจากดำเนินการสำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 3 - คัดลอกรหัสต่อไปนี้ไปยังไฟล์

app/Http/Controllers/RedirectController.php.

app/Http/Controllers/RedirectController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class RedirectController extends Controller {
   public function index() {
      echo "Redirecting to controller's action.";
   }
}

Step 4 - เพิ่มบรรทัดต่อไปนี้ใน app/Http/routes.php.

app/Http/routes.php

Route::get('rr','RedirectController@index');
Route::get('/redirectcontroller',function() {
   return redirect()->action('RedirectController@index');
});

Step 5 - ไปที่ URL ต่อไปนี้เพื่อทดสอบตัวอย่าง

http://localhost:8000/redirectcontroller

Step 6 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

Laravel ทำให้การประมวลผลด้วยฐานข้อมูลเป็นเรื่องง่ายมาก ปัจจุบัน Laravel รองรับ 4 ฐานข้อมูลดังต่อไปนี้ -

MySQL
Postgres
SQLite
เซิร์ฟเวอร์ SQL

คิวรีไปยังฐานข้อมูลสามารถเริ่มทำงานได้โดยใช้ SQL ดิบตัวสร้างคิวรีที่คล่องแคล่วและออร์ม Eloquent เพื่อทำความเข้าใจการดำเนินการ CRUD ทั้งหมด (สร้างอ่านอัปเดตลบ) ด้วย Laravel เราจะใช้ระบบการจัดการนักเรียนที่เรียบง่าย

กำลังเชื่อมต่อกับฐานข้อมูล

กำหนดค่าฐานข้อมูลใน config/database.php ไฟล์และสร้างฐานข้อมูลของวิทยาลัยด้วยโครงสร้างใน MySQL ดังแสดงในตารางต่อไปนี้

Database: College

Table: student

ชื่อคอลัมน์	ประเภทข้อมูลคอลัมน์	พิเศษ
Id	int (11)	คีย์หลัก \| เพิ่มอัตโนมัติ
ชื่อ	วาร์ชาร์ (25)

เราจะดูวิธีการเพิ่มลบอัปเดตและดึงข้อมูลจากฐานข้อมูลโดยใช้ Laravel ในตารางนักเรียน

ซีเนียร์	บันทึกและคำอธิบาย
1	แทรกบันทึก เราสามารถแทรกบันทึกโดยใช้ DB facade ด้วยวิธีแทรก
2	ดึงข้อมูล หลังจากกำหนดค่าฐานข้อมูลเราสามารถดึงข้อมูลโดยใช้ DB facade ด้วยวิธีการเลือก
3	อัปเดตบันทึก เราสามารถอัปเดตเรกคอร์ดโดยใช้ DB facade ด้วยวิธีการอัพเดต
4	ลบบันทึก เราสามารถลบบันทึกโดยใช้ DB facade ด้วยวิธีลบ

บทนี้จะเกี่ยวกับข้อผิดพลาดและการบันทึกในโปรเจ็กต์ Laravel และวิธีดำเนินการกับข้อผิดพลาด

ข้อผิดพลาด

โครงการในระหว่างดำเนินการมีข้อผิดพลาดเล็กน้อย ข้อผิดพลาดและการจัดการข้อยกเว้นได้รับการกำหนดค่าสำหรับคุณแล้วเมื่อคุณเริ่มโครงการ Laravel ใหม่ โดยปกติในสภาพแวดล้อมเฉพาะที่เราจำเป็นต้องเห็นข้อผิดพลาดเพื่อวัตถุประสงค์ในการดีบัก เราจำเป็นต้องซ่อนข้อผิดพลาดเหล่านี้จากผู้ใช้ในสภาพแวดล้อมการใช้งานจริง สิ่งนี้สามารถทำได้ด้วยตัวแปรAPP_DEBUG ตั้งค่าในไฟล์สภาพแวดล้อม .env เก็บไว้ที่รากของแอปพลิเคชัน

สำหรับสภาพแวดล้อมในท้องถิ่นมูลค่าของ APP_DEBUG ควรจะเป็น true แต่สำหรับการผลิตจำเป็นต้องตั้งค่าเป็น false เพื่อซ่อนข้อผิดพลาด

Note - หลังจากเปลี่ยนไฟล์ APP_DEBUG คุณควรรีสตาร์ทเซิร์ฟเวอร์ Laravel

การบันทึก

การบันทึกเป็นกลไกสำคัญที่ระบบสามารถบันทึกข้อผิดพลาดที่สร้างขึ้น เป็นประโยชน์ในการปรับปรุงความน่าเชื่อถือของระบบ Laravel รองรับโหมดการบันทึกที่แตกต่างกันเช่นโหมดเดี่ยวรายวัน syslog และ errorlog คุณสามารถตั้งค่าโหมดเหล่านี้ได้config/app.php ไฟล์.

'log' => 'daily'

คุณสามารถดูรายการบันทึกที่สร้างขึ้นใน storage/logs/laravel.log ไฟล์.

Laravel มีแท็กต่างๆในตัวเพื่อจัดการกับรูปแบบ HTML ได้อย่างง่ายดายและปลอดภัย องค์ประกอบหลักทั้งหมดของ HTML สร้างขึ้นโดยใช้ Laravel เพื่อรองรับสิ่งนี้เราจำเป็นต้องเพิ่มแพ็คเกจ HTML ใน Laravel โดยใช้ตัวแต่ง

ตัวอย่าง 1

Step 1 - ดำเนินการคำสั่งต่อไปนี้เพื่อดำเนินการเดียวกัน

composer require illuminate/html

Step 2 - สิ่งนี้จะเพิ่มแพ็คเกจ HTML ให้กับ Laravel ดังที่แสดงในภาพต่อไปนี้

Step 3 - ตอนนี้เราต้องเพิ่มแพ็คเกจที่แสดงด้านบนไปยังไฟล์กำหนดค่า Laravel ซึ่งเก็บไว้ที่ config/app.php.เปิดไฟล์นี้และคุณจะเห็นรายชื่อผู้ให้บริการ Laravel ดังที่แสดงในภาพต่อไปนี้ เพิ่มผู้ให้บริการ HTML ตามที่ระบุไว้ในกล่องที่ระบุไว้ในภาพต่อไปนี้

Step 4- เพิ่มนามแฝงในไฟล์เดียวกันสำหรับ HTML และ Form สังเกตสองบรรทัดที่ระบุในกล่องที่ระบุไว้ในภาพต่อไปนี้และเพิ่มสองบรรทัดนั้น

Step 5- ตอนนี้ทุกอย่างถูกตั้งค่าแล้ว มาดูกันว่าเราสามารถใช้องค์ประกอบ HTML ต่างๆโดยใช้แท็ก Laravel ได้อย่างไร

การเปิดแบบฟอร์ม

{{ Form::open(array('url' => 'foo/bar')) }}
   //
{{ Form::close() }}

การสร้างองค์ประกอบฉลาก

echo Form::label('email', 'E-Mail Address');

การสร้างการป้อนข้อความ

echo Form::text('username');

การระบุค่าเริ่มต้น

echo Form::text('email', '[email protected]');

การสร้างการป้อนรหัสผ่าน

echo Form::password('password');

การสร้างไฟล์อินพุต

echo Form::file('image');

การสร้างช่องทำเครื่องหมายหรืออินพุตวิทยุ

echo Form::checkbox('name', 'value');
echo Form::radio('name', 'value');

การสร้างช่องทำเครื่องหมายหรืออินพุตวิทยุที่เลือกไว้

echo Form::checkbox('name', 'value', true);
echo Form::radio('name', 'value', true);

การสร้างรายการแบบหล่นลง

echo Form::select('size', array('L' => 'Large', 'S' => 'Small'));

การสร้างปุ่มส่ง

echo Form::submit('Click Me!');

ตัวอย่าง 2

Step 1 - คัดลอกโค้ดต่อไปนี้เพื่อสร้างมุมมองที่เรียกว่า

resources/views/form.php.

resources/views/form.php

<html>
   <body>
      
      <?php
         echo Form::open(array('url' => 'foo/bar'));
            echo Form::text('username','Username');
            echo '<br/>';
            
            echo Form::text('email', '[email protected]');
            echo '<br/>';
     
            echo Form::password('password');
            echo '<br/>';
            
            echo Form::checkbox('name', 'value');
            echo '<br/>';
            
            echo Form::radio('name', 'value');
            echo '<br/>';
            
            echo Form::file('image');
            echo '<br/>';
            
            echo Form::select('size', array('L' => 'Large', 'S' => 'Small'));
            echo '<br/>';
            
            echo Form::submit('Click Me!');
         echo Form::close();
      ?>
   
   </body>
</html>

Step 2 - เพิ่มบรรทัดต่อไปนี้ใน app/Http/routes.php เพื่อเพิ่มเส้นทางสำหรับดู form.php

app/Http/routes.php

Route::get('/form',function() {
   return view('form');
});

Step 3 - ไปที่ URL ต่อไปนี้เพื่อดูแบบฟอร์ม

http://localhost:8000/form

Step 4 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

คุณสมบัติการแปลเป็นภาษาท้องถิ่นของ Laravel รองรับภาษาต่างๆที่จะใช้ในแอปพลิเคชัน คุณต้องจัดเก็บสตริงทั้งหมดของภาษาที่แตกต่างกันในไฟล์และไฟล์เหล่านี้จะถูกเก็บไว้ที่resources/viewsไดเรกทอรี คุณควรสร้างไดเร็กทอรีแยกต่างหากสำหรับแต่ละภาษาที่รองรับ ไฟล์ภาษาทั้งหมดควรส่งคืนอาร์เรย์ของสตริงที่คีย์ดังที่แสดงด้านล่าง

<?php
return [
   'welcome' => 'Welcome to the application'
];

ตัวอย่าง

Step 1 - สร้าง 3 ไฟล์สำหรับภาษา - English, Frenchและ German. บันทึกไฟล์ภาษาอังกฤษที่resources/lang/en/lang.php

<?php
   return [
      'msg' => 'Laravel Internationalization example.'
   ];
?>

Step 2 - บันทึกไฟล์ภาษาฝรั่งเศสที่ resources/lang/fr/lang.php.

<?php
   return [
      'msg' => 'Exemple Laravel internationalisation.'
   ];
?>

Step 3 - บันทึกไฟล์ภาษาเยอรมันที่ resources/lang/de/lang.php.

<?php
   return [
      'msg' => 'Laravel Internationalisierung Beispiel.' 
   ];
?>

Step 4 - สร้างตัวควบคุมที่เรียกว่า LocalizationController โดยดำเนินการคำสั่งต่อไปนี้

php artisan make:controller LocalizationController --plain

Step 5 - หลังจากดำเนินการสำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 6 - คัดลอกรหัสต่อไปนี้ไปยังไฟล์

app/Http/Controllers/LocalizationController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class LocalizationController extends Controller {
   public function index(Request $request,$locale) {
      //set’s application’s locale
      app()->setLocale($locale);
      
      //Gets the translated message and displays it
      echo trans('lang.msg');
   }
}

Step 7 - เพิ่มเส้นทางสำหรับ LocalizationController ใน app/Http/routes.phpไฟล์. สังเกตว่าเรากำลังส่งอาร์กิวเมนต์ {locale} หลังการแปล / ซึ่งเราจะใช้เพื่อดูผลลัพธ์ในภาษาอื่น

app/Http/routes.php

Route::get('localization/{locale}','LocalizationController@index');

Step 8- ตอนนี้ให้เราไปที่ URL ต่างๆเพื่อดูภาษาต่างๆทั้งหมด ดำเนินการตาม URL ด้านล่างเพื่อดูผลลัพธ์เป็นภาษาอังกฤษ

http://localhost:8000/localization/en

Step 9 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

Step 10 - ดำเนินการตาม URL ด้านล่างเพื่อดูผลลัพธ์ในภาษาฝรั่งเศส

http://localhost:8000/localization/fr

Step 11 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

Step 12 - ดำเนินการตาม URL ด้านล่างเพื่อดูผลลัพธ์ในภาษาเยอรมัน

http://localhost:8000/localization/de

Step 13 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

เซสชันใช้เพื่อจัดเก็บข้อมูลเกี่ยวกับผู้ใช้ในคำขอต่างๆ Laravel มีไดรเวอร์ต่างๆเช่นfile, cookie, apc, array, Memcached, Redis, และ databaseเพื่อจัดการข้อมูลเซสชัน โดยค่าเริ่มต้นโปรแกรมควบคุมไฟล์จะถูกใช้เนื่องจากมีน้ำหนักเบา สามารถกำหนดค่าเซสชันในไฟล์ที่เก็บไว้ที่config/session.php.

การเข้าถึงข้อมูลเซสชัน

ในการเข้าถึงข้อมูลเซสชันเราจำเป็นต้องมีอินสแตนซ์ของเซสชันซึ่งสามารถเข้าถึงได้ผ่านการร้องขอ HTTP หลังจากได้รับอินสแตนซ์แล้วเราสามารถใช้ไฟล์get() วิธีการซึ่งจะใช้อาร์กิวเมนต์เดียว “key”เพื่อรับข้อมูลเซสชัน

$value = $request->session()->get('key');

คุณสามารถใช้ได้ all() วิธีการรับข้อมูลเซสชันทั้งหมดแทนที่จะเป็น get() วิธี.

การจัดเก็บข้อมูลเซสชัน

ข้อมูลสามารถจัดเก็บในเซสชันโดยใช้ไฟล์ put()วิธี. put() method จะใช้อาร์กิวเมนต์สองตัวคือ “key” และ “value”.

$request->session()->put('key', 'value');

การลบข้อมูลเซสชัน

forget()วิธีการใช้เพื่อลบรายการออกจากเซสชัน วิธีนี้จะใช้“key” เป็นข้อโต้แย้ง

$request->session()->forget('key');

ใช้ flush() วิธีการแทน forget()วิธีการลบข้อมูลเซสชันทั้งหมด ใช้pull()วิธีการดึงข้อมูลจากเซสชันและลบทิ้งในภายหลัง จะใช้วิธีดึง () ด้วยkeyเป็นข้อโต้แย้ง ความแตกต่างระหว่างforget() และ pull() วิธีการก็คือ forget() วิธีการจะไม่คืนค่าของเซสชันและ pull() วิธีการจะส่งคืนและลบค่านั้นออกจากเซสชัน

ตัวอย่าง

Step 1 - สร้างตัวควบคุมที่เรียกว่า SessionController โดยดำเนินการคำสั่งต่อไปนี้

php artisan make:controller SessionController --plain

Step 2 - หลังจากดำเนินการสำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 3 - คัดลอกรหัสต่อไปนี้ในไฟล์ที่

app/Http/Controllers/SessionController.php.

app/Http/Controllers/SessionController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class SessionController extends Controller {
   public function accessSessionData(Request $request) {
      if($request->session()->has('my_name')) echo $request->session()->get('my_name');
      else
         echo 'No data in the session';
   }
   public function storeSessionData(Request $request) { $request->session()->put('my_name','Virat Gandhi');
      echo "Data has been added to session";
   }
   public function deleteSessionData(Request $request) { $request->session()->forget('my_name');
      echo "Data has been removed from session.";
   }
}

Step 4 - เพิ่มบรรทัดต่อไปนี้ที่ app/Http/routes.php ไฟล์.

app/Http/routes.php

Route::get('session/get','SessionController@accessSessionData');
Route::get('session/set','SessionController@storeSessionData');
Route::get('session/remove','SessionController@deleteSessionData');

Step 5 - ไปที่ URL ต่อไปนี้เพื่อ set data in session.

http://localhost:8000/session/set

Step 6 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

Step 7 - ไปที่ URL ต่อไปนี้เพื่อ get data from session.

http://localhost:8000/session/get

Step 8 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้

Step 9 - ไปที่ URL ต่อไปนี้เพื่อ remove session data.

http://localhost:8000/session/remove

Step 10 - คุณจะเห็นข้อความดังที่แสดงในภาพต่อไปนี้

การตรวจสอบความถูกต้องเป็นสิ่งที่สำคัญที่สุดในการออกแบบแอปพลิเคชัน ตรวจสอบความถูกต้องของข้อมูลที่เข้ามา ตามค่าเริ่มต้นคลาสคอนโทรลเลอร์พื้นฐานจะใช้ไฟล์ValidatesRequests ลักษณะที่มีวิธีการที่สะดวกในการตรวจสอบคำขอ HTTP ขาเข้าด้วยกฎการตรวจสอบที่มีประสิทธิภาพหลายแบบ

กฎการตรวจสอบที่มีอยู่ใน Laravel

Laravel จะตรวจสอบข้อผิดพลาดในข้อมูลเซสชันเสมอและเชื่อมโยงกับมุมมองโดยอัตโนมัติหากมี ดังนั้นจึงเป็นสิ่งสำคัญที่จะต้องทราบว่า$errors ตัวแปรจะพร้อมใช้งานในทุกมุมมองของคุณในทุกคำขอทำให้คุณสามารถสันนิษฐานได้อย่างสะดวก $errorsตัวแปรถูกกำหนดไว้เสมอและสามารถใช้ได้อย่างปลอดภัย ตารางต่อไปนี้แสดงกฎการตรวจสอบความถูกต้องที่มีอยู่ทั้งหมดใน Laravel

กฎการตรวจสอบที่มีอยู่ใน Laravel
ได้รับการยอมรับ	URL ที่ใช้งานอยู่	หลังจาก (วันที่)
อัลฟ่า	Alpha Dash	ตัวเลขอัลฟา
อาร์เรย์	ก่อน (วันที่)	ระหว่าง
บูลีน	ได้รับการยืนยัน	วันที่
รูปแบบวันที่	แตกต่างกัน	ตัวเลข
ตัวเลขระหว่าง	อีเมล	มีอยู่ (ฐานข้อมูล)
รูปภาพ (ไฟล์)	ใน	จำนวนเต็ม
ที่อยู่ IP	JSON	สูงสุด
ประเภท MIME (ไฟล์)	นาที	ไม่เข้า
ตัวเลข	นิพจน์ทั่วไป	จำเป็น
จำเป็นถ้า	จำเป็นเว้นแต่	จำเป็นด้วย
จำเป็นกับทั้งหมด	จำเป็นโดยไม่ต้อง	จำเป็นโดยไม่ต้องทั้งหมด
เหมือนกัน	ขนาด	สตริง
เขตเวลา	ไม่ซ้ำกัน (ฐานข้อมูล)	URL

$errors ตัวแปรจะเป็นตัวอย่างของ Illuminate\Support\MessageBag. ข้อความแสดงข้อผิดพลาดสามารถแสดงในไฟล์ดูได้โดยเพิ่มรหัสดังที่แสดงด้านล่าง

@if (count($errors) > 0)
   <div class = "alert alert-danger">
      <ul>
         @foreach ($errors->all() as $error)
            <li>{{ $error }}</li>
         @endforeach
      </ul>
   </div>
@endif

ตัวอย่าง

Step 1 - สร้างตัวควบคุมที่เรียกว่า ValidationController โดยดำเนินการคำสั่งต่อไปนี้

php artisan make:controller ValidationController --plain

Step 2 - หลังจากดำเนินการสำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 3 - คัดลอกรหัสต่อไปนี้ในรูปแบบ

app/Http/Controllers/ValidationController.php ไฟล์.

app/Http/Controllers/ValidationController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class ValidationController extends Controller {
   public function showform() {
      return view('login');
   }
   public function validateform(Request $request) {
      print_r($request->all()); $this->validate($request,[
         'username'=>'required|max:8',
         'password'=>'required'
      ]);
   }
}

Step 4 - สร้างไฟล์ดูชื่อ resources/views/login.blade.php และคัดลอกรหัสต่อไปนี้ในไฟล์นั้น

resources/views/login.blade.php

<html>
   
   <head>
      <title>Login Form</title>
   </head>

   <body>
      
      @if (count($errors) > 0)
         <div class = "alert alert-danger">
            <ul>
               @foreach ($errors->all() as $error)
                  <li>{{ $error }}</li>
               @endforeach
            </ul>
         </div>
      @endif
      
      <?php
         echo Form::open(array('url'=>'/validation'));
      ?>
      
      <table border = '1'>
         <tr>
            <td align = 'center' colspan = '2'>Login</td>
         </tr>
         <tr>
            <td>Username</td>
            <td><?php echo Form::text('username'); ?></td>
         </tr>
         <tr>
            <td>Password</td>
            <td><?php echo Form::password('password'); ?></td>
         </tr>
         <tr>
            <td align = 'center' colspan = '2'
               ><?php echo Form::submit('Login'); ?  ></td>
         </tr>
      </table>
      
      <?php
         echo Form::close();
      ?>
   
   </body>
</html>

Step 5 - เพิ่มบรรทัดต่อไปนี้ใน app/Http/routes.php.

app/Http/routes.php

Route::get('/validation','ValidationController@showform');
Route::post('/validation','ValidationController@validateform');

Step 6 - ไปที่ URL ต่อไปนี้เพื่อทดสอบการตรวจสอบความถูกต้อง

http://localhost:8000/validation

Step 7 - คลิกไฟล์ “Login”โดยไม่ต้องป้อนอะไรในช่องข้อความ ผลลัพธ์จะเป็นดังที่แสดงในภาพต่อไปนี้

การอัปโหลดไฟล์ใน Laravel นั้นง่ายมาก สิ่งที่เราต้องทำคือสร้างไฟล์มุมมองที่ผู้ใช้สามารถเลือกไฟล์ที่จะอัปโหลดและตัวควบคุมที่จะประมวลผลไฟล์ที่อัปโหลด

ในไฟล์ดูเราจำเป็นต้องสร้างอินพุตไฟล์โดยเพิ่มโค้ดบรรทัดต่อไปนี้

Form::file('file_name');

ใน Form :: open () เราจำเป็นต้องเพิ่ม ‘files’=>’true’ดังแสดงด้านล่าง สิ่งนี้ช่วยอำนวยความสะดวกในการอัปโหลดแบบฟอร์มในหลายส่วน

Form::open(array('url' => '/uploadfile','files'=>'true'));

ตัวอย่าง

Step 1 - สร้างไฟล์ดูชื่อ resources/views/uploadfile.php และคัดลอกรหัสต่อไปนี้ในไฟล์นั้น

resources/views/uploadfile.php

<html>
   <body>
      <?php
         echo Form::open(array('url' => '/uploadfile','files'=>'true'));
         echo 'Select the file to upload.';
         echo Form::file('image');
         echo Form::submit('Upload File');
         echo Form::close();
      ?>
   </body>
</html>

Step 2 - สร้างตัวควบคุมที่เรียกว่า UploadFileController โดยดำเนินการคำสั่งต่อไปนี้

php artisan make:controller UploadFileController --plain

Step 3 - หลังจากดำเนินการสำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 4 - คัดลอกรหัสต่อไปนี้ในรูปแบบ

app/Http/Controllers/UploadFileController.php ไฟล์.

app/Http/Controllers/UploadFileController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class UploadFileController extends Controller {
   public function index() {
      return view('uploadfile');
   }
   public function showUploadFile(Request $request) {
      $file = $request->file('image');
   
      //Display File Name
      echo 'File Name: '.$file->getClientOriginalName(); echo '<br>'; //Display File Extension echo 'File Extension: '.$file->getClientOriginalExtension();
      echo '<br>';
   
      //Display File Real Path
      echo 'File Real Path: '.$file->getRealPath(); echo '<br>'; //Display File Size echo 'File Size: '.$file->getSize();
      echo '<br>';
   
      //Display File Mime Type
      echo 'File Mime Type: '.$file->getMimeType(); //Move Uploaded File $destinationPath = 'uploads';
      $file->move($destinationPath,$file->getClientOriginalName());
   }
}

Step 5 - เพิ่มบรรทัดต่อไปนี้ใน app/Http/routes.php.

app/Http/routes.php

Route::get('/uploadfile','UploadFileController@index');
Route::post('/uploadfile','UploadFileController@showUploadFile');

Step 6 - ไปที่ URL ต่อไปนี้เพื่อทดสอบการทำงานของไฟล์อัปโหลด

http://localhost:8000/uploadfile

Step 7 - คุณจะได้รับข้อความแจ้งดังที่แสดงในภาพต่อไปนี้

Laravel ใช้ห้องสมุดที่มีคุณสมบัติมากมายฟรี SwiftMailerเพื่อส่งอีเมล ด้วยฟังก์ชันไลบรารีเราสามารถส่งอีเมลได้อย่างง่ายดายโดยไม่ต้องยุ่งยากมากเกินไป เทมเพลตอีเมลถูกโหลดในลักษณะเดียวกับมุมมองซึ่งหมายความว่าคุณสามารถใช้ไวยากรณ์ Blade และฉีดข้อมูลลงในเทมเพลตของคุณได้

ตารางต่อไปนี้แสดงไวยากรณ์และแอตทริบิวต์ของ send ฟังก์ชัน -

ไวยากรณ์	โมฆะส่ง (string \| array $ view, array $data, Closure\|string $โทรกลับ)
พารามิเตอร์	$ view (string \| array) - ชื่อของมุมมองที่มีข้อความอีเมล $ data (array) - อาร์เรย์ของข้อมูลที่จะส่งไปดู $ callback - การโทรกลับแบบปิดซึ่งรับอินสแตนซ์ข้อความช่วยให้คุณสามารถกำหนดผู้รับหัวเรื่องและลักษณะอื่น ๆ ของข้อความเมลได้
ผลตอบแทน	ไม่มีอะไร
คำอธิบาย	ส่งอีเมล

ในอาร์กิวเมนต์ที่สามอินสแตนซ์ข้อความที่ได้รับการปิด $ callback และด้วยอินสแตนซ์นั้นเรายังสามารถเรียกใช้ฟังก์ชันต่อไปนี้และแก้ไขข้อความดังที่แสดงด้านล่าง

$ message → subject ('ยินดีต้อนรับสู่ Tutorials Point');
$ message →จาก ('[email protected] ',' นายตัวอย่าง ');
$ message →ถึง ('[email protected] ',' นายตัวอย่าง ');

บางส่วนของวิธีการทั่วไป ได้แก่ -

$ message →ผู้ส่ง ('[email protected] ',' นายตัวอย่าง ');
$ message → returnPath ('[email protected] ');
$ message → cc ('[email protected] ',' นายตัวอย่าง ');
$ message → bcc ('[email protected] ',' นายตัวอย่าง ');
$ message → replyTo ('[email protected] ',' นายตัวอย่าง ');
ข้อความ $ →ลำดับความสำคัญ (2);

ในการแนบหรือฝังไฟล์คุณสามารถใช้วิธีการต่อไปนี้ -

$ ข้อความ→แนบ ('path / to / attachment.txt');
$ ข้อความ→ฝัง ('path / to / attachment.jpg');

สามารถส่งจดหมายเป็น HTML หรือข้อความ คุณสามารถระบุประเภทของเมลที่คุณต้องการส่งในอาร์กิวเมนต์แรกโดยส่งอาร์เรย์ตามที่แสดงด้านล่าง ประเภทเริ่มต้นคือ HTML หากคุณต้องการส่งเมลข้อความธรรมดาให้ใช้ไวยากรณ์ต่อไปนี้

ไวยากรณ์

Mail::send([‘text’=>’text.view’], $data, $callback);

ในไวยากรณ์นี้อาร์กิวเมนต์แรกรับอาร์เรย์ ใช้text เป็นชื่อคีย์ของมุมมองเป็นค่าของคีย์

ตัวอย่าง

Step 1 - ตอนนี้เราจะส่งอีเมลจากบัญชี Gmail และคุณต้องกำหนดค่าบัญชี Gmail ของคุณในไฟล์สภาพแวดล้อม Laravel - .envไฟล์. เปิดใช้งานการยืนยันแบบ 2 ขั้นตอนในบัญชี Gmail ของคุณและสร้างรหัสผ่านเฉพาะแอปพลิเคชันตามด้วยการเปลี่ยนพารามิเตอร์. env ดังที่แสดงด้านล่าง

.env

MAIL_DRIVER = smtp
MAIL_HOST = smtp.gmail.com
MAIL_PORT = 587
MAIL_USERNAME = your-gmail-username
MAIL_PASSWORD = your-application-specific-password
MAIL_ENCRYPTION = tls

Step 2 - หลังจากเปลี่ยนไฟล์ .env ไฟล์ดำเนินการสองคำสั่งด้านล่างเพื่อล้างแคชและรีสตาร์ทเซิร์ฟเวอร์ Laravel

php artisan config:cache

Step 3 - สร้างตัวควบคุมที่เรียกว่า MailController โดยดำเนินการคำสั่งต่อไปนี้

php artisan make:controller MailController --plain

Step 4 - หลังจากดำเนินการสำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 5 - คัดลอกรหัสต่อไปนี้ในรูปแบบ

app/Http/Controllers/MailController.php ไฟล์.

app/Http/Controllers/MailController.php

<?php

namespace App\Http\Controllers;
use Illuminate\Http\Request;
use Mail;

use App\Http\Requests;
use App\Http\Controllers\Controller;

class MailController extends Controller {
   public function basic_email() {
      $data = array('name'=>"Virat Gandhi");
   
      Mail::send(['text'=>'mail'], $data, function($message) {
         $message->to('[email protected]', 'Tutorials Point')->subject ('Laravel Basic Testing Mail'); $message->from('[email protected]','Virat Gandhi');
      });
      echo "Basic Email Sent. Check your inbox.";
   }
   public function html_email() {
      $data = array('name'=>"Virat Gandhi"); Mail::send('mail', $data, function($message) { $message->to('[email protected]', 'Tutorials Point')->subject
            ('Laravel HTML Testing Mail');
         $message->from('[email protected]','Virat Gandhi'); }); echo "HTML Email Sent. Check your inbox."; } public function attachment_email() { $data = array('name'=>"Virat Gandhi");
      Mail::send('mail', $data, function($message) {
         $message->to('[email protected]', 'Tutorials Point')->subject ('Laravel Testing Mail with Attachment'); $message->attach('C:\laravel-master\laravel\public\uploads\image.png');
         $message->attach('C:\laravel-master\laravel\public\uploads\test.txt'); $message->from('[email protected]','Virat Gandhi');
      });
      echo "Email Sent with attachment. Check your inbox.";
   }
}

Step 6 - คัดลอกรหัสต่อไปนี้ในรูปแบบ resources/views/mail.blade.php ไฟล์.

resources/views/mail.blade.php

<h1>Hi, {{ $name }}</h1>
l<p>Sending Mail from Laravel.</p>

Step 7 - เพิ่มบรรทัดต่อไปนี้ใน app/Http/routes.php.

app/Http/routes.php

Route::get('sendbasicemail','MailController@basic_email');
Route::get('sendhtmlemail','MailController@html_email');
Route::get('sendattachmentemail','MailController@attachment_email');

Step 8 - ไปที่ URL ต่อไปนี้เพื่อทดสอบอีเมลพื้นฐาน

http://localhost:8000/sendbasicemail

Step 9- หน้าจอแสดงผลจะมีลักษณะดังนี้ ตรวจสอบกล่องจดหมายของคุณเพื่อดูผลลัพธ์อีเมลพื้นฐาน

Step 10 - ไปที่ URL ต่อไปนี้เพื่อทดสอบอีเมล HTML

http://localhost:8000/sendhtmlemail

Step 11- หน้าจอแสดงผลจะมีลักษณะดังนี้ ตรวจสอบกล่องจดหมายของคุณเพื่อดูผลลัพธ์อีเมล html

Step 12 - ไปที่ URL ต่อไปนี้เพื่อทดสอบอีเมล HTML พร้อมไฟล์แนบ

http://localhost:8000/sendattachmentemail

Step 13 - คุณสามารถดูผลลัพธ์ต่อไปนี้

Note - ในไฟล์ MailController.phpไฟล์ที่อยู่อีเมลในวิธีการจากควรเป็นที่อยู่อีเมลที่คุณสามารถส่งที่อยู่อีเมลได้ โดยทั่วไปควรเป็นที่อยู่อีเมลที่กำหนดค่าไว้บนเซิร์ฟเวอร์ของคุณ

Ajax (Asynchronous JavaScript and XML)เป็นชุดเทคนิคการพัฒนาเว็บโดยใช้เทคโนโลยีเว็บจำนวนมากที่ใช้ในฝั่งไคลเอ็นต์เพื่อสร้างเว็บแอปพลิเคชันแบบอะซิงโครนัส นำเข้าไลบรารี jquery ในไฟล์มุมมองของคุณเพื่อใช้ฟังก์ชัน ajax ของ jquery ซึ่งจะใช้ในการส่งและรับข้อมูลโดยใช้ ajax จากเซิร์ฟเวอร์ ที่ฝั่งเซิร์ฟเวอร์คุณสามารถใช้ฟังก์ชัน response () เพื่อส่งการตอบกลับไปยังไคลเอนต์และเพื่อส่งการตอบกลับในรูปแบบ JSON คุณสามารถเชื่อมโยงฟังก์ชันการตอบกลับด้วยฟังก์ชัน json ()

json () ไวยากรณ์ของฟังก์ชัน

json(string|array $data = array(), int $status = 200, array $headers = array(), int $options)

ตัวอย่าง

Step 1 - สร้างไฟล์ดูชื่อ resources/views/message.php และคัดลอกรหัสต่อไปนี้ในไฟล์นั้น

<html>
   <head>
      <title>Ajax Example</title>
      
      <script src = "https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js">
      </script>
      
      <script>
         function getMessage() {
            $.ajax({
               type:'POST',
               url:'/getmsg',
               data:'_token = <?php echo csrf_token() ?>',
               success:function(data) {
                  $("#msg").html(data.msg);
               }
            });
         }
      </script>
   </head>
   
   <body>
      <div id = 'msg'>This message will be replaced using Ajax. 
         Click the button to replace the message.</div>
      <?php
         echo Form::button('Replace Message',['onClick'=>'getMessage()']);
      ?>
   </body>

</html>

Step 2 - สร้างตัวควบคุมที่เรียกว่า AjaxController โดยดำเนินการคำสั่งต่อไปนี้

php artisan make:controller AjaxController --plain

Step 3 - หลังจากดำเนินการสำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 4 - คัดลอกรหัสต่อไปนี้ในรูปแบบ

app/Http/Controllers/AjaxController.php ไฟล์.

app/Http/Controllers/AjaxController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class AjaxController extends Controller {
   public function index() {
      $msg = "This is a simple message.";
      return response()->json(array('msg'=> $msg), 200);
   }
}

Step 5 - เพิ่มบรรทัดต่อไปนี้ใน app/Http/routes.php.

app/Http/routes.php

Route::get('ajax',function() {
   return view('message');
});
Route::post('/getmsg','AjaxController@index');

Step 6 - ไปที่ URL ต่อไปนี้เพื่อทดสอบการทำงานของ Ajax

http://localhost:8000/ajax

Step 7 - คุณจะถูกเปลี่ยนเส้นทางไปยังหน้าที่คุณจะเห็นข้อความดังที่แสดงในภาพต่อไปนี้

Step 8 - ผลลัพธ์จะปรากฏดังที่แสดงในภาพต่อไปนี้หลังจากคลิกปุ่ม

เว็บแอปพลิเคชันส่วนใหญ่มีกลไกเฉพาะสำหรับการจัดการข้อผิดพลาด ใช้สิ่งเหล่านี้ติดตามข้อผิดพลาดและข้อยกเว้นและบันทึกเพื่อวิเคราะห์ประสิทธิภาพ ในบทนี้คุณจะได้อ่านเกี่ยวกับการจัดการข้อผิดพลาดในแอปพลิเคชัน Laravel

จุดสำคัญ

ก่อนดำเนินการต่อเพื่อเรียนรู้รายละเอียดเกี่ยวกับการจัดการข้อผิดพลาดใน Laravel โปรดสังเกตประเด็นสำคัญต่อไปนี้ -

สำหรับโปรเจ็กต์ใหม่ Laravel จะบันทึกข้อผิดพลาดและข้อยกเว้นในไฟล์ App\Exceptions\Handlerคลาสโดยค่าเริ่มต้น จากนั้นจะส่งกลับไปยังผู้ใช้เพื่อทำการวิเคราะห์
เมื่อแอปพลิเคชัน Laravel ของคุณถูกตั้งค่าในโหมดดีบักข้อความแสดงข้อผิดพลาดโดยละเอียดพร้อมสแต็กเทรซจะแสดงในทุกข้อผิดพลาดที่เกิดขึ้นภายในเว็บแอปพลิเคชันของคุณ

โดยค่าเริ่มต้นโหมดดีบักจะถูกตั้งค่าเป็น false และคุณสามารถเปลี่ยนเป็น true. สิ่งนี้ช่วยให้ผู้ใช้สามารถติดตามข้อผิดพลาดทั้งหมดด้วยสแต็กเทรซ

การกำหนดค่าโครงการ Laravel ประกอบด้วยไฟล์ debugตัวเลือกที่กำหนดว่าจะแสดงข้อมูลเกี่ยวกับข้อผิดพลาดให้กับผู้ใช้มากเพียงใด โดยค่าเริ่มต้นในเว็บแอ็พพลิเคชันตัวเลือกจะถูกตั้งค่าเป็นค่าที่กำหนดไว้ในตัวแปรสภาพแวดล้อมของ.env ไฟล์.
- ค่านี้ตั้งเป็น true ในสภาพแวดล้อมการพัฒนาท้องถิ่นและตั้งค่าเป็น false ในสภาพแวดล้อมการผลิต
- หากตั้งค่าเป็น true ในสภาพแวดล้อมการผลิตความเสี่ยงในการแบ่งปันข้อมูลที่ละเอียดอ่อนกับผู้ใช้ปลายทางจะสูงกว่า

บันทึกข้อผิดพลาด

การบันทึกข้อผิดพลาดในเว็บแอปพลิเคชันจะช่วยในการติดตามและวางแผนกลยุทธ์ในการลบข้อผิดพลาด ข้อมูลบันทึกสามารถกำหนดค่าได้ในเว็บแอปพลิเคชันในconfig/app.phpไฟล์. โปรดสังเกตประเด็นต่อไปนี้ในขณะที่จัดการกับ Error Log ใน Laravel -

Laravel ใช้ไลบรารีบันทึก PHP คนเดียว
พารามิเตอร์การบันทึกที่ใช้สำหรับการติดตามข้อผิดพลาดคือ single, daily, syslog และ errorlog.
ตัวอย่างเช่นหากคุณต้องการบันทึกข้อความแสดงข้อผิดพลาดในไฟล์บันทึกคุณควรตั้งค่าบันทึกในการกำหนดค่าแอปของคุณเป็น daily ดังแสดงในคำสั่งด้านล่าง -

'log' => env('APP_LOG',’daily’),

ถ้า daily โหมดบันทึกถูกใช้เป็นพารามิเตอร์ Laravel จะบันทึกข้อผิดพลาดเป็นระยะเวลาหนึ่ง 5 days, โดยค่าเริ่มต้น. หากคุณต้องการเปลี่ยนจำนวนไฟล์บันทึกสูงสุดคุณต้องตั้งค่าพารามิเตอร์ของไฟล์log_max_files ในไฟล์คอนฟิกูเรชันเป็นค่าที่ต้องการ

‘log_max_files’ => 25;

ระดับความรุนแรง

เนื่องจาก Laravel ใช้ไลบรารีการบันทึก PHP แบบคนเดียวจึงมีพารามิเตอร์ต่างๆที่ใช้ในการวิเคราะห์ระดับความรุนแรง ระดับความรุนแรงต่างๆที่พร้อมใช้งาน ได้แก่error, critical, alert และ emergency messages. คุณสามารถกำหนดระดับความรุนแรงดังที่แสดงในคำสั่งด้านล่าง -

'log_level' => env('APP_LOG_LEVEL', 'error')

เหตุการณ์ให้การใช้งานผู้สังเกตการณ์อย่างง่ายซึ่งช่วยให้ผู้ใช้สมัครสมาชิกและรับฟังเหตุการณ์ต่างๆที่เรียกใช้ในเว็บแอปพลิเคชัน คลาสกิจกรรมทั้งหมดใน Laravel จะถูกเก็บไว้ในไฟล์app/Events โฟลเดอร์และผู้ฟังจะถูกเก็บไว้ในไฟล์ app/Listeners โฟลเดอร์

คำสั่ง artisan สำหรับสร้างเหตุการณ์และผู้ฟังในเว็บแอปพลิเคชันของคุณแสดงอยู่ด้านล่าง -

php artisan event:generate

คำสั่งนี้สร้างเหตุการณ์และผู้ฟังไปยังโฟลเดอร์ที่เกี่ยวข้องตามที่กล่าวไว้ข้างต้น

กิจกรรมและผู้ฟังเป็นวิธีที่ยอดเยี่ยมในการแยกแอปพลิเคชันบนเว็บเนื่องจากเหตุการณ์หนึ่งสามารถมีผู้ฟังหลายคนซึ่งไม่เกี่ยวข้องกัน โฟลเดอร์เหตุการณ์ที่สร้างโดยคำสั่ง artisan ประกอบด้วยสองไฟล์ต่อไปนี้: event.php และ SomeEvent.php แสดงไว้ที่นี่ -

Event.php

<?php
namespace App\Events;
abstract class Event{
   //
}

ดังที่กล่าวมาแล้วว่า event.php รวมถึงคำจำกัดความพื้นฐานของคลาส Event และเรียกใช้เนมสเปซ App\Events. โปรดทราบว่าเหตุการณ์ที่ผู้ใช้กำหนดหรือกำหนดเองถูกสร้างขึ้นในไฟล์นี้

SomeEvent.php

<?php

namespace App\Events;

use App\Events\Event;
use Illuminate\Queue\SerializesModels;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;

class SomeEvent extends Event{
   use SerializesModels;
   /**
      * Create a new event instance.
      *
      * @return void
   */
   
   public function __construct() {
      //
   }
   
   /**
      * Get the channels the event should be broadcast on.
      *
      * @return array
   */
   
   public function broadcastOn() {
      return [];
   }
}

สังเกตว่าไฟล์นี้ใช้การทำให้เป็นอนุกรมสำหรับการออกอากาศเหตุการณ์ในเว็บแอปพลิเคชันและพารามิเตอร์ที่จำเป็นจะเริ่มต้นในไฟล์นี้ด้วย

ตัวอย่างเช่นหากเราต้องการเริ่มต้นตัวแปรคำสั่งในตัวสร้างเพื่อลงทะเบียนเหตุการณ์เราสามารถทำได้ด้วยวิธีต่อไปนี้ -

public function __construct(Order $order) {
   $this->order = $order;
}

ผู้ฟัง

ผู้ฟังจัดการกิจกรรมทั้งหมดที่กล่าวถึงในงานที่กำลังลงทะเบียน คำสั่งช่างฝีมือevent:generate สร้างไฟล์ listeners ใน app/listenersไดเรกทอรี โฟลเดอร์ Listeners มีไฟล์EventListener.php ซึ่งมีวิธีการทั้งหมดที่จำเป็นสำหรับการจัดการผู้ฟัง

EventListener.php

<?php

namespace App\Listeners;

use App\Events\SomeEvent;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;

class EventListener{
   /**
      * Create the event listener.
      *
      * @return void
   */
   
   public function __construct() {
      //
   }

   /**
      * Handle the event.
      *
      * @param SomeEvent $event * @return void */ public function handle(SomeEvent $event) {
      //
   }
}

ดังที่กล่าวไว้ในรหัสดังกล่าวประกอบด้วย handleฟังก์ชันสำหรับจัดการเหตุการณ์ต่างๆ เราสามารถสร้างผู้ฟังอิสระต่างๆที่กำหนดเป้าหมายเหตุการณ์เดียว

ซุ้มให้ staticอินเทอร์เฟซกับคลาสที่มีอยู่ในคอนเทนเนอร์บริการของแอปพลิเคชัน ลาราเวลfacades ทำหน้าที่เป็น static proxies ไปยังคลาสพื้นฐานในที่เก็บบริการโดยให้ประโยชน์ของไวยากรณ์ที่สั้นและแสดงออกในขณะที่ยังคงความสามารถในการทดสอบและความยืดหยุ่นได้มากกว่าวิธีการคงที่แบบเดิม

วิธีสร้าง Facade

ต่อไปนี้เป็นขั้นตอนในการสร้าง Facade ใน Laravel -

Step 1 - สร้างไฟล์คลาส PHP
Step 2 - ผูกคลาสนั้นกับผู้ให้บริการ
Step 3 - ลงทะเบียน ServiceProvider นั้นไปที่

กำหนดค่า \ app.php เป็นผู้ให้บริการ
Step 4 - สร้างคลาสซึ่งคลาสนี้ขยายไปถึง

ส่องสว่าง \ Support \ Facades \ Facade
Step 5 - ลงทะเบียนจุดที่ 4 เพื่อ Config \ app.php เป็นนามแฝง

การอ้างอิงชั้น Facade

Laravel มาพร้อมกับ Facades มากมาย ตารางต่อไปนี้แสดงการอ้างอิงคลาส Facade ในตัว -

ซุ้ม	คลาส	บริการเข้าเล่มคอนเทนเนอร์
แอป	Illuminate \ Foundation \ Application	แอป
ช่าง	Illuminate \ Contracts \ Console \ Kernel	ช่าง
Auth	Illuminate \ Auth \ AuthManager	รับรองความถูกต้อง
Auth (อินสแตนซ์)	ส่องสว่าง \ Auth \ Guard
ใบมีด	Illuminate \ View \ Compilers \ BladeCompiler	blade.compiler
รถบัส	Illuminate \ Contracts \ Bus \ Dispatcher
แคช	Illuminate \ Cache \ Repository	แคช
Config	ส่องสว่าง \ Config \ Repository	config
คุกกี้	Illuminate \ Cookie \ CookieJar	คุกกี้
Crypt	ส่องสว่าง \ Encryption \ Encrypter	ผู้เข้ารหัส
DB	Illuminate \ Database \ DatabaseManager	db
DB (อินสแตนซ์)	ส่องสว่าง \ Database \ Connection
เหตุการณ์	Illuminate \ Events \ Dispatcher	เหตุการณ์
ไฟล์	Illuminate \ Filesystem \ Filesystem	ไฟล์
ประตู	Illuminate \ Contracts \ Auth \ Access \ Gate
กัญชา	Illuminate \ Contracts \ Hashing \ Hasher	กัญชา
อินพุต	ส่องสว่าง \ Http \ ขอ	คำขอ
หรั่ง	Illuminate \ Translation \ Translator	นักแปล
บันทึก	Illuminate \ Log \ Writer	บันทึก
จดหมาย	ส่องสว่าง \ Mail \ Mailer	จดหมาย
รหัสผ่าน	ส่องสว่าง \ Auth \ Passwords \ PasswordBroker	auth.password
คิว	Illuminate \ Queue \ QueueManager	คิว
คิว (อินสแตนซ์)	Illuminate \ Queue \ QueueInterface
คิว (คลาสฐาน)	ส่องสว่าง \ Queue \ Queue
เปลี่ยนเส้นทาง	ส่องสว่าง \ Routing \ Redirector	เปลี่ยนเส้นทาง
Redis	ส่องสว่าง \ Redis \ Database	redis
ขอ	ส่องสว่าง \ Http \ ขอ	คำขอ
การตอบสนอง	Illuminate \ Contracts \ Routing \ ResponseFactory
เส้นทาง	ส่องสว่าง \ Routing \ Router	เราเตอร์
สคีมา	Illuminate \ Database \ Schema \ Blueprint
เซสชัน	Illuminate \ Session \ SessionManager	เซสชัน
เซสชัน (อินสแตนซ์)	Illuminate \ Session \ Store
การจัดเก็บ	Illuminate \ Contracts \ Filesystem \ Factory	ระบบไฟล์
URL	Illuminate \ Routing \ UrlGenerator	url
เครื่องมือตรวจสอบ	ส่องสว่าง \ Validation \ Factory	ตัวตรวจสอบความถูกต้อง
Validator (อินสแตนซ์)	ส่องสว่าง \ Validation \ Validator
ดู	ส่องสว่างดูโรงงาน	ดู
ดู (อินสแตนซ์)	ส่องสว่าง \ View \ View

ตัวอย่าง

Step 1 - สร้างผู้ให้บริการที่เรียกว่า TestFacadesServiceProvider โดยดำเนินการคำสั่งต่อไปนี้

php artisan make:provider TestFacadesServiceProvider

Step 2 - หลังจากดำเนินการสำเร็จคุณจะได้รับผลลัพธ์ต่อไปนี้ -

Step 3 - สร้างคลาสที่เรียกว่า TestFacades.php ที่ App/Test.

App/Test/TestFacades.php

<?php
   namespace App\Test;
   class TestFacades{
      public function testingFacades() {
         echo "Testing the Facades in Laravel.";
      }
   }
?>

Step 4 - สร้างคลาส Facade ที่เรียกว่า “TestFacades.php” ที่ “App/Test/Facades”.

App/Test/Facades/TestFacades.php

<?php

namespace app\Test\Facades;

use Illuminate\Support\Facades\Facade;

class TestFacades extends Facade {
   protected static function getFacadeAccessor() { return 'test'; }
}

Step 5 - สร้างคลาส Facade ที่เรียกว่า TestFacadesServiceProviders.php ที่ App/Test/Facades.

App/Providers/TestFacadesServiceProviders.php

<?php

namespace App\Providers;

use App;
use Illuminate\Support\ServiceProvider;

class TestFacadesServiceProvider extends ServiceProvider {
   public function boot() {
      //
   }
   public function register() {
      App::bind('test',function() {
         return new \App\Test\TestFacades;
      });
   }
}

Step 6 - เพิ่มผู้ให้บริการในไฟล์ config/app.php ดังแสดงในรูปด้านล่าง

config/app.php

Step 7 - เพิ่มนามแฝงในไฟล์ config/app.php ดังแสดงในรูปด้านล่าง

config/app.php

Step 8 - เพิ่มบรรทัดต่อไปนี้ใน app/Http/routes.php.

app/Http/routes.php

Route::get('/facadeex', function() {
   return TestFacades::testingFacades();
});

Step 9 - ไปที่ URL ต่อไปนี้เพื่อทดสอบ Facade

http://localhost:8000/facadeex

Step 10 - หลังจากเข้าไปที่ URL คุณจะได้รับผลลัพธ์ต่อไปนี้ -

สัญญา Laravel คือชุดของอินเทอร์เฟซที่มีฟังก์ชันการทำงานและบริการหลักที่หลากหลายซึ่งจัดทำโดยเฟรมเวิร์ก

ตัวอย่างเช่น, Illuminate\Contracts\Queue\Queue สัญญาใช้วิธีการที่จำเป็นสำหรับการจัดคิวงานและ Illuminate\Contracts\Mail\Mailer ใช้วิธีการส่งอีเมล

ทุกสัญญาที่กำหนดรวมถึงการปฏิบัติตามกรอบที่สอดคล้องกัน สัญญา Laravel ทั้งหมดมีอยู่ในที่เก็บ GitHub ตามที่ระบุไว้ด้านล่าง -

https://github.com/illuminate/contracts

พื้นที่เก็บข้อมูลนี้มีสัญญาต่างๆที่มีอยู่ในกรอบงาน Laravel ซึ่งสามารถดาวน์โหลดและใช้งานได้ตามนั้น

จุดสำคัญ

ในขณะที่ทำงานกับสัญญา Laravel โปรดสังเกตประเด็นสำคัญดังต่อไปนี้ -

จำเป็นต้องกำหนด facades ในคอนสตรัคเตอร์ของคลาส
สัญญามีการกำหนดไว้อย่างชัดเจนในชั้นเรียนและคุณไม่จำเป็นต้องกำหนดสัญญาในผู้ก่อสร้าง

ตัวอย่าง

พิจารณาสัญญาที่ใช้สำหรับการอนุญาตใน Laravel ซึ่งระบุไว้ด้านล่าง -

<?php

namespace Illuminate\Contracts\Auth\Access;

interface Authorizable{
   /**
      * Determine if the entity has a given ability.
      *
      * @param string $ability * @param array|mixed $arguments
      * @return bool
   */
   public function can($ability, $arguments = []);
}

สัญญาใช้ฟังก์ชันซึ่งรวมถึงไฟล์ parameter ชื่อ ability และ arguments ซึ่งใช้การระบุผู้ใช้ในรูปแบบของไฟล์ array.

คุณจะต้องกำหนดสัญญาตามที่แสดงในไวยากรณ์ด้านล่าง -

interface <contract-name>

สัญญาใช้เหมือนอาคารสำหรับสร้างแอปพลิเคชัน Laravel ที่แข็งแกร่งและผ่านการทดสอบมาเป็นอย่างดี มีหลากหลายpractical differences ด้วยการใช้สัญญาและอาคาร

รหัสต่อไปนี้แสดงโดยใช้สัญญาสำหรับการแคชที่เก็บ -

<?php

namespace App\Orders;
use Illuminate\Contracts\Cache\Repository as Cache;

class Repository{
   /**
      * The cache instance.
   */
   
   protected $cache; /** * Create a new repository instance. * * @param Cache $cache
      * @return void
   */
   
   public function __construct(Cache $cache) { $this->cache = $cache;
   }
}

สัญญาไม่มีการใช้งานและการอ้างอิงใหม่ มันเป็นเรื่องง่ายที่จะเขียนการใช้งานทางเลือกอื่นของสัญญาที่ระบุดังนั้นผู้ใช้สามารถแทนที่การใช้แคชโดยไม่ต้องแก้ไขฐานรหัสใด ๆ

CSRF หมายถึงการโจมตี Cross Site Forgery บนเว็บแอปพลิเคชัน การโจมตี CSRF เป็นกิจกรรมที่ไม่ได้รับอนุญาตซึ่งผู้ใช้ที่พิสูจน์ตัวตนของระบบดำเนินการ ด้วยเหตุนี้เว็บแอปพลิเคชันจำนวนมากจึงมีแนวโน้มที่จะถูกโจมตีเหล่านี้

Laravel เสนอการป้องกัน CSRF ด้วยวิธีต่อไปนี้ -

Laravel มีปลั๊กอิน CSRF ในตัวซึ่งสร้างโทเค็นสำหรับแต่ละเซสชันของผู้ใช้ที่ใช้งานอยู่ โทเค็นเหล่านี้ตรวจสอบว่าการดำเนินการหรือการร้องขอถูกส่งโดยผู้ใช้ที่ได้รับการพิสูจน์ตัวตนที่เกี่ยวข้อง

การนำไปใช้

การดำเนินการป้องกัน CSRF ใน Laravel จะกล่าวถึงโดยละเอียดในส่วนนี้ ประเด็นต่อไปนี้เป็นสิ่งที่น่าสังเกตก่อนที่จะดำเนินการต่อในการป้องกัน CSRF -

CSRF ถูกนำไปใช้ภายในรูปแบบ HTML ที่ประกาศไว้ในเว็บแอปพลิเคชัน คุณต้องรวมโทเค็น CSRF ที่ตรวจสอบแล้วที่ซ่อนอยู่ในแบบฟอร์มเพื่อให้มิดเดิลแวร์การป้องกัน CSRF ของ Laravel สามารถตรวจสอบคำขอได้ ไวยากรณ์แสดงด้านล่าง -

<form method = "POST" action="/profile">
   {{ csrf_field() }}
   ...
</form>

คุณสามารถสร้างแอปพลิเคชันที่ขับเคลื่อนด้วย JavaScript ได้อย่างสะดวกโดยใช้ไลบรารี JavaScript HTTP เนื่องจากมีโทเค็น CSRF สำหรับทุกคำขอที่ส่งออก
ไฟล์คือ resources/assets/js/bootstrap.js ลงทะเบียนโทเค็นทั้งหมดสำหรับแอปพลิเคชัน Laravel และรวมถึง meta tag ร้านไหน csrf-token ด้วย Axios HTTP library.

แบบฟอร์มที่ไม่มีโทเค็น CSRF

พิจารณาโค้ดบรรทัดต่อไปนี้ พวกเขาแสดงรูปแบบที่ใช้สองพารามิเตอร์เป็นอินพุต:email และ message.

<form>
   <label> Email </label>
      <input type = "text" name = "email"/>
      <br/>
   <label> Message </label> <input type="text" name = "message"/>
   <input type = ”submit” name = ”submitButton” value = ”submit”>
</form>

ผลลัพธ์ของโค้ดด้านบนคือรูปแบบที่แสดงด้านล่างซึ่งผู้ใช้ปลายทางสามารถดูได้ -

แบบฟอร์มที่แสดงด้านบนจะยอมรับข้อมูลอินพุตใด ๆ จากผู้ใช้ที่ได้รับอนุญาต ซึ่งอาจทำให้เว็บแอปพลิเคชั่นเสี่ยงต่อการโจมตีต่างๆ

โปรดทราบว่าปุ่มส่งมีฟังก์ชันการทำงานในส่วนคอนโทรลเลอร์ postContactฟังก์ชันถูกใช้ในตัวควบคุมสำหรับมุมมองที่เกี่ยวข้องนั้น ดังแสดงด้านล่าง -

public function postContact(Request $request) {
   return $request-> all();
}

สังเกตว่าแบบฟอร์มไม่มีโทเค็น CSRF ใด ๆ ดังนั้นข้อมูลที่ละเอียดอ่อนที่แชร์เป็นพารามิเตอร์อินพุตจึงมีแนวโน้มที่จะถูกโจมตีต่างๆ

แบบฟอร์มด้วยโทเค็น CSRF

โค้ดบรรทัดต่อไปนี้แสดงให้คุณเห็นแบบฟอร์มที่ออกแบบใหม่โดยใช้โทเค็น CSRF -

<form method = ”post” >
   {{ csrf_field() }}
   <label> Email </label>
   <input type = "text" name = "email"/>
   <br/>
   <label> Message </label>
   <input type = "text" name = "message"/>
   <input type = ”submit” name = ”submitButton” value = ”submit”>
</form>

ผลลัพธ์ที่ได้จะส่งคืน JSON พร้อมโทเค็นตามที่ระบุด้านล่าง -

{
   "token": "ghfleifxDSUYEW9WE67877CXNVFJKL",
   "name": "TutorialsPoint",
   "email": "[email protected]"
}

นี่คือโทเค็น CSRF ที่สร้างขึ้นเมื่อคลิกปุ่มส่ง

การพิสูจน์ตัวตนเป็นกระบวนการในการระบุข้อมูลรับรองของผู้ใช้ ในเว็บแอปพลิเคชันการรับรองความถูกต้องได้รับการจัดการโดยเซสชันซึ่งใช้พารามิเตอร์การป้อนข้อมูลเช่นอีเมลหรือชื่อผู้ใช้และรหัสผ่านเพื่อระบุตัวผู้ใช้ หากพารามิเตอร์เหล่านี้ตรงกันแสดงว่าผู้ใช้ได้รับการรับรองความถูกต้อง

คำสั่ง

Laravel ใช้คำสั่งต่อไปนี้เพื่อสร้างฟอร์มและตัวควบคุมที่เกี่ยวข้องเพื่อทำการพิสูจน์ตัวตน -

php artisan make:auth

คำสั่งนี้ช่วยในการสร้างโครงนั่งร้านรับรองความถูกต้องดังที่แสดงในภาพหน้าจอต่อไปนี้ -

ตัวควบคุม

ตัวควบคุมที่ใช้สำหรับกระบวนการรับรองความถูกต้องคือ HomeController.

<?php

namespace App\Http\Controllers;

use App\Http\Requests;
use Illuminate\Http\Request;

class HomeController extends Controller{
   /**
      * Create a new controller instance.
      *
      * @return void
   */
   
   public function __construct() {
      $this->middleware('auth');
   }
   
   /**
      * Show the application dashboard.
      *
      * @return \Illuminate\Http\Response
   */
   
   public function index() {
      return view('home');
   }
}

ด้วยเหตุนี้แอปพลิเคชัน scaffold ที่สร้างขึ้นจะสร้างหน้าเข้าสู่ระบบและหน้าการลงทะเบียนสำหรับการตรวจสอบสิทธิ์ ดังที่แสดงด้านล่าง -

เข้าสู่ระบบ

การลงทะเบียน

การพิสูจน์ตัวตนผู้ใช้ด้วยตนเอง

Laravel ใช้ไฟล์ Authfaçadeซึ่งช่วยในการพิสูจน์ตัวตนผู้ใช้ด้วยตนเอง รวมถึงไฟล์attempt วิธีการยืนยันอีเมลและรหัสผ่าน

พิจารณาโค้ดบรรทัดต่อไปนี้สำหรับ LoginController ซึ่งรวมถึงฟังก์ชันทั้งหมดสำหรับการตรวจสอบสิทธิ์ -

<?php

// Authentication mechanism
namespace App\Http\Controllers;

use Illuminate\Support\Facades\Auth;

class LoginController extends Controller{
   /**
      * Handling authentication request
      *
      * @return Response
   */
   
   public function authenticate() {
      if (Auth::attempt(['email' => $email, 'password' => $password])) {
      
         // Authentication passed...
         return redirect()->intended('dashboard');
      }
   }
}

ในบทที่แล้วเราได้ศึกษาเกี่ยวกับกระบวนการพิสูจน์ตัวตนใน Laravel บทนี้อธิบายขั้นตอนการอนุญาตใน Laravel

ความแตกต่างระหว่างการพิสูจน์ตัวตนและการอนุญาต

ก่อนดำเนินการต่อเพื่อเรียนรู้เพิ่มเติมเกี่ยวกับขั้นตอนการอนุญาตใน Laravel ขอให้เราเข้าใจความแตกต่างระหว่างการพิสูจน์ตัวตนและการอนุญาต

ใน authenticationระบบหรือเว็บแอปพลิเคชันจะระบุผู้ใช้ผ่านข้อมูลประจำตัวที่ให้ไว้ หากพบว่าข้อมูลประจำตัวนั้นถูกต้องแสดงว่าได้รับการพิสูจน์ตัวตนแล้วหรือไม่เช่นนั้นก็ไม่ได้

ใน authorizationระบบหรือเว็บแอปพลิเคชันจะตรวจสอบว่าผู้ใช้ที่พิสูจน์ตัวตนสามารถเข้าถึงทรัพยากรที่พวกเขาพยายามเข้าถึงหรือร้องขอได้หรือไม่ กล่าวอีกนัยหนึ่งก็คือตรวจสอบสิทธิ์และสิทธิ์ของพวกเขาในทรัพยากรที่ร้องขอ หากพบว่าสามารถเข้าถึงทรัพยากรได้แสดงว่าได้รับอนุญาต

ด้วยประการฉะนี้ authentication เกี่ยวข้องกับการตรวจสอบความถูกต้องของข้อมูลรับรองผู้ใช้และ authorization เกี่ยวข้องกับการตรวจสอบสิทธิ์และการอนุญาตเหนือทรัพยากรที่ผู้ใช้รับรองความถูกต้อง

กลไกการอนุญาตใน Laravel

Laravel มีกลไกง่ายๆสำหรับการอนุญาตที่มีสองวิธีหลัก ได้แก่ Gates และ Policies.

การเขียนประตูและนโยบาย

เกตส์ใช้เพื่อพิจารณาว่าผู้ใช้ได้รับอนุญาตให้ดำเนินการตามที่ระบุหรือไม่ โดยทั่วไปจะถูกกำหนดไว้ในApp/Providers/AuthServiceProvider.phpใช้ซุ้มประตู ประตูยังเป็นฟังก์ชันที่ประกาศสำหรับการดำเนินการกลไกการอนุญาต

มีการประกาศนโยบายภายในอาร์เรย์และใช้ภายในคลาสและวิธีการที่ใช้กลไกการอนุญาต

โค้ดบรรทัดต่อไปนี้อธิบายวิธีใช้เกตส์และนโยบายในการอนุญาตผู้ใช้ในเว็บแอปพลิเคชัน Laravel โปรดทราบว่าในตัวอย่างนี้ไฟล์boot ฟังก์ชันใช้สำหรับการอนุญาตผู้ใช้

<?php

namespace App\Providers;

use Illuminate\Contracts\Auth\Access\Gate as GateContract;
use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;

class AuthServiceProvider extends ServiceProvider{
   /**
      * The policy mappings for the application.
      *
      * @var array
   */
   
   protected $policies = [ 'App\Model' => 'App\Policies\ModelPolicy', ]; /** * Register any application authentication / authorization services. * * @param \Illuminate\Contracts\Auth\Access\Gate $gate
      * @return void
   */
   
   public function boot(GateContract $gate) { $this->registerPolicies($gate);
      //
   }
}

Laravel framework มีเครื่องมือหลักสามอย่างสำหรับการโต้ตอบผ่านบรรทัดคำสั่ง ได้แก่ : Artisan, Ticker และ REPL. บทนี้จะอธิบายเกี่ยวกับ Artisan โดยละเอียด

รู้เบื้องต้นเกี่ยวกับ Artisan

Artisan เป็นอินเทอร์เฟซบรรทัดคำสั่งที่ใช้บ่อยใน Laravel และมีชุดคำสั่งที่เป็นประโยชน์สำหรับการพัฒนาเว็บแอปพลิเคชัน

ตัวอย่าง

นี่คือรายการคำสั่งบางส่วนใน Artisan พร้อมกับฟังก์ชันการทำงานที่เกี่ยวข้อง -

To start Laravel project

php artisan serve

To enable caching mechanism

php artisan route:cache

To view the list of available commands supported by Artisan

php artisan list

To view help about any command and view the available options and arguments

php artisan help serve

ภาพหน้าจอต่อไปนี้แสดงผลลัพธ์ของคำสั่งที่ให้ไว้ด้านบน -

การเขียนคำสั่ง

นอกเหนือจากคำสั่งที่ระบุไว้ใน Artisan แล้วผู้ใช้ยังสามารถสร้างคำสั่งที่กำหนดเองซึ่งสามารถใช้ในเว็บแอปพลิเคชัน โปรดทราบว่าคำสั่งถูกเก็บไว้ในไฟล์app/console/commands directory.

คำสั่งเริ่มต้นสำหรับการสร้างคำสั่งที่ผู้ใช้กำหนดแสดงไว้ด้านล่าง -

php artisan make:console <name-of-command>

เมื่อคุณพิมพ์คำสั่งที่กำหนดข้างต้นคุณจะเห็นผลลัพธ์ดังที่แสดงในภาพหน้าจอด้านล่าง -

ไฟล์ที่สร้างขึ้นสำหรับ DefaultCommand มีชื่อเป็น DefaultCommand.php และแสดงไว้ด้านล่าง -

<?php

namespace App\Console\Commands;
use Illuminate\Console\Command;

class DefaultCommand extends Command{
   /**
      * The name and signature of the console command.
      *
      * @var string
   */
   
   protected $signature = 'command:name';
   
   /**
      * The console command description.
      *
      * @var string
   */
   
   protected $description = 'Command description';
   
   /**
      * Create a new command instance.
      *
      * @return void
   */
   
   public function __construct() {
      parent::__construct();
   }
   
   /**
      * Execute the console command.
      *
      * @return mixed
   */
   
   public function handle() {
      //
   }
}

ไฟล์นี้มีลายเซ็นและคำอธิบายสำหรับคำสั่งที่ผู้ใช้กำหนด ฟังก์ชันสาธารณะชื่อhandleเรียกใช้ฟังก์ชันการทำงานเมื่อดำเนินการคำสั่ง คำสั่งเหล่านี้ถูกลงทะเบียนในไฟล์Kernel.php ในไดเรกทอรีเดียวกัน

คุณยังสามารถสร้างกำหนดการของงานสำหรับคำสั่งที่ผู้ใช้กำหนดดังที่แสดงในโค้ดต่อไปนี้ -

<?php

namespace App\Console;

use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;

class Kernel extends ConsoleKernel {
   /**
      * The Artisan commands provided by your application.
      *
      * @var array
   */
   
   protected $commands = [
      // Commands\Inspire::class,
      Commands\DefaultCommand::class
   ];
   
   /**
      * Define the application's command schedule.
      *
      * @param \Illuminate\Console\Scheduling\Schedule $schedule * @return void */ protected function schedule(Schedule $schedule) {
      // $schedule->command('inspire')
      // ->hourly();
   }
}

โปรดสังเกตว่ากำหนดการของงานสำหรับคำสั่งที่กำหนดถูกกำหนดไว้ในฟังก์ชันที่ชื่อ scheduleซึ่งรวมถึงพารามิเตอร์สำหรับการจัดกำหนดการงานที่ต้องใช้ hourly พารามิเตอร์.

คำสั่งถูกลงทะเบียนในอาร์เรย์ของคำสั่งซึ่งรวมถึงเส้นทางและชื่อของคำสั่ง

เมื่อลงทะเบียนคำสั่งแล้วจะแสดงรายการในคำสั่ง Artisan ค่าที่รวมอยู่ในส่วนลายเซ็นและคำอธิบายจะแสดงเมื่อคุณเรียกใช้แอตทริบิวต์วิธีใช้ของคำสั่งที่ระบุ

ให้เราดูวิธีการดูคุณลักษณะของคำสั่งของเรา DefaultCommand. คุณควรใช้คำสั่งดังที่แสดงด้านล่าง -

php artisan help DefaultCommand

การเข้ารหัสเป็นกระบวนการแปลงข้อความธรรมดาเป็นข้อความโดยใช้อัลกอริทึมบางอย่างที่ผู้ใช้รายที่สามไม่สามารถอ่านข้อมูลได้ สิ่งนี้มีประโยชน์สำหรับการส่งข้อมูลที่ละเอียดอ่อนเนื่องจากมีโอกาสน้อยที่ผู้บุกรุกจะกำหนดเป้าหมายข้อมูลที่ถ่ายโอน

การเข้ารหัสดำเนินการโดยใช้กระบวนการที่เรียกว่า Cryptography. ข้อความที่จะเข้ารหัสเรียกว่าPlain Text และข้อความหรือข้อความที่ได้รับหลังจากเรียกการเข้ารหัส Cipher Text. เรียกกระบวนการแปลงข้อความรหัสเป็นข้อความธรรมดาDecryption.

Laravel ใช้ AES-256 และ AES-128ผู้เข้ารหัสซึ่งใช้ Open SSL สำหรับการเข้ารหัส ค่าทั้งหมดที่รวมอยู่ใน Laravel จะลงนามโดยใช้โปรโตคอลMessage Authentication Code เพื่อให้ไม่สามารถแก้ไขค่าพื้นฐานได้เมื่อเข้ารหัสแล้ว

การกำหนดค่า

คำสั่งที่ใช้ในการสร้างไฟล์ key ใน Laravel แสดงไว้ด้านล่าง -

php artisan key:generate

โปรดทราบว่าคำสั่งนี้ใช้ตัวสร้างไบต์แบบสุ่มที่ปลอดภัยของ PHP และคุณจะเห็นผลลัพธ์ดังที่แสดงในภาพหน้าจอด้านล่าง -

คำสั่งที่ให้ไว้ข้างต้นช่วยในการสร้างคีย์ที่สามารถใช้ในเว็บแอปพลิเคชัน สังเกตภาพหน้าจอด้านล่าง -

บันทึก

ค่าสำหรับการเข้ารหัสถูกจัดตำแหน่งอย่างเหมาะสมในไฟล์ config/app.php ซึ่งมีพารามิเตอร์สองตัวสำหรับการเข้ารหัส ได้แก่ key และ cipher. หากค่าที่ใช้คีย์นี้ไม่ได้รับการจัดแนวอย่างเหมาะสมค่าทั้งหมดที่เข้ารหัสใน Laravel จะไม่ปลอดภัย

กระบวนการเข้ารหัส

การเข้ารหัสค่าสามารถทำได้โดยใช้ไฟล์ encrypt helperในคอนโทรลเลอร์ของคลาส Laravel ค่าเหล่านี้ถูกเข้ารหัสโดยใช้ OpenSSL และ AES-256 cipher ค่าที่เข้ารหัสทั้งหมดจะลงนามด้วย Message Authentication code (MAC) เพื่อตรวจสอบการแก้ไขของสตริงที่เข้ารหัส

รหัสที่แสดงด้านล่างกล่าวถึงในคอนโทรลเลอร์และใช้เพื่อเก็บความลับหรือข้อความที่ละเอียดอ่อน

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class DemoController extends Controller{
   **
      * Store a secret message for the user.
      *
      * @param Request $request
      * @param int $id * @return Response */ public function storeSecret(Request $request, $id) { $user = User::findOrFail($id); $user->fill([
         'secret' => encrypt($request->secret)
      ])->save();
   }
}

กระบวนการถอดรหัส

การถอดรหัสค่าทำได้โดยใช้ decrypt helper. สังเกตโค้ดบรรทัดต่อไปนี้ -

use Illuminate\Contracts\Encryption\DecryptException;

// Exception for decryption thrown in facade
try {
   $decrypted = decrypt($encryptedValue); } catch (DecryptException $e) {
   //
}

โปรดทราบว่าหากกระบวนการถอดรหัสไม่สำเร็จเนื่องจากมีการใช้ MAC ที่ไม่ถูกต้องข้อยกเว้นที่เหมาะสมจะถูกโยนทิ้งไป

การแฮชเป็นกระบวนการในการแปลงสตริงของอักขระให้เป็นค่าคงที่ที่สั้นกว่าหรือคีย์ที่แสดงถึงสตริงดั้งเดิม Laravel ใช้ไฟล์Hash ซุ้มซึ่งเป็นวิธีที่ปลอดภัยในการจัดเก็บรหัสผ่านในลักษณะแฮช

การใช้งานพื้นฐาน

ภาพหน้าจอต่อไปนี้แสดงวิธีสร้างคอนโทรลเลอร์ที่ชื่อ passwordController ซึ่งใช้สำหรับจัดเก็บและอัปเดตรหัสผ่าน -

โค้ดบรรทัดต่อไปนี้อธิบายการทำงานและการใช้งานไฟล์ passwordController -

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use App\Http\Controllers\Controller

class passwordController extends Controller{
   /**
      * Updating the password for the user.
      *
      * @param Request $request * @return Response */ public function update(Request $request) {
      // Validate the new password length...
      $request->user()->fill([ 'password' => Hash::make($request->newPassword) // Hashing passwords
      ])->save();
   }
}

รหัสผ่านที่แฮชจะถูกเก็บไว้โดยใช้ makeวิธี. วิธีนี้ช่วยให้สามารถจัดการปัจจัยการทำงานของไฟล์bcrypt อัลกอริทึมการแฮชซึ่งนิยมใช้ใน Laravel

การยืนยันรหัสผ่านกับแฮช

คุณควรตรวจสอบรหัสผ่านกับแฮชเพื่อตรวจสอบสตริงที่ใช้สำหรับการแปลง สำหรับสิ่งนี้คุณสามารถใช้ไฟล์checkวิธี. สิ่งนี้แสดงในรหัสที่ระบุด้านล่าง -

if (Hash::check('plain-text', $hashedPassword)) {
   // The passwords match...
}

โปรดทราบว่าไฟล์ check วิธีการเปรียบเทียบข้อความธรรมดากับไฟล์ hashedPassword ตัวแปรและหากผลลัพธ์เป็นจริงจะส่งกลับค่าจริง

เฟรมเวิร์กแอปพลิเคชันเว็บทุกตัวมีประวัติเวอร์ชันของตัวเองและจะได้รับการอัปเดตและดูแลอยู่เสมอ ทุกเวอร์ชันล่าสุดนำเสนอฟังก์ชันและฟังก์ชันใหม่ ๆ ซึ่งอาจมีการเปลี่ยนแปลงหรือเลิกใช้งานดังนั้นจึงเป็นเรื่องสำคัญที่คุณจะต้องทราบว่าเวอร์ชันใดจะเหมาะกับโครงการของคุณ

เมื่อพูดถึง Laravel มีสองเวอร์ชันที่ใช้งานอยู่ตามที่ระบุด้านล่าง -

Laravel 4 - วางจำหน่ายในเดือนพฤษภาคม 2013
Laravel 5.1 - วางจำหน่ายในเดือนกุมภาพันธ์ 2015

Laravel 5.1 ยังรวมถึงรุ่นต่างๆด้วย Laravel 5.1.5 เวอร์ชันล่าสุดซึ่งรวมถึงคุณสมบัติที่มีประสิทธิภาพทั้งหมดสำหรับการพัฒนาเว็บ แผนงานของ Laravel หรือการเปิดตัวเวอร์ชันแสดงอยู่ในภาพด้านล่าง -

ประเด็นต่อไปนี้เป็นสิ่งที่น่าสังเกตในบริบทของการทำความเข้าใจกระบวนการปล่อย Laravel -

ไดเร็กทอรีเก่าของ app/models จะถูกลบออกใน Laravel 5.1
ตัวควบคุมมิดเดิลแวร์และคำขอทั้งหมดถูกจัดกลุ่มภายในไดเร็กทอรีภายใต้โฟลเดอร์ app / Http
โฟลเดอร์ใหม่คือ Providers ไดเร็กทอรีถูกแทนที่ด้วยไฟล์ app/start ไฟล์ใน Laravel 4.x. เวอร์ชันก่อนหน้า
ไฟล์ภาษาและมุมมองทั้งหมดจะถูกย้ายไปที่ไฟล์ resources ไดเรกทอรี
คำสั่งช่างฝีมือใหม่ route:cache ใช้สำหรับการลงทะเบียนเส้นทางใหม่และรวมอยู่ในรุ่น Laravel 5.1 และเวอร์ชันอื่น ๆ
Laravel รองรับ HTTP middleware และยังรวมถึง CSRF tokens และรูปแบบการพิสูจน์ตัวตน
โมเดลการตรวจสอบความถูกต้องทั้งหมดอยู่ภายใต้ไดเร็กทอรีเดียวคือ resources/views/auth. ซึ่งรวมถึงการลงทะเบียนผู้ใช้การรับรองความถูกต้องและตัวควบคุมรหัสผ่าน

Laravel เผยแพร่

เวอร์ชัน	ปล่อย	แก้ไขข้อผิดพลาดจนกว่า	แก้ไขความปลอดภัยจนกว่า
V1	มิถุนายน 2554	-	-
V2	กันยายน 2554	-	-
v3	กุมภาพันธ์ 2555	-	-
v4	พฤษภาคม 2013	-	-
5.0	4 ก.พ. 2015	4 ส.ค. 2015	4 ก.พ. 2559
5.1 (LTS)	9 มิ.ย. 2015	9 มิ.ย. 2017	9 มิ.ย. 2018
5.2	21 ธันวาคม 2558	21 มิ.ย. 2559	21 ธันวาคม 2559
5.3	23 ส.ค. 2559	23 ก.พ. 2017	23 ส.ค. 2017
5.4	24 ม.ค. 2017	24 ก.ค. 2017	24 ม.ค. 2018
5.5 (LTS)	30 ส.ค. 2017	30 ส.ค. 2019	30 ส.ค. 2020
5.6	7 ก.พ. 2018	7 ส.ค. 2018	7 ก.พ. 2019
5.7	4 ก.ย. 2561	4 ก.พ. 2019	4 ก.ย. 2019

โปรดทราบว่าเวอร์ชันที่ไฮไลต์เป็นรุ่นล่าสุด

คุณลักษณะ Guest User Gates เป็นส่วนเสริมของ 5.7 เวอร์ชันล่าสุดที่เปิดตัวในเดือนกันยายน 2018 คุณลักษณะนี้ใช้เพื่อเริ่มต้นกระบวนการอนุญาตสำหรับผู้ใช้บางราย

ใน Laravel 5.6 มีขั้นตอนที่ใช้ในการส่งคืน falseสำหรับผู้ใช้ที่ไม่ได้รับการพิสูจน์ตัวตน ใน Laravel 5.7 เราสามารถอนุญาตให้แขกตรวจสอบการอนุญาตได้โดยใช้เฉพาะnullable พิมพ์คำใบ้ภายในคอนโทรลเลอร์ที่ระบุตามที่ระบุด้านล่าง -

<?php
Gate::define('view-post', function (?User $user) {
   // Guests
});

คำอธิบายรหัส

โดยใช้ไฟล์ nullableพิมพ์คำใบ้ตัวแปร $ user จะเป็นโมฆะเมื่อผู้ใช้ที่เป็นแขกถูกส่งไปที่ประตู จากนั้นคุณสามารถตัดสินใจเกี่ยวกับการอนุญาตการดำเนินการได้ หากคุณอนุญาตประเภทที่เป็นโมฆะและส่งกลับค่าจริงผู้เยี่ยมชมจะได้รับอนุญาต หากคุณไม่ใช้คำใบ้ประเภทที่เป็นโมฆะแขกจะได้รับการตอบสนอง 403 สำหรับ Laravel 5.7 โดยอัตโนมัติซึ่งแสดงไว้ด้านล่าง -

ความแตกต่างระหว่างข้อผิดพลาด 403 และ 404 คือ 404 จะปรากฏขึ้นเมื่อผู้ใช้พยายามเข้าถึงทรัพยากรหรือ URL ที่ไม่รู้จักและข้อผิดพลาด 403 ตามที่ระบุไว้ในภาพรวมด้านบนจะแสดงขึ้นหากผู้ใช้ที่ไม่ได้รับอนุญาตเข้าถึงเว็บไซต์

Laravel 5.7 มาพร้อมกับวิธีใหม่ในการปฏิบัติและทดสอบคำสั่งใหม่ มันมีคุณสมบัติใหม่ในการทดสอบคำสั่งช่างฝีมือและการสาธิตดังต่อไปนี้ -

class ArtisanCommandTest extends TestCase{
   public function testBasicTest() {
      $this->artisan('nova:create', [
         'name' => 'My New Admin panel'
      ])
      ->expectsQuestion('Please enter your API key', 'apiKeySecret')
      ->expectsOutput('Authenticating...')
      ->expectsQuestion('Please select a version', 'v1.0')
      ->expectsOutput('Installing...')
      ->expectsQuestion('Do you want to compile the assets?', 'yes')
      ->expectsOutput('Compiling assets...')
      ->assertExitCode(0);
   }
}

คำอธิบายรหัส

ที่นี่คลาสใหม่ชื่อ“ ArtisanCommandTest” ถูกสร้างขึ้นภายใต้โมดูลกรณีทดสอบ ประกอบด้วยฟังก์ชันพื้นฐานtestBasicTest ซึ่งรวมถึงฟังก์ชันต่างๆของการยืนยัน

คำสั่งช่างฝีมือ expectsQuestionมีสองคุณลักษณะ หนึ่งคำถามและอื่น ๆ ที่มีapiKeySecret. ที่นี่ช่างฝีมือจะตรวจสอบ apiKeySecret และตรวจสอบอินพุตที่ผู้ใช้ส่งมา

สถานการณ์เดียวกันนี้ใช้กับคำถาม "โปรดเลือกรุ่น" ซึ่งคาดว่าผู้ใช้จะพูดถึงเวอร์ชันที่เจาะจง

Laravel มีคุณลักษณะของการแบ่งหน้าซึ่งช่วยให้ผู้ใช้หรือนักพัฒนาสามารถรวมคุณลักษณะการแบ่งหน้า Laravel paginator ถูกรวมเข้ากับตัวสร้างแบบสอบถามและ Eloquent ORM เมธอด paginate จะดูแลการตั้งค่าขีด จำกัด ที่ต้องการและออฟเซ็ตที่กำหนดโดยอัตโนมัติ ยอมรับเพียงพารามิเตอร์เดียวในการแบ่งหน้าเช่นจำนวนรายการที่จะแสดงในหนึ่งหน้า

Laravel 5.7 มีวิธีการแบ่งหน้าแบบใหม่เพื่อปรับแต่งจำนวนหน้าในแต่ละด้านของตัวแบ่งหน้า วิธีใหม่ไม่ต้องการมุมมองการแบ่งหน้าแบบกำหนดเองอีกต่อไป

การสาธิตรหัสมุมมองการแบ่งหน้าแบบกำหนดเองมีการระบุไว้ด้านล่าง -

<?php
namespace App\Http\Controllers;
use Illuminate\Support\Facades\DB;
use App\Http\Controllers\Controller;
class UserController extends Controller{
   /**
   * Show all of the users for the application.
   *
   * @return Response
   */
   public function index() {
      $users = DB::table('users')->paginate(15); return view('user.index', ['users' => $users]);
   }
}

การปรับแต่งเลขหน้าใหม่ตามมาตรฐาน Laravel มีการระบุไว้ด้านล่าง -

<?php
User::paginate(10)->onEachSide(5);

โปรดทราบว่า onEachSide หมายถึงการแบ่งย่อยของแต่ละระเบียนการแบ่งหน้าด้วย 10 และการแบ่งย่อย 5

เซิร์ฟเวอร์การถ่ายโอนข้อมูล Laravel มาพร้อมกับเวอร์ชัน Laravel 5.7 เวอร์ชันก่อนหน้านี้ไม่มีเซิร์ฟเวอร์ดัมพ์ใด ๆ เซิร์ฟเวอร์การถ่ายโอนข้อมูลจะเป็นการพึ่งพาการพัฒนาในไฟล์คอมโพสิต laravel / laravel

ด้วยการเปิดตัวเวอร์ชัน 5.7 คุณจะได้รับคำสั่งนี้ซึ่งรวมถึงแนวคิดนอกกรอบซึ่งอนุญาตให้ผู้ใช้ถ่ายโอนข้อมูลไปยังคอนโซลหรือไฟล์ HTML แทนเบราว์เซอร์ การดำเนินการคำสั่งดังต่อไปนี้ -

php artisan dump-server
# Or send the output to an HTML file
php artisan dump-server --format=html > dump.html

คำอธิบาย

คำสั่งรันเซิร์ฟเวอร์ในพื้นหลังซึ่งช่วยในการรวบรวมข้อมูลที่ส่งจากแอ็พพลิเคชันที่ส่งเอาต์พุตผ่านคอนโซล เมื่อคำสั่งไม่ทำงานในส่วนหน้าฟังก์ชัน dump () คาดว่าจะทำงานตามค่าเริ่มต้น

Laravel 5.7 ขอแนะนำคุณลักษณะใหม่ที่เรียกว่า "URL การดำเนินการที่เรียกได้" คุณลักษณะนี้คล้ายกับใน Laravel 5.6 ซึ่งยอมรับสตริงในวิธีการดำเนินการ วัตถุประสงค์หลักของไวยากรณ์ใหม่ที่เปิดตัว Laravel 5.7 คือเพื่อให้คุณเข้าถึงคอนโทรลเลอร์ได้โดยตรง

ไวยากรณ์ที่ใช้ใน Laravel 5.6 เวอร์ชันดังที่แสดง -

<?php
$url = action('UserController@profile', ['id' => 1]);

การกระทำที่คล้ายกันที่เรียกว่าใน Laravel 5.7 มีการระบุไว้ด้านล่าง -

<?php
$url = action([PostsController::class, 'index']);

ข้อดีอย่างหนึ่งของรูปแบบไวยากรณ์อาร์เรย์ที่เรียกได้ใหม่คือคุณลักษณะของความสามารถในการนำทางไปยังคอนโทรลเลอร์โดยตรงหากนักพัฒนาใช้โปรแกรมแก้ไขข้อความหรือ IDE ที่รองรับการนำทางโค้ด