In this tutorial, we'll take a look at how to reverse an array in JavaScript. There are a few ways to do this, and figuring out which one you'll want to employ typically depends on your personal preference.
We'll be reversing these two arrays:
<pre><code class="hljs">let numArr = [1, 2, 3, 4, 5]
let strArr = [&#x27;Java&#x27;, &#x27;Python&#x27;, &#x27;JavaScript&#x27;]
</code></pre>
<h2 id="usingarrayreverse">Using Array.reverse()</h2>
The easiest and simplest way to reverse an array is via the <code>reverse()</code> method:
<pre><code class="hljs">let numArrReversed = numArr.reverse();
let strArrReversed = strArr.reverse();

console.log(numArrReversed);
console.log(strArrReversed);
</code></pre>
We've created two new variables to point to the resulting arrays:
<pre><code class="hljs">[ 5, 4, 3, 2, 1 ]
[ &#x27;JavaScript&#x27;, &#x27;Python&#x27;, &#x27;Java&#x27; ]
</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: The <code>reverse()</code> method reverses the array in-place. This means that the original <code>num_array</code> and <code>string_array</code> are reversed and the original sequence is lost.

 </div>
 </div>
 </div>
 You don't need to create a new variable to store a pointer to these arrays in memory, since the original pointers already point to the reversed arrays:
<pre><code class="hljs">numArr.reverse();
strArr.reverse();

console.log(numArr);
console.log(strArr);
</code></pre>
This also results in:
<pre><code class="hljs">[ 5, 4, 3, 2, 1 ]
[ &#x27;JavaScript&#x27;, &#x27;Python&#x27;, &#x27;Java&#x27; ]
</code></pre>
However, it's still common practice to &quot;assign&quot; the result to a new variable to indicate a changed state, or to at least assign a more indicative name to the transformed array, such as <code>array_reversed</code>.
<h2 id="reversinganarrayfunctionally">Reversing an Array Functionally</h2>
Functional programming is a wonderful addition to most imperative programming languages. Functional constructs allow us to perform various, even complex, transformative operations on objects and sequences with intuitive and simple instructions.
Many developers simply love using functional constructs when they can, so it's no surprise that reversing an array is commonly done via functional constructs as well. This approach allows you to also pipe in another transformation alongside reversal, such as adding or changing the elements as well.
To reverse a array functionally in JavaScript, we'll leverage the spread operator and the <code>map()</code> function:
<pre><code class="hljs">// Preserves original array
let numArrReversed = numArr.map(numArr.pop, [...numArr]);

// Doesn&#x27;t preserve original array
let strArrReversed = [...strArr].map(strArr.pop, strArr);
</code></pre>
The <code>map()</code> method maps each popped element (removed last element) from the <code>numArr</code> and pushes it into a new array, which is created as a copy of <code>numArr</code>. By removing the last element and adding it as the first into a new array, we create a new reversed array.
The first approach deals with a frozen copy of the <code>numArr</code> object, and thus doesn't modify the original array.
In the second approach, we modify the original array as we're using the reference to the original array in the <code>map()</code> method, even though we create a copy of the array beforehand:
<pre><code class="hljs">console.log(&#x27;Original num_array: &#x27; + numArr);
console.log(&#x27;Original string_array: &#x27; + strArr);

console.log(&#x27;Reversed num_array: &#x27; + numArrReversed);
console.log(&#x27;Reversed string_array: &#x27; + strArrReversed);
</code></pre>
Thus, when all is said and done, the <code>num_array</code> remains unchanged, while <code>string_array</code> is gone:
<pre><code class="hljs">Original num_array: 1,2,3,4,5
Original string_array: 
Reversed num_array: 5,4,3,2,1
Reversed string_array: JavaScript,Python,Java
</code></pre>
<h2 id="reversinganarraywithaforloop">Reversing an Array with a for Loop</h2>
Finally, the good old way is to simply run the array through a <code>for</code> loop in backwards order, and add each element into a new array.
This works great for creating a new reversed array, but won't reverse the old one in-place. If you'd like to reverse it in-place, you'll want to use the <code>unshift()</code> method to add elements at the start of the array, while splicing (in-place operation) continually:
<pre><code class="hljs">function reverse(array) {
 let newArr = [];
 for(i = array.length-1; i &gt;= 0; i--) {
 newArr.push(array[i]);
 }
 return newArr;
}

function reverseInPlace(array) {
 for(i = 0; i &lt; array.length; i++) {
 let tmp = array.splice(i, 1)[0];
 array.unshift(tmp);
 }
 return array;
}
</code></pre>
You can use these methods as:
<pre><code class="hljs">let numArrReversed = reverseInPlace(numArr);
let strArrReversed = reverse(strArr);

console.log(&#x27;Original num_array: &#x27; + numArr);
console.log(&#x27;Original string_array: &#x27; + strArr);

console.log(&#x27;Reversed num_array: &#x27; + numArrReversed);
console.log(&#x27;Reversed string_array: &#x27; + strArrReversed);
</code></pre>
Which results in:
<pre><code class="hljs">Original num_array: 5,4,3,2,1
Original string_array: Java,Python,JavaScript
Reversed num_array: 5,4,3,2,1
Reversed string_array: JavaScript,Python,Java
</code></pre>

David Landup

In this guide, we'll take a look at how to reverse an array or list in JavaScript, using the reverse() method, functional programming and a manual for loop - both in-place and out-of-place.

Reverse an Array in JavaScript

<h2 id="introduction">Introduction</h2>
In this guide, we'll take a look at how to harness the power of iterators using Python's <code>itertools</code> module.
The <code>itertools</code> module provides us with an interface for creating fast and memory-efficient iterators. These iterators can be infinite, combinatorial, or terminating.
<h2 id="iteratorvsiterable">Iterator vs Iterable</h2>
An Iterator is an intelligent pointer which can guide (iterate) us through the items of an Iterable (container) in a certain order. Consider a list of colors, as well as a list of integers:
<pre><code class="hljs">colors = [&#x27;red&#x27;, &#x27;blue&#x27;, &#x27;pink&#x27;]
ints = [1, 3, 5, 4, 2]
</code></pre>
Even though we defined these lists in a particular order, they don't have to be stored in the same order when placed in memory:
<pre><code class="hljs">iterators: it1 it2 
 V V
memory: red 4 2 blue 1 3 pink 5
</code></pre>
If we went through memory in-order, we'd get that the second element of the <code>colors</code> array is <code>4</code>, which is why we need iterators.
The iterator's job is to find the next element of the list in the memory, no matter where it is. This is done via the <code>next()</code> method which returns the next element that the iterator points to. <code>it1</code> would scour through the memory it has access to and return <code>blue</code> while <code>it2</code> would return <code>3</code>.
A great feature of iterators is that we can define how they search for elements in their respective iterables. We can, for instance, ask it to skip all odd numbers and return a subset. This is achieved by implementing a custom <code>next()</code> method or by using the built-in <code>itertools</code> that allow us to generate specific iterators for iterating through objects in various ways.
The iteration tools we'll be going over are:
<ul>
<li><code>compress()</code></li>
<li><code>dropwhile()</code></li>
<li><code>takewhile()</code></li>
<li><code>groupby()</code></li>
</ul>
Each of these iterator-building functions (they generate iterators) can be used on their own, or combined.
<h2 id="thecompressfunction">The compress() Function</h2>
The <code>compress(data, selector)</code> function creates an iterator that selectively picks the values from <code>data</code> according to the boolean list - <code>selector</code>. If a value from <code>data</code> corresponds to a <code>True</code> value in the <code>selector</code> list, it will be picked, and skipped otherwise.
If <code>data</code> and <code>selector</code> are not of the same size, <code>compress()</code> stops when either the <code>data</code> or <code>selector</code> lists have been exhausted:
<pre><code class="hljs"># Importing the compress tool
from itertools import compress

cars = [&#x27;Audi&#x27;, &#x27;Volvo&#x27;, &#x27;Benz&#x27;, 
 &#x27;BMW&#x27;, &#x27;Nissan&#x27;, &#x27;Mazda&#x27;,
 &#x27;Ford&#x27;]
 
selector = [True, True, False, False, 
 False, True, False]

# This makes an iterator that filters elements, 
# from data, for which selector values amount to True
my_cars = compress(cars, selector)

for each in my_cars:
 print(each)
</code></pre>
This results in:
<pre><code class="hljs">Audi
Volvo
Mazda
</code></pre>
The <code>selector</code> can also be a list of <code>1</code>'s and <code>0</code>'s, or any truthy/falsy values.
You typically acquire these boolean lists through some sort of condition, such as:
<pre><code class="hljs">int_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
boolean_list = [True if x % 2 == 0 else False for x in int_list]

# OR

boolean_list = [1 if x % 2 == 0 else 0 for x in int_list]

print(boolean_list)
</code></pre>
Here, we've generated a <code>boolean_list</code> with a <code>True</code> for each even number:
<pre><code class="hljs">[False, True, False, True, False, True, False, True, False, True]

# OR

[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
</code></pre>
Typically, to make things shorter - you'll use the <code>compress()</code> tool, as well as other tools, without assigning the results to a new variable:
<pre><code class="hljs">import itertools

word = &#x27;STACKABUSE&#x27;
selector = [1, 0, 1, 0, 0, 0, 0, 1, 1, 1]

for each in itertools.compress(word, selector ):
 print(each)
</code></pre>
The result is:
<pre><code class="hljs">S
A 
U 
S 
E
</code></pre>
We can additionally, technically, mix-and-match the values in the <code>selector</code> with any truthy/falsy values:
<pre><code class="hljs">from itertools import compress

cars = [&#x27;Audi&#x27;, &#x27;Volvo&#x27;, &#x27;Benz&#x27;,
 &#x27;BMW&#x27;, &#x27;Nissan&#x27;, &#x27;Mazda&#x27;, &#x27;Ford&#x27;]

# Empty string is falsy, non empty is truthy
selector = [True, 1, 0, 0, &#x27;&#x27;, 1, &#x27;string&#x27;]

for each in compress(cars, selector):
 print(each)
</code></pre>
Output is:
<pre><code class="hljs">Audi
Volvo
Mazda
Ford
</code></pre>
Though, it's worth noting that mixing apples and pears like this is not advised.
<h2 id="thedropwhilefunction">The dropwhile() Function</h2>
The <code>dropwhile(criteria, sequence)</code> function creates an iterator that drops (skips over) every element in the <code>sequence</code>, and returns <code>True</code> when passed through the <code>criteria</code> function.
The <code>criteria</code> function is typically a lambda function but doesn't have to be. Usually, if it's a simple function, it's shortened to a lambda, while complex functions aren't:
<pre><code class="hljs">from itertools import dropwhile

int_list = [0, 1, 2, 3, 4, 5, 6]
result = list(dropwhile(lambda x : x &lt; 3, int_list))

print(result)
</code></pre>
Given this lambda function, every element with a value lesser than <code>3</code> will return <code>True</code>, so all elements lesser than 3 are skipped over. They're dropped while criteria is true:
<pre><code class="hljs">[3, 4, 5, 6]
</code></pre>
Instead of a lambda function, we can define a more complicated one and pass in a reference to it instead:
<pre><code class="hljs">from itertools import dropwhile

def doesnt_contain_character(str):
 substring = &#x27;a&#x27;
 if substring in str:
 return False
 else:
 return True
 
string_list = [&#x27;lorem&#x27;, &#x27;ipsum&#x27;, &#x27;dolor&#x27;, &#x27;sit&#x27;, &#x27;amet&#x27;]
print(list(dropwhile(doesnt_contain_character, string_list)))
</code></pre>
For instance, this method checks if a string doesn't contain a <code>substring</code> - in this case, just <code>a</code>. If the given string contains <code>a</code>, <code>False</code> is returned and if it doesn't contain it - <code>True</code> is returned. Thus, all words in the sequence, until <code>amet</code> return <code>True</code>, and are dropped from the result:
<pre><code class="hljs">[&#x27;amet&#x27;]
</code></pre>
However, all elements after the criteria fails will be included. In our case, everything after the <code>'amet'</code> element will be included, regardless of the <code>criteria</code>:
<pre><code class="hljs">from itertools import dropwhile

def doesnt_contain_character(str):
 substring = &#x27;a&#x27;
 if substring in str:
 return False
 else:
 return True
 
string_list = [&#x27;lorem&#x27;, &#x27;ipsum&#x27;, &#x27;dolor&#x27;, &#x27;sit&#x27;, &#x27;amet&#x27;, &#x27;a&#x27;, &#x27;b&#x27;]
print(list(dropwhile(doesnt_contain_character, string_list)))
</code></pre>
This drops the elements until <code>'amet'</code> and stops dropping them after that:
<pre><code class="hljs">[&#x27;amet&#x27;, &#x27;a&#x27;, &#x27;b&#x27;]
</code></pre>
<h2 id="thetakewhilefunction">The takewhile() Function</h2>
The <code>takewhile(criteria, sequence)</code> function is the polar opposite of <code>dropwhile()</code>. It preserves all elements for which the function doesn't fail. Let's rewrite the previous example to check whether a word contains a certain character:
Let's check it out:
<pre><code class="hljs">from itertools import takewhile

def contains_character(str):
 substring = &#x27;o&#x27;
 if substring in str:
 return True
 else:
 return False
 
string_list = [&#x27;lorem&#x27;, &#x27;ipsum&#x27;, &#x27;dolor&#x27;, &#x27;sit&#x27;, &#x27;amet&#x27;]
print(list(takewhile(contains_character, string_list)))
</code></pre>
<pre><code class="hljs">[&#x27;lorem&#x27;]
</code></pre>
Since the <code>criteria</code> fails on the second element, even though <code>'dolor'</code> also contains the character <code>o</code> - it's not taken into consideration.
<h2 id="thegroupbyfunction">The groupby() Function</h2>
The <code>groupby(iterable, key_function)</code> is a function that generates an iterator that bundles together consecutive elements which belong to the same group. Whether an element belongs to a group or not depends on the <code>key_function</code>. It computes the key value for each element, the key value in this case being a specific group's id.
A cluster is ended, and a new one is created when the <code>key_function</code> returns a new id, even if it's been seen before.
If the <code>key_function</code> is not specified, then it defaults to the identity function. However, it's worth noting that even with duplicate values - they won't be clustered together if they're separated by another cluster:
<pre><code class="hljs">from itertools import groupby

word = &quot;aaabbbccaabbbbb&quot;

for key, group in groupby(word):
 print(key, list(group))
</code></pre>
Intuitively, you might expect all instances of <code>a</code> and <code>b</code> to be clustered together, but since there are clusters between them - they're separated into clusters of their own:
<pre><code class="hljs">a [&#x27;a&#x27;, &#x27;a&#x27;, &#x27;a&#x27;] 
b [&#x27;b&#x27;, &#x27;b&#x27;, &#x27;b&#x27;] 
c [&#x27;c&#x27;, &#x27;c&#x27;] 
a [&#x27;a&#x27;, &#x27;a&#x27;] 
b [&#x27;b&#x27;, &#x27;b&#x27;, &#x27;b&#x27;, &#x27;b&#x27;, &#x27;b&#x27;]
</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: The only way to avoid this is to presort the iterable based on the keys.

 </div>
 </div>
 </div>
 Now, let's define a custom <code>key_function</code>, which can be a lambda or dedicated function:
<pre><code class="hljs">from itertools import groupby

some_list = [(&quot;Animal&quot;, &quot;cat&quot;), 
 (&quot;Animal&quot;, &quot;dog&quot;),
 (&quot;Animal&quot;, &quot;lion&quot;),
 (&quot;Plant&quot;, &quot;dandellion&quot;),
 (&quot;Plant&quot;, &quot;blumen&quot;)]
 
for key, group in groupby(some_list, lambda x : x[0]):
 key_and_group = { key : list(group) }
 print(key_and_group)
</code></pre>
We've made a list of tuples, where the first element denotes a general categorization - whether an entry is an Animal or a Plant, and the second element denotes either an animal or plant name.
Then, we've grouped these based on the first element, and printed each element of the sequence:
<pre><code class="hljs">{&#x27;Animal&#x27;: [(&#x27;Animal&#x27;, &#x27;cat&#x27;), (&#x27;Animal&#x27;, &#x27;dog&#x27;), (&#x27;Animal&#x27;, &#x27;lion&#x27;)]}
{&#x27;Plant&#x27;: [(&#x27;Plant&#x27;, &#x27;dandellion&#x27;), (&#x27;Plant&#x27;, &#x27;blumen&#x27;)]}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at the <code>compress()</code>, <code>dropwhile()</code>, <code>takewhile()</code> and <code>groupby()</code> iteration tools in Python's built-in <code>itertools</code> module.
If you want to learn more about the <code>itertools</code> module and iterators in general, feel free to check our other guides:
<ul>
<li><a target="_blank" href="https://stackabuse.com/pythons-iteration-tools-filter-islice-map-and-zip">Python's Iteration Tools: filter(), islice(), map() and zip()</a></li>
<li><a target="_blank" href="https://stackabuse.com/pythons-itertools-count-cycle-and-chain">Python's itertools – count(), cycle() and chain()</a></li>
</ul>

Vladimir Batoćanin

Ognjen Jankovic

In this guide, we'll dive into how to use the compress(), dropwhile(), takewhile() and groupby() functions from Python's itertools module.

Python's itertools - compress(), dropwhile(), takewhile() and groupby()

Arpendu Kumar Garai

Learn how to send HTTP requests using the Spring RestTemplate, how to set pre-defined headers, and set up a mutual TLS certificate validation.

Spring Boot: Guide to RestTemplate

Lazar Ristic

In this tutorial, we'll be taking a deep dive into JavaScript classes and how to implement them to achieve OOP functionality, with practical examples.

Guide to Understanding Classes in JavaScript

<h2 id="introduction">Introduction</h2>
Web applications typically receive user input in some form - and with any input, validation is important. Making sure that form fields contain valid data, or that they contain any data at all is one of the first checks you can do.
When a user uploads files - you'll want to check whether these files are empty, not just if they exist or not. Additionally, since Node supports server-side development and can work with the file system, you'll find yourself working with files and directories all the time, especially if you're creating a CLI application.
In this guide, we'll take a look at how to check if a file or directory is empty, using Node.js.

 <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: This task can be observed through two lenses - receiving a file from the front-end and validating it, or working with the file system regardless of potentially non-existent front-end. We'll be taking a look at both.

 </div>
 </div>
 </div>
 <h2 id="checkifafileisselectedwithjavascript">Check if a File is Selected With JavaScript</h2>
Vanilla JavaScript isn't up for the task of checking whether a file is empty or not, since it can check whether a form has a file attached to it, but can't process the file itself.
We'll start from there - checking if the file is selected from the file system and attached to the form. Let's create a simple form on the front-end
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html lang=&quot;en&quot;&gt;
&lt;head&gt;
 &lt;!-- Meta tags --&gt;
&lt;/head&gt;
&lt;body&gt;
 &lt;form enctype=&quot;multipart/form-data&quot;&gt;
 &lt;input type=&quot;file&quot; name=&quot;file&quot; id=&quot;file&quot;&gt;
 &lt;button type=&quot;submit&quot; onclick=&quot;checkFile()&quot;&gt;Submit&lt;/button&gt; 
 &lt;/form&gt;
 
 &lt;script src=&quot;script.js&quot;&gt;&lt;/script&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>
The page contains a <code>&lt;form&gt;</code> that accepts a <code>multipart</code> file, through an <code>&lt;input type=&quot;file&quot;&gt;</code>. Once the button is pressed, the <code>checkFile()</code> function is triggered, from the imported <code>script.js</code>:
<pre><code class="hljs">function checkFile() {
 let fileInputField = document.getElementById(&quot;file&quot;);
 if (fileInputField.files.length == 0) {
 alert(&quot;Please select a file!&quot;)
 }
}
</code></pre>
We get our <code>input</code> element with <code>document.getElementById()</code> and check the length of the <code>files</code> property, which an <code>input</code> of type <code>file</code> has. If it's empty, we alert the user that no file has been selected.
Once we're sure that the user has supplied a file, we can check whether they've supplied a non-empty file.
<h2 id="thefsmodule">The fs Module</h2>
<a rel="nofollow noopener" target="_blank" href="https://nodejs.org">Node.js</a> is a JavaScript runtime environment that executes JavaScript code outside of the browser. This gives us the ability to interface with the underlying operating system and file system as well. The built-in <code>fs</code> (File System) module works wonders for us in this case.
We'll be relying on the <code>fs.readFile()</code> and <code>fs.readdir()</code> methods.
<h2 id="checkifafileisemptywithnodejs">Check if a File is Empty with Node.js</h2>
Once the user sends a file through a form to your back-end, say, to the <code>/upload</code> endpoint, it's time to check whether the file is empty.
The easiest way to check is to stream the data within the file and check its length. If there are 0 bytes in the file, or rather, if the <code>length</code> of the data is equal to <code>0</code>, the file is empty:
<pre><code class="hljs">router.post(&#x27;/upload&#x27;, function(req, res) {
 const fs = require(&#x27;fs&#x27;);
 const multiparty = require(&#x27;multiparty&#x27;);
 let form = new multiparty.Form();
 form.parse(req, function(err, fields, files) {
 let file = files.keySelect[0];
 fs.readFile(file, function(err, data) {
 if (data.length == 0) {
 return res.status(422).json({message : &quot;File is empty! Unprocessable Entity.&quot;});
 }
 })
 });
 return res.status(200).json({message: &quot;Success&quot;});
});
</code></pre>
We've used the <a target="_blank" rel="nofollow noopener" href="https://www.npmjs.com/package/multiparty"><code>multiparty</code> module</a> to obtain the file from the form, though, this step can be done with various other libraries as well, such as <a target="_blank" href="https://stackabuse.com/handling-file-uploads-in-node-js-with-expres-and-multer">Multer</a> or <a target="_blank" href="https://www.npmjs.com/package/formidable">Formidable</a>.
With <code>multiparty</code>, we can create an instance of a form and parse it, passing the <code>req</code> to it, which is our <code>formData</code> sent from the front end. The <code>keySelect()</code> method returns all files sent via the form, but since our form only accepts one and we're only expecting one - we're accessing it via <code>[0]</code>. Using the <code>fs.readFile()</code> method, we're reading the file and unpacking its <code>data</code>. If this <code>data</code> has a <code>length</code> of <code>0</code> - the file is empty, and we return a “422 Unprocessable Entity” status code.
If you're not dealing with a form-provided file, and already have the name in mind, you can skip this process entirely and read the file directly:
<pre><code class="hljs">fs.readFile(&quot;myFile.txt&quot;, function(err, data) {
 if (data.length == 0) {
 console.log(&quot;File is empty!&quot;);
 } else {
 console.log(&quot;File is not empty!&quot;);
 }
})
</code></pre>
<h2 id="checkifadirectoryisemptywithnodejs">Check if a Directory is Empty with Node.js</h2>
When checking if a directory is empty, we can use the <code>readDir()</code> method:
<pre><code class="hljs">fs.readdir(directoryName, function(err, data) {
 if (data.length == 0) {
 console.log(&quot;Directory is empty!&quot;);
 } else {
 console.log(&quot;Directory is not empty!&quot;);
 }
})
</code></pre>
These two methods are completely equivalent in syntax (except for the name of the method), so everything that applies to one, applies to the other. If the <code>data</code> of the directory is equal to <code>0</code>, it's empty.
This is typically coupled with <a target="_blank" href="https://stackabuse.com/node-list-files-in-a-directory">listing files in a directory</a>.
<h2 id="conclusion">Conclusion</h2>
Working with files is commonplace for Node projects, as it's meant to be used on the server-side. One of the basic checks you can perform to validate files is to check whether they're empty or not.
In this guide, we've taken a look at how to check if a file or directory is empty with Node.js.

In this guide, we'll be taking a look at how to check if a file or directory is empty or not in Node.js, both when provided from a form, as well as for back-end work.

Node: Check if File or Directory is Empty

Guest Contributor

In this guide, we'll take a look at how to return HTTP status codes in Spring Boot applications with @ResponseStatus, ResponseEntity and ResponseStatusException.

How to Return HTTP Status Codes in a Spring Boot Application

<h2 id="introduction">Introduction</h2>
String manipulation in Python is achieved through a set of built-in methods, which return new strings since they're immutable. In this guide, we will look at methods to strip whitespace (in other languages it's also known as trimming) from strings in Python.
<h2 id="trimmethodsstrip">Trim Methods - strip()</h2>
In Python, the stripping methods are capable of removing leading and trailing spaces and specific characters. The leading and trailing spaces, include blanks, tabs (<code>\t</code>), carriage returns (<code>\r</code>, <code>\n</code>) and the other lesser-known whitespace characters that can be found <a href="https://en.wikipedia.org/wiki/Whitespace_character" target="_blank" rel="nofollow noopener">here</a>.
There are three ways in which the spaces or specific characters can be stripped from strings:
<ul>
<li><code>strip(chars)</code> - The vanilla strip method strips both the left and right sides of the string of the white spaces or characters mentioned.</li>
<li><code>lstrip(chars)</code> - The 'l' in the method's name corresponds to left, and this method strips white spaces or characters mentioned to the left of the input string.</li>
<li><code>rstrip(chars)</code> - The 'r' in the method's name correspond to right, and you guessed it right - it strips the characters to the right of the input string</li>
</ul>
If characters are to be stripped from the string, they need to be passed as an argument to the method, say <code>input.rstrip(&quot;abc&quot;)</code>. This is an optional argument, by default the functions strip whitespace as that's the most common usage.
<h2 id="trimmingstrippingwhitespacefromstrings">Trimming/Stripping Whitespace from Strings</h2>
Now that we are clear of what these methods are capable of, let's dive into some examples. We have an <code>input</code> and <code>output</code> string. The <code>input</code> variable denotes a string with both trailing and leading spaces, while the <code>output</code> string is a template that we can use to highlight these spaces:
<pre><code class="hljs"># trim.py
input = &quot; Stack Abuse &quot;
output = &quot;|{}|&quot;
# Remove leading spaces or spaces to the left
print(&quot;lstrip() Output:&quot;, output.format(input.lstrip()))
# Remove trailing spaces or spaces to the right
print(&quot;rstrip() Output:&quot;, output.format(input.rstrip()))
# Remove both trailing and leading spaces
print(&quot; strip() Output:&quot;, output.format(input.strip()))
</code></pre>
Once we <code>strip()</code> the <code>input</code> and add that result in-between the pipes (<code>|</code>), any whitespaces left will be very noticeable.
Running this code results in:
<pre><code class="hljs">$ python trim.py
lstrip() Output: |Stack Abuse |
rstrip() Output: | Stack Abuse|
 strip() Output: |Stack Abuse|
</code></pre>
<h2 id="trimmingstrippingspecialcharactersfromstrings">Trimming/Stripping Special Characters from Strings</h2>
Instead of removing only empty characters, it's not uncommon to remove a certain trailing and leading special character. Let's pass in a character argument to the <code>strip()</code> method:
<pre><code class="hljs"># trim_chars.py
input = &quot; ~~ Stack Abuse ~~ &quot;
output = &quot;|{}|&quot;
# Remove leading spaces or spaces to the left
print(&quot;lstrip() Output:&quot;, output.format(input.lstrip(&quot;~ &quot;)))
# Remove trailing spaces or spaces to the right
print(&quot;rstrip() Output:&quot;, output.format(input.rstrip(&quot;~ &quot;)))
# Remove both trailing and leading spaces
print(&quot; strip() Output:&quot;, output.format(input.strip(&quot;~ &quot;)))
</code></pre>
We've passed in the tilde as well as a whitespace (&quot;<code>~ </code>&quot;) as the argument of the <code>strip()</code> methods, removing any occurrence of either of them from the left, right and both sides of the string. It's worth noting that the order of these doesn't matter and that the <code>strip()</code> method doesn't perform pattern matching to remove these. It's conceptually similar to calling the <code>strip()</code> method twice, for each character.
Running this code results in:
<pre><code class="hljs">$ python trim_chars.py
lstrip() Output: |Stack Abuse ~~ |
rstrip() Output: | ~~ Stack Abuse|
 strip() Output: |Stack Abuse|
</code></pre>
<h2 id="usingstriponapandasseries">Using strip() on a Pandas Series</h2>
We can also perform the <code>strip()</code> methods for the a Pandas <code>Series</code>. The trailing spaces and characters for individual cells of the series can be stripped off. One thing to note is that the series needs to be converted to a string series before one performs the <code>strip()</code> operation.

 <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: If you are new to Pandas, read our <a href="/beginners-tutorial-on-the-pandas-python-library#installingpandas" target="_blank">Beginner's Guide to Pandas</a> to learn more about the library and how to set it up. Once Pandas is installed in your system, you can follow along with this code example!

 </div>
 </div>
 </div>
 Consider the following script:
<pre><code class="hljs"># strip_series.py
import pandas as pd

s = pd.Series([&#x27;1. Cell1. ~&#x27;, &#x27;2. Cell2!\n&#x27;])
print(&quot;Before strip():\n&quot;, s)
print(&quot;\nAfter strip():\n&quot;, s.str.strip(&#x27;.\n!~ &#x27;))
</code></pre>
Here, we're creating a series with cells containing special characters and trailing spaces. Via <code>series.str</code>, we can perform a method on each element of the Series. Considering the fact that these are strings, we can run any string method.
That being said, we can easily perform a <code>strip()</code> on each element of the sequence:
<pre><code class="hljs">$ python strip_series.py
Before strip()
 0 1. Cell1. ~
1 2. Cell2!\n
dtype: object
 
After strip()
 0 1. Cell1
1 2. Cell2
dtype: object
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Stripping (or trimming) characters from a string can be quite helpful when cleaning datasets, text files with multiple lines, or even the API responses. The basic but powerful Python methods can even work on Pandas series as well.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

In this tutorial, we'll take a look at Python's strip() method and how we can use it to trim strings, through practical examples.

Guide to Python's strip() Method

In this guide, we'll take a look at how to monitor Node.js applications using Prometheus and Grafana, with practical code and examples.

Node.js Application Monitoring with Prometheus and Grafana

Accidentally forgot to add a file to the <code>.gitignore</code> file and started tracking it with other files? Or perhaps a remote repository already has a file tracked that you've cloned, but would like to stop tracking?
<blockquote>
Just as important as tracking changes is not tracking them in certain cases, lest they change the scale of what you're keeping an eye on. Once a file is tracked, even if you add it to <code>.gitignore</code>, it will still be tracked.
</blockquote>
In this tutorial, we'll take a look at two ways on how to stop tracking a file on Git, after adding it to <code>.gitignore</code>.
Choosing between these two depends on whether you want the file to be kept in the repository or not.
<h2 id="stoptrackingfileandremoveitfromtherepository">Stop Tracking File and Remove it from the Repository</h2>
First, let's go ahead and create a couple of files, add them to the index and commit them to the repository:
<pre><code class="hljs">$ touch file.txt
$ touch file2.txt
$ git add .
$ git commit -m &quot;Initial commit&quot;
</code></pre>
These two files are now tracked, and all changes made to them are relevant in Git's eyes. Though... we've forgotten to add a <code>.gitignore</code> file, and <code>file.txt</code> we don't want to track is already in the repository.
Let's quickly create a <code>.gitignore</code> and add the matcher for <code>file.txt</code> in it:
<pre><code class="hljs">$ touch .gitignore
$ echo &quot;file.txt&quot; &gt;&gt; .gitignore
$ git add .gitignore
$ git commit -m &quot;Adding .gitignore&quot;
</code></pre>
When we make a new change to the file:
<pre><code class="hljs">$ echo &quot;new line&quot; &gt;&gt; file.txt
$ git status
</code></pre>
Even though it's now present in the <code>.gitignore</code> file - the file is still being tracked:
<pre><code class="hljs">Changes not staged for commit:
 (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
 (use &quot;git restore &lt;file&gt;...&quot; to discard changes in working directory)
 modified: file.txt
</code></pre>
We'd like to keep <code>file.txt</code> present on our local system (it &quot;includes important configurations&quot; but since the configurations are machine-specific, it's only applicable to us). To make Git stop tracking a file, while removing it from the Git repository, we'll run the <code>git rm</code> command:
<pre><code class="hljs">$ git rm --cached file.txt
rm &#x27;file.txt&#x27;
</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: The <code>--cached</code> flag removes only the files from the index - the working directory isn't affected at all.

 </div>
 </div>
 </div>
 Let's verify that the Git repository no longer lists this file, while it is still present in the working tree:
<pre><code class="hljs">$ git ls-files 
file2.txt 
.gitignore

$ ls -a
.		.git		file.txt
..		.gitignore	file2.txt
</code></pre>
<h2 id="stoptrackingfilewithoutremovingitfromtherepository">Stop Tracking File Without Removing it from the Repository</h2>
Alternatively, you might want to have the file still present in the repository, for other team members to be able to download - but it's a hassle for you personally to keep tracking changes to it, you can stop tracking it while keeping it in the repository via the <code>git update-index</code> command:
<pre><code class="hljs">$ git update-index --skip-worktree file.txt
$ git status
On branch main
nothing to commit, working tree clean
</code></pre>
This command updates the index and skips over all the files specified. In our case, it updates the index to skip over <code>file.txt</code> and turn tracking off. In that sense - this command can be used individually, separately of the <code>.gitignore</code> file.

 <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: An alternative is the <code>git update-index --assume-unchanged</code> command, in which you tell Git to trust you on your word that the file is unchanged. This is done for huge files that are not supposed to be changed, and are expensive to check for changes constantly. If you use this approach - don't change the file, lest you'll break the feature's intended use and Git will encounter errors while merging. Using <code>--skip-worktree</code> is preferred.

 </div>
 </div>
 </div>
 Let's verify that the file is present both in the repository and our local file system:
<pre><code class="hljs">$ git ls-files
.gitignore
file.txt
file2.txt

$ ls -a
.		.git		file.txt
..		.gitignore	file2.txt
</code></pre>

In this tutorial, we'll take a look at how to stop tracking a file after adding it to .gitignore post-festum, with and without removing it from the repository.