ในโลกของการพัฒนาซอฟต์แวร์, ความเข้าใจในการทำงานของหน่วยความจำคอมพิวเตอร์เป็นปัจจัยสำคัญที่จะช่วยให้นักพัฒนาสามารถเขียนโค้ดที่มีประสิทธิภาพและถูกต้องได้ เมื่อเราพูดถึงหน่วยความจำในคอมพิวเตอร์ สองคำที่พบบ่อยคือ "Heaps" และ "Stacks" ซึ่งเป็นสองโครงสร้างพื้นฐานที่ใช้สำหรับการจัดการกับข้อมูล และการทำความเข้าใจถึงลักษณะและการใช้งานของทั้งสองนี้ มีความสำคัญอย่างยิ่งต่อการเขียนโปรแกรมที่ดี
Heap เป็นพื้นที่หน่วยความจำที่ใช้สำหรับการจัดเก็บข้อมูลแบบไดนามิก หมายความว่าข้อมูลที่จัดเก็บสามารถขยายหรือหดตัวได้ตามที่โปรแกรมต้องการในระหว่างการทำงานของโปรแกรม โดยปกติแล้ว ข้อมูลที่ถูกจัดการโดย Heap เช่น อาร์เรย์ที่มีขนาดเปลี่ยนแปลงได้หรือออบเจ็กต์, เราสามารถสร้างข้อมูลเหล่านี้ได้ในระหว่างที่โปรแกรมทำงานและไม่จำเป็นต้องมีขนาดที่แน่นอนไว้ล่วงหน้า
Stack หรือ "stack memory" เป็นพื้นที่หน่วยความจำที่จัดเก็บข้อมูลแบบลำดับที่มีการเปลี่ยนแปลงตามลำดับก่อนหลัง หรือ Last-In-First-Out (LIFO) หมายความว่าข้อมูลล่าสุดที่เข้ามาจะเป็นข้อมูลแรกที่จะถูกนำออก Stack ถูกใช้สำหรับการจัดเก็บข้อมูลที่รู้ขนาดแน่นอนล่วงหน้า เช่น ตัวแปรของฟังก์ชัน และระเบียบการเรียกใช้ฟังก์ชัน (call stack)
การเขียนโปรแกรมไม่ใช่เพียงการใช้ภาษาโปรแกรมเพื่อสั่งให้คอมพิวเตอร์ทำงานบางอย่าง แต่ยังรวมถึงการจัดการข้อมูลอย่างมีประสิทธิภาพและถูกต้อง การรู้จัก Heaps และ Stacks ช่วยให้นักพัฒนาเข้าใจว่าข้อมูลใดควรถูกเก็บไว้ที่ไหน และอย่างไร ซึ่งส่งผลโดยตรงต่อความเร็วและความน่าเชื่อถือของโปรแกรม
ภาษา JavaScript เป็นภาษาการเขียนโปรแกรมที่ใช้งาน Heaps และ Stacks ผ่านระบบการจัดการหน่วยความจำโดยอัตโนมัติ หรือ Garbage Collection ซึ่งช่วยให้นักพัฒนาไม่ต้องจัดการหน่วยความจำด้วยตนเองมากนัก อย่างไรก็ตาม การเข้าใจถึงการทำงานของมันยังคงมีความสำคัญ
function heappush(heap, newKey){
// push the new key
heap.push(newKey);
// get the current index of pushed key
let curr = heap.length-1;
// keep comparing till root is reached or we terminate in middle
while(curr > 0){
let parent = Math.floor((curr-1)/2)
if( heap[curr] < heap[parent] ){
// quick swap
[ heap[curr], heap[parent] ] = [ heap[parent], heap[curr] ]
// update the index of newKey
curr = parent
} else{
// if no swap, break, since we heap is stable now
break
}
}
}
function heappop(heap){
// swap root with last node
const n = heap.length;
[heap[0], heap[n-1]] = [ heap[n-1], heap[0]]
// remove the root i.e. the last item (because of swap)
const removedKey = heap.pop();
let curr = 0;
// keep going till atleast left child is possible for current node
while(2*curr + 1 < heap.length){
const leftIndex = 2*curr+1;
const rightIndex = 2*curr+2;
const minChildIndex = (rightIndex < heap.length && heap[rightIndex] < heap[leftIndex] ) ? rightIndex :leftIndex;
if(heap[minChildIndex] < heap[curr]){
// quick swap, if smaller of two children is smaller than the parent (min-heap)
[heap[minChildIndex], heap[curr]] = [heap[curr], heap[minChildIndex]]
curr = minChildIndex
} else {
break
}
}
// finally return the removed key
return removedKey;
}
function heapify(arr){
const heap = []
for(let item of arr){
heappush(heap, item)
}
return heap;
}
// follows pretty much the same logic as heappush, except minor modifications
function percolateDown(heap, index){
let curr = index;
// keep going down till heap property is established
while(2*curr + 1 < heap.length){
const leftIndex = 2*curr+1;
const rightIndex = 2*curr+2;
const minChildIndex = (rightIndex < heap.length && heap[rightIndex] < heap[leftIndex] ) ? rightIndex :leftIndex;
if(heap[minChildIndex] < heap[curr]){
// quick swap, if smaller of two children is smaller than the parent (min-heap)
[heap[minChildIndex], heap[curr]] = [heap[curr], heap[minChildIndex]]
curr = minChildIndex
} else {
break
}
}
function heapify(heap){
for(let i in heap){
percolateDown(heap, i)
}
return heap
}
using stack and queue in javascript
var stack = [];
stack.push(2); // stack is now [2]
stack.push(5); // stack is now [2, 5]
var i = stack.pop(); // stack is now [2]
alert(i); // displays 5
var queue = [];
queue.push(2); // queue is now [2]
queue.push(5); // queue is now [2, 5]
var i = queue.shift(); // queue is now [5]
alert(i); // displays 2
ในตัวอย่างข้างต้น `a` เป็นตัวแปรธรรมดาที่ถูกจัดเก็บใน stack memory เนื่องจากขนาดแน่นอนและเกี่ยวข้องโดยตรงกับการเรียกใช้ฟังก์ชัน `example` ในขณะที่ `b` เป็นอาร์เรย์ที่ขนาดอาจเปลี่ยนแปลงถูกจัดเก็บใน heap memory ทำให้สามารถสร้างข้อมูลโดยไม่ต้องกังวลว่าจำนวนข้อมูลนั้นจะเปลี่ยนแปลงในระหว่างทำงานของโปรแกรม
หากคุณต้องการพัฒนาความสามารถการเขียนโปรแกรมของคุณให้เกินขีดจำกัด การเรียนรู้เกี่ยวกับ Heaps และ Stacks เป็นสิ่งที่ควรทำ โดยนักเรียนทุกคนที่ Expert-Programming-Tutor (EPT) จะได้รับการอบรมในหลักสูตรของเราเพื่อทำความเข้าใจในส่วนนี้อย่างล้ำลึก เพราะเมื่อเข้าใจถึงการทำงานของหน่วยความจำ คุณจะสามารถเขียนโปรแกรมที่มีประสิทธิภาพสูง และป้องกันข้อผิดพลาดที่อาจเกิดขึ้นได้
พร้อมที่จะเริ่มต้นการเดินทางในโลกการเขียนโปรแกรมอย่างมืออาชีพแล้วหรือยัง? ที่ Expert-Programming-Tutor เราพร้อมที่จะสนับสนุนและช่วยเหลือคุณให้บรรลุเป้าหมายของคุณในการเป็นนักพัฒนาซอฟต์แวร์ที่เฉียบคมและมีความสามารถ ลงทะเบียนเข้าร่วมคอร์สของเรารับประกันคุณจะได้รับทักษะและความรู้พื้นฐานที่จำเป็นเพื่อนำไปใช้งานในโลกโปรแกรมมิ่งที่กว้างใหญ่ สนใจเรียนรู้เพิ่มเติม? ติดต่อ EPT วันนี้!
หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง
หากเจอข้อผิดพลาด หรือต้องการพูดคุย ติดต่อได้ที่ https://m.me/expert.Programming.Tutor/
หากมีข้อผิดพลาด/ต้องการพูดคุยเพิ่มเติมเกี่ยวกับบทความนี้ กรุณาแจ้งที่ http://m.me/Expert.Programming.Tutor
085-350-7540 (DTAC)
084-88-00-255 (AIS)
026-111-618
หรือทาง EMAIL: NTPRINTF@GMAIL.COM