assignment to property of function parameter foreach

• Assignment to property of function parameter no-param-reassign

Last updated: Mar 7, 2024 Reading time · 3 min

# Table of Contents

• Disabling the no-param-reassign ESLint rule for a single line
• Disabling the no-param-reassign ESLint rule for an entire file
• Disabling the no-param-reassign ESLint rule globally

# Assignment to property of function parameter no-param-reassign

The ESLint error "Assignment to property of function parameter 'X' eslint no-param-reassign" occurs when you try to assign a property to a function parameter.

To solve the error, disable the ESLint rule or create a new object based on the parameter to which you can assign properties.

Here is an example of how the error occurs.

The ESLint rule forbids assignment to function parameters because modifying a function's parameters also mutates the arguments object and can lead to confusing behavior.

One way to resolve the issue is to create a new object to which you can assign properties.

We used the spread syntax (...) to unpack the properties of the function parameter into a new object to which we can assign properties.

If you need to unpack an array, use the following syntax instead.

The same approach can be used if you simply need to assign the function parameter to a variable so you can mutate it.

We declared the bar variable using the let keyword and set it to the value of the foo parameter.

We are then able to reassign the bar variable without any issues.

# Disabling the no-param-reassign ESLint rule for a single line

You can use a comment if you want to disable the no-param-reassign ESLint rule for a single line.

Make sure to add the comment directly above the assignment that causes the error.

# Disabling the no-param-reassign ESLint rule for an entire file

You can also use a comment to disable the no-param-reassign ESLint rule for an entire file.

Make sure to add the comment at the top of the file or at least above the function in which you reassign parameters.

The same approach can be used to disable the rule only for a single function.

The first comment disables the no-param-reassign rule and the second comment enables it.

If you try to reassign a parameter after the second comment, you will get an ESLint error.

# Disabling the no-param-reassign ESLint rule globally

If you need to disable the no-param-reassign rule globally, you have to edit your .eslintrc.js file.

If you only want to be able to assign properties to an object parameter, set props to false instead of disabling the rule completely.

The following code is valid after making the change.

If you use a .eslintrc or .eslintrc.json file, make sure to double-quote the properties and values.

If you want to only allow assignment to object parameters, use the following line instead.

Make sure all properties are double-quoted and there are no trailing commas if your config is written in JSON.

# Additional Resources

You can learn more about the related topics by checking out the following tutorials:

• eslint is not recognized as an internal or external command
• Plugin "react" was conflicted between package.json » eslint-config-react-app
• React: Unexpected use of 'X' no-restricted-globals in ESLint
• TypeScript ESLint: Unsafe assignment of an any value [Fix]
• ESLint error Unary operator '++' used no-plusplus [Solved]
• ESLint Prefer default export import/prefer-default-export
• Arrow function should not return assignment. eslint no-return-assign
• TypeError: Cannot redefine property: X in JavaScript [Fixed]
• ESLint: disable multiple rules or a rule for multiple lines
• Expected linebreaks to be 'LF' but found 'CRLF' linebreak-style
• Missing return type on function TypeScript ESLint error

Borislav Hadzhiev

Web Developer

Copyright © 2024 Borislav Hadzhiev

HatchJS.com

Cracking the Shell of Mystery

How to Assign to the Property of a Function Parameter in JavaScript

Assignment to Property of Function Parameter

One of the most powerful features of JavaScript is the ability to assign values to the properties of function parameters. This can be used to create complex and dynamic code that can be easily modified.

In this article, we will take a closer look at assignment to property of function parameter. We will discuss what it is, how it works, and how it can be used to improve your code.

We will also provide some examples of how assignment to property of function parameter can be used in practice. By the end of this article, you will have a solid understanding of this important JavaScript concept.

In JavaScript, a function parameter is a variable that is declared inside the function’s parentheses. When a function is called, the value of the argument passed to the function is assigned to the function parameter.

For example, the following function takes a string argument and prints it to the console:

js function greet(name) { console.log(`Hello, ${name}`); }

greet(“world”); // prints “Hello, world”

In this example, the `name` parameter is assigned the value of the `”world”` argument.

Assignment to property of function parameter

Assignment to property of function parameter is a JavaScript feature that allows you to assign a value to a property of a function parameter. This can be useful for initializing the value of a parameter or for passing a reference to an object.

For example, the following code assigns the value `”hello”` to the `name` property of the `greet` function parameter:

js function greet(name) { name.value = “hello”; }

greet({ value: “world” }); // prints “hello”

In this example, the `name` parameter is a JavaScript object. The `value` property of the `name` object is assigned the value of the `”hello”` argument.

When to use assignment to property of function parameter?

You should use assignment to property of function parameter when you need to:

• Initialize the value of a parameter
• Pass a reference to an object

Avoid creating a new object

Initializing the value of a parameter

You can use assignment to property of function parameter to initialize the value of a parameter. For example, the following code initializes the `name` property of the `greet` function parameter to the value of the `”world”` argument:

js function greet(name) { name.value = “world”; }

Passing a reference to an object

You can use assignment to property of function parameter to pass a reference to an object. For example, the following code passes a reference to the `person` object to the `greet` function:

js function greet(person) { console.log(`Hello, ${person.name}`); }

const person = { name: “John Doe” };

greet(person); // prints “Hello, John Doe”

You can use assignment to property of function parameter to avoid creating a new object. For example, the following code uses assignment to property of function parameter to avoid creating a new object for the `name` parameter:

greet(“John Doe”); // prints “Hello, John Doe”

In this example, the `name` parameter is a string literal. The `name` property of the `name` parameter is assigned the value of the `”John Doe”` string literal. This avoids creating a new object for the `name` parameter.

Assignment to property of function parameter is a JavaScript feature that can be used to initialize the value of a parameter, pass a reference to an object, and avoid creating a new object. It is a powerful feature that can be used to improve the performance and readability of your code.

Additional resources

• [MDN: Assignment to property of function parameter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Assignment_to_property_of_function_parameter)
• [Stack Overflow: When to use assignment to property of function parameter?](https://stackoverflow.com/questions/1435573/when-to-use-assignment-to-property-of-function-parameter)
• [Codecademy: Assignment to property of function parameter](https://www.codecademy.com/learn/javascript/lessons/assignment-to-property-of-function-parameter)

3. How to use assignment to property of function parameter?

To use assignment to property of function parameter, you can simply assign a value to the property of the function parameter. For example, the following code assigns the value `”hello”` to the `name` property of the `greet` function parameter:

In this example, the `greet` function is called with the argument `”world”`. The `name` property of the `greet` function parameter is then assigned the value `”hello”`. When the `greet` function is called, the value of the `name` property is used to print the message `”Hello, world”`.

Assignment to property of function parameter can be used to initialize the value of a parameter, pass a reference to an object, or avoid creating a new object.

You can use assignment to property of function parameter to initialize the value of a parameter. For example, the following code initializes the value of the `name` property of the `greet` function parameter to the value of the `name` variable:

js function greet(name) { name = “world”; console.log(`Hello, ${name}`); }

In this example, the `name` variable is assigned the value `”world”` before the `greet` function is called. The `name` property of the `greet` function parameter is then assigned the value of the `name` variable. When the `greet` function is called, the value of the `name` property is used to print the message `”Hello, world”`.

You can use assignment to property of function parameter to pass a reference to an object. For example, the following code passes a reference to the `user` object to the `greet` function:

js function greet(user) { console.log(`Hello, ${user.name}`); }

const user = { name: “John Doe”, };

greet(user); // prints “Hello, John Doe”

In this example, the `user` object is passed to the `greet` function as a parameter. The `greet` function then uses the `name` property of the `user` object to print the message `”Hello, John Doe”`.

Avoiding creating a new object

You can use assignment to property of function parameter to avoid creating a new object. For example, the following code uses assignment to property of function parameter to avoid creating a new object for the `user` variable:

In this example, the `user` variable is assigned the value of the `user` object. The `greet` function then uses the `name` property of the `user` variable to print the message `”Hello, John Doe”`.

By using assignment to property of function parameter, you can avoid creating a new object for the `user` variable. This can improve the performance of your code and reduce the amount of memory that is used.

4. Pitfalls of assignment to property of function parameter

There are a few pitfalls to be aware of when using assignment to property of function parameter:

• The value of the property may be overwritten. If you assign a value to the property of a function parameter, the value of the property may be overwritten by the next time the function is called. For example, the following code assigns the value `”hello”` to the `name` property of the `greet` function parameter. The next time the `greet` function is called, the value of the `name` property will be overwritten by the value of the `name` argument.

js function greet(name) { name = “hello”; console.log(`Hello, ${name}`); }

greet(“world”); // prints “Hello, hello” greet(“hello”); // prints “Hello, hello”

A: Assignment to property of function parameter occurs when you assign a value to a property of a function parameter. This can be done by using the dot operator (.) to access the property, or by using the bracket operator ([]) to index into the property.

For example, the following code assigns the value “10” to the `x` property of the `foo()` function’s parameter `y`:

const foo = (y) => { y.x = 10; };

foo({ x: 5 }); // { x: 10 }

Q: Why is assignment to property of function parameter dangerous?

A: Assignment to property of function parameter can be dangerous because it can change the value of the property in the calling scope. This can lead to unexpected behavior and errors.

For example, the following code changes the value of the `x` property of the global variable `a`:

foo({ x: 5 }); // a.x is now 10

This behavior can be difficult to debug, as it may not be obvious that the change to the `x` property is being caused by the `foo()` function.

Q: How can I avoid assignment to property of function parameter?

There are a few ways to avoid assignment to property of function parameter. One way is to use the `const` keyword to declare the function parameter as a constant. This will prevent the value of the parameter from being changed.

Another way to avoid assignment to property of function parameter is to use the `readonly` keyword to declare the function parameter as read-only. This will prevent the value of the parameter from being changed, even by assignment to a property of the parameter.

Finally, you can also use the `Object.freeze()` method to freeze the object that is passed as the function parameter. This will prevent any changes to the object, including changes to the values of its properties.

Q: What are the best practices for assignment to property of function parameter?

The best practices for assignment to property of function parameter are as follows:

• Use the `const` keyword to declare function parameters as constants.
• Use the `readonly` keyword to declare function parameters as read-only.
• Use the `Object.freeze()` method to freeze objects that are passed as function parameters.

Here are some key takeaways from this article:

• Assigning to the property of a function parameter can change the value of the original variable.
• This can lead to unexpected behavior and security vulnerabilities.
• To avoid this problem, use the `const` keyword or pass arguments by reference.

By following these tips, you can write more secure and reliable JavaScript code.

Author Profile

Latest entries

• December 26, 2023 Error Fixing User: Anonymous is not authorized to perform: execute-api:invoke on resource: How to fix this error
• December 26, 2023 How To Guides Valid Intents Must Be Provided for the Client: Why It’s Important and How to Do It
• December 26, 2023 Error Fixing How to Fix the The Root Filesystem Requires a Manual fsck Error
• December 26, 2023 Troubleshooting How to Fix the `sed unterminated s` Command

Similar Posts

How to fix the failed to convert value of type ‘java.lang.string’ error.

Failed to Convert Value of Type ‘java.lang.String’ Have you ever tried to convert a value of type `java.lang.String` to another type, only to get an error message like `failed to convert value of type ‘java.lang.String’`? If so, you’re not alone. This is a common error that can occur for a variety of reasons. In this…

Next.js Debug GetServerSideProps

Next.js Debug GetServerSideProps Next.js is a popular framework for building server-rendered React applications. One of the features that makes Next.js so powerful is its ability to get server-side props. This means that you can pass data from the server to your React components before they are rendered, which can improve performance and SEO. However, debugging…

How to Swap Array Elements in JavaScript

Swapping Array Elements in JavaScript Arrays are one of the most fundamental data structures in JavaScript. They allow us to store multiple pieces of data of the same type in a single variable. But what if we need to swap two elements of an array? Swapping two array elements is a relatively simple task, but…

Property ‘then’ does not exist on type ‘Promise’: error handling in JavaScript

Property does not exist on type Promise The error “Property does not exist on type Promise” is a common one that JavaScript developers encounter. It occurs when you try to access a property on a Promise that doesn’t exist. This can happen for a number of reasons, but the most common is that you’re trying…

How to Fix JavaScript onclick Not Working

JavaScript onclick Not Working: A Comprehensive Guide Have you ever tried to use the onclick event in JavaScript, only to have it not work? You’re not alone. This is a common problem, and there are a number of reasons why it might happen. In this comprehensive guide, we’ll take a look at the most common…

Javax Net Ssl SSLHandshakeException: Received fatal alert certificate_unknown

**Have you ever been trying to access a website and been presented with an error message saying that your connection is not private?** If so, you’ve likely encountered a **javax.net.ssl.SSLHandshakeException: Received fatal alert certificate_unknown** error. This error occurs when your browser is unable to verify the authenticity of the website’s certificate. This can be caused…

no-param-reassign

Disallow reassigning function parameters

Assignment to variables declared as function parameters can be misleading and lead to confusing behavior, as modifying function parameters will also mutate the arguments object. Often, assignment to function parameters is unintended and indicative of a mistake or programmer error.

This rule can be also configured to fail when function parameters are modified. Side effects on parameters can cause counter-intuitive execution flow and make errors difficult to track down.

Rule Details

This rule aims to prevent unintended behavior caused by modification or reassignment of function parameters.

Examples of incorrect code for this rule:

Examples of correct code for this rule:

This rule takes one option, an object, with a boolean property "props" , and arrays "ignorePropertyModificationsFor" and "ignorePropertyModificationsForRegex" . "props" is false by default. If "props" is set to true , this rule warns against the modification of parameter properties unless they’re included in "ignorePropertyModificationsFor" or "ignorePropertyModificationsForRegex" , which is an empty array by default.

Examples of correct code for the default { "props": false } option:

Examples of incorrect code for the { "props": true } option:

Examples of correct code for the { "props": true } option with "ignorePropertyModificationsFor" set:

Examples of correct code for the { "props": true } option with "ignorePropertyModificationsForRegex" set:

When Not To Use It

If you want to allow assignment to function parameters, then you can safely disable this rule.

This rule was introduced in ESLint v0.18.0.

Further Reading

JavaScript: Don’t Reassign Your Function Arguments

• Rule source
• Tests source

© OpenJS Foundation and other contributors Licensed under the MIT License. https://eslint.org/docs/latest/rules/no-param-reassign

forEach method in JavaScript - A Comprehensive Guide

Mastering foreach method: learn to use it for iterating arrays and enhancing your code..

14 min read

Table of contents

Introduction, prerequisites, understanding the purpose of foreach, syntax and parameters, defining and passing callbacks to foreach, accessing element, index, and original array within the callback, 'thisarg' parameter in foreach method, arrow functions for concise and expressive callbacks, benefits of using foreach, real-world example of foreach.

forEach method In JavaScript is an essential component that simplifies the process of iterating over elements in an array. It provides a convenient and straightforward way to perform actions on each element without using the traditional loop.

With its ease of use and versatility, it allows developers to perform operations on each element individually, such as accessing its value, modifying it, or invoking other functions based on specific conditions.

In this comprehensive blog post, we will dive deep into the forEach method, and try to understand its concepts through practical examples.

By the end, you'll have a solid understanding of how to leverage the full potential of forEach in your JavaScript projects, enhancing your coding skills and productivity.

So let's dive into the world of forEach and unlock its capabilities together!

Before diving into the world of forEach, it's very important to have a basic understanding of JavaScript fundamentals, arrays, functions, and iteration concepts.

I assume you are familiar with fundamental topics such as variables, data types, operators, control flow, array properties and methods, function definition and invocation, and loops and conditional statements.

Before reading the full article please make sure you understand these topics. Because without having knowledge of these topics there is a high chance you won't understand the examples I have used in this article.

Additionally, If you're new to JavaScript or need a refresher, there are few online resources available to learn the basics.

Websites like MDN Web Docs , W3Schools , and freeCodeCamp offer comprehensive tutorials and guides that can help you get started on your JavaScript journey.

Also, I highly recommend the following two books for beginners in JavaScript:

Head First JavaScript Programming: A Brain-Friendly Guide

JavaScript: The Definitive Guide: Master the World's Most-Used Programming Language

By diving into these resources, you'll gain a solid foundation in JavaScript programming and acquire the skills required to explore the world of forEach method in JavaScript and open up new opportunities for your web development projects.

To study and explore the forEach method in-depth, it's crucial to understand its purpose first. Because It may seem pointless to go into its details before understanding the goal.

So, let's take a moment to understand why the forEach method exists and what it aims to achieve.

The purpose of the forEach method in JavaScript is to simplify the process of iterating over elements in an array and performing an action on each element. It provides a more elegant and expressive alternative to traditional for loops , making code more readable and concise.

By using the forEach method in JavaScript, you can avoid the hassle of manually managing everything and focus on the logic you want to execute for each array element. It abstracts away the low-level details of iteration and allows you to concentrate on the specific operation you wish to perform.

For example, consider an array of names:

If you wanted to print each name to the console using a traditional for loop , you would need to handle the index and access the array elements explicitly:

However, with the forEach method, the syntax becomes much more straightforward:

Note: If you're feeling confused about the syntax of the forEach method at this point, don't worry! We will dive into the syntax and explain all its parameters using examples. So, please be patient and read the full article until the end. We'll make sure everything becomes clear and understandable.

The forEach method abstracts away the index management, providing a clean and concise way to iterate over the array and execute the desired action for each element. It simplifies the code structure, enhances readability, and reduces the chances of introducing errors.

So, by understanding the purpose of the forEach method, you can appreciate its value and leverage it effectively in your JavaScript projects. It serves as a powerful tool for iterating over arrays and performing actions on each element, making your code more elegant and efficient.

The syntax of forEach is quite straightforward. It follows this format:

The key component of forEach is the callback function, which is executed for each element in the array. It plays a vital role in defining the actions to be performed on each element.

The callback function accepts three parameters:

currentValue

These parameters provide valuable information during the iteration process.

The callback function allows you to define the actions to be performed on each element during the iteration.

The currentValue parameter represents the current element being processed, while the index parameter provides the index of the current element. The array parameter refers to the array on which the forEach method is being called.

Additionally, you can optionally specify the thisArg parameter to determine the value of this within the callback .

By utilizing the callback function and these parameters effectively, you can perform custom operations on each element of the array, such as modifying the values, accessing properties, or invoking other functions.

Now that we have learned the syntax of the forEach method in JavaScript, let's explore how to work with it and understand its functionality in the next sections.

To use the forEach method, you need to define and pass a callback function as its parameter. This callback function will be invoked for each element in the array.

There are two common ways to define the callback function:

Inline function

named function

Let's see how we can use the Inline function as the callback through an example:

In the above example, we define an inline callback function directly as an argument to the forEach method. This function takes an element parameter, representing each element in the numbers array.

By using inline callback functions, you can keep the code concise and avoid the need for defining separate named functions. Inline functions are particularly useful for simple operations that don't require reusability.

Now let's see Passing a named function as the callback:

In the above example, we define a named function logElement that takes an element parameter. We then pass this named function as an argument to the forEach method.

Passing a named function is useful when you have complex or reusable operations that you want to separate from the forEach loop. It enhances code modularity and allows you to reuse the same function in other parts of your codebase.

Note: Whether you choose to define the callback function inline or as a named function depends on the complexity and reusability of the operations you need to perform on each element. Both approaches are valid and provide flexibility in how you work with the forEach method.

When working with the forEach method in JavaScript, the parameters of the forEach method allows you to access and work with the current element, index, and the original array within the callback function.

Let's explore how to use each parameter effectively:

Current Element (element) : The first parameter of the callback function represents the current element being processed. You can use this parameter to perform actions or operations on each element individually. For example:

In this example, the callback function logs each fruit to the console. The fruit parameter represents the current element being processed, allowing you to access and work with it within the function.

Index (index) : The second parameter of the callback function represents the index of the current element. It provides the position of the element within the array.

For example:

In this example, the callback function logs each fruit along with its corresponding index . The index parameter allows you to access and utilize the index information within the function.

Original Array (array) : The third parameter of the callback function represents the original array being iterated. It allows you to reference the entire array and perform operations or make decisions based on its properties or other elements.

In this example, the callback function checks if the length of the array is greater than 3 and logs a message if it is. The array parameter provides access to the original array, enabling you to use its properties or perform operations based on the array as a whole.

By utilizing these parameters effectively within the callback function, you can access and work with the current element, index, and the original array to perform various operations, make decisions, or modify the array elements as needed.

The second parameter of the forEach method in JavaScript is called thisArg . It is an optional parameter that allows you to specify the value of this within the callback function.

By default, when the callback function is executed, the value of this inside the callback function refers to the global object ( window in a browser environment or global in Node.js).

However, if you pass a value for thisArg , the this value within the callback function will be set to the provided value. The thisArg parameter can be useful in scenarios where you want to explicitly set the context or scope for the callback function.

For example, if you have an object and you want to use a method from that object as the callback function, you can pass the object as thisArg to ensure the method is invoked with the correct context.

Here's an example to illustrate the usage of the thisArg parameter:

In this example, we have an object person with a greet method. We use the forEach method on an array of names and pass person.greet as the callback function.

By passing person as the thisArg parameter, we ensure that the greet method is invoked with person as the this value, allowing it to access the name property correctly.

By understanding and utilizing the thisArg parameter effectively, you can control the context in which the callback function is executed and tailor it to your specific needs.

In the previous section, we have seen how to define and pass callback in the forEach method and we have used normal functions as the callbacks.

But it is also possible to use arrow functions instead of normal functions as callbacks.

Arrow functions provide a more compact syntax for defining functions and automatically bind the current scope, eliminating the need for explicit binding or preserving the this keyword. This results in code that is easier to read and understand.

Here's an example demonstrating the use of arrow functions as callbacks with the forEach method:

In the above example, we have an array called numbers containing a sequence of numeric values. Instead of using a traditional function expression, we utilize an arrow function as the callback for the forEach method.

The arrow function takes element as its parameter, representing the current element being processed. Arrow functions provide a concise and expressive way to define callback functions.

They have a more compact syntax, and the lexical scoping of arrow functions allows them to automatically bind the current scope, which means you don't need to explicitly bind or preserve the this keyword.

By using arrow functions as callbacks, you can make your code more readable and maintainable. They offer a clean and concise way to define functions, especially for short and straightforward operations within the forEach loop.

After exploring various aspects of the forEach method, Now it's time to explore the benefits it offers.

To understand the benefits of forEach Let's consider the example that we are using so far. Iterating over an array of numbers and performing various actions on each element using the forEach method.

Here are the benefits that we are getting from forEach method in JavaScript:

Cleaner Syntax : In the example, forEach provides a cleaner syntax compared to traditional for loops . The callback function focuses on the action to be performed on each element ( console.log(element * 2) ), without the need for manual index management or loop control.

Improved Readability : By using forEach, the purpose of the iteration is clearly stated. Other developers can easily understand that we are doubling each element ( element * 2 ), making the code more readable and comprehensible.

Simplified Iteration : With forEach , we don't need to worry about initializing counters, defining loop conditions, or incrementing indexes manually. The forEach method takes care of all the iteration details, allowing us to focus on the specific action of doubling each element.

Avoiding Common Pitfalls : The forEach method automatically handles the iteration logic, ensuring that the callback function is executed for each element in the array. This avoids common pitfalls like off-by-one errors or infinite loops, as forEach guarantees that every element is processed correctly.

Enhancing Functional Programming : The example aligns with functional programming principles by using forEach . We define the desired action for each element within the callback function, separating the iteration logic from the specific action of doubling the elements. This promotes a declarative style of coding, enhancing immutability and predictability.

Compatibility with Array-like Objects : Although the example uses an array, forEach is also compatible with array-like objects. This flexibility allows us to apply the same iteration logic to different types of collections, such as NodeList or HTMLCollection, expanding the utility of the forEach method.

By considering these benefits within the context of the provided example, we can see how forEach simplifies iteration, improves readability, and aligns with functional programming principles.

So far, we have learned so many things related to forEach method in JavaScript. Now let's see a real-world example of forEach so that we can feel all things we have learned so far.

Suppose you have an array of user objects representing customers in an e-commerce application. Each user object contains properties such as name , email , and purchasedItems . You want to send a personalized email to each customer, thanking them for their purchase and providing additional information about related products. Here is the code snippet to do that:

In the given example, the forEach method is used to iterate over the users array. For each user, a personalized email is generated using template literals and the user's data. The email is then sent to the respective user's email address using the sendEmail function.

Inside the forEach loop, a callback function is defined, which takes a single argument, user . This parameter represents the current user object being processed during each iteration. By destructuring the user object, we extract the relevant properties such as name , email , and purchasedItems using object destructuring.

Using template literals, we then generate personalized email content for each user. The email content includes a thank-you message, the purchased items, and a suggestion to explore new arrivals. The join() method is used to concatenate the purchased items into a comma-separated string.

Once the email content is generated, it can be passed to the sendEmail function along with the customer's email address ( email ) to send the email. You can assume that the sendEmail function is a custom function that handles the logic of sending emails.

The forEach loop ensures that the callback function is executed for each user in the users array, allowing you to send personalized emails to all customers who made purchases.

Cool, right?

This example highlights the benefits of using forEach in a real-world scenario. It simplifies the process of iterating over an array, eliminating the need for manual loop control and index management. It allows you to focus on the specific task of generating personalized emails for each user, enhancing code readability and maintainability.

It's just a simple example of a use case that we can achieve using the forEach method in JavaScript. And I believe now you can feel how much powerful this forEach method is.

forEach method in JavaScript is a fundamental tool in JavaScript that empowers developers to iterate over arrays with ease and flexibility.

By understanding its features and concepts you can leverage the full potential of forEach in your projects, making your code more concise, readable, and efficient.

With the knowledge gained from this comprehensive guide, you are well-equipped to use the power of forEach and elevate your JavaScript programming skills to new heights.

Remember to practice and experiment with the concepts discussed in this blog post to solidify your understanding and become a master of the forEach method in JavaScript.

Happy coding :)

• Skip to main content
• Skip to search
• Skip to select language
• Sign up for free
• Português (do Brasil)

Array.prototype.forEach()

Baseline widely available.

This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015 .

• See full compatibility
• Report feedback

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

A function to execute for each element in the array. Its return value is discarded. The function is called with the following arguments:

The current element being processed in the array.

The index of the current element being processed in the array.

The array forEach() was called upon.

A value to use as this when executing callbackFn . See iterative methods .

Return value

None ( undefined ).

Description

The forEach() method is an iterative method . It calls a provided callbackFn function once for each element in an array in ascending-index order. Unlike map() , forEach() always returns undefined and is not chainable. The typical use case is to execute side effects at the end of a chain. Read the iterative methods section for more information about how these methods work in general.

callbackFn is invoked only for array indexes which have assigned values. It is not invoked for empty slots in sparse arrays .

The forEach() method is generic . It only expects the this value to have a length property and integer-keyed properties.

There is no way to stop or break a forEach() loop other than by throwing an exception. If you need such behavior, the forEach() method is the wrong tool.

Early termination may be accomplished with looping statements like for , for...of , and for...in . Array methods like every() , some() , find() , and findIndex() also stops iteration immediately when further iteration is not necessary.

forEach() expects a synchronous function — it does not wait for promises. Make sure you are aware of the implications while using promises (or async functions) as forEach callbacks.

To run a series of asynchronous operations sequentially or concurrently, see promise composition .

Converting a for loop to forEach

Printing the contents of an array.

Note: In order to display the content of an array in the console, you can use console.table() , which prints a formatted version of the array.

The following example illustrates an alternative approach, using forEach() .

The following code logs a line for each element in an array:

Using thisArg

The following (contrived) example updates an object's properties from each entry in the array:

Since the thisArg parameter ( this ) is provided to forEach() , it is passed to callback each time it's invoked. The callback uses it as its this value.

Note: If passing the callback function used an arrow function expression , the thisArg parameter could be omitted, since all arrow functions lexically bind the this value.

An object copy function

The following code creates a copy of a given object.

There are different ways to create a copy of an object. The following is just one way and is presented to explain how Array.prototype.forEach() works by using Object.* utility functions.

Flatten an array

The following example is only here for learning purpose. If you want to flatten an array using built-in methods, you can use Array.prototype.flat() .

Using the third argument of callbackFn

The array argument is useful if you want to access another element in the array, especially when you don't have an existing variable that refers to the array. The following example first uses filter() to extract the positive values and then uses forEach() to log its neighbors.

Using forEach() on sparse arrays

The callback function is not invoked for the missing value at index 2.

Calling forEach() on non-array objects

The forEach() method reads the length property of this and then accesses each property whose key is a nonnegative integer less than length .

Specifications

Browser compatibility

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

• Polyfill of Array.prototype.forEach in core-js
• Indexed collections guide
• Array.prototype.find()
• Array.prototype.map()
• Array.prototype.filter()
• Array.prototype.every()
• Array.prototype.some()
• TypedArray.prototype.forEach()
• Map.prototype.forEach()
• Set.prototype.forEach()

Disallow Reassignment of Function Parameters (no-param-reassign)

Assignment to variables declared as function parameters can be misleading and lead to confusing behavior, as modifying function parameters will also mutate the arguments object. Often, assignment to function parameters is unintended and indicative of a mistake or programmer error.

This rule can be also configured to fail when function parameters are modified. Side effects on parameters can cause counter-intuitive execution flow and make errors difficult to track down.

Rule Details

This rule aims to prevent unintended behavior caused by modification or reassignment of function parameters.

Examples of incorrect code for this rule:

Examples of correct code for this rule:

This rule takes one option, an object, with a boolean property "props" , and arrays "ignorePropertyModificationsFor" and "ignorePropertyModificationsForRegex" . "props" is false by default. If "props" is set to true , this rule warns against the modification of parameter properties unless they're included in "ignorePropertyModificationsFor" or "ignorePropertyModificationsForRegex" , which is an empty array by default.

Examples of correct code for the default { "props": false } option:

Examples of incorrect code for the { "props": true } option:

Examples of correct code for the { "props": true } option with "ignorePropertyModificationsFor" set:

Examples of correct code for the { "props": true } option with "ignorePropertyModificationsForRegex" set:

When Not To Use It

If you want to allow assignment to function parameters, then you can safely disable this rule.

Further Reading

• JavaScript: Don’t Reassign Your Function Arguments

This rule was introduced in ESLint 0.18.0.

• Rule source
• Documentation source

© OpenJS Foundation and other contributors Licensed under the MIT License. https://eslint.org/docs/rules/no-param-reassign

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications You must be signed in to change notification settings

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement . We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Initialize some property for each object in a list #1614

kirantambe commented Oct 24, 2017

ljharb commented Oct 24, 2017

• 👍 1 reaction

Sorry, something went wrong.

kirantambe commented Oct 25, 2017

No branches or pull requests

no-param-reassign

Disallows reassignment of function parameters.

Assignment to variables declared as function parameters can be misleading and lead to confusing behavior, as modifying function parameters will also mutate the arguments object. Often, assignment to function parameters is unintended and indicative of a mistake or programmer error.

This rule can be also configured to fail when function parameters are modified. Side effects on parameters can cause counter-intuitive execution flow and make errors difficult to track down.

Rule Details

This rule aims to prevent unintended behavior caused by modification or reassignment of function parameters.

Examples of incorrect code for this rule:

Examples of correct code for this rule:

This rule takes one option, an object, with a boolean property "props" , and arrays "ignorePropertyModificationsFor" and "ignorePropertyModificationsForRegex" . "props" is false by default. If "props" is set to true , this rule warns against the modification of parameter properties unless they're included in "ignorePropertyModificationsFor" or "ignorePropertyModificationsForRegex" , which is an empty array by default.

Examples of correct code for the default { "props": false } option:

Examples of incorrect code for the { "props": true } option:

Examples of correct code for the { "props": true } option with "ignorePropertyModificationsFor" set:

Examples of correct code for the { "props": true } option with "ignorePropertyModificationsForRegex" set:

When Not To Use It

If you want to allow assignment to function parameters, then you can safely disable this rule.

Further Reading

• https://spin.atomicobject.com/2011/04/10/javascript-don-t-reassign-your-function-arguments/

This rule was introduced in ESLint 0.18.0.

• Rule source
• Test source
• Documentation source

优雅解决： assignment to property of function parameter ‘state‘

在airbnb的eslint规则中，有这样一条规则 no-param-reassign

目的是提醒你不要直接修改函数的入参。因为假如入参是一个对象，修改入参可能会导致对象的属性被覆盖。

但有一些情况下，我们必须要这样做，比如在 vuex 中

其实，不仅仅是vuex，再比如express的 req res ，前端事件处理的 e.returnvalue 都需要直接给入参赋值。这时候我们显然不希望直接disable掉这条规则，或者在发生冲突的代码处单独disable。

这时候可以使用 ignorePropertyModificationsFor 这个属性，他可以为这个规则添加一个白名单，即指定的入参名称不予限制。看代码就明白了：

如上代码配置即可避免vuex与eslint的冲突。

请填写红包祝福语或标题

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

PowerShell ForEach-Object and ForEach Loop Explained

PowerShell ForEach and ForEach-Objects loops are one of the most commonly used functions. They allow you to easily iterate through collections. But what is the difference between ForEach-Object and the ForEach() cmdlets?

Both cmdlets look similar, and basically, they allow you to perform the same action. But knowing the difference between the two, allows you to improve your PowerShell script.

In this article

In this article, we are going to take a look at how to use PowerShell ForEach and ForEach-Object and explain the difference between the two.

ForEach() vs ForEach-Object

The PowerShell ForEach() and ForEach-Object cmdlet both allow you to iterate through a collection and perform an action against each item in it. However, there is a difference in how they handle the data and in the usability.

The ForEach() cmdlet loads the entire collection into the memory before it starts processing the items. By loading the collection into the memory of your computer, it’s faster than the ForEach-Object cmdlet.

On the other hand, the PowerShell ForEach-Object cmdlet also you to pipe it behind another cmdlet. This way it can process each item as it comes down the pipeline. This also means that you can pipe other cmdlets behind it.

Besides these two cmdlets, we also have the two aliases ForEach (note, without the parenthesis  () ) and % . Both are an alias for the ForEach-Object cmdlet, but this can be a bit confusing sometimes. The commands below are all the same:

Now for a small collection, the performance difference and memory usage are minimal. In the example above is the ForEach() statement only 4ms faster and the scriptblock is easier to read. But when working with large collections, you might want to take memory usage into consideration.

When you are loading a large CSV file, for example, it’s more efficient to pipe the ForEach-Object cmdlet behind it, instead of storing the results first into a variable:

PowerShell ForEach

The ForEach statement in PowerShell allows you to iterate through an array or a list of items. The syntax of the ForEach statement is pretty straightforward:

As you can see, we can specify the collection that we want to loop through, this can be an array or list, and we specify a variable for iterator. This will contain the value of each item that is inside the collection.

For example, to print out each fruit to the console we can do the following:

Using Collections

We can also use the PowerShell ForEach statement with a cmdlet that returns a collection. Most will pipe the ForEach-Object cmdlet behind a cmdlet, but that is not always necessary. The advantage of using the ForEach statement is that it is easier to read compared to the ForEach-Object cmdlet.

For example, the Get-ChildItem cmdlet returns all the files and folders from a given path. To iterate through the files we can do the following:

As you can see, the Get-ChildItem returns the file or folder object. Inside the script block, we can access all the properties of the item, in this case, the item name.

Break and Continue

When working with ForEach loops in PowerShell you sometimes want to stop the iterations when a certain value is found or skip an item based on its value. To do this we can use the Break and Continue keywords.

For example, if we want to check if a value is evenly divisible by 7. If not, then we continue to the next item:

The Break keyword allows you to stop the PowerShell foreach loop when a certain condition is met. Now I don’t use these often, most of the time you can write better code by using where-object cmdlets or using appropriate filters. But below is an example to give you an idea of how you could use the Break keyword:

Nested ForEach Loops

Inside a scriptblock, you can use other foreach statements as well. Try to keep it at a minimum, because when you are using too many nested foreach loops, your code will become harder to read and debug.

Take the following example, we have an array of teams and inside each team, we have an array of players. The outer foreach loop iterates over each team in the $teams array. The inner foreach loop then iterates over the players within each team.

PowerShell ForEach-Object

The PowerShell ForEach-Object cmdlet is used when you want to iterate through items that are streamed from a pipeline. The advantage of ForEach-Object is that it starts processing the items as they come down the pipeline and you can also pipe other cmdlets behind it.

You want to use this cmdlet when you are working with large collections or datasets because even though it’s slower than the foreach statement, it doesn’t consume that much memory.

Another advantage ForEach-Object is that you can speed it up by using the parallel switch in PowerShell 7. This allows you to process multiple items simultaneously, but more about that later.

As mentioned, the ForEach-Object cmdlet is piped behind another cmdlet. You can use one (or more) script blocks to specify the operation that you want to execute on the current item. For example, to get all process names of the running processes you can do:

As you can see in the example above, we reference the current item using the $_ variable.

You can pipe other cmdlets behind the PowerShell ForEach-Object scriptblock. So if you want to store each process name in a text file, you could do the following:

In the examples above, we are executing only a small script in the scriptblock, which allows us to write everything in one single line. But you can also add larger scripts inside the script block:

Begin, End, and Multiple Script blocks

When using the ForEach-Object cmdlet, you can use a begin and an end script block. These script blocks are only executed once, whereas the normal scriptblock (the process scriptblock) is executed for each item in the collection.

Begin and End script blocks are great when you need to register the start and end time of a script, or when you want to register the starting or end of a process:

In the example above, we have labeled each script block with what it is, the begin, process, and end block. But you don’t need to specify this (I recommend doing it, because it makes your code more readable).

If you specify multiple script blocks, then the first block is always treated as a beginning block.

If you have more than two blocks, then the last is always treated as an end block. Every block in between is a process block.

If you want to run multiple process blocks but don’t want to use a begin or end block, then you will have to specify the parameters begin, process, and end, and map a $null value to the first and latter:

Using Parallel Processing

If you have a really slow script block or when you need to process a lot of items ( 10.000+ ) then you can use the -parallel parameter in PowerShell 7.x and higher. This way the script block will run in parallel for each item, allowing you to process multiple items simultaneously.

By default, the parallel parameter will process the items in batches of 5. But with the -Trottelimit parameter we can define the number of run spaces that we want to use. The example below will process the 8 items in batches of 4:

With the parallel parameter, a new runspace is created for each batch. This means that if you need to reference a variable outside the script block, you will need to use the $using: variable to reference it:

Now good to know is that running scripts in parallel isn’t always faster. To be honest, 98% of the time isn’t faster. To problem with executing your scriptblock in parallel, is that it takes time to create the runspace to execute the script.

Without the parallel function, your scriptblock is executed in your current PowerShell thread. This way it has access to all your variables, pipeline, and loaded memory. But to execute the script block in parallel, it will need to start a new PowerShell thread (create a new runspace), and this takes time (up to 1 second roughly).

So this only makes sense when your script block is really slow, CPU intensive, or need to wait on an API to respond for example.

For example, writing “Hello World” takes only a couple of milliseconds:

But when executed in parallel, it will almost take more than 30 milliseconds to execute:

If we however have a script that takes more than 1 second to execute (simulated here with a start-sleep), then the parallel method will have an advantage:

Break, Continue, and Return

Just like with the foreach statement, we can use Break to stop a PowerShell ForEach-Object loop, but we can’t use Continue though. A break will stop the iteration in the ForEach-Object loop completely and exit the loop:

However, if we try to use Continue inside a ForEach-Object loop, then you will see that it also stops and exists in the loop. So the example below won’t work:

Instead, we will need to use the return keyword to continue to the next item in the collection.

Wrapping Up

In most cases, using the foreach() statement is the fastest and most readable method to use a ForEach loop. If you however need to process a lot of data, or need to pipe other cmdlets behind it, then it’s better to use the ForEach-Object cmdlet.

Keep in mind that the parallel function might seem nice to use, but in most cases, it’s slower because of the time needed to start up a new runspace. So make sure you measure the differences.

I hope you liked this article, if you have any questions, just drop a comment below. Subscribe to the newsletter if you want to read more of these articles!

You may also like the following articles

Steps to Install Exchange Online PowerShell Module

PowerShell Do While Loop Explained

How to Get the Computer Name with PowerShell

2 thoughts on “powershell foreach-object and foreach loop explained”.

Great article and explanation.

Thanks for the great explanation!

Leave a Comment Cancel reply

Notify me of followup comments via e-mail. You can also subscribe without commenting.

So, about that AdBlocker... Will you consider disabling it?

Yes, ads can be annoying. But they allow me to keep writing content like this. You can also support me by Buying Me a Coffee ☕ or visit the shop to get some Tech-Inspired merchandise | Read more about disabling AdBlockers

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Assignment to function parameter 'value' no-param-reassign

I am trying to get rid off the no-param-reassign error from the following code.

Tried with adding the followings:

Nothing has worked. Also tried creating a new variable and assign to it. Still didn't work. I can't commit code due to that error.

I need to update this ( properties.color ) array element with function parameter value.

• typescript-eslint

• See if it helps, stackoverflow.com/a/35637900/13262332 –  DJ Hemath Commented Mar 25, 2022 at 4:20
• Unfortunately I tried most of the suggestion from the post you suggested. But nothing worked. –  PineCone Commented Apr 4, 2022 at 7:55

Know someone who can answer? Share a link to this question via email , Twitter , or Facebook .

Your answer.

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Browse other questions tagged reactjs typescript-eslint reassign or ask your own question .

• The Overflow Blog
• Looking under the hood at the tech stack that powers multimodal AI
• Featured on Meta
• User activation: Learnings and opportunities
• Preventing unauthorized automated access to the network
• What does a new user need in a homepage experience on Stack Overflow?
• Announcing the new Staging Ground Reviewer Stats Widget

Hot Network Questions

• My team is not responsive to group messages and other group initiatives. What should be the appropriate solution?
• Change of variable, u = y(x)
• How am I supposed to solder this tiny component with pads UNDER it?
• What does St Paul mean by ' height or depth' in Romans 8:39?
• Is it ok if I was wearing lip balm and my bow touched my lips by accident and then that part of the bow touched the wood on my viola?
• Was the total glaciation of the world, a.k.a. snowball earth, due to Bok space clouds?
• How would you say "must" as in "Pet rabbits must be constantly looking for a way to escape."?
• Smallest prime q such that concatenation (p+q)"q is a prime
• Does it ever make sense to have a one-to-one obligatory relationship in a relational database?
• How to achieve 24t-38t front chainrings
• Establishing Chirality For a 4D Person?
• Consequences of registering a PhD at german university?
• Terminated employee will not help the company locate its truck
• My one-liner 'delete old files' command finds the right files but will not delete them
• "First et al.", many authors with same surname, and IEEE citations
• Model looks dented but geometry is correct
• Trinitarian Christianity says Jesus was fully God and Fully man. Did Jesus (the man) know this to be the case?
• Count squares in my pi approximation
• What's the origin of "she's no better than she should be"?
• How do exchange mail enabled security groups handle emails to multiple groups with overlapping members?
• Why a relay frequently clicks when a battery is low?
• How can one win a teaching award?
• Writing in first person for fiction novel, how to portray her inner dialogue and drag it out to make a chapter long enough?
• What is a “bearded” oyster?