David Landup

Joel Olawanle

In this hands on guide - learn how to implement the drag and drop functionality in vanilla JavaScript, as well as the Sortable JS library!

Drag and Drop in Vanilla JavaScript

<h2 id="introduction">Introduction</h2>
An object in JavaScript is an unordered collection of key-value pairs (<code>key: value</code>). Each key is known as a property, and is a string representing a property name. If a non-string is given as the key, its stringified representation will be used. A property's value can be of any data type that fits the property conceptually - a string, a number, an array, or even a function.
An array, on the other hand, is a sorted set of values. Each value is referred to as an element, which is identified by a numerical index. An array can include values of almost any type. For example, it can store items like integers, strings, booleans, functions, etc. JavaScript arrays are also not restricted to a single type, meaning a given array can contain multiple different types within it.
When working in JavaScript, you might at a particular point in time need to determine if a key exists in a given object or array.
<blockquote>
In this article, we will see the various methods which we could use to check if a particular key exists in a JavaScript object/array.
</blockquote>
<h2 id="usingtheinoperator">Using the in Operator</h2>
The <code>in</code> operator in JavaScript is used to determine if a certain property exists in an object or its inherited properties (also known as its prototype chain). If the provided property exists, the <code>in</code> operator returns true.
<h3 id="checkinganobject">Checking an Object</h3>
<pre><code class="hljs">let user = {
 name: &#x27;John Doe&#x27;,
 age: 17,
 profession: &#x27;Farmer&#x27;
};
 
// Check if key exists
 
&#x27;name&#x27; in user; // Returns true
&#x27;profession&#x27; in user; // Returns true
&#x27;Daniel&#x27; in user; // Returns false because no key like that exists
&#x27;Farmer&#x27; in user; // Returns false because &#x27;Farmer&#x27; is not a key, but a value
</code></pre>
<h3 id="checkinganarray">Checking an Array</h3>
Since we demonstrated that the JavaScript <code>in</code> operator can be used with objects, you may be asking if it can also be used with arrays. In JavaScript, everything is an instance of the Object type (except for primitives), so arrays also support the <code>in</code> operator.
Let's confirm if it's an instance of the <code>Object</code> type using the <code>instanceof</code> operator:
<pre><code class="hljs">let numbers = [22, 3, 74, 35];
 
numbers instanceof Object // Returns true
</code></pre>
Now, back to using the <code>in</code> operator:
<pre><code class="hljs">let numbers = [12, 33, 14, 45, 6];

// Checking if index 1 is present
1 in numbers; // Returns true
// Checking if index 3 is present
3 in numbers; // Returns true

8 in numbers; // Returns false because the 8 index does exist in the array 
6 in numbers; // Returns false because the 6 index does not exist in the array
</code></pre>
This will also return <code>true</code> for method properties on an array type, of which the number array is an instance.
<pre><code class="hljs">&#x27;map&#x27; in number; // Returns true because &#x27;map&#x27; is a method attribute of the array type
</code></pre>
<h2 id="usingthehasownpropertymethod">Using the hasOwnProperty() Method</h2>
In JavaScript, the <code>hasOwnProperty()</code> function is used to determine whether the object has the supplied property as its own property. This is important for determining if the attribute was inherited by the object rather than being its own.
<h3 id="checkinganobject">Checking an Object</h3>
<pre><code class="hljs">let user = {
 name: &#x27;John Doe&#x27;,
 age: 17,
 profession: &#x27;Farmer&#x27;
};
 
// Check if key exists
let hasKey = user.hasOwnProperty(&#x27;name&#x27;); 
 
if (hasKey) {
 console.log(&#x27;This key exists.&#x27;);
} else {
 console.log(&#x27;This key does not exist.&#x27;);
}
</code></pre>
<h3 id="checkinganarray">Checking an Array</h3>
You might begin to wonder if this would work for arrays. As we established earlier, an array is actually a prototype (instance) of the <code>Object</code> type, therefore it also has this method available to it.
<pre><code class="hljs">let number = [12, 33, 14, 45];

// Check if key exists
number.hasOwnProperty(1); // Returns true
number.hasOwnProperty(0); // Returns true
number.hasOwnProperty(7); // Returns false because 7 is not an existing index on the array
</code></pre>
<h2 id="usingtheobjectkeymethod">Using the Object.key() Method</h2>
The static method <code>Object.key</code> generates and returns an array whose components are strings of the names (keys) of an object's properties. This may be used to loop through the object's keys, which we can then use to verify if any match a certain key in the object.
<h3 id="usingwiththesomemethod">Using with the some() Method</h3>
<code>some()</code> is a JavaScript method that tests a callback function on all the elements of the calling array and returns <code>true</code> if the callback function returns <code>true</code> for any of them.
<h4 id="usingsomeforobjects">Using some() for Objects</h4>
<pre><code class="hljs">let user = {
 name: &#x27;John Doe&#x27;,
 age: 17,
 profession: &#x27;Farmer&#x27;
};
 
// Check if key exists
Object.keys(user).some(key =&gt; key === &#x27;name&#x27;); // Returns true
Object.keys(user).some(key =&gt; key === &#x27;role&#x27;); // Returns false
</code></pre>
We could also customize this into a reusable function:
<pre><code class="hljs">const checkKey = (obj, keyName) =&gt; {
 let keyExist = Object.keys(obj).some(key =&gt; key === keyName);
 console.log(keyExist);
};
 
checkKey(user, &#x27;name&#x27;); // Return true
</code></pre>
<h4 id="usingsomeforanarray">Using some() for an Array</h4>
<pre><code class="hljs">let number = [12, 33, 14, 45];
 
// Check if key exists
number.some(value =&gt; value === 1); // Returns true
number.some(value =&gt; value === 7); // Returns false
</code></pre>
Again, just like with the object, we could also make use of a similar customized reusable function to check a value's existence in an array:
<pre><code class="hljs">const checkVal = (arr, val) =&gt; {
 let valExist = arr.some(value =&gt; value === val);
 console.log(valExist);
};

checkVal(number, 7); // Returns false
checkVal(number, 0); // Returns true
</code></pre>
<h3 id="usingtheindexofmethod">Using the indexOf() Method</h3>
JavaScript's <code>indexOf()</code> method will return the index of the first instance of an element in the array. If the element does not exist then, -1 is returned.
<h4 id="usingindexofforanobject">Using indexOf() for an Object</h4>
The <code>Object</code> type in JavaScript does not actually support the <code>indexOf</code> method, since its properties/keys do not inherently have indexed positions in the object. Instead, we can get the object's keys as an array and then check the existence of a key using the <code>indexOf</code> method:
<pre><code class="hljs">let user = {
 name: &#x27;John Doe&#x27;,
 age: 17,
 profession: &#x27;Farmer&#x27;
};

// Check if key exists
Object.keys(user).indexOf(&#x27;name&#x27;) // Returns 0
Object.keys(user).indexOf(&#x27;role&#x27;) // Returns -1
</code></pre>
Keep in mind that JavaScript objects do not always preserve key order, so the index returned may not be as meaningful as in arrays. In this case, the index should primarily be used to determine just the existence of a key.
Here is an example of using this in a utility function:
<pre><code class="hljs">const checkKey = (obj, keyName) =&gt; {
 if (Object.keys(obj).indexOf(keyName) !== -1) {
 console.log(&#x27;This key exists&#x27;);
 } else {
 console.log(&#x27;This key does not exist&#x27;);
 }
};
 
checkKey(user, &#x27;name&#x27;); // Logs &#x27;This key exists&#x27;
checkKey(user, &#x27;role&#x27;); // Logs &#x27;This key does not exists&#x27;
</code></pre>
<h4 id="usingindexofforanarray">Using indexOf() for an Array</h4>
As we saw in the previous example, arrays do support the <code>indexOf</code> method, unlike objects. To use it, pass the value of the item you're looking for to <code>indexOf</code>, which will then return the position of that value if it exists in the array:
<pre><code class="hljs">let number = [12, 33, 14, 45];
 
// Find position of the item in the array
number.indexOf(14); // Returns 2
number.indexOf(7); // Returns -1
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we have seen all of the possible ways in which we could check if a key or item exists in a JavaScript object/array. We show how to make use of the <code>in</code> operator, <code>hasOwnProperty()</code> method, and <code>some</code> method. We also saw how JS objects and arrays are similar in that arrays inherit from objects, and thus contain many of the same methods.

Scott Robinson

How to Check if Key Exists in JavaScript Object/Array

Dimitrije Stamenic

Jovana Ninkovic

Graphs in Python: Minimum Spanning Trees - Kruskal's Algorithm

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.

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.

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.