[Review: แบบทดสอบ 1]
 [อาลี Nahm, Oreoluwa Barbarinsa ลูคัสตาร็อบโบว์] [ฮาร์วาร์มหาวิทยาลัย]
 [นี้เป็น CS50.] [CS50.TV]
 [ลูคัสตา] ยินดีต้อนรับทุกท่าน นี่คือการทบทวนเพื่อการตอบคำถามที่ 1
 เช่นเดียวกับการปฏิเสธความรับผิดชอบนี้ - ผมหมายความว่าเรากำลังจะพยายามที่จะครอบคลุม
 วัสดุมากที่สุดเท่าที่เป็นไปได้ แต่ที่ไม่ได้หมายความว่า
 เรากำลังจะครอบคลุมทุกสิ่งที่สามารถในการตอบคำถามที่ 1
 เพื่อให้แน่ใจว่าคุณยังจะดูที่การบรรยายส่วนทุกอย่างที่คุณสามารถ
 คำถามที่ 1 เป็นไปได้ในวันพุธที่วันพุธ
 เพื่อให้แน่ใจว่าการศึกษา มันเป็นไปได้สวยมากเช่นเดียวกับการทดสอบครั้งแรก
 เกี่ยวกับรูปแบบของมัน แต่ก็อาจเป็นไปได้ยากมาก
 อย่างน้อยเมื่อปีที่แล้วผมเอา 50, ฉันคิดว่ามันเป็นสิ่งที่ยากมาก
 ดังนั้นการศึกษาจำนวนมาก
 

ฉันจะครอบคลุมโครงสร้างข้อมูลและการเข้ารหัส Huffman
 นี่คือสิ่งที่คนจำนวนมากคิดว่าเป็นที่ซับซ้อน
 แต่ฉันจะพยายามที่จะทำให้มันเป็นไปอย่างง่ายดาย
 แรกของทุกสิ่งที่เราต้องการพวกคุณจะรู้ว่าสำหรับการตอบคำถามที่ 1 คือการ
 เข้าใจคำอธิบายแนวความคิดของแต่ละโครงสร้างข้อมูลที่ผมจะนำเสนอ
 นั่นหมายความว่าคุณไม่จำเป็นต้องจริง
 ใช้ตารางแฮชในการตอบคำถามของคุณ 1
 เราไม่ต้องการให้คุณที่จะใช้ตารางแฮชทั้งบางทีเราจะพยายาม
 ที่จะทำให้คุณใช้ฟังก์ชั่นบางอย่าง
 การดำเนินงานที่พบมากที่สุด แต่เราจะไม่ให้คุณใช้ทุกอย่าง
 ดังนั้นจึงเป็นสิ่งสำคัญที่คุณเข้าใจแนวคิดที่อยู่เบื้องหลังโครงสร้างข้อมูลแต่ละ
 และยังให้คุณสามารถที่จะรหัสใน C
 เพียงแค่การดำเนินงานที่พบมากที่สุดที่พวกเขามีโครงสร้างข้อมูลแต่ละ
 และยังสามารถตรวจสอบตัวชี้และ structs,
 เพราะพวกเขาปรากฏมากในโครงสร้างข้อมูลเหล่านี้
 รายการ 

แรกที่เชื่อมโยง รายการที่เชื่อมโยงเป็นจริงคล้ายกับอาร์เรย์
 แต่ความแตกต่างระหว่างรายการที่เชื่อมโยงและอาเรย์,
 แรกของทั้งหมดคือรายการที่เชื่อมโยงมีขนาดความยืดหยุ่นมาก
 ในขณะที่ในอาร์เรย์ที่คุณต้องเลือกอย่างใดอย่างหนึ่งที่มีขนาดใหญ่มากสำหรับอาร์เรย์
 เพื่อให้คุณรู้ว่าคุณจะสามารถที่จะเก็บข้อมูลทั้งหมดของคุณในแถวที่
 หรือคุณต้องใช้ malloc ที่จะมีระยะเวลาที่มีความยืดหยุ่นของอาร์เรย์
 ในรายการที่เชื่อมโยงเป็นเรื่องง่ายมากที่จะได้รับเพียงแค่องค์ประกอบเพิ่มเติม
 ใส่องค์ประกอบมากขึ้นในรายการที่เชื่อมโยงหรือลบองค์ประกอบ
 และอันที่จริงถ้าคุณไม่ต้องการรายการที่เชื่อมโยงที่จะเรียงลำดับ
 คุณสามารถค้นหาและลบองค์ประกอบในเวลาคงที่
 ดังนั้น O (1) เวลาจึงเป็นความสะดวกสบายมาก
 คุณเพียงแค่จะต้องระมัดระวังที่จะจำไว้เสมอเพื่อ malloc และฟรีโหนด,
 เพียงเพราะถ้าคุณทำไม่ได้คุณจะมีการรั่วไหลของหน่วยความจำ
 รายการเชื่อมโยงเพื่อ - นิยามของโหนดเป็นเช่นเดียวกับสิ่งที่เรามีอยู่ที่นั่น
 ฉันใส่ int n, แต่คุณสามารถจัดเก็บข้อมูลที่คุณต้องการ
 ดังนั้นหากคุณต้องการที่จะเก็บสตริงก็ปรับ
 ถ้าคุณต้องการที่จะเก็บ struct ก็ปรับสองสิ่งที่คุณต้องการ
 ฉันเพียงแค่ใส่ int n ตัวอย่างที่นี่
 และคุณมีตัวชี้ไปยังโหนดถั​​ดไป
 ดังนั้นโดยทั่วไปรายการที่เชื่อมโยงมีข้อมูลบางส่วนและจากนั้นชี้ไปยังโหนดถั​​ดไป
 ถ้ามันเป็นองค์ประกอบสุดท้ายในรายการที่เชื่อมโยงก็จะชี้ไปที่ NULL
 ดังนั้นนี่คือตัวอย่างของรายการที่เชื่อมโยง
 

Okay ดังนั้นตอนนี้เรามาดูสิ่งที่เราควรทำอย่างไรถ้าฉันต้องการแทรกองค์ประกอบในรายการที่เชื่อมโยง
 ขั้นแรกให้ใส่ฟังก์ชั่นจะเป็นชนิดเป็นโมฆะ
 เพราะผมไม่ต้องการที่จะกลับอะไร
 และฉันจะใช้ int เป็นอาร์กิวเมนต์
 เพราะผมต้องการที่จะรู้ว่าสิ่งที่ฉันต้องการที่จะแทรก
 ดังนั้นสิ่งที่เป็นสิ่งแรกที่ฉันควรทำอย่างไร ดีฉันควร malloc ใน newnode,
 เพื่อให้เป็นบรรทัดแรก
 ฉันเพียงแค่การสร้างโหนดใหม่จะใส่ในรายการที่เชื่อมโยง
 ดังนั้นสิ่งที่ฉันจะทำอย่างไร ดีเรารู้ว่าในการใช้งานของเราในรายการที่เชื่อมโยง
 ในชั้นเรียนของเรามักจะใส่หัวเป็นตัวแปรทั่วโลก
 ดังนั้นสิ่งที่เราสามารถทำได้คือการเปลี่ยนหัว
 ฉันจะทำให้โหนดใหม่นี้เป็นหัวหน้าใหม่
 และก็จะชี้ไปที่หัวก่อนหน้านี้
 วิธีที่เราสามารถทำเช่นนั้น สิ่งแรกที่ผมต้องทำ
 คือการเปลี่ยน 'n' ในโหนดใหม่สู่
 ซึ่งได้รับการส่งผ่านไปยังฟังก์ชั่น
 แล้ว newnode ต่อไปจะเป็นหัว
 หัวเป็นไปได้ newnode ดังนั้นจึงเป็นเรื่องง่ายสวย
 สำหรับการลบโหนดที่เราสามารถทำมันได้เช่น -
 วิธีหนึ่งที่เราจะทำคือการพูดว่า
 โอเคถ้าผมต้องการที่จะลบเช่น, 3,
 สิ่งที่ผมจะทำคือเพียงแค่ชี้โหนดก่อนหน้า
 ไปโหนดถั​​ดไปจาก 3
 ดังนั้นผมก็จะทำสิ่งที่ต้องการที่
 แต่สิ่งที่เป็นปัญหากับการทำว่า?
 ฉันมีหน่วยความจำรั่วดังนั้นผมจึงไม่ได้มีการเข้าถึงไปยังหมายเลข 3 อีกต่อไป
 ปัญหาเกี่ยวกับการที่เป็นที่ฉันไม่ได้ไปเพื่อให้สามารถที่จะเป็นอิสระโหนดที่
 ฉันจะมีหน่วยความจำรั่วและ (อ่านไม่ออก) จะเกลียดฉัน
 ดังนั้นแทนที่จะทำเช่นนั้นผมอาจจะมีตัวชี้ชั่วคราว
 ดังนั้นผมจึงใส่ชั่วคราว มันเป็นไปที่จะชี้ไปยังโหนดที่ฉันต้องการที่จะลบ
 แล้วฉันจะย้ายโหนดก่อนหน้านี้เพื่อชี้ไปที่โหนดถั​​ดไป
 ของโหนดที่ฉันต้องการที่จะลบ
 และในที่สุดผมสามารถฟรีตัวชี้
 ฉันต้องปลดปล่อยตัวชี้ที่ฉันสร้างขึ้นที่นั่นหรือไม่
 ฉันไม่จำเป็นต้องเพียงเพราะ -
 ความแตกต่างคือโหนดนี้ถูกสร้างโดยใช้ malloc,
 ดังนั้นจึงเป็นเรื่องในกองขณะที่หนึ่งนี้มีการประกาศเช่นเดียวกับสวิทช์โมฆะในกอง ดังนั้นผมจึงไม่จำเป็นต้องเป็นอิสระ
 เอาล่ะ 

ดังนั้นตอนนี้เราจะมาพูดคุยเกี่ยวกับกอง
 กองอยู่ที่ตรงไปตรงสวย
 เราได้กองและรอคิวอยู่ในระดับเพียงแค่ใช้อาร์เรย์
 แต่คุณควรจะคุ้นเคย - เพียงแค่จะตระหนักถึง
 ที่คุณยังสามารถทำกองอยู่ในคิวใช้รายการการเชื่อมโยงเช่นกัน
 ดังนั้นหากคุณมีอาร์เรย์สิ่งที่จะเป็นกองหรือไม่
 สแต็คเป็นครั้งแรกจะต้องมีขนาด
 คุณมีการจัดเก็บสิ่งที่เป็นขนาดของสแต็คที่คุณมีในขณะนี้
 และคุณจะมีอาร์เรย์ในกรณีของตัวเลขนี้
 แต่ถ้าคุณต้องการที่จะสามารถอาร์เรย์
 ของสตริงอาร์เรย์ของโครงสร้างสิ่งที่คุณต้องการในการจัดเก็บ
 เกี่ยวกับสแต็ค: ความแตกต่างระหว่างกองและรายการที่เชื่อมโยง
 ที่อยู่ในกองคุณมีการเข้าถึงองค์ประกอบสุดท้ายที่ถูกขังอยู่ในกองเท่านั้น
 มันเรียกว่าสุดท้ายในครั้งแรกออก
 เช่นเดียวกับที่คุณมีสแต็คของถาด,
 ถ้าคุณใส่ถาดด้านบนของกองที่
 คุณต้องเอาถาดที่แรกที่จะมีการเข้าถึงถาดอื่น ๆ
 มันเป็นสิ่งเดียวกันกับกอง
 ดังนั้นถ้าผมต้องการที่จะยกตัวอย่างเช่นการเพิ่มองค์ประกอบไปยังกองสิ่งที่ฉันควรทำอย่างไร
 มันเรียกว่าการผลักดันและก็ตรงไปตรงสวย
 สิ่งแรกที่คุณต้องทำคือการตรวจสอบถ้าขนาดของสแต็ค
 ไม่ได้มากกว่าหรือเท่ากับความจุของสแต็ค
 เพราะถ้าคุณอยู่แล้วกับความสามารถเต็มรูปแบบที่คุณไม่สามารถเพิ่มอะไรอีก
 แล้วถ้าไม่ได้คุณก็ต้องเพิ่มองค์ประกอบไปยังกอง
 และในที่สุดเพิ่มขนาด ดังนั้นจึงเป็นเรื่องตรงไปตรงสวย
 ดังนั้นฉันเพียงแค่เพิ่มจำนวน 2
 และถ้าผมต้องการที่จะปรากฏซึ่งหมายความว่าฉันต้องการที่จะลบ
 องค์ประกอบสุดท้ายที่ถูกเพิ่มเข้ามาและกลับค่าขององค์ประกอบที่
 สิ่งแรกที่ผมต้องตรวจสอบว่าสแต็คไม่ว่างเปล่า
 เพราะถ้ามันว่างเปล่าฉันไม่สามารถกลับอะไร
 ในกรณีที่ผมกลับ -1
 มิฉะนั้นฉันจะพร่องขนาดของข้อมูลจำเพาะที่
 และกลับตัวเลข (s.size)
 ทำไมฉันไม่พร่องขนาดและแล้วกลับ s.size?
 มันเป็นเพราะในกรณีนี้สเปคมีขนาด 4
 และผมต้องการที่จะกลับไปที่สี่องค์ประกอบใช่ไหม
 แต่สิ่งที่เป็นดัชนีขององค์ประกอบที่สี่คืออะไร สาม
 เพราะผมไม่ขนาด - เป็นไปได้ 3 ผมก็สามารถกลับ s.numbers (s.size)
 เพราะมันเป็น 3 จึงเป็นเพียงดัชนี
 

ตอนนี้คิว คิวจะสวยมากในสิ่งเดียวกัน
 ความแตกต่างเพียงอย่างเดียวคือแทนที่จะต้องผ่านในครั้งแรกออก
 คุณมีครั้งแรกในครั้งแรกออก
 อาจถ้าคุณกำลังรอคอยที่จะไปคอนเสิร์ต
 คุณจะไม่ได้มีความสุขถ้าคุณมีกองแทนคิว
 เป็นคนสุดท้ายที่จะมาจะเป็นคนแรกที่จะเข้าสู่คอนเสิร์ต
 คุณอาจจะไม่ได้มีความสุข
 ในคิวเป็นคนแรกที่จะได้รับในยังเป็นคนแรกที่จะได้รับการออก
 ดังนั้นในความหมายของคิวที่นอกเหนือจากที่มีขนาดในอาร์เรย์
 คุณยังต้องมีหัวซึ่งเป็นดัชนีที่หัวของสแต็ค
 ดังนั้นองค์ประกอบแรกในตอนนี้
 enqueue เป็นสิ่งเดียวกับที่ผลักดันให้กอง
 ถ้าคุณได้ไร้เดียงสามากคุณก็จะพูดว่า
 ดีฉันก็สามารถทำตรงสิ่งเดียวกับผมสำหรับการผลักดัน
 ฉันสามารถตรวจสอบว่ามันไม่ได้เกินความจุ
 ถ้าเป็นผมกลับเท็จอย่างอื่นผมก็สามารถส่งออกค่าใหม่
 แล้วเพิ่มขนาด
 แต่เหตุผลนี้เป็นที่ไม่ถูกต้อง
 ลองมาดูตัวอย่างนี้
 ฉันพยายามที่จะ enqueue พวงของสิ่งที่
 แล้วฉันจะ dequeue และ enqueue
 มีจำนวนมากของคำสั่ง แต่มันง่ายมาก
 ฉันจะ enqueue 5 เพื่อเพิ่ม 5 และ 7
 1, 4, 6, และจากนั้นผมต้องการที่จะ dequeue บางสิ่งบางอย่าง
 ซึ่งหมายความว่าฉันจะเอาองค์ประกอบแรก
 ดังนั้นฉันจะลบหมายเลข 3 ใช่ไหม
 องค์ประกอบแรก ถูก
 ตอนนี้ถ้าฉันพยายามที่จะ enqueue สิ่งอื่นสิ่งที่จะเกิดขึ้นได้อย่างไร
 ตามที่การดำเนินงานของฉัน
 ผมจะใส่หมายเลขถัดไปใน q.size ดัชนี
 ในกรณีนี้ขนาดคือ 8,
 ดังนั้นดัชนีที่ 8 จะได้รับสิทธิที่นี่ในตำแหน่งสุดท้าย
 ถ้าฉันพยายามที่จะ enqueue 1 ที่นี่ผมจะเขียนทับตำแหน่งสุดท้าย
 จำนวน 1 ซึ่งเป็นสิ่งที่ผิดอย่างสมบูรณ์
 สิ่งที่ฉันต้องการจะทำคือการห่อรอบและไปที่ตำแหน่งแรก
 บางทีคุณก็จะบอกว่าดีฉันเพียงแค่มีการตรวจสอบ
 ถ้าจริงผมสามารถนำสิ่งที่มี
 ถ้าไม่ผมก็บอกว่าโอ้เต็มกำลังการผลิตใหม่
 เป็นจริงความจุ - 1, และคุณไม่สามารถใส่องค์ประกอบที่มี
 แต่สิ่งที่เป็นปัญหาได้หรือไม่ ปัญหาคือว่าถ้าฉันเพียงแค่ dequeue ทุกอย่างที่นี่
 แล้วฉันพยายามที่จะเพิ่มอย่างอื่นมันก็จะพูดว่า
 ดีคุณอยู่ที่ความจุเต็มซึ่งเป็น 0
 ดังนั้นคิวของคุณจะหายไป
 คุณต้องห่อรอบและวิธีการห่อรอบ
 ที่พวกคุณได้เรียนรู้ใน psets มีวิสัยทัศน์และอื่น ๆ ที่ใช้ mod
 คุณสามารถทดลองใช้งานได้ที่บ้านจะเข้าใจว่าทำไมคุณจะทำ q.size + q.head
 ความจุ mod แต่ถ้าคุณตรวจสอบที่นี่
 เราจะเห็นว่ามันทำงาน
 ดังนั้นในตัวอย่างที่ผ่านมา q.size 8
 และหัวเป็น 1 เพราะมันเป็นตำแหน่งนี้ที่นี่ของอาร์เรย์
 ดังนั้นมันจะเป็น 8 + 1, 9 ความจุ Mod 9 จะเป็น 0
 มันจะไปที่ดัชนี 0 เราจะอยู่ในตำแหน่งที่เหมาะสม แล้วลองคิวที่บ้าน
 บางสิ่งที่สำคัญพยายามที่จะเข้าใจความแตกต่างระหว่างสแต็คและคิว
 ที่บ้านพยายามที่จะได้รับความคุ้นเคยกับการใช้ enqueue, dequeue ดัน, และป๊อป
 และยังเข้าใจเมื่อคุณจะใช้ในแต่ละของพวกเขา
 

เพื่อขอผ่อนคลายเป็นเวลา 10 วินาทีมีพวงของ Pokemons
 และตอนนี้ขอกลับไปยังโครงสร้างข้อมูล
 ตารางแฮช ผู้คนจำนวนมากได้รับการกลัวของตารางแฮช
 ปัญหาในการตั้งค่า 6 ตรวจสอบการสะกด
 ตารางแฮชและพยายามที่คนจำนวนมากได้กลัวของพวกเขา
 พวกเขาคิดว่าพวกเขากำลังดังนั้นยากที่จะเข้าใจ ใช่?
 [ร็อบโบว์] ปัญหาชุดที่ 5 

ปัญหาชุด 5 ใช่ ขอบคุณร็อบ
 ใช่ หกเป็นหอบ n 'พัฟใช่
 ปัญหาชุดที่ 5 ได้รับการตรวจสอบการสะกดและคุณต้องใช้อย่างใดอย่างหนึ่งตารางแฮชหรือลอง
 ผู้คนจำนวนมากคิดว่าพวกเขาเป็นสุดยากที่จะเข้าใจ แต่พวกเขากำลังจริงง่ายๆสวย
 คืออะไรตารางแฮชโดยทั่วไป? ตารางแฮชเป็น array ของรายการเชื่อมโยง
 ข้อแตกต่างระหว่างอาร์เรย์และตารางแฮช
 ที่อยู่ในตารางแฮชที่คุณมีสิ่งที่เรียกว่าฟังก์ชันแฮช
 ฟังก์ชันแฮชคืออะไร
 ผมไม่ทราบว่าถ้าพวกคุณสามารถอ่านที่นี่
 นี่คือตัวอย่างของตารางแฮช
 ดังนั้นคุณจะเห็นว่าคุณมีอาร์เรย์ที่มี 31 องค์ประกอบ
 และสิ่งที่เราทำในตารางแฮชจะมีฟังก์ชันแฮช
 ที่เป็นไปในการแปลที่สำคัญแต่ละ int ดัชนี
 ถ้ายกตัวอย่างเช่นถ้าผมต้องการที่จะเลือกสำหรับบีแฮร์ริสัน
 ฉันจะใส่บีแฮร์ริสันในฟังก์ชันแฮชของฉัน
 และฟังก์ชันแฮชจะกลับมา 24
 ดังนั้นฉันรู้ว่าฉันต้องการเก็บบีแฮร์ริสันใน 24
 เพื่อให้เป็นความแตกต่างระหว่างการมีเพียงแค่อาร์เรย์และมีตารางแฮช
 ในตารางแฮชคุณจะมีฟังก์ชั่นที่จะบอกคุณ
 ที่ในการจัดเก็บข้อมูลที่คุณต้องการเก็บ
 สำหรับฟังก์ชันแฮชที่คุณต้องการที่จะมองหาฟังก์ชันแฮช
 ที่กำหนดและมีการกระจาย
 ในขณะที่คุณสามารถดูที่นี่คุณจะเห็นว่าจำนวนมากของข้อมูลที่ผมอยากจะเก็บเป็นจริง 19
 แทนการใช้ 31 และ 30 และ 29 ซึ่งเป็นฟรีทั้งหมด
 ดังนั้นฟังก์ชันแฮชที่ผมใช้ก็ไม่ได้เป็นอย่างดีกระจาย
 เมื่อเราพูดกันกระจายก็หมายความว่าเราต้องการที่จะมี
 ประมาณอย่างน้อย 1 หรือ 2 สำหรับแต่ละ -
 เช่นความแตกต่างของ 1 หรือ 2 สำหรับแต่ละดัชนีในอาร์เรย์
 คุณต้องการที่จะมีประมาณจำนวนเดียวกันขององค์ประกอบในรายการที่เชื่อมโยงในแต่ละแถว
 และมันก็เป็นเรื่องง่ายที่จะตรวจสอบว่าเป็นที่ถูกต้องในตารางแฮชให้ดูเป็นตารางแฮช
 

แล้วต้นไม้ นี้เป็นต้นไม้
 ต้นไม้ในวิทยาศาสตร์คอมพิวเตอร์คว่ำลงด้วยเหตุผลบางอย่าง
 ดังนั้นที่นี่คุณมีรากของต้นไม้และใบไม้
 คุณก็ควรจะรู้ว่าศัพท์เฉพาะสำหรับผู้ปกครองและเด็ก
 แต่ละโหนดมีลูกของตนซึ่งเป็นโหนดที่อยู่ด้านล่างของผู้ปกครอง
 ดังนั้นสำหรับตัวอย่างเช่น 2 เป็นไปได้ของผู้ปกครองเป็นเวลา 3 และเด็กอื่น ๆ มีสิทธิ
 3 ในขณะที่เป็นไปได้ของผู้ปกครองเป็นเวลา 1 และเด็กคนอื่น ๆ ที่จะมี
 และ 1 เป็นไปได้เด็ก 3 และอื่น ๆ
 เรามีสิ่งที่น่าสนใจอื่น ๆ อีกมากมายที่เรียกว่าต้นไม้ค้นหาไบนารี
 ในการที่ค่าทั้งหมดที่อยู่ด้านขวาของโหนด
 เป็นไปได้ทางด้านขวาที่นี่ - ด้านขวา
 จะเป็นองค์ประกอบที่ยิ่งใหญ่กว่าในราก
 ดังนั้นถ้าฉันมีจำนวน 5 ที่นี่องค์ประกอบทั้งหมดที่อยู่ด้านขวา
 เป็นไปได้มากขึ้นกว่า 5 และทางซ้าย
 องค์ประกอบทั้งหมดที่เป็นไปได้น้อยกว่า 5
 นี่คือเหตุผลที่มีประโยชน์
 ดีถ้าผมต้องการที่จะตรวจสอบว่าหมายเลข 7 ที่นี่ตัวอย่างเช่น
 ผมเพิ่งไปที่ 5 ครั้งแรกและฉันจะเห็นคือ 7 มากหรือน้อยกว่า 5?
 มันเป็นมากขึ้นดังนั้นฉันรู้ว่ามันเป็นไปได้ที่จะอยู่ทางด้านขวาของต้นไม้
 ดังนั้นผมจึงมีสิ่งที่น้อยมากที่จะมองไปที่
 ในการดำเนินการของต้นไม้ค้นหาแบบไบนารีโหนดฉันแค่จะต้องมีข้อมูล
 เพื่อ int n; คุณยังอาจมีสตริง
 หรือสิ่งที่คุณต้องการ
 คุณเพียงแค่จะต้องระมัดระวังเกี่ยวกับการกำหนดสิ่งที่เป็นมากขึ้นสิ่งที่เป็นน้อย
 ดังนั้นถ้าคุณมีสตริงตัวอย่างเช่นคุณสามารถกำหนด
 ว่าสิ่งเหล่านั้นทั้งหมดที่อยู่ด้านขวาจะมีความยาวขนาดใหญ่
 ด้านซ้ายจะมีความยาวที่ลดลงจึงเป็นจริงขึ้นอยู่กับคุณ
 

ฉันสามารถใช้วิธีหา BST?
 สิ่งแรกที่เราจะต้องทำคือการตรวจสอบถ้ารากเป็นโมฆะ
 ถ้าเป็นโมฆะก็หมายความว่าสิ่งที่ไม่ได้มี
 เพราะคุณไม่ได้มีต้นไม้ใช่ไหม
 ดังนั้นผมจึงกลับเท็จ
 มิฉะนั้นฉันจะตรวจสอบว่าเป็นจำนวนที่มากขึ้น
 กว่ามูลค่าในราก
 ฉันจะพยายามที่จะหาองค์ประกอบทางด้านขวา
 ของต้นไม้
 คุณจะเห็นว่าฉันใช้เรียกซ้ำตัวเองที่นี่
 แล้วถ้ามันน้อยกว่าที่ฉันจะไปดูที่ด้านซ้าย
 และในที่สุดมิฉะนั้นถ้ามันไม่ได้น้อยหรือไม่ได้มากขึ้น
 มันหมายถึงว่ามันเป็นค่าตัวของมันเอง
 ดังนั้นฉันเพิ่งกลับจริง
 คุณสามารถดูที่นี่ที่ผมใช้ในกรณีที่ถ้าหาก
 และจำไว้ว่าในการตอบคำถาม 0, เรามีปัญหาที่มีถ้าถ้าหาก,
 และคุณควรจะหาขาดประสิทธิภาพ
 และขาดประสิทธิภาพก็คือการที่คุณใช้ในกรณีที่ คุณควรจะได้ใช้ในกรณีอื่นถ้าหากอื่นและอื่น
 ดังนั้นฉันจึงควรใช้อย่างอื่นถ้าและอื่นถ้าและอื่นที่นี่
 ไม่มีใคร - ใช่?
 [พูดนักศึกษาไม่ได้ยิน]
 นั่นดูวิเศษมาก ดังนั้นเธอจึงบอกว่ามันไม่ได้เรื่อง
 เพียงเพราะความไร้ประสิทธิภาพที่เราเคยมีมาก่อน
 ก็คือว่าเพราะบางทีถ้าเงื่อนไขบางอย่างเป็นที่น่าพอใจ
 เพื่อให้คุณได้ดำเนินการกระทำ แต่แล้วคุณก็จะตรวจสอบทุกเงื่อนไขอื่น ๆ
 แต่ในกรณีนี้มันกลับทันทีเพื่อให้มันไม่ได้เรื่อง
 ดังนั้นคุณจึงไม่จำเป็นต้องใช้อย่างอื่นถ้า
 

และสุดท้ายขอพูดคุยเกี่ยวกับการพยายาม
 ซึ่งเป็นที่ชื่นชอบของทุกคน
 ลองเป็นต้นไม้แห่งอาร์เรย์
 มันรวดเร็วมากในการค้นหาค่า แต่จะใช้จำนวนมากของหน่วยความจำ
 และก็มักจะกรองคำดังนั้นเมื่อคุณ
 ต้องการที่จะใช้ตัวอย่างเช่นผมไม่ทราบเช่นสมุดโทรศัพท์ในโทรศัพท์ของคุณ
 และคุณต้องการเพื่อให้สามารถพิมพ์ B
 และก็มีชื่อของคนที่มีบี
 มันง่ายมากที่จะใช้ว่าการใช้ลองยกตัวอย่างเช่น
 วิธีการทำคุณกำหนดโหนดในลองหรือไม่
 คุณเพียงแค่ต้องมีบูลที่เป็นไปได้ is_word
 ที่แสดงถึงว่าการใช้ตัวอักษรทั้งหมดก่อนที่โหนดที่
 คุณมีความสามารถที่จะสร้างคำ
 แล้วคุณจะมีอาร์เรย์ของตัวชี้ไปยังโหนด
 คุณจะเห็นว่าเรามีอาร์เรย์ของโหนดแม่ดังนั้นโหนด * อาร์เรย์ ใช่?
 ดังนั้นเรามาดูวิธีที่จะทำงาน สำหรับตรวจสอบการสะกด,
 เรามีอาร์เรย์ขององค์ประกอบ 27,
 เพราะเรามีตัวอักษรทั้งหมดรวมทั้งเครื่องหมายวรรคตอน
 ก่อนที่นี่ฉันแค่จะใช้ 2 เพราะผมต้องการที่จะสามารถที่จะเขียนบนกระดาน
 ถูก ดังนั้นนี่คือตัวอย่างของความพยายาม
 ถ้าฉันเพียงแค่กำหนดโหนดแรกผมจะมีอาร์เรย์ของ 2 องค์ประกอบ
 ที่มี 2 ตัวชี้ไปยังโมฆะดังนั้นฉันเพียงแค่ใส่ '' และ 'b'
 และฉันจะมีบูลที่ระบุว่า is_word
 มันจะเป็นเท็จสำหรับคนแรก
 เพียงเพราะก่อนที่คุณจะไม่ได้มีตัวอักษรใด
 ดังนั้นคำว่าว่างไม่ได้เป็นคำ ดังนั้นจึงเป็นเท็จ
 ถ้าผมต้องการที่จะเพิ่ม '' ในพจนานุกรมนี้สิ่งที่ผมจะต้องทำอย่างไร
 ฉันก็จะต้อง malloc โหนดใหม่สำหรับ ''
 แล้วเพิ่มคำที่เป็นจริง
 ดังนั้นมันก็แสดงให้เห็นว่ามี '' เป็นไปได้จริง ทำให้รู้สึก
 แล้วถ้าผมต้องการที่จะเพิ่ม 'ba' ฉันจะต้อง malloc 1 สำหรับ 'b'
 แล้วฉันจะตั้งค่าบูลีนเท็จ
 เพราะ 'b' ด้วยตัวเองไม่ได้เป็นคำ
 แล้วฉันจะ malloc อีกคนหนึ่งสำหรับ '' ดังนั้น 'ba'
 แล้วฉันจะตั้งขึ้นเป็นคำที่เป็นจริง
 เพราะ 'ba' เป็นคำที่
 แล้วถ้าผมต้องการดูว่า 'b' ในพจนานุกรมนี้
 ฉันสามารถไปที่คนแรก 'b' ฉันลงไปและฉันมองไปที่เป็นคำและกล่าวเท็จ
 ดังนั้นจึงไม่เป็นคำ ถ้าผมต้องการที่จะตรวจสอบ 'ba'
 ผมไปคนแรก, 'b' และจากนั้นไปที่ '' และฉันเห็นจริงจึงเป็นคำ ทำให้รู้สึก
 ผู้คนจำนวนมากได้รับการสับสนโดยพยายาม ไม่ได้หรือไม่
 

สุดท้าย Huffman เข้ารหัส Huffman เข้ารหัสเป็นประโยชน์อย่างมาก
 เพื่อบัน​​ทึกความทรงจำและบีบอัดไฟล์ข้อความ
 เพียงเพราะหลายครั้งที่คุณใช้ '' และ 'e',​​ ตัวอย่างเช่น
 ในเอกสารของคุณ แต่ผมไม่ทราบว่าพวกคุณใช้ 'q' หรือ 'ซี' เป็นมาก
 มีเพียง 1 ไบต์สำหรับทุกตัวอักษรเดียว
 ทุกเดียว - 256 ตัวอักษรที่เรามีในตาราง ASCII ไม่เหมาะสมมาก
 เพียงเพราะมีบางตัวละครที่คุณใช้มากขึ้น
 ดังนั้นคุณอาจจะใช้หน่วยความจำน้อยลงสำหรับผู้ที่
 ฉันจะใช้วิธีการเข้ารหัส Huffman?
 ที่เราต้องทำต้นไม้ Huffman
  ต้นไม้ Huffman มีโหนด
 ที่มีสัญลักษณ์ที่เป็นไปได้เช่น ',' ',' b ',' c ', จดหมาย,
 สิ่งที่ตัวอักษรที่คุณมีความถี่ที่เป็นความถี่ที่คำที่ปรากฏในข้อความที่เป็น
 ที่คุณได้รับการสร้างต้นไม้ Huffman สำหรับ
 แล้วโหนดที่จะชี้ไปทางด้านซ้ายของต้นไม้ Huffman
 และโหนดที่จะชี้ไปทางขวาอีก ดังนั้นเช่นเดียวกับต้นไม้
 คุณจะสร้างต้นไม้ Huffman?
 คุณกำลังจะได้รับ 2 โหนดที่มีความถี่ต่ำสุด
 หากคุณมีผูกที่คุณกำลังจะไปรับ 2 โหนด
 ที่มีค่าต่ำสุด ASCII ได้เป็นอย่างดี
 แล้วคุณกำลังจะสร้างต้นไม้ใหม่จากผู้ที่ 2 โหนด
 ที่กำลังจะมีความถี่ในการรวมกันในโหนดแม่
 แล้วคุณจะเอาเด็ก 2 คนจากป่า
 และแทนที่ด้วยผู้ปกครอง
 และคุณกำลังจะทำซ้ำจนกว่าคุณจะมีเพียง 1 ต้นไม้ในป่า
 ดังนั้นเรามาดูวิธีการที่คุณจะทำต้นไม้ Huffman เพื่อ ZAMYLA
 คุณสามารถดูได้ที่นี่ที่ตัวอักษรทั้งหมดมีความถี่ 1 ยกเว้นสำหรับ ''; ที่มีความถี่ 2
 ดังนั้นผมจึงสร้างโหนดสำหรับตัวอักษรทั้งหมดที่ฉันใส่ในคำสั่งของค่า ASCII และความถี่
 ดังนั้นถ้าผมต้องการที่จะสร้างต้นไม้ครั้งแรกก็จะอยู่กับ 'L' และ 'M'
 ดังนั้นจึงเป็นที่นี่ ความถี่ของคู่ที่ 2 จะเป็น
 เพราะมันเป็น 1 + 1 แล้วต่อไป 2 ที่มีความถี่ต่ำสุด 'Y' และ 'Z'
 และจากนั้นฉันมีทั้งหมดของพวกเขาถูก - มีความถี่ของ 2
 ดังนั้นคนที่เป็นคนที่มีค่า ASCII ต่ำสุดสำหรับหนึ่งต่อไปหรือไม่
 'A' และ 'L' ดังนั้นผมจึงสร้างโหนดใหม่
 และในที่สุดก็ถึงที่ 4 และ 2 ดังนั้น 2 เป็นไปได้ทางด้านซ้าย
 และนี่คือต้นไม้ Huffman แล้วถ้าผมต้องการที่จะเขียนข้อความบางอย่าง
 เช่นเลขฐานสองแปลงเป็นข้อความโดยใช้ต้นไม้ Huffman เป็นเรื่องง่ายมาก
 ตัวอย่างเช่นถ้าผมบอกว่าจะย้ายไปอยู่ด้านซ้ายเป็น 0 และจะย้ายไปอยู่ด้านขวาเป็น 1
 คืออะไรที่จะเป็นตัวแทน
 ดังนั้นเช่น 1, 1 ดังนั้นที่ถูกต้องเหมาะสม
 แล้ว 0, ซ้ายเพื่อจะเป็น L แล้ว 1, 0, 0
 ดังนั้น 1, 0 ดังนั้นเพียงแค่ 1, 0, 'A'
 แล้ว 0, 1, ดังนั้น 'Z'
 แล้ว 1, 0, 0 - ไม่
 0, 0 จะเป็น 'Y' ดังนั้นขี้เกียจ
 เพื่อให้ทุกอย่างสำหรับฉันร็อบจะใช้เวลามากกว่า
 

[ร็อบโบว์] ดังนั้นสัปดาห์ 7 สิ่งที่
 เรามีมากไปกว่าอย่างรวดเร็วจริงๆ
 ผู้ประกอบการค่าบิต, หน่วยความจำล้น
 ห้องสมุด CS50 แล้ว HTML, HTTP, CSS
 ในเช่น 15 ถึง 20 นาที
 ผู้ประกอบการค่าบิต มี 6 เป็นของพวกเขาว่าคุณจำเป็นต้องรู้
 บิตและบิตหรือ XOR กะซ้ายกะที่ถูกต้องและไม่ได้
 เปลี่ยนที่ถูกต้องและไม่ได้คุณแทบจะไม่ได้เห็นในการบรรยายที่
 เราจะไปกว่าได้อย่างรวดเร็วที่นี่ แต่มันเป็นเรื่องดีที่จะรู้ว่าเหล่านี้เป็น 6 ที่มีอยู่
 โปรดจำไว้ว่าผู้ประกอบการค่าที่เหมาะสมเป็นเช่นเมื่อคุณทำ 3 + 4
 คุณยังไม่ได้จัดการกับไบนารีของ 3 และ 4
 ค่าที่เหมาะสมกับผู้ประกอบการที่คุณเป็นจริงที่เกี่ยวข้องกับบุคคลบิตของตัวเลขที่ 3 และ 4
 

ดังนั้นคนแรกที่เราจะบอกว่าเป็นค่าที่เหมาะสมไม่ได้
 และทั้งหมดมันไม่สามารถพลิกบิตทั้งหมด
 ดังนั้นที่นี่ถ้าคุณกำลังเขียนใน C คุณจะไม่เขียนมัน
 เป็น ~ 11011 หรือสิ่งที่คุณจะเขียนมันชอบ ~ 4
 และแล้วมันจะพลิกแทน binary จาก 4
 ดังนั้นที่นี่, ~ ของเลขฐานสองบาง 1101101 เป็นไปได้ว่าพลิกทุก 1 ถึง 0 และทั้งหมดของ 0 ถึง 1
 ขณะที่ผมบอกว่ามีการใช้งานบ่อยของนี้
 และเราจะเห็นมันในบิตเป็นเหมือนที่เราต้องการให้เกิดขึ้นกับบางส่วนจำนวน
 ที่ทุกบิตเป็น 1 ยกเว้นหนึ่งของพวกเขา
 ดังนั้นมันจะง่ายในการแสดงจำนวน
 ที่เพียงแค่บิตเดียวที่มีการตั้งค่า
 แล้วนำ ~ ของมันดังนั้นทุกบิตอื่น ๆ จะถูกตั้งค่ายกเว้นหนึ่งที่
 ดังนั้นนั่นคือสิ่งที่เรากำลังจะใช้มากขึ้นในบิต
 

Bitwise หรือ ที่นี่ 2 เลขฐานสองและ 2 ตัวเลขเหล่านี้
 เป็นตัวแทนสวยเนื่องจากพวกเขาเป็นตัวแทนของทุกคนที่เป็นไปได้
 การรวมกันของบิตคุณอาจจำเป็นต้องดำเนินการใน
 ที่นี่เมื่อฉัน or'd แต่ละบิตเรากำลังจะเปรียบเทียบตรงลง
 ดังนั้นทางด้านซ้ายเรามี 1 และ 1
 เมื่อฉันค่าบิต | เหล่านั้นสิ่งที่ฉันจะได้รับ หนึ่ง
 จากนั้นค่าบิต | 0 และ 1 จะให้ผมหรือเปล่า หนึ่ง
 บิต 1 และ 0 เป็นไปได้ในสิ่งเดียวกันอย่างใดอย่างหนึ่ง
 บิต 0 | 0 จะให้ฉัน 0
 ดังนั้นกรณีเดียวที่ฉันจะได้รับ 0 ใน 0 | 0 กรณี
 และคุณอาจจะคิดว่าเช่นเดียวกับ ORS เชิงตรรกะของคุณ
 ดังนั้นหากคุณคิดว่าการที่ 1 เป็นจริงและเป็นเท็จ 0 สิ่งเดียวกันกับที่นี่
 ดังนั้นความจริงที่แท้จริงหรือเป็นความจริง; จริงหรือเท็จเป็นจริง
 เท็จหรือจริงก็เป็นความจริงเท็จหรือเท็จเป็นสิ่งเดียวที่ผิดพลาดจริง
 นี่คือตัวอย่างที่คุณควรรู้คือ
 เป็นตัวอย่างที่ดีงามของผู้ประกอบการเมื่อมีการใช้ค่าบิต
 นี่ถ้าเราหรือทุน 'A' ด้วย OX20,
 และเราจะดูที่เหล่านี้เป็นครั้งที่สองที่เราได้รับบางสิ่งบางอย่าง
 และถ้าเราหรือตัวพิมพ์เล็ก 'กับ OX20 เราได้รับบางสิ่งบางอย่าง
 จึงขอดึงตาราง ASCII
 ถูก ที่นี่เราจะเห็นว่า 'A' เป็น -
 ที่นี่เรามี 'A' เป็นทศนิยม 65
 แต่ฉันจะไปกับเลขฐานสิบหกซึ่งเป็น Ox41
 สวยแน่ใจว่าเราเห็นว่ามันอยู่ในชั้นเรียน ผมคิดว่าเราเห็นว่ามันอยู่ในชั้นเรียน
 ว่ามันเป็นเรื่องง่ายสวยที่จะแปลงจากเลขฐานสิบหกกับเลขฐานสอง
 ดังนั้นที่นี่ถ้าผมต้องการที่จะใส่ลงไปใน 4 ไบนารี
 ที่เพิ่งจะได้รับ 0100
 นี้เป็นสถานที่ 1 ของสถ​​านที่ 2 ที่ 4 ดังนั้นนี้คือ 4
 จากนั้นฉันก็สามารถแยก 1 เป็นเลขฐานสองซึ่งเป็นไปได้ 0001
 และอื่น ๆ นี้จะเป็นตัวแทนของ 'A' ในไบนารี
 การพิมพ์เล็ก '' ก็ตอนนี้ไปได้ Ox61,
 ที่แยกเหล่านี้ขึ้นเป็นไบนารีของดังนั้น 6 -
 ลองทำจริงมัน - คือไม่มียางลบ? ยางลบ
 Ox61 ดังนั้นการแยก 6 เป็นเลขฐานสองเป็นไปได้ 0 + 4 + 2 + 0
 และแยก 1 เป็นไปได้ 0001
 มองไปที่ความแตกต่างระหว่าง 2 เหล่านี้
 เราจะเห็นว่าแตกต่างระหว่างตัวพิมพ์เล็กและทุน 'A' เป็นบิตเดียวนี้
 ดังนั้นกลับไปที่นี่มา - ไม่เป็นไร
 กลับมาที่นี่ถ้าเรามองสิ่งที่บิต OX20 คือ
 แยกเพื่อ OX20 เป็นไบนารีของ
 คือ 0010, 0000
 OX20, บิตเท่านั้นที่ถูกตั้งเป็นบิตที่เรามีความกังวลกับเรื่องนี้
 กับการสลับไปมาระหว่างเมืองหลวงและตัวพิมพ์เล็ก ''
 ถ้าผมหรือ 'A' ซึ่งเป็นหนึ่งในนี้ ''
 ถ้าผมหรือ 'กับ OX20,
 สิ่งที่ฉันจะได้รับ
 [นักศึกษาไม่ได้ยิน] 

ตัวพิมพ์เล็ก '' เพราะมันจะพลิกบิตนี้ 1
 และถ้าผมหรือ 'กับ OX20 สิ่งที่ฉันจะได้รับ
 ตัวพิมพ์เล็กเพราะเพียงแค่ oring 'กับ OX20,
 ฉันแค่จะ oring บิตเดียวนี้เพื่อที่ 1 มันมีอยู่แล้ว 1 ดังนั้นมันไม่สำคัญ
 ดังนั้นเราจึงได้รับ '' และ ''
 

Bitwise และ อีกครั้งเราสามารถคิดว่านี้เป็นของเราคู่ตรรกะและ
 ที่ด้านซ้ายของเรามีความจริงและความจริง
 มันจะเป็นความจริงและสำหรับทุกกรณีที่
 เท็จและจริงหรือจริงและเท็จหรือเท็จและเท็จ
 ไม่มีสิ่งเหล่านั้นเป็นจริง
 ดังนั้นสิ่งที่เราจบลงด้วยการ 1000
 ดังนั้นตอนนี้ที่นี่ที่นี่เป็นที่ที่ผมเคยใช้บิตเชื่อถือไม่ได้
 ที่เรามี OX20 ดังนั้นนี่คือ OX20
 ตอนนี้สิ่งที่ฉันต้องการจะทำบิตของ ~ OX20
 ที่จะพลิกบิตทั้งหมด
 ดังนั้นผมจึงมี 1101 1111
 และอื่น ๆ '' anded ด้วย ~ OX20 จะให้ฉันอะไร
 บิตเท่านั้นเราต้องการจริงๆที่จะคิดเกี่ยวกับการเป็นหนึ่งในนี้
 ตั้งแต่ถ้าทั้งหมดของบิตเหล่านี้จะถูกตั้งค่าเป็น 1
 แล้วเราจะได้รับสิ่งที่ 'A' เป็น
 ยกเว้นอาจจะเป็นสิ่งที่บิตนี้เป็น
 เพราะถ้ามันเป็นที่ 1, ตอนนี้ก็จะได้รับการตั้งค่าให้เป็น 0,
 เพราะสิ่งนี้คือ anded กับเรื่องนี้เป็นไปได้ 0
 ดังนั้นสิ่งที่ 'A' และ ~ OX20 จะให้ผมหรือเปล่า
 [นักเรียนตอบไม่ได้ยิน] 

และสิ่งที่ 'a' และ - มัน 'A'
 และเป็นสิ่งที่ '' & ~ OX20 จะให้ผมหรือเปล่า
 'เอ' เพราะนี่คือปัจจุบัน 1
 anding ด้วย 0 จะทำให้มันเป็น 0,
 และตอนนี้เรากำลังจะได้รับ 'A'
 

ทั้งสองเป็น ',' และสุดท้าย แต่ไม่น้อยประเภทนี้
 เรามี XOR มันเป็นอย่างมากเช่นหรือ
 ยกเว้นว่ามันจะหมายถึงเฉพาะหรือ
 นี้เป็นเหมือนสิ่งที่คุณมักจะคิดว่าเป็นหรือในโลกแห่งความเป็นจริง
 เพื่อให้คุณทำอย่างใดอย่าง 'x' หรือ 'y' แต่ไม่ใช่ทั้งสอง
 ที่นี่ 1 ^ 1 เป็นไปได้ 0
 เพราะความจริงนี้เป็น - มันไม่ทำงานเช่นกันกับตรรกะความจริงและเท็จ
 เป็นค่าที่เหมาะสมและและหรือทำ
 แต่จริง ^ จริงเป็นเท็จ
 เพราะเราเพียง แต่ต้องการที่จะกลับจริงถ้ามีเพียงหนึ่งของพวกเขาเป็นความจริง
 ดังนั้น 1 ^ 1 0 สิ่งที่เกี่ยวกับ 0 ^ 1?
 1 1 ^ 0 1 0 ^ 0 0
 ดังนั้นภายใต้สถานการณ์ทั้งหมด 0 บิต 0 สิ่งที่เป็นไปได้ 0
 1 บิต 0 หรือบางสิ่งบางอย่างบิต 0 1
 ถ้ามัน | ^ หรือมันจะเป็น 1 และถ้ามันและมันจะเป็น 0
 และกรณีเดียวที่ 1 บิตที่ 1 ไม่ได้เป็น 1 จะมี แต่เพียงผู้เดียวหรือ
 ที่ 0110
 ดังนั้นที่นี่ตอนนี้ใช้ XOR - เพื่อให้เรากลับไปที่ 20
 '' ^ OX20 เป็น 2 บิตเหล่านี้เรากำลังเปรียบเทียบ
 ดังนั้น 1 ^ 0 จะให้ฉันสิ่งที่ได้หรือไม่ อย่างใดอย่างหนึ่ง
 '' ^ OX20 จะให้ผมหรือเปล่า พิมพ์เล็ก
 '' ^ OX20 จะให้ผมหรือเปล่า ทุนเอ
 เพราะสิ่งนี้จะทำ XORing นี้กับ OX20
 อย่างมีประสิทธิภาพพลิกสิ่งที่บิตนี้เป็น
 ถ้าเป็น 0 มันตอนนี้จะกลายเป็น 1
 ตั้งแต่นี้เป็น 1, 1 ^ 1 0
 ดังนั้นเรา 'ได้กลายเป็น' A 'และเรา' A 'ได้กลายเป็น' '
 ดังนั้น XOR เป็นวิธีที่สะดวกจริงๆเพียงพลิกกรณี
 คุณเพียงแค่ต้องการที่จะย้ำกว่าสตริงของตัวอักษร
 และสลับกรณีของทุกตัวอักษรเดียว
 คุณเพียงแค่ทุกอย่าง XOR ด้วย OX20
 กะ 

ตอนนี้เราได้ทิ้งไว้ กะที่เหลือเป็นเพียงการไปโดยทั่วไป
 ผลักดันทั้งหมดของตัวเลขลงหรือไปทางซ้ายและใส่ 0 อยู่เบื้องหลังพวกเขา
 ดังนั้นที่นี่เรามี 00001101
 เราจะผลักดัน 3 0 ในจากด้านขวา
 และเราได้รับ 01101000
 ในแง่ nonbinary,
 เราจะเห็นว่าที่จริงการซื้อขาย 13 ซ้ายขยับตัวด้วย 3 ซึ่งช่วยให้เรามี 104
 ขยับซ้ายดังนั้นเราดูที่นี่ << x y เป็นพื้น x * 2 ^ y
 13 * 2 ^ 3, 2 ^ 3 คือ 8 ดังนั้น 13 * 8 104
 หากคุณเพียงแค่คิดเกี่ยวกับไบนารีโดยทั่วไปว่าแต่ละหลัก
 ถ้าเราเริ่มต้นจากทางด้านขวาก็เป็นสถานที่ 1 แล้วสถานที่ 2 แล้วสถานที่ 4
 ดังนั้นโดยการผลักดันใน 0 จากด้านขวา
 เรากำลังผลักดันสิ่งที่อยู่ในสถานที่ 4 ไปยังสถานที่ 8 ของ
 และสิ่งที่อยู่ในสถานที่ 8 ไปยังสถานที่ 16 ของ
 แต่ละกะเพียงแค่คูณด้วย 2 ใช่?
 [นักศึกษา] จะเกิดอะไรขึ้นถ้าคุณเปลี่ยนโดย 5?
 [โบว์] หากคุณขยับลง 5 คุณก็จะสูญเสียหลัก
 หลีกเลี่ยงไม่ได้ก็เป็นสิ่งเดียวกัน เช่นจำนวนเต็มมีเพียง 32 บิต
 ดังนั้นถ้าคุณเพิ่ม 2 จำนวนเต็มใหญ่จริงๆมันก็ไม่พอดีกับจำนวนเต็ม
 ดังนั้นมันจึงเป็นสิ่งเดียวกันที่นี่ หากคุณขยับลง 5,
 เราก็จะสูญเสียหนึ่งที่
 และที่เป็นชนิดของสิ่งที่ฉันหมายถึงโดย "ประมาณ"
 ซึ่งถ้าคุณเปลี่ยนไกลเกินไปคุณจะสูญเสียบิต
 

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

3 ซึ่งเป็นที่มีประสิทธิภาพ x / y ^ 2
 ดังนั้นตอนนี้ที่นี่เป็นความคิดที่คล้ายกัน
 ทำไมมันจึงเป็นเพียงแค่ประมาณ x / y ^ 2 และไม่จริง x / 2 ^ Y?
 เพราะถ้าผมได้ขยับตัวโดย 4 ผมจะได้หายไป 1
 โดยทั่วไปสิ่งที่คุณคิดว่าเพียงแค่คิดว่าการแบ่งจำนวนเต็มทั่วไป
 ดังนั้นเช่น 5/2 คือ 2 มันไม่ใช่ 2.5
 มันเป็นความคิดเดียวกันที่นี่ เมื่อเราหารด้วย 2
 เราจะสูญเสียบิตแปลกไปพร้อมกัน
 ดังนั้นตอนนี้ - นั่นมันสำหรับค่าที่เหมาะสม นั่นคือทั้งหมดที่คุณจำเป็นต้องรู้
 จำได้ว่ากรณีการใช้งานที่เราเห็นในชั้นเรียน
 เช่นหน้ากากบิตเป็นประโยชน์สำหรับผู้ประกอบการบิต,
 หรือคุณใช้พวกเขาสำหรับมาสก์บิต
 ตัวพิมพ์ใหญ่และตัวพิมพ์เล็กแปลงเป็นตัวอย่างแม่บทสวย
 

เอาล่ะเพื่อโจมตี buffer ล้น
 ทุกคนจำสิ่งที่ผิดกับฟังก์ชั่นนี้
 แจ้งเราประกาศอาร์เรย์ของ 12 ไบต์, 12 ตัวอักษร,
 แล้วเราก็คัดลอกลงในบัฟเฟอร์ของเราจาก 12 ตัวอักษรบาร์สตริงทั้งหมด ดังนั้นสิ่งที่เป็นปัญหาอยู่ที่นี่
 จำนวนมายากล 12 สวยมากทันทีควรปรากฏออกมาเป็น - ทำไม 12?
 ถ้าแถบเกิดขึ้นเป็นกว่า 12 ตัวอักษร?
 สิ่งที่ถ้าบาร์ล้านของตัวละคร?
 นี่เป็นปัญหา memcpy ถ้าแถบยาวพอ
 มันก็จะสมบูรณ์ - 'c', 'c' ไม่สนใจว่ามันเป็นเพียง 12 ตัวอักษร;
 'c' ไม่สนใจว่ามันไม่สามารถใส่ไบต์ที่หลาย
 มันก็จะเป็นการเขียนทับถ่าน, 12 ไบต์ที่เราได้จัดสรรสำหรับมัน
 และทุกอย่างที่ผ่านมามันอยู่ในหน่วยความจำที่ไม่จริงเป็นบัฟเฟอร์ที่
 กับสิ่งที่บาร์สตริงเป็น
 ดังนั้นนี้คือภาพที่เราเห็นในชั้นเรียน
 ที่เราได้สแต็คของเราเติบโตขึ้น
 คุณควรจะใช้ในการภาพเหล่านี้หรือได้รับคุ้นเคยกับพวกเขาอีกครั้ง
 เรามีสแต็คของเราเติบโตขึ้นมาอยู่หน่วยความจำเริ่มต้นที่ 0 ที่ด้านบน
 และเจริญเติบโตได้ลงไปที่ชอบที่ 4 พันล้านที่ด้านล่าง
 เรามีอาร์เรย์ของเรา 'c' ในบางส่วนของหน่วยความจำ
 แล้วเรามีตัวชี้บาร์ของเราที่จะต้องอยู่ภายใต้มัน
 และแล้วเราก็มีตัวชี้กรอบนี้ถูกบันทึกไว้ในที่อยู่ผู้ส่งของเราและกองประจำผู้ปกครองของเรา
 จำสิ่งที่อยู่ผู้ส่งคืออะไร
 ก็เมื่อสายหลัก foo ฟังก์ชันเรียกบาร์ฟังก์ชั่น
 หลีกเลี่ยงไม่ได้ผลตอบแทนที่บาร์
 ดังนั้นเมื่อบาร์ผลตอบแทนที่พวกเขาต้องการที่จะรู้ว่ามันจะกลับไปที่ foo เรียกมันว่า
 ดังนั้นที่อยู่ผู้ส่งที่อยู่ของฟังก์ชั่นที่ว่ามันมีที่จะกลับไปเมื่อกลับมาทำงาน
 เหตุผลที่สำคัญสำหรับการโจมตีหน่วยความจำล้นเป็นเพราะสะดวก
 แฮกเกอร์ต้องการเปลี่ยนที่อยู่ผู้ส่งว่า
 แทนการที่จะกลับไป foo, ฉันจะกลับไปที่ใดก็ตามที่แฮกเกอร์ต้องการให้ผมกลับไปที่
 และสะดวกที่แฮกเกอร์มักต้องการที่จะกลับไปที่
 คือจุดเริ่มต้นของ buffer ที่เรามี แต่เดิม
 เพื่อแจ้งให้ทราบอีกครั้งลิตเติ้ลอินเดีย
 เครื่องใช้เป็นตัวอย่างของระบบที่ลิตเติ้ลอินเดีย,
 ดังนั้นจำนวนเต็มหรือตัวชี้จะถูกเก็บไว้ด้วยไบต์กลับ
 ดังนั้นที่นี่เราจะเห็น - นี้คืออะไร ใช่
 เราเห็น Ox80, OxC0, Ox35, OxO8
 จำเลขฐานสิบหกหรือไม่
 เราจะไม่กลับเลขฐานสิบหกในลิตเติ้ลอินเดีย
 เพราะ 2 หลักเลขฐานสิบหกทำขึ้น byte เดียวและเรากลับไบต์
 นั่นเป็นเหตุผลที่เราไม่ได้จัดเก็บเหมือน 80530CO8
 เราเก็บแทนแต่ละคู่ 2 หลักเริ่มต้นจากทางด้านขวา
 อยู่ที่หมายถึงที่อยู่ของการเริ่มต้น
 ของ buffer ของเราที่เราต้องการจริงที่จะคัดลอกลงในสถานที่แรก
 ด้วยเหตุผลที่ว่ามีประโยชน์เป็นเพราะสิ่งที่ถ้าโจมตี
 ที่เกิดขึ้นกับแทนการมีสายที่เป็นเพียง
 สตริงไม่เป็นอันตรายเช่นชื่อหรือสิ่งที่พวกเขา
 สิ่งที่ถ้าแทนสตริงที่มีเพียงโค้ดบาง
 ที่ไม่สิ่งที่พวกเขาอยากให้มันทำอะไรได้บ้าง
 ดังนั้นพวกเขาจึงสามารถ - ฉันไม่สามารถคิดของรหัสเย็นใด
 มันอาจจะเป็นอะไร แต่ รหัสใด ๆ ที่ร้ายแรง
 หากพวกเขาต้องการที่พวกเขาก็สามารถทำสิ่งที่ผิดพลาด SEG แต่ที่จะไม่มีจุดหมาย
 พวกเขามักจะทำมันจะตัดระบบของคุณ
 เอาล่ะ 

ห้องสมุด CS50
 นี้เป็นพื้น GetInt, getString ทุกฟังก์ชั่นที่เราจัดเตรียมไว้สำหรับคุณ
 ดังนั้นเราจึงมีสตริง char * และที่เป็นนามธรรมที่เราพัดออกไป
 ในบางจุดในช่วงปิดเทอม
 โปรดจำไว้ว่าสตริงเป็นเพียงอาร์เรย์ของตัวอักษร
 ดังนั้นที่นี่เราเห็นรุ่นย่อของ getString
 คุณควรมองย้อนกลับไปที่มันต้องจำไว้ว่ามันใช้งานจริง
 รายละเอียดที่สำคัญจะแจ้งให้ทราบว่าเราได้รับในตัวเดียวในเวลา
 จากมาตรฐานซึ่งเป็นเช่นเดียวกับเราพิมพ์ที่แป้นพิมพ์
 ดังนั้นตัวเดียวได้ตลอดเวลาและถ้าเราได้รับตัวอักษรมากเกินไป
 ดังนั้นหาก 1 + n มีค่ามากกว่าความจุ
 แล้วเราต้องเพิ่มความจุของบัฟเฟอร์ของเรา
 ดังนั้นที่นี่เรากำลังเพิ่มขนาดของ buffer ของเรา
 และที่ช่วยให้เกิดเราแทรกอักขระลงในบัฟเฟอร์ของเรา
 จนกว่าเราจะได้รับการขึ้นบรรทัดใหม่หรือจุดสิ้นสุดของแฟ้มหรืออะไรก็ตาม
 ซึ่งในกรณีที่เรากำลังทำกับสตริงแล้ว getString จริง
 ลดขนาดหน่วยความจำเช่นถ้าเราจัดสรรหน่วยความจำมากเกินไปมันจะกลับไปและหดตัวลงเล็กน้อย
 ดังนั้นเราจึงไม่ได้แสดงให้เห็นว่า แต่แนวคิดหลักคือ
 จะมีการอ่านได้ในตัวเดียวในเวลา
 มันไม่สามารถอ่านเพียงแค่ในสิ่งทั้งหมดในครั้งเดียว
 เพราะกันชนของพวกเขาเป็นเพียงที่มีขนาดบาง
 ดังนั้นถ้าสายที่มันพยายามที่จะแทรกลงในบัฟเฟอร์มีขนาดใหญ่เกินไปแล้วมันจะล้น
 ดังนั้นที่นี่เราป้องกันไม่ให้เพียงการอ่านในตัวเดียว
 ในเวลาและการเติบโตเมื่อใดก็ตามที่เราจำเป็นต้อง
 ดังนั้น GetInt และอื่น ๆ ฟังก์ชั่นห้องสมุด CS50 มักจะใช้ getString
 ในการใช้งานของพวกเขา
 ดังนั้นผมจึงเน้นสิ่งที่สำคัญที่นี่
 มันเรียกร้องที่จะได้รับ getString สตริง
 หาก getString ล้มเหลวที่จะกลับหน่วยความจำ
 จำไว้ว่าสิ่งที่ getString mallocs ดังนั้นเมื่อใดก็ตามที่คุณโทร getString
 คุณไม่ควร (อ่านไม่ออก) ฟรีสตริงที่คุณได้ที่
 ดังนั้นที่นี่ถ้ามันล้มเหลวในการ malloc สิ่งที่เรากลับ INT_MAX เป็นเพียงธงที่
 เดี๋ยวก่อนเราไม่ได้จริงสามารถที่จะได้รับจำนวนเต็ม
 คุณควรจะไม่สนใจสิ่งที่ฉันกลับไปที่คุณหรือ
 ที่คุณไม่ควรรักษานี้เป็นข้อมูลที่ถูกต้อง สุดท้ายสมมติว่าไม่ประสบความสำเร็จที่เราใช้ sscanf กับที่ธงพิเศษ
 ซึ่งหมายความว่าเป็นครั้งแรกตรงกับจำนวนเต็ม
 แล้วตรงกับตัวอักษรใด ๆ หลังจากที่จำนวนเต็ม
 เพื่อแจ้งให้ทราบที่เราต้องการให้เท่ากับ 1
 ดังนั้นผลตอบแทนที่ sscanf กี่แมตช์ถ้าทำสำเร็จ
 มันจะกลับ 1 ถ้ามันประสบความสำเร็จในการจับคู่จำนวนเต็ม
 มันจะกลับ 0 ถ้ามันไม่ตรงกับจำนวนเต็มและจะกลับ 2
 ถ้ามันตรงกับจำนวนเต็มตามด้วยอักขระบาง
 ดังนั้นเราลองสังเกตถ้าเราตรงกับอะไร แต่ 1
 ดังนั้นหากเราเข้ามาที่ 1, 2, 3, C, หรือ 1, 2, 3, X,
 แล้วที่ 1, 2, 3 จะได้รับการจัดเก็บไว้ในจำนวนเต็ม
 X จะได้รับการเก็บไว้ที่ตัวละคร
 sscanf จะกลับ 2 และเราจะลองใหม่อีกครั้งเพราะเราเพียงต้องการจำนวนเต็ม
 

ได้อย่างรวดเร็วพัดผ่าน HTML, HTTP, CSS
 HyperText Markup Language เป็นโครงสร้างและความหมายของเว็บ
 นี่คือตัวอย่างจากการบรรยายที่เรามีแท็ก
 เรามีแท็กหัว, แท็กร่างกาย
 เรามีตัวอย่างของแท็กว่างที่จริงเราไม่ได้มีการเริ่มต้นและแท็กปิด
 เราก็มีการเชื่อมโยงและภาพ
 ไม่มีแท็กรูปภาพปิดคือมีเพียงแท็กเดียวที่สำเร็จทุกสิ่งที่แท็กต้องทำ
 ลิงค์เป็นตัวอย่างเราจะเห็นวิธีการที่คุณเชื่อมโยงไปยัง, CSS
 สคริปต์เป็นตัวอย่างของวิธีการที่คุณเชื่อมโยงไปยังภายนอก JavaScript
 มันตรงไปตรงสวยและจำ HTML ไม่เป็นภาษาการเขียนโปรแกรม
 ที่นี่จำได้ว่าคุณจะกำหนดรูปแบบหรืออย่างน้อยสิ่งนี้จะทำอย่างไร
 รูปแบบดังกล่าวมีการดำเนินการและวิธีการที่
 วิธีการที่คุณจะเท่านั้นที่เคยเห็นเป็น GET และ POST
 เพื่อให้ได้รับเป็นรุ่นที่สิ่งที่ได้รับการใส่ใน URL
 การโพสต์เป็นที่ที่ยังไม่ได้ใส่ใน URL
 แต่ข้อมูลใด ๆ จากรูปแบบถูกแทรกซ่อนอยู่มากขึ้นในการขอ HTTP
 ดังนั้นนี่คือการกระทำที่กำหนดคำขอไป
 ที่มันจะเป็น google.com / search
 วิธี โปรดจำไว้ว่าความแตกต่างระหว่าง GET และ POST,
 และเพียงแค่บอกว่าเป็นตัวอย่างถ้าคุณต้องการบางสิ่งบางอย่างที่คั่นหน้า
 คุณจะไม่สามารถที่จะโพสต์ URL มาร์ค
 เพราะข้อมูลที่ไม่ได้รวมอยู่ใน URL ที่
 HTTP 

ตอนนี้เป็น HyperText Transfer Protocol
 HyperText Transfer Protocol คุณจะคาดหวังว่ามันจะถ่ายโอน
 HyperText Markup Language, และมันจะ
 แต่มันก็ยังถ่ายโอนภาพใด ๆ ที่คุณพบบนเว็บ
 การดาวน์โหลดที่คุณทำเริ่มต้นในขณะที่คำขอ
 ดังนั้น HTTP เป็นเพียงภาษาของเวิลด์ไวด์เว็บ
 และที่นี่คุณจำเป็นต้องรู้ชนิดของคำขอนี้
 ที่นี่ HTTP/1.1 ด้านข้างเพียงแค่บอกว่าเป็นรุ่น
 ของโปรโตคอลที่ฉันใช้
 มันสวยมากเสมอไปเป็น HTTP/1.1 เป็นคุณจะเห็นมัน
 จากนั้นเราจะเห็นว่านี้คือการได้รับทางเลือกที่ถูกโพสต์ที่คุณอาจจะเห็น
 และ URL ที่ผมพยายามที่จะเยี่ยมชมเป็น www.google.com/search?q = blah, blah, blah
 ดังนั้นจำไว้ว่านี้เครื่องหมายคำถาม q = blah blah blah,
 มีการเรียงลำดับของสิ่งที่ส่งมาตามรูปแบบ
 การตอบสนองมันอาจจะกลับไปฉันจะมีลักษณะบางอย่างเช่นนี้
 อีกครั้งที่เริ่มต้นด้วยโปรโตคอลซึ่งเป็นไปได้ว่า
 ตามด้วยรหัสสถานะ นี่มันเป็น 200 ตกลง
 และในที่สุดหน้าเว็บว่าที่จริงผมขอจะตามมา
 รหัสสถานะที่เป็นไปได้ที่คุณอาจมองเห็นและคุณควรจะรู้ว่าหลายคน
 200 ตกลงคุณอาจได้เห็นมาก่อน
 พระราชวังต้องห้าม, 404 ไม่พบข้อผิดพลาด 403 500 ภายในเซิร์ฟเวอร์
 โดยปกติจะเป็นถ้าคุณไปที่เว็บไซต์และสิ่งที่เสียหรือเกิดปัญหาโค้ด PHP ของพวกเขา
 ในขณะที่เครื่องที่เรามีอยู่ที่กล่องสีส้มขนาดใหญ่
 ที่เกิดขึ้นและบอกว่าเหมือนมีอะไรบางอย่างที่ไม่ถูกต้องรหัสนี้ไม่ทำงาน
 หรือฟังก์ชั่นนี้จะไม่ดี
 โดยปกติเว็บไซต์ที่ไม่ต้องการให้คุณรู้ว่าสิ่งที่ฟังก์ชั่นที่ไม่ดีจริง
 ดังนั้นแทนที่จะพวกเขาจะเพียงแค่ทำให้คุณมี 500 ข้อผิดพลาดภายในเซิร์ฟเวอร์
 

TCP / IP 1 ชั้นภายใต้ HTTP
 โปรดจำไว้ว่ามีอินเทอร์เน็ตนอกของเวิลด์ไวด์เว็บ
 เช่นถ้าคุณเล่นเกมออนไลน์ที่ไม่ได้ไปผ่าน HTTP,
 มันจะผ่านที่แตกต่างกัน - มันยังคงใช้อินเทอร์เน็ต
 แต่มันไม่ได้ใช้ HTTP
 HTTP เป็นเพียงตัวอย่างหนึ่งของโปรโตคอลสร้างขึ้นบน TCP / IP
 IP หมายถึง Internet Protocol
 คอมพิวเตอร์ทุกเครื่องมีที่อยู่ IP พวกเขาเป็นสิ่งที่น่า 4 หลัก
 เช่น 192.168.2.1 หรือสิ่งที่ว่ามีแนวโน้มที่จะเป็นหนึ่งในประเทศ
 แต่ที่เป็นรูปแบบของที่อยู่ IP
 ดังนั้น DNS ชื่อโดเมนบริการ
 นั่นคือสิ่งที่สิ่งที่ต้องการแปล google.com ไปยังที่อยู่ที่เกิดขึ้นจริง
 ดังนั้นถ้าคุณพิมพ์ที่อยู่ IP เป็น URL,
 ที่จะนำคุณไปยัง Google แต่คุณมักจะไม่จำสิ่งเหล่านั้น
 คุณมักจะจำ google.com แทน
 สิ่งสุดท้ายที่เรามีก็คือพอร์ตที่นี้เป็นส่วนหนึ่งของ TCP IP
 TCP จะมากขึ้น คิดเกี่ยวกับการเช่นเดียวกับที่คุณมีเว็บเบราเซอร์ของคุณทำงาน
 บางทีคุณอาจจะมีบางโปรแกรมอีเมลที่ทำงาน;
 บางทีคุณอาจมีบางโปรแกรมอื่น ๆ ที่ใช้อินเทอร์เน็ตในการทำงาน
 พวกเขาทุกคนต้องเข้าถึงอินเทอร์เน็ต
 แต่เครื่องคอมพิวเตอร์ของคุณมีการ์ดไร้สายที่ 1 หรืออะไรก็ตาม แต่
 ดังนั้นพอร์ตเป็นวิธีที่เราสามารถที่จะแยกออก
 วิธีการใช้งานเหล่านี้จะสามารถใช้อินเทอร์เน็ต
 ใบสมัครแต่ละคนได้รับ 1 พอร์ตเฉพาะที่จะสามารถฟังบน
 และโดยค่าเริ่มต้น HTTP ใช้พอร์ต 80 บางคนใช้บริการอีเมล 25
 คนเลขต่ำมีแนวโน้มที่จะสงวนไว้
 คุณมักจะสามารถที่จะได้รับคนที่สูงขึ้นเลขด้วยตัวคุณเอง
 

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

[อาลี Nahm] สวัสดีทุกคน ถ้าฉันเพียงแค่จะได้รับความสนใจของคุณ
 ฉันอาลีและฉันจะไปผ่าน PHP และ SQL อย่างรวดเร็วจริงๆ
 เพื่อให้เราสามารถเริ่มต้น PHP เป็นสั้นสำหรับ PHP: Hypertext Preprocessor
 และเป็นคุณทุกคนควรจะรู้ว่ามันเป็นภาษาสคริปต์ฝั่งเซิร์ฟเวอร์
 และเราใช้สำหรับปลายด้านหลังของเว็บไซต์
 และวิธีการที่ไม่มากของการคำนวณที่อยู่เบื้องหลังส่วน
 วากยสัมพันธ์ มันไม่เหมือน C, แปลกใจ, ประหลาดใจ
 มันก็จะมีการเริ่มต้นด้วยถ้าคุณสามารถดู - ฉันไม่สามารถเดินหน้า
 คุณสามารถดูที่คุณต้องการชนิดใหม่ของการจัดฟันแล้วคุณยังต้องหรือไม่ PHP
 นั่นคือวิธีการที่คุณมักจะมีกรอบข้อความของ PHP, PHP รหัสของคุณ
 ดังนั้นจึงไม่สามารถเพียงแค่เป็นเช่น C ที่คุณชนิดของใส่ไว้ในครั้งแรก
 คุณจำเป็นต้องเสมอล้อมรอบมัน
 และตอนนี้ไวยากรณ์ที่สำคัญคือการที่ตัวแปรทั้งหมดต้องเริ่มต้นด้วยตัวอักษร $
 ที่คุณต้องทำเมื่อคุณกำลังกำหนดให้คุณต้องทำมัน
 เมื่อคุณกำลังพูดถึงพวกเขาในภายหลัง
 คุณก็ต้อง $ ที่ มันเป็นเพื่อนที่ดีที่สุดของคุณใหม่สวยมาก
 คุณไม่ - แตกต่าง C คุณไม่จำเป็นต้องนำสิ่งที่ชนิดของชนิดตัวแปรที่เป็น
 ดังนั้นขณะที่คุณไม่จำเป็นต้อง $ คุณไม่จำเป็นต้องใส่เหมือน
 int x หรือ y สตริง, etcetera, etcetera
 ดังนั้นความแตกต่างเล็กน้อย
 ในฐานะที่เป็นผลจากการนี​​้ก็หมายความว่า PHP เป็นประเภทที่ไม่ค่อย
 PHP เป็นภาษาประเภทนิดหน่อยและมันได้พิมพ์ตัวแปรระทวย
 ในคำอื่น ๆ ที่หมายความว่าคุณสามารถสลับไปมาระหว่างชนิดที่แตกต่างกันของชนิดตัวแปร
 คุณสามารถเก็บหมายเลข 1 เป็น int,
 คุณสามารถเก็บไว้เป็นสตริงและคุณสามารถเก็บไว้เป็นลอย,
 และทั้งหมดจะเป็น 1 หมายเลขที่
 แม้ว่าคุณเก็บไว้ในรูปแบบที่แตกต่างกัน
 ก็ยังคง - ประเภทตัวแปรยังคงถือในท้ายที่สุด
 ดังนั้นถ้าคุณดูที่นี่ถ้าคุณจำจาก pset 7
 หลายท่านอาจจะมีปัญหาเกี่ยวกับเรื่องนี้
 สองสัญญาณเท่ากัน 3 สัญญาณเท่ากับ 4 สัญญาณเท่ากับ
 เอาล่ะไม่มีสัญญาณ 4 เท่ากัน แต่มี 2 และ 3
 คุณใช้ 2 สัญญาณเท่ากับตรวจสอบค่า
 มันสามารถตรวจสอบข้ามประเภท
 ดังนั้นหากคุณสามารถดูที่ตัวอย่างแรก
 ฉันมี == num_int num_string
 ดังนั้น int และสตริงของคุณมีทั้งในทางเทคนิค, 1,
 แต่พวกเขากำลังที่แตกต่างกัน แต่สำหรับเท่ากับสองก็ยังจะผ่าน
 แต่สำหรับเท่ากับสามมันจะตรวจสอบค่าเช่นเดียวกับประเภทที่แตกต่างกัน
 นั่นหมายความว่ามันจะไม่ผ่านในกรณีที่สองที่นี่
 ที่คุณกำลังใช้ 3 สัญญาณเท่ากันแทน
 เพื่อให้เป็นความแตกต่างที่สำคัญที่คุณควรได้แสดงให้เห็นในขณะนี้
 

สตริง concatenation เป็นอีกหนึ่งสิ่งที่มีประสิทธิภาพที่คุณสามารถใช้ใน PHP
 มันเป็นพื้นเพียงแค่นี้สัญกรณ์ dot ประโยชน์
 และนั่นคือวิธีการที่คุณสามารถผูกสายเข้าด้วยกัน
 ดังนั้นหากคุณมีแมวและสุนัขที่คุณมีและคุณต้องการที่จะใส่ 2 สายด้วยกัน
 คุณสามารถใช้เวลาและที่ชนิดของวิธีการทำงาน
 คุณยังสามารถวางไว้ถัดจากแต่ละอื่น ๆ
 ในขณะที่คุณสามารถดูที่นี่ในตัวอย่างด้านล่าง
 ที่ฉันได้สะท้อนสาย 1, สาย 2 พื้นที่
 PHP จะได้รู้ว่าจะเข้ามาแทนที่พวกเขาเป็นเช่น
 อาร์เรย์ ตอนนี้ใน PHP มี 2 ชนิดที่แตกต่างกันของอาร์เรย์
 คุณสามารถมีอาร์เรย์ปกติและคุณยังสามารถมีอาร์เรย์ที่สมาคม
 และเรากำลังจะไปผ่านพวกเขาในตอนนี้
 อาร์เรย์ปกติมีเพียงแค่นี้ใน C
 และเพื่อให้คุณมีดัชนีที่มีหมายเลข
 ตอนนี้เรากำลังจะสร้างและวาง -
 ดังนั้นนี่คือวิธีการที่เราสร้างอาร์เรย์ว่างเปล่าแล้วเรากำลังจะ
 ใส่ลงไปในตัวเลขดัชนี 0
 เรากำลังจะไปใส่หมายเลข 6, ค่า 6
 คุณสามารถดูได้ที่ด้านล่างที่นี่
 Where's - ตัวเลขดัชนีที่ 1 เราจะใส่หมายเลขค่า 4
 และเพื่อให้คุณสามารถดูมี 6 มี 4
 แล้วในขณะที่เรากำลังพิมพ์สิ่งที่
 เมื่อเราพยายามและพิมพ์ค่าที่เก็บไว้ที่บ้านเลขที่ดัชนี 0,
 แล้วเราจะเห็นคุณค่า 6 ถูกพิมพ์ออกมา เย็น
 เพื่อให้เป็นอาร์เรย์ปกติสำหรับคุณ
 วิธีการที่คุณยังสามารถเพิ่มสิ่งที่จะอาร์เรย์ปกติตอนนี้อีก
 ที่คุณก็สามารถผนวกพวกเขาในตอนท้าย นั่นหมายความว่าคุณไม่ได้มีการระบุดัชนีที่เฉพาะเจาะจง
 คุณจะเห็นจำนวนและจากนั้นในวงเล็บเหลี่ยมมีดัชนีที่ระบุ
 และมันก็จะรู้ - PHP จะรู้เพียงแค่เพิ่มไปยังจุดสิ้นสุดของรายการจุดฟรีต่อไป
 ดังนั้นคุณจะเห็น 1 มีสิทธิที่ที่ 0 จุด
 2 ก็มีสิทธิที่จุดแรก
 3 ไป - มีการเพิ่มมีทั้ง
 เพื่อให้ชนิดของทำให้รู้สึก คุณเพียงแค่การเพิ่มอย่างต่อเนื่องนั้น
 แล้วเมื่อเรากำลังสะท้อนดัชนีของจำนวน 1,
 จะพิมพ์ออกค่า 2
 

แล้วเรามีอาร์เรย์ที่มีความเชื่อมโยงอาร์เรย์
 เชื่อมโยงอาร์เรย์แทนการมีดัชนีตัวเลข
 สิ่งที่พวกเขาทำคือพวกเขามีดัชนีที่มีโดยสตริง
 คุณสามารถดูแทน - ฉันได้กำจัดทุกคนที่ดัชนีหมายเลข
 และตอนนี้ก็ key1, key2, key3 และพวกเขาอยู่ในเครื่องหมายคำพูดที่มีความหมายว่าพวกเขากำลังสตริงทั้งหมด
 ดังนั้นเราจึงสามารถมีตัวอย่างนี้
 ตัวอย่างนี้คือการที่เรามี tf และที่ชื่อดัชนี
 เรากำลังจะไปใส่ "อาลี" เป็นชื่อที่ดัชนี, แคลอรี่กิน
 เราสามารถใส่ int เวลานี้แทนสตริง
 แล้วที่ชอบดัชนีเราสามารถใส่อาร์เรย์ทั้งหมดภายในของมัน
 ดังนั้นนี่เป็นชนิดของ - มันเป็นแนวคิดที่คล้ายกับวิธีการที่เรามี
 ดัชนีกับตัวเลข แต่ตอนนี้เราสามารถเปลี่ยนดัชนีที่อยู่รอบ ๆ
 ที่จะมีพวกเขาเป็นสายแทน
 นอกจากนี้คุณยังสามารถทำเช่นนี้นอกจากเพียงแค่ทำมันเป็นรายบุคคล
 คุณสามารถทำมันได้ทั้งหมดในหนึ่งก้อน ดังนั้นคุณจะเห็น tf ของอาร์เรย์ที่ว่า
 แล้วเราตั้งพวกเขาทั้งหมดในชุดวงเล็บตารางยักษ์หนึ่ง
 เพื่อให้สามารถเพิ่มความเร็วขึ้น
 มันขึ้นของทางเลือกโวหารกว่าไม่ได้
 นอกจากนี้เรายังมีลูป
 ใน C เรามีลูปที่ทำงานเช่นนี้
 เรามีอาร์เรย์ของเราและเราก็ออกจากดัชนี 0 ที่ส่วนท้ายของรายการ
 และเราพิมพ์มันทั้งหมดใช่ไหม
 ยกเว้นที่เป็นปัญหาสำหรับอาร์เรย์ที่สมาคม
 เราไม่จำเป็นต้องรู้ว่าตัวเลขดัชนีที่
 เพราะตอนนี้เรามีดัชนีสตริง
 ตอนนี้เราใช้ลูป foreach ซึ่งอีกครั้งคุณใช้หวังว่าใน pset 7
 foreach ลูปก็จะรู้ทุกส่วนเดียวของรายการ
 และมันก็ไม่จำเป็นต้องรู้ว่าตัวเลขดัชนีที่คุณมี
 เพื่อให้คุณมีไวยากรณ์ foreach จึง foreach คุณใส่อาร์เรย์
 ดังนั้นอาร์เรย์ของฉันเรียกว่า pset และจากนั้นก็เป็นคำที่เป็นที่
 แล้วคุณใส่ตัวแปรชั่วคราวนี้ในประเทศที่คุณกำลังจะใช้
 เพียง แต่สำหรับสิ่งที่เฉพาะเจาะจงที่จะถือเฉพาะ -
 หนึ่งตัวอย่างหรือส่วนหนึ่งของอาร์เรย์
 pset NUM จะถือ 1 แล้วบางทีมันอาจจะจะถือจำนวน 6,
 และจากนั้นก็จะถือจำนวน 2
 แต่ก็รับประกันที่จะไปผ่านทุกค่าเดียวที่อยู่ในอาเรย์
 ฟังก์ชั่นที่มีประโยชน์ที่คุณควรรู้ใน PHP มีความจำเป็นต้องใช้
 เพื่อที่จะทำให้แน่ใจว่าคุณรวมถึงไฟล์บางอย่างสะท้อนออกว่างเปล่า
 ผมขอแนะนำให้คุณดูที่ pset 7 และดูที่ฟังก์ชั่นเหล่านั้น
 คุณอาจจะต้องรู้เหล่านั้น
 ดังนั้นแน่นอนฉันอยากจะรู้ว่าสิ่งที่ว่าเหล่านี้จะทำทุกอย่าง
 

และตอนนี้เรากำลังจะผ่านไปอย่างรวดเร็วจริงๆขอบเขต
 อยู่ในขอบเขต PHP เป็นชนิดของสิ่งที่ขี้ขลาดไม่เหมือนซี
 และเพื่อให้เรากำลังจะผ่านมันไปได้อย่างรวดเร็ว
 จึงขอบอกว่าเราเริ่มต้นที่ลูกศรที่เรามีอยู่ที่นั่น
 และเรากำลังจะเริ่มต้นด้วย $ i ดังนั้นตัวแปร 'i' เป็นไปได้ 0,
 และเรากำลังจะให้พิมพ์ลงในกล่องสีขาวที่ใหญ่กว่ามี
 เรากำลังจะเริ่มต้นด้วย i0 และจากนั้นเราจะสะท้อนมัน
 ดังนั้นจึงมี 0
 แล้วเรากำลังจะเพิ่มขึ้นทีละห่วงสำหรับที่
 แล้วมันจะเป็นค่า 1
 หนึ่งคือน้อยกว่า 3 ดังนั้นมันจะผ่านไปที่ห่วง
 แล้วเราจะเห็นมันอีกครั้งที่พิมพ์
 เรากำลังจะเพิ่มขึ้นอีกครั้งเพื่อที่ 2,
 และ 2 น้อยกว่า 3 ดังนั้นจึงจะผ่านการวนและมันจะพิมพ์ 2
 แล้วคุณจะทราบว่า 3 ไม่น้อยกว่า 3 ดังนั้นเราจะแยกออกจากการวน
 ดังนั้นตอนนี้เราได้ออกมาแล้วเราจะไปลงใน AFunction
 ถูก ดังนั้นคุณต้องทราบว่าตัวแปรนี้ที่เราได้สร้างขึ้น
 'i' ตัวแปรไม่ได้กำหนดขอบเขตในท้องถิ่น
 นั่นหมายความว่ามันไม่ได้เป็นท้องถิ่นที่จะห่วง
 และตัวแปรที่เรายังสามารถเข้าถึงและเปลี่ยนแปลงหลังจากนั้นและมันจะยังคงเป็นที่มีประสิทธิภาพ
 ดังนั้นถ้าคุณไปในการทำงานตอนนี้คุณจะเห็นว่าเรายังใช้ 'i' ตัวแปร
 และเรากำลังจะเพิ่ม 'i' + +
 คุณจะคิดว่าเป็นครั้งแรกที่อยู่บนพื้นฐานของซีว่าที่สำเนาของ 'i' ตัวแปร
 มันเป็นสิ่งที่แตกต่างกันโดยสิ้นเชิงซึ่งเป็นที่ถูกต้อง
 ดังนั้นเมื่อเราพิมพ์เรากำลังจะพิมพ์ 'i' + + ซึ่งจะพิมพ์ออกมาที่ 4
 แล้วเราจะไป - ขอโทษ
 แล้วเรากำลังจะจบออกมาจากฟังก์ชั่นที่
 และเรากำลังจะเป็นที่ลูกศรที่ถูกต้องในขณะนี้
 นั่นหมายความว่าแล้ว แต่แม้ฟังก์ชั่นการเปลี่ยนแปลงค่าของ 'i',
 มันไม่ได้มีการเปลี่ยนแปลงด้านนอกของฟังก์ชั่น
 เพราะฟังก์ชั่นมีขอบเขตที่แยกต่างหาก
 นั่นหมายความว่าเมื่อเรา echo 'i' ก็ไม่ได้เปลี่ยนแปลงในขอบเขตของฟังก์ชั่นที่
 และอื่น ๆ แล้วเรากำลังจะพิมพ์ 3 อีกครั้ง
 สิ่งที่แตกต่างกันเกี่ยวกับขอบเขตใน PHP กว่าใน C. 

ตอนนี้ใน PHP และ HTML
 PHP ใช้ในการทำหน้าเว็บแบบไดนามิก
 ชนิดของมันทำให้สิ่งที่แตกต่างกัน
 เรามีมันแตกต่างจาก HTML
 กับ HTML เรามักจะมีเพียงสิ่งเดียวที่คงที่เช่นเดียวกับวิธีการที่ร็อบแสดงให้เห็น
 ขณะที่ PHP, คุณสามารถเปลี่ยนสิ่งที่ขึ้นอยู่กับการที่ผู้ใช้เป็น
 ดังนั้นถ้าฉันมีนี้ผมได้ "คุณล็อกอินเป็น -" แล้วชื่อ
 และฉันสามารถเปลี่ยนชื่อ ดังนั้นตอนนี้ชื่อเป็นโจเซฟ
 และมี "เกี่ยวกับฉัน" แต่แล้วฉันยังสามารถเปลี่ยนชื่อที่จะมีทอมมี่
 และนั่นจะเป็นสิ่งที่แตกต่างกัน
 ดังนั้นแล้วเรายังสามารถเปลี่ยนสิ่งที่แตกต่างกันเกี่ยวกับเขา
 และจะแสดงเนื้อหาที่แตกต่างกันขึ้นอยู่กับชื่อ
 ดังนั้น PHP ชนิดของสามารถเปลี่ยนแปลงสิ่งที่เกิดขึ้นในเว็บไซต์ของคุณ
 เดียวกันที่นี่ ยังทราบว่าพวกเขามีเนื้อหาที่แตกต่างกัน
 แม้ว่าคุณจะได้ในทางเทคนิคยังคงเข้าถึงหน้าเว็บที่เดียวกันบนพื้นผิว
 สร้าง HTM​​L มี 2​​ วิธีที่แตกต่างกันที่คุณสามารถทำเช่นนี้
 ดังนั้นเราจะผ่านไปในขณะที่ตอนนี้ วิธีแรกคือคุณต้อง - ใช่ขอโทษ
 ดังนั้นคุณก็ต้องปกติของคุณสำหรับวงใน PHP
 แล้วคุณจะสะท้อนใน PHP และคุณสะท้อนออก HTML
 การใช้สิ่งที่ร็อบแสดงให้เห็นว่าคุณของสคริปต์ HTML
 แล้วใช้พิมพ์ PHP เพื่อเพียงแค่พิมพ์ออกไปยังหน้าเว็บ
 ทางเลือกหนึ่งคือการทำมันเป็นถ้าคุณแยกออกจาก PHP และ HTML
 ดังนั้นคุณจึงสามารถมีสายของ PHP ที่จะเริ่มต้นการวน
 แล้วคุณสามารถมีสายของ HTM​​L ในเป็นสิ่งที่แยกจากกัน
 แล้วคุณจะจบวงอีกครั้งกับ PHP
 จึงแยกชนิดของมันออกมา
 ที่ด้านซ้ายคุณสามารถที่คุณมี -
 ก็เพียง 1 ก้อน PHP
 ด้านขวาคุณจะเห็นว่าคุณมีสายของ PHP,
 คุณมีสายของ HTM​​L และคุณมีสายของ PHP อีกครั้ง
 ดังนั้นการแยกมันออกมาเป็นสิ่งที่พวกเขากำลังทำ
 และคุณจะทราบว่าวิธีการอย่างใดอย่างหนึ่งอย่างใดอย่างหนึ่งของพวกเขา
 พวกเขายังคงพิมพ์ออกภาพ, ภาพ, ภาพ,
 เพื่อ HTML ที่ยังคงมีการพิมพ์แบบเดียวกับที่
 แล้วคุณยังจะเห็นภาพที่ 3 แสดงขึ้นบนเว็บไซต์ของคุณ
 ดังนั้นจึงเป็น 2 วิธีที่แตกต่างกันของการทำสิ่งเดียวกัน
 

ตอนนี้เรามีรูปแบบและการร้องขอ ขณะที่ร็อบแสดงให้เห็นว่าคุณ
 มีรูปแบบของภาษาและเราก็จะสายลมผ่านทางนี้
 คุณมีการดำเนินการและคุณมีวิธีการและการกระทำของคุณ
 แสดงให้เห็นชนิดของคุณที่คุณกำลังจะส่งมันและวิธีการที่ไม่ว่าจะเป็น
 มันจะเป็น GET หรือ POST
 และ GET ขอเป็นร็อบกล่าวว่าหมายความว่าคุณจะใส่มันในรูปแบบ
 และคุณจะเห็นว่ามันเป็น URL ในขณะที่คำขอ POST คุณจะไม่เห็นอยู่ใน URL
 ดังนั้นความแตกต่างเล็กน้อย
 แต่สิ่งหนึ่งที่เป็นสิ่งที่คล้ายกัน
 คือการโพสต์และได้รับอย่างเท่าเทียมกันเป็นที่ไม่ปลอดภัย
 ดังนั้นคุณอาจจะคิดว่าเพียงเพราะคุณไม่เห็นมันใน URL
 นั่นหมายความว่าการโพสต์ที่มีความปลอดภัยมากขึ้น
 แต่คุณยังสามารถดูได้ในคุกกี้ของคุณในข้อมูลที่คุณกำลังส่ง
 จึงไม่คิดว่าเกี่ยวกับการอย่างใดอย่างหนึ่งหรืออื่น ๆ
 สิ่งที่ควรทราบก็คือว่าคุณยังมีตัวแปรส่วน
 พวกคุณใช้วิธีนี้ใน pset 7 จะได้รับข้อมูลรหัสผู้ใช้ของคุณ
 สิ่งที่เกิดขึ้นคือการที่คุณสามารถใช้อาเรย์นี้
 $ _SESSION และจากนั้นคุณจะสามารถเข้าถึงสิ่งที่แตกต่างกัน
 และเก็บสิ่งที่แตกต่างกันทั่วหน้า
 

สิ่งสุดท้ายคือเรามี SQL, Structured Query Language,
 และนี่คือภาษาการเขียนโปรแกรมในการจัดการฐานข้อมูล
 สิ่งที่ว่าฐานข้อมูลมีอะไรบ้าง พวกเขาคอลเลกชันของตาราง
 และในแต่ละตารางสามารถมีชนิดที่คล้ายกันของวัตถุ
 ดังนั้นเราจึงมีตารางของผู้ใช้ใน pset การเงินของคุณ
 และทำไมพวกเขามีประโยชน์ เพราะมันเป็นวิธีการในการจัดเก็บข้อมูลอย่างถาวร
 ซึ่งเป็นวิธีการในการติดตามสิ่งที่และการจัดการสิ่ง
 และที่จริงเห็นมันบนหน้าเว็บที่แตกต่างกันและการติดตาม
 ในขณะที่ถ้าคุณเพียงแค่เก็บไว้ที่ว่าช่วงเวลาหนึ่งได้ทันที
 แล้วใช้ต่อมาคุณจะไม่สามารถเข้าถึงสิ่งที่คุณได้บันทึกไว้
 เรามี 4 สิ่งที่สำคัญที่เราใช้สำหรับคำสั่ง
 เรามีให้เลือกแทรกลบและการปรับปรุง
 เหล่านี้เป็นสิ่งสำคัญมากสำหรับคุณผู้ชายที่จะรู้ว่าสำหรับคำถามของคุณ
 

เราได้อย่างรวดเร็วจะเลือกไปกว่าตอนนี้
 โดยทั่วไปคุณกำลังเลือกแถวจากฐานข้อมูล
 ดังนั้นหากคุณมีที่นี่ -
 เหล่านี้เรามี 2 สิ่งที่แตกต่างกันและเราต้องการที่จะเลือกจากตารางเรียน
 ที่น่ากลัว - ที่น่ากลัวในคอลัมน์ค่าเป็น 1
 เพื่อให้คุณสามารถดูที่นี่เรามี 2 สิ่งเหล่านี้ชื่อชั้น
 CS50 และ Stat110 และเรามีรหัสที่ชั้นเรียนและสโลแกน
 ดังนั้นเราจึงต้องการที่จะเลือกทั้งหมดของข้อมูลที่
 แล้วคุณจะเห็นว่าที่นี่เป็นประเภทของการเลือกออกมาจากคอลัมน์ที่น่ากลัวว่า
 ที่ทุกสิ่งที่เป็น 1 แล้วก็มีชั้น ID, ชื่อชั้นและสโลแกนที่ว่ามันสามารถเลือกออก
 วิธีการว่าคุณจะทำในรหัส? คุณมีการใช้ PHP
 เพื่อให้เป็นชนิดของวิธี PHP และ SQL ที่เกี่ยวข้องกับแต่ละอื่น
 ตอนนี้เรามีรหัสของเราและเรากำลังจะใช้ฟังก์ชั่นการค้นหาของเรา
 ในขณะที่เราไม่ได้ทำใน pset 7 และเรากำลังจะเรียกใช้แบบสอบถาม SQL
 แล้วเรากำลังจะมี -
 เรามักจะมีการตรวจสอบว่าแถวที่สามเท่ากันถ้าเท็จ ดังนั้นอีกครั้งคุณต้องการที่จะตรวจสอบชนิดและค่า
 แล้วถ้ามันไม่ทำงานแล้วคุณต้องการที่จะขอโทษตามปกติเช่นเดียวกับที่เราทำใน pset 7
 มิฉะนั้นคุณต้องการที่จะห่วงผ่านทุกอย่างด้วยประโยชน์เหล่านั้น
 foreach ลูปที่เราเพิ่งไปกว่า
 ตอนนี้ที่เรากำลังวนลูปผ่านและเราได้ทำให้มันผ่านมา
 สมมติว่าแบบสอบถามของเราผ่านไปตอนนี้เรามีห่วง foreach ของเรา
 แถวแรกที่มันได้ดังนั้นนี่คือแถวขวานี่มันชนิดบรรจุกล่อง
 มันจะพิมพ์ข้อมูลทั้งหมดที่อากาศ
 ดังนั้นมันจะพิมพ์ออกมาที่ด้านล่าง "อยากเรียนรู้ HTML ได้ไหม?"
 จากนั้นก็จะไปที่แถวถัดไปเพราะเสร็จครั้งแรกสำหรับวง
 และอื่น ๆ จากนั้นก็จะพิมพ์ออกมาบรรทัดที่สองของมัน
 ซึ่งเป็นไปได้ STAT110 หาช่วงเวลาทั้งหมด
 

สิ่งหนึ่งที่สุดท้ายคือใน SQL ช่องโหว่
 ฉันรู้ว่าเดวิดสัมผัสเกี่ยวกับเรื่องนี้นิด ๆ หน่อย ๆ ในการบรรยาย
 คุณสามารถอ่านได้ในภายหลัง มันตลกจริงๆ
 SQL ฉีดเป็นชนิดของสิ่งที่ยุ่งยาก
 สมมติว่าคุณเพียงแค่ติดตัวแปรเหล่านั้นลงในแบบสอบถามของคุณ
 อย่างที่คุณเห็นในบรรทัดแรกว่า
 ดังนั้นดูเหมือนว่าดีใช่มั้ย คุณเพียงแค่ใส่ในชื่อผู้ใช้
 และรหัสผ่านเพื่อแบบสอบถามของคุณและคุณต้องการที่จะส่งออกและได้รับสิ่งที่อยู่ในตารางข้อมูลของคุณ
 ที่ดูเหมือนง่ายสวย เพื่อช่วยให้ว่ามีคนทำให้ใน
 สำหรับรหัสผ่านนี้หรือข้อความที่นี่ -
 จริงควรจะอยู่ในกล่องสีแดง
 จึงขอบอกว่าพวกเขาใส่รหัสผ่านที่เป็น - นั่นคือสิ่งที่พวกเขาเข้าสู่
 ดังนั้นพวกเขากำลังวางหรือ "1" = 1
 ชนิดของรหัสผ่านที่โง่ที่จะมี
 ตอนนี้ขอเพียงแค่แทนที่ในและคุณจะทราบว่าในแบบสอบถามว่าตอนนี้
 จะประเมินให้เป็นจริงเสมอเพราะคุณจะทราบว่า
 คุณสามารถสอบถาม SQL เลือกข้อมูลทั้งหมดนี้
 หรือคุณก็สามารถมี 1 = 1
 เพื่อให้เสมอไปประเมินให้เป็นจริง
 ที่ไม่ได้ไปทำงานจริงๆเพราะนั่นหมายความว่าแฮกเกอร์สามารถเจาะเข้าสู่ระบบของคุณ
 วิธีแก้ปัญหานี้คือการที่คุณต้องใช้ระบบ PDO,
 ซึ่งหมายความว่าคุณต้องใช้เครื่องหมายคำถาม
 ซึ่งเป็นสิ่งที่พวกที่ใช้ใน pset 7 คุณ
 ที่คุณกำลังจะใช้เครื่องหมายคำถามในสถานที่ที่คุณต้องการที่จะนำบางสิ่งบางอย่าง
 แล้วคุณจะมีเครื่องหมายจุลภาคและจากนั้นคุณจะมีหลังจากนั้น
 หลังจากสตริงของตัวแปรที่แตกต่างกันที่คุณต้องการที่จะเปลี่ยนเป็นเครื่องหมายคำถามของคุณ
 ดังนั้นคุณจะทราบที่นี่ที่ตอนนี้ฉันมีเหล่านี้เครื่องหมายคำถามสีแดง
 จากนั้นฉันใส่ตัวแปรหลังจากสตริงของฉันเพื่อให้ฉันรู้ว่าจะเข้ามาแทนที่พวกเขาเพื่อที่หลังจากนั้น
 ที่จะตรวจสอบให้แน่ใจว่าถ้ามีคนไม่ได้เช่นนี้
 และพวกเขามีหรือ 1 = 1 สถานการณ์ที่จะทำให้แน่ใจว่า
 ในท้ายที่สุดกลับให้แน่ใจว่ามันจะไม่จริงทำลายแบบสอบถาม
 เอาล่ะเพื่อให้มันสวยมาก, ลมกรดของ PHP และ SQL
 โชคดีที่สุดของคุณทุกคนและตอนนี้ที่โอเรกอน
 

[Oreoluwatomiwa Babarinsa] ทุกคนโอเค เวลาที่จะไปกว่าบาง JavaScript
 และบางสิ่งอื่น ๆ ได้อย่างรวดเร็วดังนั้นเราจึงไม่ถือค​​ุณขึ้นในคืนนี้
 JavaScript ใช่ JavaScript เป็นชนิดของสิ่งที่เย็นต้นฉบับ
 สิ่งที่คุณจำเป็นต้องรู้เกี่ยวกับ JavaScript ก็จัดเรียงของชอบ
 ปลายฝั่งไคลเอนต์ของสิ่งที่ app เว็บของคุณจะต้องทำ
 มีบางสิ่งบางอย่างที่คุณเพียงแค่ไม่ต้องการที่จะดูแลตลอดเวลาในฝั่งเซิร์ฟเวอร์เป็น
 ทั้งหมดปฏิสัมพันธ์น้อยเน้นสิ่งหนึ่งที่ทำให้บางสิ่งบางอย่างหายไป
 คุณจริงๆไม่ต้องการให้มีการพูดคุยกับเซิร์ฟเวอร์ของคุณตลอดเวลาที่
 และบางส่วนของที่ไม่ได้เป็นไปได้ที่จะทำในฝั่งเซิร์ฟเวอร์
 นี่คือเหตุผลที่เราต้องการบางสิ่งบางอย่างเช่น JavaScript
 สิ่งดีๆเกี่ยวกับ JavaScript: เป็นพิมพ์แบบไดนามิก
 สิ่งนี้หมายความว่าโปรแกรมของคุณไม่จำเป็นต้องรู้
 สิ่งที่ว่าตัวแปรที่มีเมื่อคุณเขียนมันออกมา
 มันจะเป็นเพียงการเรียงลำดับของตัวเลขออกที่มีการใช้
 สิ่งอื่น ๆ ที่จะเย็นเกี่ยวกับมันมันเป็นภาษารั้งหยิก
 ซึ่งหมายความว่าไวยากรณ์ที่คล้ายกับ C และ PHP
 คุณไม่ต้องทำปรับปรุงมากเมื่อคุณเรียนรู้ JavaScript
 ที่นี่เรามีนิด ๆ หน่อย ๆ ของ JavaScript
 สิ่งที่น่าสนใจที่นี่คือว่าถ้าคุณมองไปที่มัน
 เรามีเกร็ดความ JavaScript มีสิทธิ์ในแท็กหัว
 อะไรคือสิ่งที่ไม่เป็นพื้นเพียงรวมถึงไฟล์ JavaScript
 นี้เป็นวิธีหนึ่งที่คุณสามารถรวมจาวาสคริปต์ลงในโปรแกรมของคุณ
 แล้วนิด ๆ หน่อย ๆ ที่สองเป็นจริงบางอย่างที่ใกล้เคียงกับ JavaScript
 คล้ายกันมากกับรูปแบบอินไลน์ด้วย CSS,
 และคุณเพียงแค่เขียนรหัสบางอย่างรวดเร็วมี
 JavaScript มีอาร์เรย์
 เพียงวิธีการเก็บข้อมูลไปรอบ ๆ ที่มีประโยชน์มากอื่น
 ไวยากรณ์อย่างดีและง่าย
 คุณสามารถใช้วงเล็บในการเข้าถึงทุกอย่างและให้ทุกอย่างเข้าด้วยกัน
 ไม่มีอะไรซับซ้อนเกินไป
 สิ่งดีๆเกี่ยวกับ JavaScript และภาษาสคริปต์ทั่วไป
 คือการที่คุณไม่ต้องกังวลเกี่ยวกับขนาดอาร์เรย์
 คุณก็สามารถใช้ array.length และติดตามมัน
 และอาเรย์สามารถเติบโตหรือหดตัวตามที่คุณต้องการไป
 ดังนั้นคุณจึงไม่จำเป็นต้องกังวลเกี่ยวกับการเรียงลำดับของการใด ๆ
 โอ้ไม่ฉันต้องจัดสรรสิ่งที่มากขึ้นหรืออะไรอย่างนั้น
 

สิ่งดีๆที่นี่คือ JavaScript มีสิ่งที่เรียกว่าวัตถุ มันเป็นภาษาเชิงวัตถุดังนั้นสิ่งที่จะได้คือเป็นหลัก
 วิธีที่คุณจะจัดกลุ่มข้อมูลด้วยกันค่อนข้างคล้ายกับ struct,
 แต่คุณสามารถเข้าถึงได้เช่น struct หรือไวยากรณ์ในอาร์เรย์ที่สมาคม
 มันง่ายสวยและสิ่งที่คุณสามารถทำอะไรกับข้อมูลนี้เป็นกลุ่มร่วมกัน
 ถ้าคุณมีพวงของข้อมูลที่เกี่ยวข้อง
 เพราะทุกสิ่งที่คุณต้องการที่จะอธิบายรถ
 คุณไม่จำเป็นที่จะมีมันในเครือของสถ​​านที่ที่แตกต่างกัน
 คุณก็สามารถติดลง 1 วัตถุใน JavaScript
 ในขณะที่คุณอาจรู้ iterating เป็นหนึ่งในงานที่น่าเบื่อเหล่านั้น
 คุณเพียงแค่ทำมันซ้ำอีกครั้งในช่วง คุณจำเป็นต้องพูดคุยกับวัตถุทุกคนในรถ
 หรือคุณต้องไปผ่านทุกรายการในรายการหรือสิ่งที่ต้องการที่
 ดังนั้น JavaScript มีคล้ายกับ PHP, ไวยากรณ์ foreach
 ในกรณีนี้จะเป็นสำหรับในวง
 คุณต้องการที่จะใช้นี้เฉพาะในวัตถุ
 มีปัญหาบางอย่างที่เกิดขึ้นถ้าคุณใช้นี้ในอาร์เรย์เป็น
 มันมักจะเป็นหนึ่งในสิ่งเหล่านั้นได้ว่าเป็นประโยชน์อย่างมาก
 เพราะคุณกำจัดมากของค่าใช้จ่าย
 เพราะคุณจะได้ไม่ต้องดึงทุกอย่างในวัตถุของคุณด้วยตัวเอง
 คุณไม่ต้องจำชื่อทั้งหมดที่สำคัญ
 คุณเพียงแค่การจัดเรียงของพวกเขาได้รับกลับมาในรูปแบบนี้
 ในเรื่องนี้ด้วยสำหรับคุณเพียงต้องการที่จะจำ
 ว่าคุณได้รับกลับคีย์ทั้งหมดในทางที่คล้ายกับตารางแฮช
 ถ้าคุณจำจากนั้นเมื่อคุณจะใส่ในสตริงคุณจะได้รับสิ่งที่ออก
 ที่จะมีค่าที่เกี่ยวข้องกับมัน
 คุณสามารถทำอะไรกับเรื่องนี้ก็คือค​​ุณสามารถพูดได้ว่าสิทธิทั้งหมด
 ฉันใส่ในรถและผมเรียกมันว่าเฟอร์รารี
 เพื่อให้คุณสามารถใส่ในสตริงเฟอร์รารีอีกครั้งในภายหลังและคุณสามารถได้รับที่ออก
 และคุณสามารถทำเช่นนั้นได้ในวงด้วยในวง
 ดังนั้นเพียงแค่เพิ่มเติมเกี่ยวกับวัตถุ สิ่งที่สำคัญจากนี้คุณต้องจำไว้
 คือการที่คุณสามารถใช้โครงสร้างวัตถุเช่นไวยากรณ์เมื่อใดก็ตามที่คุณต้องการด้วยเหล่านี้
 ยกเว้นถ้าสิ่งที่เกิดขึ้นในการใช้เป็นสตริงไม่ได้เป็นชื่อตัวแปรที่ถูกต้อง
 ดังนั้นถ้าคุณดูที่ว่ามีเรามีกุญแจที่มีช่องว่าง
 ดีถ้าคุณกำลังจะวาง object.key พื้นที่ที่มีพื้นที่ว่าง
 ที่เพิ่งจะได้ทำให้ความรู้สึก syntactically
 เพื่อให้คุณสามารถทำที่มีการเรียงลำดับของไวยากรณ์วงเล็บนี้
 

นอกจากนี้ JavaScript เป็นมากขอบเขตฉลาด PHP
 คุณมี 2 วิธีในการที่อยู่ในขอบเขต
 คุณไม่สามารถมี var ที่ด้านหน้าของตัวแปร
 และที่หมายถึงนี้เป็นระดับโลก
 คุณสามารถดูได้จากที่ใดก็ได้ แม้ว่าคุณจะใส่ในกรณีที่คำสั่ง
 ที่ใดในรหัสของคุณหลังจากจุดที่คุณสามารถมองเห็นตัวแปรที่
 อีกสิ่งหนึ่งที่แม้ว่าจะมี var ก็ จำกัด ให้สิ่งที่ฟังก์ชั่นที่คุณกำลังเข้า
 หากคุณไม่ได้อยู่ในฟังก์ชั่นที่ดีก็ทั่วโลก
 แต่ถ้าคุณอยู่ในฟังก์ชั่นเป็นเพียงการมองเห็นภายในฟังก์ชั่นที่
 ผมไม่ได้มีตัวอย่าง แต่ใช่ มันเป็นหนึ่งในสิ่งเหล่านั้นที่
 คุณสามารถจัดการสิ่งที่ตัวแปรที่คุณต้องการที่จะทั่วโลก
 สิ่งที่ตัวแปรที่คุณอยากจะเป็นท้องถิ่น แต่คุณจะต้องระมัดระวังเกี่ยวกับเรื่องนี้
 เพราะคุณไม่ได้มีประเภทของการควบคุมเม็ดละเอียดที่คุณทำใน C,
 ที่ว่าสิ่งที่มีการประกาศในการวนก็จะไปอยู่ในที่สำหรับวง
 สิ่งที่เราจะดูแลเกี่ยวกับการใช้งานจาวาสคริปต์เพื่อที่จะจัดการกับหน้าเว็บใช่ไหม
 ผมหมายถึงว่าทำไมเรากำลังทำอยู่นี้
 

ต้องการทำเช่นนั้นเราจะใช้สิ่งที่เรียกว่า DOM
 แบบวัตถุของเอกสาร
 โดยทั่วไปสิ่งที่มันไม่เป็นมันจะใช้เวลาทั้งหมด HTML ของคุณ
 และรูปแบบออกเป็นพวงของวัตถุที่ซ้อนกันในแต่ละอื่น
 คุณเริ่มต้นกับสิ่งที่ต้องการนี​​้
 คุณมีด้านขวาสำหรับฉันพวงของรหัสออกมีที่เรียงลำดับของ -
 คุณจะคิดว่าจะยากมากที่จะจัดการ
 เพราะคุณต้องการจะแยกผ่านพวงของข้อความ
 และมีชิ้นออกจากกันสิ่งที่ และสิ่งที่ถ้ามันไม่ได้มีรูปแบบถูกต้องหรือไม่
 สิ่งเลวร้ายที่จะเกิดขึ้น
 ดังนั้น JavaScript ดูแลนี้สำหรับคุณและคุณจะได้รับโครงสร้างข้อมูลที่ดี
 เช่นเดียวข้างซ้ายของเราที่คุณเพียงแค่ต้องเอกสาร
 และภายในที่คุณมีสิ่งที่เรียกว่า HTML,
 และภายในที่คุณมีหัวและร่างกาย
 และในหัวที่คุณมีชื่อ, etcetera, etcetera, etcetera
 นี้ช่วยลดความยุ่งยากการจัดการกับหน้าเว็บเพื่อให้เป็นเพียง
 โอ้ผมแค่อยากจะพูดคุยกับวัตถุนี้
 การเรียงลำดับของวิธีการที่คล้ายกันมากที่คุณจะพูดคุยกับวัตถุที่คุณทำเองอีก
 เช่นฉันกล่าวว่าทั้งหมด DOM ที่อยู่ในวัตถุเอกสาร
 ทั้งที่เป็นเพียงที่เดียวและจากนั้นคุณสามารถไปอยู่ภายในเพื่อหาสิ่งที่
 และคุณสามารถทำมัน - นี้เป็นรูปแบบเดิมในการทำมันไปอยู่ที่นั่น
 ที่คุณทำ document.getElementById แล้วชื่อ
 และในขณะที่คุณอาจจะสามารถบอกได้นี้ได้รับเทอะทะมากหลังจากที่ในขณะ
 ดังนั้นคุณอาจไม่ต้องการที่จะทำเช่นนั้น นั่นเป็นเหตุผลที่เรามี
 สิ่งต่อไปที่เรากำลังจะพูดคุยเกี่ยวกับหลังจากนี้
 สิ่งที่สำคัญที่นี่เป็นที่ที่เหมาะสมทุกอย่างที่คุณมีองค์ประกอบทั้งหมดเหล่านี้ใช่มั้ย
 ดังนั้นบางทีฉันสามารถเปลี่ยนสีของบางสิ่งบางอย่างเมื่อโหลดหน้า
 ดังนั้นสิ่งที่ เกิดอะไรขึ้นหากผู้ใช้คลิกอะไร
 ฉันต้องการที่จะทำบางสิ่งบางอย่างที่น่าสนใจเมื่อพวกเขาคลิกที่บางสิ่งบางอย่าง
 นั่นเป็นเหตุผลที่เรามีเหตุการณ์ที่เกิดขึ้น คุณสามารถโดยทั่วไปหาองค์ประกอบใน DOM ของคุณ
 แล้วบอกว่าเดี๋ยวก่อน เมื่อโหลดหรือมีคนคลิกมัน
 หรือเมื่อพวกเขาเมาส์มากกว่านั้นทำอะไรกับมัน
 และสิ่งที่คุณมีคือคุณจะมีฟังก์ชั่นที่จัดการเรื่องนี้ให้คุณ
 ฟังก์ชั่นเหล่านี้เป็นตัวจัดการเหตุการณ์
 สิ่งที่พวกเขากำลัง - เป็นเพียงวิธีแฟนซีของว่า
 ฟังก์ชั่นนี้จะทำงานเฉพาะเมื่อเหตุการณ์นี้เกิดขึ้น
 ดังนั้นจึงจะจัดการกับเหตุการณ์ที่เกิดขึ้น
 นี่คือวิธีที่คุณจะวางออกตัวจัดการเหตุการณ์
 ฉันมีปุ่มบางอย่างและเมื่อคุณคลิกที่มันจะระเบิด
 จึงไม่คลิกที่ปุ่ม
 นี้เป็นวิธีหนึ่งของใกล้มันใช่มั้ย
 คุณมีแท็กปุ่มและเมื่อคลิกคุณมีสตริงที่ระบุว่าเป็น
 โอ้โดยวิธีการที่ผมทำเช่นนี้ระเบิดสิ่งที่สำหรับฉัน
 มิฉะนั้นก็เช่นเดียวกับปุ่มปกติคุณเพิ่งทำ
 นอกจากนี้คุณยังสามารถทำเช่นนี้วิธีการอื่น
 ด้วยการคว้าองค์ประกอบ DOM แต่เราจะบันทึกว่าหลังจากที่เราได้พูดคุยเกี่ยวกับ jQuery
 

jQuery: มันเป็นห้องสมุดที่เป็นข้ามเบราว์เซอร์
 คุณสามารถใช้มันในสิ่งที่สวยมาก
 และมันก็ช่วยให้คุณมีจำนวนมากเครื่องมือที่จะทำงานกับ
 เพราะจาวาสคริปต์ที่มีประสิทธิภาพในขณะที่ไม่ได้มีเครื่องมือทั้งหมดที่คุณต้องการ
 ออกจากกล่องที่จะต่อสู้จริงๆ app เว็บที่คุณอาจต้องการที่จะทำ
 ดังนั้นจึงช่วยลดความยุ่งยากมากสิ่งที่ช่วยให้คุณมีจำนวนมากของฟังก์ชั่น
 ออกจากกล่องที่คุณมักจะต้องมีการเขียนตัวเองซ้ำแล้วซ้ำแล้วซ้ำอีก
 และเพียงแค่ทำให้สิ่งที่ง่ายมาก
 นอกจากนี้คุณยังมีตัวเลือกที่ช่วยให้คุณสามารถนำออกองค์ประกอบทั้งหมดเหล่านั้น
 จาก DOM ของคุณมากขึ้นเพียงแทนที่จะต้องใช้สายงานเหล่านี้นานมาก
 ข้อมูลเพิ่มเติมเกี่ยวกับตัวเลือกเหล่านี้ คุณมีขึ้นมีคุณได้สมมุติว่า
 ฉันต้องการที่จะได้รับองค์ประกอบที่มี ID "หิน".
 ทั้งใน jQuery ก็เพียง $ แล้วสตริงที่มีปอนด์และแล้ว "หิน".
 มันง่ายมากและมากเร็วกว่าวิธีการดั้งเดิมของ JavaScript แก้ปัญหาปัญหานี้
 และคุณมีสิ่งที่คล้ายกันสำหรับการเรียนและประเภทองค์ประกอบ
 jQuery เป็น - หนึ่งในคุณสมบัติที่เย็นเป็นคุณสามารถเรียงลำดับของการบีบอัด
 ลงคำสั่งของคุณใน DOM ของคุณอย่างรวดเร็วมาก
 ตอนนี้เรากลับไปที่การจัดการเหตุการณ์และนี่คือวิธีที่คุณจะจัดการกับเหตุการณ์หนึ่งใน jQuery
 ดังนั้นสิ่งที่เรากำลังจะไปที่นี่เป็นที่ที่เรากำลังจะบอกว่าถูกต้องทั้งหมด ฉันมีแท็กสคริปต์ใช่ไหม
 ดังนั้นผมจึงมีแบบอินไลน์นี้ JavaScript
 สิ่งที่เรากำลังจะทำคือการที่เรากำลังจะบอกว่าถูกต้องทั้งหมด
 เมื่อเอกสารพร้อมซึ่งหมายความว่าเอกสารที่ได้รับการโหลด
 เราจะไปในฟังก์ชั่นที่เราและเรากำลังจะพูดว่าสิทธิทั้งหมด
 ฟังก์ชั่นนี้จริงทำอย่างอื่น
 เป็นพื้นว่าสิทธิทั้งหมดได้รับฉันองค์ประกอบที่มี ID "myId."
 แล้วให้ดำเนินการนี​​้ฟังก์ชั่นที่รันเมื่อคุณคลิก
 โดยทั่วไปสิ่งนี้จะเป็นมันก็บอกว่าถูกต้องทั้งหมด
 หน้าจะโหลดดังนั้นฉันจะไปในหาองค์ประกอบนี้
 ให้มันจัดการเหตุการณ์นี้และมันเป็นพื้นตั้งค่าหน้าเว็บของคุณสำหรับคุณ
 และนี่คือวิธีการที่คุณต้องการคิดเกี่ยวกับการจัดการเหตุการณ์
 คุณเพียงแค่ต้องการที่จะคิดเกี่ยวกับสิทธิทั้งหมดเมื่อสิ่งที่เกิดขึ้นสิ่งที่ฉันต้องการที่จะเกิดขึ้นได้อย่างไร
 คุณไม่ต้องการที่จะคิดเกี่ยวกับโอเคฉันต้องให้แน่ใจว่าสิ่งที่พูดถึงนี้เพื่อสิ่งนี้
 สิ่งนี้ blah blah blah, เพราะคุณเพียงแค่ต้องการที่จะพูดคุยสิ่งที่ในแง่ของเหตุการณ์ที่เกิดขึ้น
 เมื่อเกิดเหตุการณ์นี้เกิดเหตุการณ์นี้ เมื่อเกิดเหตุการณ์นี้ที่เกิดขึ้น
 และถ้าสิ่งที่ก่อให้เกิดสิ่งอื่น ๆ ที่ดี
 แต่คุณไม่ต้องการที่จะพยายามทำรหัสซับซ้อน
 ที่คุณกำลังเรียกสิ่งที่หลายคนในเวลาเดียวกัน
 เพราะคุณกำลังจะให้ตัวเองปวดหัว
 

ขวาทั้งหมด ตอนนี้เราสามารถได้รับหน้าของเราที่จะจัดการกับเหตุการณ์
 แต่ขอบอกว่าผู้ใช้คลิกที่ปุ่ม
 หากฉันต้องการที่จะส่งขอให้กลับไปยังเซิร์ฟเวอร์
 แต่ฉันไม่ต้องการที่จะโหลดหน้าเว็บเพราะไม่ต้องโหลดหน้าใหม่
 ทุกเวลาเดียวที่จะได้รับชนิดของน่าเบื่อและทำไมฉันต้อง
 ที่จะดึงลงส่วนหัวอีกครั้งและท้ายอีกครั้ง
 และองค์ประกอบทั้งหมดของหน้าเว็บอีกครั้ง
 เพียงเพื่อการฟื้นฟูอวยพรหรือเวลาหรือไม่
 ดังนั้นที่ว่าทำไมเรามีบางอย่างเช่นอาแจ็กซ์
 เราสามารถทำอะไรที่นี่กับอาแจ็กซ์คือเราสามารถพูดได้ว่าสิทธิทั้งหมด
 ผมต้องการที่จะส่งข้อมูลบางส่วนไปยังเซิร์ฟเวอร์
 และฉันต้องการที่จะได้รับการตอบสนองกลับดังนั้นฉันสามารถปรับปรุงหน้าของฉัน
 หรืออาจจะแค่ทำบางขั้นตอนวิธีการคำนวณที่ไม่จำเป็นต้องแสดงอะไรให้กับผู้ใช้
 สิ่งที่คุณต้องทำเช่นนี้? ดีที่คุณต้อง URL ที่คุณต้องพูดคุยกับ
 เซิร์ฟเวอร์ของคุณไม่สามารถเพียงแค่ฟังอย่างน่าอัศจรรย์ในจากที่ไหนเลย
 คุณจำเป็นต้องมีสถานที่เฉพาะที่คุณจะส่งข้อมูลนี้ไปยัง
 และคุณยังต้องการข้อมูลบางอย่างที่จะส่งหรืออาจจะเป็นแบบสอบถาม dataless
 คุณเพียงแค่ต้องการที่จะ ping กลับไปยังเซิร์ฟเวอร์และพูดว่าเดี๋ยวก่อนฉันยังมีชีวิตอยู่หรือสิ่งที่ต้องการ
 และแล้วคุณต้องการฟังก์ชั่นที่พื้นจัดการกับความสำเร็จ
 สมมติว่าคุณได้รับกลับข้อมูลบางส่วนจากเซิร์ฟเวอร์ของคุณ
 และคุณต้องการที่จะเปลี่ยนชื่อของผู้ใช้บนหน้าเว็บของพวกเขา
 ดังนั้นคุณจะได้รับข้อมูลกลับ
 และคุณจะผลักดันให้ไปที่หน้าจอ
 สิ่งที่เกิดขึ้นคือเมื่อหน้าพร้อม
 คุณสร้างฟังก์ชั่นคลิกสำหรับปุ่มที่เรียกว่ารู้ตัวนี้ สิ่งนี้จากนั้นจะเป็นเมื่อปุ่มที่จะผลัก
 คุณพูดคุยกับ greetings.php คุณทำคำขอ POST,
 และท่านทั้งหลายว่าเ​​ดี๋ยวก่อนฉันได้รับอะไรบางอย่างจากหน้าเว็บของคุณ
 เราไม่จำเป็นต้องอธิบายว่า แต่ greetings.php,
 ขอเพียงแค่บอกว่าให้กลับ "สวัสดีโลก."
 ดังนั้นเราจึงได้รับกลับนี้ "hello โลก" และในความสำเร็จนี้
 สมมติว่าไม่มีอะไรผิดพลาดแล้วเราก็ไปที่สถานที่เป้าหมายนี้
 ที่เราระบุไว้และเราก็ติดในการตอบสนองมี
 และนี่คือวิธีที่ง่ายมากของการตั้งค่าการค้นหาอาแจ็กซ์
 

อย่างรวดเร็วร็อบประเภทที่กล่าวถึงนี้แล้ว
 สิ่งที่สามารถไปผิดสิ่งที่ไม่ดีสามารถเกิดขึ้น
 ดังนั้นคุณจึงต้องการที่จะทำความคุ้นเคยกับเหล่านี้รหัสการตอบสนอง
 สิ่งเหล่านี้จะเป็นเพียงเช่น, 200, ทุกอย่างก็โอเค
 สิ่งอื่นสิ่งเลวร้ายที่เกิดขึ้น
 มันเป็นโดยทั่วไปสิ่งที่คุณต้องการที่จะจำ
 แต่มันเป็นเรื่องที่ดีที่จะรู้ว่าสิ่งเหล่านี้
 และในที่สุดเมื่อเราได้ไปผ่านทุกที่
 เราต้องพูดคุยอย่างรวดเร็วเกี่ยวกับการออกแบบ
 แล้วเราสามารถช่วยให้คุณทั้งหมดออกจาก
 ออกแบบ สิ่งที่คุณอยากจะจดจำ
 ถามตัวเองคำถามเหล่านี้: ใครจะใช้นี้
 สิ่งที่พวกเขาจะใช้มันสำหรับ สิ่งที่ผู้ใช้ของฉันเกี่ยวกับการดูแล?
 สิ่งใดที่ไม่ได้พวกเขาดูแลเกี่ยวกับ
 คุณเพียงแค่ไม่ต้องการที่จะทำให้ app และปล่อยให้มันเป็นเพียงแค่เติบโต
 และกลายเป็นยักษ์นี้สิ่งที่ทุกคนมากที่คุณไม่สามารถแม้แต่จะเสร็จสิ้น
 คุณต้องการที่จะมีเป้าหมายต่อเนื่องและแผนและสิ่งที่คุณต้องการที่จะอยู่
 ทำให้มันง่ายดาย ทั้งหมดนี้กล่าวว่าโดยทั่วไป
 ทำให้ง่ายสำหรับผู้ใช้ที่จะใช้มันไม่ได้ทำให้มันหยดยักษ์ของข้อความเช่นสไลด์นี้เป็นจริง
 คุณเพียงแค่ต้องการให้เป็นสิ่งที่มันเป็นเรื่องง่ายมากสำหรับคนที่จะไปใน
 และทำในสิ่งที่พวกเขาต้องการที่จะทำ
 คุณไม่ต้องการให้พวกเขาที่จะมีการเลื่อนหน้า 5
 ที่จะได้รับการทำงานที่สำคัญของคุณในเว็บไซต์ของคุณ
 หาก Google มี 5 หน้าก่อนที่คุณจะสามารถค้นหาบางสิ่งบางอย่าง
 ไม่มีใครจะใช้มัน
 และสุดท้ายต้นแบบกระดาษกลุ่มโฟกัส
 มีการออกแบบและการทดสอบการปฏิบัติที่ดี
 เพียงเพราะคุณคิดว่ามันเหมาะกับคุณ
 ไม่ได้หมายความว่าคนอื่นคิดว่ามันทำงาน
 แต่ใช่ที่มัน
 [CS50.TV]