ฉันต้องการที่จะเพิ่มคำตอบสำหรับคำถามนี้เพราะฉันได้รับการจู่โจมผ่าน Java ที่ดี, ไม่ดี แต่ส่วนใหญ่น่าเกลียดเมื่อเร็ว ๆ นี้และฉันมีโหลดใหม่ทั้งหมดของภาระงานเกินขอบเขตทั่วๆไปเกี่ยวกับ Java และ Java devs vs. JS และ JS devs ที่อาจมีพื้นฐานมาจากสิ่งที่คล้ายกับความจริงที่เป็นประโยชน์
มี IDEs แต่มันก็มีประโยชน์ที่จะเข้าใจว่าทำไมไม่มีอะไรมากมาย
ฉันได้ลองใช้ Webstorm แล้วตอนนี้ฉันพบว่าตัวเองชอบที่จะพัฒนา Node และมันก็ไม่เลวร้ายพอที่ฉันซื้อมันจริงๆ แต่ฉันก็ยังคงมีแนวโน้มที่จะเปิดไฟล์ js ใน Scite บ่อยกว่า WS เหตุผลนี้คือคุณสามารถทำสิ่งต่างๆได้มากขึ้นด้วย JS ที่น้อยลง แต่เนื่องจาก UI ทำงานให้ความคิดเห็นทันทีเครื่องมือ dev ของเบราว์เซอร์ (โดยเฉพาะ Chrome และ Firebug โดยเฉพาะ) นั้นยอดเยี่ยมมากและ (บัญชีสำหรับบริบทที่ไม่ใช่เบราว์เซอร์) ) การเรียกใช้โค้ดที่เปลี่ยนแปลงใหม่นั้นทำได้ง่ายและรวดเร็วโดยไม่ต้องมีขั้นตอนการคอมไพล์
อีกสิ่งหนึ่งที่ฉันเชื่อว่าค่อนข้างเป็นธรรมโดยทั่วไปแล้ว IDEs สร้างความต้องการของตนเองโดยการเปิดใช้งานโค้ดเลอะเทอะซึ่งคุณไม่สามารถจ่ายได้ใน JavaScript ต้องการเรียนรู้วิธีที่เราจัดการใน JS หรือไม่ มันอาจช่วยในการเริ่มต้นโดยพยายามเขียนสิ่งที่ไม่สำคัญใน Java โดยไม่ต้อง IDE และใส่ใจกับสิ่งที่คุณต้องเริ่มต้นทำและคิดเพื่อที่จะสามารถรักษา / แก้ไขรหัสนั้นโดยไม่ต้องย้าย IDE ข้างหน้า IMO สิ่งเหล่านั้นยังคงมีความสำคัญต่อการเขียนโค้ดที่สามารถบำรุงรักษาได้ไม่ว่าคุณจะมี IDE หรือไม่ก็ตาม ถ้าฉันต้องเขียนหลักสูตรการเขียนโปรแกรม 4 ปีมันจะไม่ให้คุณสัมผัส IDE ในช่วงสองปีแรกเพื่อไม่ให้ได้รับเครื่องมือและการพึ่งพาที่บิดเบี้ยว
โครงสร้าง
JS ที่มีประสบการณ์จัดการกับแอ็พพลิเคชันที่ซับซ้อนสามารถและจัดโครงสร้างโค้ดของพวกเขา ในความเป็นจริงสิ่งหนึ่งที่เรามักจะต้องดีกว่าคือในช่วงต้นประวัติศาสตร์ที่ขาด IDEs ในการอ่านรหัสสำหรับเรา แต่ก็เป็นเพราะภาษาที่มีพลังสามารถแสดงออกได้อย่างมีพลังสามารถแสดงรหัสฐานความเสียหายที่ไม่สามารถทำลายได้อย่างรวดเร็ว
จริง ๆ แล้วฉันมีช่วงการเรียนรู้ที่ค่อนข้างสูงชันในการทำความเข้าใจโค้ด Java ของเราเมื่อไม่นานมานี้จนกระทั่งในที่สุดฉันก็รู้ว่าไม่มี OOP ที่เหมาะสม ชั้นเรียนไม่มีอะไรมากไปกว่าการรวมกลุ่มของวิธีการที่เกี่ยวข้องอย่างหลวม ๆ เปลี่ยนข้อมูลที่มีอยู่ทั่วโลกซึ่งนั่งอยู่ในถั่วหรือ DTOs หรือตัวรับสัญญาณแบบคงที่ นั่นคือสัตว์ร้ายตัวเดิมที่ควรจะแทนที่ OOP ดังนั้นฉันจึงหยุดมองและคิดเกี่ยวกับรหัสโดยพื้นฐาน ฉันเพิ่งเรียนรู้ปุ่มทางลัดและสืบหาความยุ่งเหยิงและทุกอย่างราบรื่นขึ้น ดังนั้นหากคุณไม่ได้ติดนิสัยให้คิดเรื่อง OOD ให้มากขึ้น
แอพ JS ที่มีโครงสร้างที่ดีในระดับสูงสุดจะมีฟังก์ชั่นที่ซับซ้อน (เช่น jQuery) และวัตถุที่มีปฏิสัมพันธ์ซึ่งกันและกัน ฉันจะยืนยันว่าเครื่องหมายของแอพที่มีโครงสร้างและบำรุงรักษาง่ายในภาษาใด ๆ ก็คือมันชัดเจนว่าคุณกำลังมองหาด้วย IDE หรือ Notepad ++ มันเป็นหนึ่งในเหตุผลหลักที่ฉันมีความสำคัญอย่างยิ่งต่อการฉีดขึ้นต่อกันและการทดสอบ TDD ครั้งแรกที่นำไปสู่จุดสูงสุด
และในที่สุดก็เลิกเรียน เรียนรู้มรดกต้นแบบ เป็นเรื่องง่ายมากที่จะใช้งานเมื่อคุณต้องการรับมรดก ฉันพบว่าวิธีการเรียงความมีแนวโน้มที่จะทำงานได้ดีขึ้นใน JS และฉันเริ่มป่วยและมีความหวาดกลัวตอนกลางคืนเมื่อใดก็ตามที่ฉันเห็นการสืบทอดมากกว่าหนึ่งหรือสองระดับในภาษาใด ๆ
หลักการสำคัญก่อน
ฉันกำลังพูดถึงสิ่งสำคัญที่การปฏิบัติที่ดีอื่น ๆ ควรมาจาก: DRY, YAGNI หลักการของความประหลาดใจอย่างน้อยที่สุดการแยกโดเมนปัญหาอย่างชัดเจนการเขียนไปยังอินเทอร์เฟซและการเขียนรหัสที่อ่านง่ายของมนุษย์ สิ่งที่ซับซ้อนกว่าเล็กน้อยที่สนับสนุนการละทิ้งการปฏิบัติเหล่านั้นควรได้รับการพิจารณาว่าเป็น Kool Aid ในภาษาใด ๆ โดยเฉพาะอย่างยิ่งภาษาอย่าง JavaScript ซึ่งมันง่ายมากที่จะทิ้งรหัสที่สับสนไว้สำหรับคนต่อไป ยกตัวอย่างเช่นการมีเพศสัมพันธ์แบบหลวม ๆ เป็นสิ่งที่ดีจนกระทั่งคุณไม่สามารถบอกได้ว่ามีปฏิสัมพันธ์ระหว่างวัตถุเกิดขึ้นที่ไหน
อย่ากลัวการพิมพ์แบบไดนามิก
JavaScript มีประเภทหลักไม่มากนัก ส่วนใหญ่กฎการส่งสัญญาณแบบไดนามิกนั้นใช้งานได้จริงและตรงไปตรงมา แต่จ่ายเพื่อเรียนรู้กฎเหล่านั้นเพื่อให้คุณสามารถเรียนรู้การจัดการการไหลของข้อมูลได้ดีขึ้นโดยไม่ต้องใช้ casts ที่ไม่จำเป็น เชื่อฉัน. ประเภทที่เข้มงวดนั้นยอดเยี่ยมสำหรับประสิทธิภาพและการระบุปัญหาในการคอมไพล์ แต่มันก็ไม่ได้ป้องกันคุณจากสิ่งใด
เรียนรู้ Crap จากฟังก์ชั่น JS และการปิด
ฟังก์ชั่นชั้นหนึ่งของ JS นั้นเป็นเหตุผลหลักที่ JS ได้รับรางวัล "ภาษาที่ควรค่าแก่การสัมผัสกับเว็บไคลเอ็นต์ที่มีรางวัล" และใช่มีการแข่งขันจริง พวกเขายังเป็นคุณลักษณะสำคัญของ JS เราสร้างวัตถุกับพวกเขา ทุกอย่างถูกกำหนดขอบเขตไว้ที่ฟังก์ชัน และพวกเขามีคุณสมบัติที่มีประโยชน์ เราสามารถตรวจสอบพารามิเตอร์ผ่านคีย์เวิร์ดอาร์กิวเมนต์ เราสามารถแนบและยิงพวกมันชั่วคราวในบริบทของการเป็นวิธีการของวัตถุอื่น ๆ และพวกเขาสร้างวิธีการที่ขับเคลื่อนด้วยเหตุการณ์สำหรับสิ่งต่าง ๆ ที่ง่ายต่อการใช้งาน ในระยะสั้นพวกเขาทำให้ JS เป็นสัตว์ร้ายที่ลดความซับซ้อนและปรับใช้การใช้งานที่แตกต่างกันของ JS ตัวเอง (แต่ส่วนใหญ่ DOM API) ที่แหล่งที่มา
ประเมินรูปแบบ / การปฏิบัติซ้ำอีกครั้งก่อนนำไปใช้
ฟังก์ชั่นชั้นหนึ่งและประเภทแบบไดนามิกทำให้รูปแบบการออกแบบที่ซับซ้อนมากขึ้นไม่มีจุดหมายและยุ่งยากใน JS อย่างไรก็ตามรูปแบบที่เรียบง่ายบางอย่างนั้นมีประโยชน์อย่างเหลือเชื่อและง่ายต่อการนำไปใช้เนื่องจากลักษณะที่ยืดหยุ่นสูงของ JS อะแดปเตอร์และอุปกรณ์ตกแต่งมีประโยชน์อย่างยิ่งและฉันพบว่ามีประโยชน์สำหรับโรงงานเครื่องมือ UI ที่ซับซ้อนซึ่งยังทำหน้าที่เป็นผู้จัดการกิจกรรมสำหรับองค์ประกอบ UI ที่พวกเขาสร้าง
ทำตามเป้าหมายของภาษาและทำสิ่งต่างๆได้มากขึ้นด้วยการใช้น้อยลง
ฉันเชื่อว่าหนึ่งในหัวหน้าจาวาจาวาทำให้เกิดการโต้แย้งที่ไหนสักแห่งที่ความฟุ่มเฟื่อยเป็นจริงคุณลักษณะที่เป็นบวกที่ทำให้โค้ดเข้าใจได้ง่ายขึ้นสำหรับทุกฝ่าย hogwash หากเป็นเรื่องจริงนักกฎหมายจะอ่านง่ายขึ้น มีเพียงนักเขียนเท่านั้นที่สามารถทำให้สิ่งที่พวกเขาเขียนเข้าใจง่ายขึ้นและคุณทำได้โดยใส่ตัวเองในรองเท้าของผู้ชายคนอื่นเป็นครั้งคราว ดังนั้นยอมรับกฎทั้งสองนี้ 1. เป็นคนตรงและชัดเจนที่สุด 2. ไปที่จุดแช่งแล้ว การชนะคือรหัสที่สะอาดและรัดกุมคือคำสั่งของขนาดที่ง่ายต่อการเข้าใจและบำรุงรักษามากกว่าสิ่งที่คุณต้องสำรวจเลเยอร์ยี่สิบห้าเพื่อรับจากทริกเกอร์ไปสู่การกระทำที่ต้องการจริง รูปแบบส่วนใหญ่ที่สนับสนุนสิ่งนั้นในภาษาที่เข้มงวดนั้นเป็นวิธีแก้ไขข้อ จำกัด ที่ JavaScript ไม่มีอยู่จริง
ทุกอย่างอ่อนและไม่เป็นไร
JS น่าจะเป็นหนึ่งในภาษาที่นิยมใช้น้อยที่สุด ยอมรับว่า มันใช้งานได้ดี เช่นคุณสามารถเขียนออบเจ็กต์ด้วย vars "ส่วนตัว" ที่ไม่สามารถเข้าถึงได้โดยเพียงประกาศ vars ปกติในฟังก์ชัน constructor และฉันทำสิ่งนี้บ่อยๆ แต่ไม่ใช่เพื่อปกป้องรหัสหรือผู้ใช้ของฉัน "จากตัวเอง" (พวกเขาสามารถแทนที่มันด้วยเวอร์ชันของตัวเองในช่วงรันไทม์อยู่ดี) แต่แทนที่จะส่งสัญญาณความตั้งใจเพราะข้อสันนิษฐานก็คือผู้ชายคนอื่นมีความสามารถพอที่จะไม่ต้องการทำลายการอ้างอิงใด ๆ และจะเห็นว่าคุณไม่ได้ตั้งใจที่จะไปที่นั่นโดยตรงด้วยเหตุผลที่ดี
ไม่มีการ จำกัด ขนาดเฉพาะโดเมนที่มีปัญหา
ปัญหาที่ใหญ่ที่สุดที่ฉันมีกับโค้ด Java ทั้งหมดที่ฉันเห็นคือไฟล์คลาสมากเกินไป ก่อนอื่น SOLID เป็นเพียงการกล่าวซ้ำที่สับสนของสิ่งที่คุณควรทราบเกี่ยวกับ OOP คลาสควรจัดการกับชุดของปัญหาที่เกี่ยวข้อง ไม่ใช่ปัญหาเดียวกับวิธีหนึ่ง นั่นเป็นเพียงการใช้โค้ด C func-spaghetti เก่าที่ไม่ดีเท่านั้นด้วยการเพิ่มไวยากรณ์คลาสที่ไม่มีจุดหมายทั้งหมดเพื่อเริ่มระบบ ไม่มีการ จำกัด ขนาดหรือวิธีการ ถ้ามันสมเหตุสมผลที่จะเพิ่มบางสิ่งลงในฟังก์ชันหรือคลาสหรือคอนสตรัคเตอร์ที่มีความยาวอยู่แล้ว รับ jQuery มันเป็นชุดเครื่องมือที่มีความยาวไลบรารีทั้งหมดในฟังก์ชั่นเดียวและไม่มีอะไรผิดปกติกับมัน ไม่ว่าเราจะต้องการ jQuery ก็ขึ้นอยู่กับการถกเถียงที่สมเหตุสมผล แต่ในแง่ของการออกแบบ
หาก Java เป็นสิ่งที่คุณรู้ว่าตะลุยสิ่งที่มีไวยากรณ์ที่ไม่ใช่ C
เมื่อฉันเริ่มยุ่งกับ Python เพราะฉันชอบสิ่งที่ฉันได้ยินเกี่ยวกับ Django ฉันเรียนรู้ที่จะเริ่มแยกไวยากรณ์จากการออกแบบภาษา เป็นผลให้มันง่ายขึ้นที่จะเข้าใจ Java และ C เป็นผลรวมของส่วนการออกแบบภาษาของพวกเขามากกว่าผลรวมของสิ่งที่พวกเขาทำแตกต่างกับไวยากรณ์เดียวกัน ผลข้างเคียงที่ดีคือยิ่งคุณเข้าใจภาษาอื่นในแง่ของการออกแบบมากเท่าไหร่คุณก็ยิ่งเข้าใจจุดแข็ง / จุดอ่อนของคนที่คุณรู้จักดีที่สุดในทางตรงกันข้ามได้ดีขึ้น
ข้อสรุป
ทีนี้เมื่อพิจารณาถึงสิ่งเหล่านี้แล้วลองมาดูปัญหาของคุณทั้งหมด:
- ไม่มีวิธีการค้นหาจุดเข้าใช้งานของฟังก์ชันในทันที (นอกเหนือจากการค้นหาข้อความธรรมดาซึ่งอาจส่งผลให้มีการค้นหาวิธีการตามลำดับชั้นการโทรที่ตามมาหลังจากนั้นสองหรือสามแห่งซึ่งคุณลืมไปว่าคุณเริ่มต้นที่ไหน)
Chrome และ Firebug มีการติดตามการโทรจริง แต่ดูจุดของฉันในโครงสร้างและทำให้สิ่งต่าง ๆ รัดกุมและตรงไปตรงมา ยิ่งคุณนึกถึงแอปของคุณในฐานะโครงสร้างที่มีการห่อหุ้มขนาดใหญ่ที่มีการโต้ตอบซึ่งกันและกันได้ง่ายยิ่งขึ้นเมื่อพิจารณาว่ามีข้อบกพร่องเกิดขึ้นได้ง่ายเพียงใด ฉันจะบอกว่านี่เป็นความจริงของ Java เช่นกัน เรามีตัวสร้างฟังก์ชั่นคล้ายคลาสที่ให้บริการที่สมบูรณ์แบบสำหรับข้อกังวล OOP
function ObjectConstructor(){
//No need for an init method.
//Just pass in params and do stuff inside for instantiation behavior
var privateAndPersistent = true;
//I like to take advantage of function hoisting for a nice concise interface listing
this.publicAndPointlessEncapsulationMurderingGetterSetter
= publicAndPointlessEncapsulationMurderingGetterSetter;
//Seriously though Java/C# folks, stop with the pointless getter/setters already
function publicAndPointlessEncapsulationMurderingGetterSetter(arg){
if(arg === undefined){
return privateAndPersistent;
}
privateAndPersistent = arg;
}
}
ObjectConstructor.staticLikeNonInstanceProperty = true;
var instance = new ObjectConstructor();//Convention is to capitalize constructors
ในรหัสของฉันฉันแทบจะไม่เคยใช้ตัวอักษรวัตถุ{}เป็นส่วนประกอบแอพโครงสร้างเพราะพวกเขาไม่สามารถมี vars ภายใน (ส่วนตัว) และชอบที่จะสำรองไว้เพื่อใช้เป็นโครงสร้างข้อมูล ที่ช่วยกำหนดความคาดหวังที่รักษาความชัดเจนของเจตนา (หากคุณเห็น curlies เป็นข้อมูลไม่ใช่องค์ประกอบของสถาปัตยกรรมแอป)
- พารามิเตอร์ถูกส่งผ่านไปยังฟังก์ชั่นโดยที่ไม่มีทางรู้ได้ว่าคุณสมบัติและฟังก์ชั่นใดที่มีอยู่ในพารามิเตอร์นั้น (นอกเหนือจากการรันโปรแกรมจริง ๆ แล้วนำทางไปยังจุดที่เรียกใช้ฟังก์ชันและใช้ console.logs เพื่อแสดงคุณสมบัติทั้งหมด สามารถใช้ได้)
ดูเครื่องมือเบราว์เซอร์ที่ทันสมัยอีกครั้ง แต่ทำไมมันถึงเป็นคนเกียจคร้านที่จะรันโปรแกรมอีกครั้ง? โหลดซ้ำเป็นสิ่งที่เว็บ dev ฝั่งไคลเอ็นต์มักจะพบเห็นทุกสองสามนาทีเพราะคุณไม่ต้องทำอะไรเลย นี่เป็นอีกจุดหนึ่งที่โครงสร้างแอปมีประโยชน์ แต่เป็นข้อเสียอย่างหนึ่งของ JS ที่คุณต้องทำการตรวจสอบความถูกต้องของตัวเองเมื่อการบังคับใช้สัญญามีความสำคัญ (สิ่งที่ฉันทำที่จุดปลายสัมผัสกับสิ่งอื่น ๆ เท่านั้น ไม่สามารถควบคุมได้) IMO การค้าขายนั้นคุ้มค่ากับผลประโยชน์
- การใช้งานทั่วไปของฟังก์ชั่นที่ไม่ระบุชื่อเป็นการเรียกกลับซึ่งมักจะนำไปสู่ปาเก็ตตี้ของเส้นทางรหัสสับสนที่คุณไม่สามารถนำทางไปรอบ ๆ อย่างรวดเร็ว
ใช่มันเป็นสิ่งที่ไม่ดีเลย อย่าทำอย่างนั้น ตั้งชื่อลูกของคุณฟังก์ชั่น ง่ายต่อการติดตามสิ่งต่าง ๆ เช่นกัน คุณสามารถกำหนดประเมิน (จำเป็นต้องกำหนด) และกำหนดฟังก์ชั่นเรื่องง่าย ๆ ในแนวเดียวกันกับ:
doSomethingWithCallback( (function callBack(){}) );
ตอนนี้ Chrome จะมีชื่อให้คุณเมื่อคุณติดตามการโทร สำหรับ func ที่ไม่สำคัญฉันจะนิยามมันนอกการโทร นอกจากนี้โปรดทราบว่าฟังก์ชั่น anonoymous ที่กำหนดให้กับตัวแปรยังคงไม่ระบุชื่อ
- และแน่นอนว่า JSLint สามารถตรวจจับข้อผิดพลาดบางอย่างได้ก่อนที่จะทำการรันไทม์ แต่ถึงกระนั้นก็ยังไม่สะดวกเท่ากับการมีเส้นหยักสีแดงใต้รหัสของคุณในเบราว์เซอร์โดยตรง
ฉันไม่เคยแตะต้องสิ่งของเลย Crockford ได้มอบสิ่งที่ดีให้กับชุมชน แต่ JSLint ข้ามเส้นไปสู่การตั้งค่าโวหารและการแนะนำองค์ประกอบบางอย่างของ JavaScript เป็นส่วนที่ไม่ดีโดยไม่มีเหตุผลที่ดีโดยเฉพาะ IMO ละเว้นสิ่งหนึ่งอย่างแน่นอนเกี่ยวกับคลาส regEx และ negation ตามด้วย * หรือ + อักขระตัวแทนมีประสิทธิภาพต่ำกว่าและคุณสามารถ จำกัด การซ้ำซ้อนได้อย่างง่ายดายด้วย {} อย่าสนใจสิ่งที่เขาพูดเกี่ยวกับตัวสร้างฟังก์ชัน คุณสามารถพันคำเหล่านั้นใน func จากโรงงานได้หากคำหลักใหม่ทำให้คุณรำคาญ CSSLint (ไม่ใช่ของคร็อคฟอร์ด) ยิ่งแย่กว่าคำแนะนำที่ไม่ดี มักจะพาคนที่ทำธุระที่พูดเยอะ ๆ ด้วยเกลือเม็ดหนึ่ง บางครั้งฉันสาบานว่าพวกเขาแค่ต้องการสร้างอำนาจหรือสร้างเนื้อหาใหม่
และอีกครั้งคุณต้องคลายความเข้าใจในสิ่งที่คุณเรียนรู้ด้วยความกังวลที่เกิดขึ้นในตอนนี้ (เป็นเรื่องปกติที่ฉันเคยเห็นด้วย Java / C # devs จำนวนมาก) หากพบข้อผิดพลาดในเวลาทำงานยังคงรบกวนคุณอีก 2 ปีต่อมาฉันต้องการให้คุณนั่งลงและสแปมโหลดในเบราว์เซอร์จนกว่ามันจะจมลงมา ไม่มีการคอมไพล์เวลา / รันไทม์ (ไม่เห็นอย่างใดอย่างหนึ่งอยู่แล้ว - JS ทำงานบน JIT ตอนนี้) ไม่เพียง แต่จะค้นพบข้อบกพร่องในเวลาทำงานเท่านั้น แต่ยังมีประโยชน์อย่างมากในการโหลดสแปมในราคาถูกและง่ายดายและค้นหาข้อบกพร่องที่จุดหยุดทุกจุดที่คุณไป
และรับ crackin 'บนเครื่องมือ dev Chrome พวกมันถูกติดตั้งมาที่ webkit โดยตรง คลิกขวาใน Chrome ตรวจสอบองค์ประกอบ. สำรวจแท็บ มีพลังการดีบักมากมายพร้อมกับความสามารถในการเปลี่ยนรหัสในคอนโซลระหว่างรันไทม์เป็นหนึ่งในตัวเลือกที่ทรงพลังที่สุด แต่ไม่ค่อยชัดเจน เหมาะสำหรับการทดสอบเช่นกัน
ในบันทึกที่เกี่ยวข้องข้อผิดพลาดคือเพื่อนของคุณ อย่าเขียนคำสั่ง catch ที่ว่างเปล่า ใน JS เราทำไม่ได้ซ่อนหรือฝังข้อผิดพลาด (หรืออย่างน้อยเราไม่ควรไอยูอิ/ ไอ ) เราเข้าร่วมกับพวกเขา อะไรที่น้อยลงจะส่งผลให้ความเจ็บปวดในการแก้ปัญหา และถ้าคุณเขียนคำสั่ง catch เพื่อซ่อนข้อผิดพลาดที่อาจเกิดขึ้นในการผลิตอย่างน้อยก็เงียบบันทึกข้อผิดพลาดและเอกสารวิธีการเข้าถึงบันทึก