David Landup

In this detailed guide, learn everything you need to know about Spring Data MongoDB's @Aggregation annotation, aggregation pipelines, named and positional arguments as well as sorting and pagination, through practical code.

Spring Data MongoDB - Guide to the @Aggregation Annotation

In this short guide, you'll learn how to select checkbox elements on the page, and check them in JavaScript, with Vanilla JavaScript and jQuery.
We'll be working with this simple checkbox setup:
<pre><code class="hljs">&lt;h1&gt;Check/Select Checkbox&lt;/h1&gt;
&lt;p&gt;Have you taken this test before?&lt;/p&gt;
&lt;input type=&quot;checkbox&quot; id=&quot;takenBefore&quot;&gt;
&lt;label for=&quot;takenBefore&quot;&gt;Yes&lt;/label&gt;

&lt;button id=&quot;button&quot;&gt; Check Checkbox &lt;/button&gt;
</code></pre>
<h2 id="elementcheckedtrue">element.checked = true</h2>
The absolute simplest way to check or select a checkbox is to explicitly set the <code>checked</code> field to <code>true</code>:
<pre><code class="hljs">// Get Element
checkBox = document.getElementById(&#x27;takenBefore&#x27;);
// Set the `checked` field to `true`
checkBox.checked = true
</code></pre>
To demonstrate this, let's attach an event listener to a button, which then programmatically selects/checks the Checkbox for us. This is a benign example, but it does serve the point - you'll be checking/selecting the checkbox based on some action from the user:
<pre><code class="hljs">document.getElementById(&#x27;button&#x27;).addEventListener(&#x27;click&#x27;, event =&gt; {
 checkBox = document.getElementById(&#x27;takenBefore&#x27;);
 checkBox.checked = true
});
</code></pre>
This results in:
<img src="https://s3.stackabuse.com/media/articles/how-to-checkselect-a-checkbox-with-jquery-javascript-1.gif" alt="check checkbox with javascript">
<h2 id="element0checkedtrue">$('#element')[0].checked = true</h2>

 <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: jQuery is a popular JavaScript library, present in many projects around the world. Due to its light weight and features that expand the scope of JavaScript's built-in capabilities - it's become a staple.

 </div>
 </div>
 </div>
 We can use jQuery's selector syntax instead of pure JavaScript's to simplify both the selection of the element and the event listener attached to other elements that lead to the checkbox being selected. If you already have jQuery in your project, it'll net simpler code in the end, though, if this is all you need to do, it's probably not worth importing the library just for this.
<blockquote>
You can import jQuery in your page via a Content Delivery Network (CDN). You can use jQuery's own CDN for importing the library as well.
</blockquote>
<pre><code class="hljs">&lt;script src=&quot;https://code.jquery.com/jquery-3.6.0.min.js&quot;
 integrity=&quot;sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4=&quot; 
 crossorigin=&quot;anonymous&quot;&gt;
&lt;/script&gt;
</code></pre>
Now, with jQuery installed - you can easily just set the <code>checked</code> property to <code>true</code> as before, but with simpler syntax:
<pre><code class="hljs">$(&#x27;#takenBefore&#x27;)[0].checked = true
</code></pre>
Here, we get a jQuery object, not the underlying element with the selector, hence, we'll have to subscript it and get the underlying object to access the <code>checked</code> property with <code>[0]</code>.
In much the same way, if we want to trigger this code based on some other action, such as a button press:
<pre><code class="hljs">$(&#x27;#button&#x27;).on(&#x27;click&#x27;, function() {
 $(&#x27;#takenBefore&#x27;)[0].checked = true
});
</code></pre>
This syntax is fairly simpler than the one we've used before, though, it's functionally equivalent:
<img src="https://s3.stackabuse.com/media/articles/how-to-checkselect-a-checkbox-with-jquery-javascript-2.gif" alt="check checkbox with jquery and javascript">
The downside of this approach is - it's raw. We just utilized the simpler selection syntax, but ultimately just explicitly set the property to <code>true</code> after that. There's another way to set the property, but more implicitly.
<h2 id="elementpropcheckedtrue">$('#element').prop(&quot;checked&quot;, true)</h2>
The <code>prop()</code> function accepts a key-value set of arguments - the name of the property we'd like to access and the value we'd like to assign to it. The method itself performs validation that isn't performed when we explicitly set the property to <code>true</code> like before.
<blockquote>
Generally speaking, if you're already using jQuery, it's advised to use <code>prop()</code> rather than explicitly setting the property, due to the added benefit of validation.
</blockquote>
That being said, setting the checkbox to be checked/selected is as easy as:
<pre><code class="hljs">$(&#x27;#takenBefore&#x27;).prop(&#x27;checked&#x27;, true);
</code></pre>
And again, since it's typically triggered on some other event:
<pre><code class="hljs">$(&#x27;#button&#x27;).on(&#x27;click&#x27;, function() {
 $(&#x27;#takenBefore&#x27;).prop(&#x27;checked&#x27;, true);
});
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/how-to-checkselect-a-checkbox-with-jquery-javascript-1.gif" alt="check checkbox with jquery">
<h2 id="elementattrcheckedtrue">$('#element').attr(&quot;checked&quot;, true)</h2>
In older versions of jQuery, which you might be forced to use due to project constraints, the <code>prop()</code> function was preceded by the <code>attr()</code> function, which set the attributes of elements.
In this context, it works in much the same way as <code>prop()</code>:
<pre><code class="hljs">$(&#x27;#takenBefore&#x27;).attr(&#x27;checked&#x27;, true);
</code></pre>
And again, since it's typically triggered on some other event:
<pre><code class="hljs">$(&#x27;#button&#x27;).on(&#x27;click&#x27;, function() {
 $(&#x27;#takenBefore&#x27;).attr(&#x27;checked&#x27;, true);
});
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at how to set a checkbox to &quot;checked&quot;/selected using Vanilla JavaScript and jQuery.
We've taken a look at the simplest methods such as explicitly setting the property and worked our way up to using jQuery's wrapper methods with validation.

How to Check/Select a Checkbox with jQuery - JavaScript

Asaolu Elijah

Jovana Ninkovic

In this guide, we'll take a look at Vuex - the centralized state management library for Vue applications. Learn how to use getters, actions and mutations to alter the Vuex store state through code.

Guide to Vuex - Centralized State Management for Vue Applications

<h2 id="introduction">Introduction</h2>
A stream represents a sequence of elements and supports different kinds of operations that lead to the desired result. The source of a stream is usually a Collection or an Array, from which data is streamed from.
Streams differ from collections in several ways; most notably in that the streams are not a data structure that stores elements. They're functional in nature, and it's worth noting that operations on a stream produce a result and typically return another stream, but do not modify its source.
To &quot;solidify&quot; the changes, you collect the elements of a stream back into a <code>Collection</code>.
<blockquote>
In this guide, we'll take a look at how to collect Stream elements to a map in Java 8.
</blockquote>
<h2 id="collectorsandstreamcollect">Collectors and Stream.collect()</h2>
Collectors represent implementations of the <code>Collector</code> interface, which implements various useful reduction operations, such as accumulating elements into collections, summarizing elements based on a specific parameter, etc.
<blockquote>
All predefined implementations can be found within the <code>Collectors</code> class.
</blockquote>
You can also very easily implement your own collector and use it instead of the predefined ones, though - you can get pretty far with the built-in collectors, as they cover the vast majority of cases in which you might want to use them.
To be able to use the class in our code we need to import it:
<pre><code class="hljs">import static java.util.stream.Collectors.*;
</code></pre>
<code>Stream.collect()</code> performs a mutable reduction operation on the elements of the stream.

 <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">
 A mutable reduction operation collects input elements into a mutable container, such as a <code>Collection</code>, as it processes the elements of the stream.

 </div>
 </div>
 </div>
 <h2 id="guidetocollectorstoset">Guide to Collectors.toSet()</h2>
The <code>toSet()</code> method is used to collect a stream into a set. It works in a similar fashion to the <code>toList()</code> method, but ultimately collects into a different underlying data structure, by returning a <code>Collector</code> that accumulates the input elements into a new <code>Set</code>.
It's worth noting that there are no guarantees on the type, mutability, serializability, or thread-safety of the <code>Set</code> returned:
<pre><code class="hljs">public static &lt;T&gt; Collector&lt;T,?,Set&lt;T&gt;&gt; toSet()
</code></pre>
<blockquote>
A <code>Set</code> doesn't allow duplicate elements or in more formal terms - sets contain no pair of elements <code>a</code> and <code>b</code> such that <code>a.equals(b)</code>, and it can contain at most one <code>null</code> element.
</blockquote>
If you collect a stream with duplicate elements into a <code>Set</code> - it's a quick way to prune away duplicates:
<pre><code class="hljs">Stream&lt;String&gt; stream = 
 Stream.of(&quot;This&quot;, &quot;forms&quot;, &quot;forms&quot;, &quot;a&quot;, &quot;short&quot;, &quot;a&quot;, &quot;sentence&quot;, &quot;sentence&quot;);
Set&lt;String&gt; sentenceSet = stream.collect(Collectors.toSet());
</code></pre>
However, this example highlights an important characteristic of how Sets are populated - the elements don't retain their relative order when collected, like they do in, say, the <code>toList()</code> collector. This is because the default implementation of a <code>Set</code> is a <code>HashSet</code>, which orders elements based on their hashes and doesn't even guarantee the consistency of this order over time.
<blockquote>
We'll take a look at how we can provide a custom implementation of a <code>Set</code> in a later section.
</blockquote>
Running this piece of code results in:
<pre><code class="hljs">[sentence, a, This, short, forms]
</code></pre>
Since we rarely work with just Strings or primitive objects - let's define a simple class to represent a <code>Book</code>:
<pre><code class="hljs">public class Book {
 private String title;
 private String author;
 private int releaseYear;
 private int soldCopies;

 // Constructor, getters and setters
}
</code></pre>
And with that, let's create a simple list of a few books (with a duplicate entry):
<pre><code class="hljs">List&lt;Book&gt; books = Arrays.asList(
 new Book(&quot;The Fellowship of the Ring&quot;, &quot;J.R.R. Tolkien&quot;, 1954, 30),
 new Book(&quot;The Hobbit&quot;, &quot;J.R.R. Tolkien&quot;, 1937, 40),
 new Book(&quot;Animal Farm&quot;, &quot;George Orwell&quot;, 1945, 32),
 new Book(&quot;Nineteen Eighty-Four&quot;, &quot;George Orwell&quot;, 1949, 50),
 new Book(&quot;Nineteen Eighty-Four&quot;, &quot;George Orwell&quot;, 1949, 38)
);
</code></pre>
A pretty typical pipeline consists of a <code>filter()</code> based on some <code>Predicate</code> before collecting back to a collection:
<pre><code class="hljs">Set&lt;String&gt; booksGeorgeOrwell = books.stream()
 .filter(book-&gt;book.getAuthor()
 .equals(&quot;George Orwell&quot;) &amp;&amp; book.getCopiesSold() &gt;= 30)
 .map(Book::getTitle).collect(Collectors.toSet());

System.out.println(booksGeorgeOrwell);
</code></pre>
<blockquote>
If you'd like to read more about filtering and predicates - read our <a target="_blank" href="https://stackabuse.com/java-8-streams-guide-to-the-filter-method/">Java 8 Streams: Definitive Guide to the filter() Method</a> and <a target="_blank" href="https://stackabuse.com/complete-guide-to-java-8-predicates/">Functional Programming in Java 8: Definitive Guide to Predicates</a>!
</blockquote>
As we discussed earlier, <code>Set</code>s don't allow for duplicates. After we've inspected the clause we've given and which of the books in our <code>List</code> meet the criteria, we should have the following result:
<pre><code class="hljs">[Animal Farm, Nineteen Eighty-Four]
</code></pre>
Works great! The duplicate entry was pruned away, without explicit logic to prune away duplicates.
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to collect and convert a stream into a Set - using Java 8's Streams API, with the <code>Collectors</code> class.

Branko Ilic

In this guide, learn how to collect and convert a stream into a Set in Java 8, with practical code examples.

Guide to Java 8 Collectors: toSet()

<h2 id="introduction">Introduction</h2>
Pages on modern websites, and especially Single-Page Applications (SPAs) do not follow the traditional method of loading new pages completely whenever something changes on them. Client-Side Routing is used instead - to route towards resources to load another part of the program or structurally change the application's entire view if needed, when an action (such as clicking a button or link) is performed.
React is a massively popular library for front-end development used to create highly responsive user interfaces, and naturally, it has its own Router, which performs Client-Side Routing - the <code>react-router-dom</code>.
<blockquote>
In this guide, we'll take a look at how to create routes in a React application, programmatically navigate between routes, as well as send and retrieve data between them, using React Router.
</blockquote>
<h2 id="creatingareactapplication">Creating a React Application</h2>
Let's start out by creating a simple React application via the command line:
<pre><code class="hljs">$ npx create-react-app router-sample
</code></pre>
Once created, let's move into the project's directory, and start the application:
<pre><code class="hljs">$ cd router-sample
$ npm start
</code></pre>
This will start up a server on <code>localhost:3000</code> and your default browser will fire up to serve the application. Before creating any new files to serve on this endpoint, let's install <code>react-router-dom</code>, since it doesn't come prepackaged.
<h3 id="installingreactrouter">Installing React Router</h3>
As usual, installing a package using <code>npm</code> is as simple as running a single command:
<pre><code class="hljs">$ npm install react-router-dom
</code></pre>
<h3 id="creatingnewrouteswithreactrouter">Creating New Routes with React Router</h3>
The <code>react-router-dom</code> package makes it simple to create new routes. To begin, you wrap the entire application with the <code>&lt;BrowserRouter&gt;</code> tag. We do this to gain access to the browser's <code>history</code> object. Then you define your router links, as well as the components that will be used for each route.
To demonstrate this, let's create a new file called <code>About.js</code> in the <code>/src</code> folder:
<pre><code class="hljs">const About = () =&gt; {
 return (
 &lt;div&gt;
 &lt;h1&gt;About page here!&lt;/h1&gt;
 &lt;p&gt;
 Lorem ipsum dolor sit amet consectetur adipisicing elit. Fugit, modi!
 &lt;/p&gt;
 &lt;/div&gt;
 );
};

export default About;
</code></pre>
Now, let's update the <code>src/index.js</code> page and import <code>About</code> from the file we've just created. Within the <code>&lt;BrowserRouter&gt;</code> tag, we'll define our routes and components associated with them:
<pre><code class="hljs">import { render } from &quot;react-dom&quot;;
import { BrowserRouter, Routes, Route } from &quot;react-router-dom&quot;;
import App from &quot;./App&quot;;
import About from &quot;./About&quot;;

render(
 &lt;BrowserRouter&gt;
 &lt;Routes&gt;
 &lt;Route path=&quot;/&quot; element={&lt;App /&gt;} /&gt;
 &lt;Route path=&quot;about&quot; element={&lt;About /&gt;} /&gt;
 &lt;/Routes&gt;
 &lt;/BrowserRouter&gt;,
 document.getElementById(&quot;root&quot;)
);
</code></pre>
We've imported the <code>&lt;BrowserRouter&gt;</code> here, and we've wrapped our entire application around it. We'd also selected <code>App.js</code> as the component for our home page (under the <code>/</code> endpoint), and <code>About.js</code> as the component for the <code>/about</code> page.
Finally, let's adapt the <code>App.js</code> file, which will, again, be the main entry point for the application and serve our home page:
<pre><code class="hljs">import { Link } from &quot;react-router-dom&quot;;

function App() {
 return (
 &lt;div className=&quot;App&quot;&gt;
 &lt;h1&gt;Welcome to my react app!&lt;/h1&gt;
 &lt;p&gt;
 Lorem ipsum dolor sit amet consectetur adipisicing elit. Accusamus,
 pariatur?
 &lt;/p&gt;
 &lt;br /&gt;
 &lt;Link to=&quot;/about&quot;&gt;About Page&lt;/Link&gt;
 &lt;/div&gt;
 );
}

export default App;
</code></pre>
At this stage, we've created two routes: the entry route (<code>/</code>) and the <code>/about</code> route, and we should be able to easily navigate from the home page to the about page when we visit our application:
<img src="https://s3.stackabuse.com/media/articles/programmatically-navigate-using-react-router-1.gif" alt="navigating between pages with react">
<h2 id="reactrouterhooksnavigationmethods">React Router Hooks (Navigation Methods)</h2>
Hooks were added to React recently, which are functions that allow you to &quot;hook&quot; into the application's state, without having to write new classes. The React Router comes with a few hooks that allow us to programmatically access the Router State and navigate between components. Among these are the following hooks:
<ul>
<li><code>useHistory()</code></li>
<li><code>userNavigate()</code></li>
<li><code>useLocation()</code></li>
<li><code>useParams()</code></li>
</ul>
To use any of these hooks, we must first import them from the <code>react-router-dom</code> package and then specify a variable that invokes the hook; we'll go through this in more detail in the sections that follow.
<h3 id="usehistory">useHistory()</h3>

 <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>useHistory()</code> hook has been deprecated in the latest version of React Router. If you're using React Router V6, you'll want to use the <code>useNavigate()</code> hook instead. It's covered right after <code>useHistory()</code>.

 </div>
 </div>
 </div>
 The <code>useHistory()</code> hook provides direct access to React Router's history instances, enabling us to perform actions like retrieving the number of entries in the history stack, adding, altering, or removing an entry from the stack, and so on.
Some of the most useful methods here include:
<ul>
<li><code>goBack()</code> - Go backward in history.</li>
<li><code>goForward()</code> - Go forward in history.</li>
<li><code>push()</code> - Add a new entry to the history stack, i.e., navigate to a new URL.</li>
<li><code>replace()</code> - Similar to <code>push()</code> in that it replaces the current stack in the history, but unlike <code>push()</code>, the user cannot travel back in history, i.e. clicking the browser back button will not return to the previous state.</li>
</ul>
With just this, we can navigate from our <code>About</code> page to the home page programmatically, by <code>push()</code>-ing a new entry into the history, effectively navigating the user to the new entry:
<pre><code class="hljs">import React from &quot;react&quot;;
import { useHistory } from &quot;react-router-dom&quot;;

const About = () =&gt; {
 let history = useHistory();

 const goHome = () =&gt; {
 history.push(&quot;/&quot;);
 };

 return (
 &lt;div&gt;
 &lt;h1&gt;About page here!&lt;/h1
 &lt;p&gt;
 Lorem ipsum dolor sit amet consectetur adipisicing elit. Fugit, modi!
 &lt;/p&gt;
 &lt;button onClick={goHome}&gt;Go to home page&lt;/button&gt;
 &lt;/div&gt;
 );
};

export default About;
</code></pre>
Here, we just import the <code>useHistory()</code> hook and create a new <code>goHome()</code> function that executes on a button click. It's just a wrapper for a <code>push()</code> call.
We can also transfer the state or send arbitrary data to the route we are navigating to. We can do this by sending an object to the push methods instead of the pathname as a string, and adding our state to a distinct object:
<pre><code class="hljs">history.push({
 pathname: &#x27;/blog,
 search: &#x27;?blogId=12, // Query string
 state: { // Location state
 author_name: &quot;John Doe&quot;, 
 },
}); 
</code></pre>
After covering <code>useNavigate()</code>, we'll take a look at how to access this data using the <code>useLocation()</code> and <code>useParams()</code> hooks.
<h3 id="usenavigate">useNavigate()</h3>
If you're using the most recent version of React Router, the <code>useHistory()</code> hook has been deprecated in favor of <code>useNavigate()</code>. The approach is nearly identical; the main difference is that the <code>useNavigate()</code> hook does not accept methods like <code>.push()</code> or <code>.replace()</code>. You just <code>navigate()</code> to a certain entry:
<pre><code class="hljs">import React from &quot;react&quot;;
import { useNavigate } from &quot;react-router-dom&quot;;

const About = () =&gt; {
 let navigate = useNavigate();

 const goHome = () =&gt; {
 navigate(&quot;/&quot;);
 };

 return (
 &lt;div&gt;
 &lt;h1&gt;About page here!&lt;/h1&gt;
 &lt;p&gt;
 Lorem ipsum dolor sit amet consectetur adipisicing elit. Fugit, modi!
 &lt;/p&gt;
 &lt;button onClick={goHome}&gt;Go to home page&lt;/button&gt;
 &lt;/div&gt;
 );
};

export default About;
</code></pre>
And, of course, this method also allows us to transfer states between routes:
<pre><code class="hljs">navigate(&quot;/blog&quot;, { state: { author_name: &quot;John Doe&quot; } });
</code></pre>
<h3 id="retrievingdatabetweenrouteswithuselocationanduseparams">Retrieving Data Between Routes with useLocation() and useParams()</h3>
The <code>useLocation()</code> hook provides us access to the browser's <code>location</code> object. Consider it the hook in charge of obtaining the necessary information about the current route:
<pre><code class="hljs">import { useNavigate, useLocation } from &quot;react-router-dom&quot;;
/*...*/
let location = useLocation();
console.log(location);
</code></pre>
Running the code above should return all of the information about the current route, as shown below:
<pre><code class="hljs">{
 &quot;pathname&quot;: &quot;/about&quot;,
 &quot;search&quot;: &quot;&quot;,
 &quot;hash&quot;: &quot;&quot;,
 &quot;state&quot;: null,
 &quot;key&quot;: &quot;default&quot;
}
</code></pre>
It's reasonable to think of the <code>useLocation()</code> hook as a <code>useState()</code> hook that updates the state to a new location whenever the URL changes. On the other hand, the <code>userParams()</code> hook can be used to get the value of URL parameters. When called, <code>useParams()</code> provides an object that maps the names of URL parameters to their values in the current URL.
For example, in our router configuration, say we've had a dynamic route:
<pre><code class="hljs">&lt;Route path=&quot;/about/:user_id&quot;&gt;
 &lt;About /&gt;
&lt;/Route&gt;
</code></pre>
And on another page, we have a link component that points to some information pertaining to User 2:
<pre><code class="hljs">&lt;Link to=&quot;/about/2&quot;&gt;About User 2&lt;/Link&gt;
</code></pre>
When parameters are passed, like we've seen before - we can access the parameters via the <code>userParams()</code> hook:
<pre><code class="hljs">import { useParams } from &quot;react-router-dom&quot;;

const About = () =&gt; {
 const { user_id } = useParams();

 return (
 &lt;div&gt;
 &lt;h1&gt;About user {user_id}&lt;/h1&gt;
 &lt;p&gt;
 Lorem ipsum dolor...
 &lt;/p&gt;
 &lt;/div&gt;
 );
};

export default About;
</code></pre>
<h2 id="conclusion">Conclusion</h2>
React Router is used for Client-Side Routing of resources. In this guide, we've taken a quick look at how you can programmatically navigate an application using React Router as well as how to transfer states between routes when you do.

In this guide, learn how to create routes, programmatically navigate, send and receive data using React Router in JavaScript, with practical examples.

Programmatically Navigate Using React Router

Marcus Sanatan

Mohammad Waseem

In this practical guide, learn how to perform object detection on images, real-time videos and video streams in Python with OpenCV and Haar-Cascade Classifiers!

Object Detection with OpenCV-Python Using a Haar-Cascade Classifier

<h2 id="introduction">Introduction</h2>
Counting the word frequency in a list element in Python is a relatively common task - especially when creating distribution data for <a target="_blank" href="https://stackabuse.com/matplotlib-histogram-plot-tutorial-and-examples/">histograms</a>.
Say we have a list <code>['b', 'b', 'a']</code> - we have two occurrences of &quot;b&quot; and one of &quot;a&quot;. This guide will show you three different ways to count the number of word occurrences in a Python list:
<ul>
<li>Using Pandas and NumPy</li>
<li>Using the <code>count()</code> Function</li>
<li>Using the Collection Module's <code>Counter</code></li>
<li>Using a Loop and a Counter Variable</li>
</ul>
In practice, you'll use Pandas/NumPy, the <code>count()</code> function or a <code>Counter</code> as they're pretty convenient to use.
<h2 id="usingpandasandnumpy">Using Pandas and NumPy</h2>
The shortest and easiest way to get value counts in an easily-manipulable format (<code>DataFrame</code>) is via NumPy and Pandas. We can wrap the list into a NumPy array, and then call the <code>value_counts()</code> method of the <code>pd</code> instance (which is also available for all <code>DataFrame</code> instances):
<pre><code class="hljs">import numpy as np
import pandas as pd

words = [&#x27;hello&#x27;, &#x27;goodbye&#x27;, &#x27;howdy&#x27;, &#x27;hello&#x27;, &#x27;hello&#x27;, &#x27;hi&#x27;, &#x27;bye&#x27;]

pd.value_counts(np.array(words))
</code></pre>
This results in a <code>DataFrame</code> that contains:
<pre><code class="hljs">hello 3
goodbye 1
bye 1
howdy 1
hi 1
dtype: int64
</code></pre>
You can access its <code>values</code> field to get the counts themselves, or <code>index</code> to get the words themselves:
<pre><code class="hljs">df = pd.value_counts(np.array(words))

print(&#x27;Index:&#x27;, df.index)
print(&#x27;Values:&#x27;, df.values)
</code></pre>
This results in:
<pre><code class="hljs">Index: Index([&#x27;hello&#x27;, &#x27;goodbye&#x27;, &#x27;bye&#x27;, &#x27;howdy&#x27;, &#x27;hi&#x27;], dtype=&#x27;object&#x27;)

Values: [3 1 1 1 1]
</code></pre>
<h2 id="usingthecountfunction">Using the count() Function</h2>
The &quot;standard&quot; way (no external libraries) to get the count of word occurrences in a list is by using the list object's <code>count()</code> function.
The <code>count()</code> method is a built-in function that takes an element as its only argument and returns the number of times that element appears in the list.
<blockquote>
The complexity of the <code>count()</code> function is O(n), where <code>n</code> is the number of factors present in the list.
</blockquote>
The code below uses <code>count()</code> to get the number of occurrences for a word in a list:
<pre><code class="hljs">words = [&#x27;hello&#x27;, &#x27;goodbye&#x27;, &#x27;howdy&#x27;, &#x27;hello&#x27;, &#x27;hello&#x27;, &#x27;hi&#x27;, &#x27;bye&#x27;]

print(f&#x27;&quot;hello&quot; appears {words.count(&quot;hello&quot;)} time(s)&#x27;)
print(f&#x27;&quot;howdy&quot; appears {words.count(&quot;howdy&quot;)} time(s)&#x27;)
</code></pre>
This should give us the same output as before using loops:
<pre><code class="hljs">&quot;hello&quot; appears 3 time(s)
&quot;howdy&quot; appears 1 time(s)
</code></pre>
The <code>count()</code> method offers us an easy way to get the number of word occurrences in a list for each individual word.
<h2 id="usingthecollectionmodulescounter">Using the Collection Module's Counter</h2>
The <code>Counter</code> class instance can be used to, well, count instances of other objects. By passing a list into its constructor, we instantiate a <code>Counter</code> which returns a dictionary of all the elements and their occurrences in a list.
From there, to get a single word's occurrence you can just use the word as a key for the dictionary:
<pre><code class="hljs">from collections import Counter

words = [&#x27;hello&#x27;, &#x27;goodbye&#x27;, &#x27;howdy&#x27;, &#x27;hello&#x27;, &#x27;hello&#x27;, &#x27;hi&#x27;, &#x27;bye&#x27;]

word_counts = Counter(words)

print(f&#x27;&quot;hello&quot; appears {word_counts[&quot;hello&quot;]} time(s)&#x27;)
print(f&#x27;&quot;howdy&quot; appears {word_counts[&quot;howdy&quot;]} time(s)&#x27;)
</code></pre>
This results in:
<pre><code class="hljs">&quot;hello&quot; appears 3 time(s)
&quot;howdy&quot; appears 1 time(s)
</code></pre>
<h2 id="usingaloopandacountervariable">Using a Loop and a Counter Variable</h2>
Ultimately, a brute force approach that loops through every word in the list, incrementing a counter by one when the word is found, and returning the total word count will work!
Of course, this method gets more inefficient as the list size grows, it's just conceptually easy to understand and implement.
The code below uses this approach in the <code>count_occurrence()</code> method:
<pre><code class="hljs">def count_occurrence(words, word_to_count):
 count = 0
 for word in words:
 if word == word_to_count:
 # update counter variable
 count = count + 1
 return count


words = [&#x27;hello&#x27;, &#x27;goodbye&#x27;, &#x27;howdy&#x27;, &#x27;hello&#x27;, &#x27;hello&#x27;, &#x27;hi&#x27;, &#x27;bye&#x27;]
print(f&#x27;&quot;hello&quot; appears {count_occurrence(words, &quot;hello&quot;)} time(s)&#x27;)
print(f&#x27;&quot;howdy&quot; appears {count_occurrence(words, &quot;howdy&quot;)} time(s)&#x27;)
</code></pre>
If you run this code you should see this output:
<pre><code class="hljs">&quot;hello&quot; appears 3 time(s)
&quot;howdy&quot; appears 1 time(s)
</code></pre>
Nice and easy!
<h2 id="mostefficientsolution">Most Efficient Solution?</h2>
Naturally - you'll be searching for the most efficient solution if you're dealing with a large corpora of words. Let's benchmark all of these to see how they perform.
The task can be broken down into finding occurrences for all words or a single word, and we'll be doing benchmarks for both, starting with all words:
<pre><code class="hljs">import numpy as np
import pandas as pd
import collections

def pdNumpy(words):
 def _pdNumpy():
 return pd.value_counts(np.array(words))
 return _pdNumpy

def countFunction(words):
 def _countFunction():
 counts = []
 for word in words:
 counts.append(words.count(word))
 return counts
 return _countFunction

def counterObject(words):
 def _counterObject():
 return collections.Counter(words)
 return _counterObject
 
import timeit

words = [&#x27;hello&#x27;, &#x27;goodbye&#x27;, &#x27;howdy&#x27;, &#x27;hello&#x27;, &#x27;hello&#x27;, &#x27;hi&#x27;, &#x27;bye&#x27;]

print(&quot;Time to execute:\n&quot;)
print(&quot;Pandas/NumPy: %ss&quot; % timeit.Timer(pdNumpy(words)).timeit(1000))
print(&quot;count(): %ss&quot; % timeit.Timer(countFunction(words)).timeit(1000))
print(&quot;Counter: %ss&quot; % timeit.Timer(counterObject(words)).timeit(1000))
</code></pre>
Which results in:
<pre><code class="hljs">Time to execute:

Pandas/NumPy: 0.33886080000047514s
count(): 0.0009540999999444466s
Counter: 0.0019409999995332328s
</code></pre>
The <code>count()</code> method is extremely fast compared to the other variants, however, it doesn't give us the labels associated with the counts like the other two do.
If you need the labels - the <code>Counter</code> outperforms the inefficient process of wrapping the list in a NumPy array and then counting.
On the other hand, you can make use of DataFrame's methods for sorting or other manipulation that you can't do otherwise. <code>Counter</code> has some unique methods as well.
Ultimately, you can use the <code>Counter</code> to create a dictionary and turn the dictionary into a <code>DataFrame</code> as as well, to leverage the speed of <code>Counter</code> and the versatility of <code>DataFrame</code>s:
<pre><code class="hljs">df = pd.DataFrame.from_dict([Counter(words)]).T
</code></pre>
If you don't need the labels - <code>count()</code> is the way to go.
Alternatively, if you're looking for a single word:
<pre><code class="hljs">import numpy as np
import pandas as pd
import collections

def countFunction(words, word_to_search):
 def _countFunction():
 return words.count(word_to_search)
 return _countFunction

def counterObject(words, word_to_search):
 def _counterObject():
 return collections.Counter(words)[word_to_search]
 return _counterObject

def bruteForce(words, word_to_search):
 def _bruteForce():
 counts = []
 count = 0
 for word in words:
 if word == word_to_search:
 # update counter variable
 count = count + 1
 counts.append(count)
 return counts
 return _bruteForce
 
import timeit

words = [&#x27;hello&#x27;, &#x27;goodbye&#x27;, &#x27;howdy&#x27;, &#x27;hello&#x27;, &#x27;hello&#x27;, &#x27;hi&#x27;, &#x27;bye&#x27;]

print(&quot;Time to execute:\n&quot;)
print(&quot;count(): %ss&quot; % timeit.Timer(countFunction(words, &#x27;hello&#x27;)).timeit(1000))
print(&quot;Counter: %ss&quot; % timeit.Timer(counterObject(words, &#x27;hello&#x27;)).timeit(1000))
print(&quot;Brute Force: %ss&quot; % timeit.Timer(bruteForce(words, &#x27;hello&#x27;)).timeit(1000))
</code></pre>
Which results in:
<pre><code class="hljs">Time to execute:

count(): 0.0001573999998072395s
Counter: 0.0019498999999996158s
Brute Force: 0.0005682000000888365s
</code></pre>
The brute force search and <code>count()</code> methods outperform the <code>Counter</code>, mainly because the <code>Counter</code> inherently counts all words instead of one.
<h2 id="conclusion">Conclusion</h2>
In this guide, we explored finding the occurrence of the word in a Python list, assessing the efficiency of each solution and weighing when each is more suitable.

Guest Contributor

In this tutorial, we'll learn how to count the number of times a word occurred in a list in Python using Pandas/Numpy, the count() function, a for loop, and the Counter() function of the collections module and benchmark them.

Count Number of Word Occurrences in List Python

Joseph Eshiett

In this guide, we’ll take a look at extracting and parsing data from XML files with BeautifulSoup and lxml. Let's practice by parsing an RSS feed and saving it to a CSV file.

Parsing XML with BeautifulSoup in Python

<h2 id="introduction">Introduction</h2>
In this short guide, we'll cover all necessary aspects of sorting an array by date in JavaScript.
The array data structure in JavaScript has a built-in <code>sort()</code> method, but it is not designed to be used to sort an array by date. There are a lot of different date formats and we need to make the sorting work no matter the format used to represent a date.
Firstly, let's go into some basic concepts and constraints that we need to understand to be able to alter the <code>sort()</code> method so that it can sort the elements of an array by date, and then we'll show some practical examples that explain how sorting by dates works.

 <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: In this guide, we'll be sorting an array of dates, but the same rules apply in the case of sorting an array of objects containing a date property

 </div>
 </div>
 </div>
 <h2 id="javascriptssortmethod">JavaScript's sort() method</h2>
As previously mentioned, the <code>Array</code> data structure in JavaScript has a built-in <code>sort()</code> method used to sort the elements of an array. The <code>sort()</code> method works by converting the elements into strings and sorting those string representations of elements lexicographically in ascending order.
Another important fact to keep in mind is that the <code>sort()</code> method sorts elements in-place, meaning that it alters the original array:
<pre><code class="hljs">const exampleArray = [&#x27;bbb&#x27;, &#x27;aa&#x27;, &#x27;ddd&#x27;, &#x27;c&#x27;];
exampleArray.sort();
console.log(exampleArray);
// Outputs: [&#x27;aa&#x27;, &#x27;bbb&#x27;, &#x27;c&#x27;, &#x27;ddd&#x27;]
</code></pre>
Obviously, the <code>sort()</code> method is designed to work with strings, but it is not designed to work with dates. For example, let's assume that we want to sort the following array of dates:
<pre><code class="hljs">const dates = [&#x27;Mar 16 2017&#x27;, &#x27;Jan 22 2021&#x27;, &#x27;Dec 31 2000&#x27;];
dates.sort();
console.log(dates);
</code></pre>
The desired output will be an array sorted by dates in ascending order:
<pre><code class="hljs">[&#x27;Dec 31 2000&#x27;, &#x27;Mar 16 2017&#x27;, &#x27;Jan 22 2021&#x27;]
</code></pre>
But the actual output will be:
<pre><code class="hljs">[&#x27;Dec 31 2000&#x27;, &#x27;Jan 22 2021&#x27;, &#x27;Mar 16 2017&#x27;]
</code></pre>
This happens because the <code>sort()</code> method works by sorting the string representations of elements, not the actual elements.
For instance, <code>D</code> from <code>'Dec 31 2000'</code> is lexicographically lesser than <code>J</code> from <code>'Jan 22 2021'</code> and so on. This undesired behavior is the same no matter the date format, therefore, we need to find a way to alter the <code>sort()</code> method to make it suitable for sorting dates.
<h2 id="primerondatesinjavascript">Primer on Dates in JavaScript</h2>
In order to know how to sort an array by date in JavaScript, firstly, we need to understand how JavaScript represents dates.
In short, the structure used to represent dates in JavaScript is a <code>Date</code> object, it does so by storing a <code>Number</code> that represents the number of milliseconds since 1 January 1970.
There are four ways of creating a <code>Date</code> object, but, in essence, all of them store the date as the <code>Number</code>, as previously described:
<pre><code class="hljs">// Blank constructor - the current date and time
const now = new Date();

// Date string as the argument
const exampleDate1 = new Date(dateString);

// Number of milliseconds since 1 Jan 1970 as the argument
const exampleDate2 = new Date(milliseconds);

// Year, month, ... as the argument
const exampleDate3 = new Date(year, month, day, hour, minute, second, millisecond);
</code></pre>
Due to the nature of the problem of sorting an array by date, we'll use the second way, passing the string representation of the date in the <code>Date</code> constructor. Generally speaking, there are 3 formats of strings that are used to represent dates:
<table class="table table-striped">
 <thead>
 <td>Name</td>
 <td>Format</td>
 <td>Example</td>
 <td>Browser Independent</td>
 </thead>
 <tr>
 <td>ISO Date</td>
 <td>YYYY-MM-DD</td>
 <td>"2017-09-24"</td>
 <td>**Yes** (strictly defined by ISO standard)</td>
 </tr>
 <tr>
 <td>Short Date</td>
 <td>MM/DD/YYYY</td>
 <td>"09/24/2017"</td>
 <td>**No** (may vary on different browsers)</td>
 </tr>
 <tr>
 <td>Long Date</td>
 <td>DD Month YYYY</td>
 <td>"24 September 2017"</td>
 <td>**No** (may vary on different browsers)</td>
 </tr>
</table>
So, if we want to create a <code>Date</code> object for the 24th of September 2017, we'll do so in one of the following ways:
<pre><code class="hljs">const date = new Date(&quot;2017-09-24&quot;);
// Or
const date = new Date(&quot;09/24/2017&quot;);
// Or
const date = new Date(&quot;24 September 2017&quot;);
</code></pre>
All of these will represent the exact same date (the same number of milliseconds since 1 January 1970).
<h2 id="howtosortanarraybydateinjavascriptstringrepresentation">How to Sort an Array by Date in JavaScript (String Representation)</h2>
Now that we know how does the <code>Date</code> object and <code>sort()</code> method work, we can explain how to use the <code>sort()</code> method to sort an array by a date.
Firstly, let's assume that we need to sort an array of dates:
<pre><code class="hljs">// [&#x27;16 March 2017&#x27;, &#x27;22 January 2021&#x27;, &#x27;31 December 2000&#x27;]
const dates = [&#x27;16 March 2017&#x27;, &#x27;01/22/2021&#x27;, &#x27;2000-12-31&#x27;];
</code></pre>
As we can see, elements of the <code>dates</code> array are string representations of some dates. As we've discussed before, simply using the <code>sort()</code> method on <code>dates</code> won't produce the desired output, so we need to alter it to make it suitable for sorting dates. We'll do so by creating an appropriate custom comparison function and passing it to the <code>sort()</code> method.

 <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">
 A comparison function, in simple terms, is a function that accepts two arguments (numbers) and returns positive, negative, or zero values. It is used to define the sorting order in a <code>sort()</code> method.

 </div>
 </div>
 </div>
 For example, the following comparison function will be used for sorting elements in ascending order:
<pre><code class="hljs">function(a, b){
 return a - b;
}
</code></pre>
The following rules apply to the sorting order based on the return value of a compare function:
<table class="table table-striped">
 <thead>
 <td>Return value</td>
 <td>Sorting order</td>
 </thead>
 <tr>
 <td>Positive</td>
 <td>b before a</td>
 </tr>
 <tr>
 <td>Zero</td>
 <td>same</td>
 </tr>
 <tr>
 <td>Negative</td>
 <td>a before b</td>
 </tr>
</table>
The comparison function that will be able to sort dates must firstly convert string representations of dates into <code>Date</code> objects and then compare two dates in the desired way. Thankfully, the <code>Date</code> constructor accepts a wide variety of formats, and can translate them to an easily comparable format:
<pre><code class="hljs">function(a, b){
 // Convert string dates into `Date` objects
 const date1 = new Date(a);
 const date2 = new Date(b);
 
 return date1 - date2;
}
</code></pre>
For sorting in descending order, the only change we need to make is to swap places of <code>date1</code> and <code>date2</code> in the return statement:
<pre><code class="hljs">return date2 - date1;
</code></pre>
When we've created the appropriate comparison function, the only thing left to do is to pass it to the <code>sort()</code> method in order for it to be able to sort dates:
<pre><code class="hljs">dates.sort(function(a, b){
 const date1 = new Date(a)
 const date2 = new Date(b)
 
 return date1 - date2;
})
</code></pre>
Alternatively, you can define the function as a non-anonymous function and pass it that way:
<pre><code class="hljs">function dateComparison(a, b) {
 const date1 = new Date(a)
 const date2 = new Date(b)
 
 return date1 - date2;
}

dates.sort(dateComparison);
console.log(dates);
</code></pre>
Now, the <code>dates</code> array is sorted in the ascending order:
<pre><code class="hljs">[&#x27;2000-12-31&#x27;, &#x27;16 March 2017&#x27;, &#x27;01/22/2021&#x27;]
</code></pre>
<h2 id="howtosortanarraybydateinjavascriptdateobjects">How to Sort an Array by Date in JavaScript (Date Objects)</h2>
The simpler version of this problem is the case where the <code>dates</code> array is already an array of <code>Date</code> objects. In that case, the simplest compare function will do the job:
<pre><code class="hljs">const date1 = new Date(&#x27;16 March 2017&#x27;);
const date2 = new Date(&#x27;01/22/2021&#x27;);
const date3 = new Date(&#x27;2000-12-31&#x27;);
const dates = [date1, date2, date3];

dates.sort(function(a, b){
 return a - b 
});

console.log(dates);
</code></pre>
The output will be:
<pre><code class="hljs">[&#x27;2000-12-31&#x27;, &#x27;16 March 2017&#x27;, &#x27;01/22/2021&#x27;]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've discussed the important facts about sorting an array by date. Finishing it, you should have the knowledge of sorting arrays, <code>Date</code> objects, and you are able to combine what you have learned to sort an array of dates in the desired order.

Dimitrije Stamenic

In this short guide, learn how to sort an array in JavaScript for both string representations and date objects with a custom comparator function and practical code examples.