Loopis in the Enterprise Collaboration Industry

Loop

Introduction is a fundamental part of any programming language, and JavaScript is no exception. is a powerful tool that allows developers to iterate over collections of data, perform operations on each item, and make decisions based on certain conditions. JavaScript Loop JavaScript loop However, loops can quickly become a source of problems if not implemented properly. Poorly written loops can lead to performance issues, bugs, and code that is difficult to maintain. Whether you're a beginner or an experienced developer, writing efficient and effective loops can be a challenging task. In this comprehensive guide, we'll explore the best practices for writing that will help to take your code from noob to pro. We'll start with the basics, including choosing the right loop type and optimizing loop performance. JavaScript loops Then we'll dive into more advanced topics like using functional programming techniques and being careful with the asynchronous loops to avoid weird things in your code. Whether you're working with , , or other data structures, our tips and tricks will help you write clean, concise, and bug-free loops. arrays objects So if you're ready to master the art of , buckle up and let's dive in! JavaScript loop Choosing the Right Type of Loop When you are writing a loop in JavaScript, the First thing you need to do is choose the right type of loop. JavaScript offers several types of loops, including , , and , each with its own strengths and weaknesses. for loop while loop do-while loop Depending on the specific requirements of your code, one type of loop may be more efficient or more readable than another. Therefore, it's essential to consider the situation and choose the appropriate loop type to achieve the desired results. let's enlighten them one by one: Starting with the most popular one, The . It's the most common type of loop in JavaScript and is often used when you know how many times you want to execute a block of code. For loop For example, imagine you have an array of numbers and you want to calculate their sum: let numbers = [1, 2, 3, 4, 5] 
let sum = 0 
for (let i = 0; i < numbers.length; i++) { 
    sum += numbers[i] 
} 
console.log(sum) // Output: 15 Here, the is used to iterate over each element in the numbers array and add its value to the variable. Next , it is useful when you want to repeatedly execute a block of code until a certain condition is met. for loop sum While loop For example, imagine you want to generate random numbers between and until you get a number greater than : 0 1 0.5 let randomNumber = Math.random() 
while (randomNumber <= 0.5) { 
    randomNumber = Math.random() 
} 
console.log(randomNumber) // Output: a number greater than 0.5 In this case, the while loop repeatedly generates a new random number until it gets one that is greater than . 0.5 Next . It's similar to , but the difference is that a will always execute its block of code at least once, regardless of whether the condition is initially or . Do-while loop while loop do-while loop true false For example, imagine you want to ask the user to enter a number between and , and keep asking until they enter a valid number: 1 10 let number 
do { 
number = prompt('Enter a number between 1 and 10:') 
} while (number < 1 || number > 10) 
console.log(number) // Output: a number between 1 and 10 In this case, the repeatedly prompts the user to enter a number until they enter a number between and . do-while loop 1 10 So, as you can see, choosing the right type of loop depends on the specific task you are trying to accomplish. If you know how many times you want to execute a block of code, a may be the best choice. for loop If you want to repeatedly execute a block of code until a certain condition is met, or may be more appropriate. while loop do-while loop By selecting the right type of loop, you can make your code more efficient and easier to read. Use the Right Loop Control Statement After choosing the appropriate loop for your desired task, the Next thing you need to know is how to use the right loop control statement. There are two main loop control statements available in JavaScript: and . break continue These Loop control statements allow you to control the flow of a loop. is used to exit a loop completely when a certain condition is met. On the other hand, is used to skip the current iteration of the loop and move on to the next one. break continue For example, let's say you have an array of numbers and you want to find the first number in the array using a for loop. You can use to exit the loop once you find the first number: even break even const numbers = [1, 3, 2, 5, 4, 7, 6] 
for (let i = 0; i < numbers.length; i++) { 
    if (numbers[i] % 2 === 0) { 
        console.log(`The first even number is ${numbers[i]}`) 
        break 
    } 
} In this example, the loop will exit as soon as it finds the first number (which is ). Without the statement, the loop would continue iterating through the rest of the array. even 2 break On the other hand, let's say you want to print out all the numbers in the array, skipping over any numbers. You can use to skip the numbers: odd even continue even const numbers = [1, 3, 2, 5, 4, 7, 6] 
for (let i = 0; i < numbers.length; i++) { 
        if (numbers[i] % 2 === 0) { 
            continue 
        }         
    console.log(`Odd number: ${numbers[i]}`) 
} In this example, the loop will skip over the numbers and only print out the numbers (which are , , , and ). Without the continue statement, the loop would print out all the numbers in the array. odd 1 3 5 7 Now, we know how to choose the right loop for our task also when to use and . break continue Let's move to the next thing we need to think of when writing a loop, and this is optimizing the Loop performance. Optimizing the Loop Performance In normal situations, it may not create a big change in our code performance, but when we will work with a large number of data, optimizing the loop performance will become one of the most important things. Because Loop performance can have a significant impact on the overall performance of your JavaScript code. Therefore, it's essential to profile and optimize the performance of your loops. Here are some tips for optimizing loop performance: Avoiding Unnecessary Calculations One way to optimize loop performance is by avoiding unnecessary calculations. To understand the point, let's have a look at the example below: Suppose you have a loop that iterates over an . In that case, when you use a for loop to iterate over an array, the of the array is checked in each iteration to see if the loop should continue. array length For example, consider the following code: let arr = [1, 2, 3, 4, 5] 
for (let i = 0; i < arr.length; i++) { 
    console.log(arr[i]) 
} In each iteration of the loop, is checked to see if is less than the of the array. arr.length i length However, is a property of the array, and accessing it in each iteration can be expensive if the array is very large. arr.length Note: In JavaScript, an array is a special type of object that can store a collection of values of any data type. Every array has a property, which represents the number of elements in the array. This property is automatically updated as elements are added to or removed from the array. Since an array is an object, it can have properties and methods just like any other object. However, the property is unique to arrays and allows for easy access to the number of elements in the array. length length length To improve performance, you can cache the of the array outside the loop, like this: length let arr = [1, 2, 3, 4, 5] 
let len = arr.length // caching the length outside the loop 
for (let i = 0; i < len; i++) { 
    console.log(arr[i]) 
} By doing this, you avoid accessing the property of the array in each iteration, which can improve the performance of your code. This technique can be particularly useful when working with large arrays. length Note: It's worth noting that modern JavaScript engines like V8 are optimized to handle loops efficiently, and in some cases, caching the length of the array may not provide a significant performance boost. However, it's still a good practice to follow, especially when working with large arrays or in performance-critical code. Use Efficient Loops Another way to optimize loop performance is by using efficient loops. For example, is generally more efficient than the loop when iterating over arrays. for loop forEach Let's see the code snippet below to understand this: let arr = [1, 2, 3, 4, 5] // Using for loop for iterating over the array 
for (let i = 0, len = arr.length; i < len; i++) { 
    console.log(arr[i]) 
} In the above example, we are using a to iterate over the array. But the question is we could do the same using the . for loop arr forEach loop This is the better approach. Right? This topic is a bit complex and deserves a separate blog post to explain briefly. But one of the main reasons is when we use the loop, it creates a new function scope for every element in the array. forEach This means that for each element, a new function is created, and when the iteration is done, those functions are destroyed. This process is not an issue if the array is small. However, for larger arrays, it can slow down the loop's execution. On the other hand, creates a single function scope for the entire loop, which means that it only has to create and destroy a single function scope. for loop Also, provides a way to get control over the loop iteration using the and which simply doesn't provide. for loop break continue forEach loop That's why the is more optimized for looping over arrays. for loop Minimize DOM Manipulation In loops, it's important to minimize DOM manipulation as much as possible. Because, when working with the Document Object Model (DOM) in JavaScript, manipulating the DOM can be a time-consuming process. Each time you make a change to the DOM, the browser has to reflow and repaint the page, which can slow down your application, especially when working with large numbers of elements. For Example: // Inefficient DOM manipulation 
for (let i = 0; i < 1000; i++) { document.getElementById('myDiv').innerHTML += '<p>' + i + '</p>' 
} 
// More efficient DOM manipulation let output = '' 
for (let i = 0; i < 1000; i++) { 
    output += '<p>' + i + '</p>' 
} 
document.getElementById('myDiv').innerHTML = output In the given example, the first loop is inefficient because it manipulates the DOM on every iteration. The property of the element is updated with a new paragraph element on every iteration, resulting in a total of manipulations of the DOM. innerHTML myDiv 1000 On the other hand, the second loop is more efficient because it minimizes DOM manipulation. Instead of updating the DOM on every iteration, the loop concatenates a string of HTML to a variable called output. Once the loop is complete, the output string is used to update the property of the element just once, resulting in a single manipulation of the DOM. innerHTML myDiv Avoid Common Mistakes There are a few common mistakes that developers normally do, and you should be aware of and when working with loops in JavaScript: avoid common mistakes Modifying Loop Variables Inside the Loop can lead to unexpected results or errors. It's generally not a good practice to modify loop variables inside the loop. Instead, you should use a separate variable to store any values that you want to modify. Modifying loop variables inside the loop For example, consider the following loop: for (let i = 0; i < 10; i++) { 
    console.log(i); i++; // modifying i inside the loop 
} In this loop, i is being modified inside the loop, which can lead to unexpected results. Instead, you should use a separate variable to store any values that you want to modify, like this: for (let i = 0; i < 10; i++) { 
    console.log(i); 
    let modifiedValue = i + 1; // using a separate variable to modify i 
} Not Using Curly Braces It's possible to write a loop without curly braces, but it's generally not recommended. Without curly braces, it can be difficult to read and understand your code, and it can also lead to unexpected results or errors. For example, consider the following loop: for (let i = 0; i < 10; i++) 
console.log(i); This loop does not have curly braces, which can make it difficult to read and understand the code. It's better to always use curly braces, even for single-line statements: for (let i = 0; i < 10; i++) { 
    console.log(i); 
} Be Careful of Infinite Loop An is a loop that never stops. This can happen if you don't set up the correct exit condition or if the exit condition is never met. Infinite loops can cause your program to crash or hang, and they can be difficult to debug. infinite loop For example: Consider a loop that always increments the value of a variable but never checks if it has exceeded a certain value: let count = 0 
while (count < 10) { 
    console.log(count) 
} This code will result in an infinite loop because the count variable is never incremented beyond . 0 That's why you should always be careful about infinite loops. To avoid infinite loops, make sure you set up the correct exit condition and test it thoroughly. Off-by-One Errors occur when you use the wrong comparison operator or when you don't take into account the initial value of a loop variable. These errors can lead to incorrect results in your program or even crashes in some cases. Off-by-one errors For example, let's say you have an array with elements, and you want to loop through it and perform some operation on each element. 10 Here's how you might write the loop: const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; 
for (let i = 0; i < arr.length; i++) { 
    console.log(arr[i]); 
} This code will loop through all elements of the array and print their values to the console. However, what if you accidentally use the wrong comparison operator and write instead of ? 10 i <= arr.length i < arr.length const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; 
for (let i = 0; i <= arr.length; i++) { 
    console.log(arr[i]); 
} This code will result in an error because it will try to access an element that doesn't exist when is equal to . The loop will run a total of times instead of , and the final iteration will throw an error because is . off-by-one i arr.length 11 10 arr[10] undefined To avoid errors, always double-check your loop conditions to make sure you're using the correct comparison operator and taking into account the initial value of your loop variable. off-by-one By avoiding these , you can ensure that your loops are running as intended and reduce the chances of errors or crashes in your program. It's always a good idea to double-check your loops for these mistakes before running your code. common mistakes Use Recursion If Needed While loops are powerful, sometimes can be an even more elegant solution. recursion It is particularly useful for traversing hierarchical data structures, where it's not possible to know how many levels of nesting there are in advance. It can also lead to simpler and more elegant code than using nested loops, especially in cases where the depth of the structure is not known in advance. Note: It's important to use recursion carefully and avoid infinite recursion, which can lead to a stack overflow error. For example: Let's say you have a nested array of numbers, and you want to find the of all the numbers in the array, including the nested ones. One way to do this is by using recursion. Here's an example of how you could use recursion to find the : sum sum const nestedArray = [[1, 2, [3]], 4]; 
function sumArray(arr) { 
    let sum = 0; 
     for (let i = 0; i < arr.length; i++) { 
        if (Array.isArray(arr[i])) { 
            // If the element is an array, call the function recursively 
            sum += sumArray(arr[i]); } else { 
            // If the element is a number, add it to the sum 
            sum += arr[i]; 
        } 
      } 
return sum; 
} 
console.log(sumArray(nestedArray)); // Output: 10 In this example, we used because the input data, , is a data structure and the function need to traverse all the elements of the structure, regardless of the number of levels of nesting. Recursion nestedArray hierarchical allows the function to call itself repeatedly until it reaches the deepest level of nesting and returns a value that can be used to calculate the final . Recursion sum The function checks whether each element in the array is an array itself, and if it is, the function calls itself with that element as the input. This process repeats until all the nested arrays are traversed and the function reaches the deepest level of nesting, which is a number. At that point, the function returns the number to the previous level of recursion, which can then use that value to calculate the of all the elements in the current level of nesting. sum Conclusion is a fundamental part of any developer's toolbox, but they can be tricky to master. By following these best practices, you can write more efficient and effective loops that will help take your code to the next level. JavaScript loop Choose the right type of loop, use the right loop control statement, optimize loop performance, avoid common mistakes, and consider using recursion when appropriate. By keeping these tips in mind, you'll be well on your way to becoming a expert. JavaScript loop So take the time to evaluate and optimize your loops, and your code will be better for it. Visit my personal blog where I write more content like this: Roblog Other Posts of Mine: Javascript setTimeout method - All you need to know forEach method in JavaScript - A Comprehensive Guide Javascript hasOwnProperty: A Powerful Property Checking tool How to Round a Number to 2 Decimal Places in JavaScript How to Check if a String is Empty in JavaScript

JavaScript Loop: The Best Practices to Have the Optimal Performance

Testing has been a subject for developers for a while now, the agile Manifesto is more than 20 years old. Before that, we had eXtreme Programming (XP), and XP was the precursor for testing, meaning: having testable code as a practice, shifting left the need for writing the test first. This is not to say that, before, XP developers weren't testing applications - but writing test code became popular. Along those lines came different concerns, for example, any developer that follows TDD (Test Driven Development) or is familiar with that, follows the flow: write a failing test, make it pass with the simplest possible change, and then, refactor. Refactoring is a crucial step. Although practitioners have been practicing TDD for a few years, as there is no formal education, some questions come to mind: Should I use logic inside my tests? Should I use multiple assertions inside my tests? Here, we will focus on the assertions aspect of things as well as the logic inside the tests, using for loops for example. To For Loop or Not? If you think about that at first glance, having logic (of any kind  inside a test case) is something that looks like a smell. Diving a bit on the subject,  the mentions that tests should have no logic inside the test case. xUnit book For example, the classic logic is the if/else statement: if variable X is equal to true, I will assert that X is true, otherwise I will assert that Y is a string. With that, the test has two different reasons to fail. If you do that, you will have to spend some extra time understanding the logic behind the test and dedicate time to debugging which branch failed. In the end, if you have dynamic code in the test case, who will test the test? Therefore, we still have the question “Is it ok to use ?“ there.  Let’s start with some survey data, as it could provide insights into what approach practitioners follow. for loops in test cases The didn't get much attention but, from the ones that answered, it seems that developers don't care much about that (as interesting as it could sound, but in the comments, there are strong opinions). Twitter poll On the one hand, the results show just a minor difference. The "no", you should not use won the poll, but with a difference of 2.5% of the votes compared to “yes”. Not that much difference. for loops, On the other hand, If you take the GitHub repositories used in the , and navigate inside the source code, the probability of seeing a for loop inside the test case is not that high; at least, it wasn't for me. The pattern is the without for loops. TDD anti-patterns series AAA Last but Not Least, What About Multiple Assertions? There is a grey area in the comments on the tweet, but as far as the , there is no rule of having only one assertion per test case; the winner was “As many as I want“. poll data on Twitter goes Developers said that for the testing in place, if you are asserting multiple times the same behavior, why shouldn't you use multiple assertions? Elliotte Rusty Harold lists, as a best practice, to use one assertion per test method: https://youtu.be/fr1E9aVnBxw?t=938 All in all, assertions are a tricky subject to tackle, and it depends on the context in which the test was written, as such the takeaway from this section for me is the following: listen to your tests (Steve Freeman and Nat Pryce). Listening to the tests and the feedback it gives is an indicator of whether you are doing something good or not - good in the sense that it gives your ease of keeping the test running fast and gives the correct feedback when it fails.

The Never-Ending Debate: For Loops in Test Cases or Multiple Assertions

In this part of creating your programming language, we will implement loops. Please see the previous parts: Building Your Own Programming Language From Scratch Building Your Own Programming Language From Scratch: Part II - Dijkstra's Two-Stack Algorithm Build Your Own Programming Language Part III: Improving Lexical Analysis with Regex Lookaheads Building Your Own Programming Language From Scratch Part IV: Implementing Functions Building Your Own Programming Language From Scratch: Part V - Arrays The full source code is available over on . GitHub Our language will provide the following types of loops: loop - to iterate through a range: For loop - to iterate as long as a specified condition is true: While loop - to iterate through elements of arrays and structures: For-each (Iterable) 1 Lexical analysis In the first section, we will cover lexical analysis. It’s a process to divide the source code into language lexemes, such as keyword, identifier/variable, operator, etc. To make our lexical analysis work with loop constructions, we add the following lexemes: , , to the TokenType enum: Keyword loop in by package org.example.toylanguage.token;

...
public enum TokenType {
    ...
        Keyword("(if|elif|else|then|end|print|input|struct|fun|return|loop|in|by)(?=\\s|$)"),
    ...
} Then, in order to separate the lower and upper bounds of the For loop range, we add the two-dot lexeme: GroupDivider [.]{2} ...
public enum TokenType {
    ...
    GroupDivider("(\\[|\\]|\\,|\\{|}|[.]{2})"),
    ...
} And finally, if we don’t want the lexeme to catch the two-dot lexeme declared after the loop’s lower bound, we add a negative look ahead construction before the dot expression: Numeric GroupDivider (?![.]{2}) ...
public enum TokenType {
    ...
    Numeric("([-]?(?=[.]?[0-9])[0-9]*(?![.]{2})[.]?[0-9]*)"),
    ...
} 2 Syntax analysis Let’s move to the next section - the syntax analysis, which will convert the lexemes received from the previous step into the final statements following our language rules. As was said at the beginning, our language will support three types of loops: For, While and Iterable. Therefore, first we will declare the class, which will contain common execution process for all the loop types: AbstractLoopStatement package org.example.toylanguage.statement.loop;

public abstract class AbstractLoopStatement extends CompositeStatement {
    protected abstract void init();

    protected abstract boolean hasNext();

    protected abstract void preIncrement();

    protected abstract void postIncrement();
} Inside this class, we declare the following abstract methods, which can have different implementation for each loop type: - it will be invoked to perform initialization operations, like initializing a counter variable when a loop starts the execution. init() - It will be called before each iteration to define that we still have remaining items to iterate. hasNext() - It’s a prefix operation that will be called before each iteration. preIncrement() - It’s a postfix operation that will be called at the end of each iteration. postIncrement() Before creating the loop implementations, we complete the method by utilizing declared abstract methods. To start the execution, we invoke the method to initialize the loop state, but before that, we should open the new MemoryScope for the variables declared within the loop, as they shouldn’t be accessed after the loop ends. In the end of the execution, we release the earlier opened MemoryScope: Statement#execute() init() MemoryContext.newScope();

try {
	init();
} finally {
	MemoryContext.endScope();
} Next, to iterate a loop, we utilize the abstract method. Inside each iteration, we invoke the loop’s inner statements, defined within the inherited CompositeStatement class. When the iteration starts, we invoke the method to perform the prefix increment operations. At the end of each iteration, we call the method to perform the postfix increment operations accordingly: hasNext() preIncrement() postIncrement() while (hasNext()) {
	preIncrement();

	try {

		// execute inner statements
		for (Statement statement : getStatements2Execute()) {
			statement.execute();
		}
	} finally {
		postIncrement();
	}
} Next, to make sure that variables declared inside the loop statements are isolated from each iteration, we open the inner MemoryScope during the statements' execution. And finally, if our loop is defined inside the function and one of the loop’s inner statements contains a return statement, we should stop the iteration immediately because it’s a sign to exit a function. Therefore, we validate that the function's return statement hasn’t been called after each statement execution. The complete method: AbstractLoopStatement#execute() public abstract class AbstractLoopStatement extends CompositeStatement {
    ...

    @Override
    public void execute() {
        MemoryContext.newScope();
        try {

            init();

            while (hasNext()) {
                preIncrement();

                MemoryContext.newScope();

                try {

                    // execute inner statements
                    for (Statement statement : getStatements2Execute()) {
                        statement.execute();

                        if (ReturnContext.getScope().isInvoked())
                            return;

                    }
                } finally {
                    MemoryContext.endScope(); // release each iteration memory

                    
                    postIncrement();
                }

            }
        } finally {
            MemoryContext.endScope(); // release loop memory
        }
    }
} 2.1 For loop Let’s begin with the first For loop implementation. By our language design, it will contain the variable expression, the lower bound, the upper bound, and the step expression: package org.example.toylanguage.statement.loop;

@RequiredArgsConstructor
public class ForLoopStatement extends AbstractLoopStatement {
    private final VariableExpression variable;
    private final Expression lowerBound;
    private final Expression uppedBound;
    private final Expression step;
} Next, we implement the abstract methods. Within the first method, we assign the lower bound to the variable by evaluating an instance of AssignmentOperator, which accepts the expression as a first operand and the expression as a second operand: init() variable lowerBound ...
public class ForLoopStatement extends AbstractLoopStatement {
	...

	@Override
	protected void init() {
		new AssignmentOperator(variable, lowerBound)
				.evaluate();
	}
} Next, we override the . It should return a boolean value if we remaining have items. To make a compare operation, we create an instance of the LessThenOperator by passing the expression as a first operand, and the as a second operand. As a result, we expect to get the LogicalValue with boolean value inside it: hasNext() variable upperBound ...
public class ForLoopStatement extends AbstractLoopStatement {
    ...

	@Override
	protected boolean hasNext() {
		LessThanOperator hasNext = new LessThanOperator(variable, uppedBound);
		Value<?> value = hasNext.evaluate();
		return value instanceof LogicalValue && ((LogicalValue) value).getValue();
	}
} Lastly, to perform the increment operations for each iteration, we need to implement the and methods. The For loop should use the step increment only at the end of each iteration. Therefore, we perform the increment only within the method. To implement the increment operation, we create an instance of the AdditionOperator, which will sum up the value with the value, and assign the result to the expression again using an instance of the AssignmentOperator. If the step expression hasn’t been provided, we accumulate the NumericValue instance with the default value equal to : preIncrement() postIncrement() postIncrement() variable step variable 1.0 ...
public class ForLoopStatement extends AbstractLoopStatement {
	...

	@Override
	protected void preIncrement() {
	}

	@Override
	protected void postIncrement() {
		AdditionOperator stepOperator = new AdditionOperator(variable, Objects.requireNonNullElseGet(step, () -> new NumericValue(1.0)));
		new AssignmentOperator(variable, stepOperator)
				.evaluate();
	}
} 2.2 While loop The next loop implementation is the While loop. It’s more straightforward than the For loop, as we don’t need to perform addition and assignment operations at all. This operator will contain only the expression, which will only serve to calculate the result. The other overridden methods will be empty: hasNext hasNext() package org.example.toylanguage.statement.loop;

@RequiredArgsConstructor
public class WhileLoopStatement extends AbstractLoopStatement {
    private final Expression hasNext;

    @Override
    protected void init() {
    }

    @Override
    protected boolean hasNext() {
        Value<?> value = hasNext.evaluate();
        return value instanceof LogicalValue && ((LogicalValue) value).getValue();
    }

    @Override
    protected void preIncrement() {
    }

    @Override
    protected void postIncrement() {
    }
} 2.3 Iterable loop The last loop implementation is the Iterable loop. It will allow us to perform the for-each iterations with arrays and structures. First, we define the new Value implementation, which will override the interface and, accordingly, will provide us with the implementation: java.util.Iterable java.util.Iterator package org.example.toylanguage.expression.value;

public abstract class IterableValue<T> extends Value<T> implements Iterable<Value<?>> {
    public IterableValue(T value) {
        super(value);
    }
} Next, we extend the ArrayValue by implementing IterableValue and passing array values to the Iterator instance: package org.example.toylanguage.expression.value;

public class ArrayValue extends IterableValue<List<Value<?>>> {
    ...

    @Override
    public Iterator<Value<?>> iterator() {
        return getValue().iterator();
    }
} And we do the same extension for StructureValue as well. For now, we will iterate only the structure’s values. Later, we can introduce the dictionary data type to operate with key-value types: package org.example.toylanguage.expression.value;

public class StructureValue extends IterableValue<Map<String, Value<?>>> {
    ...

    @Override
    public Iterator<Value<?>> iterator() {
        return getValue().values().iterator();
    }
} Now we have the two IterableValue implementations which can provide us with the Iterator instance, we can complete the Iterable loop with the corresponding implementation. It will contain the expression and the expression. Also, we declare an auxiliary non-final field that will be used to iterate the loop: variable iterable Iterator<Value<?> package org.example.toylanguage.expression.value;

@RequiredArgsConstructor
public class IterableLoopStatement extends AbstractLoopStatement {
    private final VariableExpression variable;
    private final Expression iterableExpression;

    private Iterator<Value<?>> iterator;
} Next, we override and resolve the abstract methods. Inside the method, we initialize the field using the IterableValue’s method: init() iterator iterator() ...
public class IterableLoopStatement extends AbstractLoopStatement {
    ...

	@Override
	protected void init() {
		Value<?> value = iterableExpression.evaluate();
		if (!(value instanceof IterableValue))
			throw new ExecutionException(String.format("Unable to loop non IterableValue `%s`", value));
		this.iterator = ((IterableValue<?>) value).iterator();
	}
} The method will utilize the implementation. Lastly, we should perform the prefix increment operation to know the value that is currently being iterated. Within , we create an instance of the AssignmentOperator, which will accept the as a first operand, and the value received from the iterator as a second operand: hasNext() Iterator#hasNext() preIncrement() variable ...
public class IterableLoopStatement extends AbstractLoopStatement {
    ...

	@Override
	protected boolean hasNext() {
		return iterator.hasNext();
	}

	@Override
	protected void preIncrement() {
		Value<?> next = iterator.next();
		new AssignmentOperator(variable, next)
				.evaluate();
	}

	@Override
	protected void postIncrement() {
	}

} 2.4 StatementParser To make the loop statements work, we need to map the loop lexemes to the defined statements using the StatementParser class. All the loops defined by the language grammar start with the keyword. Therefore, inside the parseExpression() method, we add a new case for the corresponding Keyword lexeme: loop loop package org.example.toylanguage;

public class StatementParser {
	...

	private Statement parseExpression() {
		Token token = tokens.next(TokenType.Keyword, TokenType.Variable, TokenType.Operator);
		switch (token.getType()) {
			case Variable:
			case Operator:
                ...
			case Keyword:
				switch (token.getValue()) {
					case "print":
                        ...
					case "input":
                        ...
					case "if":
                        ...
					case "struct":
                        ...
					case "fun":
                        ...
					case "return":
                        ...
					case "loop":
                        ...
				}
			default:
                ...
		}
	}
} After the Keyword, we read the next expression using the Dijkstra Two-Stack algorithm defined within the ExpressionReader class. If we read the For or the Iterable loop, we expect this expression to be only a variable. If we read the While loop, this expression will act as a loop condition, which can be an instance of any Expression implementation, including operator or function invocation. Therefore, we split the execution. In case the expression is the VariableExpression instance and the next lexeme is the Keyword, we continue to read the For and Iterable loop. In the negative case, we build the WhileLoopStatement using the condition expression: loop in case "loop": {
    Expression loopExpression = new ExpressionReader().readExpression();

    AbstractLoopStatement loopStatement;
    if (loopExpression instanceof VariableExpression && tokens.peek(TokenType.Keyword, "in")) {
        // loop <variable> in <bounds>
    } else {
        // loop <condition>
        loopStatement = new WhileLoopStatement(loopExpression);
    } Inside the For and Iterable loop clause, we skip the next Keyword lexeme, and then read the following bounds expression. This expression can be an instance of any Expression implementation which can be evaluated to the lower bound value or IterableValue only when the code will be executed. To define which loop type it is, we can rely on the next lexeme. In the case of the For loop, after the lower bound expression, we expect to read the two-dot GroupDivider as a spliterator for lower and upper bounds. In the negative condition, we build the IterableLoopStatement: in if (loopExpression instanceof VariableExpression && tokens.peek(TokenType.Keyword, "in")) {

    // loop <variable> in <bounds>
    VariableExpression variable = (VariableExpression) loopExpression;
    tokens.next(TokenType.Keyword, "in");
    Expression bounds = new ExpressionReader().readExpression();

    if (tokens.peek(TokenType.GroupDivider, "..")) {
        // loop <variable> in <lower_bound>..<upper_bound>
    } else {
        // loop <variable> in <iterable>
        loopStatement = new IterableLoopStatement(variable, bounds);
    }
} To build the last For loop statement, we skip the two-dot GroupDivider and read the upper bound expression. In our language grammar, for the For loop, we can define the step expression with the keyword. Therefore, if the next expression is the lexeme, we read the following step expression. At the end, we build an instance of the ForLoopStatement: by by if (tokens.peek(TokenType.GroupDivider, "..")) {
    // loop <variable> in <lower_bound>..<upper_bound>
    tokens.next(TokenType.GroupDivider, "..");
    Expression upperBound = new ExpressionReader().readExpression();

    Expression step = null;
    if (tokens.peek(TokenType.Keyword, "by")) {
        // loop <variable> in <lower_bound>..<upper_bound> by <step>
        tokens.next(TokenType.Keyword, "by");
        step = new ExpressionReader().readExpression();
    }

    loopStatement = new ForLoopStatement(variable, bounds, upperBound, step);
} We have read every loop type declaration. Finally, we can read the body of the loop. To gather all internal statements, we invoke the recursive method, which will return an instance of the Statement interface. We should stop the process when we reach the finalizing lexeme: StatementParser#parseExpression() end while (!tokens.peek(TokenType.Keyword, "end")) {
    Statement statement = parseExpression();
    loopStatement.addStatement(statement);
} At the end, we skip this keyword and return the loopStatement. The complete clause: end loop case "loop": {
    Expression loopExpression = new ExpressionReader().readExpression();
    AbstractLoopStatement loopStatement;

    if (loopExpression instanceof VariableExpression && tokens.peek(TokenType.Keyword, "in")) {
        // loop <variable> in <bounds>
        VariableExpression variable = (VariableExpression) loopExpression;
        tokens.next(TokenType.Keyword, "in");
        Expression bounds = new ExpressionReader().readExpression();

        if (tokens.peek(TokenType.GroupDivider, "..")) {
            // loop <variable> in <lower_bound>..<upper_bound>
            tokens.next(TokenType.GroupDivider, "..");
            Expression upperBound = new ExpressionReader().readExpression();

            Expression step = null;
            if (tokens.peek(TokenType.Keyword, "by")) {
                // loop <variable> in <lower_bound>..<upper_bound> by <step>
                tokens.next(TokenType.Keyword, "by");
                step = new ExpressionReader().readExpression();
            }

            loopStatement = new ForLoopStatement(variable, bounds, upperBound, step);

        } else {
            // loop <variable> in <iterable>
            loopStatement = new IterableLoopStatement(variable, bounds);
        }

    } else {
        // loop <condition>
        loopStatement = new WhileLoopStatement(loopExpression);
    }

    while (!tokens.peek(TokenType.Keyword, "end")) {
        Statement statement = parseExpression();
        loopStatement.addStatement(statement);
    }

    tokens.next(TokenType.Keyword, "end");

    return loopStatement;
} 3 Tests We have finished embedding loops in both lexical and syntax analyzers. Now we should be able to perform For, While and Iterable loops. Let’s create and test a more real task - the bubble sort algorithm: fun bubble_sort [ arr, n ]
    loop i in 0..n - 1
        loop j in 0..n - i - 1
            if arr{j+1} < arr{j} then
                temp = arr{j}
                arr{j} = arr{j + 1}
                arr{j + 1} = temp
            end
       end
    end
end

fun is_sorted [ arr, n ]
    loop i in 0..n - 1
        if arr{i} > arr{i+1} then
            return false
        end
    end
    return true
end

arr = {}
arr_len = 20
loop i in 0..arr_len by 1
    arr << i * 117 % 17 - 1
end

print arr # [-1, 14, 12, 10, 8, 6, 4, 2, 0, 15, 13, 11, 9, 7, 5, 3, 1, -1, 14, 12]
print is_sorted [ arr, arr_len ] # false

bubble_sort [ arr, arr_len ]
print arr # [-1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 12, 13, 14, 14, 15]
print is_sorted [ arr, arr_len ] # true

Building Your Own Programming Language From Scratch: Part VI - Loops

Feedback Loop Optimization:
From Customer Insights to Product Development

The article demonstrates the advantages of loop unrolling by iterating over multiple items per cycle while adjusting the loop counter accordingly. Learning Objectives The problem with iterating using traditional loops
Advantages with loop unrolling Prerequisites for Developers Basic understanding of C# programming language.


Familiar with for loops Getting Started The problem with iterating using traditional loops Most developers will iterate over array elements and perform a mathematical operation as shown in the following code snippet. for (int i = 0; i < array.Length; i++)
    {
        array[i] = i * 2;
    } Although the above code snippet is quite clean and straightforward, it incurs a cost due to the loop control structure. Advantages with loop unrolling Please find below the refactored version of the previous code snippet int len = array.Length;
    for (int i = 0; i < len; i += 4)
    {
        array[i] = i * 2;
        if (i + 1 < len) array[i + 1] = (i + 1) * 2;
        if (i + 2 < len) array[i + 2] = (i + 2) * 2;
        if (i + 3 < len) array[i + 3] = (i + 3) * 2;
    } With refactored code, now we have reduced the loop frequency to 4 which leads to faster execution. In addition to that, it will: Reduce loop overheads which in turn decreases any conditional checks inside the loops.
Increase performance as it enhances the execution speed Complete Code Create another class named LoopUnrolling and add the following code snippet public static class LoopUnrolling
    {
        public static void BadWay() {
            const int size = 1024;
            int[] numbers = new int[size];
    
            // Traditional loop
            var watch = System.Diagnostics.Stopwatch.StartNew();
            for (int i = 0; i < numbers.Length; i++)
            {
                numbers[i] = i * 2;
            }
            watch.Stop();
            Console.WriteLine($"Traditional loop time: {watch.ElapsedTicks} ticks");
    
        }
        public static void GoodWay()
        {
            const int size = 1024;
            int[] numbers = new int[size];
            int len = numbers.Length;
            var watch = System.Diagnostics.Stopwatch.StartNew();
            for (int i = 0; i < len; i += 4)
            {
                numbers[i] = i * 2;
                if (i + 1 < len) numbers[i + 1] = (i + 1) * 2;
                if (i + 2 < len) numbers[i + 2] = (i + 2) * 2;
                if (i + 3 < len) numbers[i + 3] = (i + 3) * 2;
            }
            watch.Stop();
            Console.WriteLine($"Unrolled loop time: {watch.ElapsedTicks} ticks");
        }
    } Execute from the main method as follows #region Day 26: Loop Unrolling
    static string ExecuteDay26()
    {
        LoopUnrolling.BadWay();
        LoopUnrolling.GoodWay();
    
        return "Executed Day 26 successfully..!!";
    }
    
    #endregion Console Output Traditional loop time: 20 ticks
    Unrolled loop time: 12 ticks As the output demonstrates loop unrolling took much less time than the traditional loop approach. Complete Code here: GitHub — ssukhpinder/30DayChallenge.Net Thank you for being a part of the C# community! Before you leave: Follow us: Youtube | X | LinkedIn | Dev.to
Visit our other platforms: GitHub
More content at C# Programming The article demonstrates the advantages of loop unrolling by iterating over multiple items per cycle while adjusting the loop counter accordingly. Learning Objectives The problem with iterating using traditional loops Advantages with loop unrolling The problem with iterating using traditional loops Advantages with loop unrolling Prerequisites for Developers Basic understanding of C# programming language. Familiar with for loops Basic understanding of C# programming language. Basic understanding of C# programming language. Familiar with for loops Familiar with for loops Getting Started The problem with iterating using traditional loops Most developers will iterate over array elements and perform a mathematical operation as shown in the following code snippet. for (int i = 0; i < array.Length; i++)
    {
        array[i] = i * 2;
    } for (int i = 0; i < array.Length; i++)
    {
        array[i] = i * 2;
    } Although the above code snippet is quite clean and straightforward, it incurs a cost due to the loop control structure. Advantages with loop unrolling Please find below the refactored version of the previous code snippet int len = array.Length;
    for (int i = 0; i < len; i += 4)
    {
        array[i] = i * 2;
        if (i + 1 < len) array[i + 1] = (i + 1) * 2;
        if (i + 2 < len) array[i + 2] = (i + 2) * 2;
        if (i + 3 < len) array[i + 3] = (i + 3) * 2;
    } int len = array.Length;
    for (int i = 0; i < len; i += 4)
    {
        array[i] = i * 2;
        if (i + 1 < len) array[i + 1] = (i + 1) * 2;
        if (i + 2 < len) array[i + 2] = (i + 2) * 2;
        if (i + 3 < len) array[i + 3] = (i + 3) * 2;
    } With refactored code, now we have reduced the loop frequency to 4 which leads to faster execution. In addition to that, it will: Reduce loop overheads which in turn decreases any conditional checks inside the loops. Increase performance as it enhances the execution speed Reduce loop overheads which in turn decreases any conditional checks inside the loops. Increase performance as it enhances the execution speed Complete Code Create another class named LoopUnrolling and add the following code snippet public static class LoopUnrolling
    {
        public static void BadWay() {
            const int size = 1024;
            int[] numbers = new int[size];
    
            // Traditional loop
            var watch = System.Diagnostics.Stopwatch.StartNew();
            for (int i = 0; i < numbers.Length; i++)
            {
                numbers[i] = i * 2;
            }
            watch.Stop();
            Console.WriteLine($"Traditional loop time: {watch.ElapsedTicks} ticks");
    
        }
        public static void GoodWay()
        {
            const int size = 1024;
            int[] numbers = new int[size];
            int len = numbers.Length;
            var watch = System.Diagnostics.Stopwatch.StartNew();
            for (int i = 0; i < len; i += 4)
            {
                numbers[i] = i * 2;
                if (i + 1 < len) numbers[i + 1] = (i + 1) * 2;
                if (i + 2 < len) numbers[i + 2] = (i + 2) * 2;
                if (i + 3 < len) numbers[i + 3] = (i + 3) * 2;
            }
            watch.Stop();
            Console.WriteLine($"Unrolled loop time: {watch.ElapsedTicks} ticks");
        }
    } public static class LoopUnrolling
    {
        public static void BadWay() {
            const int size = 1024;
            int[] numbers = new int[size];
    
            // Traditional loop
            var watch = System.Diagnostics.Stopwatch.StartNew();
            for (int i = 0; i < numbers.Length; i++)
            {
                numbers[i] = i * 2;
            }
            watch.Stop();
            Console.WriteLine($"Traditional loop time: {watch.ElapsedTicks} ticks");
    
        }
        public static void GoodWay()
        {
            const int size = 1024;
            int[] numbers = new int[size];
            int len = numbers.Length;
            var watch = System.Diagnostics.Stopwatch.StartNew();
            for (int i = 0; i < len; i += 4)
            {
                numbers[i] = i * 2;
                if (i + 1 < len) numbers[i + 1] = (i + 1) * 2;
                if (i + 2 < len) numbers[i + 2] = (i + 2) * 2;
                if (i + 3 < len) numbers[i + 3] = (i + 3) * 2;
            }
            watch.Stop();
            Console.WriteLine($"Unrolled loop time: {watch.ElapsedTicks} ticks");
        }
    } Execute from the main method as follows #region Day 26: Loop Unrolling
    static string ExecuteDay26()
    {
        LoopUnrolling.BadWay();
        LoopUnrolling.GoodWay();
    
        return "Executed Day 26 successfully..!!";
    }
    
    #endregion #region Day 26: Loop Unrolling
    static string ExecuteDay26()
    {
        LoopUnrolling.BadWay();
        LoopUnrolling.GoodWay();
    
        return "Executed Day 26 successfully..!!";
    }
    
    #endregion Console Output Traditional loop time: 20 ticks
    Unrolled loop time: 12 ticks Traditional loop time: 20 ticks
    Unrolled loop time: 12 ticks As the output demonstrates loop unrolling took much less time than the traditional loop approach. Complete Code here: GitHub — ssukhpinder/30DayChallenge.Net Complete Code here: GitHub — ssukhpinder/30DayChallenge.Net GitHub — ssukhpinder/30DayChallenge.Net Thank you for being a part of the C# community! Before you leave: Follow us: Youtube | X | LinkedIn | Dev.to Visit our other platforms: GitHub More content at C# Programming Youtube X LinkedIn Dev.to GitHub C# Programming

30-Day .NET Challenge - Day 26: Loop Unrolling

Introduction Welcome to this module, Day 4 of 30-Day .NET Challenge: For Loops, where let's dive into the world of for statements. Explore how to write For Loop statements that iterate a set number of times. Learning Objectives Utilize the for statement to iterate through a set of code. Prerequisites for Developers Proficiency with the for each iteration statement. Familiarity with working with variables. Getting Started What is the for statement? The for statement allows you to iterate through a code block a fixed number of times, providing precise control over the iteration process. Basic For Loop Example To begin, create a static class file called “ForLoop.cs” within the console application. Insert the provided code snippet into this file. /// <summary>
/// Outputs
/// 0
/// 1
/// 2
/// 3
/// 4
/// 5
/// 6
/// 7
/// 8
/// 9
/// </summary>
public static void ForLoopExample()
{
    for (int i = 0; i < 10; i++)
    {
        Console.WriteLine(i);
    }
} Execute the code from the main method as follows #region Day 4 - For Loops

ForLoops.ForLoopExample();

#endregion Console Output // Console Output
0
1
2
3
4
5
6
7
8
9 Run For Loop in reverse. The goal is to iterate through a code block while counting down instead of counting up. Add another method into the same static class as shown below /// <summary>
/// Outputs
/// 10
/// 9
/// 8
/// 7
/// 6
/// 5
/// 4
/// 3
/// 2
/// 1
/// 0
/// </summary>
public static void BackwardForLoopExample()
{
    for (int i = 10; i >= 0; i--)
    {
        Console.WriteLine(i);
    }
} Execute the code from the main method as follows #region Day 4 - For Loops

ForLoops.BackwardForLoopExample();

#endregion Console Output // Console Output
10
9
8
7
6
5
4
3
2
1
0 Iterative Pattern With For The goal is to skip specific values in the iterator variable. Add another method into the same static class as shown below /// <summary>
/// Outputs
/// 3
/// 6
/// 0
/// 9
/// </summary>
public static void IterationForLoopExample()
{
    for (int i = 0; i < 10; i += 3)
    {
        Console.WriteLine(i);
    }
} Execute the code from the main method as follows #region Day 4 - For Loops

ForLoops.IterationForLoopExample();

#endregion Console Output // Console Output
0
3
6
9 Break Loop The goal is to exit the iteration statement prematurely based on some conditions. Add another method into the same static class as shown below /// <summary>
    /// Outputs
    /// 0
    /// 1
    /// 2
    /// 3
    /// 4
    /// 5
    /// 6
    /// 7
    /// </summary>
    public static void BreakForLoopExample()
    {
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine(i);
            if (i == 7) break;
        }
    } Execute the code from the main method as follows #region Day 4 - For Loops
    
    ForLoops.BreakForLoopExample();
    
    #endregion Console Output // Console Output
    0
    1
    2
    3
    4
    5
    6
    7 Complete Code on GitHub GitHub — ssukhpinder/30DayChallenge.Net C# Programming🚀 Thank you for being a part of the C# community! Before you leave: If you’ve made it this far, please show your appreciation with a clap and follow the author! 👏️️ Follow us: | | | | | X LinkedIn Dev.to Hashnode Newsletter Tumblr Visit our other platforms: | | | | GitHub Instagram Tiktok Quora Daily.dev More content at C# Programming Also published . here

The 30-Day .NET Challenge Day 4: For Loops

Let’s talk about mastering foreach loops in C# and boosting your programming efficiency! Foreach loops are an important concept in C# programming — and many other languages for that matter. When it comes to iterating through collections and arrays, they’re especially useful. By the end of this article, you can expect to have a solid understanding of the basic syntax of foreach loops, common mistakes to avoid, advanced techniques to try, and best practices for using them effectively in your own projects. Whether you’re a beginner or an experienced software engineer, this article will provide valuable insights into how to use foreach loops to streamline your code and improve your programming skills. The Importance of foreach Loops in C# Foreach loops are essential for software engineers and developers who work with collections and arrays in C#. They allow for the iteration of these data structures with a simple and concise syntax that makes working with them easier and more efficient. One of the key benefits of using foreach loops is that they have less complexity than traditional for loops. Say goodbye to range checking and indexing! For loops require the use of an index variable, which often requires additional declarations and assignments. On the other hand, foreach loops manage the index variable and iterating logic behind the scenes, reducing the amount of code needed to loop through a collection or array. This simplicity leads to cleaner code that is easier to read and maintain. Another benefit of using foreach loops is easier debugging. Since the iterating logic is abstracted away, coding errors that occur in the iteration process are easier to diagnose. This is particularly relevant when using for loops where the potential exists for an off-by-one error that can be difficult to identify and resolve. Basic Syntax of foreach Loops in C# The basic syntax of a foreach loop in C# is as follows: dataType[] collectionName = new dataType[10];

foreach (dataType variableName in collectionName)
{
   //Execute code for each item in collectionName using variableName as you go.
} The dataType is the type of the items in the collection, variableName is the name assigned to the current item in the collection as it is being iterated, and collectionName is the name of the collection being iterated over. The ‘in’ keyword is what tells C# that the loop is a foreach loop, and the logic inside the curly braces is executed for each item in the collection. Foreach loops can also be used in conjunction with the IEnumerable interface, which provides a way to access the values in a collection one at a time. The use of and foreach loops can reduce memory usage and increase performance by allowing developers to obtain values from the collection only when required — . the IEnumerable interface but it’s not always that black-and-white This approach is commonly used when dealing with large datasets that would be impractical to process all at once. Common Mistakes in Using foreach Loops When using foreach loops, there are several common mistakes that developers may encounter if they are not careful. It is important to take care to avoid these mistakes as they can lead to difficult-to-resolve bugs, crashes, and runtime errors. Some of the most common mistakes are discussed below with tips on how to avoid and resolve them. Modification During Iteration One mistake is attempting to modify the during the loop. Modified collections can cause unintended behavior, such as an infinite loop or skipping over certain items. To avoid this mistake, it is important to create a copy of the collection to work with if modification is necessary, thereby removing the potential for direct modification of the original collection during the iteration process. collection being iterated Null References Another common mistake is not checking for null references before attempting to iterate. This mistake can lead to null reference exceptions, which can cause the program to crash and can be difficult to catch and resolve. Checking for null references before starting the iteration process is an effective way to avert this mistake. Concurrent Modifications Concurrent modification problems can also be frustrating, causing unpredictable program behavior and hard-to-reproduce defects. This can occur if multiple threads access and modify the same collection. Developers can avoid concurrent modification issues by using a synchronized collection class or using locks to ensure that only one thread can modify the collection at a time. Using And Statements in foreach Loops break continue A break statement will immediately terminate the loop when executed, regardless of whether the or not. Alternatively, a continue statement will immediately move on to the next iteration of the loop, skipping over the remaining lines of code in the current iteration. These statements can be used to simplify error-checking and improve code readability. collection has finished iterating For example, a break statement can be useful when searching for a specific item in a collection, and the loop can be stopped as soon as the item is found. When used properly, break and continue statements can reduce the complexity of code, increase its performance, and make it easier to follow and understand. Check out this code for an example of the break keyword. Item? foundItem = null;
foreach (var item in collection)
{
    if (item.Name == "Dev Leader")
    {
        foundItem = item;
        break;
    }
} Advanced Techniques With foreach Loops As you become more comfortable with using foreach loops in C#, they may want to explore some of the advanced techniques available to them. Advanced techniques with foreach loops can help to further optimize code and improve performance. This section will explore several techniques at a high level, including LINQ queries and lambdas, enumeration and filtering, and parallelization. Each of these are topics deserving of their own full article. LINQ & Lambdas Within Loops One advanced technique is using LINQ queries and lambdas with foreach loops. LINQ allows developers to write more concise and expressive code. Queries can be written using LINQ syntax, and lambdas can be used for filtering, sorting, and manipulating data directly within the loop, reducing the need for subsequent loops. Let’s see an example: public sealed record Item(
    int Id,
    string Name,
    DateTime CreatedDateTimeUtc);

// Use .Select() from LINQ to change what we're operating on
foreach (var item in collection.Select(x => new { Id = x.Id, Name = x.Name }))
{
    if (item.Name == "Dev Leader")
    {
        // we're only interested in the ID, so return it!
        return item.Id;
    }
} Filtering Another technique is enumeration and filtering, which can help to reduce the memory footprint of large datasets. This technique allows for generating only the subset of data that is relevant to the current operation and that meets a specific criteria. This can be of great benefit when dealing with large datasets because it avoids the need to process the entire dataset at once, which can be time-consuming and can result in performance issues. Let’s look at a code example: public sealed record Item(
    int Id,
    string Name,
    DateTime CreatedDateTimeUtc);

// Put the filtering right in the foreach line by using .Where() from LINQ
foreach (var item in collection.Where(x => x.Name == "Dev Leader"))
{
    // we're only interested in the ID, so return it!
    return item.Id;
} Parallelization Parallelization is another advanced technique that can be utilized with foreach loops. Parallelizing a foreach loop can be a way to take advantage of multi-core processors and can improve performance. Parallelization can be achieved through the use of the parallel LINQ operator, PLINQ, which can divide the iteration process into smaller pieces and execute them on separate threads. We can also use things like , , and even splitting work out into dedicated tasks and waiting on results using . You might be when looking into these options! Parallel.Foreach Parallel.ForeachAsync Task.WhenAll() interested in checking out this video for some performance differences https://www.youtube.com/watch?v=GE-phyI6lEM&embedable=true Using LINQ With foreach Loops LINQ, or Language Integrated Query, is a powerful to interact with various data sources in a more expressive and efficient way. The ability to use LINQ queries in conjunction with foreach loops can simplify code and reduce complexity, making code more readable and maintainable. language feature in C# that allows developers To use LINQ with foreach loops, the query is performed outside of the loop and saved to a variable. The query variable is then iterated over using the foreach loop. Common LINQ queries include , which sorts the data in ascending or descending order, and , which returns a subset of items that meet a specific criteria. Writing custom LINQ queries can be done by using lambda expressions, thereby allowing developers to manipulate the data in meaningful ways. OrderBy Where() Best Practices for Using foreach Loops in C# When working with foreach loops in C#, there are several best practices to keep in mind. By following these practices, developers can ensure that their code is efficient and maintainable, free of errors, and conforms to industry standards. Some of the most important best practices are discussed below. Choosing the Appropriate Data Type Choosing the appropriate data type to iterate through is an important best practice for working with foreach loops. Certain such as lists and arrays, are more suited for foreach loops, while others, such as hash tables, may not be as efficient. It is important to consider both the data structure and the type of data being stored when selecting the appropriate data type to iterate through. data types, In more recent versions of dotnet (at the time of writing!), there have been some incredible performance gains for arrays and lists. Historically, a foreach loop may not have been as performant compared to a for loop with an indexer. However, the dotnet team has worked some magic! I highly recommend you : check out this video for some performance details https://www.youtube.com/watch?v=G2-d7kZFlRA&embedable=true Using Read-Only Collections Wherever Possible Using read-only collections wherever possible is another important best practice when working with foreach loops. Read-only collections can help prevent modification of the data structure during the iteration process, thereby reducing the risk of errors. If modification is required, it is better to make a copy of the collection and work with the copy instead of modifying the original. Fighting off issues where a collection has been modified during enumeration is a total pain in the butt. Keeping the Code Simple Keeping the code simple and avoiding unnecessary complexity is another best practice that can save time and reduce errors. Code should be kept clean and readable, with a clear and logical structure that is easy to follow. This can be achieved by using descriptive variable names, and by grouping code into functions and classes. I’ve seen that we as programmers have a tendency to lean into some of the LINQ options that we have. The result is sometimes that we have these complicated chained LINQ queries that do some awesome stuff but… they’re difficult to read. Just keep this in mind when trying to filter and manipulate data. Avoiding Premature Optimizations Avoiding premature optimizations is another important aspect of working with foreach loops. Developers should avoid optimizing code before they have a clear understanding of what needs to be optimized. Optimizing code too early can lead to a lack of clarity and can cause regression bugs. Remember the points about parallelism earlier in the article? If you’re just getting started… don’t waste your time on that stuff yet. Get the basics down. Get a solid foundation before going to the more advanced aspects. Using Concise and Descriptive Variable Names Using concise and descriptive variable names is another important best practice when working with foreach loops. Variable names should be short and descriptive and should reflect the purpose of the variable. This can help to improve code readability and make the code easier to understand. Is this tip specific for foreach loops? Absolutely not. But it’s so important in programming that I’ll continue to find ways to sneak it in to remind people about the importance of readable code. Proper Error-Checking and Exception Handling Proper error-checking and exception handling are crucial best practices when working with foreach loops. Error-checking should be included throughout the code, particularly when working with collections and arrays. Any exceptions that are thrown during the iteration process should be handled correctly using try-catch statements. This can help to prevent program crashes and improve code maintainability. Wrapping Up foreach Loops in C# Understanding foreach loops in C# is a fundamental skill for developers. By using foreach loops, you can save time, write cleaner and more concise code, and avoid common pitfalls associated with traditional for loops. Throughout this article, I covered the basic syntax of foreach loops in C#, common mistakes to avoid, advanced techniques such as LINQ queries and lambdas, and best practices for using foreach loops. Remember to always choose the appropriate to iterate through, use read-only collections whenever possible, and keep your code simple and concise. With you can become better at writing one of the most used tools in C#. data type practice and application, I hope that you found something useful in this article! If you’re interested in more learning opportunities, and ! subscribe to my free weekly newsletter check out my YouTube channel Also published here

foreach Loops in C# – A Beginner's Guide

foreach Loops in C# - একটি বিগিনারস গাইড

foreach-Schleifen in C# – Ein Leitfaden für Anfänger

Bucles foreach en C#: una guía para principiantes

Boucles foreach en C# – Guide du débutant

सी# में फ़ोरैच लूप्स - एक शुरुआती मार्गदर्शिका

C# の foreach ループ – 初心者ガイド

C#의 foreach 루프 – 초보자 가이드

Loops foreach em C# – Guia para iniciantes

Циклы foreach в C# — руководство для начинающих

C#'ta foreach Döngüleri – Yeni Başlayanlar İçin Kılavuz

Vòng lặp foreach trong C# – Hướng dẫn cho người mới bắt đầu

C# 中的 foreach 循环 – 初学者指南

Ah, the SEO industry, a realm that promises untold digital success and riches, but often leaves me feeling like I'm stuck in a never-ending cycle of déjà vu. It's time for a little rant, a bit of a grumble about how the in an infinite loop, regurgitating the same old information over and over again. SEO industry seems to be trapped Don't get me wrong, I understand the importance of staying up to date in the digital world, but it's high time we broke free from the chains of repetition and started offering something new and exciting. The Age-Old SEO "Best Practices" If you've been in the SEO game for any length of time, you'll know the drill. Articles, blog posts, and webinars all promising the "ultimate" SEO strategies are everywhere. But once you click, you're often greeted with the same regurgitated advice we've heard a thousand times before: optimize your meta tags, focus on quality content, and build high-quality backlinks. It's as if the SEO industry has a "best practices" handbook, and every piece of content is merely a rehash of the same old tips and tricks. In an ever-evolving digital landscape, where is the innovation? Where is the fresh perspective that could potentially revolutionize our SEO strategies? Clickbait Titles and Empty Promises. Let's not forget the endless stream of clickbait titles that flood SEO blogs and YouTube channels. "Secret SEO Hacks to Rank #1 in Minutes!" or "The ONE Trick Google Doesn't Want You to Know." It's like an echo chamber of empty promises, and it's getting old. In reality, SEO is not about tricks or secrets that lead to instant success. It's about hard work, quality content, and adapting to Google's ever-changing algorithms. So, why are we still seeing these shallow, misleading headlines that only contribute to the perpetuation of falsehoods? Algorithm Updates and Speculation Speaking of Google's ever-changing algorithms, we can't ignore the endless speculation and predictions about these updates. Every time Google sneezes, the SEO industry seems to catch a cold of speculation. Articles pop up like wildfire, prophesizing the doom of some websites while elevating others to the digital heavens. The problem is, much of this information is pure speculation or conjecture based on limited data. Google's algorithms are complex and closely guarded secrets. SEO professionals are not mind-readers, and yet, many claim to know precisely how these updates will impact rankings. It's frustrating, misleading, and, frankly, a waste of time. The Elusive "Content Is King" Mantra Oh, the famous "Content is King" mantra. It's been regurgitated so often that it's become a tiresome cliché in the SEO world. While it is true that high-quality content is essential, it's time to recognize that there's more to SEO than just churning out blog posts and articles. There are countless other aspects of SEO that deserve attention. What about technical SEO, user experience, and the impact of mobile optimization? Rehashing the same old "content is king" phrase simply doesn't cut it anymore. Let's stop dwelling on the past and embrace a future where the industry evolves and adapts to the ever-changing digital landscape. SEO has the potential to be an exciting and dynamic field – let's make that potential a reality. My Frustration of Lackluster SEO Results SEO providers, oh how you make grand promises of digital success, but more often than not, the results fall far short of expectations. It's time to vent my frustration and call out the all-too-common issue of underwhelming performance from SEO service providers. The plethora of businesses that have entrusted their online visibility to SEO professionals, only to be left disappointed, deserve better. Overpromising, Underdelivering One of the most infuriating aspects of SEO providers is their tendency to overpromise and underdeliver. It's a tale as old as time - they guarantee your website will be at the top of Google's search results, promising floods of traffic and conversions. Yet, when you eagerly check your analytics, you're met with a reality that is far less rosy. The problem isn't necessarily that they can't deliver results; it's that they set unrealistic expectations. SEO is a long-term strategy, and instant success is rare. It's time for service providers to be honest about what they can realistically achieve. Lack of Transparency Transparency should be a cornerstone of any professional relationship, but, unfortunately, it's often lacking in the SEO industry. Many providers leave clients in the dark about their strategies and progress. Clients are left to trust that their provider is doing the right thing without any clear understanding of what's being done and why. This lack of transparency creates a frustrating environment where clients feel disconnected from the SEO process. When results are poor, clients can't pinpoint the issue or take steps to rectify it because they don't have a clear picture of the strategy. Cookie-Cutter Solutions Another source of exasperation is the one-size-fits-all approach that many SEO providers employ. Every website is unique, with its own set of challenges and opportunities. Yet, so many SEO companies use generic templates and strategies that don't take individual circumstances into account. The result is that clients often end up with generic, mediocre results that could have been significantly improved with a more tailored approach. SEO should be as unique as the websites it's meant to optimize. Failure to Adapt to Changing Algorithms Search engine algorithms are in a constant state of flux. SEO providers should be nimble and ready to adapt to these changes, but all too often, they are stuck in outdated practices. They continue to use techniques that might have worked in the past but are now ineffective or even harmful. The failure to stay updated and leads to poor results and, in some cases, can even harm a website's ranking and reputation. adapt to algorithm shifts The SEO Gurus and Their Hollow Click Bait Promises SEO and digital marketing is brimming with big-name players like Neil Patel, who have amassed fame and followers for their apparent expertise. But the more I delve into the endless stream of SEO and digital marketing advice emails they send, the more I'm convinced that these so-called experts are leading us down a rabbit hole of frustration. Their marketing emails consistently landing in our inboxes promise the "secret sauce" to success, only to lead us to their websites with a bait-and-switch tactic that offers nothing but empty rhetoric and a sales pitch. Let's rant about the disillusionment that follows every click. The Illusive "Secret" Revealed We've all seen it before. An enticing email subject line arrives in our inbox, promising to unveil the industry's best-kept secrets: "Here's how I made millions with SEO, and you can too!" It's too tempting to resist. You open the email, expecting an enlightening revelation, only to be greeted with a sea of vague generalities and promises of untold riches. These big players claim to have discovered a secret formula, but instead, all they share is a vague outline that leaves you more puzzled than informed. It's a classic case of "all sizzle, no steak." The Disappointing Click Bait Following the trail of promises, you inevitably find yourself on their websites, ready to dive deep into the so-called "secrets" they're touting. But what do you actually find? A maze of clickbait articles, videos, and webinars that promise the world but deliver mere breadcrumbs of information. Instead of valuable insights and actionable tips, you're bombarded with more marketing spiels, each designed to push their expensive courses, consulting services, and software packages. It's as if the initial promise was just a carrot on a stick to lure you into their sales funnel. The Hollow Advice and Lack of Substance Let's talk about the content they offer. It's often shallow, filled with generalities, and devoid of any real value. Instead of concrete steps and techniques, you'll be met with surface-level fluff like "create high-quality content" or "build quality backlinks." Wow, thanks for the groundbreaking advice! It's disheartening to see these industry giants provide content that lacks substance, especially when they have the resources and knowledge to offer in-depth insights. It's as if they're intentionally holding back the good stuff, only to dangle it as a carrot for you to chase. The Never-Ending Sales Pitch The biggest letdown is the relentless sales pitch that follows. After teasing you with elusive secrets and underwhelming advice, they unleash an avalanche of offers for their paid services. Webinars that promise to reveal the real secrets, courses that claim to turn you into a digital marketing wizard, and consulting services that come with hefty price tags. It's frustrating to realize that these experts are more interested in your wallet than your success. They prioritize their bottom line over your growth, and it's disheartening to see that their emails and content are just elaborate funnels to sell their products and services. It's not my intention to disparage the entire SEO service provider industry. There are undoubtedly capable and ethical professionals out there who genuinely strive to provide excellent results for their clients. However, the frustration I've expressed here is rooted in the recurring issues faced by clients who put their trust in SEO service providers only to be disappointed. Clients deserve better. They deserve transparency, realistic expectations, and a personalized approach to their unique SEO needs. It's high time for the SEO industry to step up its game, improve the quality of service, and deliver results that match the promises. After all, a satisfied client is the ultimate testament to a job well done. In the end, my rant about the repetitive nature of the SEO industry isn't a condemnation of the entire field. There are undoubtedly talented SEO professionals who genuinely strive to innovate and offer valuable insights. As a whole, the industry often feels like a broken record, repeating the same tired advice and empty promises. It's time to break free from the shackles of repetition and start pushing the boundaries of SEO knowledge.

Loop

heyloop.ai

-- employees

Since n.d.

COMPANY RANKING

LOOP

EVERGREEN INDEX #6888

Loop WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

Loop

heyloop.ai

-- employees

Since n.d.

COMPANY RANKING

LOOP

EVERGREEN INDEX #6888

RELATED COMPANIESRANK

STORIES ABOUT LOOP

Loop WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!