<h2 id="introduction">Introduction</h2>
Working with files is a common task with any programming language. File manipulation requires us to know their location. One of the most fundamental ways to interact with files is to list files in a directory.
In this article, we'll be using Node.js and the built-in fs module as well as the directory-tree module from NPM to list all files from a directory.
We'll read a directory, <code>files</code>, located at the same place our <code>app.js</code> file is in:
<pre><code class="hljs">09/10/2020 01:27 PM 332 app.js
09/10/2020 01:24 PM &lt;DIR&gt; files
</code></pre>
The directory contains:
<pre><code class="hljs">files
│ anotherDirectory
│ └── fileInDirectory.txt
└── textFile.txt
└── anotherTextFile.txt
</code></pre>
<h2 id="directorytree">directory-tree</h2>
<code>directory-tree</code> is a handy NPM module that takes care of this task for us and formats the output nicely. First, let's install it:
<pre><code class="hljs">$ npm install directory-tree
</code></pre>
Now, let's import it into our script and supply it with our directory's location:
<pre><code class="hljs">const dirTree = require(&quot;directory-tree&quot;);

const tree = dirTree(&#x27;./files/&#x27;);
console.log(tree);
</code></pre>
The <code>tree</code> constant now contains the information we'd like to access. This code results in:
<pre><code class="hljs">{
 path: &#x27;./files/&#x27;,
 name: &#x27;files&#x27;,
 children: [
 {
 path: &#x27;files\\anotherDirectory&#x27;,
 name: &#x27;anotherDirectory&#x27;,
 children: [Array],
 size: 8,
 type: &#x27;directory&#x27;
 },
 {
 path: &#x27;files\\anotherTextFile.txt&#x27;,
 name: &#x27;anotherTextFile.txt&#x27;,
 size: 2218,
 extension: &#x27;.txt&#x27;,
 type: &#x27;file&#x27;
 },
 {
 path: &#x27;files\\textFile.txt&#x27;,
 name: &#x27;textFile.txt&#x27;,
 size: 7,
 extension: &#x27;.txt&#x27;,
 type: &#x27;file&#x27;
 }
 ],
 size: 2233,
 type: &#x27;directory&#x27;
}
</code></pre>
We can also specify the extensions we'd like to filter based on, using the <code>dirTree()</code> function:
<pre><code class="hljs">const tree = dirTree(&#x27;./files/&#x27;, {extensions:/\.js$/});
console.log(tree);
</code></pre>
This would return an empty result since there are no JS files in the <code>files</code> directory.
<h2 id="fsreaddir">fs.readdir()</h2>
The easiest way to read files from a directory without external modules is with the help of the <code>readdir()</code> function. It's asynchronous and returns an array containing file names in the directory you've specified.
Let's go ahead and list the files from the <code>files</code> directory:
<pre><code class="hljs">const directory = &#x27;./files/&#x27;;
const fs = require(&#x27;fs&#x27;);

fs.readdir(directory, (err, files) =&gt; {
 files.forEach(file =&gt; {
 console.log(file);
 });
});
</code></pre>
Here, we've specified the <code>directory</code> constant, pointing to the <code>files</code> folder, after which, we've imported the <code>fs</code> module.
Then, we've supplied the <code>directory</code> to the <code>readdir()</code> function and logged their name via a callback. This results in:
<pre><code class="hljs">anotherDirectory
anotherTextFile.txt
textFile.txt
textFile.txt - Shortcut.lnk
</code></pre>
Note: The <code>readdir()</code> function also reads directories, but without an indication as to whether it's a directory or a file. A file without an extension looks the same as a directory in this case.
However, we can use the <code>fs.lstatSync()</code> function to help us out with this:
<pre><code class="hljs">const directory = &#x27;./files/&#x27;;
const path = require(&#x27;path&#x27;);
const fs = require(&#x27;fs&#x27;);

fs.readdir(directory, (err, files) =&gt; {
 files.forEach(file =&gt; {
 if (fs.lstatSync(path.resolve(directory, file)).isDirectory()) {
 console.log(&#x27;Directory: &#x27; + file);
 } else {
 console.log(&#x27;File: &#x27; + file);
 }
 });
});
</code></pre>
Using <code>isDirectory()</code>, we've checked if what we're encountering at the given path is a directory or a file. This now results in:
<pre><code class="hljs">Directory: anotherDirectory
File: anotherTextFile.txt
File: file
File: textFile.txt
</code></pre>
<h2 id="fsreaddirsync">fs.readdirSync()</h2>
The <code>readdirSync()</code> function is virtually the same as the <code>readdir()</code> function, but it reads synchronously, instead of asynchronously.
It works in the very same way as the previous approach - it just handles the operation synchronously:
<pre><code class="hljs">const directory = &#x27;./files/&#x27;;
const path = require(&#x27;path&#x27;);
const fs = require(&#x27;fs&#x27;);

fs.readdirSync(directory).forEach(file =&gt; {
 if (fs.lstatSync(path.resolve(directory, file)).isDirectory()) {
 console.log(&#x27;Directory: &#x27; + file);
 } else {
 console.log(&#x27;File: &#x27; + file);
 }
});
</code></pre>
Here, we've done the same thing we've done before. Checking for files and directories, changing the flow slightly based on the results. This code prints out:
<pre><code class="hljs">Directory: anotherDirectory
File: anotherTextFile.txt
File: file
File: textFile.txt
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over a few ways to list files in a directory in Node.js We've started off with <code>directory-tree</code>, an NPM package built for this purpose, after which we've used the built-in <code>fs</code> module and its <code>readdir()</code> and <code>readdirSync()</code> functions to list the files.

David Landup

In this tutorial, we'll learn how to list files in a directory using Node.js. We'll use the NPM package directory-tree for this, as well as the built-in fs module.

Node: List Files in a Directory

<h2 id="introduction">Introduction</h2>
Redis is an in-memory data store, which can be used as a NoSQL database, cache, or as a typical message broker. It's written in ANSI C, which compiles into significantly efficient machine code and its ability to store data as key-value pairs makes in-memory caching an attractive use-case for Redis, besides also persisting data to a disk.
In this article, we'll use Pipelining to allow a Spring Boot application to send multiple requests to the Redis server, in a non-blocking way.
<h2 id="usecaseofpipelininginredis">Use Case of Pipelining in Redis</h2>
Redis is based on a Client/Server(Request/Response) architecture. In these architectures, a client typically sends a query or request to the server and waits for a response. This is usually done in a blocking way such that a new request can't be sent until the response for the last one was sent:
<pre><code class="hljs">Client: &lt;command 1&gt;
Server: Response for &lt;command 1&gt;
Client: &lt;command 2&gt;
Server: Response for &lt;command 2&gt;
Client: &lt;command 3&gt;
Server: Response for &lt;command 3&gt;
</code></pre>
This can lead to massive inefficiencies, with high latency between receiving commands and processing them.
Pipelining allows us to send multiple commands, as a single operation by the client, without waiting for the response from the server between each command. Then, all the responses are read together instead:
<pre><code class="hljs">Client: &lt;command 1&gt;
Client: &lt;command 2&gt;
Client: &lt;command 3&gt;
Server: Response for &lt;command 1&gt;
Server: Response for &lt;command 2&gt;
Server: Response for &lt;command 3&gt;
</code></pre>
Since the client is not waiting for the server's response before issuing another command, latency is reduced which in turn improves the performance of the application.
Note: The commands here are placed in a queue. This queue should remain of a reasonable size. If you're dealing with tens of thousands of commands, it's better to send and process them in batches, lest the benefits of pipelining become redundant.
<h2 id="implementation">Implementation</h2>
Let's go ahead and make a small Spring Boot application that works with Redis and pipelines multiple commands. This is made easier with the help of the <a target="_blank" rel="nofollow noopener" href="https://spring.io/projects/spring-data-redis">Spring Data Redis</a> project.
<h3 id="springbootsetup">Spring Boot Setup</h3>
The easiest way to start off with a blank Spring Boot app is to use <a rel="nofollow noopener" target="_blank" href="https://start.spring.io">Spring Initializr</a>:
<img src="https://stackabuse.s3.amazonaws.com/media/spring-boot-with-redis-hashoperations-crud-functionality-1.PNG" alt="spring boot initializr">
Alternatively, you can also use the <a rel="nofollow noopener" target="_blank" href="https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-cli.html">Spring Boot CLI</a> to bootstrap the application:
<pre><code class="hljs">$ spring init --dependencies=spring-boot-starter-data-redis redis-spring-boot-demo
</code></pre>
We're starting off with the <code>spring-boot-starter-data-redis</code> dependency as it includes <code>spring-data-redis</code>, <code>spring-boot-starter</code> and <code>lettuce-core</code>.
If you already have a Maven/Spring application, add the dependency to your <code>pom.xml</code> file:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
 &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifactId&gt;
 &lt;version&gt;${version}&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Or if you're using Gradle:
<pre><code class="hljs">compile group: &#x27;org.springframework.data&#x27;, name: &#x27;spring-data-redis&#x27;, version: &#x27;${version}&#x27;
</code></pre>
We'll also be using Jedis as the connection client, instead of Lettuce:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;redis.clients&lt;/groupId&gt;
 &lt;artifactId&gt;jedis&lt;/artifactId&gt;
 &lt;version&gt;${version}&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
<h3 id="redisconfiguration">Redis Configuration</h3>
We will host Redis on <a target="_blank" rel="nofollow noopener" href="https://scalegrid.io/">ScaleGrid</a>, which provides a free trial account, for hosting a Redis server instance. Alternatively, you can <a target="_blank" rel="nofollow noopener" href="https://redis.io/download">download the server</a> and host it on your own computer on Linux and MacOS. Windows requires a bit of hacking and is tricky to set up.
Let's set up the <code>JedisConnectionFactory</code> so that our application can connect to the Redis server instance. In your <code>@Configuration</code> class, annotate the adequate <code>@Bean</code>:
<pre><code class="hljs">@Configuration
public class Config {
 @Bean
 public JedisConnectionFactory redisConnectionFactory() {
 JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
 jedisConnectionFactory.setHostName(&quot;&lt;server-hostname-here&gt;&quot;);
 jedisConnectionFactory.setPort(6379);
 jedisConnectionFactory.setPassword(&quot;&lt;server-password-here&gt;&quot;);
 jedisConnectionFactory.afterPropertiesSet();
 return jedisConnectionFactory;
 }
}
</code></pre>
<code>RedisTemplate</code> is an entry-class provided by Spring Data through which we interact with the Redis server.
We'll pass our configured connection factory to it:
<pre><code class="hljs">@Bean
public RedisTemplate&lt;String, String&gt; redisTemplate() {
 RedisTemplate&lt;String, String&gt; redisTemplate = new RedisTemplate&lt;&gt;();
 redisTemplate.setConnectionFactory(redisConnectionFactory());
 redisTemplate.setDefaultSerializer(RedisSerializer.string());
 redisTemplate.afterPropertiesSet();
 return redisTemplate;
}
</code></pre>
We have set the default serializer to store keys and values as <code>String</code>. Alternatively, you can define your own custom serializer.
<h3 id="pipeliningusingredistemplate">Pipelining Using RedisTemplate</h3>
Let's add a few items from a list to the Redis server. We'll do this without pipelining, using the <code>RedisTemplate</code>. Specifically, we'll use the <code>ListOperations</code> interface, acquired from <code>opsForList()</code>:
<pre><code class="hljs">List&lt;String&gt; values = Arrays.asList(&quot;value-1&quot;, &quot;value-2&quot;, &quot;value-3&quot;, &quot;value-4&quot;, &quot;value-5&quot;);
redisTemplate.opsForList().leftPushAll(&quot;pipeline-list&quot;, values);
</code></pre>
Running this code will result in:
<img src="https://stackabuse.s3.amazonaws.com/media/spring-boot-with-redis-pipeline-operations-1.png" alt="redis operation results">
Now, let's remove these. Imagining that this can be an expensive operation, we'll pipeline each <code>rPop()</code> command so that they get sent together and that the results synchronize upon all of the elements being removed. Then, we'll receive these results back. To pipeline commands, we use the <code>executedPipeline()</code> method.
It accepts a <code>RedisCallback</code> or <code>SessionCallback</code> that we provide it with. The <code>executedPipeline()</code> method returns the results that we can then capture and review. If this isn't needed, and you'd just like to execute the commands, you can use the <code>execute()</code> method, and pass <code>true</code> as the <code>pipeline</code> argument instead:
<pre><code class="hljs">List&lt;Object&gt; results = redisTemplate.executePipelined(new RedisCallback&lt;Object&gt;() {
 public Object doInRedis(RedisConnection connection) throws DataAccessException {
 for(int i = 0; i &lt; 5; i++) {
 connection.rPop(&quot;pipeline-list&quot;.getBytes());
 }
 return null;
 }
});
return results;
</code></pre>
The <code>executePipelined()</code> method accepts a <code>new RedisCallback()</code>, in which we use the <code>doInRedis()</code> method to specify what we'd like to do.
Specifically, we've run the <code>rPop()</code> method 5 times, removing the 5 list elements we've inserted beforehand.
Once all five of these commands have been executed, the elements removed from the list and sent back - the results are packed in the <code>results</code> list:
<img src="https://stackabuse.s3.amazonaws.com/media/spring-boot-with-redis-pipeline-operations-2.png" alt="redis pipeline results">
<h2 id="conclusion">Conclusion</h2>
Redis' most popular use-case is as a cache store. However, it can also be used as a database, or as a message broker.
Redis allows us to increase the performance of applications, by minimizing the calls to the database layer. Its support for pipelining allows for multiple commands to be sent to the server in a single write operation, thereby reducing round trip Time to and from the server.
In this article, we've pipelined multiple commands using the <code>RedisTemplate</code> API and verified the results.

Guest Contributor

In this tutorial, we'll perform Redis operation pipelining for Spring Boot Java applications to improve the efficiency and performance.

Spring Boot with Redis: Pipeline Operations

<h2 id="introduction">Introduction</h2>
In this article, we'll convert a JSON array into a Java Array and Java List using Jackson.
Since we're using Jackson, you'll have to add it to your project. If you're using Maven, it's as easy as adding the dependency:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;com.fasterxml.jackson.core&lt;/groupId&gt;
 &lt;artifactId&gt;jackson-databind&lt;/artifactId&gt;
 &lt;version&gt;2.11.2&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Or, if you're using Gradle:
<pre><code class="hljs">compile group: &#x27;com.fasterxml.jackson.core&#x27;, name: &#x27;jackson-databind&#x27;, version: &#x27;2.11.2&#x27;
</code></pre>
Since we're mapping from JSON to our own objects, let's go ahead and define a POJO:
<pre><code class="hljs">public class Language {

 private String name;
 private String description;

 // Getters, setters and toString() method
</code></pre>
<h2 id="readingjsonfromastring">Reading JSON from a String</h2>
Let's start out with reading JSON from a String. The String contains an array of programming languages, with brief descriptions:
<pre><code class="hljs">String json = &quot;[{\&quot;name\&quot;: \&quot;Java\&quot;, \&quot;description\&quot;: \&quot;Java is a class-based, object-oriented programming language.\&quot;},{\&quot;name\&quot;: \&quot;Python\&quot;, \&quot;description\&quot;: \&quot;Python is an interpreted, high-level and general-purpose programming language.\&quot;}, {\&quot;name\&quot;: \&quot;JS\&quot;, \&quot;description\&quot;: \&quot;JS is a programming language that conforms to the ECMAScript specification.\&quot;}]&quot;;
</code></pre>
Using Jackson's <code>ObjectMapper</code> class, it's easy to read values and map them to an object, or an array of objects. We just use the <code>readValue()</code> method, passing the JSON contents and the class we'd like to map to. Since we're mapping to an array of <code>Language</code>, we'll also specify this in the <code>readValue()</code> method:
<pre><code class="hljs">// It&#x27;s advised to use ObjectMapper as a singleton and reuse the instance
final ObjectMapper objectMapper = new ObjectMapper();
Language[] langs = objectMapper.readValue(json, Language[].class);
</code></pre>
Alternatively, you can extract the values directly into a list, using Jackson's <code>TypeReference</code>:
<pre><code class="hljs">List&lt;Language&gt; langList = objectMapper.readValue(json, new TypeReference&lt;List&lt;Language&gt;&gt;(){});
</code></pre>
Without using <code>TypeReference&lt;&gt;</code>, which is advised, you can <a target="_blank" href="/how-to-convert-a-java-array-to-arraylist/">convert the array into a list</a> with any other approach at your disposal, such as:
<pre><code class="hljs">List&lt;Language&gt; langList = new ArrayList(Arrays.asList(langs));
</code></pre>
And then print out the values:
<pre><code class="hljs">langList.forEach(x -&gt; System.out.println(x.toString()));
</code></pre>
This results in:
<pre><code class="hljs">Language{name=&#x27;Java&#x27;, description=&#x27;Java is a class-based, object-oriented programming language.&#x27;}
Language{name=&#x27;Python&#x27;, description=&#x27;Python is an interpreted, high-level and general-purpose programming language.&#x27;}
Language{name=&#x27;JS&#x27;, description=&#x27;JS is a programming language that conforms to the ECMAScript specification.&#x27;}
</code></pre>
<h2 id="readingjsonfromafile">Reading JSON from a File</h2>
We don't always deal with JSON in String format. Oftentimes, the contents come from a <code>File</code>. Thankfully, Jackson makes this task as easy as the last one, we just provide the <code>File</code> to the <code>readValue()</code> method:
<pre><code class="hljs">final ObjectMapper objectMapper = new ObjectMapper();
List&lt;Language&gt; langList = objectMapper.readValue(
 new File(&quot;langs.json&quot;), 
 new TypeReference&lt;List&lt;Language&gt;&gt;(){});

langList.forEach(x -&gt; System.out.println(x.toString()));
</code></pre>
The <code>langs.json</code> file contains:
<pre><code class="hljs">[
 {
 &quot;name&quot;: &quot;Java&quot;,
 &quot;description&quot;: &quot;Java is a class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible.&quot;
 },
 {
 &quot;name&quot;: &quot;Python&quot;,
 &quot;description&quot;: &quot;Python is an interpreted, high-level and general-purpose programming language. Created by Guido van Rossum and first released in 1991.&quot;
 },
 {
 &quot;name&quot;: &quot;JS&quot;,
 &quot;description&quot;: &quot;JS is a programming language that conforms to the ECMAScript specification. JavaScript is high-level, often just-in-time compiled, and multi-paradigm.&quot;
 }
]
</code></pre>
Running this code results in:
<pre><code class="hljs">Language{name=&#x27;Java&#x27;, description=&#x27;Java is a class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible.&#x27;}
Language{name=&#x27;Python&#x27;, description=&#x27;Python is an interpreted, high-level and general-purpose programming language. Created by Guido van Rossum and first released in 1991.&#x27;}
Language{name=&#x27;JS&#x27;, description=&#x27;JS is a programming language that conforms to the ECMAScript specification. JavaScript is high-level, often just-in-time compiled, and multi-paradigm.&#x27;}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've used Jackson to parse and map the values from a JSON String and file into a Java array and list.
This is done via the <code>readValue()</code> method, by specifying the JSON contents (String or file) and by specifying the POJO we'd like to map to.

In this tutorial, we'll use Jackson with Java to convert a JSON array into a Java array and a Java List with examples. This can be done from Strings or Files.

Convert JSON Array to a Java Array or List with Jackson

<h2 id="introduction">Introduction</h2>
A common development task is reading data from files. A common file format is the <code>.csv</code> format.
While you can read CSV files using the <code>fs</code> module that comes with Node and get the content of the file, in most cases, parsing and further conversion is much easier with the help of modules made exactly for that purpose.
Multiple modules provide such capabilities like the <code>neat-csv</code> or <code>csv-parser</code> packages. However, in this article, we'll be using <a href="https://csv.js.org/" rel="nofollow noopener" target="_blank"><code>node-csv</code></a> - a suite of CSV packages for generating, parsing, transforming and stringifying CSV data.
<h2 id="installingnodecsv">Installing node-csv</h2>
The module consists of <code>csv-generate</code>, <code>csv-parse</code>, <code>csv-transform</code> and <code>csv-stringify</code> packages.
You can either install the whole suite or each package one by one if you don't need them all. Let's initialize a Node project with default settings:
<pre><code class="hljs">$ npm init -y
</code></pre>
Then, let's install the entire <code>node-csv</code> suite:
<pre><code class="hljs">$ npm install csv
</code></pre>

 <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">
 Note: Although the suite is called <code>node-csv</code> - the relevant NPM package is actually called <code>csv</code>.

 </div>
 </div>
 </div>
 We'll be working with a CSV file with these contents:
<pre><code class="hljs">Account Name,Account Code,Type,Description
Cash,101,Assets,Checking account balance
Wages Payable,220,Liabilities,Amount owed to employee for hours not yet paid
Rent expense,560,Expenses,Cost of occupied rented facilities during accounting period
</code></pre>
<h2 id="readingcsvfileswithcsvparse">Reading CSV Files with csv-parse</h2>
To read CSV files, we’ll be using the <a href="https://csv.js.org/parse/" rel="nofollow noopener" target="_blank"><code>csv-parse</code></a> package from <code>node-csv</code>.
The <code>csv-parse</code> package provides multiple approaches for parsing CSV files - using callbacks, a stream + callback as well as the Sync and Async API. We'll be covering the stream + callback API and the Sync API.
<h3 id="streamcallbackapi">Stream + Callback API</h3>
Let's create a file, called <code>index.js</code> and construct a <code>parser</code>:
<pre><code class="hljs">var fs = require(&#x27;fs&#x27;); 
var parse = require(&#x27;csv-parse&#x27;);
var parser = parse({columns: true}, function (err, records) {
 console.log(records);
});

fs.createReadStream(__dirname+&#x27;/chart-of-accounts.csv&#x27;).pipe(parser);
</code></pre>
First, we import the native file system module (<code>fs</code>) and the <code>csv-parse</code> module. Then, we create a <code>parser</code> which accepts an object literal, containing the options we'd like to set. The second argument is the callback function that's used to access the records - or just print them out, in our case.
The options we can set aren't mandatory. In most cases, you'll be using any of the <code>delimiter</code>, <code>cast</code> or <code>columns</code> options:
<ul>
<li>
The delimiter option defaults to a comma <code>,</code>. If the data from the file you’re trying to parse uses some other delimiter like a semi-colon <code>;</code>, or a pipe <code>|</code>, you can specify that with this option.
</li>
<li>
The cast option defaults to <code>false</code> and is used to indicate whether you want to cast the strings to their native data types. For example, a column that is made up of date fields can be cast into a <code>Date</code>.
</li>
<li>
The columns option is to indicate whether you want to generate the record in the form of object literals. By default, this column is set to <code>false</code> and records are generated by the parser in the form of arrays. If set to <code>true</code>, the parser will infer the column name from the first line.
</li>
</ul>
Finally, we've opened up a read stream using the <code>fs</code> module and started piping it into the parser.
Let's run this file:
<pre><code class="hljs">$ node index.js
</code></pre>
This results in:
<pre><code class="hljs">[
 {
 &#x27;Account Name&#x27;: &#x27;Cash&#x27;,
 &#x27;Account Code&#x27;: &#x27;101&#x27;,
 Type: &#x27;Assets&#x27;,
 Description: &#x27;Checking account balance&#x27;
 },
 {
 &#x27;Account Name&#x27;: &#x27;Wages Payable&#x27;,
 &#x27;Account Code&#x27;: &#x27;220&#x27;,
 Type: &#x27;Liabilities&#x27;,
 Description: &#x27;Amount owed to employee for hours not yet paid&#x27;
 },
 {
 &#x27;Account Name&#x27;: &#x27;Rent expense&#x27;,
 &#x27;Account Code&#x27;: &#x27;560&#x27;,
 Type: &#x27;Expenses&#x27;,
 Description: &#x27;Cost of occupied rented facilities during accounting period&#x27;
 }
]
</code></pre>
Instead of just printing the contents out, you can manipulate this data, construct objects with the information from these fields or save them into a database, for example.
<h3 id="usingsyncapi">Using Sync API</h3>
Let's replicate this functionality using the Sync API:
<pre><code class="hljs">var fs = require(&#x27;fs&#x27;).promises;
var parse = require(&#x27;csv-parse/lib/sync&#x27;);
(async function () {
 const fileContent = await fs.readFile(__dirname+&#x27;/chart-of-accounts.csv&#x27;);
 const records = parse(fileContent, {columns: true});
 console.log(records)
})();
</code></pre>
Again, we're importing the <code>fs</code> module and the Sync API from the <code>csv-parse</code> module.
Then, we're creating an <code>async</code> function, in which we retrieve the contents of the file by <code>await</code>ing the response of the <code>readFile()</code> function.
Then, we can create a <code>parser</code> which takes in the file contents as the first argument and an object literal as the second. This object literal contains options for creating the parser (we've set <code>columns</code> to <code>true</code>). This parser is assigned to a constant variable and we simply print its contents out for brevity's sake:
<pre><code class="hljs">[
 {
 &#x27;Account Name&#x27;: &#x27;Cash&#x27;,
 &#x27;Account Code&#x27;: &#x27;101&#x27;,
 Type: &#x27;Assets&#x27;,
 Description: &#x27;Checking account balance&#x27;
 },
 {
 &#x27;Account Name&#x27;: &#x27;Wages Payable&#x27;,
 &#x27;Account Code&#x27;: &#x27;220&#x27;,
 Type: &#x27;Liabilities&#x27;,
 Description: &#x27;Amount owed to employee for hours not yet paid&#x27;
 },
 {
 &#x27;Account Name&#x27;: &#x27;Rent expense&#x27;,
 &#x27;Account Code&#x27;: &#x27;560&#x27;,
 Type: &#x27;Expenses&#x27;,
 Description: &#x27;Cost of occupied rented facilities during accounting period&#x27;
 }
]
</code></pre>
<h2 id="writingcsvfilesusingcsvstringify">Writing CSV Files using CSV Stringify</h2>
Similar to reading, we'd sometimes like to write data down into a CSV format. For this, we'll use the <a href="https://csv.js.org/stringify/" rel="nofollow noopener" target="_blank"><code>csv-stringify</code></a> package from the <code>node-csv</code> suite. Stringification just means that we'll convert some data (JSON in our example) into a string. This string is then written to a file, in CSV format.
Let's assume you've got some JSON contents that you'd like to write down as a CSV file:
<pre><code class="hljs">var someData = [
 {
 &quot;Country&quot;: &quot;Nigeria&quot;,
 &quot;Population&quot;: &quot;200m&quot;,
 &quot;Continent&quot;: &quot;Africa&quot;,
 &quot;Official Language(s)&quot;: &quot;English&quot;
 },
 {
 &quot;Country&quot;: &quot;India&quot;,
 &quot;Population&quot;: &quot;1b&quot;,
 &quot;Continent&quot;: &quot;Asia&quot;,
 &quot;Official Language(s)&quot;: &quot;Hindi, English&quot;
 },
 {
 &quot;Country&quot;: &quot;United States of America&quot;,
 &quot;Population&quot;: &quot;328m&quot;,
 &quot;Continent&quot;: &quot;North America&quot;,
 &quot;Official Language&quot;: &quot;English&quot;
 },
 {
 &quot;Country&quot;: &quot;United Kingdom&quot;,
 &quot;Population&quot;: &quot;66m&quot;,
 &quot;Continent&quot;: &quot;Europe&quot;,
 &quot;Official Language&quot;: &quot;English&quot;
 },
 {
 &quot;Country&quot;: &quot;Brazil&quot;,
 &quot;Population&quot;: &quot;209m&quot;,
 &quot;Continent&quot;: &quot;South America&quot;,
 &quot;Official Language&quot;: &quot;Portuguese&quot;
 }
]
</code></pre>
The <code>csv-stringify</code> package also has a couple of API options, though, the Callback API offers a really simple way to stringify data, without the need to handle events like with the Stream API.
Let's go ahead and stringify the data above, before writing it to a file:
<pre><code class="hljs">var fs = require(&#x27;fs&#x27;);
var stringify = require(&#x27;csv-stringify&#x27;);
 
stringify(someData, {
 header: true
}, function (err, output) {
 fs.writeFile(__dirname+&#x27;/someData.csv&#x27;, output);
})
</code></pre>
Here, we're importing the <code>fs</code> and <code>csv-stringify</code> modules. Then, using the <code>stringify()</code> function, we supply the data we'd like to convert to a string. We've also supplied an object literal containing the <code>header</code> option. Finally, there's also a callback function that's used to write the contents down into a file.
Other options like <code>cast</code>, <code>columns</code> and <code>delimiter</code> are also available. In our case, we’re setting the <code>header</code> option to <code>true</code> to tell the stringifier to generate the column names in the first record.
Running this code generates a file with the proper contents:
<img src="https://stackabuse.s3.amazonaws.com/media/reading-and-writing-csv-files-in-nodejs-with-node-csv-1.png" alt="writing csv to a file in nodejs">
<h2 id="conclusion">Conclusion</h2>
The <code>node-csv</code> module is a suite of smaller modules used to read/parse, transform and write CSV data from and to files.
We've used the <code>csv-parse</code> module to read CSV files and the <code>csv-stringify</code> module to stringify data before writing it to a file using Node.js.

Aniuchi Adaobi

In this tutorial, we'll be using the node-csv suite, or rather, the csv-parse and csv-stringify modules to read and write CSV file in Node.js with examples.

Reading and Writing CSV Files in Node.js with node-csv

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll be converting a Java Array into a Java Stream for primitive types, as well as objects. This can be done either via Arrays.stream(), as well as Stream.of().
<h2 id="arraysstream">Arrays.stream()</h2>
A good way to turn an array into a stream is to use the <code>Arrays</code> class' <code>stream()</code> method. This works the same for both primitive types and objects.
<h3 id="primitivetypes">Primitive Types</h3>
For primitive types, you can use <code>Arrays.stream()</code> with an array reference as the parameter.
Optionally, you can also specify the range of indices that should be used as the starting and ending point of the stream/array. If these are not supplied, the entire array will be converted:
<pre><code class="hljs">// Entire array is used for constructing the Stream
Arrays.stream(T[] arr) 
// Construct Stream with a range of elements
Arrays.stream(T[] arr,int start_ind_Include,int end_ind_Exclude) 
)
</code></pre>
Let's instantiate an array and convert it into a stream:
<pre><code class="hljs">long[] array = {2, 5, 9, 10, 15, 18, 56};
LongStream stream = Arrays.stream(array);
System.out.println(&quot;Long stream:&quot;);
stream.forEach(x -&gt; System.out.print(x + &quot; &quot;));
</code></pre>
This results in:
<pre><code class="hljs">Long stream: 
2 5 9 10 15 18 56 
</code></pre>
Similarly, we can create a stream from a range of indices (0,4) by supplying them as the parameters. Note the starting index of the range is included and end index is not included when a range is specified:
<pre><code class="hljs">LongStream stream = Arrays.stream(array,0,4);
System.out.println(&quot;\nLong stream from index 0 to 3:&quot;);
stream.forEach(x -&gt; System.out.print(x + &quot; &quot;));
</code></pre>
This results in:
<pre><code class="hljs">Long stream from index 0 to 3: 
2 5 9 10 
</code></pre>
<h3 id="objects">Objects</h3>
For objects, <code>Arrays.stream()</code> returns a <code>Stream</code> of the specified object. It accepts an array reference and optionally takes in a range of indices. Let's make a <code>String</code> array and convert it into a <code>Stream</code>:
<pre><code class="hljs">String[] array = new String[]{&quot;John&quot;, &quot;Jenny&quot;, &quot;Martha&quot;, &quot;Adam&quot;};

// Create a Stream
Stream&lt;String&gt; stream = Arrays.stream(array);
System.out.println(&quot;Entire array:&quot;);
stream.forEach(c -&gt; System.out.println(c));

// Create a Stream from a range
System.out.println(&quot;\nSubarray:&quot;)
Stream&lt;String&gt; streamWithRange = Arrays.stream(array,0,2);
</code></pre>
The above code generates the following output:
<pre><code class="hljs">Entire array:
John
Jenny
Martha
Adam

Subarray:
John
Jenny
</code></pre>
<h2 id="streamof">Stream.of()</h2>
<h3 id="primitiveobjects">Primitive Objects</h3>
Instead of using the <code>Arrays</code> class, we can also use the goal class - <code>Stream</code>. The <code>of()</code> method, as the name implies, creates a <code>Stream</code> with a given collection, such as an array.
Keep in mind, <code>Stream.of()</code> returns a stream of objects, regardless of the type you're using. You'll have to flatten it for primitive types. The conversion/casting is done automatically for objects, since in that case, the <code>Stream.of()</code> method just calls <code>Arrays.stream()</code>.
Let's make a primitive <code>int</code> array:
<pre><code class="hljs">int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9};
Stream&lt;int[]&gt; stream = Stream.of(array);
System.out.println(&quot;\nInt stream: &quot;);
// Need to be flattened to its primitive type
stream.flatMapToInt(Arrays::stream).forEach(x -&gt; System.out.print(x + &quot; &quot;));
</code></pre>
The flattening is done via the <code>Arrays.stream()</code> method, which in this case just adds redundancy to the code. Instead of using <code>Stream.of()</code> on primitive arrays, we can use built-in classes for these such as <code>IntStream</code>.
This code results in:
<pre><code class="hljs">Int stream: 
1 2 3 4 5 6 7 8 9
</code></pre>
<h3 id="objects">Objects</h3>
Now, let's create a <code>Stream</code> of <code>String</code> type. We'll then filter out only names that start with the letter 'J':
<pre><code class="hljs">String[] array = new String[]{&quot;John&quot;, &quot;Jenny&quot;, &quot;Martha&quot;, &quot;Adam&quot;};

Stream&lt;String&gt; stream = Stream.of(array);
System.out.println(&quot;Printing only names that start with &#x27;J&#x27;...&quot;);
stream.filter(string -&gt; string.startsWith(&quot;J&quot;))
 .forEach(string -&gt; System.out.pritnln(string));
</code></pre>
The code has the following output:
<pre><code class="hljs">Printing only names that start with &#x27;J&#x27;...
John
Jenny
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered the two ways you can create a Stream from an array. This goes for both primitive arrays and object arrays.
The <code>Arrays.stream()</code> method is a straightforward one, which accepts an array reference and an optional range. The <code>Stream.of()</code> method calls <code>Arrays.stream()</code> for object types, while it requires flattening for primitive types.

Mehreen Saeed

In this tutorial, we'll convert a Java Array to a Java Stream. This can be done for primitive types and objects, using the Arrays.stream() and Stream.of() methods.

Java: Convert Array to Stream

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll be converting a Java Stream into a Java Array for primitive types, as well as objects.
<h2 id="streamtoarray">Stream.toArray()</h2>
The <code>toArray()</code> method is a built-in method from the <code>Stream</code> class which is really convenient to use when converting from a <code>Stream</code> to an array. It works for both primitive types and objects, though, there's a slight difference in the usage.
The method returns a new array, which means that we'll be packing the results into a new array for storage. For objects, we'll have to specify the object type and provide an array constructor of that type to the method as well.
<h3 id="primitivetypes">Primitive Types</h3>
Java 8 has special streams for primitive types, i.e., <code>IntStream</code>, <code>LongStream</code> and <code>DoubleStream</code>. Let's use an <code>IntStream</code> to store a range of integers, and then convert it into an array:
<pre><code class="hljs">IntStream stream = IntStream.range(10, 20);
int[] array = stream.toArray();
System.out.println(&quot;Printing array ...&quot;);

for (int i = 0; i &lt; array.length; ++i)
 System.out.print(array[i] + &quot; &quot;);
</code></pre>
This results in:
<pre><code class="hljs">Printing array ...
10 11 12 13 14 15 16 17 18 19 
</code></pre>
Streams are handy for data manipulation, so you might want to do preprocessing on a stream, rather than an array, and convert it into one in the end:
<pre><code class="hljs">IntStream stream = IntStream.range(10, 20);
// Filter out all even numbers
int[] array = stream.filter(x -&gt; x%2 == 0).toArray();
System.out.println(&quot;\nPrinting even numbers ...&quot;);
for (int i = 0; i &lt; array.length; ++i)
 System.out.print(array[i] + &quot; &quot;);
</code></pre>
This results in:
<pre><code class="hljs">Printing even numbers ...
10 12 14 16 18
</code></pre>
<h3 id="objects">Objects</h3>
For objects, the <code>toArray()</code> method takes in an array constructor reference for the respective object, and returns an array of that type. Let's make a <code>Stream</code> of <code>String</code> objects and convert it into an array:
<pre><code class="hljs">// Create a List of Strings
List&lt;String&gt; list = new ArrayList&lt;&gt;();
list.add(&quot;John&quot;);
list.add(&quot;Jenny&quot;);
list.add(&quot;Martha&quot;);

// Stream the List
Stream&lt;String&gt; stream = list.stream();

// Create an array using the toArray() method
String[] array = stream.toArray(String[]::new);
System.out.println(&quot;Printing String array ...&quot;);
for (int i = 0; i &lt; array.length; ++i)
 System.out.println(array[i]);
</code></pre>
This results in:
<pre><code class="hljs">Printing String array...
John
Jenny
Martha
</code></pre>
Note: The <code>toArray()</code> method requires the array constructor to be used and we've used a method reference to specify the type - <code>String[]::new</code>. <code>toArray()</code> returns an array of the specified type, and if the type isn't specified, a mismatch will occur:
<pre><code class="hljs">String[] array = stream.toArray();
</code></pre>
The result is a compiler error:
<pre><code class="hljs">error: incompatible types: Object[] cannot be converted to String[]
</code></pre>
Instead of the shorthand method references, we can also use Lambda Expressions to achieve this. Let's filter out only names that start with 'J':
<pre><code class="hljs">// Create a List of Strings
List&lt;String&gt; list = new ArrayList&lt;&gt;();
list.add(&quot;John&quot;);
list.add(&quot;Jenny&quot;);
list.add(&quot;Martha&quot;);

// Stream the List
Stream&lt;String&gt; stream = list.stream();

// Filter the stream element and convert to array
String[] array = stream
 .filter(string -&gt; string.startsWith(&quot;J&quot;))
 .toArray(size -&gt; new String[size]);
System.out.println(&quot;Printing names starting with &#x27;J&#x27;...&quot;);
for (int i = 0; i &lt; array.length; ++i)
 System.out.println(array[i]);
</code></pre>
This produces:
<pre><code class="hljs">Printing names starting with &#x27;J&#x27;...
John
Jenny
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've converted a <code>Stream</code> into an array. This can be done for primitive and object arrays via the <code>Stream.toArray()</code> method, albeit, with slightly different usage.

In this tutorial, we'll convert a Java Stream to a Java Array. This can be done for primitive types and objects, using the Stream.toArray() method.

Java: Convert Stream to Array

<h2 id="introduction">Introduction</h2>
This tutorial will go through some common techniques for removing elements from Java arrays. Manipulating array elements is an extremely common task as discussions about it can be found on many forums, particularly on StackOverflow.
Here's a list of the techniques and methods we'll go over in this article:
<ul>
<li><a href="#usingtwoarrays">Using Two Arrays</a></li>
<li><a href="#arrayutilsremove">ArraysUtils.remove()</a></li>
<li><a href="#usingaforloop">Using a <code>for</code> loop</a></li>
<li><a href="#systemarraycopy">System.arraycopy()</a></li>
</ul>
<h2 id="ashortbriefingonarrays">A Short Briefing on Arrays</h2>
Arrays are data structures common in many programming languages. Each array is stored in a single block of memory and it allows sequential storage and simple manipulation of elements:
<img src="https://stackabuse.s3.amazonaws.com/media/remove-an-element-from-an-array-in-java-1.png" alt="java array in memory">
Credit: <a target="_blank" rel="Nofollow noopener" href="https://codeforwin.org/">CodeForWin</a>
Elements are sequentially stored one after another. When someone wants to access an element at a certain index, pointer arithmetic (which is the mechanism under the hood) allows to quickly and efficiently obtain any particular element.
If the index of a requested element is <code>3</code>, the underlying mechanism simply needs to take the memory address of the zero-th element and add three times the size of each element. Since all array elements have the same size, this kind of computation leads directly to the element with index <code>3</code>. Furthermore, this happens in <code>O(1)</code> complexity which means it's as fast as it can be.
What makes removing an array element difficult is the fact that all elements are stored sequentially in a single memory block. Due to the nature of array's memory placement, it is simply impossible to remove the element directly.
Instead, to &quot;remove&quot; any element, all subsequent elements need to be shifted backward by one place. This will create an illusion that a specific element was removed.
<h2 id="usingtwoarrays">Using Two Arrays</h2>
The simplest pure Java way to do this is to make a new array, one element shorter than the original one and copy all element, except the one we'd like to remove, into it:
<pre><code class="hljs">int[] copy = new int[array.length - 1];

for (int i = 0, j = 0; i &lt; array.length; i++) {
 if (i != index) {
 copy[j++] = array[i];
 }
}
</code></pre>
Here, we're simply iterating over the original array and copying elements from the original array into the new array, skipping the one we'd like to remove.
The <code>copy</code> array now consists of:
<pre><code class="hljs">10, 20, 30, 50, 60, 70, 80, 90, 100
</code></pre>
<h2 id="arrayutilsremove">ArrayUtils.remove()</h2>
In case you're already using the Apache Commons library, you can use the <code>ArrayUtils.remove()</code> method.
Before working with Apache Commons, we'll want to add it to our project:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.apache.commons&lt;/groupId&gt;
 &lt;artifactId&gt;commons-lang3&lt;/artifactId&gt;
 &lt;version&gt;${version}&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Using the method is really simple. We simply supply it with the array we'd like to remove an element from and its index:
<pre><code class="hljs">int[] array = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int index = 3;
array = ArrayUtils.remove(array, index);
</code></pre>
It then returns the new array, which is stored in the <code>array</code> variable:
<pre><code class="hljs">10, 20, 30, 50, 60, 70, 80, 90, 100
</code></pre>
<h2 id="usingaforloop">Using a for loop</h2>
The seemingly simplest way to remove an element is to iterate the array manually using a <code>for</code> loop. Alternatively, a <code>while</code> loop can also be used but <code>for</code> is much more suitable for this type of task.
Say, we want to remove the third element:
<pre><code class="hljs">int[] array = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int index = 3;
</code></pre>
The element corresponding to index <code>3</code> is <code>40</code>. To remove this element, we simply &quot;shift&quot; all elements after it. This means that we're going to iterate through all the elements after <code>40</code> and simply &quot;move&quot; them one place to the left.
Since it's not possible to just move an element, we copy its value instead. Subsequent copies will overwrite original values and the result will be as if the entire right part of the array was shifted leftward by one:
<pre><code class="hljs">for (int i = index; i &lt; array.length - 1; i++) {
 array[i] = array[i + 1];
}
</code></pre>
If we went and printed the modified array, this would be the result:
<pre><code class="hljs">10, 20, 30, 50, 60, 70, 80, 90, 100, 100
</code></pre>
Arrays are of fixed length. The last element, <code>100</code>, is duplicated because of this. Using a single array, it's impossible to remove an element without filling the new gap with some value.
You could override it with a dummy value, such as <code>-1</code>, but this solution isn't very valid. This is eliminated by <a href="#using-two-arrays">Using Two Arrays</a>.
<h2 id="systemarraycopy">System.arraycopy</h2>
A shorthand way of doing the exact same thing as before but in a single line of code is with the <code>System.arraycopy()</code> method:
<pre><code class="hljs">public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
</code></pre>
The method accepts a source array and the position from which to start copying. It also accepts a destination array and the position into which to start copying. The final argument is the number of elements to copy from the source array.
The <code>arraycopy</code> is generally used to copy contents from some source array into some destination array. Though, we can also copy an array, or a part of it, into itself. This allows us to shift a part of it to the left like last time:
<pre><code class="hljs">int[] array = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int index = 3;
</code></pre>
To remove the element, we only need to write this one line of code:
<pre><code class="hljs">System.arraycopy(array, index + 1, array, index, array.length - index - 1);
</code></pre>
The method will copy all elements from the source array (<code>array</code>) starting one position right of the <code>index</code>. The elements will be copied into the same array (<code>array</code>) starting exactly at <code>index</code>. The result will be a perceived shifting of all elements right of the element we wanted to remove.
If we printed the result, we would still see the element <code>100</code> being duplicated for the same reason as in the previous section.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we showed a few ways of removing array elements. Some are quick and dirty, whereas some require additional overhead such as using additional libraries. It's always best to think about these things beforehand to get the idea of what kind of approach is right for any given situation.
The list of techniques shown in this tutorial is by no means exhaustive. There are plenty of ways to get creative in programming so we're sure you can find some other interesting approaches to remove elements from arrays.

Luka Čupić

In this tutorial, we'll showcase examples of how to remove an element from an array in Java using two arrays, ArrayUtils.remove(), a for loop and System.arraycopy().

Remove Element from an Array in Java

<h2 id="introduction">Introduction</h2>
JavaScript is a dynamically typed language, meaning that the interpreter determines the type of the variable at runtime. In practice, this allows us to use the same variable to store different types of data in the same code. It also means that without documentation and consistency, we do not always know the type of a variable in our code when we use it.
Operating on a string or array when we expect a number can bring strange results in our code. In this article, we'll look at various functions that can help determine if a variable we are using is a number.
Strings that contain numbers like &quot;10&quot; should not be accepted. In JavaScript, special values like <code>NaN</code>, <code>Infinity</code> and <code>-Infinity</code> are numbers too - though, we'll be ignoring those values.
With these requirements, the best function to use is the <a href="#usingthenumberisfinitefunction"><code>isFinite()</code></a> function from the built-in <code>Number</code> object.
However, developers have commonly used other functions for this purpose, particularly <code>Number.isNaN()</code> and the <code>typeof()</code> function.
Let's create a few variables for testing:
<pre><code class="hljs">let intVar = 2;
let floatVar = 10.5;
let stringVar = &#x27;4&#x27;;
let nanVar = NaN;
let infinityVar = Infinity;
let nullVar = null;
let undefinedVar = undefined;
</code></pre>
<h2 id="usingthenumberisfinitefunction">Using the Number.isFinite() function</h2>
The <code>Number.isFinite()</code> function checks if the variable is a number, but also checks if it's a finite value. Therefore, it returns <code>false</code> on numbers that are <code>NaN</code>, <code>Infinity</code> or <code>-Infinity</code>.
Let's test it out on the variables we've defined above:
<pre><code class="hljs">&gt; Number.isFinite(intVar);
true
&gt; Number.isFinite(floatVar);
true
&gt; Number.isFinite(stringVar);
false
&gt; Number.isFinite(nanVar);
false
&gt; Number.isFinite(infinityVar);
false
&gt; Number.isFinite(nullVar);
false
&gt; Number.isFinite(undefined);
false
</code></pre>
It's exactly what we wanted. The special non-finite numbers are ignored, as well as any variable that isn't a number type.
If you'd like to check if a variable is a number, your best bet is to use the <code>Number.isFinite()</code> function.
<h2 id="usingthenumberisnanfunction">Using the Number.isNaN() Function</h2>
The standard <code>Number</code> object has an <code>isNaN()</code> method. It takes one argument, and determines if its value is <code>NaN</code>. Since we want to check if a variable is a number, we will use the not operator, <code>!</code>, in our checks.
Now let's check if the not operator and <code>Number.isNaN()</code> function can filter only numbers:
<pre><code class="hljs">&gt; !Number.isNaN(intVar);
true
&gt; !Number.isNaN(floatVar);
true
&gt; !Number.isNaN(stringVar);
true # Wrong
&gt; !Number.isNaN(nanVar);
false
&gt; !Number.isNaN(infinityVar);
true # Wrong
&gt; !Number.isNaN(nullVar);
true # Wrong
&gt; !Number.isNaN(undefinedVar);
true # Wrong
</code></pre>
This method is a fairly permissive as it accepts values that are not numbers at all. This method is best suited for when you know you have a number and would to check if it is a <code>NaN</code> value, not for general number checking.
<h2 id="usingthetypeoffunction">Using the typeof() function</h2>
The <code>typeof()</code> function is a global function that accepts a variable or value as an argument and returns a string representation of its type. JavaScript has 9 types in total:
<ul>
<li><code>undefined</code></li>
<li><code>boolean</code></li>
<li><code>number</code></li>
<li><code>string</code></li>
<li><code>bigint</code></li>
<li><code>symbol</code></li>
<li><code>object</code></li>
<li><code>null</code> (<code>typeof()</code> shows as object)</li>
<li><code>function</code> (a special type of object)</li>
</ul>
To verify if a variable is a number, we simply we need to check if the value returned by <code>typeof()</code> is <code>&quot;number&quot;</code>. Let's try it out on test variables:
<pre><code class="hljs">&gt; typeof(intVar) == &#x27;number&#x27;;
true
&gt; typeof(floatVar) == &#x27;number&#x27;;
true
&gt; typeof(stringVar) == &#x27;number&#x27;;
false
&gt; typeof(nanVar) == &#x27;number&#x27;;
true # Wrong
&gt; typeof(infinityVar) == &#x27;number&#x27;;
true # Wrong
&gt; typeof(nullVar) == &#x27;number&#x27;;
false
&gt; typeof(undefined) == &#x27;number&#x27;;
false
</code></pre>
The <code>typeof()</code> function performs much better than <code>Number.isNaN()</code>. It correctly determines that a string variable, <code>null</code> and <code>undefined</code> are not numbers. However, it returns true for <code>NaN</code> and <code>Infinity</code>.
While that is the technically correct result, <code>NaN</code> and <code>Infinity</code> are special number values, for most use cases we would prefer to ignore them.
<h2 id="conclusion">Conclusion</h2>
In this article, we learned how to check if a variable in JavaScript is a number. The <code>Number.isNaN()</code> function is only suitable if we know our variable is a number and need to verify if it specifically <code>NaN</code> or otherwise.
The <code>typeof()</code> function is suitable if your code can work with <code>NaN</code>, <code>Infinity</code> or <code>-Infinity</code> as well as other numbers.
The <code>Number.isFinite()</code> method captures all the finite numbers and was most appropriate for our requirements.

Marcus Sanatan

In this tutorial, we'll be covering how to check if a variable is a number in JavaScript. We'll use the isNan(), typeOf() and isFinite() functions to do that.

JavaScript: Check if Variable is a Number

<h2 id="introduction">Introduction</h2>
Python's built-in sequence representation is a list, defined as a heterogeneous sequence of elements, where each element has a definitive index in the sequence.

 <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">
 Note: Heterogeneous sequence means that one list can contain elements of different types.

 </div>
 </div>
 </div>
 To use arrays, you'd have to import the <code>array</code> module, which does ship with Python itself, but lists are far more commonly used.

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: To learn more about lists in Python, read our <a target="_blank" href="https://stackabuse.com/guide-to-lists-in-python/">&quot;Guide to Lists in Python&quot;</a>

 </div>
 </div>
 </div>
 Additionally - since the list syntax looks a lot like the syntax you'd use to define arrays in other programming languages - the terms &quot;array&quot; and &quot;list&quot; are oftentimes used interchangeably, even though they're not the same data structure.

 <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">
 Note: It's worth noting that many of these methods work both for an array and a list!

 </div>
 </div>
 </div>
 <blockquote>
In this article, we'll go through some common ways for removing elements from Python arrays/lists.
</blockquote>
<h2 id="approach1usingremovemethod">Approach #1 - Using remove() Method</h2>
We can use the <code>remove()</code> method on any array or list in Python. To use it, we can simply pass the value of the element we want to remove. Let's imagine we have the following array:
<pre><code class="hljs">array = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
</code></pre>
To remove, say, element <code>40</code>, we would simply write:
<pre><code class="hljs">array.remove(40)
</code></pre>
The result is the same array without the value <code>40</code>:
<pre><code class="hljs">[10, 20, 30, 50, 60, 70, 80, 90, 100]
</code></pre>
<h2 id="approach2usingpopmethod">Approach #2 - Using pop() Method</h2>
Another way we can remove elements from list/array in Python is by using the <code>pop()</code> method. It accepts the index of the element we want to remove. If we had the same array/list as before (with values from 10 to 100), we could write something like the following:
<pre><code class="hljs">index = 3
array.pop(index)
</code></pre>
If we printed the result of the <code>pop()</code> method, it would be the value <code>40</code>:
<pre><code class="hljs">[10, 20, 30, 50, 60, 70, 80, 90, 100]
</code></pre>
Similarly to how <code>pop()</code> works in the stack data structure, here <code>pop()</code> also returns the value that it had just removed.

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: To learn more about stacks in Python, read our article <a target="_blank" href="https://stackabuse.com/stacks-and-queues-in-python/">&quot;Stacks and Queues in Python&quot;</a>

 </div>
 </div>
 </div>
 The only difference is that with arrays, we can remove an arbitrary element. With stacks, only the top element (i.e. the last one added) can ever be removed.
<h2 id="approach3usingdelkeyword">Approach #3 - Using del Keyword</h2>
<code>del</code> is a Python keyword used for deleting objects. Its exact behavior changes depending on the context, so we can also use it to remove list elements.

 <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: Arrays don't support the <code>del</code> keyword!

 </div>
 </div>
 </div>
 Once again, let's take the same array and index as before:
<pre><code class="hljs">array = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
index = 3
</code></pre>
To remove the element at index <code>3</code>, we simply type the following:
<pre><code class="hljs">del array[index]
</code></pre>
If we now printed the contents of our array, we would get the following output:
<pre><code class="hljs">[10, 20, 30, 50, 60, 70, 80, 90, 100]
</code></pre>
<h2 id="approach4usingnumpyarrays">Approach #4 - Using numpy Arrays</h2>
NumPy arrays are commonly used (especially in machine learning), so let's show one of the ways to remove an element from a <code>numpy</code> array. Before using <code>numpy</code>, it is necessary to import it:
<pre><code class="hljs">import numpy as np
</code></pre>
To create a <code>numpy</code> array, we can wrap our current list using <code>np.array()</code> as such:
<pre><code class="hljs">a = np.array(array)
</code></pre>
Alternatively, we could also declare a new array inside the method call itself:
<pre><code class="hljs">a = np.array([10, 20, 30, 40, 50, 60, 70, 80, 90, 100])
</code></pre>
Now to remove an element at index <code>3</code>, we use the following code:
<pre><code class="hljs">index = 3
a = np.delete(a, index)
</code></pre>
<code>delete()</code> is a static method declared in the <code>numpy</code> module. It accepts the array and the index of the element to remove.
The method returns a new array without the removed element:
<pre><code class="hljs">[10, 20, 30, 50, 60, 70, 80, 90, 100]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
There are different ways to remove a list element in Python. Sometimes we might want to remove an element by index and sometimes by value. Sometimes we're using Python's default array and sometimes a <code>numpy</code> array.
In all these cases, it's good to have multiple options to help us decide which of the techniques to use.

Dimitrije Stamenic

In this tutorial, we'll showcase examples of how to remove an element from an array in Python using remove(), pop(), the del keyword, and Numpy.