เริ่มต้นใช้งาน Array ใน JavaScript

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

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

อาร์เรย์ใน JavaScript คืออะไร

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

นี่คือวิธีที่คุณสามารถสร้างอาร์เรย์ง่ายๆ ใน JavaScript:

const fruits = ["apple", "banana", "orange"];

ในตัวอย่างนี้ fruits คืออาร์เรย์ที่มีค่าสตริงสามค่า คุณสามารถเข้าถึงองค์ประกอบของอาร์เรย์ได้ตามดัชนี เช่นนี้:

console.log(fruits[0]); // Output: "apple"
console.log(fruits[1]); // Output: "banana"
console.log(fruits[2]); // Output: "orange"

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

คุณสมบัติของอาร์เรย์

อาร์เรย์มีคุณสมบัติในตัวบางอย่าง ซึ่งส่วนใหญ่รวมถึง:

constructor: ส่งคืนฟังก์ชัน Array ที่สร้างอาร์เรย์

length: สะท้อนจำนวนองค์ประกอบในอาร์เรย์

prototype: ช่วยให้คุณเพิ่มคุณสมบัติและเมธอดให้กับอ็อบเจกต์อาร์เรย์

ตัวอย่างเช่น:

const fruits = ['apple', 'banana', 'orange'];

fruits.constructor // Array()
fruits.length // 3  
fruits.prototype // Array.prototype

คุณสมบัติ constructor ส่งคืนฟังก์ชันตัวสร้าง Array ที่สร้างอาร์เรย์นี้

คุณสมบัติ length สะท้อนจำนวนองค์ประกอบในอาร์เรย์

คุณสมบัติ prototype ชี้ไปที่อ็อบเจกต์ต้นแบบของอาร์เรย์ Array.prototype ช่วยให้คุณเพิ่มคุณสมบัติและเมธอดแบบกำหนดเองให้กับอาร์เรย์ได้

นอกจากนี้ อาร์เรย์ยังสืบทอดเมธอดต่างๆ เช่น forEach(), map(), filter() เป็นต้น จากอ็อบเจกต์ต้นแบบ Array.prototype

ผ่านคุณสมบัติในตัวของอาร์เรย์ เราสามารถรับข้อมูลพื้นฐานเกี่ยวกับอาร์เรย์ได้ โดยการปรับเปลี่ยนคุณสมบัติ prototype เราสามารถปรับแต่งพฤติกรรมของอาร์เรย์ได้ คุณสมบัติของอาร์เรย์เป็นรากฐานสำหรับการทำงานกับอาร์เรย์

เมธอดการสำรวจอ็อบเจกต์ใน JavaScript

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

เมธอดอาร์เรย์ใน JavaScript พร้อมตัวอย่าง

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

forEach

• forEach() - ดำเนินการฟังก์ชัน callback ที่ให้ไว้หนึ่งครั้งสำหรับแต่ละองค์ประกอบในอาร์เรย์ ไม่ได้เปลี่ยนแปลงอาร์เรย์ดั้งเดิม

js
Copy code
const fruits = ['apple', 'banana', 'orange'];
fruits.forEach(fruit => {
  console.log(fruit);
});

เมธอด forEach() จะวนซ้ำอาร์เรย์และดำเนินการฟังก์ชัน callback หนึ่งครั้งสำหรับแต่ละองค์ประกอบ

ฟังก์ชัน callback ยอมรับอาร์กิวเมนต์สามตัว:

• องค์ประกอบปัจจุบัน
• ดัชนีปัจจุบัน
• ตัวอาร์เรย์เอง

คุณสามารถเข้าถึงอาร์กิวเมนต์เหล่านี้ได้ดังนี้:

js
Copy code
fruits.forEach((fruit, index, array) => {
  console.log(fruit, index, array); 
});

ลำดับการวนซ้ำถูกกำหนดโดยดัชนีอาร์เรย์

forEach() มักใช้เพื่อดำเนินการกับแต่ละองค์ประกอบในอาร์เรย์ เช่น การบันทึก:

js
Copy code
fruits.forEach(fruit => {
  console.log(fruit);
});

หรือการแมปไปยังอาร์เรย์ใหม่:

js
Copy code
const upperCased = [];
fruits.forEach(fruit => {
  upperCased.push(fruit.toUpperCase()); 
});

join

• join() - รวมองค์ประกอบทั้งหมดของอาร์เรย์เป็นสตริง คุณสามารถระบุตัวคั่นที่จะใช้ระหว่างแต่ละองค์ประกอบได้

js
Copy code
const fruits = ['apple', 'banana', 'orange'];
fruits.join(); // 'apple,banana,orange'
fruits.join(' & '); // 'apple & banana & orange'

Push

• push() - เพิ่มองค์ประกอบอย่างน้อยหนึ่งรายการไปยังจุดสิ้นสุดของอาร์เรย์และส่งคืนความยาวใหม่ของอาร์เรย์ ซึ่งจะเปลี่ยนแปลงอาร์เรย์ดั้งเดิมโดยการปรับเปลี่ยนความยาวและเพิ่มองค์ประกอบใหม่

js
Copy code
const fruits = ['apple', 'banana'];
fruits.push('orange'); // 3
fruits.push('mango', 'pear'); // 5

pop

• pop() - ลบองค์ประกอบสุดท้ายออกจากอาร์เรย์และส่งคืนองค์ประกอบนั้น ซึ่งจะเปลี่ยนแปลงอาร์เรย์โดยการลดความยาวลง 1 และเปลี่ยนเนื้อหา

js
Copy code
const fruits = ['apple', 'banana', 'orange'];
fruits.pop(); // 'orange'

unshift

• unshift() - เพิ่มองค์ประกอบอย่างน้อยหนึ่งรายการไปยังจุดเริ่มต้นของอาร์เรย์และส่งคืนความยาวใหม่ เปลี่ยนแปลงอาร์เรย์โดยการเพิ่มความยาวและเพิ่มองค์ประกอบ

js
Copy code
const fruits = ['apple', 'banana'];
fruits.unshift('grape'); // 3
fruits.unshift('mango', 'pear'); // 5

• shift() - ลบองค์ประกอบแรกของอาร์เรย์และส่งคืนองค์ประกอบนั้น เปลี่ยนแปลงอาร์เรย์โดยการลบองค์ประกอบแรกและลดความยาว

js
Copy code
const fruits = ['apple', 'banana', 'orange'];
fruits.shift(); // 'apple'

• indexOf() - ส่งคืนดัชนีแรกที่พบองค์ประกอบที่กำหนดในอาร์เรย์ หรือ -1 หากไม่มีอยู่

js
Copy code
const fruits = ['apple', 'banana', 'orange', 'apple'];
fruits.indexOf('apple'); // 0
fruits.indexOf('grape'); // -1

• includes() - กำหนดว่าอาร์เรย์มีองค์ประกอบบางอย่างหรือไม่ โดยส่งคืน true หรือ false ไม่ได้เปลี่ยนแปลงอาร์เรย์

js
Copy code
const fruits = ['apple', 'banana', 'orange'];
fruits.includes('apple'); // true
fruits.includes('grape'); // false

การทดสอบอัตโนมัติและการสำรวจอาร์เรย์ใน Apidog

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

การทดสอบอัตโนมัติ

Apidog มี เครื่องมือทดสอบอัตโนมัติมากมายเพื่อช่วยให้คุณตรวจสอบความถูกต้องของอินเทอร์เฟซและบริการแบ็กเอนด์ของคุณได้อย่างง่ายดาย เครื่องมือเหล่านี้ประกอบด้วย:

• การทดสอบ API

Apidog รองรับการทดสอบสำหรับโปรโตคอลหลายรายการ รวมถึง HTTP(S), WebSocket, Socket, gRPC และอื่นๆ คุณสามารถใช้ Apidog เพื่อส่งคำขอ ตรวจสอบการตอบสนอง ตรวจสอบรหัสสถานะ และจัดการสถานการณ์การทดสอบอินเทอร์เฟซที่ซับซ้อน

• การทดสอบการรวม

สำหรับการใช้งานหรือบริการที่ซับซ้อน การทดสอบการรวมเป็นสิ่งสำคัญ Apidog ช่วยให้คุณสร้างและจัดการชุดทดสอบสำหรับอินเทอร์เฟซหลายรายการ เพื่อให้มั่นใจว่าอินเทอร์เฟซต่างๆ ทำงานร่วมกันตามที่คาดไว้

• การทดสอบที่ขับเคลื่อนด้วยข้อมูล

Apidog รองรับการทดสอบที่ขับเคลื่อนด้วยข้อมูล ทำให้คุณสามารถโหลดข้อมูลการทดสอบและเรียกใช้กรณีทดสอบโดยอัตโนมัติเพื่อให้แน่ใจว่าอินเทอร์เฟซทำงานได้ดีภายใต้สถานการณ์ข้อมูลอินพุตที่แตกต่างกัน

• การทดสอบแบบสคริปต์

สำหรับสถานการณ์การทดสอบขั้นสูง Apidog มีความสามารถในการทดสอบแบบสคริปต์ ช่วยให้คุณสามารถเขียนตรรกะการทดสอบแบบกำหนดเองโดยใช้สคริปต์

ความสามารถในการสำรวจอาร์เรย์

Apidog ยังมีคุณสมบัติการสำรวจอาร์เรย์ที่แข็งแกร่ง ซึ่งช่วยให้คุณทดสอบและตรวจสอบพฤติกรรมของอินเทอร์เฟซได้อย่างมีประสิทธิภาพมากขึ้น นี่คือคุณสมบัติหลักของการสำรวจอาร์เรย์ของ Apidog:

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

บทสรุป

การทำความเข้าใจวิธีการสำรวจอ็อบเจกต์โดยใช้เมธอดต่างๆ เช่น for...in, Object.keys(), Object.values() และ Object.entries() เป็นสิ่งสำคัญเมื่อทำงานกับโครงสร้างข้อมูลที่ซับซ้อน นอกจากนี้ เมธอดอาร์เรย์ เช่น forEach(), map(), filter() และ reduce() ยังมีเครื่องมือที่มีประสิทธิภาพสำหรับการจัดการและแปลงอาร์เรย์