<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.</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

David Landup

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

Dimitrije Stamenic

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

Lazar Ristic

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.

JavaScript: Get Last Element in List

<h2 id="introduction">Introduction</h2>
Package managers are tools commonly created for programming languages that make the setup and management of third-party packages easier. Pip is the preferred package manager in Python for both the native Pip modules and the ones installed inside the virtual environments.
When Pip is invoked, it automatically crawls against the repository of public Python packages (the Python Package Index, also known as PyPI), downloads the package(s), and installs the setup files.
In this article, we will be learning to install Pip in Windows-based Operating systems.
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-install-pip-on-windows-01.jpg" alt="Pip Installation on Windows">
<h2 id="pythoninstallation">Python Installation</h2>
Let's check if Python and Pip are already installed on our Windows-based OS. Let's fire up our Windows Terminal from the start menu - we'll be using PowerShell through it. You can also use the PowerShell Terminal, but Windows Terminal gives you a better developer experience, and gives you easy access to other powerful Linux or macOS shells. Once the window opens, key in the following command to check if Python is installed:
<pre><code class="hljs">PS C:\&gt; python --version
Python was not found; run without arguments to install from the Microsoft Store, or disable this shortcut from Settings &gt; Manage App Execution Aliases.
</code></pre>
If you are looking at a message like that of the above, Python is not installed on your machine. You may download the latest version of Python from <a href="https://www.python.org/downloads/windows/" target="_blank" rel="nofollow noopener">the official download page</a>. Choose the version that you would like to download (If your RAM size is greater than 4GB, your machine should be of a 64Bit architecture, so make sure you get an AMD64 version of the executable).
Upon download, locate your Downloads directory and double-click on the downloaded executable. Follow along the steps provided in the window and install your version of Python, as shown below:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-install-pip-on-windows-02.gif" alt="Python Installation Steps">
Now that Python has been downloaded and installed, let's open the terminal again and provide the following command:
<pre><code class="hljs">PS C:\&gt; python --version
Python 3.9.5
</code></pre>
<h2 id="pipinstallation">Pip Installation</h2>
Modern versions of Python, i.e. version 3.4 and higher, come with Pip preinstalled along with the version of Python. This can be checked by keying in the following command:
<pre><code class="hljs">PS C:\&gt; pip --version
pip 21.1.1 from c:\users\stackabuse\appdata\local\programs\python\python39\lib\site-packages\pip (python 3.9)
</code></pre>
If you see something different from the message above, it means that Pip is either not installed or corrupted on your machine:
<pre><code class="hljs">PS C:\&gt; pip --version
pip : The term &#x27;pip&#x27; is not recognized as the name of a cmdlet, function, script file, or operable program. Check the
spelling of the name, or if a path was included, verify that the path is correct and try again.
At line:1 char:1
+ pip --version
+ ~~~
 + CategoryInfo : ObjectNotFound: (pip:String) [], CommandNotFoundException
 + FullyQualifiedErrorId : CommandNotFoundException
</code></pre>
The message above shows that Pip is not installed on your machine. In this case, you need the source code to set up Pip your machine. This can be downloaded from <code>bootstrap.pypa.io</code> using <code>wget</code> on your machine. This downloads the source code to a local file <code>get-pip.py</code>:
<pre><code class="hljs">PS C:\&gt; wget https://bootstrap.pypa.io/get-pip.py -OutFile get-pip.py
</code></pre>
The mentioned file contains the source code to install the latest version of Pip. Since it's a Python file itself, it can be invoked in the same way all Python scripts are executed:
<pre><code class="hljs">PS C:\&gt; python get-pip.py
Collecting pip
 Downloading pip-21.1.1-py3-none-any.whl (1.5 MB)
 |████████████████████████████████| 1.5 MB 384 kB/s
Collecting wheel
 Downloading wheel-0.36.2-py2.py3-none-any.whl (35 kB)
Installing collected packages: wheel, pip
Successfully installed pip-21.1.1 wheel-0.36.2
</code></pre>
The message shows that the latest version of Pip has been installed on your machine. As a confirmation, you can also check if you had installed the recent version of the Pip by invoking the following command:
<pre><code class="hljs">PS C:\&gt; pip --version
pip 21.1.1 from c:\users\stackabuse\appdata\local\programs\python\python39\lib\site-packages\pip (python 3.9)
</code></pre>
<h2 id="uninstallingpip">Uninstalling Pip</h2>
There could be times when your existing version of Pip might get corrupted after an update, or perhaps wanted to do a fresh installation. The following command can be used to uninstall Pip entirely:
<pre><code class="hljs">PS C:\&gt; pip uninstall pip
Found existing installation: pip 21.1.1
Uninstalling pip-21.1.1:
 Would remove:
 c:\users\sathy\appdata\local\programs\python\python39\lib\site-packages\pip-21.1.1.dist-info\*
 c:\users\sathy\appdata\local\programs\python\python39\lib\site-packages\pip\*
 c:\users\sathy\appdata\local\programs\python\python39\scripts\pip.exe
 c:\users\sathy\appdata\local\programs\python\python39\scripts\pip3.9.exe
 c:\users\sathy\appdata\local\programs\python\python39\scripts\pip3.exe
Proceed (y/n)? y
 Successfully uninstalled pip-21.1.1
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Pip is one of the most popular package managers used by Python developers. For the most recent versions of Python, it is already installed on Windows. However, we can easily manage our Pip installation in case of errors by using a safe, Python script to install the latest version, and by using Pip itself to remove it from our system.

This article shows you how to install Pip,  the preferred package manager in Python for tools and projects, on Windows, as well as how to uninstall pip.

How to Install Pip on Windows

Dan Nelson

Juan Hurtado

In this guide, we'll take a look at the built-in iteration tools in Python 3: filter(), map() and zip(), as well as the islice() function of the itertools module with examples.