จะสร้างไฟล์ php ได้อย่างไร?
วันที่: 2010-09-08
ความแตกต่างระหว่างไฟล์ php และไฟล์ html คืออะไรตามที่คุณเข้าใจการสร้างเว็บไซต์อัตโนมัติเป็นขั้นตอนต่อไปในการสร้างเว็บไซต์ หากสามารถสร้างเว็บไซต์แบบธรรมดาด้วย HTML ธรรมดาได้ ก็สามารถสร้างเว็บไซต์อัตโนมัติได้โดยใช้ PHP เท่านั้น และมักใช้ฐานข้อมูล (ตั้งแต่หนึ่งรายการขึ้นไป) บ่อยครั้ง
แต่พื้นฐานของหน้าเว็บใน PHP ยังคงเป็นภาษา HTML ดังนั้นกฎทั้งหมดสำหรับการสร้างเพจทั้งสองประเภทจึงเป็นเรื่องปกติ
และฉันจะถือว่าคุณคุ้นเคยกับ HTML อยู่แล้วและรู้วิธีสร้างหน้าเว็บที่เรียบง่าย หากคุณไม่ทราบหรือลืมไปแล้ว :) ให้อัปเดตความรู้ของคุณในส่วนนี้ สิ่งนี้นำไปสู่กฎที่สำคัญมาก: แท็กทั้งหมดที่เราศึกษาในส่วนนี้ยังใช้งานได้ดีในไฟล์ PHP และเราจะใช้แท็กเหล่านี้ ดังนั้นคุณต้องรู้ HTML
ในโครงสร้างของมัน ไฟล์ PHP มีลักษณะคล้ายกับไฟล์ HTML ทั่วไป แต่มีการแทรกโค้ด PHP แบบพิเศษ การแทรกโค้ดเหล่านี้จะถูกแทรกลงในโค้ดของหน้าเว็บโดยใช้ตัวดำเนินการพิเศษ ซึ่งบางครั้งเรียกว่า descriptors:
คำอธิบาย
หมายเหตุ: บางครั้งคุณอาจพบคำย่อสำหรับ descriptors: . ขอแนะนำให้หลีกเลี่ยงการบันทึกดังกล่าว สคริปต์ PHP แบบสั้นอาจไม่ทำงานบนเซิร์ฟเวอร์ทั้งหมด
เมื่อเซิร์ฟเวอร์ (หรือเซิร์ฟเวอร์ท้องถิ่น) พบส่วนแทรกดังกล่าว มันจะเชื่อมต่อ (ติดตั้งบนเซิร์ฟเวอร์) โค้ด PHP จะถูกประมวลผล และผู้ใช้ (ผู้เยี่ยมชมไซต์) จะได้รับหน้าเว็บที่ประมวลผลแล้วและพร้อมใช้งาน นั่นคือเหตุผลที่ถ้าเราพยายามดูโค้ดของหน้า php ที่เบราว์เซอร์โหลดไว้แล้ว (ปุ่มเมาส์ขวา ดูโค้ด HTML) เราจะไม่เห็นส่วนแทรกดังกล่าว (เซิร์ฟเวอร์ประมวลผลแล้ว)
ไฟล์ php ถูกสร้างขึ้นในลักษณะเดียวกับไฟล์ html เพียงเปลี่ยนชื่อนามสกุลของไฟล์ข้อความ และสามารถทำได้ใน Notepad ทั่วไป เราได้พูดถึงเรื่องนี้ไปแล้วในบทเรียน: “ฉันจะไม่พูดซ้ำอีก
เมื่อมีการร้องขอไฟล์ดังกล่าว (กล่าวอีกนัยหนึ่งคือ เซิร์ฟเวอร์จะคลิกที่ลิงก์) เซิร์ฟเวอร์จะ "เข้าใจ" แล้วว่าไฟล์นี้มีโค้ด PHP และจำเป็นต้องได้รับการประมวลผลก่อนที่จะมอบให้กับผู้เยี่ยมชม รหัส HTML ถูกส่งผ่านโดยเซิร์ฟเวอร์หรือโดยตัวประมวลผลล่วงหน้าของ PHP โดยไม่ต้องประมวลผล
ตอนนี้เรามาดูไฟล์ง่ายๆ ที่มีโค้ด PHP กัน เพื่อให้เจาะจงยิ่งขึ้น ลองเรียกมันว่าตัวอย่าง name.php ลองดูที่รายการ 1:
รายการ 1.
อย่างที่คุณเห็น โค้ดสำหรับไฟล์ php นี้แตกต่างจากไฟล์ html ด้วยนามสกุล .php (ในชื่อไฟล์) และการแทรกโค้ด php รายการ 2:
รายการ 2.
|
ตัวดำเนินการเสียงสะท้อนถูกแปลเป็นเอาต์พุต ในกรณีนี้หมายถึงเอาต์พุตไปยังหน้าจอมอนิเตอร์ เหล่านั้น. คำจารึก สวัสดี ฉันชื่ออีวาน จะปรากฏบนจอภาพเมื่อคุณเรียกใช้ไฟล์นี้
แต่ละคำสั่งจะตามด้วยเครื่องหมายอัฒภาค (;) ถ้ามีเพียงคำสั่งเดียวอย่างที่เรามีอยู่ตอนนี้ก็ไม่จำเป็นต้องใส่เครื่องหมายอัฒภาค แต่ถ้ามีหลายคำสั่ง ก็ควรใส่เครื่องหมายอัฒภาคไว้หลังแต่ละคำสั่ง นี่คือตัวคั่นระหว่างคำสั่ง หลังจากเครื่องหมายอัฒภาค ถือว่าคำสั่งเสร็จสมบูรณ์ นอกจากนี้ยังถือเป็นรูปแบบที่ดีเมื่อเขียนโปรแกรมใน PHP
ในบทเรียนเบื้องต้นนี้ ฉันจะแนะนำคุณเกี่ยวกับโปรแกรมที่จำเป็น และบอกคุณถึงสิ่งที่คุณต้องการในการทำงานกับ PHP
สิ่งที่คุณต้องรู้คุณต้องรู้ว่า PHP เขียนอย่างไร ในไฟล์สคริปต์ PHP จะขึ้นต้นด้วยคำว่า - ทุกสิ่งที่อยู่ระหว่างนั้นคือโค้ด PHP จำสิ่งนี้ไว้
ไฟล์ที่มีโค้ด PHP จะต้องบันทึกภายใต้นามสกุล .php
เพื่อที่จะเรียนรู้ PHP (เช่นเดียวกับภาษาโปรแกรมอื่นๆ) สิ่งสำคัญคือต้องฝึกฝนให้มาก
เมื่อคุณอ่านบทเรียน อย่าคัดลอกโค้ด แต่เขียนเอง มันจะดีกว่าสำหรับคุณ ด้วยวิธีนี้คุณจะจำภาษาได้เร็วขึ้น และจะง่ายขึ้นสำหรับคุณในอนาคต
โปรแกรมแรกที่คุณต้องการคือเบราว์เซอร์ (สิ่งที่คุณอยู่ในปัจจุบัน :D)
เว็บเซิร์ฟเวอร์ สำหรับการทดสอบในเครื่อง คุณจะต้องติดตั้งเว็บเซิร์ฟเวอร์ ฉันแนะนำให้ติดตั้ง Open Server (เวอร์ชัน Mini ก็เพียงพอแล้ว) วิธีการติดตั้ง Open Server. Open Server สามารถพกพาได้ เช่น คุณเพียงแค่ต้องคลายซิปไฟล์เก็บถาวรที่ดาวน์โหลดมาและเริ่มเซิร์ฟเวอร์ผ่าน OpenServer.exe
เมื่อเริ่มเขียนโปรแกรมสำหรับเว็บ โปรแกรมเมอร์มือใหม่หลายคนพบข้อผิดพลาดนี้ พวกเขาปฏิบัติต่อระบบเบราว์เซอร์-เซิร์ฟเวอร์เหมือนกับแอปพลิเคชันปกติ แบบโต้ตอบ ฉันกดปุ่มและระบบตอบกลับ ฉันเลื่อนเมาส์และตอบสนอง ข้อมูลทั้งหมดที่มีให้กับไคลเอนต์นั้นมีอยู่ในโปรแกรมเช่นกัน
นี่ไม่ใช่กรณีในการเขียนโปรแกรมเว็บ! -
ในขณะที่ผู้ใช้เห็นหน้าเว็บตรงหน้าและเริ่มดำเนินการบางอย่างกับมัน PHP ก็ทำงานเสร็จแล้ว! และผู้ใช้ไม่ได้โต้ตอบกับสคริปต์ PHP แต่โต้ตอบกับหน้า HTML ซึ่งเขาได้รับในเบราว์เซอร์ ผลลัพธ์ของสคริปต์ PHP ในกรณีส่วนใหญ่คือข้อความธรรมดา ข้อความหน้า HTML ซึ่งมอบให้กับเบราว์เซอร์และแสดงให้พวกเขาเห็นเป็น HTML ปกติ คุณสามารถดูสิ่งนี้ได้ด้วยตัวเองโดยการเขียนในสคริปต์
;
จากนั้นดูข้อความต้นฉบับของหน้าผลลัพธ์ในเบราว์เซอร์ ไม่มีแท็ก PHP อยู่ที่นั่น! เท่านั้น
สวัสดีวาสยา!
เพราะ PHP ทำงานบนเซิร์ฟเวอร์!
เซิร์ฟเวอร์และเบราว์เซอร์สื่อสารกันโดยส่งคำขอถึงกันโดยใช้โปรโตคอลพิเศษ - HTTP มีเพียงเบราว์เซอร์เท่านั้นที่สามารถเริ่มการเชื่อมต่อได้ เขาส่งคำขอไปยังเซิร์ฟเวอร์เพื่อแสดงไฟล์ดังกล่าว เซิร์ฟเวอร์ส่งไฟล์ไปยังไคลเอนต์
นั่นเป็นวิธีเดียวที่มันจะเกิดขึ้น ลูกค้าร้องขอ - เซิร์ฟเวอร์จัดให้ และฉันก็ลืมลูกค้าทันที จากที่นี่คำตอบสำหรับคำถามก็ชัดเจน: เป็นไปได้หรือไม่ที่จะทราบจำนวนผู้ใช้ที่อยู่ในไซต์ในปัจจุบัน เป็นสิ่งต้องห้าม เพราะไม่มี "บนเว็บไซต์" พวกเขาเชื่อมต่อ ขอเพจ และยกเลิกการเชื่อมต่อ พวกเขาไม่มีการเชื่อมต่อกับเซิร์ฟเวอร์อย่างถาวร เช่น ผู้เล่น Kwaku คุณสามารถทราบโดยประมาณได้โดยการบันทึกเวลาของการเชื่อมต่อแต่ละครั้งและเลือกบันทึกในช่วงระยะเวลาหนึ่งเท่านั้น
ตัวอย่างการสื่อสารของเบราว์เซอร์กับเซิร์ฟเวอร์:
ผู้ใช้คลิกที่ลิงค์ เบราว์เซอร์ส่งคำขอไปยังเซิร์ฟเวอร์และรอการตอบกลับ:
เบราว์เซอร์ -> PHP
PHP รันสคริปต์ ส่งผลลัพธ์ไปยังเบราว์เซอร์ และออกจาก:
PHP -> เบราว์เซอร์
เบราว์เซอร์จะแสดงเพจ "เรียกดู" เพื่อดูลิงก์ที่ต้องขอจากเซิร์ฟเวอร์ (แท็ก และอื่นๆ) และส่งคำขอที่เหมาะสม สามารถดูได้จากการดูการแลกเปลี่ยนส่วนหัว ซึ่งจะกล่าวถึงด้านล่าง:
เบราว์เซอร์ -> เซิร์ฟเวอร์ เบราว์เซอร์ -> เซิร์ฟเวอร์ เบราว์เซอร์ -> เซิร์ฟเวอร์...
ผู้ใช้กรอกแบบฟอร์มและคลิกที่ปุ่ม:
เบราว์เซอร์ -> PHP
PHP ประมวลผลแบบฟอร์ม เขียนข้อมูลไปยังฐานข้อมูล และส่งส่วนหัวไปยังเบราว์เซอร์
ที่ตั้ง:
PHP -> เบราว์เซอร์
เบราว์เซอร์ที่ได้รับส่วนหัวนี้ร้องขอหน้าที่ระบุ
เบราว์เซอร์ -> PHP
PHP ทำมัน... และอื่นๆ
ดูการแลกเปลี่ยนส่วนหัว HTTP
ฉันขอแนะนำให้ฝึกใช้ส่วนหัว HTTP และดูวิธีการแลกเปลี่ยนระหว่างเซิร์ฟเวอร์และไคลเอนต์
มีหลายวิธีในการทำเช่นนี้ หากคุณมีโปรแกรมจัดการดาวน์โหลดยอดนิยมอย่าง FlashGet คุณก็สามารถใช้งานได้ โปรแกรม Proxomitron ยอดนิยมยังแสดงส่วนหัวด้วย คุณสามารถดาวน์โหลดยูทิลิตี้พิเศษบางอย่างได้
สำหรับ IE คุณสามารถแนะนำปลั๊กอิน http://blunck.se/iehttpheaders/iehttpheaders.html
มีปลั๊กอินที่สะดวกสำหรับเบราว์เซอร์ Mozilla http://livehttpheaders.mozdev.org/
นอกจากนี้ยังมียูทิลิตี้อื่น ๆ อีกมากมายที่สามารถพบได้ง่ายบนอินเทอร์เน็ตโดยค้นหา HTTP sniffer
อย่าลืมใช้วิธีใดๆ เพื่อดูส่วนหัว HTTP ที่แลกเปลี่ยนระหว่างเบราว์เซอร์และเซิร์ฟเวอร์ นี่เป็นแนวทางปฏิบัติที่ดีมาก รวมถึงตรวจสอบว่าสคริปต์ของคุณส่งอะไรไปบ้าง สะดวกในการแก้ไขการติดตั้งคุกกี้หรือเกิดปัญหากับเซสชัน
คุณยังสามารถทราบแนวคิดคร่าวๆ เกี่ยวกับส่วนหัวที่เข้ามาได้โดยใช้ฟังก์ชัน getallheaders() แต่คุณควรจำไว้ว่ามันจะใช้งานได้ก็ต่อเมื่อ PHP ได้รับการคอมไพล์เป็นโมดูลเท่านั้น
หมายเหตุสำคัญมาก
จากข้อเท็จจริงที่ว่า PHP ทำงานบนเซิร์ฟเวอร์และส่งผลงานไปยังเบราว์เซอร์ จึงมีข้อสรุปที่เรียบง่าย แต่สำคัญอย่างหนึ่งตามมา โดยหลักการแล้ว PHP นั้นไม่สามารถแสดงสิ่งใด ๆ ในเบราว์เซอร์ที่ไม่สามารถทำได้โดยใช้ html
ก่อนที่จะเขียนอะไรก็ตามใน PHP ให้ลองทำโดยใช้ HTML ล้วนๆ
“กด Enter” ไม่แปลบรรทัด? คุณได้ลองแปลสตริงด้วยวิธีนี้เป็น html แล้วหรือยัง? ไม่ได้ผลเหรอ? น่าเสียดายจริงๆ อ่านวิธีขึ้นบรรทัดใหม่ใน html แล้วกลับมาใหม่อีกครั้ง
จากการทำงาน PHP จะไม่สร้างรูปภาพพร้อมข้อความอย่างที่คุณเห็นบนหน้าจอมอนิเตอร์! PHP สร้างโค้ด HTML! และรหัสนี้แตกต่างอย่างมากจากภาพที่คุณเห็นบนหน้าจอ หากมีบางอย่างไม่ได้ผลสำหรับคุณ คุณควรดูที่ซอร์สโค้ดของหน้าเสมอ ไม่ใช่ดูว่าเบราว์เซอร์ดึงมันมาให้คุณอย่างไร ใน Internet Explorer คุณสามารถดูซอร์สโค้ดได้โดยเลือก ดู - ดูโค้ด HTML จากเมนู
หาก JavaScript ที่สร้างโดยสคริปต์ PHP ใช้งานไม่ได้สำหรับคุณ หรือ html ไม่แสดงสิ่งที่คุณต้องการ การแก้ไขปัญหานี้ง่ายมาก
1. ขั้นแรก ให้เขียน JavaScript หรือ HTML ที่จำเป็นด้วยตนเอง
หากคุณมีปัญหาในเรื่องนี้ โปรดติดต่อฟอรัมที่เหมาะสม - ใน Javascript หรือ html PHP ไม่มีส่วนเกี่ยวข้องกับมัน
2. เปรียบเทียบกับสิ่งที่ได้รับจาก PHP
เบราว์เซอร์ไม่ทราบวิธีแสดงไฟล์ที่มีรูปภาพ HTML ในเวลาเดียวกัน เบราว์เซอร์สามารถแสดงเฉพาะประเภทข้อมูลที่ทราบเท่านั้น โดยเฉพาะมันเป็นทั้ง html หรือรูปภาพ แต่ไม่ได้อยู่ด้วยกัน ถ้ามีรูปก็แสดงว่ามีรูปเดียว เบราเซอร์ไม่สามารถแสดงภาพหลายภาพติดต่อกันได้ เบราว์เซอร์สามารถแสดง HTML ที่มี LINKS ไปยังรูปภาพหลายรูปได้
โปรดก่อนที่จะเรียนรู้ PHP เรียนรู้พื้นฐาน HTML เป็นอย่างน้อย! ก่อนที่จะเรียกร้องอะไรจาก PHP ให้ลองทำใน html ก่อน
เมื่อใช้เซสชัน PHP เซิร์ฟเวอร์จะระบุตัวคุณและอนุญาตให้คุณดำเนินการที่จำเป็น: การเปลี่ยนแปลงข้อมูลบนหน้าเว็บต่างๆ การเพิ่มข้อมูลใหม่ ฯลฯ หลังจากเสร็จสิ้นการทำงานบนไซต์ คุณจะลบเซสชันปัจจุบันโดยคลิกที่ปุ่ม "ออกจากระบบ":
เซสชั่น PHP คืออะไร?เซสชัน PHP เป็นวิธีการจัดเก็บข้อมูลในตัวแปรเซสชันที่สามารถใช้เพื่อตรวจสอบความถูกต้องของหน้าเว็บหลายหน้า ต่างจากคุกกี้ตรงที่ข้อมูลเซสชั่นจะไม่ถูกจัดเก็บไว้ในคอมพิวเตอร์ของผู้ใช้ เซสชันจะสร้างไฟล์บนเซิร์ฟเวอร์ในไดเร็กทอรีชั่วคราวแทน
ข้อมูลนี้ซึ่งจัดเก็บไว้ตลอดเซสชันจะพร้อมใช้งานสำหรับหน้าเว็บทั้งหมดของทรัพยากร บนเซิร์ฟเวอร์ ตำแหน่งของไฟล์ชั่วคราวถูกกำหนดโดยพารามิเตอร์ session.save_path ในไฟล์คอนฟิกูเรชัน php.ini
เมื่อสร้างเซสชัน PHP จะต้องดำเนินการสามขั้นตอนต่อไปนี้:
- เมื่อมีการสร้างเซสชัน PHP จะสร้างตัวระบุที่ไม่ซ้ำกัน ซึ่งเป็นสตริงสุ่มที่มีเลขฐานสิบหก 32 ตัว ID อายุการใช้งานเซสชัน PHP มีลักษณะดังนี้: 9c8foj87c3jj973actop1re472e8774 ;
- เซิร์ฟเวอร์ส่งคุกกี้ที่เรียกว่า PHPSESSID ไปยังคอมพิวเตอร์ของผู้ใช้เพื่อจัดเก็บสตริงตัวระบุเซสชันที่ไม่ซ้ำกัน
- เซิร์ฟเวอร์สร้างไฟล์ในไดเร็กทอรีชั่วคราวที่ระบุซึ่งมีชื่อของตัวระบุเซสชันที่ไม่ซ้ำกันพร้อมคำนำหน้า sess _g sess_9c8foj87c3jj973actop1re472e8774 .
การตั้งค่าเหล่านี้ช่วยให้สคริปต์ PHP ดึงค่าตัวแปรเซสชันจากไฟล์ ในฝั่งไคลเอ็นต์ PHPSESSID มีตัวระบุเซสชัน โดยจะยืนยันชื่อของไฟล์ที่จะค้นหาในไดเร็กทอรีเฉพาะบนฝั่งเซิร์ฟเวอร์ ซึ่งสามารถแยกตัวแปรเซสชันและใช้สำหรับการตรวจสอบได้
ผู้ใช้สามารถสิ้นสุดเซสชันได้โดยคลิกปุ่มออกจากระบบ ซึ่งเรียกใช้ฟังก์ชัน session_destroy() เมื่อผู้ใช้ปิดเบราว์เซอร์ เซสชัน PHP จะถูกปิดโดยอัตโนมัติ มิฉะนั้นเซิร์ฟเวอร์จะยุติเซสชันหลังจากระยะเวลาที่กำหนด
ไวยากรณ์เซสชันใน PHPเมื่อ PHP อนุญาตผ่านเซสชัน PHP จะถูกสร้างขึ้นโดยใช้ฟังก์ชัน session_start() และลบออกโดยใช้ฟังก์ชัน session_destroy() ตัวแปรโกลบอล PHP ที่เรียกว่า $_SESSION ใช้เพื่อตั้งค่าตัวแปรเซสชัน คุณสามารถรีเซ็ตค่าทั้งหมดที่ตั้งไว้สำหรับตัวแปรเซสชันได้โดยใช้ฟังก์ชัน session_unset()
การดำเนินการเซสชันเราจะดูการดำเนินการต่อไปนี้โดยใช้เซสชัน PHP รวมถึงตัวอย่างการดำเนินการเหล่านี้
- การเริ่มต้นเซสชัน PHP และการตั้งค่าตัวแปรเซสชัน: เซสชัน PHP ใหม่เริ่มต้นโดยใช้ฟังก์ชัน session_start() เมื่อสร้างเซสชันแล้ว ตัวแปรเซสชันสามารถตั้งค่าได้โดยใช้ $_SESSION เราตั้งค่าสำหรับตัวแปร "userID" - "php_user" และ "รหัสผ่าน" - "บทช่วยสอน":
เซสชัน PHP - การสร้าง
ผลลัพธ์: การรันโค้ด PHP ข้างต้นบนเซิร์ฟเวอร์จะสร้างข้อความต่อไปนี้:
- รับค่าของตัวแปรเซสชัน PHP: เป็นไปได้ที่จะรับค่าของตัวแปรที่เราตั้งค่าระหว่างเซสชันการเข้าสู่ระบบ PHP ครั้งล่าสุด เมื่อเราเปิดเซสชัน PHP ที่จุดเริ่มต้นของแต่ละหน้า (session_start()) จะต้องระบุโค้ดด้านล่างนี้ เราดึงและแสดงค่าเหล่านี้โดยใช้ตัวแปรโกลบอล $_SESSION:
เซสชัน PHP - รับค่า
ผลลัพธ์: เมื่อเรารันโค้ด PHP ข้างต้นบนเซิร์ฟเวอร์ เราจะได้รับข้อความต่อไปนี้ ค่าของตัวแปรเซสชันที่เราตั้งค่าไว้ก่อนหน้านี้หลังจากสร้างเซสชัน PHP จะปรากฏขึ้น
- การอัพเดตค่าของตัวแปรเซสชัน PHP: ในระหว่างเซสชัน คุณสามารถอัปเดตค่าของตัวแปรได้ ก่อนอื่น เราต้องเปิดเซสชัน PHP ที่จุดเริ่มต้นของแต่ละหน้า (session_start()) ในโค้ดด้านล่าง เราอัปเดตค่าของตัวแปร “userID” - “new_php_user” และ “รหัสผ่าน” - “การศึกษา”
คุณสามารถพิมพ์อาร์เรย์ของตัวแปรเซสชันและค่าของมันได้โดยใช้ฟังก์ชัน print_r($ _SESSION) ดังที่แสดงด้านล่าง:
เซสชัน PHP - การเปลี่ยนค่า
ผลลัพธ์: เมื่อเรารันโค้ด PHP ข้างต้นบนเซิร์ฟเวอร์ เราจะได้รับข้อความต่อไปนี้ โดยจะมีอาร์เรย์ของตัวแปรเซสชันพร้อมค่าใหม่
ขอให้มีวันดีๆ นะทุกคน นี่เป็นบทความแรกในชุด PHP สำหรับนักพัฒนามือใหม่ นี่จะเป็นบทความชุดที่ไม่ธรรมดาจะไม่มีเสียงก้อง "Hello World" ชีวิตของโปรแกรมเมอร์ PHP จะฮาร์ดคอร์โดยมีส่วนผสมของ "การบ้าน" เล็กน้อยเพื่อรวมเนื้อหา
ฉันจะเริ่มต้นด้วยเซสชัน นี่เป็นหนึ่งในองค์ประกอบที่สำคัญที่สุดที่คุณจะต้องร่วมงานด้วย หากไม่เข้าใจหลักการทำงานของมัน คุณจะทำสิ่งต่างๆ เสียหาย ดังนั้นเพื่อหลีกเลี่ยงปัญหาฉันจะพยายามพูดถึงความแตกต่างที่เป็นไปได้ทั้งหมด
แต่ก่อนอื่น เพื่อทำความเข้าใจว่าทำไมเราถึงต้องมีเซสชัน เรามาพูดถึงต้นกำเนิด - โปรโตคอล HTTP กันก่อน
โปรโตคอล HTTPโปรโตคอล HTTP คือ HyperText Transfer Protocol - "โปรโตคอลการถ่ายโอนไฮเปอร์เท็กซ์" - เช่น โดยพื้นฐานแล้ว มันเป็นโปรโตคอลข้อความ และมันก็เข้าใจได้ไม่ยาก
ในตอนแรกตั้งใจว่าจะส่งเฉพาะ HTML เท่านั้นผ่านโปรโตคอลนี้ รวมถึงชื่อด้วย แต่ตอนนี้พวกเขาไม่ส่งอะไรเลย（ _ㅅ_ ）=^.^=
เพื่อไม่ให้เป็นการวุ่นวาย ฉันขอยกตัวอย่างการสื่อสารผ่านโปรโตคอล HTTP นี่คือคำขอที่เบราว์เซอร์ของคุณส่งเมื่อคุณขอหน้า http://example.com:
GET / HTTP/1.1 Host: example.com ยอมรับ: text/html ...บรรทัดว่าง...
นี่คือตัวอย่างของการตอบกลับ:
HTTP/1.1 200 ตกลง ความยาวเนื้อหา: 1983 ประเภทเนื้อหา: ข้อความ/html; ชุดอักขระ=utf-8 ... ...
นี่เป็นตัวอย่างที่เรียบง่ายมาก แต่คุณสามารถดูได้ว่าคำขอ HTTP และการตอบกลับประกอบด้วยอะไรบ้าง:
ดูเหมือนว่าเราจะเข้าใจโปรโตคอลแล้ว - มันง่าย ๆ ประวัติของมันย้อนกลับไปในปี 1992 ดังนั้นคุณไม่สามารถเรียกมันว่าอุดมคติได้ แต่มันคืออะไร - ส่งคำขอ - รับการตอบกลับ เพียงเท่านี้ เซิร์ฟเวอร์และ ลูกค้าไม่ได้เชื่อมต่ออีกต่อไปในทางใดทางหนึ่ง แต่สถานการณ์ดังกล่าวไม่ใช่สถานการณ์เดียวที่เป็นไปได้ เราอาจได้รับอนุญาต เซิร์ฟเวอร์ต้องเข้าใจว่าคำขอนี้มาจากผู้ใช้รายใดรายหนึ่ง เช่น ลูกค้าและเซิร์ฟเวอร์จะต้องสื่อสารภายในเซสชันที่กำหนด และใช่ พวกเขาคิดกลไกขึ้นมาเพื่อสิ่งนี้:
ในการใช้กลไกนี้ (คุกกี้ คุกกี้) ถูกสร้างขึ้น - ไฟล์ข้อความธรรมดาบนคอมพิวเตอร์ของคุณ หนึ่งไฟล์สำหรับแต่ละโดเมน (แม้ว่าเบราว์เซอร์บางตัวจะล้ำหน้ากว่าและใช้ฐานข้อมูล SQLite เพื่อจัดเก็บ) ในขณะที่เบราว์เซอร์กำหนดขีดจำกัดจำนวน ของบันทึกและขนาดของข้อมูลที่จัดเก็บ (สำหรับเบราว์เซอร์ส่วนใหญ่คือ 4096 ไบต์ ดู RFC 2109 จากปี 1997)
เหล่านั้น. หากคุกกี้ถูกขโมยจากเบราว์เซอร์ของคุณ เป็นไปได้ไหมที่จะเข้าสู่หน้า Facebook ของคุณในนามของคุณ? ไม่ต้องกังวล คุณไม่สามารถทำเช่นนี้ได้ อย่างน้อยกับ Facebook จากนั้นฉันจะสอนวิธีป้องกันตัวเองจากการโจมตีผู้ใช้ประเภทนี้
ตอนนี้เรามาดูกันว่าการตอบกลับคำขอของเราเปลี่ยนแปลงไปอย่างไรหากได้รับอนุญาต:
POST /login/ HTTP/1.1 โฮสต์: example.com ยอมรับ: text/html login=Username&password=Userpass
วิธีการของเราเปลี่ยนเป็น POST และการเข้าสู่ระบบและรหัสผ่านจะถูกส่งไปในเนื้อความของคำขอ (หากเราใช้วิธีการ GET สตริงคำขอจะมีข้อมูลการเข้าสู่ระบบและรหัสผ่าน และอาจจบลงด้วยการบันทึกไว้ในพร็อกซีเซิร์ฟเวอร์ระดับกลางบางตัว ซึ่งแย่มาก)
HTTP/1.1 200 ตกลง ประเภทเนื้อหา: text/html; charset=utf-8 ชุดคุกกี้: KEY=VerySecretUniqueKey ... ...
การตอบสนองของเซิร์ฟเวอร์จะมีส่วนหัว Set-Cookie: KEY=VerySecretUniqueKey ซึ่งจะบังคับให้เบราว์เซอร์บันทึกข้อมูลนี้ในคุกกี้ และในครั้งต่อไปที่ติดต่อกับเซิร์ฟเวอร์ เซิร์ฟเวอร์จะส่งและรับรู้ข้อมูลนั้น:
GET / HTTP/1.1 โฮสต์: example.com ยอมรับ: text/html คุกกี้: KEY=VerySecretUniqueKey ...สตริงว่าง...
อย่างที่คุณเห็น ส่วนหัวที่ส่งโดยเบราว์เซอร์ (ส่วนหัวคำขอ) และเซิร์ฟเวอร์ (ส่วนหัวการตอบกลับ) นั้นแตกต่างกัน แม้ว่าจะมีบางส่วนที่พบบ่อยสำหรับทั้งคำขอและการตอบกลับ (ส่วนหัวทั่วไป)
เซิร์ฟเวอร์จดจำผู้ใช้ของเราจากคุกกี้ที่ส่ง และจากนั้นจะให้เขาสามารถเข้าถึงข้อมูลส่วนบุคคลได้ ดูเหมือนว่าเราจะจัดการเซสชันและ HTTP เรียบร้อยแล้ว ตอนนี้เราสามารถกลับไปใช้ PHP และฟีเจอร์ต่างๆ ของมันได้แล้ว
PHP และเซสชันฉันหวังว่าคุณจะติดตั้ง PHP บนคอมพิวเตอร์ของคุณแล้ว เพราะ... ฉันจะยกตัวอย่างเพิ่มเติมและจะต้องดำเนินการ
ภาษา PHP ถูกสร้างขึ้นเพื่อให้ตรงกับโปรโตคอล HTTP - เช่น หน้าที่หลักคือการตอบสนองต่อคำขอ HTTP และ "ตาย" เพื่อเพิ่มหน่วยความจำและทรัพยากร ดังนั้นกลไกเซสชันใน PHP จะไม่ทำงานโดยอัตโนมัติ แต่ทำงานด้วยตนเอง และคุณจำเป็นต้องรู้ว่าจะเรียกอะไรและเรียงลำดับอย่างไร
ก่อนอื่นคุณต้อง "เริ่มต้น" เซสชัน - สำหรับสิ่งนี้เราจะใช้ฟังก์ชัน session_start() สร้างไฟล์ session.start.phpโดยมีเนื้อหาดังนี้
Session_start();
และตอนนี้เรารีเฟรชหน้าและเราเห็นว่าเบราว์เซอร์ส่งคุกกี้นี้ไปยังเซิร์ฟเวอร์ คุณสามารถลองรีเฟรชหน้าได้สองสามครั้งผลลัพธ์จะเหมือนกัน:
สิ่งที่เรามีคือทฤษฎีนั้นเกิดขึ้นพร้อมกับการปฏิบัติ และนี่ก็เยี่ยมมาก
ขั้นตอนต่อไปคือการบันทึกค่าที่กำหนดเองลงในเซสชัน สำหรับสิ่งนี้ใน PHP เราใช้ตัวแปร super-global $_SESSION เราจะประหยัดเวลาปัจจุบัน - สำหรับสิ่งนี้เราจะเรียกฟังก์ชัน date():
Session_start(); $_SESSION["time"] = date("H:i:s"); เสียงสะท้อน $_SESSION["เวลา"];
เรารีเฟรชหน้าและดูเวลาเซิร์ฟเวอร์ รีเฟรชอีกครั้ง - และเวลาได้รับการอัปเดต ตอนนี้ตรวจสอบให้แน่ใจว่าเวลาที่ตั้งค่าไว้ไม่เปลี่ยนแปลงทุกครั้งที่รีเฟรชเพจ:
Session_start(); if (!isset($_SESSION["time"])) ( $_SESSION["time"] = date("H:i:s"); ) echo $_SESSION["time"];
เราอัปเดต - เวลาไม่เปลี่ยนแปลงสิ่งที่จำเป็น แต่ในขณะเดียวกัน เราก็จำได้ว่า PHP กำลังจะตาย ซึ่งหมายความว่ามันจะเก็บเซสชั่นนี้ไว้ที่ใดที่หนึ่ง และเราจะพบที่นี่...
ความลับทุกอย่างก็ชัดเจนตามค่าเริ่มต้น PHP จะจัดเก็บเซสชันไว้ในไฟล์ - คำสั่ง session.save_handler มีหน้าที่รับผิดชอบในเรื่องนี้ มองหาเส้นทางที่ไฟล์ถูกบันทึกไว้ในคำสั่ง session.save_path หรือใช้ฟังก์ชัน session_save_path() เพื่อรับเส้นทางที่ต้องการ
ในการกำหนดค่าของคุณอาจไม่ได้ระบุเส้นทางไปยังไฟล์จากนั้นไฟล์เซสชันจะถูกเก็บไว้ในไฟล์ชั่วคราวในระบบของคุณ - เรียกใช้ฟังก์ชัน sys_get_temp_dir() และค้นหาว่าสถานที่ที่ซ่อนอยู่นี้อยู่ที่ไหน
ดังนั้นไปตามเส้นทางนี้และค้นหาไฟล์เซสชันของคุณ (สำหรับฉันมันคือไฟล์ sess_dap83arr6r3b56e0q7t5i0qf91) ให้เปิดในโปรแกรมแก้ไขข้อความ:
เวลา|s:8:"16:19:51";
ดังที่เราเห็น นี่คือเวลาของเรา นี่เป็นรูปแบบที่ยุ่งยากในการจัดเก็บเซสชันของเรา แต่เราสามารถทำการแก้ไข เปลี่ยนแปลงเวลา หรือเพียงแค่ป้อนบรรทัดใดก็ได้ ทำไมไม่:
เวลา|s:13:"\m/ (@.@) \m/";
ในการแปลงสตริงนี้เป็นอาร์เรย์ คุณต้องใช้ฟังก์ชัน session_decode() สำหรับการแปลงย้อนกลับ - session_encode() - ซึ่งเรียกว่าการทำให้เป็นอนุกรม เฉพาะใน PHP สำหรับเซสชันเท่านั้น - เป็นพิเศษ แม้ว่าคุณจะสามารถใช้การทำให้เป็นอนุกรม PHP มาตรฐานได้ - เขียนไว้ในคำสั่งการกำหนดค่าเซสชัน .serialize_handler php_serialize value แล้วคุณจะมีความสุข และ $_SESSION สามารถใช้ได้โดยไม่มีข้อจำกัด - ตอนนี้คุณสามารถใช้ตัวเลขและอักขระพิเศษเป็นดัชนี | และ! ในนาม (ตลอดการทำงานมากกว่า 10 ปี ไม่เคยจำเป็นเลย :)
ออกกำลังกาย
เขียนฟังก์ชันของคุณเอง ซึ่งคล้ายกับฟังก์ชันการทำงานกับ session_decode() นี่คือชุดข้อมูลทดสอบสำหรับเซสชัน (ไม่จำเป็นต้องมีความรู้เกี่ยวกับนิพจน์ทั่วไป) นำข้อความสำหรับการแปลงจากไฟล์ของเซสชันปัจจุบันของคุณ:
$_SESSION["จำนวนเต็ม var"] = 123; $_SESSION["float var"] = 1.23; $_SESSION["เลขฐานแปด"] = 0x123; $_SESSION["string var"] = "สวัสดีชาวโลก"; $_SESSION["array var"] = ["หนึ่ง", "สอง", ]; $object = ใหม่ stdClass(); $object->foo = "บาร์"; $object->arr = ["สวัสดี", "โลก"]; $_SESSION["วัตถุ var"] = $วัตถุ; $_SESSION["จำนวนเต็มอีกครั้ง"] = 42;
แล้วเรายังไม่ได้ลองอะไรอีกล่ะ? ถูกต้อง - ขโมยคุกกี้ มาเปิดเบราว์เซอร์อื่นและเพิ่มคุกกี้เดียวกันลงไป ฉันเขียนจาวาสคริปต์ง่ายๆ ให้คุณสำหรับสิ่งนี้ คัดลอกไปยังคอนโซลเบราว์เซอร์ของคุณแล้วรัน เพียงอย่าลืมเปลี่ยนตัวระบุเซสชันเป็นของคุณเอง:
Javascript:(function())(document.cookie="PHPSESSID=dap83arr6r3b56e0q7t5i0qf91;path=/;";window.location.reload();))()
ตอนนี้เบราว์เซอร์ทั้งสองกำลังดูเซสชันเดียวกัน ฉันได้กล่าวไปแล้วว่าฉันจะพูดถึงวิธีการป้องกันลองพิจารณาวิธีที่ง่ายที่สุด - เราจะผูกเซสชันกับเบราว์เซอร์โดยแม่นยำยิ่งขึ้นกับวิธีการนำเสนอเบราว์เซอร์ไปยังเซิร์ฟเวอร์ - เราจะจดจำ User-Agent และตรวจสอบทุกครั้ง : :
Session_start(); if (!isset($_SESSION["time"])) ( $_SESSION["ua"] = $_SERVER["HTTP_USER_AGENT"]; $_SESSION["time"] = date("H:i:s"); ) if ($_SESSION["ua"] != $_SERVER["HTTP_USER_AGENT"]) ( die("เบราว์เซอร์ผิด"); ) echo $_SESSION["time"];
นี่เป็นเรื่องยากที่จะปลอมแปลง แต่ก็ยังเป็นไปได้ เพิ่มการบันทึกและการตรวจสอบของ $_SERVER["REMOTE_ADDR"] และ $_SERVER["HTTP_X_FORWARDED_FOR"] ที่นี่ และสิ่งนี้จะคล้ายกับการป้องกันจากผู้โจมตีที่บุกรุกเข้ามา " คุกกี้”.
คำหลักในย่อหน้าก่อนหน้านี้คล้ายกัน ในโครงการจริงคุกกี้มีการ "ทำงาน" ผ่านโปรโตคอล HTTPS มานานแล้ว ดังนั้นจึงไม่มีใครสามารถขโมยคุกกี้เหล่านี้ได้โดยไม่ต้องเข้าถึงคอมพิวเตอร์หรือสมาร์ทโฟนของคุณ
ออกกำลังกาย
เพิ่มการตรวจสอบรหัสสำหรับ IP ของผู้ใช้ หากการตรวจสอบล้มเหลว ให้ลบเซสชันที่ถูกบุกรุก
ตอนนี้ ผมจะอธิบายขั้นตอนวิธีการทำงานของเซสชันใน PHP ทีละขั้นตอน โดยใช้โค้ดต่อไปนี้เป็นตัวอย่าง (การตั้งค่าเริ่มต้น):
Session_start(); $_SESSION["id"] = 42;
- หากไม่พบ เราจะสร้างไฟล์ว่างชื่อ sess_($_COOKIE) (ตัวระบุสามารถมีได้เฉพาะอักขระจากช่วง a-z , A-Z , 0-9 เครื่องหมายจุลภาคและเครื่องหมายลบ)
- ค้นหา อ่านไฟล์ และแตกข้อมูล (ดู session_decode()) ลงในตัวแปร super-global $_SESSION
ออกกำลังกาย
ตั้งค่าเบราว์เซอร์ของคุณเป็นค่าคุกกี้ที่กำหนดเองชื่อ PHPSESSID ให้เป็น 1234567890 รีเฟรชหน้า ตรวจสอบว่าคุณได้สร้างไฟล์ใหม่ sess_1234567890
PHP สามารถทำงานร่วมกับเซสชันได้แม้ว่าคุกกี้จะถูกปิดใช้งานในเบราว์เซอร์ แต่ URL ทั้งหมดบนไซต์จะมีพารามิเตอร์พร้อมกับตัวระบุเซสชันของคุณ และใช่ - สิ่งนี้ยังจำเป็นต้องได้รับการกำหนดค่า แต่คุณต้องการหรือไม่ ฉันไม่จำเป็นต้องใช้สิ่งนี้ แต่ถ้าคุณต้องการจริงๆ ฉันจะบอกคุณว่าจะขุดที่ไหน:
จะทำอย่างไรถ้าคุณต้องการจัดเก็บเซสชันไว้ในฐานข้อมูล?ในการจัดเก็บเซสชันในฐานข้อมูล คุณจะต้องเปลี่ยนที่เก็บข้อมูลเซสชันและบอก PHP ถึงวิธีการใช้งาน อินเทอร์เฟซ SessionHandlerInterface และฟังก์ชัน session_set_save_handler ได้ถูกสร้างขึ้นเพื่อจุดประสงค์นี้
ฉันต้องการทราบว่าคุณไม่จำเป็นต้องเขียนตัวจัดการเซสชันของคุณเองสำหรับ Redis และ Memcache - เมื่อคุณติดตั้งส่วนขยายเหล่านี้ ตัวจัดการที่เกี่ยวข้องจะมาพร้อมกับส่วนขยายเหล่านั้น ดังนั้น RTFM จึงเป็นทุกอย่างของเรา ใช่แล้ว ต้องระบุตัวจัดการก่อนที่จะเรียก session_start() ;)
ออกกำลังกาย
ใช้ SessionHandlerInterface เพื่อจัดเก็บเซสชันใน MySQL ตรวจสอบว่าใช้งานได้หรือไม่
งานที่มีเครื่องหมายดอกจันนี้มีไว้สำหรับผู้ที่คุ้นเคยกับฐานข้อมูลอยู่แล้ว
คำถามที่น่าสนใจ คุณสามารถถามนักพัฒนาที่มีประสบการณ์ได้ - PHP จะลบไฟล์เซสชันที่หมดอายุเมื่อใด คำตอบอยู่ในคู่มืออย่างเป็นทางการ แต่ไม่ชัดเจน ดังนั้นโปรดจำไว้ว่า:
ตัวรวบรวมขยะ (การรวบรวมขยะ) สามารถเริ่มทำงานได้เมื่อมีการเรียกใช้ฟังก์ชัน session_start() ความน่าจะเป็นในการเริ่มต้นขึ้นอยู่กับสองคำสั่ง session.gc_probability และ session.gc_divisor คำสั่งแรกทำหน้าที่เป็นเงินปันผล คำสั่งที่สอง - ตัวหาร และโดย ค่าเริ่มต้นค่าเหล่านี้คือ 1 และ 100 เช่น ความน่าจะเป็นที่ตัวรวบรวมจะถูกเปิดใช้งานและไฟล์เซสชันจะถูกลบคือประมาณ 1%
ออกกำลังกาย
เปลี่ยนค่าของคำสั่ง session.gc_divisor เพื่อให้ตัวรวบรวมขยะทำงานทุกครั้ง ตรวจสอบว่าสิ่งนี้เกิดขึ้น
ข้อผิดพลาดที่มีผลลัพธ์มากกว่าครึ่งล้านใน Google:
ไม่สามารถส่งคุกกี้เซสชันได้ - ส่วนหัวที่ส่งไปแล้ว
ไม่สามารถส่งตัวจำกัดแคชเซสชัน - ส่งส่วนหัวแล้ว
หากต้องการรับไฟล์ ให้สร้างไฟล์ session.error.phpโดยมีเนื้อหาดังนี้
Echo str_pad(" ", ini_get("output_buffering")); session_start();
ในบรรทัดที่สองมี "เวทย์มนตร์" แปลก ๆ - นี่เป็นเคล็ดลับเกี่ยวกับบัฟเฟอร์เอาต์พุต ฉันจะพูดถึงมันในบทความใดบทความหนึ่งต่อไปนี้ ตอนนี้ให้พิจารณาเฉพาะบรรทัดที่มีความยาว 4096 อักขระ ในกรณีนี้คือช่องว่างทั้งหมด
เรียกใช้โดยลบคุกกี้ไปก่อนหน้านี้แล้วคุณจะได้รับข้อผิดพลาดต่อไปนี้แม้ว่าข้อความของข้อผิดพลาดจะแตกต่างกัน แต่สาระสำคัญก็เหมือนกัน - รถไฟออกไปแล้ว - เซิร์ฟเวอร์ได้ส่งเนื้อหาของหน้าไปที่ เบราว์เซอร์ และมันสายเกินไปที่จะส่งส่วนหัว สิ่งนี้จะไม่ทำงาน และตัวระบุเซสชันที่เป็นเจ้าข้าวเจ้าของไม่ปรากฏในคุกกี้ หากคุณพบข้อผิดพลาดนี้ ให้มองหาตำแหน่งที่แสดงข้อความ
ล่วงหน้าอาจเป็นช่องว่างก่อนอักขระในไฟล์ใดไฟล์หนึ่งที่รวมไว้ และโอเค หากเป็นการเว้นวรรค อาจมีอักขระที่ไม่สามารถพิมพ์ได้เช่น BOM ดังนั้นควรระวัง และการติดไวรัสนี้จะไม่ส่งผลต่อคุณ ( ท้ายที่สุดแล้ว ... เสียงหัวเราะแบบโฮเมอร์)
ออกกำลังกาย
เพื่อทดสอบความรู้นี้ ฉันต้องการให้คุณใช้กลไกเซสชันของคุณเองและทำให้โค้ดต่อไปนี้ใช้งานได้:
Require_once "รวม/sess.php"; session_start(); ถ้า (isset($_SESS["id"])) ( echo $_SESS["id"]; ) else ( $_SESS["id"] = 42; )
หากต้องการดำเนินการตามแผน คุณจะต้องมีฟังก์ชัน register_shutdown_function()
สรุปแล้วในบทความนี้ คุณจะได้รับมอบหมายงาน 6 ภารกิจ ซึ่งไม่เพียงแต่เกี่ยวข้องกับการทำงานกับเซสชันเท่านั้น แต่ยังจะแนะนำให้คุณรู้จักกับ MySQL และฟังก์ชันการทำงานกับสตริงด้วย หากต้องการเชี่ยวชาญเนื้อหานี้ คุณไม่จำเป็นต้องมีบทความแยกต่างหาก คู่มือจากลิงก์ที่ให้มาก็เพียงพอแล้ว - จะไม่มีใครอ่านให้คุณ ไปเลย!
ป.ล. หากคุณเรียนรู้สิ่งใหม่จากบทความนี้ขอขอบคุณผู้เขียน - แบ่งปันบทความบนโซเชียลเน็ตเวิร์ก;)
