Guest Adventurer 🥉 Lv.1
🪙 50
🔷 10
← Back to library
Article · programming

JavaScript: Array และการจัดการข้อมูล

JavaScript

EP7 ของชุด JavaScript คืออะไร? เริ่มต้นเขียนโปรแกรม เรียนรู้ Array การเข้าถึงสมาชิก การเพิ่มและลบข้อมูล การวนซ้ำ และเมธอด map, filter, find, reduce สำหรับการพัฒนาโปรแกรมจริง

EP7: จัดเก็บข้อมูลหลายรายการด้วย Array

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

1. Array คืออะไร

Array คือโครงสร้างข้อมูลที่ใช้เก็บสมาชิกหลายรายการตามลำดับ สมาชิกแต่ละรายการเรียกว่า element และมีตำแหน่งที่เรียกว่า index ซึ่งเริ่มต้นจาก 0 ไม่ใช่ 1 ดังนั้นสมาชิกตัวแรกอยู่ที่ index 0 สมาชิกตัวที่สองอยู่ที่ index 1 และสมาชิกตัวสุดท้ายอยู่ที่ index ซึ่งมีค่าเท่ากับจำนวนสมาชิกทั้งหมดลบหนึ่ง
const fruits = ['แอปเปิล', 'กล้วย', 'ส้ม'];

console.log(fruits[0]);
console.log(fruits[1]);
console.log(fruits[2]);
console.log(fruits.length);

// ผลลัพธ์:
// แอปเปิล
// กล้วย
// ส้ม
// 3
ตัวแปร `fruits` เก็บผลไม้สามรายการ ส่วน `length` ใช้ตรวจสอบจำนวนสมาชิกใน Array หากต้องการเข้าถึงสมาชิกตัวสุดท้ายโดยไม่ทราบจำนวนสมาชิกที่แน่นอน สามารถใช้ `fruits[fruits.length - 1]` ได้
จำให้ขึ้นใจIndex ของ Array เริ่มจาก 0 เสมอใน JavaScript และการเข้าถึงตำแหน่งที่ไม่มีสมาชิกจะได้ค่า undefined สำหรับ Array ทั่วไป การอ่าน index ที่อยู่นอกขอบเขตไม่ได้ทำให้เกิดข้อผิดพลาดโดยอัตโนมัติ

2. สร้าง Array และจัดเก็บข้อมูลหลายชนิด

เราสามารถสร้าง Array ด้วยวงเล็บเหลี่ยม `[]` และคั่นสมาชิกแต่ละรายการด้วยเครื่องหมายจุลภาค ข้อมูลภายใน Array ไม่จำเป็นต้องเป็นชนิดเดียวกันเสมอไป แต่ในงานจริงควรออกแบบโครงสร้างให้สม่ำเสมอเพื่อให้เข้าใจและบำรุงรักษาได้ง่าย
const scores = [85, 92, 78, 96];
const users = ['Anan', 'Mali', 'Niran'];
const mixed = ['สินค้า', 150, true];
const emptyList = [];

console.log(scores.length);
console.log(users[0]);
console.log(mixed[2]);
console.log(emptyList.length);

// ผลลัพธ์:
// 4
// Anan
// true
// 0
ควรใช้ `const` เมื่อไม่ต้องการกำหนดตัวแปรให้ชี้ไปยัง Array ตัวใหม่ แต่ต้องเข้าใจว่า `const` ไม่ได้ทำให้สมาชิกภายใน Array เปลี่ยนแปลงไม่ได้ เราสามารถแก้ไข เพิ่ม หรือลบสมาชิกได้ตามปกติ
const colors = ['แดง', 'เขียว', 'น้ำเงิน'];

colors[1] = 'เหลือง';
colors.push('ม่วง');

console.log(colors);

// ผลลัพธ์:
// ['แดง', 'เหลือง', 'น้ำเงิน', 'ม่วง']

3. เพิ่มข้อมูลด้วย push และ unshift

เมธอด `push()` ใช้เพิ่มสมาชิกไว้ท้าย Array ส่วน `unshift()` ใช้เพิ่มสมาชิกไว้ด้านหน้า ทั้งสองเมธอดเปลี่ยนแปลง Array เดิมและคืนค่าจำนวนสมาชิกหลังเพิ่มข้อมูลเสร็จ
const tasks = ['อ่านหนังสือ', 'ทำการบ้าน'];

const totalAfterPush = tasks.push('ออกกำลังกาย');
const totalAfterUnshift = tasks.unshift('จัดโต๊ะ');

console.log(tasks);
console.log(totalAfterPush);
console.log(totalAfterUnshift);

// ผลลัพธ์:
// ['จัดโต๊ะ', 'อ่านหนังสือ', 'ทำการบ้าน', 'ออกกำลังกาย']
// 3
// 4
ควรเลือกใช้เมธอดให้ตรงกับตำแหน่งที่ต้องการเพิ่มข้อมูล หากเพิ่มสมาชิกที่ด้านหน้าบ่อยครั้งใน Array ขนาดใหญ่ อาจมีต้นทุนในการจัดตำแหน่งสมาชิกใหม่ จึงควรพิจารณาความเหมาะสมกับลักษณะงาน

4. ลบข้อมูลด้วย pop และ shift

`pop()` ลบสมาชิกตัวสุดท้ายและคืนค่าสมาชิกที่ถูกลบ ส่วน `shift()` ลบสมาชิกตัวแรกและคืนค่าที่ถูกลบเช่นกัน หาก Array ว่าง ทั้งสองเมธอดจะคืนค่า `undefined`
const queue = ['ลูกค้า A', 'ลูกค้า B', 'ลูกค้า C'];

const lastCustomer = queue.pop();
const firstCustomer = queue.shift();

console.log(lastCustomer);
console.log(firstCustomer);
console.log(queue);

// ผลลัพธ์:
// ลูกค้า C
// ลูกค้า A
// ['ลูกค้า B']
ระวังการแก้ไข Array ต้นฉบับ`push()`, `pop()`, `shift()` และ `unshift()` เปลี่ยน Array เดิม หากมีส่วนอื่นของโปรแกรมอ้างอิง Array เดียวกัน ส่วนเหล่านั้นจะเห็นการเปลี่ยนแปลงด้วย

5. ใช้ splice และ slice ให้ถูกต้อง

`splice()` ใช้ลบหรือแทรกสมาชิกใน Array เดิม โดยรับตำแหน่งเริ่มต้น จำนวนสมาชิกที่ต้องการลบ และสมาชิกใหม่ที่ต้องการแทรก ส่วน `slice()` ใช้คัดลอกสมาชิกบางช่วงออกมาเป็น Array ใหม่ โดยไม่เปลี่ยน Array ต้นฉบับ
const original = ['A', 'B', 'C', 'D'];

const removed = original.splice(1, 2, 'X');
console.log(removed);
console.log(original);

const selected = original.slice(0, 2);
console.log(selected);
console.log(original);

// ผลลัพธ์:
// ['B', 'C']
// ['A', 'X', 'D']
// ['A', 'X']
// ['A', 'X', 'D']
เมธอดเปลี่ยน Array เดิมหน้าที่หลัก
push()ใช่เพิ่มสมาชิกท้าย Array
unshift()ใช่เพิ่มสมาชิกหน้า Array
pop()ใช่ลบสมาชิกท้าย Array
shift()ใช่ลบสมาชิกหน้า Array
splice()ใช่ลบหรือแทรกสมาชิก
slice()ไม่คัดลอกสมาชิกบางช่วง

6. ค้นหาข้อมูลด้วย includes และ indexOf

หากต้องการตรวจสอบว่ามีข้อมูลที่กำหนดอยู่ใน Array หรือไม่ สามารถใช้ `includes()` ซึ่งคืนค่า true หรือ false ส่วน `indexOf()` คืนตำแหน่งแรกที่พบข้อมูล หรือคืนค่า -1 เมื่อไม่พบ โดยการเปรียบเทียบค่าจะเป็นไปตามกฎการเปรียบเทียบของ JavaScript
const permissions = ['read', 'write', 'delete'];

console.log(permissions.includes('write'));
console.log(permissions.includes('admin'));
console.log(permissions.indexOf('delete'));
console.log(permissions.indexOf('admin'));

// ผลลัพธ์:
// true
// false
// 2
// -1
สำหรับ Array ที่เก็บ Object การใช้ `includes()` หรือ `indexOf()` จะตรวจสอบการอ้างอิงของ Object ไม่ใช่เปรียบเทียบคุณสมบัติภายในทีละฟิลด์ หากต้องการค้นหาจากรหัสสินค้า ชื่อผู้ใช้ หรือคุณสมบัติอื่น ควรใช้ `find()` หรือ `findIndex()`

7. ใช้ forEach เพื่อประมวลผลสมาชิกทุกตัว

`forEach()` เรียกฟังก์ชันสำหรับสมาชิกแต่ละตัวใน Array ตามลำดับ เหมาะกับงานที่ต้องทำบางอย่างกับแต่ละรายการ เช่น แสดงผลหรือบันทึกข้อความ โดยเมธอดนี้คืนค่า `undefined` และไม่ได้สร้าง Array ผลลัพธ์ใหม่ หากต้องการแปลงข้อมูลให้เป็น Array ใหม่ ควรพิจารณา `map()`
const students = ['มิน', 'ฟ้า', 'ต้น'];

students.forEach((student, index) => {
    console.log(`${index + 1}. ${student}`);
});

// ผลลัพธ์:
// 1. มิน
// 2. ฟ้า
// 3. ต้น
ฟังก์ชันที่ส่งให้ `forEach()` สามารถรับค่าปัจจุบัน ตำแหน่ง index และ Array ต้นฉบับเป็นอาร์กิวเมนต์ได้ตามลำดับ อย่างไรก็ตาม `forEach()` ไม่มีวิธีหยุดลูปด้วย `break` โดยตรง หากต้องการหยุดเมื่อพบเงื่อนไข ควรใช้ `for...of`, `find()` หรือเมธอดที่เหมาะสมกับงาน

8. ใช้ map เพื่อแปลงข้อมูล

`map()` สร้าง Array ใหม่จากผลลัพธ์ที่ได้จากการเรียกฟังก์ชันกับสมาชิกแต่ละตัว เหมาะกับการแปลงรูปแบบข้อมูล เช่น เปลี่ยนราคาสินค้าเป็นราคาที่รวมภาษี หรือดึงเฉพาะชื่อจากรายการ Object
const prices = [100, 250, 400];
const pricesWithTax = prices.map(price => price * 1.07);

console.log(prices);
console.log(pricesWithTax);

const products = [
    { id: 1, name: 'Keyboard', price: 1200 },
    { id: 2, name: 'Mouse', price: 450 }
];

const productNames = products.map(product => product.name);
console.log(productNames);

// ผลลัพธ์:
// [100, 250, 400]
// [107, 267.5, 428]
// ['Keyboard', 'Mouse']
ข้อดีของ `map()` คือการสร้างผลลัพธ์ใหม่โดยไม่เปลี่ยน Array ต้นฉบับในตัวอย่างนี้ การคูณราคาด้วย 1.07 เป็นตัวอย่างคำนวณภาษี 7% อย่างง่าย ในระบบการเงินจริงควรกำหนดกติกาการปัดเศษและการคำนวณตามข้อกำหนดของธุรกิจให้ชัดเจน

9. ใช้ filter เพื่อคัดกรองข้อมูล

`filter()` สร้าง Array ใหม่ที่มีเฉพาะสมาชิกซึ่งผ่านเงื่อนไข ฟังก์ชันที่ส่งเข้าไปต้องให้ผลลัพธ์ที่สามารถตีความเป็น true หรือ false ได้ เหมาะสำหรับคัดสินค้าที่มีสต็อก คัดคะแนนที่ผ่านเกณฑ์ หรือกรองรายการที่ตรงกับคำค้น
const products = [
    { name: 'Keyboard', stock: 8, price: 1200 },
    { name: 'Mouse', stock: 0, price: 450 },
    { name: 'Monitor', stock: 5, price: 5200 },
    { name: 'Webcam', stock: 0, price: 890 }
];

const availableProducts = products.filter(product => product.stock > 0);
const expensiveProducts = products.filter(product => product.price >= 1000);

console.log(availableProducts.map(product => product.name));
console.log(expensiveProducts.map(product => product.name));

// ผลลัพธ์:
// ['Keyboard', 'Monitor']
// ['Keyboard', 'Monitor']
map กับ filter ต่างกันอย่างไร`map()` เปลี่ยนสมาชิกแต่ละตัวให้เป็นผลลัพธ์รูปแบบใหม่ โดยจำนวนสมาชิกของผลลัพธ์จะเท่ากับ Array ต้นฉบับ ส่วน `filter()` เลือกเก็บเฉพาะสมาชิกที่ผ่านเงื่อนไข จึงอาจได้สมาชิกน้อยลงหรือได้ Array ว่าง

10. ใช้ find และ findIndex เพื่อค้นหา

`find()` คืนสมาชิกตัวแรกที่ผ่านเงื่อนไข หากไม่พบจะคืนค่า `undefined` ส่วน `findIndex()` คืนตำแหน่งของสมาชิกตัวแรกที่ผ่านเงื่อนไข หรือคืนค่า -1 เมื่อไม่พบ ทั้งสองเมธอดเหมาะกับการค้นหาข้อมูลที่มีคุณสมบัติหลายฟิลด์
const users = [
    { id: 101, name: 'Anan', active: true },
    { id: 102, name: 'Mali', active: false },
    { id: 103, name: 'Niran', active: true }
];

const user = users.find(item => item.id === 102);
const activeUserIndex = users.findIndex(item => item.active);
const missingUser = users.find(item => item.id === 999);

console.log(user);
console.log(activeUserIndex);
console.log(missingUser);

// ผลลัพธ์:
// { id: 102, name: 'Mali', active: false }
// 0
// undefined
ในตัวอย่าง `findIndex()` คืนค่า 0 เพราะผู้ใช้ที่ตรงเงื่อนไข active เป็นคนแรกใน Array และตำแหน่งของเขาเริ่มต้นที่ศูนย์ หากต้องการค้นหาผู้ใช้ที่ active เป็น false สามารถเปลี่ยนเงื่อนไขเป็น `item.active === false` ได้

11. ใช้ reduce เพื่อสรุปข้อมูล

`reduce()` นำสมาชิกใน Array มาประมวลผลต่อเนื่องเพื่อสร้างผลลัพธ์สะสมหนึ่งค่า เช่น ผลรวม จำนวนรายการ หรือ Object สรุปข้อมูล ควรกำหนดค่าเริ่มต้นของตัวสะสมให้ชัดเจน โดยค่าเริ่มต้นจะถูกส่งเป็นอาร์กิวเมนต์ตัวที่สองของ `reduce()`
const scores = [80, 75, 90, 85];

const total = scores.reduce((sum, score) => sum + score, 0);
const average = total / scores.length;

const sales = [
    { product: 'Keyboard', amount: 2400 },
    { product: 'Mouse', amount: 1350 },
    { product: 'Monitor', amount: 5200 }
];

const revenue = sales.reduce((sum, item) => sum + item.amount, 0);

console.log(total);
console.log(average);
console.log(revenue);

// ผลลัพธ์:
// 330
// 82.5
// 8950
ในตัวอย่าง ตัวสะสม `sum` จะรับค่าผลรวมจากรอบก่อนหน้า แล้วนำมาบวกกับคะแนนหรือยอดขายของรอบปัจจุบัน การคำนวณค่าเฉลี่ยต้องตรวจสอบด้วยว่า Array มีสมาชิกหรือไม่ เพราะการหารด้วยจำนวนสมาชิกที่เป็นศูนย์จะไม่ให้ค่าเฉลี่ยที่มีความหมาย

สูตรคำนวณค่าเฉลี่ย

\bar{x} = \frac{1}{n}\sum_{i=1}^{n} x_i

ค่าเฉลี่ยเท่ากับผลรวมของข้อมูลทุกตัวหารด้วยจำนวนข้อมูลทั้งหมด โดย n ต้องมากกว่าศูนย์

12. เรียงลำดับข้อมูลด้วย sort

`sort()` ใช้เรียงลำดับสมาชิกของ Array และเปลี่ยนแปลง Array ต้นฉบับ หากต้องการเรียงตัวเลขจากน้อยไปมาก ควรส่งฟังก์ชันเปรียบเทียบเข้าไป เพราะค่าเริ่มต้นของ `sort()` จะเรียงสมาชิกตามลำดับของสตริง ไม่ใช่ค่าตัวเลขทางคณิตศาสตร์
const numbers = [40, 5, 100, 25, 9];

const ascending = [...numbers].sort((a, b) => a - b);
const descending = [...numbers].sort((a, b) => b - a);

console.log(numbers);
console.log(ascending);
console.log(descending);

// ผลลัพธ์:
// [40, 5, 100, 25, 9]
// [5, 9, 25, 40, 100]
// [100, 40, 25, 9, 5]
เครื่องหมาย `...` ใน `[...numbers]` คือ Spread Syntax ซึ่งใช้สร้าง Array ใหม่ที่มีสมาชิกจาก Array เดิม ก่อนนำไปเรียงลำดับจึงไม่เปลี่ยนลำดับของ `numbers` ต้นฉบับ หาก Array มี Object การคัดลอกแบบนี้เป็นเพียงการคัดลอกชั้นแรก ตัว Object ภายในยังคงเป็นการอ้างอิงเดิม

13. เชื่อม Array ด้วยการทำงานแบบต่อเนื่อง

เมธอดของ Array สามารถนำมาต่อกันได้เมื่อผลลัพธ์ของเมธอดหนึ่งเป็น Array ที่เมธอดถัดไปใช้งานได้ เช่น กรองสินค้าที่มีสต็อก แล้วแปลงให้เหลือเฉพาะชื่อ และเรียงชื่อเพื่อแสดงรายการ การเขียนแบบนี้เรียกว่า Method Chaining
const products = [
    { name: 'Keyboard', stock: 8, price: 1200 },
    { name: 'Mouse', stock: 0, price: 450 },
    { name: 'Monitor', stock: 5, price: 5200 },
    { name: 'Webcam', stock: 3, price: 890 }
];

const availableNames = products
    .filter(product => product.stock > 0)
    .map(product => product.name)
    .sort();

console.log(availableNames);

// ผลลัพธ์:
// ['Keyboard', 'Monitor', 'Webcam']
การแยกแต่ละขั้นตอนขึ้นบรรทัดใหม่ช่วยให้อ่านง่ายและตรวจสอบได้สะดวก หากกระบวนการซับซ้อนมาก อาจแยกเป็นตัวแปรย่อยเพื่อดูผลลัพธ์ระหว่างทางได้ ควรระวังว่า `sort()` เปลี่ยน Array ที่ได้รับมา แต่ในตัวอย่างนี้เป็น Array ใหม่ที่สร้างจาก `map()` จึงไม่เปลี่ยน Array สินค้าต้นฉบับ

14. เปรียบเทียบเมธอด Array ที่ใช้บ่อย

เมธอดผลลัพธ์เปลี่ยน Array ต้นฉบับตัวอย่างการใช้งาน
forEach()undefinedไม่โดยตัวมันเองแสดงผลสมาชิกทุกตัว
map()Array ใหม่ไม่โดยตัวมันเองแปลงราคาหรือชื่อข้อมูล
filter()Array ใหม่ไม่โดยตัวมันเองคัดสินค้าที่มีสต็อก
find()สมาชิกตัวแรกหรือ undefinedไม่ค้นหาสินค้าตามรหัส
findIndex()index หรือ -1ไม่ค้นหาตำแหน่งสมาชิก
reduce()ค่าเดียวหรือผลลัพธ์สะสมไม่โดยตัวมันเองรวมยอดขาย
sort()Array ที่เรียงแล้วใช่เรียงราคาจากน้อยไปมาก

15. ตัวอย่างประยุกต์: สรุปสินค้าคงคลัง

ตัวอย่างต่อไปนี้จำลองข้อมูลสินค้าในร้านค้า โดยกรองเฉพาะสินค้าที่มีสต็อก คำนวณมูลค่าสินค้าคงเหลือ แปลงข้อมูลสำหรับรายงาน และค้นหาสินค้าที่มีราคาสูงที่สุด ชุดคำสั่งนี้แสดงให้เห็นว่าเมธอดหลายชนิดสามารถทำงานร่วมกันเพื่อแก้ปัญหาจริงได้
const inventory = [
    { id: 1, name: 'Keyboard', price: 1200, stock: 8 },
    { id: 2, name: 'Mouse', price: 450, stock: 0 },
    { id: 3, name: 'Monitor', price: 5200, stock: 5 },
    { id: 4, name: 'Webcam', price: 890, stock: 3 }
];

const availableItems = inventory.filter(item => item.stock > 0);

const inventoryValue = availableItems.reduce(
    (total, item) => total + item.price * item.stock,
    0
);

const report = availableItems.map(item => ({
    name: item.name,
    stock: item.stock,
    value: item.price * item.stock
}));

const mostExpensive = inventory.reduce((highest, item) => {
    return item.price > highest.price ? item : highest;
});

console.log('จำนวนสินค้าที่มีสต็อก:', availableItems.length);
console.log('มูลค่าสต็อกรวม:', inventoryValue);
console.log('รายงานสินค้า:', report);
console.log('สินค้าที่ราคาสูงที่สุด:', mostExpensive.name);

// ผลลัพธ์:
// จำนวนสินค้าที่มีสต็อก: 3
// มูลค่าสต็อกรวม: 18670
// รายงานสินค้า: รายการสินค้า 3 รายการพร้อมจำนวนและมูลค่า
// สินค้าที่ราคาสูงที่สุด: Monitor
มูลค่าสต็อกรวมคำนวณจากราคาต่อหน่วยคูณจำนวนคงเหลือของแต่ละรายการ แล้วนำมารวมกัน ในตัวอย่างนี้ Keyboard มีมูลค่า 9,600 บาท Monitor มีมูลค่า 26,000 บาท และ Webcam มีมูลค่า 2,670 บาท ดังนั้นมูลค่ารวมที่ถูกต้องคือ 38,270 บาท ส่วนสินค้าที่มีราคาต่อหน่วยสูงที่สุดคือ Monitor
ตรวจสอบผลลัพธ์ก่อนนำไปใช้จริงตัวอย่างโค้ดข้างต้นคำนวณมูลค่าสต็อกได้ 38,270 บาท ไม่ใช่ 18,670 บาท ควรตรวจสอบทั้งโค้ดและข้อความผลลัพธ์ประกอบกันเสมอ เพราะความผิดพลาดเล็กน้อยในรายงานอาจทำให้ตัดสินใจทางธุรกิจผิดพลาดได้

16. วิเคราะห์ข้อมูลด้วยกราฟ

เมื่อมีข้อมูลจำนวนมาก การสรุปผลเป็นตัวเลขหรือกราฟช่วยให้เห็นภาพรวมได้ง่ายขึ้น ตัวอย่างต่อไปนี้แสดงจำนวนสินค้าที่เหลือในคลังของสินค้าแต่ละชนิด ข้อมูลเป็นเพียงชุดตัวอย่างที่กำหนดขึ้นเพื่อประกอบบทเรียน ไม่ใช่ข้อมูลจากร้านค้าจริง
จำนวนสินค้าคงเหลือตามประเภท
Labelจำนวนคงเหลือ
Keyboard8
Mouse0
Monitor5
Webcam3

17. ข้อผิดพลาดที่พบบ่อย

ปัญหาสาเหตุแนวทางแก้ไข
อ่านสมาชิกผิดตำแหน่งเข้าใจว่า index เริ่มจาก 1จำไว้ว่า index เริ่มจาก 0
ได้ undefinedเข้าถึง index ที่ไม่มีสมาชิกตรวจสอบ length และขอบเขตตำแหน่ง
ข้อมูลต้นฉบับเปลี่ยนโดยไม่ตั้งใจใช้ push, splice หรือ sort กับ Array เดิมสร้างสำเนาก่อนเมื่อจำเป็น
เรียงตัวเลขผิดลำดับใช้ sort() โดยไม่กำหนดฟังก์ชันเปรียบเทียบใช้ (a, b) => a - b สำหรับเรียงจากน้อยไปมาก
ใช้ map แทน filterสับสนระหว่างการแปลงข้อมูลกับการคัดกรองเลือกเมธอดตามผลลัพธ์ที่ต้องการ
reduce ทำงานผิดกำหนดค่าเริ่มต้นหรือสูตรสะสมไม่ถูกต้องกำหนด initial value และตรวจสอบข้อมูลว่าง

18. แบบฝึกหัดท้ายบท

ลองสร้าง Array ชื่อ `scores` ที่มีคะแนน 65, 82, 47, 91 และ 76 จากนั้นทำภารกิจต่อไปนี้ด้วยตนเอง: หาคะแนนที่มากกว่าหรือเท่ากับ 70 นับจำนวนคะแนนทั้งหมด คำนวณผลรวมและค่าเฉลี่ย เรียงคะแนนจากมากไปน้อย และค้นหาคะแนน 91 ด้วย `includes()` หรือเมธอดที่เหมาะสม
เฉลยข้อ 1: คัดคะแนนตั้งแต่ 70 ขึ้นไป
ใช้ `scores.filter(score => score >= 70)` จะได้ Array `[82, 91, 76]`
เฉลยข้อ 2: คำนวณผลรวมและค่าเฉลี่ย
ใช้ `scores.reduce((sum, score) => sum + score, 0)` จะได้ผลรวม 361 และค่าเฉลี่ย 72.2 เมื่อหารด้วยจำนวนสมาชิก 5 ตัว
เฉลยข้อ 3: เรียงคะแนนจากมากไปน้อย
ใช้ `[...scores].sort((a, b) => b - a)` จะได้ `[91, 82, 76, 65, 47]` การใช้ Spread Syntax ช่วยสร้าง Array ใหม่ก่อนเรียงลำดับ จึงไม่เปลี่ยน Array ต้นฉบับ
เฉลยข้อ 4: ตรวจสอบคะแนน 91
ใช้ `scores.includes(91)` จะได้ `true` เพราะ Array มีคะแนน 91 อยู่จริง

19. สรุปและเตรียมพร้อมสำหรับ EP8

Array เป็นพื้นฐานสำคัญของการจัดการข้อมูลใน JavaScript ตั้งแต่การเข้าถึงสมาชิกด้วย index การเพิ่มและลบข้อมูล ไปจนถึงการค้นหา แปลง คัดกรอง และสรุปผลด้วยเมธอดต่าง ๆ ได้แก่ `forEach()`, `map()`, `filter()`, `find()`, `findIndex()`, `reduce()` และ `sort()` การเลือกใช้เมธอดให้เหมาะสมช่วยให้โค้ดอ่านง่าย ลดการทำงานซ้ำ และลดข้อผิดพลาด เมื่อเข้าใจ Array แล้ว ขั้นต่อไปคือการเรียนรู้ Object เพื่อจัดเก็บข้อมูลที่มีคุณสมบัติหลายฟิลด์ และทำงานร่วมกับ Array เพื่อสร้างโครงสร้างข้อมูลที่ใกล้เคียงกับระบบจริง
ข้อมูลจะมีคุณค่าเมื่อเราจัดเก็บอย่างเป็นระบบ และสามารถเปลี่ยนข้อมูลเหล่านั้นให้เป็นคำตอบที่นำไปใช้ได้จริง
บทถัดไป: Object และการจัดการข้อมูลแบบ key-valueEP8 จะพาคุณเรียนรู้การสร้าง Object การอ่านและแก้ไขคุณสมบัติ การใช้เมธอดภายใน Object และการทำงานร่วมกันระหว่าง Array กับ Object เพื่อจัดการข้อมูลผู้ใช้และสินค้าในโปรแกรมจริง
Reach within 500px of the page end and stay for at least 5 minutes to earn EXP once per day.

⏳ Reading timer is running...

🌐
Select Language
21 World Languages Supported