JScript Katana

เชี่ยวชาญการจัดการอาเรย์ใน JavaScript: คู่มือครบวงจรสำหรับการสร้าง การปรับเปลี่ยน การกรอง และการประยุกต์ใช้งานจริง

การประมวลผล JSON
佐川 直弘 | Naohiro Sagawa
By 佐川 直弘 | Naohiro Sagawa (運営者)
※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。　
目次

1. บทนำ

อะไรคืออาเรย์ใน JavaScript และทำไมจึงสำคัญ?

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

กรณีการใช้งานจริงของอาเรย์

  • การจัดการรายการ : จัดการรายการสินค้าในตะกร้าหรือรายการสิ่งที่ต้องทำ
  • การกรองข้อมูล : ฟีเจอร์การค้นหาและการจัดเรียงของผู้ใช้
  • การควบคุมแอนิเมชัน : จัดการลำดับขององค์ประกอบหรือการเปลี่ยนแปลงแบบไดนามิก

อาเรย์เป็นโครงสร้างพื้นฐานสำหรับการจัดการข้อมูลที่เป็นกลุ่มและเป็นหัวข้อสำคัญเมื่อเรียนรู้ JavaScript

สิ่งที่คุณจะได้เรียนในบทความนี้

บทความนี้อธิบายอาเรย์ใน JavaScript อย่างเป็นระบบ ครอบคลุมหัวข้อต่าง ๆ เช่น

  1. วิธีการประกาศและกำหนดค่าเริ่มต้นของอาเรย์
  2. วิธีการเพิ่ม, ลบ, และดึงข้อมูลของสมาชิก
  3. เทคนิคการจัดเรียงและการกรอง
  4. วิธีการรวมและแยกอาเรย์
  5. ตัวอย่างการประยุกต์ใช้อาเรย์

เนื้อหานี้เหมาะสำหรับผู้เริ่มต้นถึงระดับกลางและอธิบายทุกอย่างอย่างละเอียดตั้งแต่พื้นฐานจนถึงเทคนิคการใช้งานจริง

ผู้ที่เหมาะกับบทความนี้

  • ผู้เริ่มต้น : ผู้ที่ใช้อาเรย์เป็นครั้งแรก
  • ผู้ใช้ระดับกลาง : ผู้ที่ต้องการเรียนรู้การดำเนินการขั้นสูงหรือเขียนโค้ดที่มีประสิทธิภาพมากขึ้น

ด้วยตัวอย่างโค้ดและกรณีการใช้งานจริง แม้ผู้เริ่มต้นก็สามารถเรียนรู้ได้อย่างมั่นใจ

สิ่งที่คุณจะสามารถทำได้เมื่อเรียนรู้เรื่องอาเรย์

  • การจัดการและการจัดการข้อมูล : เพิ่ม, ลบ, หรือจัดเรียงข้อมูลได้อย่างง่ายดาย
  • การบูรณาการ API : จัดการและแสดงข้อมูลที่ดึงมาจาก Web API อย่างมีประสิทธิภาพ
  • การพัฒนาแอปพลิเคชัน : สร้างแอปง่าย ๆ ด้วยตัวอย่างที่เป็นประโยชน์

ใช้สิ่งที่คุณเรียนที่นี่เพื่อสร้างแอปพลิเคชัน JavaScript ที่ซับซ้อนยิ่งขึ้น

2. พื้นฐานอาเรย์ | การประกาศและการกำหนดค่าเริ่มต้น

2.1 คำจำกัดความและบทบาทของอาเรย์

อาเรย์ใน JavaScript เป็นอ็อบเจ็กต์พิเศษที่ช่วยให้คุณจัดการข้อมูลหลายรายการพร้อมกัน แต่ละสมาชิกมีดัชนีที่กำหนดตำแหน่งของมัน ทำให้การดึงและจัดการข้อมูลเป็นเรื่องง่าย

บทบาทหลักของอาเรย์

  1. การจัดการรายการ : จัดการข้อมูลที่เป็นกลุ่มเช่นรายการสินค้า หรือข้อมูลผู้ใช้
  2. การจัดการข้อมูล : ทำงานอย่างมีประสิทธิภาพเช่นการจัดเรียงหรือการค้นหา
  3. การประมวลผลข้อมูลแบบไดนามิก : จัดการและแปลงข้อมูลที่ดึงมาจาก API

ลักษณะของอาเรย์

  • ดัชนีของสมาชิกเริ่มจาก 0.
  • สามารถเก็บค่าที่มีประเภทข้อมูลต่างกันร่วมกันได้.
    let mixedArray = [1, "hello", true];
console.log(mixedArray[1]); // "hello"

2.2 การประกาศและกำหนดค่าเริ่มต้นของอาเรย์

การประกาศอาเรย์พื้นฐาน

ใน JavaScript, สามารถประกาศอาเรย์ได้สองวิธี:

  1. ใช้การเขียนแบบลิเทรัล (แนะนำ)
    let fruits = ["apple", "banana", "grape"];
  1. ใช้ตัวสร้าง Array
    let fruits = new Array("apple", "banana", "grape");

การสร้างอาเรย์เปล่า

let emptyArray = [];

2.3 การประกาศอาเรย์หลายมิติ

อาเรย์หลายมิติคืออาเรย์ที่บรรจุอาเรย์อื่น ๆ อยู่ภายใน เป็นประโยชน์เมื่อจัดการโครงสร้างข้อมูลแบบลำดับชั้น

let matrix = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
];

console.log(matrix[1][2]); // 6

2.4 หมายเหตุเกี่ยวกับการกำหนดค่าเริ่มต้น

การผสมประเภทข้อมูล

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

let mixed = [1, "text", true];
console.log(typeof mixed[0]); // "number"
console.log(typeof mixed[1]); // "string"
console.log(typeof mixed[2]); // "boolean"

2.5 ตัวอย่างการดำเนินการอาเรย์พื้นฐาน

let animals = ["dog", "cat", "bird"];
console.log(animals[0]); // "dog"

animals.push("rabbit");
console.log(animals); // ["dog", "cat", "bird", "rabbit"]

animals[1] = "lion";
console.log(animals); // ["dog", "lion", "bird", "rabbit"]

สรุป

ส่วนนี้อธิบายแนวคิดต่อไปนี้เกี่ยวกับอาร์เรย์ใน JavaScript:

  1. การกำหนดและบทบาทของอาร์เรย์
  2. ไวยากรณ์พื้นฐานสำหรับการประกาศและการกำหนดค่าเริ่มต้น
  3. อาร์เรย์หลายมิติและการจัดการความยาว
  4. ข้อควรพิจารณาที่สำคัญระหว่างการกำหนดค่าเริ่มต้นพร้อมตัวอย่างโค้ด

ด้วยความรู้นี้ คุณจะพร้อมมากขึ้นสำหรับขั้นตอนต่อไป: “การดำเนินการอาร์เรย์พื้นฐาน”

3. การดำเนินการอาร์เรย์พื้นฐาน | การเพิ่ม, การลบ, และการดึงข้อมูลองค์ประกอบ

3.1 วิธีการเพิ่มองค์ประกอบ

เพิ่มองค์ประกอบที่ส่วนท้าย – push()

let fruits = ["apple", "banana"];
fruits.push("orange");
console.log(fruits); // ["apple", "banana", "orange"]

เพิ่มองค์ประกอบที่ส่วนเริ่มต้น – unshift()

let animals = ["cat", "dog"];
animals.unshift("rabbit");
console.log(animals); // ["rabbit", "cat", "dog"]

3.2 วิธีการลบองค์ประกอบ

ลบองค์ประกอบสุดท้าย – pop()

let colors = ["red", "blue", "green"];
let removed = colors.pop();
console.log(colors); // ["red", "blue"]
console.log(removed); // "green"

ลบองค์ประกอบแรก – shift()

let numbers = [1, 2, 3, 4];
let removedNumber = numbers.shift();
console.log(numbers); // [2, 3, 4]
console.log(removedNumber); // 1

ลบองค์ประกอบจากตำแหน่งใดก็ได้ – splice()

let sports = ["soccer", "baseball", "basketball", "tennis"];
sports.splice(1, 2);
console.log(sports); // ["soccer", "tennis"]

3.3 วิธีการดึงข้อมูลองค์ประกอบ

ดึงข้อมูลโดยใช้ดัชนี

let drinks = ["water", "tea", "coffee"];
console.log(drinks[0]); // "water"
console.log(drinks[2]); // "coffee"

ดึงข้อมูลองค์ประกอบสุดท้าย

let cities = ["Tokyo", "Osaka", "Kyoto"];
console.log(cities[cities.length - 1]); // "Kyoto"

ดึงข้อมูลองค์ประกอบที่ตรงกันเป็นอันดับแรก – find()

let numbers = [10, 20, 30, 40];
let result = numbers.find(num => num > 25);
console.log(result); // 30

สรุป

ในส่วนนี้ เราอธิบายการดำเนินการอาร์เรย์ของ JavaScript ต่อไปนี้:

  1. วิธีการเพิ่มองค์ประกอบ (push() และ unshift() )
  2. วิธีการลบองค์ประกอบ (pop() , shift() , splice() )
  3. วิธีการดึงข้อมูลองค์ประกอบ (การเข้าถึงโดยดัชนี, find() , includes() )

โดยการรวมการดำเนินการพื้นฐานเหล่านี้ คุณสามารถจัดการอาร์เรย์ได้อย่างอิสระ.

4. การจัดเรียงและการกรองอาร์เรย์

4.1 วิธีการจัดเรียงอาร์เรย์

จัดเรียงตามลำดับเพิ่มหรือลด – sort()

let numbers = [40, 10, 30, 20];
numbers.sort((a, b) => a - b);
console.log(numbers); // [10, 20, 30, 40]

กลับลำดับ – reverse()

let letters = ["a", "b", "c", "d"];
letters.reverse();
console.log(letters); // ["d", "c", "b", "a"]

4.2 วิธีการกรองอาร์เรย์

สกัดองค์ประกอบที่ตรงกับเงื่อนไข – filter()

let numbers = [1, 2, 3, 4, 5, 6];
let evenNumbers = numbers.filter(num => num % 2 === 0);
console.log(evenNumbers); // [2, 4, 6]

ดึงข้อมูลองค์ประกอบแรกที่ตรงกับเงื่อนไข – find()

let ages = [15, 20, 25, 30];
let firstAdult = ages.find(age => age >= 20);
console.log(firstAdult); // 20

รับดัชนีขององค์ประกอบที่ตรงกันเป็นอันดับแรก – findIndex()

let scores = [50, 70, 85, 40];
let highScoreIndex = scores.findIndex(score => score > 80);
console.log(highScoreIndex); // 2

สรุป

ส่วนนี้อธิบายวิธีการจัดเรียงและกรองอาร์เรย์ใน JavaScript:

  1. การจัดเรียง: ใช้ sort() และ reverse() เพื่อควบคุมลำดับ.
  2. การกรอง: ใช้ filter() เพื่อสกัดองค์ประกอบที่ตรงกัน.
  3. การค้นหา: ใช้ find() และ findIndex() เพื่อค้นหาองค์ประกอบ.

5. การรวม, การแยก, และการแปลงอาร์เรย์

5.1 วิธีการรวมอาร์เรย์

รวมอาร์เรย์ – concat()

let fruits = ["apple", "banana"];
let vegetables = ["carrot", "spinach"];
let combined = fruits.concat(vegetables);
console.log(combined); // ["apple", "banana", "carrot", "spinach"]

การเข้าร่วมโดยใช้ Spread Syntax

let fruits = ["apple", "banana"];
let vegetables = ["carrot", "spinach"];
let combined = [...fruits, ...vegetables];
console.log(combined); // ["apple", "banana", "carrot", "spinach"]

5.2 เมธอดสำหรับการแยกอาร์เรย์

สกัดส่วนหนึ่ง – slice()

let colors = ["red", "blue", "green", "yellow", "purple"];
let selectedColors = colors.slice(1, 4);
console.log(selectedColors); // ["blue", "green", "yellow"]

ลบหรือแทนที่องค์ประกอบ – splice()

let languages = ["JavaScript", "Python", "Ruby", "Java"];
languages.splice(1, 2);
console.log(languages); // ["JavaScript", "Java"]

5.3 เมธอดสำหรับการแปลงอาร์เรย์

แปลงอาร์เรย์เป็นสตริง – join()

let items = ["apple", "banana", "grape"];
let result = items.join(", ");
console.log(result); // "apple, banana, grape"

แปลงสตริงเป็นอาร์เรย์ – split()

let str = "apple,banana,grape";
let arr = str.split(",");
console.log(arr); // ["apple", "banana", "grape"]

ทำให้อาร์เรย์หลายมิติแบน – flat()

let numbers = [1, [2, 3], [4, [5, 6]]];
let flatNumbers = numbers.flat(2);
console.log(flatNumbers); // [1, 2, 3, 4, 5, 6]

สรุป

ส่วนนี้ได้อธิบายเมธอดอาร์เรย์ JavaScript ต่างๆ สำหรับการเข้าร่วม การแยก และการแปลงอาร์เรย์:

  1. การเข้าร่วมอาร์เรย์: concat() และ spread syntax
  2. การแยกอาร์เรย์: slice() สำหรับการสกัดและ splice() สำหรับการลบหรือแทนที่
  3. การแปลงอาร์เรย์: join() และ split() สำหรับการแปลงสตริง
  4. การทำให้แบน: flat() สำหรับการแปลงอาร์เรย์ซ้อนกันให้เป็นมิติเดียว

6. การวนลูปผ่านอาร์เรย์และเทคนิคขั้นสูง

6.1 เมธอดสำหรับการวนลูปผ่านอาร์เรย์

การวนลูปพื้นฐานด้วย for

let fruits = ["apple", "banana", "grape"];
for (let i = 0; i < fruits.length; i++) {
  console.log(fruits[i]);
}
// Output: apple, banana, grape

การวนลูปที่ง่ายขึ้นด้วย for...of

let colors = ["red", "blue", "green"];
for (let color of colors) {
  console.log(color);
}
// Output: red, blue, green

การวนลูปด้วยเมธอด forEach()

let animals = ["cat", "dog", "bird"];
animals.forEach((animal, index) => {
  console.log(`${index}: ${animal}`);
});
// Output: 0: cat, 1: dog, 2: bird

สร้างอาร์เรย์ใหม่ด้วย map()

let numbers = [1, 2, 3, 4];
let doubled = numbers.map(num => num * 2);
console.log(doubled); // [2, 4, 6, 8]

6.2 เทคนิคขั้นสูง

ลบองค์ประกอบที่ซ้ำกัน

let numbers = [1, 2, 2, 3, 4, 4, 5];
let uniqueNumbers = [...new Set(numbers)];
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

ทำให้อาร์เรย์แบน – flat()

let nested = [1, [2, 3], [4, [5, 6]]];
let flatArray = nested.flat(2);
console.log(flatArray); // [1, 2, 3, 4, 5, 6]

สรุป

ส่วนนี้ได้อธิบายเมธอดการวนลูปอาร์เรย์และเทคนิคขั้นสูง:

  1. ลูปพื้นฐาน : การวนลูปที่มีประสิทธิภาพโดยใช้ for และ for...of .
  2. ลูปที่ใช้เมธอด : การใช้ forEach() และ map() สำหรับการประมวลผลที่สะอาดและมีฟังก์ชันมากขึ้น.
  3. การจัดการข้อมูลขั้นสูง : การลบองค์ประกอบที่ซ้ำกันและการทำให้อาร์เรย์ซ้อนกันแบน.

7. ตัวอย่างปฏิบัติ | การสร้างแอปพลิเคชันง่ายๆ โดยใช้ Arrays

7.1 การสร้างแอปพลิเคชันรายการสิ่งที่ต้องทำ

ภาพรวมคุณสมบัติ

แอปพลิเคชันรายการสิ่งที่ต้องทำง่ายๆ นี้รวมคุณสมบัติต่อไปนี้:

  1. เพิ่มงานใหม่
  2. ลบงานที่เสร็จสิ้น
  3. แสดงรายการงานปัจจุบัน

ตัวอย่างโค้ด

let tasks = [];

// Function to add a new task
function addTask(task) {
  tasks.push(task);
  console.log(`Added: ${task}`);
  displayTasks();
}

// Function to remove a task
function removeTask(index) {
  if (index >= 0 && index < tasks.length) { let removed = tasks.splice(index, 1); console.log(`Removed: ${removed[0]}`); displayTasks(); } else { console.log("Invalid index"); } } // Function to display current tasks function displayTasks() { console.log("Current Tasks:"); tasks.forEach((task, index) => {
    console.log(`${index + 1}: ${task}`);
  });
}

// Test execution
addTask("Study JavaScript");
addTask("Create shopping list");
addTask("Check email");

removeTask(1); // Remove the second task

ตัวอย่างผลลัพธ์

Added: Study JavaScript
Added: Create shopping list
Added: Check email
Current Tasks:
1: Study JavaScript
2: Create shopping list
3: Check email
Removed: Create shopping list
Current Tasks:
1: Study JavaScript
2: Check email

สรุป

ส่วนนี้ได้แนะนำการประยุกต์ใช้งานจริงโดยใช้การดำเนินการกับอาร์เรย์:

  1. แอปพลิเคชันรายการสิ่งที่ต้องทำ : ฝึกการเพิ่ม, ลบ, และแสดงงาน.
  2. การค้นหาและการวิเคราะห์ข้อมูล : แสดงวิธีการทำการค้นหาแบบยืดหยุ่นและการรวมข้อมูลโดยใช้การดำเนินการกับอาร์เรย์.

8. สรุป | การเชี่ยวชาญการดำเนินการกับอาร์เรย์

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

8.1 การทบทวนบทความนี้

1. การดำเนินการอาร์เรย์พื้นฐาน

  • การประกาศและการเริ่มต้น : เรียนรู้วิธีสร้างอาร์เรย์และจัดการอาร์เรย์หลายมิติ.
  • การเพิ่ม, การลบ, และการดึงข้อมูล : ฝึกการปรับเปลี่ยนข้อมูลแบบไดนามิกโดยใช้เมธอดเช่น push() , pop() และอื่น ๆ.

2. การจัดเรียงและการกรองอาร์เรย์

  • การจัดเรียง : อธิบายวิธีการเปลี่ยนลำดับของอาร์เรย์โดยใช้ sort() และ reverse() .
  • การกรอง : เรียนรู้วิธีการดึงข้อมูลโดยใช้ filter() และ find() .

3. การรวม, การแยก, และการแปลงอาร์เรย์

  • การรวม : เข้าใจวิธีการผสานอาร์เรย์โดยใช้ concat() และสแปรดซินแทกซ์.
  • การแยกและการแปลง : ใช้ slice() , splice() , join() และ split() เพื่อการจัดการข้อมูลที่ยืดหยุ่น.

4. การวนลูปและเทคนิคขั้นสูง

  • การวนลูป : ใช้ for , forEach() และ map() เพื่อการทำซ้ำที่มีประสิทธิภาพ.
  • เทคนิคขั้นสูง : เรียนรู้การลบรายการซ้ำและการทำให้แอเรย์ซ้อนเป็นแอเรย์แบน.

5. ตัวอย่างการใช้งานจริง

  • แอปรายการสิ่งที่ต้องทำ : นำการดำเนินการอาร์เรย์ไปใช้สร้างแอปที่ทำงานได้จริง.
  • การค้นหาและการรวมข้อมูล : แสดงการกรองและวิเคราะห์ข้อมูลในเชิงปฏิบัติ.

8.2 ความสำคัญของการดำเนินการอาร์เรย์และกรณีการใช้งาน

ทำไมการดำเนินการอาร์เรย์จึงสำคัญ?

การจัดการอาร์เรย์เป็นสิ่งจำเป็นสำหรับการจัดระเบียบ, การวิเคราะห์, และการแสดงผลข้อมูล สถานการณ์ทั่วไปได้แก่:

  1. การจัดการและการแสดงผลข้อมูล : การกรองข้อมูลจาก API และแสดงผลในตาราง.
  2. การจัดการฟอร์มและข้อมูลผู้ใช้ : การอัปเดตรายการแบบไดนามิกหรือการประมวลผลค่าที่ป้อนเข้ามา.
  3. ฟังก์ชันการค้นหาและการจัดเรียง : การจัดการชุดข้อมูลขนาดใหญ่อย่างมีประสิทธิภาพ.
  4. การพัฒนาแอปพลิเคชัน : การสร้างฟีเจอร์ UI เช่น รถเข็นช็อปปิ้งและผู้จัดการงาน.

8.3 ขั้นตอนต่อไปในการเรียนรู้

1. การใช้เมธอดอาร์เรย์ต่อไป

  • งานที่แนะนำ : สร้างแอปที่ดึงข้อมูลจาก API และกรองผลลัพธ์โดยใช้การดำเนินการอาร์เรย์.

2. เปรียบเทียบและใช้โครงสร้างข้อมูลอื่น

  • เรียนรู้ Objects , Set และ Map เพื่อเลือกโครงสร้างที่เหมาะสมกับแต่ละสถานการณ์.

3. นำความรู้ไปใช้ในเฟรมเวิร์ก JavaScript

  • ใช้ทักษะการทำงานกับอาร์เรย์ในเฟรมเวิร์กเช่น React หรือ Vue.js สำหรับการพัฒนาในโลกจริง.

8.4 ลิงก์อ้างอิงและแหล่งข้อมูล

8.5 ความคิดสุดท้ายและคำแนะนำสำหรับผู้อ่าน

JavaScript array operations เป็นสิ่งสำคัญสำหรับการสร้างพื้นฐานการเขียนโปรแกรมที่มั่นคง บทความนี้นำเสนอแนวทางที่เป็นโครงสร้างตั้งแต่พื้นฐานจนถึงแนวคิดระดับสูง

คำแนะนำ

  1. ฝึกเขียนโค้ด : ทดสอบแต่ละเมธอดเพื่อทำความเข้าใจให้ลึกซึ้งขึ้น
  2. พัฒนาทักษะการแก้ปัญหา : แปลงงานจริงให้เป็นโปรแกรมเพื่อเพิ่มความเชี่ยวชาญเชิงปฏิบัติ
  3. เรียนรู้อย่างต่อเนื่อง : เรียนรู้เฟรมเวิร์กใหม่และเทคโนโลยีล่าสุดเพื่อพัฒนาชุดทักษะของคุณ

ก้าวต่อไป!

ใช้บทความนี้เป็นพื้นฐานเพื่อก้าวต่อไปในการสร้างแอปพลิเคชันที่ซับซ้อนมากขึ้นหรือเรียนรู้เฟรมเวิร์กสมัยใหม่

คำถามที่พบบ่อย | Frequently Asked Questions

Q1. ความแตกต่างระหว่าง map() กับ forEach() คืออะไร?

  • map() : คืนค่าอาร์เรย์ใหม่หลังจากนำฟังก์ชันไปใช้กับแต่ละองค์ประกอบ
  • forEach() : ทำงานฟังก์ชันกับแต่ละองค์ประกอบแต่ไม่คืนค่าอาร์เรย์ใหม่

ตัวอย่าง:

let numbers = [1, 2, 3];

// map()
let doubled = numbers.map(num => num * 2);
console.log(doubled); // [2, 4, 6]

// forEach()
numbers.forEach(num => console.log(num * 2));
// Output: 2, 4, 6

Q2. ฉันจะจัดเรียงตัวเลขอย่างถูกต้องได้อย่างไร?

โดยค่าเริ่มต้น sort() จะเปรียบเทียบค่าตามสตริง เพื่อจัดเรียงตัวเลขตามค่าตัวเลขจริง คุณต้องส่งฟังก์ชันเปรียบเทียบ
ตัวอย่าง:

let numbers = [40, 100, 1, 5, 25];
numbers.sort((a, b) => a - b);
console.log(numbers); // [1, 5, 25, 40, 100]

Q3. ฉันจะลบค่าซ้ำจากอาร์เรย์ได้อย่างไร?

ใช้วัตถุ Set เพื่อลบค่าซ้ำได้อย่างง่ายดาย
ตัวอย่าง:

let numbers = [1, 2, 2, 3, 4, 4, 5];
let uniqueNumbers = [...new Set(numbers)];
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

Q4. ฉันจะตรวจสอบว่าองค์ประกอบมีอยู่ในอาร์เรย์หรือไม่?

ใช้เมธอด includes() เพื่อตรวจสอบว่าอาร์เรย์มีค่าที่ระบุหรือไม่
ตัวอย่าง:

let fruits = ["apple", "banana", "grape"];
console.log(fruits.includes("banana")); // true
console.log(fruits.includes("melon")); // false

Q5. ฉันจะทำให้แอเรย์หลายมิติแบนเป็นแอเรย์ระดับเดียวได้อย่างไร?

ใช้เมธอด flat() เพื่อแปลงอาร์เรย์ที่ซ้อนกันให้เป็นอาร์เรย์ระดับเดียว
ตัวอย่าง:

let nested = [1, [2, 3], [4, [5, 6]]];
let flatArray = nested.flat(2);
console.log(flatArray); // [1, 2, 3, 4, 5, 6]
広告