Array is a financial innovation platform that helps digital brands, financial institutions, and fintechs get compelling consumer products to market faster

Array is a financial innovation platform that helps digital brands, financial institutions, and fintechs get compelling consumer products to market faster. Our suite of private label offerings helps our partners drive revenue, increase engagement, and empower millions of consumers to achieve their financial goals. Array was founded in 2020 by Martin Toha and Phillip Zedalis. Key investors include Battery Ventures, General Catalyst, and Nyca Partners. To learn more visit array.com.

Array

How to Compare the Same Contents but Different Ordered Arrays in JavaScript

Sorting is any process of arranging items systematically in a sequence ordered by some criterion so that you can analyze it more effectively. In this article, I want to describe a common method used to sort array elements in alphabetical and numerical order. In addition to general examples, I have provided a real-life use-case example to clarify the context of sorting array values. Introduction to Sort Array Elements Sorting is the process of arranging data into a meaningful order so that you can analyze it more effectively. For example, you might want to sort the data in a column to find the string "Alex" or you might want to order sales data by calendar month so that you can produce a graph of sales performance. Sorts are most commonly in numerical or a form of alphabetical (called lexicographical) order and can be in ascending (A-Z, 0-9) or descending (Z-A, 9-0) order. Why sorting data is important? Sorting is an important algorithm in Computer Science because it can often minimize the complexity of a task or simply facilitate the later search for members of the sorted set. These algorithms have direct applications in search algorithms, database algorithms, divide-and-conquer methods, data structure algorithms, and a variety of other areas. There are different sorting algorithms for different cases but they are not in the context of this article. Note: I think it's enough for the theory so let's dive into the practical part! Sorting Array Elements Alphabetically The very straightforward and easy way to sort array elements alphabetically is to use the Array.prototype.sort method. Ascending Sort The sort method sorts the elements of an array in place and returns the sorted array. The default sort order is ascending. The sort method needs an optional compareFunction(firstEl, secondEl) parameter that defines the sort order. If omitted, the array elements are converted to strings, then sorted according to each character's Unicode code point value. Let's look at the example below: names.sort(); const names = [ 'Williams' , 'James' , 'Alex' , 'Mason' , 'Ella' , 'Jackson' ]; // Sort the "names" array console .log(names); // Output: ["Alex", "Ella", "Jackson", "James", "Mason", "Williams"] You know, there are pointers in JavaScript. You can learn more about JavaScript Pointers on our Guide. JavaScript Pointers are actually as much important as  JavaScript Scope & Scope Chain. Descending Sort You can just as easily sort the elements of an array in ascending order, but if you want to sort the elements in descending order, use the Array.prototype.reverse method after the array has been sorted as the example below: names.sort(); names.reverse(); const names = [ 'Williams' , 'James' , 'Alex' , 'Mason' , 'Ella' , 'Jackson' ]; // Sort the "names" array // Reverse the "names" array console .log(names); // Output: ["Williams", "Mason", "James", "Jackson", "Ella", "Alex"] The reverse method reverses an array in place. The first array element becomes the last, and the last array element becomes the first. Be careful, the sort method is destructive. It changes the original array. If you want to overcome this problem, make a shallow copy of the array at first and then invoke the sort method as in the example below: Warning: copyOfNames.sort(); const names = [ 'Williams' , 'James' , 'Alex' , 'Mason' , 'Ella' , 'Jackson' ]; // Make a shallow copy of the "names" array const copyOfNames = [...names]; // Sort the "copyOfNames" array console .log(names); // Output: ["Williams", "James", "Alex", "Mason", "Ella", "Jackson"] console .log(copyOfNames); // Output: ["Alex", "Ella", "Jackson", "James", "Mason", "Williams"] Node.js is important for Developers to Use in 2022. Learn more about Node.js for Developers. To Speed up your Node.js App's Performance, you should learn how to create it optimal. You can learn about speeding your Node.js App. Sorting strings with non-ASCII characters For sorting strings with non-ASCII characters, i.e. strings with accented characters (e, é, è, a, ä, etc.), strings from languages other than English, use the localeCompare method within the compareFunction parameter of sort method. ES6 is important, You should learn about ES6 Code Snippets in minutes with our Tutorial. The localeCompare method can compare those characters so they appear in the right order. }); const items = [ 'réservé' , 'communiqué' , 'café' , 'adieu' , 'éclair' ]; items.sort( function ( a, b ) { return a.localeCompare(b); console .log(items); // Output: ["adieu", "café", "communiqué", "éclair", "réservé"] The localeCompare method returns a number indicating whether a reference string comes before, or after, or is the same as the given string in sort order. Note: Sorting Array Elements Numerically To sort numbers, you can use the Array.prototype.sort method, but as long as array items are converted to strings and compared in UTF-16 code units, all you need is a simple trick. But let's once sort an array of numbers without applying that trick and see the result: numbers.sort(); const numbers = [ 9 , 1 , 80 , 100 ]; console .log(numbers); // Output: [1, 100, 80, 9] The array got sorted alphabetically, so each integer actually got coerced into a string type. Then each string was compared, which is why 80 came before 9 and 100 came before 80 — strings are compared character-by-character. Have you ever thought of using Chakra UI & What are its Benefits? If not, you can learn more about using Chakra UI in 2022. The solution to achieve a numeric sort is passing a comparison (a, b) => a - b function to the sort method as a parameter. }); const numbers = [ 9 , 1 , 80 , 100 ]; numbers.sort( function ( a, b ) { return a - b; console .log(numbers); // Output: [1, 9, 80, 100] If the compareFunction parameter is supplied to the sort method, all non-undefined array elements are sorted according to the return value of the compare function. If a and b are two elements being compared, then: If compareFunction(a, b) returns a value > 0, sort b before aIf compareFunction(a, b) returns a value ≤ 0, leave a and b in the same order So, the compare function can have something like this under the hood: } } } function compare ( a, b ) { if (a is less than b by some ordering criterion) { return - 1 ; if (a is greater than b by the ordering criterion) { return 1 ; // a must be equal to b return 0 ; Ascending Sort To sort an array numerically in ascending order, the comparison function (a, b) => a - b should return the difference between the two numbers. const numbers = [ 8 , - 2 , 10 , 100 , 19 , - 4 , - 10 ]; numbers.sort( ( a, b ) => a - b); console .log(numbers); // Output: [-10, -4, -2, 8, 10, 19, 100] The comparison function (a, b) => a - b subtracts the second item from the first, returning a negative value if the second item is bigger, a positive value if the second item is smaller, and zero if the two items are equal. Descending Sort A descending sort would just need the operators reversed, so the comparison function becomes (a, b) => b - a. const numbers = [ 8 , - 2 , 10 , 100 , 19 , - 4 , - 10 ]; numbers.sort( ( a, b ) => b - a); console .log(numbers); // Output: [100, 19, 10, 8, -2, -4, -10] Use-case Consider the following array which each element of it is an object, holding two properties of name and score: ]; const results = [ { name : 'Edward' , score : 87 }, { name : 'Williams' , score : 50 }, { name : 'Andy' , score : 45 }, { name : 'Ella' , score : 75 }, { name : 'Alex' , score : 68 }, { name : 'Mason' , score : 37 } The use-case is to sort the results array once according to the names and once according to the score in ascending orders. Give it a try and then look at the solution! Arrays of objects can be sorted by comparing the value of one of their properties. Hint: Let's do it! As mentioned above in the hint, arrays whose elements are objects can be sorted by comparing the value of one of their properties. So let's start with sorting the results array according to the score property: }); // Make a shallow copy const resultsSortedAccordingToScore = [...results]; // Sort in ascending order resultsSortedAccordingToScore.sort( function ( a, b ) { return a.score - b.score; console .log(resultsSortedAccordingToScore); /* * (6) [{…}, {…}, {…}, {…}, {…}, {…}] *   0: {name: "Mason", score: 37} *   1: {name: "Andy", score: 45} *   2: {name: "Williams", score: 50} *   3: {name: "Alex", score: 68} *   4: {name: "Ella", score: 75} *   5: {name: "Edward", score: 87} */ As you see, the resultsSortedAccordingToScore has been sorted according to the score property. You can learn about JavaScript on our Website with #1 Programming Tutorials. In the next step, let's sort the results array according to the name property: } } }); // Make a shallow copy const resultsSortedAccordingToName = [...results]; // Sort in ascending order resultsSortedAccordingToName.sort( function ( a, b ) { let nameA = a.name.toLowerCase(); let nameB = b.name.toLowerCase(); if (nameA < nameB) { return - 1 ; if (nameA > nameB) { return 1 ; // names must be equal return 0 ; console .log(resultsSortedAccordingToName); /* * (6) [{…}, {…}, {…}, {…}, {…}, {…}] *   0: {name: "Alex", score: 68} *   1: {name: "Andy", score: 45} *   2: {name: "Edward", score: 87} *   3: {name: "Ella", score: 75} *   4: {name: "Mason", score: 37} *   5: {name: "Williams", score: 50} */ As you see the output, the array has been sorted according to the name property of the results array but was a little bit tricky. In the first step, I converted all the letters of name properties to lower case letters (or upper case letters) to do a case-insensitive comparison. The Alex and alex are different strings because a and A holds different Unicode code point values. Note: Conclusion The JavaScript sort method orders the elements of an array alphabetically in ascending order by default. The sort modifies an array in place which means the method does not return a new sorted array. In order to sort an array in descending order, instantly invoke Array.prototype.reverse method after the array has been sorted. In this article, I have broken down how to sort an array in JavaScript using sort method in either ascending and descending orders, both numerically and alphabetically, and at the end, I provided a real-life use-case example for a better understanding of the subject. SUBCRIBE TO OUR NEWSLETTER TO RECIEVE EXCULSIVE CONTENT EVERY WEEK FROM THE BEST PROGRAMMING PUBLICATION FOR FREE. subscribe!

How to Sort Array Elements: An Essential Guide

There are many ways to traverse an array in JavaScript. In this benchmark, we will look at five different ways and the pros and cons of each. Keep in mind that these benchmarks were run in a Chrome browser on . Results will vary by browser/interpreter. Codepen For a working example of these benchmarks, take a look at this codepen: All benchmarks we ran on an array of 1000000000 items. 1st: Vanilla JS - Backwards ( i = arr.length ; i>= ; i--){} for let -1 0 ~ 30 milliseconds Going than going forward! This is because at each iteration the loop checks against a constant 0 zero value instead of calling the array's property. Doesn't mean you should do it though... its weird and hard to follow cognitively. backwards is faster .length 2nd: Vanilla JS - Forwards ( i = ; i< arr.length; i++){} for let 0 ~39 milliseconds 3rd: ES6 forEach() arr.forEach( {}); ( ) function element ~180 milliseconds Slow but with a more convenient syntax, nothing surprising here. 4th: jQuery Each $.each(arr, {}); ( ) function index, value ~225 milliseconds Eeeeeew... jQuery. Convenient if you live in 2010. Very Slow. Wildcard: For..Of  ES6 ( item arr){} for const of First and second time running: 153 Milliseconds Third+ times running : ~18 milliseconds This is weird, and I'm not sure how to explain it. Maybe someone smarter than me can tweet me the answer . The first two times running this after a fresh browser load are quite slow, but then it gets blazingly fast. I'm assuming there are some es6 optimizations under the hood that kick in. @wagslane Subscribe to Qvault: https://qvault.io

Benchmarking Array Traversal in Javascript: How to Go Backwards the Fastest

In programming, we often need to go between strings and bytes. Humans read strings. Computers read bytes. As a result, dotnet developers need to understand how to convert a string to a byte array in C#. We accomplish this through a process called encoding and decoding to go back and forth between the two. In this article, I’ll provide you code examples to convert a string to a byte array in C# — and back again! You’ll also learn about some of the nuances of character encodings to look out for! Encoding and Decoding in C# If we want to convert a string to a byte array — or go the other way — we need to understand the concept of encoding and decoding. In software engineering, encoding refers to the process of transforming a string into a sequence of bytes, while decoding involves the reverse process of transforming bytes back into a string. Simple, right? Remember that strings are a sequence of characters, and the concept of a character makes a lot of sense to us as readers, but computers understand bytes. Characters themselves can be represented by numbers in computers so when we want to work with strings at a lower level, such as when sending data over a network or storing it in a file, we need to convert the string into a byte array. Encoding comes into play when converting strings to byte arrays. It determines how the characters in the string are represented as bytes. The encoding scheme defines the mapping between characters and their byte representations. Common encoding schemes include UTF-8, UTF-16, ASCII, and Unicode. Choosing the correct encoding is important because different encoding schemes support different sets of characters. For example, ASCII only supports the basic English alphabet (with a few more characters), while UTF-8 and UTF-16 are capable of representing characters from multiple languages and scripts. More on this later though since I know you’re eager for some code! Choosing an Encoding for String to Byte Array Conversion When converting strings to byte arrays in C#, one of the most important things to consider is character encoding. Character encoding determines the mapping between characters and byte values, and if you’re considering transforming data one way then you may want to put some thought into how to transform it back! What’s that supposed to mean? Well, if we use a data transform — let’s say taking a string and transforming it to bytes with an ASCII encoding — if there is not a mapping of a particular character to a byte representation we lose that data in the result. Now what happens if you want to go the other way and get your byte array back to a string? Data is missing! In C#, there are various encodings available, including ASCII, UTF-8, and UTF-16, each with its specific characteristics and usage scenarios. Let’s explore these encodings and see how they can be used for string to byte array conversion. ASCII Encoding ASCII encoding represents characters using 7 bits, allowing for a total of 128 different characters. It’s primarily suitable for handling basic English characters and is more space-efficient compared to other encodings. Here’s an example of converting a string to a byte array using ASCII encoding: string text = "Hello, World!";
byte[] asciiBytes = Encoding.ASCII.GetBytes(text); In many modern applications, ASCII may not be what you’re after. This is especially true if you have users across the globe in locales that are not English. That’s not to say that ASCII *cannot* be used, but you’ll want to be careful about what data you ASCII encode so as to not lose information during the encoding transform. So keep in mind that the ASCII character set represents characters using a 7-bit encoding scheme, allowing for a total of 128 unique characters. However, with the growing need for internationalization and multilingual support, ASCII alone is insufficient to represent all characters effectively. Good thing we have some other options coming right up! UTF-8 Encoding UTF-8 encoding is a variable-length encoding scheme that can represent any Unicode character. It’s widely used for encoding text in various languages and is backward compatible with ASCII. It uses fewer bytes for representing ASCII characters but may require more bytes for non-ASCII characters. Here’s an example of converting a string to a byte array using UTF-8 encoding: string text = "Привет, мир!";
byte[] utf8Bytes = Encoding.UTF8.GetBytes(text); UTF-16 Encoding UTF-16 encoding represents characters using either 2 or 4 bytes, making it capable of representing any Unicode character. It’s commonly used by applications that need to handle multilingual text or when interoperability with other systems is required. The encoding can be little-endian or big-endian, with the former being more prevalent. Here’s an example of converting a string to a byte array using UTF-16 encoding: string text = "こんにちは、世界！";
byte[] utf16Bytes = Encoding.Unicode.GetBytes(text); UTF-8 Encoding vs UTF-16 Encoding – What’s The Difference? Each of these encodings is variable width, and their size gives them different characteristics when we consider different alphabets. Starting with UTF-8, it’s variable-width and backward-compatible with ASCII. In this encoding: ASCII characters, which are on the range U+0000 to U+007F, take only 1 byte.
In the next range, code points U+0080 to U+07FF take twice as much space at 2 bytes each.
Code points U+0800 to U+FFFF take one more byte, bringing us up to 3 bytes
And finally, code points U+10000 to U+10FFFF take 4 bytes. This can be very effective for English text because those characters will take up minimal space. However, when it comes to Asian text it’s not ideal for the exact opposite reason. Because UTF-16 has code points from U+0000 to U+FFFF take 2 bytes and code points U+10000 to U+10FFFF are double that at 4 bytes, it’s not-so-great for English. It *does* happen to be better suited for Asian characters though. There’s even UTF-32 encoding! This is a fixed-width encoding where all of the code points take four bytes — unlike the others I’ve mentioned which are dynamic in size. This can use much more storage than the other encodings, but because of its simplicity can be much faster to operate on. Give some consideration to the alphabets you’ll need to support primarily! Best Practices for String to Byte Array Conversion When converting strings to byte arrays in C#, it’s important to follow best practices to ensure efficiency and reliability. In this section, I’ll discuss some key best practices that you should keep in mind when performing string-to-byte array conversions. Error Handling and Validation When working with encodings, it’s important to handle potential errors and validate your data to prevent unexpected behavior in your code. Ideally, you structure the flow of your application such that you know what kind of data you’re dealing with. If you can write code to avoid errors in the first place, this is preferred! We don’t want to have to rely on this but sometimes it’s outside of our control — handling errors is by using try-catch blocks. By encapsulating the conversion code within a try block, you can catch any exceptions that may occur during the conversion process and handle them gracefully. If you don’t have control over the source of the input data, this is something you might need to do for safety. Encoding Selection C# provides several encoding options for converting strings to byte arrays, such as UTF-8, UTF-16, ASCII, and more. It’s important to select the appropriate encoding based on the specific requirements of your application. Consider factors such as character sets, compatibility with other systems, and performance implications when choosing the encoding. // Example of encoding selection
string inputString = "Hello, World!";
byte[] encodedBytes = Encoding.UTF8.GetBytes(inputString); Just like we saw in the previous examples, after the Encoding class we get to pick the static property holding the encoding instance. If we need to select one to pass around as a variable and parameter, you can absolutely store it in a dedicated encoding reference: Encoding selectedEncoding = Encoding.UTF8;
SomeMethod("Hello World!", selectedEncoding); Selecting the wrong encoding can have big consequences for your application! This is especially true if you save data with an encoding that will lose data resolution and you can’t reverse it… so put some care into this! Now You Know How to Convert a String to Byte Array in C#! You’re a pro now with encoding and decoding! Well, maybe not a full-on expert… but you have the basics put in front of you and some guidelines to work with. That’s a pretty good start. Remember to select the right encoding for the situation you’re dealing with. Keep in mind that you can potentially lose data resolution when using the wrong encoding, and as a result, lose data forever! If you found this useful and you’re looking for more learning opportunities, consider subscribing to my free weekly software engineering newsletter and check out my free videos on YouTube! In programming , we often need to go between strings and bytes. Humans read strings. Computers read bytes. As a result, dotnet developers need to understand how to convert a string to a byte array in C#. We accomplish this through a process called encoding and decoding to go back and forth between the two. programming In this article, I’ll provide you code examples to convert a string to a byte array in C# — and back again! You’ll also learn about some of the nuances of character encodings to look out for! Encoding and Decoding in C# If we want to convert a string to a byte array — or go the other way — we need to understand the concept of encoding and decoding. In software engineering, encoding refers to the process of transforming a string into a sequence of bytes, while decoding involves the reverse process of transforming bytes back into a string. Simple, right? Remember that strings are a sequence of characters, and the concept of a character makes a lot of sense to us as readers, but computers understand bytes. Characters themselves can be represented by numbers in computers so when we want to work with strings at a lower level, such as when sending data over a network or storing it in a file, we need to convert the string into a byte array. Encoding comes into play when converting strings to byte arrays. It determines how the characters in the string are represented as bytes. The encoding scheme defines the mapping between characters and their byte representations. Common encoding schemes include UTF-8, UTF-16, ASCII, and Unicode . how encoding scheme defines the mapping between characters Common encoding schemes include UTF-8, UTF-16, ASCII, and Unicode Choosing the correct encoding is important because different encoding schemes support different sets of characters. For example, ASCII only supports the basic English alphabet (with a few more characters), while UTF-8 and UTF-16 are capable of representing characters from multiple languages and scripts. More on this later though since I know you’re eager for some code! Choosing an Encoding for String to Byte Array Conversion When converting strings to byte arrays in C#, one of the most important things to consider is character encoding. Character encoding determines the mapping between characters and byte values, and if you’re considering transforming data one way then you may want to put some thought into how to transform it back! What’s that supposed to mean? Well, if we use a data transform — let’s say taking a string and transforming it to bytes with an ASCII encoding — if there is not a mapping of a particular character to a byte representation we lose that data in the result. Now what happens if you want to go the other way and get your byte array back to a string? Data is missing! In C#, there are various encodings available, including ASCII, UTF-8, and UTF-16, each with its specific characteristics and usage scenarios. Let’s explore these encodings and see how they can be used for string to byte array conversion. ASCII Encoding ASCII encoding represents characters using 7 bits, allowing for a total of 128 different characters. It’s primarily suitable for handling basic English characters and is more space-efficient compared to other encodings. Here’s an example of converting a string to a byte array using ASCII encoding: string text = "Hello, World!";
byte[] asciiBytes = Encoding.ASCII.GetBytes(text); string text = "Hello, World!";
byte[] asciiBytes = Encoding.ASCII.GetBytes(text); In many modern applications, ASCII may not be what you’re after. This is especially true if you have users across the globe in locales that are not English. That’s not to say that ASCII *cannot* be used, but you’ll want to be careful about what data you ASCII encode so as to not lose information during the encoding transform. So keep in mind that the ASCII character set represents characters using a 7-bit encoding scheme, allowing for a total of 128 unique characters. However, with the growing need for internationalization and multilingual support, ASCII alone is insufficient to represent all characters effectively. Good thing we have some other options coming right up! UTF-8 Encoding UTF-8 encoding is a variable-length encoding scheme that can represent any Unicode character. It’s widely used for encoding text in various languages and is backward compatible with ASCII. It uses fewer bytes for representing ASCII characters but may require more bytes for non-ASCII characters. Here’s an example of converting a string to a byte array using UTF-8 encoding: string text = "Привет, мир!";
byte[] utf8Bytes = Encoding.UTF8.GetBytes(text); string text = "Привет, мир!";
byte[] utf8Bytes = Encoding.UTF8.GetBytes(text); UTF-16 Encoding UTF-16 encoding represents characters using either 2 or 4 bytes, making it capable of representing any Unicode character. It’s commonly used by applications that need to handle multilingual text or when interoperability with other systems is required. The encoding can be little-endian or big-endian, with the former being more prevalent. Here’s an example of converting a string to a byte array using UTF-16 encoding: string text = "こんにちは、世界！";
byte[] utf16Bytes = Encoding.Unicode.GetBytes(text); string text = "こんにちは、世界！";
byte[] utf16Bytes = Encoding.Unicode.GetBytes(text); UTF-8 Encoding vs UTF-16 Encoding – What’s The Difference? Each of these encodings is variable width, and their size gives them different characteristics when we consider different alphabets. Starting with UTF-8, it’s variable-width and backward-compatible with ASCII. In this encoding: ASCII characters, which are on the range U+0000 to U+007F, take only 1 byte. In the next range, code points U+0080 to U+07FF take twice as much space at 2 bytes each. Code points U+0800 to U+FFFF take one more byte, bringing us up to 3 bytes And finally, code points U+10000 to U+10FFFF take 4 bytes. ASCII characters, which are on the range U+0000 to U+007F, take only 1 byte. In the next range, code points U+0080 to U+07FF take twice as much space at 2 bytes each. Code points U+0800 to U+FFFF take one more byte, bringing us up to 3 bytes And finally, code points U+10000 to U+10FFFF take 4 bytes. This can be very effective for English text because those characters will take up minimal space. However, when it comes to Asian text it’s not ideal for the exact opposite reason. Because UTF-16 has code points from U+0000 to U+FFFF take 2 bytes and code points U+10000 to U+10FFFF are double that at 4 bytes, it’s not-so-great for English. It *does* happen to be better suited for Asian characters though. There’s even UTF-32 encoding! This is a fixed-width encoding where all of the code points take four bytes — unlike the others I’ve mentioned which are dynamic in size. This can use much more storage than the other encodings, but because of its simplicity can be much faster to operate on. Give some consideration to the alphabets you’ll need to support primarily! Best Practices for String to Byte Array Conversion When converting strings to byte arrays in C#, it’s important to follow best practices to ensure efficiency and reliability. In this section, I’ll discuss some key best practices that you should keep in mind when performing string-to-byte array conversions. Error Handling and Validation When working with encodings, it’s important to handle potential errors and validate your data to prevent unexpected behavior in your code. Ideally, you structure the flow of your application such that you know what kind of data you’re dealing with. If you can write code to avoid errors in the first place, this is preferred! We don’t want to have to rely on this but sometimes it’s outside of our control — handling errors is by using try-catch blocks. By encapsulating the conversion code within a try block, you can catch any exceptions that may occur during the conversion process and handle them gracefully. If you don’t have control over the source of the input data, this is something you might need to do for safety. Encoding Selection C# provides several encoding options for converting strings to byte arrays, such as UTF-8, UTF-16, ASCII, and more. It’s important to select the appropriate encoding based on the specific requirements of your application. Consider factors such as character sets, compatibility with other systems, and performance implications when choosing the encoding. // Example of encoding selection
string inputString = "Hello, World!";
byte[] encodedBytes = Encoding.UTF8.GetBytes(inputString); // Example of encoding selection
string inputString = "Hello, World!";
byte[] encodedBytes = Encoding.UTF8.GetBytes(inputString); Just like we saw in the previous examples, after the Encoding class we get to pick the static property holding the encoding instance. If we need to select one to pass around as a variable and parameter, you can absolutely store it in a dedicated encoding reference: Encoding selectedEncoding = Encoding.UTF8;
SomeMethod("Hello World!", selectedEncoding); Encoding selectedEncoding = Encoding.UTF8;
SomeMethod("Hello World!", selectedEncoding); Selecting the wrong encoding can have big consequences for your application! This is especially true if you save data with an encoding that will lose data resolution and you can’t reverse it… so put some care into this! Now You Know How to Convert a String to Byte Array in C#! You’re a pro now with encoding and decoding! Well, maybe not a full-on expert… but you have the basics put in front of you and some guidelines to work with. That’s a pretty good start. Remember to select the right encoding for the situation you’re dealing with. Keep in mind that you can potentially lose data resolution when using the wrong encoding, and as a result, lose data forever! If you found this useful and you’re looking for more learning opportunities, consider subscribing to my free weekly software engineering newsletter and check out my free videos on YouTube ! subscribing to my free weekly software engineering newsletter free videos on YouTube

How to Convert a String to Byte Array in C#

Optimization involves choosing Span<T> over Arrays for manipulating memory regions. Discover a better approach using Spans on Day 23 of our 30-Day .NET Challenge. This article demonstrates the use of Span<T> for optimizing memory management, highlighting the performance benefits. Learning Objectives Drawbacks of the array in memory management
Efficiency of Spans Prerequisites for Developers Basic understanding of C# programming language. Getting Started The drawbacks of Arrays Generally, developers use an array to store sequences of elements in continuous memory locations. Arrays are quite simple and easy to understand. A code snippet of the byte array is shown below: // Bad way: Using arrays may lead to unnecessary memory allocations and copying
    byte[] data = GetData();
    ProcessData(data); The problem with the above code is that it may lead to unnecessary memory allocations and copying because GetData creates a new array each time. The aforementioned code block will degrade the performance of the applications that require high data processing or applications that have limited memory resources. Efficiency of Spans Please find below the refactored version of the previous code snippet. // Good way: Using Span<T> avoids additional memory allocation and copying
    byte[] data = GetData();
    Span<byte> dataSpan = data.AsSpan();
    ProcessData(dataSpan); The Span<T> provides a type-safe and memory-safe view of contiguous memory regions without worrying about the copy issue highlighted previously. Using the AsSpan() method creates a view of the original array without copying or creating a new memory each time. Complete Code Create another class named SpanOverArrayand add the following code snippet: public static class SpanOverArray
    {
        public static void ProcessData(byte[] data)
        {
            Console.WriteLine("Processing byte array:");
            foreach (var b in data)
            {
                Console.Write($"{b} ");
            }
            Console.WriteLine("\n");
        }
    
        public static void ProcessData(Span<byte> dataSpan)
        {
            Console.WriteLine("Processing Span<byte>:");
            foreach (var b in dataSpan)
            {
                Console.Write($"{b} ");
            }
            Console.WriteLine("\n");
        }
    } Execute from the main method as follows #region Day 23: Span Over Arrays
    static string ExecuteDay23()
    {
    
        byte[] largeData = new byte[100]; // Simulate a large data set
        Random rng = new Random();
        rng.NextBytes(largeData); // Populate with random bytes
    
        // Process using array slice
        byte[] slice = new byte[10]; // Creating a new array for the slice
        Array.Copy(largeData, 10, slice, 0, 10); // Copying data
        SpanOverArray.ProcessData(slice);
    
        // Process using Span<T>
        Span<byte> span = largeData.AsSpan(10, 10); // Creating a span starting at index 10
        SpanOverArray.ProcessData(span);
        return "Executed Day 23 successfully..!!";
    }
    
    #endregion Console Output Processing byte array:
    75 20 132 37 218 170 182 227 224 146
    
    Processing Span<byte>:
    75 20 132 37 218 170 182 227 224 146 Complete Code: GitHub — ssukhpinder/30DayChallenge.Net Thank you for being a part of the C# community! Before you leave: Follow on: Youtube | X | LinkedIn | Dev.to
Visit our other platforms: GitHub Optimization involves choosing Span<T> over Arrays for manipulating memory regions. Discover a better approach using Spans on Day 23 of our 30-Day .NET Challenge. Optimization involves choosing Span<T> over Arrays for manipulating memory regions. Discover a better approach using Spans on Day 23 of our 30-Day .NET Challenge. Optimization involves choosing Span<T> over Arrays for manipulating memory regions. Discover a better approach using Spans on Day 23 of our 30-Day .NET Challenge. 30-Day .NET Challenge. This article demonstrates the use of Span<T> for optimizing memory management, highlighting the performance benefits. Learning Objectives Drawbacks of the array in memory management Efficiency of Spans Drawbacks of the array in memory management Efficiency of Spans Prerequisites for Developers Basic understanding of C# programming language. Basic understanding of C# programming language. C# programming language. Getting Started The drawbacks of Arrays Generally, developers use an array to store sequences of elements in continuous memory locations. Arrays are quite simple and easy to understand. A code snippet of the byte array is shown below: // Bad way: Using arrays may lead to unnecessary memory allocations and copying
    byte[] data = GetData();
    ProcessData(data); // Bad way: Using arrays may lead to unnecessary memory allocations and copying
    byte[] data = GetData();
    ProcessData(data); The problem with the above code is that it may lead to unnecessary memory allocations and copying because GetData creates a new array each time. The aforementioned code block will degrade the performance of the applications that require high data processing or applications that have limited memory resources. Efficiency of Spans Please find below the refactored version of the previous code snippet. // Good way: Using Span<T> avoids additional memory allocation and copying
    byte[] data = GetData();
    Span<byte> dataSpan = data.AsSpan();
    ProcessData(dataSpan); // Good way: Using Span<T> avoids additional memory allocation and copying
    byte[] data = GetData();
    Span<byte> dataSpan = data.AsSpan();
    ProcessData(dataSpan); The Span<T> provides a type-safe and memory-safe view of contiguous memory regions without worrying about the copy issue highlighted previously. Using the AsSpan() method creates a view of the original array without copying or creating a new memory each time. Complete Code Create another class named SpanOverArrayand add the following code snippet: public static class SpanOverArray
    {
        public static void ProcessData(byte[] data)
        {
            Console.WriteLine("Processing byte array:");
            foreach (var b in data)
            {
                Console.Write($"{b} ");
            }
            Console.WriteLine("\n");
        }
    
        public static void ProcessData(Span<byte> dataSpan)
        {
            Console.WriteLine("Processing Span<byte>:");
            foreach (var b in dataSpan)
            {
                Console.Write($"{b} ");
            }
            Console.WriteLine("\n");
        }
    } public static class SpanOverArray
    {
        public static void ProcessData(byte[] data)
        {
            Console.WriteLine("Processing byte array:");
            foreach (var b in data)
            {
                Console.Write($"{b} ");
            }
            Console.WriteLine("\n");
        }
    
        public static void ProcessData(Span<byte> dataSpan)
        {
            Console.WriteLine("Processing Span<byte>:");
            foreach (var b in dataSpan)
            {
                Console.Write($"{b} ");
            }
            Console.WriteLine("\n");
        }
    } Execute from the main method as follows #region Day 23: Span Over Arrays
    static string ExecuteDay23()
    {
    
        byte[] largeData = new byte[100]; // Simulate a large data set
        Random rng = new Random();
        rng.NextBytes(largeData); // Populate with random bytes
    
        // Process using array slice
        byte[] slice = new byte[10]; // Creating a new array for the slice
        Array.Copy(largeData, 10, slice, 0, 10); // Copying data
        SpanOverArray.ProcessData(slice);
    
        // Process using Span<T>
        Span<byte> span = largeData.AsSpan(10, 10); // Creating a span starting at index 10
        SpanOverArray.ProcessData(span);
        return "Executed Day 23 successfully..!!";
    }
    
    #endregion #region Day 23: Span Over Arrays
    static string ExecuteDay23()
    {
    
        byte[] largeData = new byte[100]; // Simulate a large data set
        Random rng = new Random();
        rng.NextBytes(largeData); // Populate with random bytes
    
        // Process using array slice
        byte[] slice = new byte[10]; // Creating a new array for the slice
        Array.Copy(largeData, 10, slice, 0, 10); // Copying data
        SpanOverArray.ProcessData(slice);
    
        // Process using Span<T>
        Span<byte> span = largeData.AsSpan(10, 10); // Creating a span starting at index 10
        SpanOverArray.ProcessData(span);
        return "Executed Day 23 successfully..!!";
    }
    
    #endregion Console Output Processing byte array:
    75 20 132 37 218 170 182 227 224 146
    
    Processing Span<byte>:
    75 20 132 37 218 170 182 227 224 146 Processing byte array:
    75 20 132 37 218 170 182 227 224 146
    
    Processing Span<byte>:
    75 20 132 37 218 170 182 227 224 146 Complete Code: GitHub — ssukhpinder/30DayChallenge.Net Complete Code: GitHub — ssukhpinder/30DayChallenge.Net GitHub — ssukhpinder/30DayChallenge.Net Thank you for being a part of the C# community! Before you leave: Follow on: Youtube | X | LinkedIn | Dev.to Visit our other platforms: GitHub Follow on: Youtube | X | LinkedIn | Dev.to Youtube X LinkedIn Dev.to Visit our other platforms: GitHub GitHub

The 30-Day .NET Challenge - Day 23: Span<T> over Arrays

ArrayPool<T>, a mechanism to recycle temporary buffers and optimize performance by reducing garbage collection cycles. Introduction Frequent allocation and deallocation of bigger buffers can impact performance due to the increased work on the garbage collector. The recommendation is to use ArrayPool<T>, a mechanism to recycle temporary buffers and optimize performance by reducing garbage collection cycles. Learning Objectives Understanding the Problem with Traditional Buffer Allocation The Approach Using ArrayPool<T> Best Practices for Using ArrayPool<T> Prerequisites for Developers Basic understanding of C# programming language. 30 Day .Net Challenge Getting Started Understanding the Problem with Traditional Buffer Allocation A common approach developers use involves directly allocating a new buffer // Allocating a new large buffer
byte[] buffer = new byte[4096]; While the aforementioned code snippet looks clean and straightforward, it has significant drawbacks regarding performance, particularly in applications that frequently request large temporary buffers. Each allocation will increase the heap size, leading to more frequent garbage collection. The Approach Using ArrayPool<T> ArrayPool<T> is part of the System.Buffers namespace and provides temporary arrays, thereby reducing the need for frequent memory allocations and GC. // Using ArrayPool<T> to recycle large buffers
var pool = ArrayPool<byte>.Shared;
byte[] buffer = pool.Rent(4096);
try
{
    // Work with the buffer
}
finally
{
    pool.Return(buffer);
} Best Practices for Using ArrayPool<T> While ArrayPool<T> can significantly enhance performance, there are best practices to ensure its effective use: Always return the rented buffers to the pool in a final block to ensure that they are returned even if an exception occurs. Properly Return Buffers: If sensitive data is stored in the buffer, use the overload of the Return method that takes a boolean parameter indicating whether the buffer should be cleared. Clear Buffers When Necessary: Rent buffers for the shortest time necessary to keep the pool efficient and avoid exhausting the pool. Avoid Holding Buffers for Long Periods: Complete Code Create another class named ArrayPoolExample and add the following code snippet. public static class ArrayPoolExample
{
    public static void BadMethod()
    {
        // Allocating a new large buffer
        byte[] buffer = new byte[4096];
        // Simulate work with the buffer
        FillBuffer(buffer, 0xAA); // Example operation
        Console.WriteLine("Buffer used and will be discarded after method execution.");
    }

    public static void GoodMethod()
    {
        var pool = ArrayPool<byte>.Shared;
        byte[] buffer = pool.Rent(4096);
        try
        {
            // Work with the buffer
            FillBuffer(buffer, 0xBB); // Example operation
            Console.WriteLine("Buffer rented from the pool and returned after use.");
        }
        finally
        {
            pool.Return(buffer);
        }
    }

    public static void FillBuffer(byte[] buffer, byte value)
    {
        for (int i = 0; i < buffer.Length; i++)
        {
            buffer[i] = value;
        }
        // Just an example to simulate buffer usage
        Console.WriteLine($"Buffer filled with value: {value}");
    }
} Execute from the main method as follows. #region Day 22: Array Pool
static string ExecuteDay22()
{

    Console.WriteLine("Demonstrating BAD Method:");
    ArrayPoolExample.BadMethod();
    Console.WriteLine("\nDemonstrating GOOD Method:");
    ArrayPoolExample.GoodMethod();
    return "Executed Day 22 successfully..!!";
}

#endregion Console Output Demonstrating BAD Method:
Buffer filled with value: 170
Buffer used and will be discarded after method execution.

Demonstrating GOOD Method:
Buffer filled with value: 187
Buffer rented from the pool and returned after use. Complete Code on GitHub GitHub — ssukhpinder/30DayChallenge.Net C# Programming🚀 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 30-Day .NET Challenge - Day 22: Use Array Pool

Introduction The article demonstrates the use of various C# helper methods like Sort, Reverse, Clear and Resize. Learning Objectives Learn how to use helper methods like Sort() and Reverse() Learn how to use helper methods like Clear() and Resize() Prerequisites for Developers Familiar with arrays. Familiar with if statement Experience in running C# code through Visual Studio or Visual Studio Code. Getting Started How to use a Sort helper method Utilize the Array class’s Sort() method to arrange the elements in the array in alphanumeric order. To begin, create a static class file called “ArrayHelperMethods.cs” within the console application. Insert the provided code snippet into this file. public static class ArrayHelperMethods
    {
        /// <summary>
        /// Outputs
        /// Before Sorting...
        /// B14, A11, B12, A13
        /// After Sorting...
        /// A11, A13, B12, B14
        /// </summary>
        public static void SortExample()
        {
            Console.WriteLine("Before Sorting...");
            string[] pallets = { "B14", "A11", "B12", "A13" };
    
            Console.WriteLine(string.Join(",", pallets));
    
            Array.Sort(pallets);
    
            Console.WriteLine("After Sorting...");
            Console.WriteLine(string.Join(",", pallets));
        }
    } Execute the code from the main method as follows #region Day 11 - Helper Methods  -  Array
    
    ArrayHelperMethods.SortExample();
    
    #endregion Console Output Before Sorting...
    B14,A11,B12,A13
    After Sorting...
    A11,A13,B12,B14 How to use the Reverse helper method In the following example, let’s execute the Reverse() method from the Array class to invert the sequence of elements. To do that, add another method into the same static class as shown below. /// <summary>
    /// Outputs
    /// Before Sorting...
    /// B14,A11,B12,A13
    /// After Reverse Sorting...
    /// A13,B12,A11,B14
    /// </summary>
    public static void ReverseSortExample() {
    
        Console.WriteLine("Before Sorting...");
        string[] pallets = { "B14", "A11", "B12", "A13" };
    
        Console.WriteLine(string.Join(",", pallets));
    
        Array.Reverse(pallets);
    
        Console.WriteLine("After Reverse Sorting...");
        Console.WriteLine(string.Join(",", pallets));
    } Execute the code from the main method as follows #region Day 11 - Helper Methods  -  Array
    
    ArrayHelperMethods.ReverseSortExample();
    
    #endregion Console Output Before Sorting...
    B14,A11,B12,A13
    After Reverse Sorting...
    A13,B12,A11,B14 How to use the Clear Helper method The Array.Clear() method helps to clear the value of specified elements within the array. To do that, add another method into the same static class as shown below /// <summary>
    /// Outputs
    /// Clearing 2 ... count: 4
    /// ,,B12,A13
    /// </summary>
    public static void ClearExample()
    {
        string[] pallets = { "B14", "A11", "B12", "A13" };
        Console.WriteLine("");
    
        Array.Clear(pallets, 0, 2);
        Console.WriteLine($"Clearing 2 ... count: {pallets.Length}");
    
        Console.WriteLine(string.Join(",", pallets));
    }

Execute the code from the main method as follows

    #region Day 11 - Helper Methods  -  Array
    
    ArrayHelperMethods.ClearExample();
    
    #endregion Console Output Clearing 2 ... count: 4
    ,,B12,A13 How to use the Resize helper method In the following example, let’s expand the array size from 4 to 6, then add two new numbers at index 4 and 5. The two newly added elements will remain null until the value is assigned. /// <summary>
    /// Outputs
    /// B14,A11,B12,A13
    /// Resizing 6 ... count: 6
    /// B14,A11,B12,A13,C01,C02
    /// </summary>
    public static void ResizeAndAdd() {
        string[] pallets = { "B14", "A11", "B12", "A13" };
    
        Console.WriteLine(string.Join(",", pallets));
    
        Array.Resize(ref pallets, 6);
        Console.WriteLine($"Resizing 6 ... count: {pallets.Length}");
    
        pallets[4] = "C01";
        pallets[5] = "C02";
    
        Console.WriteLine(string.Join(",", pallets));
    } Execute the code from the main method as follows #region Day 11 - Helper Methods  -  Array
    
    ArrayHelperMethods.ResizeAndAdd();
    
    #endregion Console Output B14,A11,B12,A13
    Resizing 6 ... count: 6
    B14,A11,B12,A13,C01,C02 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 11: Helper Methods — Array

Simple bar chart based on an array in Python import matplotlib.pyplot as plt
import numpy as np

x = np.array(['A', 'B', 'C', 'D', 'E'])
y = np.array([50, 30, 70, 80, 60])

plt.bar(x, y, align='center', width=0.5, color='b', label='data')
plt.xlabel('X axis')
plt.ylabel('Y axis')
plt.title('Bar chart')
plt.legend()
plt.show() Stacked bar chart based on arrays in Python import matplotlib.pyplot as plt
import numpy as np
x = np.array(['A', 'B', 'C', 'D', 'E'])
y1 = np.array([50, 30, 70, 80, 60])
y2 = np.array([20, 40, 10, 50, 30])

plt.bar(x, y1, align='center', width=0.5, color='b', label='Series 1')
plt.bar(x, y2, bottom=y1, align='center', width=0.5, color='g', label='Series 2')
plt.xlabel('X axis')
plt.ylabel('Y axis')
plt.title('Stacked Bar Chart')
plt.legend()
plt.show() Grouped bar chart based on arrays in Python import matplotlib.pyplot as plt
import numpy as np

# Prepare the data
N = 5
men_means = (20, 35, 30, 35, 27)
women_means = (25, 32, 34, 20, 25)
ind = np.arange(N)  # x-axis position
width = 0.35  # width of each bar

# Plot the bar chart
fig, ax = plt.subplots()
rects1 = ax.bar(ind, men_means, width, color='r')
rects2 = ax.bar(ind + width, women_means, width, color='y')

# Add labels, legend, and axis labels
ax.set_xticks(ind + width / 2)
ax.set_xticklabels(('G1', 'G2', 'G3', 'G4', 'G5'))
ax.legend((rects1[0], rects2[0]), ('Men', 'Women'))
ax.set_xlabel('Groups')
ax.set_ylabel('Scores')

# Display the plot
plt.show() Percent stacked bar chart based on arrays in Python import matplotlib.pyplot as plt
import numpy as np

# Prepare the data
x = ['Group 1', 'Group 2', 'Group 3', 'Group 4', 'Group 5']
y = np.array([[10, 20, 30],
              [20, 25, 30],
              [15, 30, 25],
              [25, 15, 20],
              [30, 20, 10]])

# calculate percentage
y_percent = y / np.sum(y, axis=1, keepdims=True) * 100

# Plot the chart
fig, ax = plt.subplots()
ax.bar(x, y_percent[:, 0], label='Series 1', color='r')
ax.bar(x, y_percent[:, 1], bottom=y_percent[:, 0], label='Series 2', color='g')
ax.bar(x, y_percent[:, 2], bottom=y_percent[:, 0] + y_percent[:, 1], label='Series 3', color='b')

# Display the plot
plt.show() Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on or (@Luca_DataTeam). You can also catch glimpses of my personal life on , Happy exploring!👋 LinkedIn X Instagram Also published . here

ARRAY

array.com

201-500 employees

Since 2020

COMPANY RANKING

ARRAY

EVERGREEN INDEX #588

Representing this company? Click here to claim and customize this page!

Array WIKI

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

ARRAY

array.com

201-500 employees

Since 2020

COMPANY RANKING

ARRAY

EVERGREEN INDEX #588

RELATED COMPANIESRANK

STORIES ABOUT ARRAY

Representing this company? Click here to claim and customize this page!

Array WIKI

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