<h2 id="introduction">Introduction</h2>
In English, it's essential to capitalize the first letter of a sentence. JavaScript has built-in methods to help us with this.
In this article we will look at three different ways to check if the first letter of a string is upper case and how to capitalize it.
<h2 id="checkiffirstletterisuppercaseinjavascript">Check if First Letter Is Upper Case in JavaScript</h2>
We can check if the first of a letter a string is upper case in a few ways. Let's take a look at some popular ones.
<h3 id="touppercase">toUpperCase()</h3>
This is a built-in string method that returns the invoked string with only upper case characters:
<pre><code class="hljs">function startsWithCapital(word){
 return word.charAt(0) === word.charAt(0).toUpperCase()
}

console.log(startsWithCapital(&quot;Hello&quot;)) // true
console.log(startsWithCapital(&quot;hello&quot;)) // false
</code></pre>
Here, we're making a single character string consisting of only the first letter/character of the provided string and comparing it to its upper case version. If they match, the original letter is uppercase.
Note: <code>string.charAt(index)</code> is preferred over <code>string[index]</code> (bracket notation). This is because <code>&quot;&quot;.charAt(0)</code> returns an empty string whereas <code>&quot;&quot;[0]</code> returns <code>undefined</code>.
This removes the need to check if a variable is <code>undefined</code>, and avoids exceptional states in your code.
<h3 id="charcodeat">charCodeAt()</h3>
Every character of a string is represented by a unique number using UTF-16 character encoding. For English capital letters: A = 65 and Z = 90. If the first letter's character code falls in this range, we know it's upper case:
<pre><code class="hljs">function startsWithCapital(word){
 return word.charCodeAt(0) &gt;= 65 &amp;&amp; word.charCodeAt(0) &lt;= 90
}

console.log(startsWithCapital(&quot;This is working!&quot;)) // true
console.log(startsWithCapital(&quot;checking!&quot;)) // false
</code></pre>
<h3 id="test">test()</h3>
Alternatively, we can check for a match between a regular expression and a specified string. This is easily achieved with the <code>test()</code> function.
Let's take a look at an example:
<pre><code class="hljs">function startsWithCapital(word){
 return /[A-Z]/.test(word.charAt(0))
}

console.log(startsWithCapital(&quot;Capital letters&quot;)) // true
console.log(startsWithCapital(&quot;is this true?&quot;)) // false
</code></pre>
Here, <code>/[A-Z]/</code> represents all capital English letters (A to Z). We are checking whether the first letter of the string matches any of them.
<h2 id="capitalizingthefirstletter">Capitalizing the First Letter</h2>
If we found out that the first letter of the string is lower case, and if we want to capitalize it, we can do that using following method:
<pre><code class="hljs">function capitalizeFirstLetter(word){
 return word.charAt(0).toUpperCase() + word.slice(1)
}

console.log(capitalize(&quot;hello world!&quot;)) // Hello world
</code></pre>
Here, we take the first character and convert it to upper case. Then, we concatenate the rest of the string to that capitalized letter. This is done via the <code>slice()</code> function, where we've specified the starting index as <code>1</code>. Since it's 0-based, we've skipped the first letter.
<h2 id="conclusion">Conclusion</h2>
In this article, we have looked at a few ways to check if the first letter of a string is upper case and how to capitalize the first letter of a string.

Abhilash Kakumanu

In this tutorial, we'll go over examples of how to check if a string starts with a capital letter in JavaScript. We'll use a few approaches and discuss good practices.

JavaScript: Check if First Letter of a String Is Upper Case

JavaScript: Check if First Letter of a String is Upper Case

Guest Contributor

In this tutorial, we'll cover everything you need to know from basic to advanced usage of Heatmaps in Seaborn and Python. 

Ultimate Guide to Heatmaps in Seaborn with Python

<h2 id="introduction">Introduction</h2>
Comparison operators are used in logical statements to determine whether two variables or objects are equal by some already set or custom defined criteria. If the two variables or objects are deduced to be equal the operator returns <code>true</code>, and <code>false</code> if they aren't.
Comparison operators in JavaScript are:
<ul>
<li><code>&lt;</code> - less than</li>
<li><code>&gt;</code> - greater than</li>
<li><code>&lt;=</code> - less or equal than</li>
<li><code>&gt;=</code> - greater or equal than</li>
<li><code>==</code> and <code>===</code> - equal to (loose and strict equality operator)</li>
<li><code>!=</code> and <code>!==</code> - not equal to (loose and strict inequality operator)</li>
</ul>
JavaScript is interesting because it's got two visually very similar, but in practice very different comparison operators for equality: <code>==</code> and <code>===</code>.
In this article, we will explain the differences between loose and strict equality operators and go over some examples of their usage.
<h2 id="looseequalityoperatorinjavascript">Loose Equality Operator in JavaScript (==)</h2>
Double equals in JavaScript are testing for loose equality. This permits the JavaScript engine to try and cast these expressions to a common type. Meaning that the expressions don't necessarily need to be of the same type.
The process of converting a value from one type to another is called type coercion. Type coercion can be explicit and implicit.
Explicit type coercion is, as its name implies, done explicitly in code by a programmer, using the built-in methods that JavaScript provides (<code>Number()</code>, <code>String()</code>, <code>Boolean()</code>...).
For example:
<pre><code class="hljs">// This would result in x being a number 42
let x = Number(&quot;42&quot;);

// Similarly,this would result in y being cast to the boolean value false 
let y = Boolean(0);
</code></pre>
Implicit type coercion is, on the other hand, done implicitly by JavaScript. This coercion type is usually done when we use operators on different types, but can be reasonably &quot;matched&quot; by one of them, for example:
<pre><code class="hljs">// x is going to be cast to the string &quot;1&quot;.
let x = 1 + &quot;&quot;; 
</code></pre>
To explain this example, let's look at it from a JavaScript engine's perspective:
<blockquote>
The expression should be evaluated and assigned to <code>x</code>. The first number is <code>1</code> and has <code>+</code> operator beside it. This implies integer addition with the next number. However, there's an empty string, <code>&quot;&quot;</code>, there. This can't be converted into a number. However, we can also concatenate strings with <code>+</code>, so let's match them as strings and perform concatenation. Finally, the result is returned and assigned to <code>x</code>.
</blockquote>
To sum up, the JavaScript engine tries to convert both values to a type that supports 
the <code>+</code> operator, which in this case is a string.
<pre><code class="hljs">/* In this case, the JS engine deduces that both the operands and the result have to be cast to an integer because it&#x27;s the only type that has a defined subtraction operation (-) */

let y = &quot;5&quot; - &quot;2&quot;;

// Because booleans don&#x27;t have a + operation, the JS engine converts both true values into 1&#x27;s

let z = true + true;
</code></pre>
Now, it's exactly this type of coercion that the <code>==</code> operator uses to check for equality. Let's go over some examples of loose equality operator usage, in the Node REPL:
<pre><code class="hljs">&gt; 42 == &quot;42&quot;
true
&gt; &quot;42&quot; == &#x27;42&#x27;
true
</code></pre>
<code>42</code>, <code>&quot;42&quot;</code> and <code>'42'</code> are all matched into the same data type, and are all loosely equal, returning <code>true</code> in the comparisons.
Booleans follow the same principle:
<pre><code class="hljs">&gt; true == 1
true
&gt; true + true == 2
true
&gt; false == 0
true
&gt; false + true == 1
true
</code></pre>
<code>true</code> is <code>1</code> and <code>false</code> is <code>0</code>. We can implicitly convert these into integers by adding them.
Finally, here's an example of an (unreadable) but syntactically valid comparison:
<pre><code class="hljs">&gt; (&quot;42&quot; == &#x27;42&#x27;) + (42 == &quot;42&quot;) == 2
true
</code></pre>
<code>&quot;42&quot; == '42'</code> is evaluated as <code>true</code>, as well as <code>42 == &quot;42&quot;</code>. The other side of the expression is also <code>true</code>, so we ended up with <code>true + true</code>, which is implicitly converted into <code>1+1</code> because of the <code>+</code> sign. That's obviously <code>==</code> to <code>2</code>, so the overall expression returns <code>true</code>.
<h2 id="falsyvaluecomparisoninjavascript">Falsy Value Comparison in JavaScript</h2>
A falsy value is a variable which evaluates to <code>false</code>. In JavaScript, there are seven falsy values - <code>false</code>, <code>0</code>, <code>&quot;&quot;</code>, <code>[]</code>, <code>null</code>, <code>undefined</code>, <code>NaN</code>.
There are a couple of simple rules when it comes to using the double equals operator on falsy values:
<ul>
<li><code>false</code>, <code>0</code> and <code>&quot;&quot;</code> are equivalent</li>
<li><code>undefined</code> and <code>null</code> return <code>true</code> when compared to themselves or each other, and <code>false</code> when compared to anything else</li>
<li><code>NaN</code> compared to anything (even another <code>NaN</code>) returns <code>false</code></li>
</ul>
So, these would all be <code>true</code>:
<pre><code class="hljs">&gt; false == 0;
true
&gt; false == &quot;&quot;;
true
&gt; 0 == &quot;&quot;;
true
&gt; undefined == null;
true
&gt; undefined == undefined;
true
&gt; null == null;
true
&gt; [] == false;
true
&gt; [] == 0;
true
</code></pre>
While these would all be <code>false</code>:
<pre><code class="hljs">&gt; undefined == false;
false
&gt; 0 == null;
false
&gt; null == true
false
&gt; NaN == false;
false
&gt; NaN == NaN;
false
</code></pre>
<h2 id="strictequalityoperatorinjavascript">Strict Equality Operator in JavaScript (===)</h2>
Triple equals in JavaScript stands for strict equality. This means that, unlike the loose equality operator we talked about before, there is no implicit conversion. Meaning the output won't be <code>true</code> unless both the type and values of the two expressions match. They aren't matched on type anymore.
Now, let's have a look at some strict equality operator examples:
<pre><code class="hljs">&gt; true === true
true
&gt; true === 1
false
&gt; false === 0
false
</code></pre>
This example produces <code>true</code> in the first case because both the type (boolean) and value (<code>true</code>) are equal. In the other two cases, it returns <code>false</code>, because although the values are the same, the types don't match. We're comparing a boolean to an integer.
<pre><code class="hljs">&gt; 42 === 42
true
&gt; 42 === &quot;42&quot;
false
</code></pre>
Here, both the number and value are equal in the first example, resulting in <code>true</code>, while the value and type mismatch in the second example, resulting in <code>false</code>.
<h2 id="conclusion">Conclusion</h2>
In this article we explained the difference between the loose equality operator and the strict equality operator in JavaScript. 
We also explained what type coercion was, and the concept of explicit and implicit type coercion.
You may have noticed that implicit type coercion that occurs when we use the loose equality operator in JavaScript can be pretty unpredictable an <a rel="nofollow noopener" raget ="_blank" href ="http://www.jsfuck.com/">counter-intuitive</a>. This is why, if you're not very experienced with JavaScript, it is usually better to stick to the strict equality operator when checking whether or not the two expressions are equal.
By using the strict equality operator you are testing both the type and value, and you can therefore be sure to always execute a true equality test.

Mila Lukic

In this tutorial, we'll go over the difference between the loose == and strict === equality operators in JavaScript with examples.

JavaScript: == vs === Operator

<h2 id="introduction">Introduction</h2>
In Python, every object instance comes pre-built with standard functions and attributes. For example, Python uses a dictionary to store an object's instance attributes. This has many benefits, like allowing us to add new attributes at runtime. However, this convenience comes at a cost.
Dictionaries can consume a fair chunk of memory, especially if we have many instance objects with a large number of attributes. If the performance and memory efficiency of code are critical, we can trade the convenience of dictionaries for <code>__slots__</code>.
In this tutorial, we will look at what <code>__slots__</code> are and how to use them in Python. We'll also discuss the tradeoffs for using <code>__slots__</code>, and look at their performance when compared to typical classes that store their instance attributes with dictionaries.
<h2 id="whatare_slots_andhowtousethem">What Are _slots_ and How to Use Them?</h2>
Slots are class variables that can be assigned a string, an iterable, or a sequence of strings of the instance variable names. When using slots, you name an object's instance variables up front, losing the ability to add them dynamically.
An object instance using slots does not have a built-in dictionary. As a result, more space is saved and accessing attributes is faster.
Let's see it in action. Consider this regular class:
<pre><code class="hljs">class CharacterWithoutSlots():
 organization = &quot;Slate Rock and Gravel Company&quot;

 def __init__(self, name, location):
 self.name = name
 self.location = location

without_slots = character_without_slots(&#x27;Fred Flinstone&#x27;, &#x27;Bedrock&#x27;)
print(without_slots.__dict__) # Print the arguments
</code></pre>
In the above snippet:
<ul>
<li><code>organization</code> is a class variable</li>
<li><code>name</code> and <code>location</code> are instance variables (note the keyword <code>self</code> in front of them)</li>
</ul>
While every object instance of the class is created, a dynamic dictionary is allocated under the attribute name as <code>__dict__</code> which includes all of an object's writable attributes. The output of the above code snippet is:
<pre><code class="hljs">{&#x27;name&#x27;: &#x27;Fred Flinstone&#x27;, &#x27;location&#x27;: &#x27;Bedrock&#x27;}
</code></pre>
This can be pictorially represented as:
<img src="https://stackabuse.s3.amazonaws.com/media/using-slots-to-store-data-in-python-1.jpg" alt="Figure 1: Behavior of a Normal Class Object">
Now, let's see how we can implement this class using slots:
<pre><code class="hljs">class CharacterWithSlots():
 __slots__ = [&quot;name&quot;, &quot;location&quot;]
 organization = &quot;Slate Rock and Gravel Company&quot;

 def __init__(self, name, location):
 self.name = name
 self.location = location

with_slots = CharacterWithSlots(&#x27;Fred Flinstone&#x27;, &#x27;Bedrock&#x27;)
print(with_slots.__dict__)
</code></pre>
In the above snippet:
<ul>
<li><code>organization</code> is a class variable</li>
<li><code>name</code> and <code>location</code> are instance variables</li>
<li>The keyword <code>__slots__</code> is a class variable holding the list of the instance variables (<code>name</code> and <code>location</code>)</li>
</ul>
Running that code will give us this error:
<pre><code class="hljs">Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
AttributeError: &#x27;character_without_slots&#x27; object has no attribute &#x27;__dict__&#x27;
</code></pre>
That's right! Object instances of classes with slots do not have a <code>__dict__</code> attribute. Behind the scenes, instead of storing the instance variables in a dictionary, the values are mapped with the index locations as shown in the figure below:
<img src="https://stackabuse.s3.amazonaws.com/media/using-slots-to-store-data-in-python-2.jpg" alt="Figure 2: Behavior of a Class Object with ">
While there's no <code>__dict__</code> attribute, you still access the object properties as you would typically do:
<pre><code class="hljs">print(with_slots.name) # Fred Flinstone
print(with_slots.location) # Bedrock
print(with_slots.organization) # Slate Rock and Gravel Company
</code></pre>
Slots were created purely for performance improvements as stated by Guido in his <a href="http://python-history.blogspot.com/2010/06/inside-story-on-new-style-classes.html" rel="nofollow noopener" target="_blank">authoritative blog post</a>.
Let's see if they outperform standard classes.
<h2 id="efficiencyandvelocityofslots">Efficiency and Velocity of Slots</h2>
We are going to compare objects instantiated with slots to objects instantiated with dictionaries with two tests. Our first test will look at how they allocate memory. Our second test will look at their runtimes.
This benchmarking for memory and runtime is done on Python 3.8.5 using the modules <code>tracemalloc</code> for memory allocation tracing and <code>timeit</code> for the runtime evaluation.
Results may vary on your personal computer:
<pre><code class="hljs">import tracemalloc
import timeit

# The following `Benchmark` class benchmarks the
# memory consumed by the objects with and without slots
class Benchmark:
 def __enter__(self):
 self.allocated_memory = None
 tracemalloc.start()
 return self

 def __exit__(self, exec_type, exec_value, exec_traceback):
 present, _ = tracemalloc.get_traced_memory()
 tracemalloc.stop()
 self.allocated_memory = present


# The class under evaluation. The following class
# has no slots initialized
class CharacterWithoutSlots():
 organization = &quot;Slate Rock and Gravel Company&quot;

 def __init__(self, name, location):
 self.name = name
 self.location = location


# The class under evaluation. The following class
# has slots initialized as a class variable
class CharacterWithSlots():
 __slots__ = [&quot;name&quot;, &quot;location&quot;]
 organization = &quot;Slate Rock and Gravel Company&quot;

 def __init__(self, name, location):
 self.name = name
 self.location = location


# The following `calculate_memory` function creates the object for the
# evaluated `class_` argument corresponding to the class and finds the
# memory used
def calculate_memory(class_, number_of_times):
 with Benchmark() as b:
 _ = [class_(&quot;Barney&quot;, &quot;Bedrock&quot;) for x in range(number_of_times)]
 return b.allocated_memory / (1024 * 1024)


# The following `calculate_runtime` function creates the object for the
# evaluated `class_` argument corresponding to the class and finds the
# runtime involved
def calculate_runtime(class_, number_of_times):
 timer = timeit.Timer(&quot;instance.name; instance.location&quot;,
 setup=&quot;instance = class_(&#x27;Barney&#x27;, &#x27;Bedrock&#x27;)&quot;,
 globals={&#x27;class_&#x27;: class_})
 return timer.timeit(number=number_of_times)


if __name__ == &quot;__main__&quot;:
 number_of_runs = 100000 # Alter the number of runs for the class here

 without_slots_bytes = calculate_memory(
 CharacterWithoutSlots, number_of_runs)
 print(f&quot;Without slots Memory Usage: {without_slots_bytes} MiB&quot;)

 with_slots_bytes = calculate_memory(CharacterWithSlots, number_of_runs)
 print(f&quot;With slots Memory Usage: {with_slots_bytes} MiB&quot;)

 without_slots_seconds = calculate_runtime(
 CharacterWithoutSlots, number_of_runs)
 print(f&quot;Without slots Runtime: {without_slots_seconds} seconds&quot;)

 with_slots_seconds = calculate_runtime(
 CharacterWithSlots, number_of_runs)
 print(f&quot;With slots Runtime: {with_slots_seconds} seconds&quot;)
</code></pre>
In the above snippet, the <code>calculate_memory()</code> function determines the allocated memory, and the <code>calculate_runtime()</code> function determines the runtime evaluation of the class with slots vs the class without slots.
The results will look something along these lines:
<pre><code class="hljs">Without slots Memory Usage: 15.283058166503906 MiB
With slots Memory Usage: 5.3642578125 MiB
Without slots Runtime: 0.0068232000012358185 seconds
With slots Runtime: 0.006200600000738632 seconds
</code></pre>
It's evident that using <code>__slots__</code> gives an edge over using dictionaries in size and speed. While the speed difference is not particularly noticeable, the size difference is significant.
<h2 id="gotchasusingslots">Gotchas Using Slots</h2>
Before you jump into using slots in all of your classes, there are a few caveats to be mindful of:
<ol>
<li>It can only store attributes defined in the <code>__slots__</code> class variable. For example, in the following snippet when we try to set an attribute for an instance that is not present in the <code>__slots__</code> variable, we get an <code>AttributeError</code>:</li>
</ol>
<pre><code class="hljs">class character_with_slots():
 __slots__ = [&quot;name&quot;, &quot;location&quot;]
 organization = &quot;Slate Rock and Gravel Company&quot;

 def __init__(self, name, location):
 self.name = name
 self.location = location

with_slots = character_with_slots(&#x27;Fred Flinstone&#x27;, &#x27;Bedrock&#x27;)
with_slots.pet = &quot;dino&quot;
</code></pre>
Output:
<pre><code class="hljs">Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
AttributeError: &#x27;character_with_slots&#x27; object has no attribute &#x27;pet&#x27;
</code></pre>
With slots, you need to know all the attributes present in the class and define them in the <code>__slots__</code> variable.
<ol start="2">
<li>Sub-classes will not follow the <code>__slots__</code> assignment in the superclass. Let's say your base class has the <code>__slots__</code> attribute assigned and this is inherited to a subclass, the subclass will have a <code>__dict__</code> attribute by default.</li>
</ol>
Consider the following snippet where the object of the subclass is checked if its directory contains the <code>__dict__</code> attribute and the output turns out to be <code>True</code>:
<pre><code class="hljs">class CharacterWithSlots():
 __slots__ = [&quot;name&quot;, &quot;location&quot;]
 organization = &quot;Slate Rock and Gravel Company&quot;

 def __init__(self, name, location):
 self.name = name
 self.location = location


class SubCharacterWithSlots(CharacterWithSlots):
 def __init__(self, name, location):
 self.name = name
 self.location = location

sub_object = SubCharacterWithSlots(&quot;Barney&quot;, &quot;Bedrock&quot;)

print(&#x27;__dict__&#x27; in dir(sub_object))
</code></pre>
Output:
<pre><code class="hljs">True
</code></pre>
This can be averted by declaring the <code>__slots__</code> variable one more time for the subclass for all the instance variables present in the subclass. Although this seems redundant, the effort can be weighed against the amount of memory saved:
<pre><code class="hljs">class CharacterWithSlots():
 __slots__ = [&quot;name&quot;, &quot;location&quot;]
 organization = &quot;Slate Rock and Gravel Company&quot;

 def __init__(self, name, location):
 self.name = name
 self.location = location

class SubCharacterWithSlots(CharacterWithSlots):
 __slots__ = [&quot;name&quot;, &quot;location&quot;, &quot;age&quot;]

 def __init__(self, name, location):
 self.name = name
 self.location = location
 self.age = 40

sub_object = SubCharacterWithSlots(&quot;Barney&quot;, &quot;Bedrock&quot;)

print(&#x27;__dict__&#x27; in dir(sub_object))
</code></pre>
Output:
<pre><code class="hljs">False
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we have learned the basics about the <code>__slots__</code> attribute, and how classes with slots differ from classes with dictionaries. We also benchmarked those two classes with slots being significantly more memory efficient. Finally, we discussed some known caveats with using slots in classes.
If used in the right places, <code>__slots__</code> can boost performance and optimize the code in making it more memory efficient.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

In this tutorial, you will learn what are slots in Python. We'll discuss their memory and speed improvements as well as the tradeoffs for using them.

Using __slots__ to Store Object Data in Python

Naazneen Jatu

In this article, we will learn how to load and export HTML table data to and from a Pandas DataFrame.

Reading and Writing HTML Tables with Pandas

In this tutorial, we'll go over how to create a confirmation dialogue in Vue.js, by making a general modal popup window and inheriting it for this purpose, with examples.

How to Create a Confirmation Dialogue in Vue.js

<h2 id="introduction">Introduction</h2>
Working with arrays in JavaScript is a common activity. Sometimes we get a variable in JavaScript that we need to be an array, but we aren't sure that it is.
Non-primitive data types in JavaScripts are all objects (functions have their own type, but they too are objects). As a result, it's not sufficient to use the <code>typeof</code> operator that's commonly used to determine a data type:
<pre><code class="hljs">let result = { subject: &#x27;Science&#x27;, marks: 97 };
let numbers = [1, 2, 3, 4, 5];

console.log(typeof result); // Object
console.log(typeof numbers); // Object
</code></pre>
In this article, we'll take a look at how to check if a given variable or value is an array or not, in JavaScript.
<h2 id="usingthearrayisarraymethod">Using the Array.isArray() Method</h2>
As the name suggests, this method can be used to identify whether the given argument is an array or not. It returns a boolean (<code>true</code>/<code>false</code>) value with the result.
For example, with the following variables the <code>Array.isArray()</code> method correctly determines if they are one or not:
<pre><code class="hljs">let result = { subject: &quot;Science&quot;, marks: 97 }; // Object
let numbers = [1, 2, 3, 4, 5]; // Array
let name = &quot;Mark&quot;; // String
let names = new Array(&quot;Jill&quot;, &quot;Jane&quot;, &quot;Jacqueline&quot;);

console.log(Array.isArray(result)); // false
console.log(Array.isArray(numbers)); // true
console.log(Array.isArray(name)); // false
console.log(Array.isArray(names)); // true
</code></pre>
<h2 id="usinganobjectsconstructorproperty">Using an Object's constructor Property</h2>
Every object has a <code>constructor</code> property (except objects created with <code>Object.create(null)</code>, an unlikely occurrence). We can compare the constructor property directly with JavaScript's constructor functions. Therefore, if we compare it with the array constructor function, we'll know if it's an array.

 <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: A constructor function is a function that initializes an object. If you've created an object with the <code>new</code> keyword, you did so with a constructor function. For example, in <code>let myArray = new Array(1, 2)</code> the constructor function used is <code>Array()</code>.

 </div>
 </div>
 </div>
 You can use the constructor property to determine if a variable is an array:
<pre><code class="hljs">let result = { subject: &quot;Science&quot;, marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = &quot;Mark&quot;;
let names = new Array(&quot;Jill&quot;, &quot;Jane&quot;, &quot;Jacqueline&quot;);

console.log(result.constructor === Array); // false
console.log(numbers.constructor === Array); // true
console.log(name.constructor === Array); // false
console.log(names.constructor === Array); // true
</code></pre>
<h2 id="usingtheinstanceofoperator">Using the instanceof Operator</h2>
The <code>instanceof</code> operator checks if a constructor function is found in the prototype chain of an object. If you're less familiar with JavaScript's prototypal inheritance, the operator checks if an object was created by a class, and if not, checks if the object was derived from that class.
Like the <code>typeof</code> operator, it returns a boolean value. To determine if a variable is an array, we can use <code>instanceof</code> like this:
<pre><code class="hljs">let result = { subject: &quot;Science&quot;, marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = &quot;Mark&quot;;
let names = new Array(&quot;Jill&quot;, &quot;Jane&quot;, &quot;Jacqueline&quot;);

console.log(result instanceof Array); // false
console.log(numbers instanceof Array); // true
console.log(name instanceof Array); // false
console.log(names instanceof Array); // true
</code></pre>
<h2 id="usingtheobjectprototypecallmethod">Using the Object.prototype.call() Method</h2>
All objects in JavaScript inherit properties from the main prototype object, aptly named <code>Object.prototype</code>. A <code>toString()</code> method exists in <code>Object.prototype</code>, which is why every object has a <code>toString()</code> method of their own. The <code>toString()</code> method of <code>Object.prototype</code> displays the type of an object.
The <code>call()</code> method of objects executes a function but changes the value of <code>this</code> to the object passed in its arguments i.e. it allows an object to use a method from another object.
Therefore, we can use <code>Object.prototype.toString()</code> to print the type and then use <code>call()</code> so it's done for another object. We then compare that string value to determine if it's an array:
<pre><code class="hljs">let result = { subject: &quot;Science&quot;, marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = &quot;Mark&quot;;
let names = new Array(&quot;Jill&quot;, &quot;Jane&quot;, &quot;Jacqueline&quot;);

console.log(Object.prototype.toString.call(result)); // [object Object]
console.log(Object.prototype.toString.call(numbers)); // [object Array]
console.log(Object.prototype.toString.call(name)); // [object String]
console.log(Object.prototype.toString.call(names)); // [object Array]

console.log(Object.prototype.toString.call(result) === &quot;[object Array]&quot;); // false
console.log(Object.prototype.toString.call(numbers) === &quot;[object Array]&quot;); // true
console.log(Object.prototype.toString.call(name) === &quot;[object Array]&quot;); // false
console.log(Object.prototype.toString.call(names) === &quot;[object Array]&quot;); // true
</code></pre>
It's unlikely that you'll use this method, but it never hurts to know more about JavaScript objects!
<h2 id="conclusion">Conclusion</h2>
In this article, we looked at a few ways in JavaScript to determine if an object is an array. The easiest method is the <code>Array.isArray()</code> method that will most likely be used in production.
However, we can always leverage the <code>instanceof</code> operator and other object properties to determine if it's an array.

In this article, we'll discuss various methods to determine whether an object is an array in JavaScript using the Arrays.isArray() method, instanceof operator, etc.

JavaScript: Check if Object is Array

Dan Nelson

In this tutorial, we'll go over how to plot Violin Plots with Seaborn. We'll go over simple and advanced customized Violin Plots with examples.

Seaborn Violin Plot - Tutorial and Examples

<h2 id="introduction">Introduction</h2>
Python is supported by many libraries which simplify data transfer over HTTP. The <code>requests</code> library is one of the most popular Python packages as it's heavily used in web scraping. It's also popular for interacting with servers! The library makes it easy to upload data in a popular format like JSON, but also makes it easy to upload files as well.
In this tutorial, we will take a look at how to upload files using Python's <code>requests</code> library. The article will start by covering the <code>requests</code> library and the <code>post()</code> function signature. Next, we will cover how to upload a single file using the <code>requests</code> package. Last but not least, we upload multiple files in one request.
<h2 id="uploadingasinglefilewithpythonsrequestslibrary">Uploading a Single File with Python's Requests Library</h2>
This tutorial covers how to send the files, we're not concerned about how they're created. To follow along, create three files called <code>my_file.txt</code>, <code>my_file_2.txt</code> and <code>my_file_3.txt</code>.
The first thing we need to do is install our the <code>request</code> library in our workspace. While not necessary, it's recommended that you install libraries in a virtual environment:
<pre><code class="hljs">$ python3 -m venv .
</code></pre>
Activate the virtual environment so that we would no longer impact the global Python installation:
<pre><code class="hljs">$ . bin/activate
</code></pre>
Now let's install the <code>requests</code> library with <code>pip</code>:
<pre><code class="hljs">$ pip install requests
</code></pre>
Create a new file called <code>single_uploader.py</code> which will store our code. In that file, let's begin by importing the <code>requests</code> library:
<pre><code class="hljs">import requests
</code></pre>
Now we're set up to upload a file! When uploading a file, we need to open the file and stream the content. After all, we can't upload a file we don't have access to. We'll do this with the <code>open()</code> function.
The <code>open()</code> function accepts two parameters: the path of the file and the <a href="/file-handling-in-python/" target="_blank">mode</a>. The path of the file can be an absolute path or a relative path to where the script is being run. If you're uploading a file in the same directory, you can just use the file's name.
The second argument, mode, will take the &quot;read binary&quot; value which is represented by <code>rb</code>. This argument tells the computer that we want to open the file in the read mode, and we wish to consume the data of the file in a binary format:
<pre><code class="hljs">test_file = open(&quot;my_file.txt&quot;, &quot;rb&quot;)
</code></pre>
Note: it's important to read the file in binary mode. The <code>requests</code> library typically determines the <code>Content-Length</code> header, which is a value in bytes. If the file is not read in bytes mode, the library may get an incorrect value for <code>Content-Length</code>, which would cause errors during file submission.
For this tutorial, we'll make requests to the free httpbin service. This API allows developers to test their HTTP requests. Let's create a variable that stores the URL we'll post our files to:
<pre><code class="hljs">test_url = &quot;http://httpbin.org/post&quot;
</code></pre>
We now have everything to make the request. We'll use the <code>post()</code> method of the <code>requests</code> library to upload the file. We need two arguments to make this work: the URL of the server and <code>files</code> property. We'll also save the response in a variable, write the following code:
<pre><code class="hljs">test_response = requests.post(test_url, files = {&quot;form_field_name&quot;: test_file})
</code></pre>
The <code>files</code> property takes a dictionary. The key is the name of the form field that accepts the file. The value is the bytes of the opened file you want to upload.
Normally to check if your <code>post()</code> method was successful we check the HTTP status code of the response. We can use the <code>ok</code> property of the response object, <code>test_url</code>. If it's true, we'll print out the response from the HTTP server, in this case, it will echo the request:
<pre><code class="hljs">if test_response.ok:
 print(&quot;Upload completed successfully!&quot;)
 print(test_response.text)
else:
 print(&quot;Something went wrong!&quot;)
</code></pre>
Let's try it out! In the terminal, execute your script with the <code>python</code> command:
<pre><code class="hljs">python single_uploader.py
</code></pre>
Your output would be similar to this:
<pre><code class="hljs">Upload completed successfully!
{
 &quot;args&quot;: {}, 
 &quot;data&quot;: &quot;&quot;, 
 &quot;files&quot;: {
 &quot;form_field_name&quot;: &quot;This is my file\nI like my file\n&quot;
 }, 
 &quot;form&quot;: {}, 
 &quot;headers&quot;: {
 &quot;Accept&quot;: &quot;*/*&quot;, 
 &quot;Accept-Encoding&quot;: &quot;gzip, deflate&quot;, 
 &quot;Content-Length&quot;: &quot;189&quot;, 
 &quot;Content-Type&quot;: &quot;multipart/form-data; boundary=53bb41eb09d784cedc62d521121269f8&quot;, 
 &quot;Host&quot;: &quot;httpbin.org&quot;, 
 &quot;User-Agent&quot;: &quot;python-requests/2.25.0&quot;, 
 &quot;X-Amzn-Trace-Id&quot;: &quot;Root=1-5fc3c190-5dea2c7633a02bcf5e654c2b&quot;
 }, 
 &quot;json&quot;: null, 
 &quot;origin&quot;: &quot;102.5.105.200&quot;, 
 &quot;url&quot;: &quot;http://httpbin.org/post&quot;
}
</code></pre>
As a sanity check, you can verify the <code>form_field_name</code> value matches what's in your file.
<h2 id="uploadingmultiplefileswithpythonsrequestslibrary">Uploading Multiple Files with Python's requests Library</h2>
Uploading multiple files using requests is quite similar to a single file, with the major difference being our use of lists. Create a new file called <code>multi_uploader.py</code> and the following setup code:
<pre><code class="hljs">import requests

test_url = &quot;http://httpbin.org/post&quot;
</code></pre>
Now create a variable called <code>test_files</code> that's a dictionary with multiple names and files:
<pre><code class="hljs">test_files = {
 &quot;test_file_1&quot;: open(&quot;my_file.txt&quot;, &quot;rb&quot;),
 &quot;test_file_2&quot;: open(&quot;my_file_2.txt&quot;, &quot;rb&quot;),
 &quot;test_file_3&quot;: open(&quot;my_file_3.txt&quot;, &quot;rb&quot;)
}
</code></pre>
Like before, the keys are the names of the form fields and the values are the files in bytes.
We can also create our files variables as a list of tuples. Each tuple contains the name of the form field accepting the file, followed by the file's contents in bytes:
<pre><code class="hljs">test_files = [(&quot;test_file_1&quot;, open(&quot;my_file.txt&quot;, &quot;rb&quot;)),
 (&quot;test_file_2&quot;, open(&quot;my_file_2.txt&quot;, &quot;rb&quot;)),
 (&quot;test_file_3&quot;, open(&quot;my_file_3.txt&quot;, &quot;rb&quot;))]
</code></pre>
Either works so choose whichever one you prefer!
Once the list of files is ready, you can send the request and check its response like before:
<pre><code class="hljs">test_response = requests.post(test_url, files = test_files)

if test_response.ok:
 print(&quot;Upload completed successfully!&quot;)
 print(test_response.text)
else:
 print(&quot;Something went wrong!&quot;)
</code></pre>
Execute this script with the <code>python</code> command:
<pre><code class="hljs">$ python multi_uploader.py
</code></pre>
You'll see this output:
<pre><code class="hljs">Upload completed successfully!
{
 &quot;args&quot;: {}, 
 &quot;data&quot;: &quot;&quot;, 
 &quot;files&quot;: {
 &quot;test_file_1&quot;: &quot;This is my file\nI like my file\n&quot;, 
 &quot;test_file_2&quot;: &quot;All your base are belong to us\n&quot;, 
 &quot;test_file_3&quot;: &quot;It&#x27;s-a me, Mario!\n&quot;
 }, 
 &quot;form&quot;: {}, 
 &quot;headers&quot;: {
 &quot;Accept&quot;: &quot;*/*&quot;, 
 &quot;Accept-Encoding&quot;: &quot;gzip, deflate&quot;, 
 &quot;Content-Length&quot;: &quot;470&quot;, 
 &quot;Content-Type&quot;: &quot;multipart/form-data; boundary=4111c551fb8c61fd14af07bd5df5bb76&quot;, 
 &quot;Host&quot;: &quot;httpbin.org&quot;, 
 &quot;User-Agent&quot;: &quot;python-requests/2.25.0&quot;, 
 &quot;X-Amzn-Trace-Id&quot;: &quot;Root=1-5fc3c744-30404a8b186cf91c7d239034&quot;
 }, 
 &quot;json&quot;: null, 
 &quot;origin&quot;: &quot;102.5.105.200&quot;, 
 &quot;url&quot;: &quot;http://httpbin.org/post&quot;
}
</code></pre>
Good job! You can upload single and multiple files with <code>requests</code>!
<h2 id="conclusion">Conclusion</h2>
In this article, we learned how to upload files in Python using the <code>requests</code> library. Where it's a single file or multiple files, only a few tweaks are needed with the <code>post()</code> method. We also verified our response to ensure that our uploads were successful.

Mohamed Echout

In this tutorial, will learn how to upload files with the Python requests library. We'll cover uploading single and many files in one request.