Home > Web Front-end > JS Tutorial > body text

Mastering JavaScript Arrays: Techniques, Best Practices, and Advanced Uses

王林
Release: 2024-09-04 07:02:03
Original
900 people have browsed it

An array is a special variable, which can hold more than one value:

const name = ["Sakib", "Arif", "Fatema"];
Copy after login

Why Use Arrays?

Arrays are a fundamental data structure in JavaScript (and many other programming languages) for several reasons:

  1. Organize Data: Arrays allow you to store multiple values in a single variable, making it easier to manage collections of data. For example, if you need to keep track of a list of user names, you can store them all in an array.

  2. Indexed Access: Arrays provide a convenient way to access elements using indices. This makes it easy to retrieve or modify specific items based on their position.

  3. Iterate Efficiently: JavaScript offers various methods to iterate over arrays, such as for, forEach, map, filter, and reduce. These methods enable you to process each element of an array with minimal code.

  4. Dynamic Resizing: Arrays in JavaScript are dynamic, meaning they can grow or shrink in size as needed. You don't need to specify the size in advance, which adds flexibility to how you handle data.

  5. Built-in Methods: JavaScript arrays come with a rich set of built-in methods for manipulating and querying data. Methods like push, pop, shift, unshift, splice, slice, and many others simplify common tasks.

  6. Versatile Data Handling: Arrays can hold various types of data, including numbers, strings, objects, and even other arrays. This versatility makes arrays suitable for a wide range of applications.

  7. Enhanced Performance: Arrays are optimized for performance in JavaScript engines, making them efficient for tasks that involve sequential data processing and manipulation.

  8. Support for Higher-Order Functions: JavaScript arrays are designed to work seamlessly with higher-order functions, which can lead to more expressive and concise code. Functions like map, filter, and reduce enable powerful data transformations and aggregations.

In summary, arrays are essential for organizing, accessing, and manipulating collections of data efficiently and flexibly in JavaScript.

Creating an Array

Mastering JavaScript Arrays: Techniques, Best Practices, and Advanced Uses

Syntax

const array_name = [item1, item2, ...]; 
Copy after login

Spaces and line breaks are not important. A declaration can span multiple lines:

const developer = [
  "Fatema",
  "Sakib",
  "Riaz"
];
Copy after login

You can also create an array, and then provide the elements:

const man = [];
cars[0]= "Abdur Rahman";
cars[1]= "Riyaz Khan";
cars[2]= "Jumman KL";
Copy after login

Using the JavaScript Keyword new

const man = new Array("Saabid", "Fatema", "Rukhsana");
Copy after login

Accessing Array Elements
You access an array element by referring to the index number:

const man = ["Fatema", "Sakib", "Ayesha"];
let car = cars[0];
Copy after login

Converting an Array to a String

const fruits = ["Banana", "Orange", "Apple", "Mango"];
document.getElementById("demo").innerHTML = fruits.toString();
Copy after login

Converting an array to a string in JavaScript is a common operation, and there are several methods to achieve this, each serving different needs. Here are the most commonly used methods:

1. join() Method

The join() method combines all elements of an array into a single string, with a specified separator between elements.

const fruits = ['apple', 'banana', 'cherry'];
const result = fruits.join(', '); // 'apple, banana, cherry'
console.log(result);
Copy after login
  • Syntax: array.join([separator])
  • Default Separator: , (comma)
  • Custom Separator: You can specify any string as a separator, such as '-', ' | ', etc.

2. toString() Method

The toString() method converts an array to a string, using commas to separate elements.

const numbers = [1, 2, 3, 4];
const result = numbers.toString(); // '1,2,3,4'
console.log(result);
Copy after login
  • Syntax: array.toString()
  • Separator: Always uses , (comma) as a separator.

3. String() Constructor

You can use the String() constructor to convert an array to a string. This approach is similar to toString() but can be more explicit in certain contexts.

const boolArray = [true, false, true];
const result = String(boolArray); // 'true,false,true'
console.log(result);
Copy after login
  • Syntax: String(array)

4. Template Literals

For custom formatting, you might use template literals to convert an array to a string.

const colors = ['red', 'green', 'blue'];
const result = `${colors[0]}, ${colors[1]}, ${colors[2]}`; // 'red, green, blue'
console.log(result);
Copy after login
  • Syntax: Use ${} to embed array elements in a template string.

5. Array.prototype.map() with join()

For more control over the conversion, especially if you need to format each element, you can use map() in combination with join().

const numbers = [1, 2, 3];
const result = numbers.map(num => `Number ${num}`).join(' | '); // 'Number 1 | Number 2 | Number 3'
console.log(result);
Copy after login
  • Syntax: array.map(callback).join(separator)

Access the Full Array

let a = [1, 12, 13, 14, 6, 8,9, 5, 11, 7, 10, 15, 2, 3, 4, 22, 44, 33];
console.log(a);
Copy after login
let a = [1, 12, 13, 14, 6, 8,9, 5, 11, 7, 10, 15, 2, 3, 4, 22, 44, 33];
document.getElementById("demo").innerHTML = a;
Copy after login

Accessing the full contents of an array in JavaScript can be done in various ways depending on the context and the goal. Here are several methods to access and work with all elements of an array:

1. Direct Access by Index

You can access individual elements of an array directly using their indices. For example, to access the first element, you use index 0.

const fruits = ['apple', 'banana', 'cherry'];
console.log(fruits[0]); // 'apple'
console.log(fruits[1]); // 'banana'
console.log(fruits[2]); // 'cherry'
Copy after login

2. Looping through the Array

You can use loops to iterate through each element of the array. Here are a few common looping methods:

a. for Loop

The traditional for loop gives you control over the index and can be useful for tasks like modifying elements based on their position.

const numbers = [10, 20, 30];
for (let i = 0; i < numbers.length; i++) {
  console.log(numbers[i]); // 10, 20, 30
}
Copy after login

b. forEach() Method

The forEach() method executes a provided function once for each array element.

const colors = ['red', 'green', 'blue'];
colors.forEach(color => {
  console.log(color); // 'red', 'green', 'blue'
});
Copy after login

c. for...of Loop

The for...of loop provides a more modern and readable way to iterate through array elements.

const fruits = ['apple', 'banana', 'cherry'];
for (const fruit of fruits) {
  console.log(fruit); // 'apple', 'banana', 'cherry'
}
Copy after login

d. map() Method

The map() method creates a new array with the results of calling a provided function on every element.

const numbers = [1, 2, 3];
const doubled = numbers.map(num => num * 2);
console.log(doubled); // [2, 4, 6]
Copy after login

3. Using Array Destructuring

Array destructuring allows you to unpack elements from arrays into distinct variables.

const [first, second, third] = ['apple', 'banana', 'cherry'];
console.log(first);  // 'apple'
console.log(second); // 'banana'
console.log(third); // 'cherry'
Copy after login

4. console.log()

To quickly view the entire array, you can use console.log().

const array = [1, 2, 3, 4, 5];
console.log(array); // [1, 2, 3, 4, 5]
Copy after login

5. toString() Method

Convert the entire array to a comma-separated string.

const array = [1, 2, 3, 4];
console.log(array.toString()); // '1,2,3,4'
Copy after login

6. join() Method

Similar to toString(), but you can specify a separator.

const array = [1, 2, 3, 4];
console.log(array.join(' - ')); // '1 - 2 - 3 - 4'
Copy after login

7. Spread Operator

Use the spread operator to create a new array or pass the array elements to a function.

const numbers = [1, 2, 3];
const newNumbers = [...numbers];
console.log(newNumbers); // [1, 2, 3]
Copy after login

JavaScript as Object

const man = ["Fatema", "CSE", "UU", 24];
console.log(man);
Copy after login

In JavaScript, arrays are indeed a type of object. This concept is fundamental to understanding how arrays work in JavaScript. Here’s a deeper look into why arrays are considered objects and how that impacts their behavior:

1. Arrays as Objects

  • Inheritance from Object: Arrays in JavaScript inherit from the Object prototype, which means they have all the properties and methods of objects. This includes methods like hasOwnProperty(), toString(), and others.

  • Prototype Chain: Arrays have their own prototype chain that extends from Array.prototype, which is itself an object. This prototype chain provides arrays with their specific methods, like push(), pop(), map(), and more.

const arr = [1, 2, 3];
console.log(arr.constructor === Array); // true
console.log(arr instanceof Object); // true
console.log(arr instanceof Array); // true
Copy after login

2. Array-Specific Properties

  • Length Property: Arrays have a length property that automatically updates as elements are added or removed. This is specific to arrays and is not present in general objects.
const fruits = ['apple', 'banana'];
console.log(fruits.length); // 2
fruits.push('cherry');
console.log(fruits.length); // 3
Copy after login
  • Index-Based Access: Arrays use numeric indices to access elements, whereas objects use string keys. This is a key distinction between arrays and regular objects.
const arr = ['a', 'b', 'c'];
console.log(arr[0]); // 'a'
Copy after login

3. Arrays vs. Objects

  • Enumerability: Arrays have numeric indices and are often used in scenarios where the order of elements is important. Objects use string keys and are typically used for key-value pairs where the order is less significant.

  • Prototype Methods: Arrays come with a set of methods specific to array manipulation, such as concat(), slice(), and reduce(). Objects have methods and properties from Object.prototype, such as hasOwnProperty().

const obj = { a: 1, b: 2 };
console.log(Object.keys(obj)); // ['a', 'b']

const arr = [1, 2, 3];
console.log(arr.map(x => x * 2)); // [2, 4, 6]
Copy after login

4. Arrays as Objects in Practice

  • Additional Properties: You can add custom properties to arrays just like you can with objects, though it's not common practice. This does not affect array behavior but can lead to unexpected results when using array methods or properties.
const arr = [1, 2, 3];
arr.customProperty = 'value';
console.log(arr.customProperty); // 'value'
Copy after login
  • Array Methods: Methods such as forEach(), filter(), and map() operate on arrays but are not part of the base Object prototype. They are defined on Array.prototype.
const numbers = [1, 2, 3];
numbers.forEach(num => console.log(num)); // 1 2 3
Copy after login

5. Practical Implications

  • Use Cases: Arrays are best used when you need to store ordered collections of data and perform operations that involve sequence and index-based access. Objects are more suited for storing data with named properties where the order is not a priority.

  • Performance: Arrays can be optimized for sequential access and manipulation due to their special handling in JavaScript engines. Objects are optimized for key-based access.

The length Property

The length property in JavaScript is a special property found on arrays and strings, and it plays a crucial role in managing collections of data. Here's a comprehensive overview of how the length property works:

1. length Property in Arrays

The length property of an array returns the number of elements in the array. It is a dynamic property that automatically updates when elements are added or removed from the array.

Basic Usage

const fruits = ['apple', 'banana', 'cherry'];
console.log(fruits.length); // 3
Copy after login

Dynamic Updates

  • Adding Elements: When you add elements to an array, the length property increases.
  const numbers = [1, 2, 3];
  numbers.push(4);
  console.log(numbers.length); // 4
Copy after login
  • Removing Elements: When you remove elements, the length property decreases.
  const numbers = [1, 2, 3];
  numbers.pop();
  console.log(numbers.length); // 2
Copy after login
  • Directly Setting Length: You can also set the length property manually. This will truncate the array or pad it with empty slots.
  const numbers = [1, 2, 3, 4, 5];
  numbers.length = 3;
  console.log(numbers); // [1, 2, 3]

  numbers.length = 5;
  console.log(numbers); // [1, 2, 3, <2 empty items>]
Copy after login
  • Truncation: Setting length to a smaller number truncates the array to that length.
  • Padding: Setting length to a larger number adds empty slots (undefined values) to the array.

2. length Property in Strings

The length property of a string returns the number of characters in the string.

Basic Usage

const message = 'Hello, World!';
console.log(message.length); // 13
Copy after login

3. Special Considerations

  • Sparse Arrays: Arrays can be sparse, meaning they may have "holes" where indices are not explicitly assigned values. The length property reflects the highest index plus one, not the number of actual elements.
  const arr = [1, , 3];
  console.log(arr.length); // 3
Copy after login

Here, arr has a length of 3, but only two indices (0 and 2) have values. The index 1 is "empty" but still counts towards the length.

  • Negative Indexes: The length property does not support negative indexes. Negative indices are not part of the standard JavaScript array indexing.

4. Practical Uses

  • Iteration: Knowing the length of an array or string is essential for iterating through elements.
  const arr = ['a', 'b', 'c'];
  for (let i = 0; i < arr.length; i++) {
    console.log(arr[i]); // 'a', 'b', 'c'
  }
Copy after login
  • Validation: Use the length property to validate input, such as ensuring a user input string meets minimum length requirements.
  function validatePassword(password) {
    return password.length >= 8;
  }
Copy after login
  • Padding and Truncation: Adjust the size of arrays and strings to fit specific requirements by setting the length property.
  const arr = [1, 2, 3];
  arr.length = 5; // Adds two empty slots
Copy after login

Adding Array Elements

Adding elements to an array in JavaScript can be done using several methods, depending on where you want to add the elements and how you want to manipulate the array. Here’s a detailed look at the various techniques for adding elements to arrays:

1. Using push()

The push() method adds one or more elements to the end of an array and returns the new length of the array.

const fruits = ['apple', 'banana'];
fruits.push('cherry'); // Adds 'cherry' to the end
console.log(fruits); // ['apple', 'banana', 'cherry']
Copy after login
  • Syntax: array.push(element1, element2, ..., elementN)

2. Using unshift()

The unshift() method adds one or more elements to the beginning of an array and returns the new length of the array.

const fruits = ['banana', 'cherry'];
fruits.unshift('apple'); // Adds 'apple' to the beginning
console.log(fruits); // ['apple', 'banana', 'cherry']
Copy after login
  • Syntax: array.unshift(element1, element2, ..., elementN)

3. Using splice()

The splice() method can add elements at any position in the array. It can also be used to remove elements.

const fruits = ['apple', 'cherry'];
fruits.splice(1, 0, 'banana'); // At index 1, remove 0 elements, add 'banana'
console.log(fruits); // ['apple', 'banana', 'cherry']
Copy after login
  • Syntax: array.splice(start, deleteCount, element1, element2, ..., elementN)
    • start: The index at which to start adding elements.
    • deleteCount: The number of elements to remove (0 if you are only adding).
    • element1, ..., elementN: The elements to add.

4. Using the Spread Operator

The spread operator (...) allows you to add elements from one array into another array. This is particularly useful for combining arrays.

const fruits = ['apple', 'banana'];
const moreFruits = ['cherry', 'date'];
const allFruits = [...fruits, ...moreFruits];
console.log(allFruits); // ['apple', 'banana', 'cherry', 'date']
Copy after login
  • Syntax: const newArray = [...array1, ...array2, ...array3]

5. Using concat()

The concat() method creates a new array by combining multiple arrays or values.

const fruits = ['apple', 'banana'];
const moreFruits = ['cherry', 'date'];
const allFruits = fruits.concat(moreFruits);
console.log(allFruits); // ['apple', 'banana', 'cherry', 'date']
Copy after login
  • Syntax: array1.concat(array2, array3, ..., value1, value2, ...)

6. Using Array Destructuring with Spread Operator

You can use array destructuring with the spread operator to add elements to specific positions in an array.

const fruits = ['apple', 'date'];
const newFruits = ['banana', ...fruits, 'cherry'];
console.log(newFruits); // ['banana', 'apple', 'date', 'cherry']
Copy after login
  • Syntax: const newArray = [element1, ...oldArray, elementN]

7. Inserting Multiple Elements

You can use splice() to insert multiple elements at a specific index.

const numbers = [1, 2, 5];
numbers.splice(2, 0, 3, 4); // Insert 3 and 4 at index 2
console.log(numbers); // [1, 2, 3, 4, 5]
Copy after login

8. Handling Empty Slots

When using length to add elements, be aware that it will add empty slots.

const arr = [1, 2, 3];
arr.length = 5; // Adds two empty slots
console.log(arr); // [1, 2, 3, <2 empty items>]
Copy after login

Nested Arrays and Objects

Nested arrays and objects in JavaScript are powerful features that allow you to create complex data structures. These can be used to represent multi-dimensional data, hierarchies, or any scenario where data is organized in layers.

1. Nested Arrays

A nested array is an array that contains other arrays as its elements. This can be useful for representing matrices, grids, or hierarchical data.

Example of a Nested Array

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

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

// Iterating through a nested array
for (const row of matrix) {
  for (const value of row) {
    console.log(value);
  }
}
Copy after login

2. Nested Objects

A nested object is an object that contains other objects as its properties. This is useful for representing hierarchical data or entities with multiple attributes.

Example of a Nested Object

const person = {
  name: 'John Doe',
  age: 30,
  address: {
    street: '123 Main St',
    city: 'Anytown',
    zipCode: '12345'
  },
  hobbies: ['reading', 'gaming']
};

// Accessing nested properties
console.log(person.address.street); // '123 Main St'
console.log(person.hobbies[1]); // 'gaming'

// Iterating through a nested object
for (const key in person) {
  if (typeof person[key] === 'object' && !Array.isArray(person[key])) {
    console.log(`Nested object ${key}:`);
    for (const subKey in person[key]) {
      console.log(`  ${subKey}: ${person[key][subKey]}`);
    }
  } else {
    console.log(`${key}: ${person[key]}`);
  }
}
Copy after login

3. Combining Nested Arrays and Objects

You can combine arrays and objects to create more complex structures. For example, you might have an array of objects, where each object contains nested arrays or other objects.

Example of Combining Nested Arrays and Objects

const classRoom = [
  {
    name: 'Math',
    students: [
      { name: 'Alice', score: 95 },
      { name: 'Bob', score: 88 }
    ]
  },
  {
    name: 'Science',
    students: [
      { name: 'Charlie', score: 92 },
      { name: 'David', score: 85 }
    ]
  }
];

// Accessing data
console.log(classRoom[0].students[1].name); // 'Bob'
console.log(classRoom[1].students[0].score); // 92

// Iterating through the combined structure
for (const subject of classRoom) {
  console.log(`Subject: ${subject.name}`);
  for (const student of subject.students) {
    console.log(`  Student: ${student.name}, Score: ${student.score}`);
  }
}
Copy after login

4. Manipulating Nested Structures

  • Accessing: Use dot notation or bracket notation for objects, and indices for arrays.

  • Updating: Assign new values to nested properties or elements.

  person.address.city = 'New City'; // Update a nested property
  classRoom[0].students[0].score = 97; // Update a nested element
Copy after login
  • Adding: Add new properties or elements as needed.
  person.phone = '555-5555'; // Add a new property
  classRoom.push({ name: 'History', students: [] }); // Add a new subject
Copy after login
  • Deleting: Use delete for properties and .splice() for array elements.
  delete person.phone; // Remove a nested property
  classRoom[1].students.splice(1, 1); // Remove a student
Copy after login

5. Practical Use Cases

  • Data Representation: Represent complex data structures such as configuration settings, hierarchical data (e.g., organizational charts), and multi-dimensional datasets.

  • APIs and Databases: Often used in API responses and database queries to represent complex records.

  • Form Data: Useful for handling nested form data, such as forms with sections or groups of fields.

JavaScript Array Methods

JavaScript arrays come with a rich set of built-in methods that help you manipulate and interact with array data. These methods can be broadly categorized into several types, including those for modifying arrays, accessing elements, and iterating over elements. Here’s a comprehensive overview of common array methods:

1. Adding and Removing Elements

  • push(): Adds one or more elements to the end of an array.
  const fruits = ['apple', 'banana'];
  fruits.push('cherry'); // ['apple', 'banana', 'cherry']
Copy after login
  • pop(): Removes the last element from an array and returns it.
  const fruits = ['apple', 'banana', 'cherry'];
  const lastFruit = fruits.pop(); // 'cherry'
Copy after login
  • unshift(): Adds one or more elements to the beginning of an array.
  const fruits = ['banana', 'cherry'];
  fruits.unshift('apple'); // ['apple', 'banana', 'cherry']
Copy after login
  • shift(): Removes the first element from an array and returns it.
  const fruits = ['apple', 'banana', 'cherry'];
  const firstFruit = fruits.shift(); // 'apple'
Copy after login
  • splice(): Adds or removes elements from a specific index.
  const fruits = ['apple', 'banana', 'cherry'];
  fruits.splice(1, 1, 'blueberry'); // ['apple', 'blueberry', 'cherry']
Copy after login
  • Syntax: array.splice(start, deleteCount, item1, item2, ...)

2. Accessing and Searching Elements

  • indexOf(): Returns the first index at which a given element can be found, or -1 if not found.
  const fruits = ['apple', 'banana', 'cherry'];
  const index = fruits.indexOf('banana'); // 1
Copy after login
  • includes(): Checks if an array contains a specific element.
  const fruits = ['apple', 'banana', 'cherry'];
  const hasBanana = fruits.includes('banana'); // true
Copy after login
  • find(): Returns the first element that satisfies a provided testing function.
  const numbers = [1, 2, 3, 4];
  const firstEven = numbers.find(num => num % 2 === 0); // 2
Copy after login
  • findIndex(): Returns the index of the first element that satisfies a provided testing function.
  const numbers = [1, 2, 3, 4];
  const index = numbers.findIndex(num => num % 2 === 0); // 1
Copy after login

3. Iterating Over Elements

  • forEach(): Executes a provided function once for each array element.
  const fruits = ['apple', 'banana', 'cherry'];
  fruits.forEach(fruit => console.log(fruit));
Copy after login
  • map(): Creates a new array with the results of calling a provided function on every element.
  const numbers = [1, 2, 3];
  const doubled = numbers.map(num => num * 2); // [2, 4, 6]
Copy after login
  • filter(): Creates a new array with all elements that pass the test implemented by the provided function.
  const numbers = [1, 2, 3, 4];
  const evens = numbers.filter(num => num % 2 === 0); // [2, 4]
Copy after login
  • reduce(): Applies a function against an accumulator and each element to reduce it to a single value.
  const numbers = [1, 2, 3, 4];
  const sum = numbers.reduce((acc, num) => acc + num, 0); // 10
Copy after login
  • reduceRight(): Similar to reduce(), but starts from the right end of the array.
  const numbers = [1, 2, 3, 4];
  const product = numbers.reduceRight((acc, num) => acc * num, 1); // 24
Copy after login
  • some(): Tests whether at least one element in the array passes the provided function.
  const numbers = [1, 2, 3, 4];
  const hasEven = numbers.some(num => num % 2 === 0); // true
Copy after login
  • every(): Tests whether all elements in the array pass the provided function.
  const numbers = [2, 4, 6];
  const allEven = numbers.every(num => num % 2 === 0); // true
Copy after login

4. Sorting and Reversing

  • sort(): Sorts the elements of an array in place and returns the array.
  const numbers = [4, 2, 3, 1];
  numbers.sort(); // [1, 2, 3, 4]
Copy after login
  • Note: sort() sorts elements as strings by default. For numerical sorting, use a compare function.
  const numbers = [4, 2, 3, 1];
  numbers.sort((a, b) => a - b); // [1, 2, 3, 4]
Copy after login
  • reverse(): Reverses the elements of an array in place.
  const numbers = [1, 2, 3];
  numbers.reverse(); // [3, 2, 1]
Copy after login

5. Array Transformation

  • concat(): Merges two or more arrays into a new array.
  const arr1 = [1, 2];
  const arr2 = [3, 4];
  const combined = arr1.concat(arr2); // [1, 2, 3, 4]
Copy after login
  • slice(): Returns a shallow copy of a portion of an array into a new array.
  const numbers = [1, 2, 3, 4];
  const sliced = numbers.slice(1, 3); // [2, 3]
Copy after login
  • splice(): Modifies an array by adding, removing, or replacing elements. (Also listed under adding/removing elements.)
  const numbers = [1, 2, 3, 4];
  numbers.splice(2, 1, 'a', 'b'); // [1, 2, 'a', 'b', 4]
Copy after login

6. String Conversion

  • toString(): Converts an array to a string, with elements separated by commas.
  const numbers = [1, 2, 3];
  const str = numbers.toString(); // '1,2,3'
Copy after login
  • join(): Joins all elements of an array into a string with a specified separator.
  const numbers = [1, 2, 3];
  const str = numbers.join('-'); // '1-2-3'
Copy after login

JavaScript Array Search

JavaScript arrays come with various methods for searching and locating elements. These methods can be used to find specific values, check for the presence of elements, or retrieve indexes. Here's a detailed overview of the key array search methods:

1. indexOf()

The indexOf() method returns the first index at which a given element can be found, or -1 if the element is not found.

const fruits = ['apple', 'banana', 'cherry'];
const index = fruits.indexOf('banana'); // 1
const notFound = fruits.indexOf('orange'); // -1
Copy after login
  • Syntax: array.indexOf(searchElement, fromIndex)

    • searchElement: The element to search for.
    • fromIndex (optional): The index to start the search from.

2. includes()

The includes() method determines whether an array contains a certain element and returns true or false.

const fruits = ['apple', 'banana', 'cherry'];
const hasBanana = fruits.includes('banana'); // true
const hasOrange = fruits.includes('orange'); // false
Copy after login
  • Syntax: array.includes(searchElement, fromIndex)

    • searchElement: The element to search for.
    • fromIndex (optional): The index to start the search from.

3. find()

The find() method returns the first element in the array that satisfies a provided testing function. If no elements satisfy the testing function, it returns undefined.

const numbers = [4, 9, 16, 25];
const firstEven = numbers.find(num => num % 2 === 0); // 4
const noMatch = numbers.find(num => num > 30); // undefined
Copy after login
  • Syntax: array.find(callback(element, index, array), thisArg)

    • callback: A function that tests each element.
    • thisArg (optional): Value to use as this when executing callback.

4. findIndex()

The findIndex() method returns the index of the first element in the array that satisfies a provided testing function. If no elements satisfy the testing function, it returns -1.

const numbers = [4, 9, 16, 25];
const index = numbers.findIndex(num => num % 2 === 0); // 0
const noMatchIndex = numbers.findIndex(num => num > 30); // -1
Copy after login
  • Syntax: array.findIndex(callback(element, index, array), thisArg)

    • callback: A function that tests each element.
    • thisArg (optional): Value to use as this when executing callback.

5. some()

The some() method tests whether at least one element in the array passes the provided testing function. It returns true if any elements pass the test, otherwise false.

const numbers = [1, 2, 3, 4];
const hasEven = numbers.some(num => num % 2 === 0); // true
const allEven = numbers.some(num => num % 2 === 0 && num > 5); // false
Copy after login
  • Syntax: array.some(callback(element, index, array), thisArg)

    • callback: A function that tests each element.
    • thisArg (optional): Value to use as this when executing callback.

6. every()

The every() method tests whether all elements in the array pass the provided testing function. It returns true if all elements pass the test, otherwise false.

const numbers = [2, 4, 6];
const allEven = numbers.every(num => num % 2 === 0); // true
const notAllEven = numbers.every(num => num > 3); // false
Copy after login
  • Syntax: array.every(callback(element, index, array), thisArg)

    • callback: A function that tests each element.
    • thisArg (optional): Value to use as this when executing callback.

7. filter()

The filter() method creates a new array with all elements that pass the test implemented by the provided function.

const numbers = [1, 2, 3, 4, 5];
const evens = numbers.filter(num => num % 2 === 0); // [2, 4]
Copy after login
  • Syntax: array.filter(callback(element, index, array), thisArg)

    • callback: A function that tests each element.
    • thisArg (optional): Value to use as this when executing callback.

8. findLast() (Experimental)

The findLast() method returns the last element in the array that satisfies a provided testing function. If no elements satisfy the testing function, it returns undefined. Note that this method is experimental and may not be supported in all environments.

const numbers = [4, 9, 16, 25];
const lastEven = numbers.findLast(num => num % 2 === 0); // 16
Copy after login
  • Syntax: array.findLast(callback(element, index, array), thisArg)

    • callback: A function that tests each element.
    • thisArg (optional): Value to use as this when executing callback.

9. findLastIndex() (Experimental)

The findLastIndex() method returns the index of the last element in the array that satisfies a provided testing function. If no elements satisfy the testing function, it returns -1. Note that this method is experimental and may not be supported in all environments.

const numbers = [4, 9, 16, 25];
const lastEvenIndex = numbers.findLastIndex(num => num % 2 === 0); // 2
Copy after login
  • Syntax: array.findLastIndex(callback(element, index, array), thisArg)

    • callback: A function that tests each element.
    • thisArg (optional): Value to use as this when executing callback.

JavaScript Sorting Arrays

Sorting arrays in JavaScript can be done using the sort() method. This method allows you to arrange elements in an array according to a specified order. By default, the sort() method sorts the elements as strings, but you can provide a custom comparison function to sort elements in different ways.

Basic Usage of sort()

The sort() method sorts the elements of an array in place and returns the sorted array.

const fruits = ['banana', 'apple', 'cherry'];
fruits.sort();
console.log(fruits); // ['apple', 'banana', 'cherry']
Copy after login

Custom Sorting with a Comparison Function

To sort elements in a specific order, you need to pass a comparison function to sort(). The comparison function takes two arguments (let's call them a and b) and returns:

  • A negative value if a should come before b.
  • Zero if a and b are equal in the sort order.
  • A positive value if a should come after b.

Sorting Numbers

By default, the sort() method converts numbers to strings and sorts them lexicographically. To sort numbers correctly, provide a comparison function that performs numerical comparisons.

const numbers = [10, 5, 100, 1];
numbers.sort((a, b) => a - b); // Ascending order
console.log(numbers); // [1, 5, 10, 100]

numbers.sort((a, b) => b - a); // Descending order
console.log(numbers); // [100, 10, 5, 1]
Copy after login

Sorting Strings

Strings are sorted lexicographically (dictionary order) by default. For case-insensitive sorting, you can convert strings to the same case (e.g., lowercase) in the comparison function.

const words = ['banana', 'Apple', 'cherry'];
words.sort((a, b) => a.localeCompare(b)); // Case-sensitive
console.log(words); // ['Apple', 'banana', 'cherry']

words.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase())); // Case-insensitive
console.log(words); // ['Apple', 'banana', 'cherry']
Copy after login

Sorting Objects

To sort an array of objects, use a comparison function that compares the desired properties of the objects.

const people = [
  { name: 'John', age: 30 },
  { name: 'Jane', age: 25 },
  { name: 'Mike', age: 35 }
];

// Sort by age
people.sort((a, b) => a.age - b.age);
console.log(people);
// [ { name: 'Jane', age: 25 }, { name: 'John', age: 30 }, { name: 'Mike', age: 35 } ]

// Sort by name
people.sort((a, b) => a.name.localeCompare(b.name));
console.log(people);
// [ { name: 'Jane', age: 25 }, { name: 'John', age: 30 }, { name: 'Mike', age: 35 } ]
Copy after login

Sorting Multi-Dimensional Arrays

When sorting multi-dimensional arrays (arrays of arrays), provide a comparison function that compares the relevant elements.

const matrix = [
  [1, 4],
  [3, 2],
  [5, 0]
];

// Sort by the first element of each sub-array
matrix.sort((a, b) => a[0] - b[0]);
console.log(matrix); // [ [1, 4], [3, 2], [5, 0] ]

// Sort by the second element of each sub-array
matrix.sort((a, b) => a[1] - b[1]);
console.log(matrix); // [ [5, 0], [3, 2], [1, 4] ]
Copy after login

Stable Sorting

JavaScript's sort() method is stable in modern environments, meaning that elements with equal values retain their relative order. However, this is not guaranteed in all JavaScript engines, so if stability is crucial, consider using a custom stable sorting algorithm or library.

Sorting with localeCompare()

The localeCompare() method can be useful for sorting strings in a locale-aware manner, accounting for different cultural sorting rules.

const words = ['résumé', 'resume', 'apple'];
words.sort((a, b) => a.localeCompare(b, 'en', { sensitivity: 'base' }));
console.log(words); // ['apple', 'resume', 'résumé']
Copy after login

JavaScript Array Iteration

JavaScript provides several methods for iterating over arrays, allowing you to execute a function on each element or transform the array in various ways. Here’s a comprehensive overview of the array iteration methods available in JavaScript:

1. forEach()

The forEach() method executes a provided function once for each array element. It does not return a value and cannot be stopped or broken out of early.

const fruits = ['apple', 'banana', 'cherry'];
fruits.forEach(fruit => console.log(fruit));
// Output:
// apple
// banana
// cherry
Copy after login
  • Syntax: array.forEach(callback(element, index, array), thisArg)

    • callback: Function that is executed for each element.
    • thisArg (optional): Value to use as this when executing callback.

2. map()

The map() method creates a new array with the results of calling a provided function on every element in the original array. It’s used for transforming elements.

const numbers = [1, 2, 3, 4];
const doubled = numbers.map(num => num * 2);
console.log(doubled); // [2, 4, 6, 8]
Copy after login
  • Syntax: array.map(callback(element, index, array), thisArg)

    • callback: Function that is executed for each element.
    • thisArg (optional): Value to use as this when executing callback.

3. filter()

The filter() method creates a new array with all elements that pass the test implemented by the provided function. It is used for selecting elements that meet certain criteria.

const numbers = [1, 2, 3, 4, 5];
const evens = numbers.filter(num => num % 2 === 0);
console.log(evens); // [2, 4]
Copy after login
  • Syntax: array.filter(callback(element, index, array), thisArg)

    • callback: Function that is executed for each element.
    • thisArg (optional): Value to use as this when executing callback.

4. reduce()

The reduce() method applies a function against an accumulator and each element in the array to reduce it to a single value, such as a sum or a concatenated string.

const numbers = [1, 2, 3, 4];
const sum = numbers.reduce((acc, num) => acc + num, 0);
console.log(sum); // 10
Copy after login
  • Syntax: array.reduce(callback(accumulator, currentValue, index, array), initialValue)

    • callback: Function that is executed for each element.
    • initialValue (optional): Value to use as the first argument to the first call of the callback.

5. reduceRight()

The reduceRight() method is similar to reduce(), but it processes the array from right to left.

const numbers = [1, 2, 3, 4];
const product = numbers.reduceRight((acc, num) => acc * num, 1);
console.log(product); // 24
Copy after login
  • Syntax: array.reduceRight(callback(accumulator, currentValue, index, array), initialValue)

    • callback: Function that is executed for each element.
    • initialValue (optional): Value to use as the first argument to the first call of the callback.

6. some()

The some() method tests whether at least one element in the array passes the test implemented by the provided function. It returns true if at least one element passes the test, otherwise false.

const numbers = [1, 2, 3, 4];
const hasEven = numbers.some(num => num % 2 === 0);
console.log(hasEven); // true
Copy after login
  • Syntax: array.some(callback(element, index, array), thisArg)

    • callback: Function that is executed for each element.
    • thisArg (optional): Value to use as this when executing callback.

7. every()

The every() method tests whether all elements in the array pass the test implemented by the provided function. It returns true if all elements pass the test, otherwise false.

const numbers = [2, 4, 6];
const allEven = numbers.every(num => num % 2 === 0);
console.log(allEven); // true
Copy after login
  • Syntax: array.every(callback(element, index, array), thisArg)

    • callback: Function that is executed for each element.
    • thisArg (optional): Value to use as this when executing callback.

8. find()

The find() method returns the first element in the array that satisfies the provided testing function. If no elements satisfy the testing function, it returns undefined.

const numbers = [4, 9, 16, 25];
const firstEven = numbers.find(num => num % 2 === 0);
console.log(firstEven); // 4
Copy after login
  • Syntax: array.find(callback(element, index, array), thisArg)

    • callback: Function that is executed for each element.
    • thisArg (optional): Value to use as this when executing callback.

9. findIndex()

The findIndex() method returns the index of the first element in the array that satisfies the provided testing function. If no elements satisfy the testing function, it returns -1.

const numbers = [4, 9, 16, 25];
const index = numbers.findIndex(num => num % 2 === 0);
console.log(index); // 0
Copy after login
  • Syntax: array.findIndex(callback(element, index, array), thisArg)

    • callback: Function that is executed for each element.
    • thisArg (optional): Value to use as this when executing callback.

10. for...of Loop

The for...of loop provides a clean syntax for iterating over iterable objects like arrays. It is especially useful for looping through array values.

const fruits = ['apple', 'banana', 'cherry'];
for (const fruit of fruits) {
  console.log(fruit);
}
// Output:
// apple
// banana
// cherry
Copy after login

11. for...in Loop

The for...in loop iterates over the enumerable properties of an object. When used with arrays, it iterates over array indices, not values. It is generally not recommended for arrays, as it is intended for objects.

const fruits = ['apple', 'banana', 'cherry'];
for (const index in fruits) {
  console.log(index); // 0, 1, 2
}
Copy after login

12. flatMap()

The flatMap() method first maps each element using a mapping function, then flattens the result into a new array. This is useful for when you need to map and then flatten the results in one go.

const numbers = [1, 2, 3];
const flattened = numbers.flatMap(num => [num, num * 2]);
console.log(flattened); // [1, 2, 2, 4, 3, 6]
Copy after login
  • Syntax: array.flatMap(callback(element, index, array), thisArg)

    • callback: Function that is executed for each element.
    • thisArg (optional): Value to use as this when executing callback.

JavaScript Array Const

In JavaScript, const is a keyword used to declare variables that are intended to remain constant—i.e., their references cannot be reassigned. However, this does not mean the value or object they point to is immutable. For arrays declared with const, the array itself cannot be reassigned, but its elements can still be modified.

Here's a more detailed look at using const with arrays:

1. Declaring Arrays with const

When you declare an array with const, you are creating a constant reference to that array. This means you cannot reassign the array to a different value or array, but you can still modify its elements or its structure (such as adding or removing elements).

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

// Valid: modifying elements
fruits[0] = 'blueberry'; // ['blueberry', 'banana', 'cherry']
fruits.push('date');     // ['blueberry', 'banana', 'cherry', 'date']

console.log(fruits);

// Invalid: reassigning the array
fruits = ['kiwi', 'mango']; // TypeError: Assignment to constant variable.
Copy after login

2. Modifying Arrays

Even though you cannot reassign the const array, you can use array methods to modify its contents:

  • Adding Elements: Use methods like push(), unshift(), or splice().
  const numbers = [1, 2, 3];
  numbers.push(4); // [1, 2, 3, 4]
  numbers.unshift(0); // [0, 1, 2, 3, 4]
Copy after login
  • Removing Elements: Use methods like pop(), shift(), or splice().
  const colors = ['red', 'green', 'blue'];
  colors.pop(); // ['red', 'green']
  colors.shift(); // ['green']
Copy after login
  • Modifying Elements: Directly access and change elements by index.
  const animals = ['cat', 'dog', 'bird'];
  animals[1] = 'fish'; // ['cat', 'fish', 'bird']
Copy after login

3. Array Methods

Methods that modify the array in place are allowed:

  • sort(): Sorts the elements of the array.
  const numbers = [3, 1, 4, 1, 5];
  numbers.sort(); // [1, 1, 3, 4, 5]
Copy after login
  • reverse(): Reverses the order of elements.
  const letters = ['a', 'b', 'c'];
  letters.reverse(); // ['c', 'b', 'a']
Copy after login
  • splice(): Adds or removes elements.
  const fruits = ['apple', 'banana', 'cherry'];
  fruits.splice(1, 1, 'blueberry', 'date'); // ['apple', 'blueberry', 'date', 'cherry']
Copy after login

4. Immutability of Arrays

If you need an immutable array, where changes to the array are not allowed, you need to use additional techniques or libraries to achieve this. JavaScript itself does not provide immutable arrays directly.

For example, you could use libraries like Immutable.js for immutability:

import { List } from 'immutable';

const immutableList = List([1, 2, 3]);
const newList = immutableList.push(4); // Returns a new List: List [ 1, 2, 3, 4 ]
console.log(immutableList); // List [ 1, 2, 3 ]
Copy after login

Summary

JavaScript provides a wide range of operations and methods to handle arrays, including creation, manipulation, searching, and iteration. Here's a summary of the most common array operations:

1. 作成と初期化

  • リテラル構文: const array = [1, 2, 3];
  • 配列コンストラクターの使用: const array = new Array(3); // 3 つの空のスロットを持つ配列を作成します

2. 要素へのアクセスと変更

  • インデックスによるアクセス: const firstElement = array[0];
  • インデックスによる変更: array[0] = 10;

3. 配列メソッド

創造と変革

  • concat(): 配列を結合します。 const 結合 = array1.concat(array2);
  • flat(): ネストされた配列を平坦化します。 const flatArray =nestedArray. flat();
  • flatMap(): マップしてからフラット化します。 const result = array. flatMap(x => [x, x * 2]);

並べ替え

  • sort(): 要素を並べ替えます。 array.sort((a, b) => a - b);
  • reverse(): 順序を逆にします。配列.reverse();

要素の追加と削除

  • push(): 要素を最後に追加します。配列.push(4);
  • pop(): 最後の要素を削除します。 const last = array.pop();
  • unshift(): 要素を先頭に追加します。配列.unshift(0);
  • shift(): 最初の要素を削除します。 const first = array.shift();
  • splice(): 指定されたインデックスの要素を追加または削除します。 array.splice(1, 1, 'newElement');

反復

  • forEach(): 各要素に対して関数を実行します。 array.forEach(element => console.log(element));
  • map(): 要素を変換し、新しい配列を返します。 const newArray = array.map(x => x * 2);
  • filter(): テストに合格した要素を返します。 const filtered = array.filter(x => x % 2 === 0);
  • reduce(): 配列を単一の値に削減します。 const sum = array.reduce((acc, x) => acc + x, 0);
  • reduceRight(): 配列を右から左に縮小します。 const product = array.reduceRight((acc, x) => acc * x, 1);
  • some(): 要素がテストに合格するかどうかをテストします。 const hasEven = array.some(x => x % 2 === 0);
  • every(): すべての要素がテストに合格するかどうかをテストします。 const allPositive = array.every(x => x > 0);
  • find(): テストに合格した最初の要素を検索します。 const found = array.find(x => x > 3);
  • findIndex(): テストに合格した最初の要素のインデックスを検索します。 const インデックス = array.findIndex(x => x > 3);
  • flatMap(): 結果をマップして平坦化します。 const flattened = array. flatMap(x => [x, x * 2]);

4. 検索とインデックス作成

  • indexOf(): 要素の最初のインデックスを検索します。 const インデックス = array.indexOf(3);
  • includes(): 要素が存在するかどうかを確認します。 const が存在します = array.includes(3);
  • lastIndexOf(): 要素の最後のインデックスを検索します。 const lastIndex = array.lastIndexOf(3);

5. その他

  • slice(): 配列の一部の浅いコピーを返します。 const subArray = array.slice(1, 3);
  • join(): 配列要素を文字列に結合します。 const str = array.join('-');
  • toString(): 配列を文字列に変換します。 const str = array.toString();

6. 配列と定数

  • const with Arrays: 配列参照の再割り当てを防ぎますが、配列要素と構造の変更は許可します。 const 配列 = [1, 2, 3];配列.push(4); // 許可された

7. 高度な反復

  • for...of: 値を反復処理します。 for (配列の定数値) { console.log(value); }
  • for...in: インデックスを反復します (配列にはあまり推奨されません)。 for (配列内の const インデックス) { console.log(index); }

要するに

  • 作成: 配列リテラルまたはコンストラクターを使用します。
  • アクセス/変更: インデックスベースの操作を使用します。
  • メソッド: 変換、並べ替え、追加/削除、反復用。
  • 検索/インデックス: 要素とインデックスを検索します。
  • const: 定数参照に使用し、変更を許可します。
  • 反復: さまざまな反復ニーズに応じて、forEach()、map()、filter() などを使用します。

これらの操作を理解して効果的に利用すると、JavaScript で配列をより効率的かつ柔軟に管理および操作できるようになります。

The above is the detailed content of Mastering JavaScript Arrays: Techniques, Best Practices, and Advanced Uses. For more information, please follow other related articles on the PHP Chinese website!

source:dev.to
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template