<h2 id="introduction">Introduction</h2>
Whether you are creating a daily routine app, your own blog, or most any other type of dynamic web app, you will probably need to work with dates. In this article, we're going to learn how to get the current date in JavaScript, so you can successfully develop your applications. In JavaScript, there are a plethora of options to choose from, but the main class being used is <code>Date()</code>. It has a lot of methods and how you use it will depend on the format of the date you want to get. Afterwards, I will show you a popular JavaScript library that can be used for formatting time in general, and not just dates.
<h2 id="usingthedateclass">Using the Date() class</h2>
<code>Date()</code> is a go-to class in JavaScript when talking about time. There are several ways to get the time and date in a granular manner from this class!
<h3 id="usinggetdategetmonthandgetfullyearmethods">Using getDate(), getMonth() and getFullYear() methods</h3>
Note for getDate method: The first thing to notice when using this approach is that we use <code>getDate</code> and not <code>getDay</code>. The reason is that the <code>getDay</code> method returns the day of the week, so since it's Friday now as I'm writing, the <code>getDay</code> method would return 5. The method <code>getDate</code> actually does what we need in this case, it returns the day of the month number. So for me, right now the day of the month is 21 (because it's 21.05.2021.). These methods are easily confused, so I wanted to give a heads up.
Note for getMonth method: Another thing to watch out for is that the month indexes start from 0, so January is 0, February is 1, etc. Basically, when we retrieve the month number, we need to add 1.
Now that we got the potential problems out the way, let's code:
<pre><code class="hljs">let date = new Date()
let day = date.getDate();
let month = date.getMonth()+1;
let year = date.getFullYear();

let fullDate = `${day}.${month}.${year}.`;
console.log(fullDate);
</code></pre>
At first, we instance the class <code>Date</code> and for each part of the date, we use a variable to break it out and inspect each.
We placed each method result in a separate variable and then used <a target="_blank" href="/es6-template-string-literals-in-nodejs">string interpolation</a> to create a complete date. String interpolation is when we pass variables to string; in JavaScript this is achieved between back-ticks ( `` ) and variables are placed in <code>${variableName}</code>. If you don't prefer string interpolation, the other way around this is to simply concatenate (add) strings together like this:
<pre><code class="hljs">let fullDate = day + &quot;.&quot; + month + &quot;.&quot; + year + &quot;.&quot;;
</code></pre>
Our results will be the same in each case:
<pre><code class="hljs">21.5.2021. // string interpolation
21.5.2021. // string concatenation
</code></pre>
Say you want to show the month as <code>05</code> and not <code>5</code>. Unfortunately JavaScript's built-in <code>Date</code> class doesn't have many options for formatting dates to strings like other libraries do. So in this case we'll need to do the formatting ourselves, which we can do with some of JavaScript's methods on strings, like <code>padStart(length, substring)</code>. What it does is &quot;pads&quot; (i.e. prefixes) our string with the<code>substring</code>, until it reaches <code>length</code>. So since we want to make <code>05</code> from <code>5</code>, we want to pad the string with &quot;0&quot; until it reaches length 2. Before all that, we need to cast <code>date.getMonth()+1</code> to type <code>String</code>. Casting is explicitly changing a variable's type from one to the other. Here we change type <code>number</code> to type <code>String</code>. Our <code>month</code> variable will change to:
<pre><code class="hljs">let month = String(date.getMonth()+1).padStart(2, &quot;0&quot;);
</code></pre>
This will change our date format to:
<pre><code class="hljs">21.05.2021.
</code></pre>
<h3 id="usingtojsonmethod">Using toJSON() Method</h3>
Previous method left space for date formatting; you could have a date like <code>dd/mm/yyyy</code>, <code>dd-mm-yyyy</code>, <code>dd.mm.yyyy</code> and all the other variations relating the order of day, month, and year. When using <code>toJSON()</code>, it returns a <code>yyyy-mm-dd</code> format alongside the time format, <code>hh:mm:ss.ms</code>.
Let's preview this approach:
<pre><code class="hljs">let date = new Date().toJSON();
console.log(date);
</code></pre>
This will output:
<pre><code class="hljs">2021-05-21T13:42:07.553Z
</code></pre>
You should see an output similar to this, but obviously your output will be different depending on when you ran the code. We see that we need only the date, which is the first 10 characters, so let's use JavaScript's <code>slice()</code> method. Method <code>slice(a, b)</code> slices a string from point <code>a</code> to point <code>b</code>; in our example from 0 to 10. Let's try it:
<pre><code class="hljs">let date = new Date().toJSON().slice(0, 10);
</code></pre>
This will return:
<pre><code class="hljs">2021-05-21
</code></pre>
We can further slice this string, so we can arrange the parts to variables <code>day, month</code> and <code>year</code>, but it would be overdoing it, so if you need a different format, just use a different approach.
<h3 id="usingtoisostring_toutcstring_andtolocaledatestringmethods">Using toISOString(),_ toUTCString()_, and toLocaleDateString() Methods</h3>
Fun fact: <code>toISOString()</code> returns the exact same result as <code>toJSON()</code>, so we will skip it and go straight into <code>toUTCString()</code>.
<h4 id="usingtoutcstring">Using toUTCString()</h4>
<pre><code class="hljs">let date = new Date().toUTCString();
console.log(date);
</code></pre>
Will give us the output:
<pre><code class="hljs">Fri, 21 May 2021 13:53:30 GMT
</code></pre>
This format also returns date and time, with the addition of the day of the week. As I said in the <code>toJSON()</code> section, you could parse this result further, but it would probably be unnecessary since you have different approaches. Since we're only getting the date, we can slice this. Now there's no need for casting, because this is already a <code>String</code>:
<pre><code class="hljs">let date = new Date().toUTCString().slice(5, 16);
</code></pre>
This will give us the desired output:
<pre><code class="hljs">21 May 2021
</code></pre>
<h4 id="usingtolocaledatestring">Using toLocaleDateString()</h4>
This method returns the date in a format corresponding to your system's language. It even has the option to pass the desired language as an argument and even simple date formatting options such as <code>weekday</code>, <code>month</code>, <code>day</code>, etc. We will divide this into 3 examples:
<ol>
<li>
Default options
Let's see what happens when we call the method without any arguments:
<pre><code class="hljs">let date = new Date().toLocaleDateString();
console.log(date);
</code></pre>
The output, for me, will be:
<pre><code class="hljs">5/21/2021
</code></pre>
This output depends on your locale, mine is US so the format will be as US date format.
</li>
<li>
Passing only language preference
If you want define a specific locale, you can pass it as a string argument, like so:
<pre><code class="hljs">let date = new Date().toLocaleDateString(&quot;fr-FR&quot;);
console.log(date);
</code></pre>
The <code>fr-FR</code> is a locale code for France. You can find all the locale codes <a rel="nofollow noopener" target="_blank" href="https://saimana.com/list-of-country-locale-code/">here</a>.
The French date format is <code>dd/mm/yyyy</code>, so the output will be:
<pre><code class="hljs">21/5/2021
</code></pre>
</li>
<li>
Passing both language preference and options
Finally, let's go through the possible options. Only month and weekday can have a value of &quot;long&quot; or &quot;numeric&quot;. Day and year can only be &quot;numeric&quot;:
<ul>
<li>day</li>
<li>month</li>
<li>year</li>
<li>weekday</li>
</ul>
</li>
</ol>
<pre><code class="hljs">const dateOptions = { 
 day: &#x27;numeric&#x27;,
 month: &#x27;long&#x27;,
 year: &#x27;numeric&#x27;
};

console.log(event.toLocaleDateString(&#x27;fr-FR&#x27;, dateOptions));
</code></pre>
We will exclude <code>weekday</code> since we only need the date. This should output:
<pre><code class="hljs">21 mai 2021
</code></pre>
Now you learned a bit of French, as well.
<h3 id="usingnow">Using now()</h3>
Method <code>now()</code> returns the number of milliseconds passed from January 1st, 1970 - which is the beginning of the Unix epoch in programming. If we pass the number of milliseconds to the <code>Date</code> constructor, we can get an ISO format date. Let's try it:
<pre><code class="hljs">let time = Date.now()
console.log(time);
</code></pre>
Which will output, again, for me:
<pre><code class="hljs">1621608925212
</code></pre>
Now if we pass that <code>time</code> to the constructor, as mentioned above, we can create a date object with that time:
<pre><code class="hljs">let date = new Date(time);
console.log(time);
</code></pre>
This will output:
<pre><code class="hljs">2021-05-21T14:55:25.212Z
</code></pre>
And we already know how to process this, using <code>slice()</code>.
<h2 id="usingmomentjs">Using moment.js</h2>
This is just an alternative for using all the previous methods, a library made specifically for dates and times in JavaScript. You can visit their website <a target="_blank" href="https://stackabuse.com/moment-js-a-better-date-library-for-javascript/">here</a>. Although this library has quite a few features, I will only go over how to create and do simple formatting for a date. Let's see how it works:
<pre><code class="hljs">moment.format();
moment.format(&#x27;Do MMMM YYYY&#x27;);
moment.format(&#x27;Do MMMM YY&#x27;);
</code></pre>
If you don't pass anything to format, you will get an ISO representation of the date, however, you can choose any format you want (and which is defined in Moment's documentation).
The code above will output:
<pre><code class="hljs">2021-05-21T17:17:02+02:00
May 21st 2021
May 21st 21
</code></pre>
This option is not the best if all you're looking for is retrieving the current date. This is because the Moment library is quite large and will bloat your JS code when used in front-end applications. On the other hand, if you need date and time manipulation or more advanced formatting, this is a great library.
<h2 id="conclusion">Conclusion</h2>
There are numerous ways to retrieve a date in JavaScript, you just need to choose one that fits your use-case. For very simple needs, like creating a date or very simple formatting, then you can use the built-in <code>Date</code> class. If you need something a bit more complex with date and time, moments.js is a library to choose.

Scott Robinson

Lazar Ristic

How to Get the Current Date in JavaScript

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll take a look at how to get the current URL of a loaded HTML page, using JavaScript.
Firstly, let's take a look at a URL:
<pre><code class="hljs">https://www.stackabuse.com:8080/category/article-title.html?searchterm=Example+title#2
</code></pre>
It's a made-up URL, that contains several components - the protocol, domain, port, path, query and hash.
<blockquote>
If you'd like to avoid handling the parsing of URLs manually, especially with more complex URL formats such as Git's - read on <a target="_blank" href="">How to Easily Parse URLs in JavaScript with parse-url</a>!
</blockquote>
<h2 id="urlcomponents">URL Components</h2>
The URL we've defined consists of different segments, divided by certain special characters such as <code>/</code>, <code>?</code> and <code>#</code>. Each of these segments is a URL component:
<ul>
<li>
Protocol - The protocol of a URL refers to the URL segment which defines which protocol is used for data transfer. In our case, we're using <code>https://</code>, signifying the HTTPS protocol.
</li>
<li>
Domain - The domain, also known as the hostname of an URL refers to the proceeding section of a URL - <code>www.stackabuse.com</code>.
</li>
<li>
Port - The port section of an URL is specified after the domain, preceded by <code>:</code>. Most of the time, the port isn't public, so you'll rarely actually see it in deployed applications, but very commonly in the development phase.
</li>
<li>
Path - The path section of an URL follows the domain name and port. It specifies a single resource on a website, HTML page, image, or some other type of file or directory. In our example, the path refers to the <code>/category/article-title.html</code> segment, meaning that it points to the <code>article-title.html</code> file on the server.
</li>
<li>
Query - The query is a string that is usually used to enable internal searches on a website. The query section refers to the <code>?articleTitle=Example+title</code> section of the example URL and is a result of the user entering the search term <code>Example title</code> on the <code>article-title.html</code> page of the website.
</li>
<li>
Hash - The hash section is usually used to represent an anchor on the page, which is commonly a heading, but can be any other <code>&lt;div&gt;</code> or tag, given that we aim at its <code>id</code> attribute. In our case, we aim at <code>#2</code>, scrolling the user's view to the tag with an <code>id=2</code>.
</li>
</ul>
Generally speaking, URLs have a fairly standardized structure, where certain elements are optional, while others aren't:
<pre><code class="hljs">&lt;protocol&gt;//&lt;domain&gt;:&lt;port&gt;/&lt;path&gt;/&lt;query&gt;&lt;hash&gt;
</code></pre>
Now, we can take a closer look at how to access the current URL, as well as each of its components using JavaScript.
<h2 id="howtogetcurrenturlinjavascript">How to Get Current URL in JavaScript</h2>
In JavaScript, the <code>Location</code> object contains the information regarding the URL of the currently loaded webpage. It belongs to <code>window</code>, though, we can access it directly because <code>window</code> is hierarchically located at the top of the scope
To get the current URL, we'll leverage the <code>Location</code> object and retrieve its <code>href</code> property:
<pre><code class="hljs">let url = window.location.href
console.log(url)
</code></pre>
This results in:
<pre><code class="hljs">https://www.stackabuse.com:8080/python/article-title.html?searchterm=Example+title#2
</code></pre>
The <code>href</code> property contains the full URL to the currently loaded resource. If you'd like to retrieve some certain components, rather than the entire URL, the <code>Location</code> object has various properties as well.
<h3 id="geturlorigin">Get URL Origin</h3>
The <code>window.location.origin</code> property returns the base URL (protocol + hostname + port number) of the current URL:
<pre><code class="hljs">console.log(window.location.origin)
</code></pre>
<pre><code class="hljs">https://www.stackabuse.com:8080
</code></pre>
<h3 id="geturlprotocol">Get URL Protocol</h3>
The <code>window.location.protocol</code> property returns the protocol used by the current URL:
<pre><code class="hljs">console.log(window.location.protocol)
</code></pre>
<pre><code class="hljs">https://
</code></pre>
<h3 id="geturlhostandhostname">Get URL Host and Hostname</h3>
The <code>window.location.host</code> property returns the hostname and the port number of the current URL:
<pre><code class="hljs">console.log(window.location.host)
</code></pre>
<pre><code class="hljs">www.stackabuse.com:8080
</code></pre>
On the other hand, the <code>window.location.hostname</code> property returns the hostname of the current URL:
<pre><code class="hljs">console.log(window.location.hostname)
</code></pre>
<pre><code class="hljs">www.stackabuse.com
</code></pre>
<h3 id="geturlport">Get URL Port</h3>
The <code>window.location.port</code> property returns the port number of the current URL:
<pre><code class="hljs">console.log(window.location.port)
</code></pre>
<pre><code class="hljs">8080
</code></pre>
<h3 id="geturlpath">GET URL Path</h3>
The <code>window.location.pathname</code> property returns the path section of the current URL:
<pre><code class="hljs">console.log(window.location.pathname)
</code></pre>
<pre><code class="hljs">/category/article-title.html
</code></pre>
<h3 id="geturlqueryandhash">Get URL Query and Hash</h3>
The <code>window.location.search</code> property returns **the query section ** of the current URL:
<pre><code class="hljs">console.log(window.location.search)
</code></pre>
<pre><code class="hljs">?searchterm=Example+title
</code></pre>
The <code>window.location.hash</code> property returns the hash section of the current URL:
<pre><code class="hljs">console.log(window.location.hash)
</code></pre>
<pre><code class="hljs">#2
</code></pre>
<h2 id="conclusion">Conclusion</h2>
As we've seen, JavaScript provides a powerful, yet simple, way of accessing the current URL. The <code>Location</code> object, accessed by the <code>Window</code> interface enables us to get not only the string representation of the current URL but every single section of it.
The <code>Location</code> object also can change and manipulate the current URL, <a target="_blank" href="https://stackabuse.com/javascript-how-to-redirect-to-another-webpage/">as well as redirect the page to the new URL</a>.

David Landup

Dimitrije Stamenic

In this tutorial, we'll take a look at how to get the current URL in JavaScript, including its components such as the protocol, domain, port, path, query and hash.

JavaScript: Get Current URL and Components (Protocol, Domain, Port, Path, Query, Hash)

<h2 id="introduction">Introduction</h2>
Oftentimes, we need to redirect users to another website or another web page on the same site. There are several ways to redirect which include JavaScript redirection, server-side redirection, and HTML meta refresh redirection. Redirection is basically a mechanism to send users to another URL address.
The motivation to use redirection can vary, in most cases, it's because:
<ul>
<li>
You moved to another domain for any reason, so you can redirect users to the new domain when they access the content on an older domain.
</li>
<li>
You have multiple pages whose content varies based on location, language, browsers, or other factors based on which you redirect users to the most suitable page.
</li>
<li>
You redirect unauthenticated or unauthorized users' requests to resources to a login page.
</li>
<li>
You send users to other pages correlated with the content of the current site.
</li>
</ul>
All of these are practically achieved through the <code>Location</code> object that contains URL information. There are a few ways to do this, by fiddling around with different properties of the <code>Location</code> object. In this tutorial, we'll take a look at how to redirect a user to a different webpage in JavaScript and what to look out for to minimize the potential negative SEO impact.
<h2 id="thewindowlocationproperty">The window.location Property</h2>
The <code>window.location</code> object denotes the current location, or rather, URL of the window/user. It's technically a read-only property, though, nevertheless, we can manipulate it by assigning new values (<code>DOMString</code>s) to its properties. The <code>windows</code> prefix in <code>windows.location</code> object can be omitted since it is hierarchically located at the top of the scope.
<h2 id="redirectuserswithlocationhref">Redirect Users with location.href</h2>
The <code>location.href</code> property denotes the current URL as a String. Changing the <code>href</code> property will automatically also navigate the user to the new <code>href</code> value. Changing the <code>href</code> property is as easy as simply assigning a new value to it:
<pre><code class="hljs">location.href = &quot;https://stackabuse.com/&quot;;
</code></pre>
Note: A functionally equivalent line of code is:
<pre><code class="hljs">windows.location = &quot;https://stackabuse.com&quot;;
</code></pre>
It's worth noting that you can redirect a user to a domain other than the domain they're currently on with this approach, though, security issues can arise from this, so the practice should be avoided if possible.
Redirection is typically tied to some sort of event, such as pressing a button that redirects a user to a different webpage, or other events, such as a user performing some operation on a website (uploading an image on social media, after which they're redirected to that post, for example). Let's write a simple function that redirects a user on the click of a button:
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html lang=&quot;en&quot;&gt;
&lt;head&gt;
 &lt;title&gt;Redirection&lt;/title&gt;
 &lt;script type = &quot;text/javascript&quot;&gt;
 function Redirect() {
 window.location.href = &quot;https://stackabuse.com/&quot;;
 }
 &lt;/script&gt;
&lt;/head&gt;
&lt;body&gt;
 &lt;input type=&quot;button&quot; value=&quot;Redirect Me&quot; onclick=&quot;Redirect()&quot;/&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>
Setting the <code>href</code> property is similar to what a mouse-click would do.
<h2 id="redirectuserswithlocationassign">Redirect Users with location.assign()</h2>
The <code>location.assign(url)</code> method loads the resource in the provided <code>url</code>, and displays it in the <code>window</code>. This is actually the preferred approach to redirecting users compared to setting the <code>href</code> property, since it also checks for the safety of the provided <code>url</code>, throwing an exception if it's not a safe destination. Another benefit is that it creates a new entry in the browser's history, allowing the user to gracefully go &quot;Back&quot; if they'd like to.
It's also worth noting that <code>location.assign()</code> doesn't allow cross-origin redirection. You can only redirect to the same domain in which the call is made, which has a positive impact on security.
Other than that, it can be used in much the same way as assigning a new value to <code>location.href</code>. Let's rewrite our page to use the <code>assign()</code> function instead:
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html lang=&quot;en&quot;&gt;
&lt;head&gt;
 &lt;title&gt;Assigning&lt;/title&gt;
 &lt;script type = &quot;text/javascript&quot;&gt;
 function Assign() {
 window.location.assign(&quot;https://stackabuse.com/&quot;);
 }
 &lt;/script&gt;
&lt;/head&gt;
&lt;body&gt;
 &lt;input type=&quot;button&quot; value=&quot;Redirect Me&quot; onclick=&quot;Assign()&quot; /&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>
<h2 id="redirectuserswithlocationreplace">Redirect Users with location.replace()</h2>
The <code>replace(url)</code> method can be used to replace the current resource on the <code>window</code>, with the resource loaded from the <code>url</code>. It doesn't really redirect a user, and doesn't get stored in the browser's history. The same security-constraints exist as with the <code>assign()</code> method, which makes this a desirable method to use if you'd like to replace the content by another page:
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html lang=&quot;en&quot;&gt;
&lt;head&gt;
 &lt;title&gt;Replacing&lt;/title&gt;
 &lt;script type = &quot;text/javascript&quot;&gt;
 function Replace() {
 window.location.Replace(&quot;https://stackabuse.com&quot;);
 }
 &lt;/script&gt;
&lt;/head&gt;
&lt;body&gt;
 &lt;input type=&quot;button&quot; value=&quot;Redirect Me&quot; onclick=&quot;Replace()&quot; /&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>
It's also worth noting that the <code>assign()</code> method has a serious potential downside. If the user is to go back onto a page which automatically runs the <code>assign()</code> method, they'll be redirected back to the page they've tried going back from. They'd then enter a loop of going &quot;back&quot; via the Back Button, but being redirected to another page due to the <code>assign()</code> method.
If you're using <code>assign()</code>, make sure that it's not automatically called on the page, and that its invocation requires a user's action, such as invoking it on a button press. If not - use <code>location.replace()</code>.
Additionally, <code>location.replace()</code> is the closest to an HTTP redirect, since the original link doesn't get added to the browser's history.
<h2 id="securityimplicationsandsideeffects">Security Implications and Side-Effects</h2>
The mentioned security applies to all of the methods above and it refers to the following aspects:
<ul>
<li>
If the origin of the script that's calling the method are not the same as the origins of the current page - it will be treated as a security violation and <a rel="nofollow noopener" target="_blank" href="https://developer.mozilla.org/en-US/docs/Web/API/DOMException">DOMException</a> of <code>SECURITY_ERROR</code> type will be thrown. That's to say, external libraries and services embedded into your own page won't be able to redirect users. This kind of restriction highlights the importance of conducting a proper <a target="_blank" rel="noopener noreferrer" href="https://www.getastra.com/blog/dast/what-is-dast/">security risk assessment</a> when integrating external scripts.
</li>
<li>
If the stored URL is invalid, a <code>DOMException</code> will be thrown.
</li>
<li>
If you're redirecting a user to a domain other than the domain they were already on, <a target="_blank" rel="nofollow noopener" href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS">CORS</a> may kick in and prevent it.
</li>
</ul>
Some of the possible side-effects that could happen due to human-induced design issues are:
<ul>
<li>When redirection (other than <code>replace()</code>) occurs too quickly (i.e. in less than 3 seconds) it can break the back button on a browser. This means that each time you try to move back to the previous page, the redirection will occur once again almost immediately, creating an infinite loop.</li>
<li>It can be considered as Doorway Page(i.e pages created for SEO indexes manipulation) which is not recommended</li>
<li>Poorly planned and used redirections can cause chain redirects, redirecting between two or more pages.</li>
</ul>
<h3 id="influenceonseo">Influence on SEO</h3>
There are many factors that affect SEO, and a lot of them aren't actually publicly known, lest they be abused. Though, what's certain is that poorly optimized code can make a negative impact on SEO. It can lead to longer load times, chains of redirects, or even loops. Some web crawlers may try to execute JavaScript code to get a more accurate representation of the page, but those that don’t can result in having a lower SEO “score”.
The best way to overcome these issue may be:
<ul>
<li>
To either properly issue an HTTP redirect on the server-side with any of the redirect status codes (<code>301..308</code>), or to issue a <code>404</code> for the pages you no longer want to host or to redirect to.
</li>
<li>
To inform search engines of a duplicate page by adding <code>&lt;link rel=&quot;canonical&quot; href=&quot;https://original_link&quot;/&gt;</code> in the <code>&lt;head&gt;&lt;/head&gt;</code> section. This is easier to implement than doing any additional work on the server-side, but keep in mind that not all web crawlers will appreciate it.
</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to perform a redirect using JavaScript, as well as the security implications and potential influence on SEO.

Guest Contributor

In this tutorial, we'll take a look at examples, pros and cons of several approaches on how to redirect a user to another page or URL in JavaScript.

JavaScript: How to Redirect to Another Webpage

<h2 id="introduction">Introduction</h2>
A Java Map implementation is an collection that maps keys to values. Every Map Entry contains key/value pairs, and every key is associated with exactly one value. The keys are unique, so no duplicates are possible.
A common implementation of the <code>Map</code> interface is a <code>HashMap</code>:
<pre><code class="hljs">Map&lt;Integer, String&gt; students = new HashMap&lt;&gt;();
students.put(132, &quot;James&quot;);
students.put(256, &quot;Amy&quot;);
students.put(115, &quot;Young&quot;);

System.out.println(&quot;Print Map: &quot; + students);
</code></pre>
We've created a simple map of students (Strings) and their respective IDs:
<pre><code class="hljs">Print Map: {256=Amy, 115=Young, 123=James}
</code></pre>
A Java List implementation is a collection that sequentially stores references to elements. Each element has an index and is uniquely identified by it:
<pre><code class="hljs">List&lt;String&gt; list = new ArrayList&lt;&gt;(Arrays.asList(&quot;James&quot;, &quot;Amy&quot;, &quot;Young&quot;));
System.out.println(list);
System.out.println(String.format(&quot;Third element: %s&quot;, list.get(2));
</code></pre>
<pre><code class="hljs">[James, Amy, Young]
Third element: Young
</code></pre>
<blockquote>
The key difference is: Maps have two dimensions, while Lists have one dimension.
</blockquote>
Though, this doesn't stop us from converting Maps to Lists through several approaches. In this tutorial, we'll take a look at how to convert a Java Map to a Java List:
<ul>
<li><a href="#convertmaptolistofmapentrykv">Convert Map to List of Map.Entry&lt;K,V&gt;</a></li>
<li><a href="#convertmaptolistusingtwolists">Convert Map to List using Two Lists</a></li>
<li><a href="#convertmaptolistwithcollectorstolistandstreammap">Collectors.toList and Stream.map()</a></li>
<li><a href="#convertmaptolistwithstreamfilterandstreamsorted">Stream.filter() and Stream.sorted()</a></li>
<li><a href="#convertmaptolistwithstreamflatmap">Stream.flatMap()</a></li>
</ul>
<h2 id="convertmaptolistofmapentrykv">Convert Map to List of Map.Entry&lt;K,V&gt;</h2>
Java 8 introduced us to the Stream API - which were meant as a step towards integrating Functional Programming into Java to make laborious, bulky tasks more readable and simple. Streams work wonderfully with collections, and can aid us in converting a Map to a List.
The easiest way to preserve the key-value mappings of a <code>Map</code>, while still converting it into a <code>List</code> would be to <code>stream()</code> the entries, which consist of the key-value pairs.
The <code>entrySet()</code> method returns a <code>Set</code> of <code>Map.Entry&lt;K,V&gt;</code> elements, which can easily be converted into a <code>List</code>, given that they both implement <code>Collection</code>:
<pre><code class="hljs">List&lt;Map.Entry&lt;Integer, String&gt;&gt; singleList = students.entrySet()
 .stream()
 .collect(Collectors.toList());
 
System.out.println(&quot;Single list: &quot; + singleList);
</code></pre>
This results in:
<pre><code class="hljs">Single list: [256=Amy, 115=Young, 132=James]
</code></pre>
Since Streams are not collections themselves - they just stream data from a Collection - <code>Collectors</code> are used to collect the result of a <code>Stream</code>'s operations back into a <code>Collection</code>. One of the Collectors that we can use is <code>Collectors.toList()</code>, which collects elements into a <code>List</code>.
<h2 id="convertmaptolistusingtwolists">Convert Map to List using Two Lists</h2>
Since Maps are two-dimensional collections, while Lists are one-dimensional collections - the other approach would be to convert a <code>Map</code> to two <code>List</code>s, one of which will contain the Map's keys, while the other would contain the Map's values.
Thankfully, we can easily access the keys and values of a map through the <code>keySet()</code> and <code>values()</code> methods.
The <code>keySet()</code> method returns a <code>Set</code> of all the keys, which is to be expected, since keys have to be unique. Due to the flexibility of Java Collections - we can create a <code>List</code> from a <code>Set</code> simply by passing a <code>Set</code> into a <code>List</code>'s constructor.
The <code>values()</code> method returns a <code>Collection</code> of the values in the map, and naturally, since a <code>List implements Collection</code>, the conversion is as easy as passing it in the <code>List</code>'s constructor:
<pre><code class="hljs">List&lt;Integer&gt; keyList = new ArrayList(students.keySet());
List&lt;String&gt; valueList = new ArrayList(students.values());

System.out.println(&quot;Key List: &quot; + keyList);
System.out.println(&quot;Value List: &quot; + valueList);
</code></pre>
This results in:
<pre><code class="hljs">Key List: [256, 115, 132]
Value List: [Amy, Young, James]
</code></pre>
<h2 id="convertmaptolistwithcollectorstolistandstreammap">Convert Map to List with Collectors.toList() and Stream.map()</h2>
We'll <code>steam()</code> the keys and values of a <code>Map</code>, and then <code>collect()</code> them into a <code>List</code>:
<pre><code class="hljs">List&lt;Integer&gt; keyList = students.keySet().stream().collect(Collectors.toList());
System.out.println(&quot;Key list: &quot; + keyList);

List&lt;String&gt; valueList = students.values().stream().collect(Collectors.toList());
System.out.println(&quot;Value list: &quot; + valueList);
</code></pre>
This results in:
<pre><code class="hljs">Key list: [256, 115, 132]
Value list: [Amy, Young, James]
</code></pre>
This approach has the advantage of allowing us to perform various other operations or transformations on the data before collecting it. For example, knowing that we're working with Strings - we could attach an anonymous function (<a target="_blank" href="/lambda-expressions-in-java/">Lambda Expression</a>). For example, we could reverse the bytes of each <code>Integer</code> (key) and lowercase every <code>String</code> (value) before collecting them into a <code>List</code>:
<pre><code class="hljs">List&lt;Integer&gt; keyList = students.keySet()
 .stream()
 .map(Integer::reverseBytes)
 .collect(Collectors.toList());
 
System.out.println(&quot;Key list: &quot; + keyList);

List&lt;String&gt; valueList = students.values()
 .stream()
 .map(String::toLowerCase)
 .collect(Collectors.toList());
 
System.out.println(&quot;Value list: &quot; + valueList);
</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>map()</code> method returns a new <code>Stream</code> in which the provided Lambda Expression is applied to each element. If you'd like to read more about the <code>Stream.map()</code> method, read our <a target="_blank" href="/java-8-stream-map-examples/">Java 8 - Stream.map()</a> tutorial.

 </div>
 </div>
 </div>
 Running this code transforms each value in the streams before returning them as lists:
<pre><code class="hljs">Key list: [65536, 1929379840, -2080374784]
Value list: [amy, young, james]
</code></pre>
We can also use <code>Collectors.toCollection()</code> method, which allows us to chose the particular <code>List</code> implementation:
<pre><code class="hljs">List&lt;Integer&gt; keyList = students.keySet()
 .stream()
 .collect(Collectors.toCollection(ArrayList::new));
List&lt;String&gt; valueList = students.values()
 .stream()
 .collect(Collectors.toCollection(ArrayList::new));

System.out.println(&quot;Key list: &quot; + keyList);
System.out.println(&quot;Value list: &quot; + valueList);
</code></pre>
This results in:
<pre><code class="hljs">Key list: [256, 115, 132]
Value list: [Amy, Young, James]
</code></pre>
<h2 id="convertmaptolistwithstreamfilterandstreamsorted">Convert Map to List with <code>Stream.filter()</code> and <code>Stream.sorted()</code></h2>
We're not only limited to mapping values to their transformations with <code>Stream</code>s. We can also filter and sort collections, so that the lists we're creating have certain picked elements. This is easily achieved through <code>sorted()</code> and <code>filter()</code>:
<pre><code class="hljs">List&lt;String&gt; sortedValueList = students.values()
 .stream()
 .sorted()
 .collect(Collectors.toList());
 
System.out.println(&quot;Sorted Values: &quot; + sortedValueList);
</code></pre>
After we sorted the values we get the following result:
<pre><code class="hljs">Sorted Values: [Amy, James, Young]
</code></pre>
We can also pass in a custom comparator to the <code>sorted()</code> method:
<pre><code class="hljs">List&lt;String&gt; sortedValueList = students.values()
 .stream()
 .filter(value-&gt; value.startsWith(&quot;J&quot;))
 .collect(Collectors.toList());
 
System.out.println(&quot;Sorted Values: &quot; + sortedValueList);
</code></pre>
Which results in:
<pre><code class="hljs">Sorted Values: [James]
</code></pre>
If you'd like to read more about the <code>sorted()</code> method and how to use it - we've got a guide on <a target="_blank" href="/java-8-how-to-sort-list-with-stream-sorted/">How to Sort a List with Stream.sorted()</a>.
<h2 id="convertmaptolistwithstreamflatmap">Convert Map to List with <code>Stream.flatMap()</code></h2>
The <code>flatMap()</code> is yet another <code>Stream</code> method, used to flatten a two-dimensional stream of a collection into a one-dimensional stream of a collection. While <code>Stream.map()</code> provides us with an A-&gt;B mapping, the <code>Stream.flatMap()</code> method provides us with a A -&gt; Stream&lt;B&gt; mapping, which is then flattened into a single Stream again.
If we have a two-dimensional Stream or a Stream of Streams, we can flatten it into a single one. This is conceptually very similar to what we're trying to do - convert a 2D Collection into a 1D Collection. Let's mix things up a bit by creating a Map&lt;K,V&gt; where the keys are of type <code>Integer</code> while the values are of type <code>List&lt;String&gt;</code>:
<pre><code class="hljs">Map&lt;Integer, List&lt;String&gt;&gt; newMap = new HashMap&lt;&gt;();

List&lt;String&gt; firstName = new ArrayList();
firstName.add(0, &quot;Jon&quot;);
firstName.add(1, &quot;Johnson&quot;);
List&lt;String&gt; secondName = new ArrayList();
secondName.add(0, &quot;Peter&quot;);
secondName.add(1, &quot;Malone&quot;);

// Insert elements into the Map
newMap.put(1, firstName);
newMap.put(2, secondName);

List&lt;String&gt; valueList = newMap.values()
 .stream()
 // Aforementioned A -&gt; Stream&lt;B&gt; mapping
 .flatMap(e -&gt; e.stream())
 .collect(Collectors.toList());

System.out.println(valueList);
</code></pre>
This results in:
<pre><code class="hljs">[Jon, Johnson, Peter, Malone]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we have seen how to convert Map to List in Java in several ways with or without using Java 8 stream API.

Ognjen Jankovic

In this tutorial, we'll take a look at how to convert a Java Map to a Java List with Streams, Stream.map(), Stream.filter(), Stream.sorted() and Stream.flatMap(), with examples.

Java 8: How to Convert a Map to List

<h2 id="introduction">Introduction</h2>
As developers, we're encouraged from the start of the journey to write clean code. Equally as important, but less talked about is writing and using secure code.
In Python projects, we typically install modules and third-party packages to avoid developing solutions that already exist. However, this common practice is why hackers exploit dependencies to wreak havoc in our software, and why we need to be able to detect when something is amiss. As such, we use tools like <a rel="nofollow noopener" href="https://bandit.readthedocs.io/en/latest/" target="_blank">Bandit</a>, an open-source security analysis utility for Python projects.
In this guide - we'll explore how simple lines of code can end up being destructive, and how we can use Bandit to help us identify them.
<h2 id="securityvulnerabilitiesinpython">Security Vulnerabilities in Python</h2>
A security vulnerability in our code is a flaw that malicious agents can take advantage of to exploit our systems and/or data. As you program in Python, there could be some vulnerable usage of functional calls or module imports that may be safe when invoked locally but could open doors for malicious users to tamper with the system when deployed without the right configurations.
You've probably come across several of these in your day-to-day coding activities. Some of the more common attacks and exploits are largely dealt with by modern frameworks and systems which anticipate such attacks.
Here are a few:
<ul>
<li>OS Command Injection - Based on the humble <code>subprocess</code> module that you use to execute command-line utilities and invoke OS-related processes. The following snippet uses the <code>subprocess</code> module to perform a DNS lookup and returns the output:</li>
</ul>
<pre><code class="hljs"># nslookup.py
import subprocess
domain = input(&quot;Enter the Domain: &quot;)
output = subprocess.check_output(f&quot;nslookup {domain}&quot;, shell=True, encoding=&#x27;UTF-8&#x27;)
print(output)
</code></pre>
What could go wrong here?
In an ideal scenario, the end-user will provide a DNS and the script returns the results of the <code>nslookup</code> command. But, if they were to provide an OS-based command such as <code>ls</code> along with the DNS, the following output is received - the command would be run too:
<pre><code class="hljs">$ python3 nslookup.py
Enter the Domain: stackabuse.com ; ls
Server: 218.248.112.65
Address: 218.248.112.65#53

Non-authoritative answer:
Name: stackabuse.com
Address: 172.67.136.166
Name: stackabuse.com
Address: 104.21.62.141
Name: stackabuse.com
Address: 2606:4700:3034::ac43:88a6
Name: stackabuse.com
Address: 2606:4700:3036::6815:3e8d

config.yml
nslookup.py
</code></pre>
By allowing someone to pass in a part of a command - we've let them access the OS-level terminal.
Imagine how destructive things might get, if the malicious actor were to provide a command such as <code>cat /etc/passwd</code> which would reveal the passwords of the existing users. As simple as it sounds, the <code>subprocess</code> module can be very risky to use.
<ul>
<li>SQL Injection - SQL Injection attacks are rare these days, thanks to the ORM functionalities which are widely being used. But if you are still aligned to using raw SQL, you need to be aware of how your SQL queries are constructed and how safe your query parameters are validated and passed in.</li>
</ul>
Consider the following snippet:
<pre><code class="hljs">from django.db import connection

def find_user(username):
 with connection.cursor() as cur:
 cur.execute(f&quot;&quot;&quot;select username from USERS where name = &#x27;%s&#x27;&quot;&quot;&quot; % username)
 output = cur.fetchone()
 return output
</code></pre>
The function call is simple - you pass in a string as an argument, say <code>&quot;Foobar&quot;</code> and the string gets inserted into the SQL query, resulting in:
<pre><code class="hljs">select username from USERS where name = &#x27;Foobar&#x27;
</code></pre>
However, much like the previous issue - if someone were to add a <code>;</code> character, they could chain multiple commands. For example, inserting <code>'; DROP TABLE USERS; --</code> would result in:
<pre><code class="hljs">select username from USERS where name = &#x27;&#x27;; DROP TABLE USERS; --&#x27;
</code></pre>
The first statement would run, right before the database drops the entire <code>USERS</code> table. Yikes!
Notice how the last quote has been commented out using the double dashes. SQL query parameters can become nightmares, if not reviewed properly. Here's where security tools can help in spotting such unintentional yet harmful lines of code.
<h2 id="bandit">Bandit</h2>
<code>Bandit</code> is an open-source tool written in Python that helps you analyze your Python code and find common security issues in it. It will be able to scan your Python code, spot the vulnerabilities and exploits such as the ones that were mentioned in the previous section. Bandit can be installed locally or inside your virtual environment easily via <code>pip</code>:
<pre><code class="hljs">$ pip install bandit
</code></pre>
Bandit can be used from the following perspectives:
<ul>
<li>DevSecOps: Including Bandit as a part of the Continuous Integration (CI) Practices.</li>
<li>Development: Bandit can be used locally as part of the local development setup, where the developers can have control over function exploitation before committing the code.</li>
</ul>
<h2 id="usingbandit">Using Bandit</h2>
Bandit can be easily integrated as part of the CI tests, and common vulnerability checks can be performed before shipping the code to production. For example, DevSecOps Engineers can invoke Bandit whenever a pull request is raised or code is being committed, for enhanced security. Based on the organization guidelines, the import modules and function calls can be allowed or restricted.
Bandit provides control to the users on which modules to use and which modules to blacklist. This control is defined inside the configuration file, which can be generated using the <code>bandit-config-generator</code> tool. The output of the code tests that are run can be exported in the form of CSV, JSON, etc.
The configuration file can be generated as:
<pre><code class="hljs">$ bandit-config-generator -o config.yml
</code></pre>
The generated <code>config.yml</code> file contains several parts corresponding to the tests that can be allowed or revoked, function calls that can be allowed or revoked, along the maximum length of cryptographic keys. The user may use bandit by specifying this configuration file or perform all tests simply by passing in the project's directory:
<pre><code class="hljs">$ bandit -r code/ -f csv -o out.csv
[main] INFO profile include tests: None
[main] INFO profile exclude tests: None
[main] INFO cli include tests: None
[main] INFO cli exclude tests: None
[main] INFO running on Python 3.8.5
434 [0.. 50.. 100.. 150.. 200.. 250.. 300.. 350.. 400.. ]
[csv] INFO CSV output written to file: out.csv
</code></pre>
In this Bandit call, you will be specifying the project directory using the <code>-r</code> flag and writing the output as a CSV using the <code>-o</code> flag. Bandit tests all the python scripts inside this project directory and returns the output as a CSV. The output is very detailed and here's what it looks like:
<img src="https://stackabuse.s3.amazonaws.com/media/checking-vulnerabilities-in-your-python-code-with-bandit-01.png" alt="Fig 1. Bandit Output">
As mentioned in the previous section, the <code>subprocess</code> module import and the <code>shell=True</code> argument are of high-security threat. If it's inevitable to use this module and argument, these can be whitelisted in the configuration file and make it skip the tests by including the codes <code>B602</code> (subprocess_popen_with_shell_equals_true) and <code>B404</code> (import_subprocess) in &quot;skips&quot;. You may find these codes in the generated config file. The tests that are included in the file in the <code>skips</code> section as:
<pre><code class="hljs">skips: [B602, B404]
</code></pre>
If you re-run the Bandit tests again using the generated configuration file, this will result in an empty CSV file that denotes that all tests were passed:
<pre><code class="hljs">&gt; bandit -c code/config.yml -r code/ -f csv -o out2.csv
[main] INFO profile include tests: None
[main] INFO profile exclude tests: B404,B602
[main] INFO cli include tests: None
[main] INFO cli exclude tests: None
[main] INFO using config: code/config.yml
[main] INFO running on Python 3.8.5
434 [0.. 50.. 100.. 150.. 200.. 250.. 300.. 350.. 400.. ]
[csv] INFO CSV output written to file: out2.csv
</code></pre>
For collaborations inside an organization, this bandit configuration file needs to be embedded in newly created projects so that the developers can have access to it even locally.
<h2 id="conclusion">Conclusion</h2>
Code should be clean and safe. In this short guide, we've taken a look at Bandit, a Python library used for identifying commonplace security issues with modules you're probably already using.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

In this article, you will be exploring how to use Bandit - an open source security analyzer for Python projects. Bandits generates reports on vulnerabilities in our code!

Checking Vulnerabilities in Your Python Code with Bandit

Rayven Yor Esplanada

In this tutorial, we'll take a look at how to perform Unit Testing on Spring Boot REST APIs with examples, using JUnit, Mockito and MockMVC.

Guide to Unit Testing Spring Boot REST APIs

In this introduction to Brython, we'll take a look at what it is, how to install it, and how to initialize a Brython project, as well as how to perform basic tasks, with examples.

An Introductory Guide to Brython

In this tutorial, we'll take a look at how to change an element's class in JavaScript using className and classList for modern browsers, with practical examples.

How to Change Element's Class with JavaScript - className and classList

<h2 id="introduction">Introduction</h2>
Getting the last element of a list/array is a common operation. In this tutorial, we'll take a look at how to get the last element in a JavaScript array/list.
JavaScript is a weakly-typed or untyped language, which means that the type of variable doesn't need to be declared before using it, since JavaScript determines the type by reading the variable's value.
<code>var x = &quot;something&quot;</code> is evaluated, and <code>x</code> is assigned to a String type. The same process applies to lists - you don't need to define a list's type, you can just fill the list up with values.
A list is defined by putting the elements in between the square brackets (<code>[]</code>), where the elements can be heterogeneous (don't have to be of the same type):
<pre><code class="hljs">var myList = [&quot;Peter&quot;, &quot;Smith&quot;, 25, 23, &quot;Random String&quot;, 10]
</code></pre>
JavaScript has a lot of built-in methods that can be used to manipulate lists like this one. Here are the ones we'll be using to get the last element.
<h2 id="getlastelementusinglength">Get Last Element Using length</h2>
The <code>length</code> attribute of a list denotes the number of elements in a list:
<pre><code class="hljs">console.log(myList.length)
</code></pre>
Element indexing in arrays/lists in JavaScript is much akin to other languages. We can access an element, based on its index, by passing it in square brackets <code>[]</code>, referencing the array. The last element has the index of <code>length-1</code>.
Since the <code>length</code> field just returns the saved value of elements - this is a fast, efficient and cheap operation. The best way to get the last element of a JavaScript array/list is:
<pre><code class="hljs">var lastElement = myList[myList.length - 1];
console.log(lastElement);
</code></pre>
This results in:
<pre><code class="hljs">10
</code></pre>
<h2 id="getlastelementusingpop">Get Last Element Using pop()</h2>
The <code>pop()</code> method returns the last element of a collection, but removes it during the process. Though, if we use the spread operator from ES6 - we can avoid this functionality by temporarily copying the list in memory, and performing <code>pop()</code> on the copy, keeping the original list intact.
<h3 id="thepopmethod">The pop() Method</h3>
Let's <code>pop()</code> the last element off the list:
<pre><code class="hljs">var lastElement = myList.pop();
console.log(lastElement)
console.log(myList)
</code></pre>
This results in the list being cut short of that element:
<pre><code class="hljs">10
[&quot;Peter&quot;, &quot;Smith&quot;, 25, 23, &quot;Random String&quot;]
</code></pre>
If you don't need the original list to stay intact, then you can pop elements off of it, but if you do need the original, you can make a copy and <code>pop()</code> from it.
<h3 id="popwithes6spreadoperator">pop() with ES6' Spread Operator</h3>
ES6 is short for EcmaScript6, which is a JavaScript standard used to make programming in JavaScript easier (to code less, but do more).
It was founded back in 1997 and its first major breakthrough was in 2015, with the ES6 standard (or EcmaScript2015). The latest version is the 11th one, developed in 2020. All versions are meant to make coding easier in JavaScript (with new syntax rules, new keywords, etc.).
The feature that we can leverage here is the <a target="_blank" href="https://stackabuse.com/spread-operator-in-javascript/">spread operator (<code>...</code>)</a>.
Amongst other features, the spread operator can copy lists/arrays:
<pre><code class="hljs">[...myList]
</code></pre>
This generates a new list, with the same elements as <code>myList</code>. That being said - we can <code>pop()</code> from the new list instead of the original one:
<pre><code class="hljs">console.log([...myList].pop())
console.log(myList)
</code></pre>
This results in:
<pre><code class="hljs">10
[&quot;Peter&quot;, &quot;Smith&quot;, 25, 23, &quot;Random String&quot;, 10]
</code></pre>
Note: This may be convenient to write, but is not the cheapest of solutions, since it copies a list. For small lists, it doesn't reduce the performance by much, but with longer lists, this is an inefficient way to simply get the last element.
<h2 id="getlastelementusingslice">Get Last Element Using slice()</h2>
The <code>slice(a, b)</code> method 'slices' the array from point <code>a</code> to point <code>b-1</code> - given that <code>a</code> and <code>b</code> are integers. In a more mathematical way, you can look at slice like this: <code>[a, b)</code> - the element at <code>a</code> is included, whilst the element at <code>b</code> is not:
<pre><code class="hljs">console.log(myList.slice(1, 4))
</code></pre>
This results in a slice of the original array:
<pre><code class="hljs">[&quot;Smith&quot;, 25, 23]
</code></pre>
The <code>slice()</code> method also accepts negative indexing - where it iterates through the collection backwards. So if we <code>slice(-4, -1)</code>, the iteration will start from the third element from the back and end at one before the last one (because <code>slice</code> doesn't include the <code>b</code> point).
This allows us to simply include one last element, from the end of the list via <code>slice()</code>:
<pre><code class="hljs">console.log(myList.slice(-1))
</code></pre>
Which results in:
<pre><code class="hljs">[10]
</code></pre>
This is still an array, so to get this element we access it with <code>myList.slice(-1)[0]</code> - which will return our element:
<pre><code class="hljs">console.log(myList.slice(-1)[0])
</code></pre>
Note: <code>slice()</code> is best used when you want to retrieve the last N elements of an array, rather than one, since you can simply use <code>length-1</code> instead.
<h2 id="getlastelementusingreverse">Get Last Element Using reverse()</h2>
The <code>reverse()</code> method reverses the list in-place. The last element will become the first, and vice-versa:
<pre><code class="hljs">console.log(myList.reverse())
</code></pre>
The output will be:
<pre><code class="hljs">[10, &#x27;Random String&#x27;, 23, 25, &#x27;Smith&#x27;, &#x27;Peter&#x27;]
</code></pre>
Now our element is the first one, so we can access it with <code>myListReversed[0]</code>.
Note: Reversing an array/list is also a potentially very expensive operation. Avoid reversing the collection if the only thing you want to do is access the last element. If you are to reverse it anyway - you can access the element like this. If not, refer to the first approach of using <code>length-1</code>.
<h2 id="conclusion">Conclusion</h2>
The cheapest, most efficient, and probably most intuitive method of these is the first - <code>myList[myList.length()-1]</code>. This is what you'll be using most of the time.
Using <code>pop()</code> removes the element from the list and returns it. If you want to remove the element - this is the approach you'll want to be using, since otherwise, you'll have to remove the element manually.
<code>slice()</code> gives us a slice, which is a great approach if we want to get the last N elements.
<code>reverse()</code> reverses the array in-place and should be avoided if you just want to get an element. If you're reversing the array anyway, though, this doesn't cost anything extra.

In this tutorial, we'll take a look at how to get the last element in a JavaScript collection such as an array or list, with practical examples and comparison.