Guest Contributor

Dockerizing Python Applications

Spring Security: Email Verification Registration

Dhananjay Singh

Spring Custom Password Validation

<h2 id="whatareiterators">What are Iterators?</h2>
An iterator in Python refers to an object that we can iterate upon. The iterator consists of countable values, and it is possible to traverse through these values, one by one.
The iterator simply implements the Python's iterator protocol. The iterator protocol is a Python class which comes with two special methods, namely <code>__iter__()</code> and <code>__next__()</code>. With these two methods, the iterator is able to compute the next value in the iteration.
With iterators, it is easy for us to work with sequences of items in Python. We don't have to allocate computing resources to all the items in the sequence, rather we iterate upon single item at a time which helps us save the memory space.
In this article, we will study how to work with iterators in Python.
<h2 id="iterableobjectsinpython">Iterable Objects in Python</h2>
An iterable is an object capable of returning an iterator. An iterable can represent both finite and infinite data sources. The iterable directly or indirectly implements the two methods: <code>__iter__()</code> and <code>__next__()</code>. The <code>__iter__()</code> method returns the iterator object while the <code>__next__()</code> method helps us traverse the elements in the iterable object.
Examples of iterable objects in Python include Lists, dictionaries, tuples, and sets.
<h2 id="creatinganiterator">Creating an Iterator</h2>
In Python, we create an iterator by implementing the <code>__iter__()</code> and <code>__next__()</code> methods on the object. Consider the following example:
<pre><code class="hljs">class IterationExample:
 def __iter__(self):
 self.x = 0
 return self

 def __next__(self):
 y = self.x
 self.x += 1
 return y

classinstance = IterationExample()
element = iter(classinstance)
</code></pre>
We have created an iterator named <code>element</code> that prints numbers from 0 to N. We first created an instance of the class and we gave it the name <code>classinstance</code>. We then called the <code>iter()</code> built-in method and passed the name of the class instance as the parameter. This creates the iterator object.
Let us now discuss how to use an iterator to actually iterate through the items.
<h2 id="iteratingthroughaniterator">Iterating through an Iterator</h2>
The <code>next()</code> method helps us iterate through the elements of an iterator. Let us demonstrate this with the example given above:
<pre><code class="hljs">class IterationExample:
 def __iter__(self):
 self.x = 0
 return self

 def __next__(self):
 y = self.x
 self.x += 1
 return y

classinstance = IterationExample()
element = iter(classinstance)

print(next(element))
print(next(element))
print(next(element))
print(next(element))
print(next(element))
print(next(element))
print(next(element))
print(next(element))
print(next(element))
print(next(element))
</code></pre>
Output
<pre><code class="hljs">0
1
2
3
4
5
6
7
8
9
</code></pre>
In the script above, we called the <code>next()</code> method and passed the name of the iterator element to the method as the parameter. Every time we do this, the iterator moves to the next element in the sequence. Here is another example:
<pre><code class="hljs"># create a list
list1 = [0, 5, 10, 15]

# create an iterator
element = iter(list1)

## use next() to traverse/iterate through the list elements

# prints first element, 0
print(next(element))

# prints second element, 5
print(next(element))

## next(element) is similar to element.__next__()

# prints third element, 10
print(element.__next__())

# prints fourth element, 15
print(element.__next__())
</code></pre>
Output
<pre><code class="hljs">0
5
10
15
</code></pre>
In the script above, we created a list named <code>list1</code>, which has 4 integers. An iterator named <code>element</code> has been created. The <code>next()</code> method has helped us iterate through the list elements.
<h2 id="iterationwiththeforloop">Iteration with the &quot;for&quot; Loop</h2>
The <code>for</code> loop helps us iterate through any object capable of returning an iterator. For example:
<pre><code class="hljs"># create a list
list1 = [0, 5, 10, 15]

# create an iterator
element = iter(list1)

# iterate with a for loop
for x in element:
 print(x)
</code></pre>
Output
<pre><code class="hljs">0
5
10
15
</code></pre>
In the above code, we created a variable named <code>x</code>, which is used to iterate through the iterator <code>element</code> via a <code>for</code> loop.
<h2 id="infiniteiterators">Infinite Iterators</h2>
An infinite iterator is an iterator with infinite number of iterations. We must be extra careful when dealing with infinite iterators. Consider the following example:
<pre><code class="hljs">class IterationExample:
 def __iter__(self):
 self.x = 0
 return self

 def __next__(self):
 y = self.x
 self.x += 1
 return y

classinstance = IterationExample()
element = iter(classinstance)

for x in element:
 print(x)
</code></pre>
The above code will run forever. To stop it, you will have to intervene manually. Here is another example demonstrating how to create an infinite iterator in Python:
<pre><code class="hljs">class Infinite:
 # Print all even numbers

 def __iter__(self):
 self.x = 0
 return self

 def __next__(self):
 x = self.x
 self.x += 2
 return x
</code></pre>
The code should return all even numbers, starting from 0. We can run the code as demonstrated below:
<pre><code class="hljs">&gt;&gt;&gt; y = iter(Infinite())
&gt;&gt;&gt; next(y)
0
&gt;&gt;&gt; next(y)
2
&gt;&gt;&gt; next(y)
4
&gt;&gt;&gt; next(y)
6
&gt;&gt;&gt; next(y)
8
&gt;&gt;&gt; next(y)
10
&gt;&gt;&gt;
</code></pre>
And the above chain can continue forever. This shows that with an infinite iterator, we can have an infinite number of items without having to store all of them in the memory.
In the next section, we will see how we can implement a mechanism to break out of such infinite iterators.
<h2 id="stoppinganiteration">Stopping an Iteration</h2>
In the previous section, we saw how to create an infinite iterator in Python. However, iterators are not usually meant for infinite iteration in Python. It is always convenient to implement a terminating condition.
We can stop an iterator from executing forever using the <code>StopIteration</code> statement. We only need to add a terminating condition in the <code>__next__()</code> method which will raise an error once the specified number of iterations has been reached. Here is an example:
<pre><code class="hljs">class StoppingIteration:
 def __iter__(self):
 self.x = 1
 return self

 def __next__(self):
 if self.x &lt;= 5:
 y = self.x
 self.x += 1
 return y
 else:
 raise StopIteration

classinstance = StoppingIteration()
element = iter(classinstance)

for a in element:
 print(a)
</code></pre>
Output
<pre><code class="hljs">1
2
3
4
5
</code></pre>
The execution halts after 5 iterations. This is because of the <code>self.x &lt;= 5:</code> condition added within the <code>__next__()</code> method. If the iterator is called after reaching 5, it will raise <code>StopIteration</code> event. Consider the example given below:
<pre><code class="hljs">class StoppingIteration:
 def __init__(self, max = 0):
 self.max = max

 def __iter__(self):
 self.x = 1
 return self

 def __next__(self):
 if self.x &lt;= self.max:
 val = 3 ** self.x
 self.x += 1
 return val
 else:
 raise StopIteration
</code></pre>
Let us create an iterator then iterate through it:
<pre><code class="hljs">&gt;&gt;&gt; y = StoppingIteration(3)
&gt;&gt;&gt; z = iter(y)
&gt;&gt;&gt; next(z)
3
&gt;&gt;&gt; next(z)
9
&gt;&gt;&gt; next(z)
27
&gt;&gt;&gt; next(z)
Traceback (most recent call last):
 File &quot;&lt;pyshell#5&gt;&quot;, line 1, in &lt;module&gt;
 next(z)
 File &quot;C:\Users\admin\iteration.py&quot;, line 17, in __next__
 raise StopIteration
StopIteration
&gt;&gt;&gt;
</code></pre>
The terminating condition has been implemented in the following section of our code:
<pre><code class="hljs">if self.x &lt;= self.max:
 val = 3 ** self.x
</code></pre>
We passed a value of 3 to the iterator, meaning that the iterator should not iterate beyond 27, that is, 3^3.
<h2 id="conclusion">Conclusion</h2>
Iterators are extremely useful, especially if you need to iterate through a large sequence of items. Iterators allow you to iterate through a sequence of items one at a time without having to load all the items in to memory at once.
In this article, we saw how to create iterators in Python and how to iterate through items in an iterator. We also saw how to create an infinite iterator and how to add terminating condition to an infinite iterator.

Nicholas Samuel

Introduction to Python Iterators

<h2 id="introduction">Introduction</h2>
One of the most &quot;obscure&quot; features of Python that almost all Python programmers use, even the beginner ones, but don't really understand, is context managers. You've probably seen them in the form of <code>with</code> statements, usually first encountered when you learn opening files in Python. Although context managers seem a little strange at first, when we really dive into them, understand the motivation and techniques behind it, we get access to a new weapon in our programming arsenal. So without further ado, let's dive into it!
<h2 id="motivationresourcemanagement">Motivation: Resource Management</h2>
<blockquote>
&quot;Necessity is the mother of invention&quot;
</blockquote>
To really understand what a context manager is and how we can use it, we must first investigate the motivations behind it — the necessities that gave rise to this &quot;invention&quot;.
The primary motivation behind context managers is resource management. When a program wants to get access to a resource on the computer, it asks the OS for it, and the OS, in turn, provides it with a handle for that resource. Some common examples of such resources are files and network ports. What's important to understand is that these resources have limited availability, for example, a network port can be used by a single process at a time, and there are a limited number of ports available. So whenever we open a resource, we have to remember to close it, so that the resource is freed. But unfortunately, it's easier said than done.
The most straightforward way to accomplish proper resource management would be calling the <code>close</code> function after we're done with the resource:
<pre><code class="hljs">opened_file = open(&#x27;readme.txt&#x27;)
text = opened_file.read()
...
opened_file.close()
</code></pre>
Here we are opening a file named <code>readme.txt</code>, reading the file and saving its contents in a string <code>text</code>, and then when we're done with it, closing the file by calling the <code>close()</code> method of the <code>opened_file</code> object. Now at first glance this might seem okay, but actually, it's not robust at all. If anything unexpected happens between opening the file and closing the file, causing the program to fail to execute the line containing the <code>close</code> statement, there would be a resource leak. These unexpected events are what we call <code>exceptions</code>, a common one would be when someone forcefully closes the program while it's executing.
Now, the proper way to handle this would be using Exception handling, using <code>try...else</code> blocks:
<pre><code class="hljs">try:
 opened_file = open(&#x27;readme.txt&#x27;)
 text = opened_file.read()
 #...
else:
 opened_file.close()
</code></pre>
Python always makes sure the code in the <code>else</code> block is executed, regardless of anything that might happen. This is the way programmers in other languages would handle resource management, but Python programmers get a special mechanism that lets them implement the same functionality without all the boilerplate. This is where context managers come into play!
<h2 id="implementingcontextmanagers">Implementing Context Managers</h2>
Now that we are done with the most crucial part about understanding context managers, we can jump into implementing them. For this tutorial, we will implement a custom <code>File</code> class. It's totally redundant as Python already provides this, but nevertheless, it'll be a good learning exercise as we'll always be able to relate back to the <code>File</code> class that's already there in the standard library.
The standard and &quot;lower-level&quot; way of implementing a context manager is defining two &quot;magic&quot; methods in the class you want to implement resource management for, <code>__enter__</code>and <code>__exit__</code>. If you're getting lost-thinking, &quot;what's this magic method thingy? I've never heard of this before&quot; - well, if you've started doing object-oriented programming in Python, you surely have encountered a magic method already, the method <code>__init__</code>.
For lack of better words, they're special methods that you can define to make your classes smarter or add &quot;magic&quot; to them. You can find a nice reference list of all the magic methods available in Python <a rel="nofollow" target="_blank" href="https://rszalski.github.io/magicmethods/">here</a>.
Anyway, getting back to the topic, before we start implementing these two magic methods, we'll have to understand their purpose. <code>__enter__</code> is the method that gets called when we open the resource, or to put it in a slightly more technical way - when we &quot;enter&quot; the runtime context. The <code>with</code> statement will bind this method's return value to the target specified in the <code>as</code> clause of the statement:
<pre><code class="hljs">class FileManager:
 def __init__(self, filename):
 self.filename = filename
 
 def __enter__(self):
 self.opened_file = open(self.filename)
 return self.opened_file
</code></pre>
As you can see, the <code>__enter__</code> method is opening the resource - the file, and returning it. When we use this <code>FileManager</code> in a <code>with</code> statement, this method will be called and its return value will be bind to the target variable you mentioned in the <code>as</code> clause:
<pre><code class="hljs">with FileManager(&#x27;readme.txt&#x27;) as file:
 text = file.read()
</code></pre>
Let's break it down part-by-part. Firstly, an instance of the <code>FileManager</code> class is created when we instantiate it, passing the filename <code>&quot;readme.txt&quot;</code> to the constructor. Then, the <code>with</code> statement starts working on it - it calls the <code>__enter__</code> method of that <code>FileManager</code> object and assigns the returned value to the <code>file</code> variable mentioned in the <code>as</code> clause. Then, inside the <code>with</code> block, we can do whatever we want to do with the opened resource.
The other important part of the puzzle is the <code>__exit__</code> method. The <code>__exit__</code> method contains clean-up code which must be executed after we're done with the resource, no matter what. The instructions in this method will be similar to the ones in the <code>else</code> block we discussed before while discussing exception handling. To reiterate, the <code>__exit__</code> method contains instructions to properly close the resource handler, so that the resource is freed for further use by other programs in the OS.
Now let's take a look at how we might write this method:
<pre><code class="hljs">class FileManager:
 def __exit__(self. *exc):
 self.opened_file.close()
</code></pre>
Whenever the instances of this class will be used in a <code>with</code> statement, this <code>__exit__</code> method will be called before the program leaves the <code>with</code> block, or before the program halts due to some exception. Now let's look at the whole <code>FileManager</code> class so that we have a complete idea:
<pre><code class="hljs">class FileManager:
 def __init__(self, filename):
 self.filename = filename
 
 def __enter__(self):
 self.opened_file = open(self.filename)
 return self.opened_file
 
 def __exit__(self, *exc):
 self.opened_file.close()
</code></pre>
Simple enough, right? We just defined the opening and cleaning-up actions in the respective magic methods, and Python will take care of resource management wherever this class might be used. That brings us to the next topic, the different ways we can use context manager classes, such as this <code>FileManager</code> class.
<h2 id="usingcontextmanagers">Using Context Managers</h2>
There's not much to explain here, so instead of writing long paragraphs, let's take a look at a few code-snippets in this section:
<pre><code class="hljs">file = FileManager(&#x27;readme.txt&#x27;)
with file as managed_file:
 text = managed_file.read()
 print(text)
</code></pre>
<pre><code class="hljs">with FileManager(&#x27;readme.txt&#x27;) as managed_file:
 text = managed_file.read()
 print(text)
</code></pre>
<pre><code class="hljs">def open_file(filename):
 file = FileManager(filename)
 return file

with open_file(&#x27;readme.txt&#x27;) as managed_file:
 text = managed_file.read()
 print(text)
</code></pre>
You can see that the key thing to remember is,
<ol>
<li>The object passed to the <code>with</code> statement must have <code>__enter__</code> and <code>__exit__</code> methods.</li>
<li>The <code>__enter__</code> method must return the resource that's to be used in the <code>with</code> block.</li>
</ol>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Important: There are some subtleties I left out, to make the discussion to-the-point. For the exact specifications of these magic methods, refer to the Python documentation <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/stdtypes.html#context-manager-types">here</a>.

 </div>
 </div>
 </div>
 <h2 id="using_contextlib_">Using <code>_contextlib_</code></h2>
The <a rel="nofollow" target="_blank" href="https://www.python.org/dev/peps/pep-0020/">Zen of Python</a> - Python's guiding principle as a list of aphorisms - states:
<blockquote>
&quot;Simple is better than complex&quot;
</blockquote>
To really drive this point home, Python developers have created a library named <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/contextlib.html">contextlib</a> containing utilities regarding context managers, as if they didn't simplify the problem of resource management enough. We are going to demonstrate only one of them briefly here, but we recommend you to check out the official Python docs for more information.
<pre><code class="hljs">from contextlib import contextmanager

@contextmanager
def open_file(filename):
 opened_file = open(filename)
 try:
 yield opened_file
 finally:
 opened_file.close()
</code></pre>
Like the code above, we can simply define a function that <code>yield</code>s the protected resource in a <code>try</code> statement, closing it in the subsequent <code>finally</code> statement. Another way to understand it:
<ul>
<li>All the contents you'd otherwise put in the <code>__enter__</code> method, except the <code>return</code> statement, goes before the <code>try</code> block here — basically the instructions for opening the resource.</li>
<li>Instead of returning the resource, you <code>yield</code> it, inside a <code>try</code> block.</li>
<li>The contents of the <code>__exit__</code> method goes inside the corresponding <code>finally</code> block.</li>
</ul>
Once we have such a function, we can decorate it using the <code>contextlib.contextmanager</code> decorator and we're good:
<pre><code class="hljs">with open_file(&#x27;readme.txt&#x27;) as managed_file:
 text = managed_file.read()
 print(text)
</code></pre>
As you can see, the decorated <code>open_file</code> function returns a context manager and we can use that directly. This lets us achieve the same effect as creating the <code>FileManager</code> class, without all the hassle.
<h2 id="conclusion">Conclusion</h2>
If you're feeling enthusiastic and want to read more about context managers, I encourage you to check out the following links:
<ul>
<li><a rel="nofollow" target="_blank" href="https://docs.python.org/3/reference/compound_stmts.html#with">https://docs.python.org/3/reference/compound_stmts.html#with</a></li>
<li><a rel="nofollow" target="_blank" href="https://docs.python.org/3/reference/datamodel.html#context-managers">https://docs.python.org/3/reference/datamodel.html#context-managers</a></li>
<li><a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/contextlib.html">https://docs.python.org/3/library/contextlib.html</a></li>
<li><a rel="nofollow" target="_blank" href="https://rszalski.github.io/magicmethods/">https://rszalski.github.io/magicmethods/</a></li>
</ul>

Python Context Managers

Introduction to Python's Collections Module

Adam McQuistan

Automating AWS EC2 Management with Python and Boto3

<h2 id="introduction">Introduction</h2>
The term <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Comma-separated_values">CSV</a> is an abbreviation that stands for comma-separated values.
A CSV file is a plain text file that contains data formatted according to the CSV standard. It has distinct lines which represent records and each field in the record is separated from another by a comma.
It's very convenient to store tabular data in CSV:
<pre><code class="hljs">Name,Surname,Age,Gender
John,Snow,26,M
Clair,White,33,F
Fancy,Brown,78,F
</code></pre>
Here, the first row represents the titles of the columns/fields of our CSV records and then there are 3 records that represent certain people. As you can see, the values are delimited by commas and each record starts on a new row.
<blockquote>
Hey, but what if we want to include commas or line breaks to some of the fields that are stored in the CSV format?
</blockquote>
There are several approaches to solving this issue, for example, we could wrap up such values in double quotes. Some of the CVS implementations don't support this feature by design, though.
<h2 id="csvstandardization">CSV Standardization</h2>
One of the most commonly used CSV standards is described in the <a rel="nofollow" target="_blank" href="https://tools.ietf.org/html/rfc4180">RFC4180</a>.
According to it, the CSV format is described by these 7 rules:
<ol>
<li>Each record is located on a separate line, delimited by a line break (CRLF).</li>
<li>The last record in the file may or may not have an ending line break.</li>
<li>There may be an optional header line appearing as the first line of the file with the same format as normal record lines. This header will contain names corresponding to the fields in the file and should contain the same number of fields as the records in the rest of the file (the presence or absence of the header line should be indicated via the optional &quot;header&quot; parameter of this MIME type).</li>
<li>Within the header and each record, there may be one or more fields, separated by commas. Each line should contain the same number of fields throughout the file. Spaces are considered part of a field and should not be ignored. The last field in the record must not be followed by a comma.</li>
<li>Each field may or may not be enclosed in double quotes (however some programs, such as Microsoft Excel, do not use double quotes at all). If fields are not enclosed with double quotes, then double quotes may not appear inside the fields.</li>
<li>Fields containing line breaks (CRLF), double quotes, and commas should be enclosed in double-quotes.</li>
<li>If double-quotes are used to enclose fields, then a double-quote appearing inside a field must be escaped by preceding it with another double quote.</li>
</ol>
If you're interested in reading more with multiple examples, you can study the original RFC4180 document, linked above.
<h2 id="readingcsvfilesinnodejs">Reading CSV Files in Node.js</h2>
To read a CSV file in Node.js, we could use nothing else than just the <code>fs</code> module, as in essence the CSV file is a plain text file.
If you're interested in reading more about <a target="_blank" href="/read-files-with-node-js/">Reading Files with Node.js</a> or <a target="_blank" href="/writing-to-files-in-node-js/">Writing Files with Node.js</a>, we've got both covered!
However, there are a couple of helpful modules that could handle generating or parsing the CSV content for us. We'll start by installing the module <code>csv-parser</code>:
<pre><code class="hljs">$ npm i -s csv-parser
</code></pre>
Then, let's put the CSV data from the beginning of the article to a file called <code>data.csv</code> and follow up with a very simple example:
<pre><code class="hljs">const csv = require(&#x27;csv-parser&#x27;);
const fs = require(&#x27;fs&#x27;);

fs.createReadStream(&#x27;data.csv&#x27;)
 .pipe(csv())
 .on(&#x27;data&#x27;, (row) =&gt; {
 console.log(row);
 })
 .on(&#x27;end&#x27;, () =&gt; {
 console.log(&#x27;CSV file successfully processed&#x27;);
 });
</code></pre>
Here, we create a <code>readStream</code> using the <code>fs</code> module, pipe it into the <code>csv</code> object that will then fire the <code>data</code> event each time a new row from the CSV file is processed. The <code>end</code> event is triggered when all the rows from the CSV file are processed and we log a short message to the console to indicate that.
For demonstration purposes, we just <code>console.log</code> each processed row and after running the code, you'll see this output in your console:
<pre><code class="hljs">Row {
 Name: &#x27;John&#x27;,
 &#x27;Surname&#x27;: &#x27;Snow&#x27;,
 &#x27;Age&#x27;: &#x27;26&#x27;,
 &#x27;Gender&#x27;: &#x27;M&#x27; }
Row {
 Name: &#x27;Clair&#x27;,
 &#x27;Surname&#x27;: &#x27;White&#x27;,
 &#x27;Age&#x27;: &#x27;33&#x27;,
 &#x27;Gender&#x27;: &#x27;F&#x27; }
Row {
 Name: &#x27;Fancy&#x27;,
 &#x27;Surname&#x27;: &#x27;Brown&#x27;,
 &#x27;Age&#x27;: &#x27;78&#x27;,
 &#x27;Gender&#x27;: &#x27;F&#x27; }
CSV file successfully processed
</code></pre>
<h2 id="writingcsvfilesinnodejs">Writing CSV Files in Node.js</h2>
Remembering the fact that CSV files are just plain text files, we could always limit ourselves to using only the native <code>fs</code> module, but to make our life easier, we'll use another common <code>npm</code> module, <code>csv-writer</code>.
First goes the installation:
<pre><code class="hljs">$ npm i -s csv-writer
</code></pre>
Then, the code:
<pre><code class="hljs">const createCsvWriter = require(&#x27;csv-writer&#x27;).createObjectCsvWriter;
const csvWriter = createCsvWriter({
 path: &#x27;out.csv&#x27;,
 header: [
 {id: &#x27;name&#x27;, title: &#x27;Name&#x27;},
 {id: &#x27;surname&#x27;, title: &#x27;Surname&#x27;},
 {id: &#x27;age&#x27;, title: &#x27;Age&#x27;},
 {id: &#x27;gender&#x27;, title: &#x27;Gender&#x27;},
 ]
});

const data = [
 {
 name: &#x27;John&#x27;,
 surname: &#x27;Snow&#x27;,
 age: 26,
 gender: &#x27;M&#x27;
 }, {
 name: &#x27;Clair&#x27;,
 surname: &#x27;White&#x27;,
 age: 33,
 gender: &#x27;F&#x27;,
 }, {
 name: &#x27;Fancy&#x27;,
 surname: &#x27;Brown&#x27;,
 age: 78,
 gender: &#x27;F&#x27;
 }
];

csvWriter
 .writeRecords(data)
 .then(()=&gt; console.log(&#x27;The CSV file was written successfully&#x27;));
</code></pre>
The <code>csv-writer</code> module requires an initial configuration where we provide it with the name of the resulting CSV file and the <code>header</code> configuration.
Note: In our JavaScript object, all properties are in lowercase, but in the CSV file the first letters of them should be capitalized.
After the config is done, all we need to do is call the <code>writeRecords</code> function, pass in the <code>data</code> array that represents the data structure that should be written to the CSV file.
Once this process is done, we'll print an informational message to the console stating that the program has completed.
<h3 id="usingthefastcsvmodule">Using the fast-csv Module</h3>
The Node.js ecosystem and <code>npm</code> provides a lot of options to read and write CSV files. We'll show another example of a popular CSV module and take a look at how we can write our data array using the <code>fast-csv</code> module as an alternative.
First, we have to install the module:
<pre><code class="hljs">$ npm i -s fast-csv
</code></pre>
<pre><code class="hljs">const fastcsv = require(&#x27;fast-csv&#x27;);
const fs = require(&#x27;fs&#x27;);
const ws = fs.createWriteStream(&quot;out.csv&quot;);
fastcsv
 .write(data, { headers: true })
 .pipe(ws);
</code></pre>
The API is a bit different, but the result is identical. In just a couple of lines of code, we managed to write the array of JavaScript objects to a CSV file that could be later used by a variety of other applications.
<h2 id="conclusion">Conclusion</h2>
Reading and writing CSV files with Node.js is a common development task as a CSV format is commonly used to store structured tabular data. Many <code>npm</code> modules provide this functionality, so you should choose the one that suits best to your needs and has ongoing support.

Vasyl Lagutin

Reading and Writing CSV Files with Node.js

David Landup

Linked List Programming Interview Questions