David Landup

Joel Olawanle

In this hands-on guide, learn how to create a reusable React button component, to scroll to top, bottom or any particular section on a page with JavaScript!

How to Scroll to Top, Bottom or Any Section in React with a Button Component

<h2 id="introduction">Introduction</h2>
Converting text into a uniform case is a good starting point of any type for text processing.
<blockquote>
In this article we'll show you how to convert text to lowercase using one of the Pythons' built-in methods used to manipulate strings - <code>str.lower()</code>.
</blockquote>
From a top-level view, the process is achieved through:
<pre><code class="hljs">exampleString = &quot;AbCdF_1@3$&quot;
lowercaseString = exampleString.lower()
print(lowercaseString) # abcdef_1@3$
</code></pre>
However, and especially if you're new to Python - read on. We'll discuss one alternative approach for converting strings to lowercase, so that you have a comprehensive overview of the subject. After reading the article, you'll be able to convert any string to lowercase, know when to simply use the <code>str.lower()</code> method, and when to choose the alternative approach instead.
<h2 id="howtoconvertstringtolowercaseinpython">How to Convert String to Lowercase in Python</h2>
Converting strings to lowercase is pretty straightforward to perform in Python. <code>str.lower()</code> is the built-in method made specifically for that purpose. It is defined as a method of the <code>String</code> type which is built into the Python namespace.

 <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: Every Python built-in type has a set of methods designed to perform operations on that specific type. For example, the <code>String</code> type has predefined methods for removing leading and trailing whitespaces, finding and replacing substrings, splitting strings into arrays, etc. One of those methods is <code>str.lower()</code>. 
Every method defined for the <code>String</code> type has the <code>str</code> prefix by its name in the documentation. That suggests that all of them are called on string instances.

 </div>
 </div>
 </div>
 The <code>str.lower()</code> method returns a lowercase copy of the string on which it is called. That can be useful when you want to save the original string for later use. Now, let's see how to convert a string to lowercase in Python.
Let's assume that you have some string that you want to convert:
<pre><code class="hljs">exampleString = &quot;AbCdF_1@3$&quot;
</code></pre>
As you can see, this string has both lowercase and uppercase letters, as well as some special characters. Only the letters can be converted into lowercase, so you would expect the lowercase version of this string to be <code>&quot;abcdef_1@3$&quot;</code>:
<pre><code class="hljs">lowercaseString = exampleString.lower()
print(lowercaseString) # abcdef_1@3$
</code></pre>
After calling the <code>str.lower()</code> method on the <code>exampleString</code>, its lowercase copy is stored as a new object, referenced by <code>lowercaseString</code>. Just to make sure that the <code>str.lower()</code> method produces the correct output, let's compare the <code>lowercaseString</code> to the expected lowercase version of the <code>exampleString</code>:
<pre><code class="hljs">if(lowercaseString == &quot;abcdef_1@3$&quot;):
 print(&quot;Lowercase string EQUAL to expected string!&quot;)
else:
 print(&quot;Lowercase string NOT EQUAL to expected string!&quot;)
</code></pre>
This piece of code will output:
<pre><code class="hljs">&quot;Lowercase string EQUAL to expected string!&quot;
</code></pre>
Awesome!

 <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 opposite method to the <code>str.lower()</code> method is the <code>str.upper()</code>. It is used in the same fashion as the <code>str.lower()</code>. Also, you can check if a string is all-lowercase or all-uppercase by using the <code>str.islower()</code> or <code>str.isupper()</code>.

 </div>
 </div>
 </div>
 <h2 id="whyusestrcasefoldinsteadofstrlower">Why Use str.casefold() instead of str.lower()</h2>
The previous method is suitable for most use cases. It does what it is supposed to do by following a few simple rules. Starting with Python 3.0, strings are represented as arrays of Unicode characters which makes it easy for <code>str.lower()</code> to replace every code of a capital letter with the code of the corresponding lowercase letter.
That principle works fine in almost all use-cases, but there are some instances where you should consider using the <code>str.casefold()</code> method instead.
For example, when implementing caseless matching of two strings, the <code>str.casefold()</code> is the way to go. Since Python uses Unicode to represent strings, all rules defined in the Unicode Standard apply to the Python as well. In section 3.13 the Standard states the following:
<blockquote>
A string <code>X</code> is a caseless match for a string <code>Y</code> if and only if:
<pre><code class="hljs">toCasefold(X) = toCasefold(Y)
</code></pre>
</blockquote>
Because the <code>str.casefold()</code> is the Python implementation of the Unicode method <code>toCasefold()</code>, you should use it when implementing case-less matching.

 <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: Both <code>X.casefold()</code> and <code>toCasefold(X)</code> methods map each character of the string <code>X</code> into its case-fold correspondent, as defined in the <code>CaseFolding.txt</code> file in the Unicode Character Database.

 </div>
 </div>
 </div>
 To illustrate the difference between <code>str.lower()</code> and <code>str.casefold()</code>, let's take a look at the example of the German letter &quot;ß&quot;, a lowercase letter which is equal to &quot;ss&quot;. That means that the following strings are supposed to be the exact caseless match:
<pre><code class="hljs">A = &quot;ßaBcß&quot;
B = &quot;ssAbCss&quot;
</code></pre>
But if you try to compare them using the <code>str.lower()</code> method, you won't get the expected result:
<pre><code class="hljs">Al = A.lower()
Bl = B.lower()

print(Al == Bl)
# Output: False
</code></pre>
This comparison will produce the <code>False</code> value, meaning that <code>A.lower()</code> is not equal to <code>B.lower()</code>. That is because the &quot;ß&quot; is already a lowercase letter, so the <code>str.lower()</code> method won't change it. Therefore, <code>Al</code> and <code>Bl</code> have the following values:
<pre><code class="hljs">Al = &quot;ßabcß&quot;
Bl = &quot;ssabcss&quot;
</code></pre>
Obviously, <code>Al</code> is not equal to <code>Bl</code>, thus the previous comparison must produce the <code>False</code> value.
To correct this unexpected behavior, you should use the <code>str.casefold()</code> method. It is more aggressive compared to the <code>str.lower()</code> because it will remove absolutely all differences in letter casing in a string. Therefore, the &quot;ß&quot; will be replaced by &quot;ss&quot; and you can caseless match strings <code>A</code> and <code>B</code>:
<pre><code class="hljs">Ac = A.casefold()
# Ac = &quot;ssabcss&quot;

Bc = B.casefold()
# Bc = &quot;ssabcss&quot;
</code></pre>
Now, if you compare case-folded strings <code>A</code> and <code>B</code>, you'll get the expected result, the same as defined in the Unicode Standard:
<pre><code class="hljs">print(Ac == Bc)
# Output: True
</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">
 Alert: The shown type of caseless matching is called default caseless matching, which is the most basic type of caseless matching defined by the Unicode Standard. 
There are three more types of caseless matching defined in the Unicode Standard - canonical, compatibility, and identifier caseless matching. Each of them implies that one or more steps are added in order to improve the correctness of the matching in more specific use-cases. Those additional steps usually consist of normalizing strings during the matching (which is not performed during the default caseless matching).

 </div>
 </div>
 </div>
 <h2 id="problemswithstrcasefold">Problems with str.casefold()</h2>
Even though <code>str.casefold()</code> is a built-in Python method intended to implement the <code>toCasefold()</code> method from the Unicode Standard, you definitely shouldn't use it carelessly. There are some edge cases where it won't produce the desired result.
For example, the Unicode Standard defines the case-folded (lowercase) version of the capital letter <code>I</code> as <code>i</code>, which is in line with its use in most languages. But that mapping can't work in Turkish. The Turkish language has two variants of the letter <code>I</code> with their own lowercase correspondents:
<ul>
<li>uppercase i - <code>I</code> (similar to the usual uppercase letter i)
<ul>
<li>with its lowercase variant - <code>ı</code></li>
</ul>
</li>
<li>dotted uppercase i - <code>İ</code>
<ul>
<li>with its lowercase variant - <code>i</code> (similar to the usual lowercase letter i)</li>
</ul>
</li>
</ul>
Consequently, the standard Unicode coding wouldn't work in the Turkish language. Because of that, the Unicode Standard defined two different case-folding mappings - for Turkish and non-Turkish languages. The Turkish variant takes into account the count mentioned nuances from the Turkish language and the non-Turkish variant maps the uppercase <code>I</code> to its usual lowercase counterpart <code>i</code>.
On the other hand, the <code>str.casefold()</code> uses only the default (non-Turkish) case-fold mapping, therefore it can't perform caseless matching in Turkish for some words.

 <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: Therefore, it is said that the <code>str.casefold()</code> doesn't pass the Turkish test!

 </div>
 </div>
 </div>
 For example, the following strings are supposed to be a caseless match in Turkish:
<pre><code class="hljs">str1 = &quot;Iabcİ&quot;
str2 = &quot;ıabci&quot;
</code></pre>
But, in practice, the usual comparison will yield the <code>False</code> value:
<pre><code class="hljs">print(str1.casefold() == str2.casefold())
# &quot;iabci&quot; == &quot;ıabci&quot;
# Outputs: False
</code></pre>
Note that the <code>str.casefold()</code> converted both <code>I</code> and <code>İ</code> into the same lowercase character - <code>i</code>, which is according to the standard (non-Turkish) case-fold mapping of the Unicode Standard. That is what caused the undesired result of this caseless matching.
This example illustrates the case when <code>str.casefold()</code> produces the incorrect result of caseless matching in a specific language. Therefore, you should pay attention to the specifics of the language you are working with.
<h2 id="conclusion">Conclusion</h2>
After reading this guide, you will understand what's the most generic way to convert a string to lowercase in Python, as well as what is the alternative approach.
We've shortly covered the <code>str.lower()</code> method in Python and then dove into the details of the <code>str.casefold()</code> method.
We've covered its basic use cases, compared them to the <code>str.lower()</code> method, explained basic concepts and standards surrounding the Python implementation of the case-folding algorithm.
In the end, we've discussed some problematic use-cases so that you can be aware of some of the undesired results that the <code>str.casefold()</code> method can produce.

Dimitrije Stamenic

In this guide, learn how to convert a string to lowercase in Python, with str.lower() and str.casefold(), through practical code examples, and extensive explanations, for beginners.

Convert String to Lowercase in Python

<h2 id="introduction">Introduction</h2>
Dates are a regular part of our everyday lives, and we're generally aware of the day, or at least month we're in at any given point. This proves to be a great reference point for time, and displaying the name of a month or a day can help users figure out when, relative to their current state, something has happened or will happen.
In JavaScript, there's a number of ways we can achieve this.
<blockquote>
In this article, we'll walk you through the most common ways on how to get the name of month and day in Vanilla JavaScript, alongside how this could also be achieved with the Moment.js library.
</blockquote>
It is important to note that if you are working on a small project, it might be frustrating to start installing packages for something rudimentary. Small projects should be implemented using JavaScript's built-in methods, dependencies should only be introduced if the necessity arises.
Getting and displaying a day's or month's name, in JavaScript, can be simplified to:
<pre><code class="hljs">let now = new Date().toLocaleDateString(&#x27;en-us&#x27;, { weekday:&quot;long&quot;, month:&quot;long&quot;, day:&quot;numeric&quot;});
console.log(now)
</code></pre>
This results in:
<pre><code class="hljs">Friday, March 4
</code></pre>
There are a few parameters that we can tweak here for a different result and effect, and it's worth noting how the <code>toLocaleDateString()</code> method works, and what locale's are available. You can additionally extract singular day or month names from the method!
<blockquote>
We'll answer all of these questions in the proceeding sections.
</blockquote>
<h2 id="thedateobjectinjavascript">The Date Object in JavaScript</h2>
The <code>Date</code> object is a built-in datatype, used to work with dates and times. The <code>Date</code> object is created by using the <code>new</code> keyword, i.e. <code>new Date()</code> and provides a number of built-in methods for formatting and managing that data.
By default, a new <code>Date</code> instance without any parameters, creates an object corresponding to the current date and time (i.e. according to the computer's system settings):
<pre><code class="hljs">let dateTime = new Date();
console.log(dateTime); // Mon Mar 07 2022 18:07:01 GMT+0100 (Central European Standard Time)
</code></pre>
Now, let's take a look at how to extract the day and month from this output, and get their names!
<h3 id="getdayfromjavascriptsdateobject">Get Day from JavaScript's Date Object</h3>
There are multiple ways to extract the date from a <code>Date</code> object. We've used <code>toLocaleString()</code> in the introduction - but you can also extract the exact field with <code>getDay()</code>!
<h4 id="usingthegetdaymethod">Using the getDay() Method</h4>
<code>getDay()</code> returns the day of the week (a number to represent the day in a week between 0 and 6) for that <code>Date</code> object:
<pre><code class="hljs">// Get current day
let day = new Date().getDay();
console.log(day); //6

// Get day in the week of a certain date
let day = new Date(&quot;October 14, 2020 09:38:00&quot;).getDay();
console.log(day); //3
</code></pre>
Knowing fully well that there are 7 days in a week, we can simply map the days in a week to an index! However, it's worth noting that the numbering of days in a week starts from Sunday and ends at Saturday:
<pre><code class="hljs">Sunday=0, 
Monday=1, 
Tuesday=2,
...,
Saturday=6.
</code></pre>
Let's create an array of the names of the days in the week, following the expected order, and get the name, given the index (day in the week) returned by <code>getDay()</code>:
<pre><code class="hljs">let daysArray = [&#x27;Sunday&#x27;, &#x27;Monday&#x27;, &#x27;Tuesday&#x27;, &#x27;Wednesday&#x27;, &#x27;Thursday&#x27;, &#x27;Friday&#x27;, &#x27;Saturday&#x27;];
let day = new Date().getDay();
let dayName = daysArray[day];
console.log(dayName); // &quot;Saturday&quot;
</code></pre>
You can also wrap this functionality up in a callable function if you're using the logic on multiple occasions:
<pre><code class="hljs">const getDayName = (dayIndex) =&gt;{
 let daysArray = [&#x27;Sunday&#x27;, &#x27;Monday&#x27;, &#x27;Tuesday&#x27;, &#x27;Wednesday&#x27;, &#x27;Thursday&#x27;, &#x27;Friday&#x27;, &#x27;Saturday&#x27;];
 return daysArray[dayIndex];
}
 
const dayName = getDayName(new Date().getDay());
console.log(dayName); // &quot;Saturday&quot;
</code></pre>
<h3 id="usingthetolocaledatestringmethod">Using the toLocaleDateString() Method</h3>
A much more straightforward method that does the indexing logic for you is <code>toLocaleDateString()</code>! Additionally, it provides formatting options for the locale you've defined, so you can dynamically adapt the format to the user's location.
This method takes in four basic options - <code>weekday</code>, <code>year</code>, <code>month</code> and <code>day</code>, and allows us to set the day's name to be longer or shorter:
<pre><code class="hljs">let dayName = new Date().toLocaleDateString(&#x27;en-us&#x27;, { weekday:&quot;long&quot;})
console.log(dayName); // &quot;Saturday&quot;
 
let dayNameSt = new Date().toLocaleDateString(&#x27;en-us&#x27;, { weekday:&quot;short&quot;})
console.log(dayNameSt); // &quot;Sat&quot;
</code></pre>
<h2 id="getmonthfromjavascriptsdateobject">Get Month from JavaScript's Date Object</h2>
So far we have been able to see how to get the day and I know you are guessing how that of the month will work. To be very sincere, most of you if not all will get it right. We would use the two methods like we did for the day, but just change a little syntax.
<h3 id="usingthegetmonthmethod">Using the <code>getMonth()</code> Method</h3>
The <code>getMonth()</code> method is another <code>Date</code> method, much in the way <code>getDay()</code> returns an integer - returns the index of the month, denoted by the <code>Date</code> instance. The returned month will be between <code>0..11</code>, starting at January and ending at December:
<pre><code class="hljs">let month = new Date().getMonth();
console.log(month); // 2

let month = new Date(&quot;October 14, 2020 09:38:00&quot;).getMonth();
console.log(month); // 9
</code></pre>
Let's define an array of month names, and access the appropriate name based on the returned value:
<pre><code class="hljs">let monthsArray = [&#x27;January&#x27;, &#x27;February&#x27;, &#x27;March&#x27;, &#x27;April&#x27;, &#x27;May&#x27;, &#x27;June&#x27;, &#x27;July&#x27;, &#x27;August&#x27;, &#x27;September&#x27;, &#x27;October&#x27;, &#x27;November&#x27;, &#x27;December&#x27;];
let month = new Date().getMonth();
let monthName = monthsArray[month];
console.log(monthName); // &quot;March&quot;
</code></pre>
We could also decide to make this reusable by creating a function that can easily be called anywhere in your application:
<pre><code class="hljs"> const getMonthName = (monthIndex) =&gt;{
 let monthsArray = [&#x27;January&#x27;, &#x27;February&#x27;, &#x27;March&#x27;, &#x27;April&#x27;, &#x27;May&#x27;, &#x27;June&#x27;, &#x27;July&#x27;, &#x27;August&#x27;, &#x27;September&#x27;, &#x27;October&#x27;, &#x27;November&#x27;, &#x27;December&#x27;];
 return monthsArray[monthIndex];
}
 
const monthName = getMonthName(new Date().getMonth());
console.log(monthName); // &quot;March&quot;
</code></pre>
<h3 id="usingthetolocaledatestringmethod">Using the toLocaleDateString() Method</h3>
Again, the <code>toLocaleDateString()</code> method formats a <code>Date</code> to a string, displaying the field we're interested in, and formatting it according to the configuration object:
<pre><code class="hljs">let monthName = new Date().toLocaleDateString(&#x27;en-us&#x27;, { month:&quot;long&quot;})
console.log(monthName); // &quot;March&quot;
 
let monthNameSt = new Date().toLocaleDateString(&#x27;en-us&#x27;, { month:&quot;short&quot;})
console.log(monthNameSt); // &quot;Mar&quot;
</code></pre>
<h2 id="usingjavascriptlibraries">Using JavaScript Libraries</h2>
It is also expedient to cover how this could be achieved with Moment.js, a popular JavaScript library present in many projects.
<h3 id="momentjs">Moment.js</h3>
Moment.js is widely regarded as the one of the best JavaScript date-time packages, and for good reason. It is really simple to use, extensively documented, and just 20kb in size (minified, Gzipped)!
<h3 id="howtogetnameofdaywithmomentjs">How to Get Name of Day with Moment.js</h3>
Moment.js makes getting the name of the day or month a breeze - we simply <code>format()</code> a date! The <code>'ddd'</code> signifier formats the date name to a short one, while <code>'dddd'</code> formats it to a long one:
<pre><code class="hljs">// Get current date
var date = moment();

var dayName = date.format(&#x27;ddd&#x27;);
console.log(dayName); // &quot;Sat&quot;

var dayName = date.format(&#x27;dddd&#x27;);
console.log(dayName); // &quot;Saturday&quot;
</code></pre>
<h3 id="howtogetnameofmonthwithmomentjs">How to Get Name of Month with Moment.js</h3>
The same logic applies to month names:
<pre><code class="hljs">var date = moment();
var monthName = date.format(&#x27;MMM&#x27;);
console.log(monthName); // &quot;Mar&quot;
 
var monthName = date.format(&#x27;MMMM&#x27;);
console.log(monthName); // &quot;March&quot; 
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've covered how to get the name of the day and month of a date in JavaScript, in a human-friendly format.
We've covered the <code>getDay()</code>, <code>getMonth()</code>, <code>toLocaleString()</code> methods, as well as Moment.js, which simplifies and streamlines the process.

In this short guide - learn how to get the name of the day or month of a date in Vanilla JavaScript, with getDay(), getMonth(), toLocaleString() and Moment.js! 

How to Get Name of Month and Day in JavaScript

In this hands on guide - learn how to create a vanilla JavaScript countdown timer, styled beautifully with CSS.


How to Build a Date Countdown With Vanilla JavaScript

In this guide, you'll learn how to filter an array in JavaScript with the filter() method. You'll learn how to use the context, index and array arguments, as well as how to chain filter() with map(), indexOf() and find(), through practical code examples.

Guide to JavaScript's filter() Method

<h2 id="introduction">Introduction</h2>
Storing passwords securely should be imperative for any credible engineer. Plain text passwords are extremely insecure - you shouldn't even bother considering storing them a plain format. It's enough that someone gains view privileges on a database for an entire user base to be compromised.
<blockquote>
Passwords must be stored in a database in a secure, yet manageable way.
</blockquote>
You should always assume that your database will be compromised and take all necessary precautions to prevent anyone, who could get hold of your data, from exploiting it in any way possible. That is especially true for databases that store users' login credentials or other sensitive data.
Additionally - it's a question of ethical conduct. If a user signs up for your website - should you be able to find their password ad verbatim? Passwords are oftentimes used on multiple websites, contain personal information and/or could expose a side of the user that they wouldn't like to put out publicly. Neither you nor a malicious actor should be able to read a plain-text password at any point. This is why websites can't email you your password when you forget it - they don't know it. You have to reset it.
<blockquote>
Hashing passwords is a cheap, secure and standard procedure that keeps passwords safe from both a webmaster and malicious actors.
</blockquote>
To prevent anyone from blatantly exploiting login credentials, you should always hash passwords before storing them in a database. That is the simplest, yet most effective way to prevent the unauthorized use of passwords stored in your database. Even if someone gets a hold of users' login credentials, that information can't be used in any shape or form, since the format is unreadable for humans, and hard to crack computationally.
<blockquote>
In this guide, we'll explain how to hash your passwords in Python using BCrypt. We'll cover what hashing is, how hashes are compared, how &quot;salting&quot; works and how hashing even makes passwords secure.
</blockquote>
<h2 id="whatispasswordhashing">What Is Password Hashing?</h2>
In its most basic form, hashing refers to converting one string to another (which is also called a hash) using a hash function. Regardless of the size of an input string, the hash will have a fixed size which is predefined in a hashing algorithm itself. The goal is that the hash doesn't look anything like the input string and that any change in the input string produces a change in the hash.
Additionally - hashing functions hash input in a one-way fashion. It's not a round trip and a hashed password cannot be unhashed. The only way to check whether an input password matches the one in the database is to hash the input password as well, and then compare the hashes. This way, we don't need to know what the actual password is to ascertain whether it's matching the one in the database or not.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: In this guide, we'll use the term &quot;hashing function&quot; for a mathematical function used to calculate the fixed-size hash based on the input string (popular hashing functions include SHA256, SHA1, MD5, CRC32, BCrypt etc.). A &quot;hashing algorithm&quot; refers to the whole process of hashing, including not only a hashing function used but many more parameters that can be altered during the process of hashing.

 </div>
 </div>
 </div>
 <img src="https://s3.stackabuse.com/media/articles/hashing-passwords-in-python-with-bcrypt-2.png" alt="how salting works during password hashing">
Every time you put something such as <code>&quot;myPwd&quot;</code> into the hashing algorithm you'll get the same exact output. But, if you change <code>&quot;myPwd&quot;</code> even a bit, the output will be changed beyond recognition.
That ensures that even similar input strings produce completely different hashes. If similar passwords produced the same hashes - cracking one simple password could lead to creating a lookup table for other characters. On the other hand, since the same input always yields the same output, a hashing is pretty predictable.
<blockquote>
Predictability is easily exploitable.
</blockquote>
If someone knows what hashing function was used to hash a certain password (and there isn't a large list of hash functions in use), they can crack it by guessing all possible passwords, hashing them with the same hashing function, and comparing obtained hashes to the hash of the password that they want to crack. This type of attack is called a brute-force attack and the attack used to work extremely well for simple passwords, such as <code>password123</code>, <code>12345678</code>, etc.
The easiest way to prevent brute-force attacks is to use a hashing function that is relatively slow to compute. That way the brute-force attack would take so much time to compute all possible hashes, that it's not even worth trying to perform.
Additionally, most web applications have built-in &quot;timeouts&quot; after a certain number of incorrect passwords were input, making brute-force guessing not viable if someone's trying to brute-force a password through a controlled UI, though, this doesn't hold if someone obtains a local copy of a hashed password.
<h3 id="whatissaltinpasswordhashing">What Is Salt in Password Hashing?</h3>
As cryptography, price per computation and technology advance - just choosing a proper hashing function isn't quite enough to secure passwords stored in a database. In some cases, even a great hashing function can't prevent an attack. Therefore, it's advised to take additional precautions to make cracking stored passwords even more difficult.
The problem with hashing is that the output (i.e. hash) is always the same for the same input. That makes hashing predictable, thus vulnerable. You can solve that by passing an additional random string alongside the input string when performing hashing. That will ensure that the hashing no longer produces the same output every time it gets the same string as the input.
That fixed-length pseudo-random string passed alongside the input string when performing hashing is called salt. Every time you want to store a password in a database, a new, random salt will be created and passed alongside the password to the hashing function. Consequently, even if two users have the same password, its record in a database will be totally different.
<blockquote>
Remember that adding a single character to the end of a string before hashing changes the hash completely.
</blockquote>
<img src="https://s3.stackabuse.com/media/articles/hashing-passwords-in-python-with-bcrypt-1.png" alt="what is a salt in password hashing?">
The salt used to generate a password is stored separately, and added to any new input that's to be hashed and compared to the stored hash in the database, ensuring that even with the addition of random elements - the user can log in using their respective password. The point of salting isn't to make it much more computationally difficult to crack a single password - it's to prevent finding similarities between hashed strings, and to prevent an attacker from cracking multiple passwords if they're the same.
Through salting - extremely computationally expensive operations are localized to a single instance and have to be repeated for every password in the database, stopping a cascade of broken security.
Thankfully - the entirety of this logic is typically abstracted away by security frameworks and modules that we can readily use in code.
<h2 id="whatisbcrypt">What is BCrypt?</h2>
BCrypt is a password hashing algorithm, designed with all security precautions we've mentioned in mind. It is used as the default password hashing algorithm in OpenBSD, an open-source security-focused operating system, and is the most widely supported hashing algorithm to date.
BCrypt is considered to be fairly secure. Its hashing function is based on the Blowfish (cipher) algorithm, implements salting and adaptive computation speed. Adaptive speed refers to the ability to increase the complexity of calculating hash value, which future proofs the algorithm. It keeps being slow enough to prevent brute-force attacks no matter the increasing computing speed of the hardware.
BCrypt is widely supported and implemented in most mainstream languages. There publicly available implementations for Java, JavaScript, C, C++, C#, Go, Perl, PHP, etc. In this guide, we'll cover the Python implementation of the BCrypt algorithm.
<h2 id="howtohashapasswordinpythonusingbcrypt">How to Hash a Password in Python Using BCrypt</h2>
The <code>bcrypt</code> module on PyPi offers a great implementation of BCrypt that we can easily install via <code>pip</code>:
<pre><code class="hljs">$ pip install bcrypt
</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: 
To make sure that all required dependencies are installed, the official documentation advises you to run the following commands based on your operating system of choice.

 </div>
 </div>
 </div>
 For Debian and Ubuntu:
<pre><code class="hljs">$ sudo apt-get install build-essential libffi-dev python-dev
</code></pre>
For Fedora and RHEL-derivatives:
<pre><code class="hljs">$ sudo yum install gcc libffi-devel python-devel
</code></pre>
For Alpine:
<pre><code class="hljs">$ apk add --update musl-dev gcc libffi-dev
</code></pre>
After you've installed BCrypt using <code>pip</code>, you can import it to your project:
<pre><code class="hljs">import bcrypt
</code></pre>
To hash your password using BCrypt, you must convert it to the array of bytes first. To achieve that, we can use the <code>encode()</code> method of the <code>string</code> class! It will encode the string version of the password you want to hash into a byte array, given a certain encoding type, and make it possible to hash using BCrypt.
Let's take <code>'MyPassWord'</code> as the example password to illustrate the usage of BCrypt:
<pre><code class="hljs">pwd = &#x27;MyPassWord&#x27;

bytePwd = pwd.encode(&#x27;utf-8&#x27;)
</code></pre>
The <code>encode()</code> method takes a string in some encoding (e.g. ASCII, UTF-8, etc.) and converts it to a corresponding array of bytes. That byte-array formed of a string is called a b-string.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: In the previous example, <code>pwd</code> is a string and <code>bytePwd</code> is a byte-array. But if you print both variables, the only visible difference is that the <code>bytePwd</code> has <code>b</code> as a prefix before its value - <code>b'myPassword'</code>. Thence the name of that type of byte-array - a b-string.

 </div>
 </div>
 </div>
 Finally, you can hash the encoded password using BCrypt:
<pre><code class="hljs"># Generate salt
mySalt = bcrypt.gensalt()

# Hash password
pwd_hash = bcrypt.hashpw(bytePwd, mySalt)
</code></pre>
As you can see, the method used for hashing in BCrypt is <code>hashpw()</code>. It takes two arguments, the b-string representation of a password and a salt. Obviously, you can manually create a salt, but it's definitely recommended to use the <code>gensalt()</code>method instead. It's a BCrypt method created specifically for creating salt in a cryptographically secure fashion.

 <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: Adaptive computation speed in BCrypt is achieved by setting a number of iterations needed to create a salt. That value is passed as the argument of the <code>gensalt()</code>method. The default value is 12, meaning that BCrypt uses 212 (4096) iterations to generate a salt. By increasing the value of that argument, you increase the number of iterations used to generate a salt, and by extension, the time needed to compute the hash.

 </div>
 </div>
 </div>
 Now, the <code>hash</code> is storing the hashed version of the password <code>pwd</code>. The <code>hash</code> should look somewhat similar to:
<pre><code class="hljs">b&#x27;$2b$12$1XCXpgmbzURJvo.bA5m58OSE4qhe6pukgSRMrxI9aNSlePy06FuTi&#x27;
</code></pre>
Not very similar to the original password, right? But if you compare the <code>hash</code> to the original password using BCrypt's <code>checkpw()</code> method, it returns a <code>True</code> value!

 <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>checkpw()</code> method is designed for validating hashed passwords. It hashes the new input password, adds the salt it automatically tracks, and then compares the results.

 </div>
 </div>
 </div>
 Let's check whether the literal-text <code>password</code> is a valid password for the new <code>hash</code> we've just created:
<pre><code class="hljs">password = &#x27;MyPassWord&#x27;
password = password.encode(&#x27;utf-8&#x27;)
print(bcrypt.checkpw(password, pwd_hash))
# Output: True
</code></pre>
<h2 id="componentsofabcryptoutput">Components of a BCrypt output</h2>
As we've seen in the previous example, the input to BCrypt is a password (up to 72 bytes) and a salt (with the associated number of iterations) and the output is the 24-byte hash.
Let's examine the following illustration to get a grasp of how BCrypt constructs the produced hash:
<img src="https://s3.stackabuse.com/media/articles/hashing-passwords-in-python-with-bcrypt-3.png" alt="BCrypt Explained">
This illustration shows a hashing of the password, <code>'MyPassword'</code>, therefore it illustrates hashing from the previous section.
As we've discussed before, every time you call the <code>gensalt()</code> method, it produces a new fixed-size byte-array (represented by a b-string). In this example, the <code>gensalt()</code> method produced the output marked as <code>salt</code> in the illustration. Let's decompose the <code>salt</code> section and explain each individual subsection.
The <code>salt</code> has three subsections divided by the <code>$</code> sign:
<ul>
<li>
bcrypt version 
A special hashing algorithm identifier - in this case <code>2b</code> - the newest version of the BCrypt algorithm.
</li>
<li>
exponent 
The argument of the <code>gensalt()</code> method represents the number of iterations used to compute a salt. If no argument is passed, the default value is 12, therefore 212 iterations are used to compute a salt.
</li>
<li>
generated salt 
A radix-64 encoding of the generated salt represented by 22 characters.
</li>
</ul>
After that, BCrypt sticks the <code>salt</code> together with the hashed value of <code>MyPassword</code> and thus creates the final <code>hash</code> of the <code>MyPassword</code>.

 <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 hashed value of <code>MyPassword</code> (or any other password) refers to a radix-64 encoding of the first 23 bytes of the 24-byte hash. It is represented by 31 characters.

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
After reading this article you will have a solid understanding of how to use a BCrypt to hash a password before storing it into a database. To put things into a perspective, we've explained basic terminology in a general sense and then illustrated the process of hashing a password on the example of BCrypt.

Jovana Ninkovic

In this guide, we'll take a look at how to hash passwords in Python with BCrypt and answer questions such as - what is password hashing and what is salting through practical code examples.

Hashing Passwords in Python with BCrypt

<h2 id="introduction">Introduction</h2>
Objects are used to store a collection of properties, each of which may be thought of as an association between a name (or key) and a value (a collection of key-value pairs).
<blockquote>
In this guide, we will explore many JavaScript methods on how to check if an object is empty. We'll be using Vanilla JavaScript, as well as common libraries such as <a rel="nofollow noopener noreferrer" target="_blank" href="https://lodash.com/">lodash</a> and <a rel="nofollow noopener noreferrer" target="_blank" href="https://underscorejs.org/">underscore</a>.
</blockquote>
When it comes to small applications that don't require external dependencies - checking whether an object is empty is best done with pure JavaScript. However, if your application already has external libraries such as lodash and underscore - they offer great ways to perform these checks as well.
Checking if an object is empty or not is a basic and frequent operation, however, there are several methods for determining whether it's empty or not.
Let's start by creating an empty Object with the object literal syntax:
<pre><code class="hljs">const emptyObject = {}
</code></pre>
<h3 id="usingtheobjectkeysmethod">Using the Object.keys() Method</h3>
<code>Object.keys()</code> is a static method that returns an Array when we pass an object to it, which contains the property names (keys) belonging to that object. We can check whether the <code>length</code> of this array is <code>0</code> or higher - denoting whether any keys are present or not. If no keys are present, the object is empty:
<pre><code class="hljs">Object.keys(obj).length === 0 &amp;&amp; obj.constructor === Object;
</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 constructor check makes sure the passed argument is indeed an object.

 </div>
 </div>
 </div>
 We could also create a reusable function, if you're using the check multiple times in the project:
<pre><code class="hljs">const isEmptyObject = (obj) =&gt; {
 return Object.keys(obj).length === 0 &amp;&amp; obj.constructor === Object;
}

console.log(isEmptyObject(emptyObject)); // true
</code></pre>
This is by far the simplest method for determining whether an object is empty, though it's a bit verbose. We'll remove this verbosity with the following approaches - after we take a look at the <code>Object.values()</code> and <code>Object.entries()</code> static methods, which can be used in much the same way as <code>Object.keys()</code>.
<h4 id="usingtheobjectvaluesmethod">Using the Object.values() Method</h4>
Just as with keys - if an object has no <code>values</code> associated (not even an <code>undefined</code>/<code>null</code>) - it's empty:
<pre><code class="hljs">const isEmptyObject = (obj) =&gt; {
 return Object.values(obj).length === 0 &amp;&amp; obj.constructor === Object;
}

console.log(isEmptyObject(emptyObject)); // true
</code></pre>
<h4 id="usingtheobjectentriesmethod">Using the Object.entries() Method</h4>
The <code>entries()</code> method represents all key-value pairs (entries), which can be used as a wrapper for both of the approaches above:
<pre><code class="hljs">const isEmptyObject = (obj) =&gt; {
 return Object.entries(obj).length === 0 &amp;&amp; obj.constructor === Object;
}

console.log(isEmptyObject(emptyObject)); // true
</code></pre>
<h3 id="forinandhasownproperty">for...in and hasOwnProperty()</h3>
For browsers that don't support the <code>keys()</code>, <code>values()</code> and <code>entries()</code> methods - you can explicitly loop through the properties! You can wrap this logic within a method that returns <code>true</code> if no properties were found, and <code>false</code> if properties were found:
<pre><code class="hljs">const isEmptyObject = (objectName) =&gt; {
 for (var prop in objectName) {
 if (objectName.hasOwnProperty(prop)) {
 return false;
 }
 }
 return true;
}

console.log(isEmptyObject(emptyObject)); // true
</code></pre>
<h3 id="usingjsonstringify">Using JSON.stringify</h3>
This is one of the simplest methods to use. When we stringify an object and the output is only an opening and closing bracket, we know the item is empty:
<pre><code class="hljs">JSON.stringify(objectName) === &#x27;{}&#x27;;
</code></pre>
We could also easily be wrapped into a function:
<pre><code class="hljs">const isEmptyObject = (objectName) =&gt; {
 return JSON.stringify(objectName) === &#x27;{}&#x27;;
}

console.log(isEmptyObject(emptyObject)); // true
</code></pre>
<h3 id="checkifobjectisemptywithjavascriptlibraries">Check if Object Is Empty With JavaScript Libraries</h3>
Libraries help us write code faster, by incorporating advanced functionality, used and honed by countless other developers, instead of writing our own solutions.
Libraries are common, typically fast/optimized, and some are present in many projects due to how useful they are. Several of them can also be used for checking whether an object is empty or not. The majority of them offer excellent compatibility for older browsers.
<h4 id="usingunderscoreandlodash">Using Underscore and Lodash</h4>
Both lodash and underscore are utility libraries that offer a fair bit of common utilities. They're both typically imported as <code>_</code>, and can be imported via a CDN:
<pre><code class="hljs">&lt;script src=&quot;https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js&quot;&gt;&lt;/script&gt;
&lt;script src=&quot;https://cdn.jsdelivr.net/npm/underscore@1.13.2/underscore-umd-min.js&quot;&gt;&lt;/script&gt;
</code></pre>
Or installed a package manager such as NPM, and then imported via the <code>require()</code> syntax:
<pre><code class="hljs">$ npm install lodash
$ npm install underscore
</code></pre>
<pre><code class="hljs">const _ = require(&#x27;lodash&#x27;);
const _ = require(&#x27;underscore&#x27;);
</code></pre>
Both libraries have the exact same syntax for checking whether an object is empty:
<pre><code class="hljs">_.isEmpty();
</code></pre>
This function works with any data structure - lists, arrays, strings, objects, etc. The function is a wrapper around the logic that checks the length of the object that was passed in, returning <code>true</code> or <code>false</code>:
<pre><code class="hljs">_.isEmpty(emptyObject); // true
</code></pre>
<h4 id="jquery">jQuery</h4>
<a rel="nofollow noopener noreferrer" target="_blank" href="https://jquery.com/">jQuery</a> is a popular JavaScript library, present in many projects around the world. Due to its light weight and features that expand the scope of JavaScript's built-in capabilities - it's become a staple.
jQuery can be imported via a CDN:
<pre><code class="hljs">&lt;script src=&quot;https://code.jquery.com/jquery-3.6.0.min.js&quot; integrity=&quot;sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4=&quot; crossorigin=&quot;anonymous&quot;&gt;&lt;/script&gt;
</code></pre>
Or installed a package manager such as NPM, and then imported via the <code>require()</code> syntax:
<pre><code class="hljs">$ npm install jquery
</code></pre>
It's typically imported as <code>$</code>:
<pre><code class="hljs">const $ = require(&#x27;jquery&#x27;);
</code></pre>
Naturally, you can use it to check whether an object is empty or not:
<pre><code class="hljs">$.isEmptyObject(emptyObject); // true
</code></pre>
<h4 id="ramda">Ramda</h4>
<a rel="nofollow noopener noreferrer" target="_blank" href="https://www.npmjs.com/package/ramda">Ramda</a> is a functional JavaScript library! It never mutates data and supports the creation of purely functional pipelines. For those with a more functional programming background - it's a great library to feel at home with.
Ramda can be imported via a CDN:
<pre><code class="hljs">&lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/ramda/0.28.0/ramda.min.js&quot;&gt;&lt;/script&gt;
</code></pre>
Or installed a package manager such as NPM, and then imported via the <code>require()</code> syntax:
<pre><code class="hljs">$ npm install ramda
</code></pre>
It's typically imported as <code>R</code>:
<pre><code class="hljs">const R = require(&#x27;ramda&#x27;);
</code></pre>
If you're already using it - it offers an <code>isEmpty()</code> function as well:
<pre><code class="hljs">R.isEmpty(emptyObject); // true
</code></pre>
<h4 id="hoek">Hoek</h4>
<a rel="nofollow noopener noreferrer" target="_blank" href="https://www.npmjs.com/package/@hapi/hoek">@hapi/hoek</a> is part of the hapi ecosystem, and a popular utility method library for hapi-based apps. It offers a <code>deepEqual()</code> method, that checks whether two objects are the same (depth-wise):
<pre><code class="hljs">Hoek.deepEqual({}, emptyObject); // true
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we have taken a look at how to check whether an object is empty or not in JavaScript. To this end - we've used several Vanilla JS approaches, jQuery, Underscore, Lodash, Ramda, Hoek and the JSON module.

In this tutorial - learn how to check if an object is empty in JavaScript with Vanilla JS, jQuery, Lodash, Underscore, Ramda and Hoek, with practical code examples!

JavaScript: Check if an Object is Empty

<h2 id="introduction">Introduction</h2>
Subtracting two matrices in NumPy is a pretty common task to perform. The most straightforward way to subtract two matrices in NumPy is by using the <code>-</code> operator, which is the simplification of the <code>np.subtract()</code> method - NumPy specific method designed for subtracting arrays and other array-like objects such as matrices.

 <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 array-like object in NumPy is considered to be any object which can be passed to the <code>np.array()</code> method so that it creates an object that has the <code>ndarray</code> type.

 </div>
 </div>
 </div>
 In this guide, you'll find out how to subtract two matrices in NumPy using both <code>-</code> operator and <code>np.subtract()</code> method, when to use either of them, and have a deeper understanding of all the nuances of the <code>np.subtract()</code> method in NumPy.
<h2 id="howtosubtracttwomatricesinnumpy">How to Subtract Two Matrices in NumPy</h2>
In algebra, two matrices can be subtracted only if both of them have the same number of rows and columns, meaning that they are of the same shape. Let's assume you have two matrices of the same shape that you want to subtract:
<pre><code class="hljs">matrix1 = np.array([[2, 4, 0], [9, 1, 7]])
matrix2 = np.array([[2, 2, 1], [3, 5, 8]])
</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: Before calling any of NumPy's methods, such as the <code>np.array()</code> method for the first time, you have to import the NumPy module in your project with <code>import numpy as np</code>

 </div>
 </div>
 </div>
 As you can see, two matrices are of the same shape, meaning that the <code>matrix1.shape</code> is equal to <code>matrix2.shape</code> - both are equal to <code>(2, 3)</code>. This fact is crucial because both the <code>-</code> operator and the <code>np.subtract()</code> method won't behave as expected otherwise.

 <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>shape</code> property of any <code>ndarray</code> object (an array or a matrix) stores the shape of that object in a form of <code>(m, n)</code>, where <code>m</code> represents the number of rows and <code>n</code> represents the number of columns in a matrix.

 </div>
 </div>
 </div>
 Now you can subtract those two matrices using the <code>-</code> operator:
<pre><code class="hljs">resultMatrix = matrix1 - matrix2
</code></pre>
As simple as that! This line is equal to the following line:
<pre><code class="hljs">resultMatrix = np.subtract(matrix1, matrix2)
</code></pre>
In both of those cases, the <code>resultMatrix</code> will have exactly the same value, as expected:
<pre><code class="hljs">[ 0 2 -1]
[ 6 -4 -1]
</code></pre>
<h2 id="subtractingtwomatricesofdifferentshapesinnumpy">Subtracting Two Matrices of Different Shapes in NumPy</h2>
The previous section illustrated the most intuitive way of using the subtraction in NumPy. Rules of algebra state that you can subtract two matrices only if they are of the same shape, thus the previous section describes the only type of matrix subtraction that is mathematically valid.
However, the NumPy library allows the <code>np.subtract()</code> method to work even if argument matrices are not of the same shape. It does so with help of a mechanism called broadcasting, which defines how NumPy treats arrays of different shapes during arithmetic operations. Ultimately, they're equalized shape-wise, and the usual subtraction takes place.
For example, let's take a look at the following two matrices:
<pre><code class="hljs">rowMatrix = np.array([1, 2, 3])
columnMatrix = np.array([[1], [2], [3]])
</code></pre>
Those matrices definitely have different shapes, <code>rowMatrix.shape</code> is <code>(1, 3)</code>, and <code>columnMatrix.shape</code> is <code>(3, 1)</code>. This could confuse you into thinking that you can't perform subtraction of them in NumPy, but that is definitely possible (albeit, indirectly, as they're automatically broadcast before subtraction):
<pre><code class="hljs">resultMatrix = np.subtract(rowMatrix, columnMatrix)
</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>resultMatrix</code> will have the exact same value if you use the <code>-</code> operator instead of <code>np.subtract()</code> method

 </div>
 </div>
 </div>
 The <code>resultMatrix</code> will have the following value:
<pre><code class="hljs">[ 0 1 2]
[-1 0 1]
[-2 -1 0]
</code></pre>
Though, this result may look a bit counterintuitive, but let's use it to illustrate the mechanism of broadcasting in simple terms.
<h3 id="whatisnumpybroadcasting">What is NumPy Broadcasting?</h3>
In order to subtract <code>columnMatrix</code> from <code>rowMatrix</code> both of them must be of the same shape. Since those two matrices do not meet the mentioned criterion, the broadcasting mechanism comes in place. It makes sure to stretch both of them to have compatible shapes. Therefore, the <code>rowMatrix</code> is stretched so that it forms the matrix of the shape <code>(3, 3)</code>:
<pre><code class="hljs">&gt; Original `resultMatrix`:
[1 2 3]

&gt; Broadcasted `resultMatrix`:
[1 2 3]
[1 2 3]
[1 2 3]
</code></pre>
In a similar manner, the <code>columnMatrix</code> is stretched to form the <code>(3, 3)</code> matrix as well:
<pre><code class="hljs">&gt; Original `resultMatrix`:
[1]
[2]
[3]

&gt; Broadcasted `resultMatrix`:
[1 1 1]
[2 2 2]
[3 3 3]
</code></pre>
Now that you have two modified matrices of the same shape, the subtraction can be performed on them. The resulting matrix is the same as the <code>resultMatrix</code> from the example above.
<pre><code class="hljs">[1 2 3] [1 1 1] [ 0 1 2]
[1 2 3] - [2 2 2] = [-1 0 1]
[1 2 3] [3 3 3] [-2 -1 0]
</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">
 Alert: Broadcasting is a far more complex mechanism than described here, so we strongly advise you to use it with caution or perform further research on the topic. For example, some other combination of two matrix shapes will produce a <code>ValueError</code> because those shapes can't be broadcast into the same shape.

 </div>
 </div>
 </div>
 <h2 id="whentousenpsubtractmethodinsteadofoperator">When to Use np.subtract() Method Instead of - Operator</h2>
Based on what you've seen until now, you can conclude that you can use both <code>-</code> and <code>subtract()</code> interchangeably pretty much any time you want. That's almost true, but there are some cases where you should consider using the <code>np.subtract()</code> method instead of the <code>-</code> operator.
In essence, the <code>-</code> operator is an abstraction of the <code>np.subtract()</code> method. When called, the <code>-</code> operator will, effectively, call the <code>np.subtract()</code> with its default parameters. Therefore, the one use case where you can consider using the <code>np.subtract()</code> over the <code>-</code> operator is when you want to tweak the predefined default behavior of the subtraction in the NumPy. We'll take a look at a few arguments that can be interesting to play around with.
Firstly, let's take a look at the declaration of the<code>np.subtract()</code> method:
<pre><code class="hljs">numpy.subtract(x1, x2, /, out=None, *, where=True, casting=&#x27;same_kind&#x27;, order=&#x27;K&#x27;, dtype=None, subok=True[, signature, extobj]) = &lt;ufunc &#x27;subtract&#x27;&gt;
</code></pre>
Besides a few usual and self-explanatory arguments, the section of the declaration that will most probably draw your attention is <code>&lt;ufunc 'subtract'&gt;</code>, so let's first clarify what it stands for. In NumPy, <code>ufunc</code> stands for universal function, thus this argument signalizes that the <code>np.subtract()</code> method is a universal function.
Universal functions in NumPy operate on arrays (more specifically <code>ndarrays</code>) in an element-by-element fashion. They can efficiently iterate over elements of two <code>ndarrays</code> and perform a predefined operation on corresponding elements. For example, <code>np.subtract()</code> will subtract two corresponding elements from two <code>ndarrays</code>. Therefore, you can think of universal functions as basic, predefined functions, which enable you to perform a wide variety of basic mathematical operations on <code>ndarrays</code>.
Now we can describe some other interesting arguments:
<ul>
<li><code>x1</code> (required)
<ul>
<li>the first input array (or other array-like objects)</li>
<li>has to be either the same shape as <code>x2</code> or broadcastable to the same shape as <code>x2</code></li>
</ul>
</li>
<li><code>x2</code> (required)
<ul>
<li>the second input array (or other array-like objects)</li>
<li>has to be either the same shape as <code>x1</code> or broadcastable to the same shape as <code>x1</code></li>
</ul>
</li>
<li><code>out</code> (optional)
<ul>
<li>used if you want to specify the location where to store the result</li>
<li>if not specified, the new object is created to store the result</li>
<li>if specified, it has to be a <code>ndarray</code> object or a tuple of <code>ndarray</code> and <code>None </code>objects</li>
<li>the specified object has to have the shape that the two input arrays broadcast to</li>
</ul>
</li>
<li><code>where</code> (optional)
<ul>
<li>used if you want to specify some elements of the input array on which the <code>ufunc</code> will not be performed</li>
<li>the default value is <code>True</code>, thus the <code>np.subtract()</code> will subtract all corresponding elements from <code>x1</code> and <code>x2</code></li>
<li>if you want not to subtract elements on a certain position in the <code>out</code> array, you can pass the array of Boolean values which has the same shape as the <code>out</code> array, and set the value to <code>False</code> on those positions</li>
</ul>
</li>
<li><code>dtype</code> (optional)
<ul>
<li>used to specify the type of the result matrix</li>
<li>by default, it is equal to the type of the input arrays</li>
</ul>
</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
Whether you were looking for an easy way to subtract two matrices using NumPy or trying to recall more advanced concepts surrounding the <code>np.subtract()</code> method, this guide has you covered. The main point of this guide was to give you the answer to both of those questions.
Firstly, we've covered the easy and intuitive way to subtract two matrices in the NumPy module. Alongside that, we've discussed the similarities and differences between the <code>-</code> operator and the <code>np.subtract()</code> method. Afterward, we've illustrated the concept of broadcasting in NumPy, but we do advise you to dig deeper on the subject of broadcasting.
In the end, we've given you a detailed overview of the <code>np.subtract()</code> method in NumPy, thus you can tweak its default behavior to make it more suitable for certain more specific use cases.

In this guide, learn how to perform NumPy matrix subtraction of same-shape and different-shape matrices, with broadcasting, in Python.

Guide to NumPy Matrix Subtraction

<h2 id="setfloatingpointprecisioninjavascript">Set Floating-Point Precision in JavaScript</h2>
Floating-points in JavaScript have an extremely high precision, and you don't always need this precision. Additionally - your user is even less likely to want it. More often than not - we'll want to &quot;trim&quot; floating-point numbers by setting a specific precision (such as, say, two decimal points) for an end-user.
The <code>Number</code> object has several methods that allow us to change the precision of a floating-point number in JavaScript!
<h3 id="tofixed">toFixed()</h3>
<code>toFixed()</code> is a <code>Number</code> method that is used to convert a number to fixed-point notation (rounding the result where necessary) and returns the value as a string:
<pre><code class="hljs">number.toFixed([decimalPlaces]);
</code></pre>
<code>decimalPlaces</code> is optional, and defines the number of digits that should be present after the decimal place and defaults to <code>0</code>:
<pre><code class="hljs">let number = 12345.6789
 
console.log(number.toFixed()) // Returns &#x27;12346&#x27;: note rounding, no fractional part
console.log(number.toFixed(1)) // Returns &#x27;12345.7&#x27;: note rounding
console.log(number.toFixed(6)) // Returns &#x27;12345.678900&#x27;: note added zeros
console.log((1.23e+20).toFixed(3)) // Returns &#x27;123000000000000000000.000&#x27;
</code></pre>
If the floating-point number didn't offer precision up to the fixed point you're formatting to - 0s are added as padding to the end.
<h3 id="toprecision">toPrecision()</h3>
<code>toPrecision()</code> is a <code>Number</code> method that formats a number to a precision string - keeping track of how many total digits (including digits to the left and right of the decimal) to display of a number:
<pre><code class="hljs">number.toPrecision([significantDigits]);
</code></pre>
<code>significantDigits</code> is optional, denoting the number of significant digits to display in the result. If omitted, the method just converts the number to a string.
<pre><code class="hljs">let number = 5.123456
 
console.log(number.toPrecision()) // logs &#x27;5.123456&#x27;
console.log(number.toPrecision(5)) // logs &#x27;5.1235&#x27;
 
number = 0.000123
 
console.log(number.toPrecision()) // logs &#x27;0.000123&#x27;
console.log(number.toPrecision(5)) // logs &#x27;0.00012300&#x27;
</code></pre>
The returned values are of <code>string</code> type:
<pre><code class="hljs">console.log(typeof number.toPrecision()) // string
</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>toPrecision()</code> method will pad the resulting value with 0's if there are not enough significant digits, and it does not change the value of the original number - it returns a new result.

 </div>
 </div>
 </div>
 <h3 id="toexponential">toExponential()</h3>
The <code>toExponential()</code> function in JavaScript is used to show a number in exponential notation (sometimes known as scientific notation), even if the number is inside the range where JavaScript ordinarily uses standard notation:
<pre><code class="hljs">number.toExponential([fractionalDigits]);
</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: It's worth noting that with sufficiently small and sufficiently large numbers - JavaScript automatically displays them in their exponential notation.

 </div>
 </div>
 </div>
 <code>fractionalDigits</code> as an argument is optional, and specifies how many fractional digits are to be displayed in the result. If this argument is missing, the output may contain up to 16 fractional digits, depending on your browser:
<pre><code class="hljs">let number = 95.3434;
 
console.log(number.toExponential()); // 9.53434e+1
console.log(number.toExponential(4)); // 9.5343e+1
console.log(number.toExponential(2)); // 9.53e+1
console.log(95.3434.toExponential()); // 9.53434e+1
</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>toExponential()</code> method does not change the value of the original number - it returns a new value to be stored.

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
In this short tutorial, we've covered the process of setting a precision for floating-point numbers in JavaScript, using the <code>toExponential()</code>, <code>toFixed()</code> and <code>toPrecision()</code> methods of the <code>Number</code> object.

In this short tutorial, we'll take a look at how to set floating-point precision to a certain decimal place and how to convert to exponential (scientific) notation in JavaScript with toFixed(), toPrecision() and toExponential().