Hiram Kamau

Overloading refers to defining multiple methods with the same names but different signatures in the same class. We'll be discussing the syntax and best practices when overloading.

Guide to Overloading Methods in Java

<h2 id="introduction">Introduction</h2>
Some functions have no arguments, others have multiple. There are times we have functions with arguments we don't know about beforehand. We may have a variable number of arguments because we want to offer a flexible API to other developers or we don't know the input size. With Python, we can create functions to accept any amount of arguments.
In this article, we will look at how we can define and use functions with variable length arguments. These functions can accept an unknown amount of input, either as consecutive entries or named arguments.
<h2 id="usingmanyargumentswithargs">Using Many Arguments with *args</h2>
Let's implement a function that finds the minimum value between two numbers. It would look like this:
<pre><code class="hljs">def my_min(num1, num2):
 if num1 &lt; num2:
 return num1
 return num2

my_min(23, 50)
</code></pre>
<pre><code class="hljs">23
</code></pre>
It simply checks if the first number is smaller than the second number. If it is, then the first number is returned. Otherwise, the second number is returned.
If we would like to find a minimum of 3 numbers, we can add another argument to <code>my_min()</code> and more if-statements. If our minimum function needs to find the lowest number of any indeterminate amount, we can use a list:
<pre><code class="hljs">def my_min(nums):
 result = nums[0]
 for num in nums:
 if num &lt; result:
 result = num
 return result

my_min([4, 5, 6, 7, 2])
</code></pre>
<pre><code class="hljs">2
</code></pre>
While this works, our coders now have to enclose their numbers in a list, which isn't as straightforward as it was when we had two or three defined arguments. Let's get the best of both worlds with variable length arguments.
Variable-length arguments, varargs for short, are arguments that can take an unspecified amount of input. When these are used, the programmer does not need to wrap the data in a list or an alternative sequence.
In Python, varargs are defined using the <code>*args</code> syntax. Let's reimplement our <code>my_min()</code> function with <code>*args</code>:
<pre><code class="hljs">def my_min(*args):
 result = args[0]
 for num in args:
 if num &lt; result:
 result = num
 return result

my_min(4, 5, 6, 7, 2)
</code></pre>
<pre><code class="hljs">2
</code></pre>
<blockquote>
Note: <code>args</code> is just a name, you can name that vararg anything as long as it is preceded by a single asterisk (<code>*</code>). It's best practice to keep naming it <code>args</code> to make it immediately recognizable.
</blockquote>
Any argument that comes after <code>*args</code> must be a named argument - an argument that's referenced by its name instead of its position. With <code>*args</code> you can no longer reference another argument by its position.
Also, you can only have on <code>*args</code> type vararg in a function.
You may be thinking that the solution with <code>*args</code> is very similar to the list solution. That's because <code>*args</code> is internally a Tuple, which is an iterable sequence similar to lists. If you'd like to verify it's type, you can enter the code in your Python interpreter:
<pre><code class="hljs">$ python3
&gt;&gt;&gt; def arg_type_test(*args):
... print(type(args))
...
&gt;&gt;&gt; arg_type_test(1, 2)
&lt;class &#x27;tuple&#x27;&gt;
</code></pre>
With <code>*args</code>, we can accept multiple arguments in sequence as is done in <code>my_min()</code>. These arguments are processed by their position. What if we wanted to take multiple arguments, but reference them by their name? We'll take a look at how to do this in the next section.
<h2 id="usingmanynamedargumentswithkwargs">Using Many Named Arguments with **kwargs</h2>
Python can accept multiple keyword arguments, better known as <code>**kwargs</code>. It behaves similarly to <code>*args</code>, but stores the arguments in a dictionary instead of tuples:
<pre><code class="hljs">def kwarg_type_test(**kwargs):
 print(kwargs)

kwarg_type_test(a=&quot;hi&quot;)
kwarg_type_test(roses=&quot;red&quot;, violets=&quot;blue&quot;)
</code></pre>
The output will be:
<pre><code class="hljs">{&#x27;a&#x27;: &#x27;hi&#x27;}
{&#x27;roses&#x27;: &#x27;red&#x27;, &#x27;violets&#x27;: &#x27;blue&#x27;}
</code></pre>
By using a dictionary, <code>**kwargs</code> can preserve the names of the arguments, but it would not be able to keep their position.
<blockquote>
Note: Like <code>args</code>, you can use any other name than <code>kwargs</code>. However, best practice dictates that you should consistently use <code>kwargs</code>.
</blockquote>
Since <code>**kwargs</code> is a dictionary, you can iterate over them like any other using the <code>.items()</code> method:
<pre><code class="hljs">def kwargs_iterate(**kwargs):
 for i, k in kwargs.items():
 print(i, &#x27;=&#x27;, k)

kwargs_iterate(hello=&#x27;world&#x27;)
</code></pre>
When run, our console will show:
<pre><code class="hljs">hello = world
</code></pre>
Keyword arguments are useful when you aren't sure if an argument is going to be available. For example, if we had a function to save a blog post to a database, we would save the information like the content and the author. A blog post may have tags and categories, though those aren't always set.
We can define a function like this:
<pre><code class="hljs">def save_blog_post(content, author, tags=[], categories=[]):
 pass
</code></pre>
Alternatively, we allow the function caller to pass any amount of arguments, and only associate <code>tags</code> and <code>categories</code> if they're set:
<pre><code class="hljs">def save_blog_post(content, author, **kwargs):
 if kwargs.get(&#x27;tags&#x27;):
 # Save tags with post
 pass

 if kwargs.get(&#x27;categories&#x27;):
 # Save categories with post
 pass
</code></pre>
Now that we have a grasp of both types of support for variable length arguments, let's see how we can combine the two in one function.
<h2 id="combiningvarargsandkeywordarguments">Combining Varargs and Keyword Arguments</h2>
Quite often we want to use both <code>*args</code> and <code>**kwargs</code> together, especially when writing Python libraries or reusable code. Lucky for us, <code>*args</code> and <code>**kwargs</code> play nicely together, and we can use them in the following way:
<pre><code class="hljs">def combined_varargs(*args, **kwargs):
 print(args)
 print(kwargs)

combined_varargs(1, 2, 3, a=&quot;hi&quot;)
</code></pre>
If you run that code snippet you'll see:
<pre><code class="hljs">(1, 2, 3)
{&#x27;a&#x27;: &#x27;hi&#x27;}
</code></pre>
When mixing the positional and named arguments, positional arguments must come before named arguments. Furthermore, arguments of a fixed length come before arguments with variable length. Therefore, we get an order like this:
<ol>
<li>Known positional arguments</li>
<li><code>*args</code></li>
<li>Known named arguments</li>
<li><code>**kwargs</code></li>
</ol>
A function with all types of arguments can look like this:
<pre><code class="hljs">def super_function(num1, num2, *args, callback=None, messages=[], **kwargs):
 pass
</code></pre>
Once we follow that order when defining and calling functions with varargs and keyword arguments, we'll get the behavior we expect from them.
So far we've used the <code>*args</code> and <code>**kwargs</code> syntax for function definitions. Python allows us to use the same syntax when we call functions as well. Let's see how!
<h2 id="unpackingargumentswithargsandkwargs">Unpacking Arguments with *args and **kwargs</h2>
Let's consider a function <code>add3()</code>, that accepts 3 numbers and prints their sum. We can create it like this:
<pre><code class="hljs">def add3(num1, num2, num3):
 print(&quot;The grand total is&quot;, num1 + num2 + num3)
</code></pre>
If you had a list of numbers, you can use this function by specifying which list item is used as an argument:
<pre><code class="hljs">magic_nums = [32, 1, 7]

add3(magic_nums[0], magic_nums[1], magic_nums[2])
</code></pre>
If your run this code, you will see:
<pre><code class="hljs">The grand total is 40
</code></pre>
While this works, we can make this more succinct with <code>*args</code> syntax:
<pre><code class="hljs">add3(*magic_nums)
</code></pre>
The output is <code>The grand total is 40</code>, just like before.
When we use <code>*args</code> syntax in a function call, we are unpacking the variable. By unpacking, we mean that we are pulling out the individual values of the list. In this case, we pull out each element of the list and place them in the arguments, where position 0 corresponds to the first argument.
You can also similarly unpack a tuple:
<pre><code class="hljs">tuple_nums = (32, 1, 7)
add3(*tuple_nums) # The grand total is 40
</code></pre>
If you would like the unpack a dictionary, you must use the <code>**kwargs</code> syntax.
<pre><code class="hljs">dict_nums = {
 &#x27;num1&#x27;: 32,
 &#x27;num2&#x27;: 1,
 &#x27;num3&#x27;: 7,
}

add3(**dict_nums) # The grand total is 40
</code></pre>
In this case, Python matches the dictionary key with the argument name and sets its value.
And that's it! You can easier manage your function calls by unpacking values instead of specifying each argument that needs a value from an object.
<h2 id="conclusion">Conclusion</h2>
With Python, we can use the <code>*args</code> or <code>**kwargs</code> syntax to capture a variable number of arguments in our functions. Using <code>*args</code>, we can process an indefinite number of arguments in a function's position. With <code>**kwargs</code>, we can retrieve an indefinite number of arguments by their name.
While a function can only have one argument of variable length of each type, we can combine both types of functions in one argument. If we do, we must ensure that positional arguments come before named arguments and that fixed arguments come before those of variable length.
Python allows us to use the syntax for function calls as well. If we have a list or a tuple and use the <code>*args</code> syntax, it will unpack each value as positional arguments. If we have a dictionary and use <code>**kwargs</code> syntax, then it will match the names of the dictionary keys with the names of the function arguments.
Are you working on a function that can benefit from these type of arguments? Or maybe you can refactor a function and make it future proof? Let us know what you're working on!

Marcus Sanatan

Sajjad Heydari

With a variable number of arguments in a function, we offer a flexible API to other developers. In this article, we'll define and use functions with variable length arguments.

Variable-Length Arguments in Python with *args and **kwargs

<h2 id="introduction">Introduction</h2>
Testing is a fundamental part of the software development process. When creating web applications, we make calls to third-party APIs, databases, or other services in our environment. Therefore, our tests must validate those request are sent and responses handled correctly. However, we may not always be able to communicate with those external services when running tests.
On our local development computer, we may not have the company API keys or database credentials to run a test successfully. That's why we sometimes &quot;fake&quot; the HTTP or database responses with a stub, tricking our code into behaving like a real request was made.
In this article, we will begin by looking at what stubs are and why we'd want to use them. We will then leverage <a rel="nofollow" target="_blank" href="https://sinonjs.org">Sinon.js</a>, a popular JavaScript testing library, to create unit tests for JavaScript that stubs an HTTP request.
We'll then follow up on this with articles on Spies and Mocks:
<ul>
<li>Using Stubs for Testing in JavaScript with Sinon.js (you are here)</li>
<li><a target="_blank" href="/using-spies-for-testing-in-javascript-with-sinon">Using Spies for Testing in JavaScript with Sinon.js</a></li>
<li><a target="_blank" href="/using-mocks-for-testing-in-javascript-with-sinon-js/">Using Mocks for Testing in JavaScript with Sinon.js</a></li>
</ul>
<h2 id="whatarestubs">What are Stubs?</h2>
A test stub is a function or object that replaces the actual behavior of a module with a fixed response. The stub can only return the fixed response it was programmed to return.
A stub can be seen as an assumption for our test - if we assume that an external service returns this response, this is how the function will behave.
Imagine that you have a function that accepts an HTTP request and gets data from a GraphQL endpoint. If we cannot connect to the GraphQL endpoint in our tests, we would stub its response so that our code will run as if GraphQL was actually hit. Our function code would not know the difference between an actual GraphQL response vs our stubbed response.
Let's look at scenarios where stubbing is useful.
<h2 id="whyusestubs">Why Use Stubs?</h2>
While making requests to external services in a test, you can run into these problems:
<ul>
<li>Failing tests because of network connectivity errors instead of code errors</li>
<li>Long run times as network latency adds to the testing time</li>
<li>Mistakenly affecting production data with tests if a configuration error occurs</li>
</ul>
We can get around these problems by isolating our tests and stubbing these external service calls. There would be no network dependency, making our tests more predictable and less likely to fail. Without network latency, our tests are expected to be faster as well.
There are scenarios where external requests would not work. For example, it's common in CI/CD build processes to block external requests while running tests for security reasons. It's also likely that sometime we'll write code that depends on a service that's still in development and not in a state to be used.
In these cases, stubs are very useful as it allows us to test our code even when the service is unavailable.
Now that we know what stubs are and why they are useful, let's use Sinon.js to get practical experience with stubs.
<h2 id="usingsinonjstocreateastub">Using Sinon.js to Create a Stub</h2>
We'll use Sinon.js to stub a response from a JSON API that retrieves a list of photos in an album. Our tests will be created with the <a rel="nofollow" target="_blank" href="https://mochajs.org/">Mocha</a> and <a rel="nofollow" target="_blank" href="https://www.chaijs.com/">Chai</a> testing libraries. If you would like to learn more about testing with Mocha and Chai before continuing, you can follow <a target="_blank" href="/testing-node-js-code-with-mocha-and-chai/">our guide</a>.
<h3 id="setup">Setup</h3>
First, in your terminal create a new folder and move into it:
<pre><code class="hljs">$ mkdir PhotoAlbum
$ cd PhotoAlbum
</code></pre>
Initialize NPM so you can keep track of the packages you install:
<pre><code class="hljs">$ npm init -y
</code></pre>
Once that is complete, we can begin to install our dependencies. First, let's install the <a target="_blank" href="/the-node-js-request-module/">request</a> library, which will be used by our code to create an HTTP request to the API. In your terminal, enter:
<pre><code class="hljs">$ npm i request --save
</code></pre>
Now, let's install all the test libraries as dev dependencies. Test code is not used in production so we don't install testing libraries as a regular code dependencies with the <code>--save</code> option. Instead, we'll use the <code>--save-dev</code> option to tell NPM that these dependencies should only be used in our development/testing environment. Enter the command in your terminal:
<pre><code class="hljs">$ npm i mocha chai sinon --save-dev
</code></pre>
With all of our libraries imported, we'll create a new <code>index.js</code> file and add the code to make the API request there. You can use the terminal to create the <code>index.js</code> file:
<pre><code class="hljs">$ touch index.js
</code></pre>
In your text editor or IDE, write the code below:
<pre><code class="hljs">const request = require(&#x27;request&#x27;);

const getPhotosByAlbumId = (id) =&gt; {
 const requestUrl = `https://jsonplaceholder.typicode.com/albums/${id}/photos?_limit=3`;
 return new Promise((resolve, reject) =&gt; {
 request.get(requestUrl, (err, res, body) =&gt; {
 if (err) {
 return reject(err);
 }
 resolve(JSON.parse(body));
 });
 });
};

module.exports = getPhotosByAlbumId;
</code></pre>
This function makes a call to an API which returns a list of photos from an album whose ID is passed as a parameter to the function. We limit the response to only return three photos.
Now we'll write tests for our function to confirm that it works as expected. Our first test will not use stubs, but instead it'll make the actual request.
<h3 id="testingwithoutstubs">Testing Without Stubs</h3>
First, let's create a file to write our tests in. In the terminal or otherwise, make an <code>index.test.js</code> file in the current directory:
<pre><code class="hljs">$ touch index.test.js
</code></pre>
Our code will test that we get back three photos, and that each photo has the expected <code>id</code>, <code>title</code>, and <code>url</code> properties.
In the <code>index.test.js</code> file, add the following code:
<pre><code class="hljs">const expect = require(&#x27;chai&#x27;).expect;
const getPhotosByAlbumId = require(&#x27;./index&#x27;);

describe(&#x27;withoutStub: getPhotosByAlbumId&#x27;, () =&gt; {
 it(&#x27;should getPhotosByAlbumId&#x27;, (done) =&gt; {
 getPhotosByAlbumId(1).then((photos) =&gt; {
 expect(photos.length).to.equal(3);
 photos.forEach(photo =&gt; {
 expect(photo).to.have.property(&#x27;id&#x27;);
 expect(photo).to.have.property(&#x27;title&#x27;);
 expect(photo).to.have.property(&#x27;url&#x27;);
 });
 done();
 });
 });
});
</code></pre>
In this test, we first require the <code>expect()</code> function from Chai, and then require the <code>getPhotosByAlbumId()</code> function from our <code>index.js</code> file.
We use Mocha's <code>describe()</code> and <code>it()</code> functions so we can use the <code>mocha</code> command to run the code as a test.
Before running our test, we need to add a script to our package.json to run our tests. In the <code>package.json</code> file, add the following:
<pre><code class="hljs">&quot;scripts&quot;: {
 &quot;test&quot;: &quot;mocha index.test.js&quot;
}
</code></pre>
Now run your test with the following command:
<pre><code class="hljs">$ npm test
</code></pre>
You should see this output:
<pre><code class="hljs">$ mocha index.test.js

 withoutStub: getPhotosByAlbumId
 ✓ should getPhotosByAlbumId (311ms)

 1 passing (326ms)
</code></pre>
In this case, the test took 326ms to run, however that may vary depending on your Internet speed and location.
This test would not pass if you don't have an active internet connection since the HTTP request would fail. Although that does not mean that the function does not behave as expected. Let's use a stub so that we can test our function's behavior without a network dependency.
<h3 id="testingwithstubs">Testing with Stubs</h3>
Let's rewrite our function so that we stub the request to the API, returning a predefined list of photos:
<pre><code class="hljs">const expect = require(&#x27;chai&#x27;).expect;
const request = require(&#x27;request&#x27;);
const sinon = require(&#x27;sinon&#x27;);
const getPhotosByAlbumId = require(&#x27;./index&#x27;);

describe(&#x27;with Stub: getPhotosByAlbumId&#x27;, () =&gt; {
 before(() =&gt; {
 sinon.stub(request, &#x27;get&#x27;)
 .yields(null, null, JSON.stringify([
 {
 &quot;albumId&quot;: 1,
 &quot;id&quot;: 1,
 &quot;title&quot;: &quot;accusamus beatae ad facilis cum similique qui sunt&quot;,
 &quot;url&quot;: &quot;https://via.placeholder.com/600/92c952&quot;,
 &quot;thumbnailUrl&quot;: &quot;https://via.placeholder.com/150/92c952&quot;
 },
 {
 &quot;albumId&quot;: 1,
 &quot;id&quot;: 2,
 &quot;title&quot;: &quot;reprehenderit est deserunt velit ipsam&quot;,
 &quot;url&quot;: &quot;https://via.placeholder.com/600/771796&quot;,
 &quot;thumbnailUrl&quot;: &quot;https://via.placeholder.com/150/771796&quot;
 },
 {
 &quot;albumId&quot;: 1,
 &quot;id&quot;: 3,
 &quot;title&quot;: &quot;officia porro iure quia iusto qui ipsa ut modi&quot;,
 &quot;url&quot;: &quot;https://via.placeholder.com/600/24f355&quot;,
 &quot;thumbnailUrl&quot;: &quot;https://via.placeholder.com/150/24f355&quot;
 }
 ]));
 });

 after(() =&gt; {
 request.get.restore();
 });

 it(&#x27;should getPhotosByAlbumId&#x27;, (done) =&gt; {
 getPhotosByAlbumId(1).then((photos) =&gt; {
 expect(photos.length).to.equal(3);
 photos.forEach(photo =&gt; {
 expect(photo).to.have.property(&#x27;id&#x27;);
 expect(photo).to.have.property(&#x27;title&#x27;);
 expect(photo).to.have.property(&#x27;url&#x27;);
 });
 done();
 });
 });
});
</code></pre>
Before the test is run, we tell Sinon.js to stub the <code>get()</code> function of the <code>request</code> object that's used in <code>getPhotosByAlbumId ()</code>.
The arguments passed to the <code>yields()</code> function of the stub are the arguments that will be passed to the callback of the get request. We pass <code>null</code> for the <code>err</code> and <code>res</code> parameters, and an array of fake photo album data for the <code>body</code> parameter.
<blockquote>
Note: The <code>after()</code> function is run after a test is complete. In this case we restore the behavior of the <code>request</code> library's <code>get()</code> function. Best practices encourages our test states to be independent for each test. By restoring the function, the changes we made for this test would not affect how it is used in other tests.
</blockquote>
Like before, we run this test with <code>npm test</code>. You should see the following output:
<pre><code class="hljs">$ mocha index.test.js

 with Stub: getPhotosByAlbumId
 ✓ should getPhotosByAlbumId

 1 passing (37ms)
</code></pre>
Great! Now without an internet connection, we are still sure that our function works well with the expected data. The test ran quicker as well! Without a network request, we simply need to get the data from memory.
<h2 id="conclusion">Conclusion</h2>
A stub is a replacement for a function that returns fixed data when called. We usually stub requests to external systems to make test runs more predictable and eliminate the need for network connections.
Sinon.js can be used alongside other testing frameworks to stub functions. In this article, we stubbed an HTTP GET request so our test can run without an internet connection. It also reduced the test time as well.
If you would like to see the code for this tutorial, you can find it <a rel="nofollow" target="_blank" href="https://github.com/allan690/SinonStubs-1">here</a>.
In our next article, we continue on with Sinon.js and cover <a target="_blank" href="/using-spies-for-testing-in-javascript-with-sinon/">how to use spies for testing JavaScript</a>.

Allan Mogusu

We might not have access to the services we use while testing software at work. To ensure proper testing in all environments, we'll use Sinon.js to create unit tests that stub HTTP requests.

Using Stubs for Testing in JavaScript with Sinon.js

<h2 id="introduction">Introduction</h2>
It's not an overstatement to say that information and data runs the world. Almost any application, from social media and e-commerce websites to simple time tracker and drawing apps, relies on the very basic and fundamental task of storing and retrieving data in order to run as expected.
Amazon's <a rel="nofollow" target="_blank" href="https://aws.amazon.com/rds/">Relational Database Service</a> (RDS) provides an easy way to get a database set up in the cloud using any of a wide range of relational database technologies. In this article, we're going to set up a database on RDS, and store data on it with a Node application.
<h2 id="prerequisites">Prerequisites</h2>
<h3 id="amazonwebservices">Amazon Web Services</h3>
<a rel="nofollow" target="_blank" href="https://aws.amazon.com/">Amazon Web Services</a> (AWS) provides a collection of tools for building applications in the cloud. As RDS is an AWS service, we'll need to get set up with an AWS account.
AWS has a free tier for a lot of awesome stuff, and RDS is no exception - you get to use 750 hours (31 days) a month of <code>db.t2.micro</code> database usage for free for 12 months.
<h3 id="postman">Postman</h3>
<a target="_blank" href="/getting-started-with-postman/">Postman</a> is a useful tool for creating and sending requests. We'll be using this in the Node half of the article in order to test the code we've written.
Postman is optional, and really, you can use any tool to test out the endpoint, even your Internet browser.
<h2 id="settingupanrdsinstance">Setting Up an RDS Instance</h2>
First, we're going to create our RDS instance cluster. Head to AWS and <a rel="nofollow" target="_blank" href="https://signin.aws.amazon.com/">log in</a>.
Once you're logged in, click on 'Services' in the top left, and then search for 'RDS'. You'll be presented with a page that looks something like this:
<img src="https://stackabuse.s3.amazonaws.com/media/working-with-aws-rds-with-node-and-express-1.png" alt="setting_up_rds_instance">
On the menu on the left, select 'Databases'. This would normally display a list of RDS instance clusters that we've created, but we don't have any yet.
To create one, click the orange 'Create database' button. You should be presented with a page that looks like:
<img src="https://stackabuse.s3.amazonaws.com/media/working-with-aws-rds-with-node-and-express-2.png" alt="create_rds_database">
AWS has recently introduced an 'Easy create' method for creating new RDS instances, so let's use that.
Under 'Engine type' we'll use 'Amazon Aurora', which is Amazon's own database engine optimized for RDS. For the edition, we'll leave this set to 'Amazon Aurora with MySQL 5.6 compatibility'.
Under 'DB instance size' select the 'Dev/Test' option - this is a less powerful (and cheaper) instance type, but is still more than enough for what we need it for.
The 'DB cluster identifier' is the name of the database cluster that we're creating. Let's call ours <code>my-node-database</code> for now.
For the master username, leave it as <code>admin</code>. Finally, we have the option to have a master password generated automatically. For the ease of this tutorial, let's set our own.
Make sure it's secure as this is the master username and password!
Finally, scroll down and click 'Create database'. It takes a few minutes to fully provision an RDS instance:
<img src="https://stackabuse.s3.amazonaws.com/media/working-with-aws-rds-with-node-and-express-3.png" alt="create_rds_database">
Before getting started on our Node application, we need to make sure we can connect to the instance. Select the instance you just created (it'll be the option that ends in <code>instance-1</code>) and take a note of the value under 'Endpoint'.
On the right-hand side, under 'VPC security groups', click the link - this will take you to the security group that's been set up for the database. Security groups are essentially firewall rules as to who is and isn't allowed to make connections to a resource.
Currently, this one is set to only allow connections from resources that have the same security group.
Selecting the 'Actions' drop down at the top, navigate to 'Edit inbound rules'. In this dialog, click 'Add rule'. For the new rule, under 'Type', select 'All traffic'. Under 'Source', select 'Anywhere'.
You should end up with something that looks like this:
<img src="https://stackabuse.s3.amazonaws.com/media/working-with-aws-rds-with-node-and-express-4.png" alt="edit_inbound_rules">
Head back to RDS, and 'Modify' the instance. Here, at the 'Network &amp; Security' section, under 'Public accessibility', we want to select 'Yes' - this allows us to connect to the database from our machines - otherwise we would need to <a target="_blank" href="/deploying-node-js-apps-to-aws-ec2-with-docker/">put our application on an EC2 instance</a>, which isn't the focus of this article.
Your RDS instance should now be ready to go! Let's write some code to interact with it.
<h2 id="nodeapplication">Node Application</h2>
In order to interact with our application, we're going to create a very simple API that allows us to store user profiles via Express.js. Before we do that, we need to create a table inside our RDS instance to store data in.
Let's create a folder, move into it and initialize a blank Node.js application with the default configuration:
<pre><code class="hljs">$ mkdir node-rds
$ cd node-rds
$ npm init -y
</code></pre>
Then, let's install the required dependencies:
<pre><code class="hljs">$ npm install express --save
$ npm install mysql --save
</code></pre>
And finally, we want to create two JavaScript files - one of them will be our Express app, the other will be a single-use script to create a table in our database:
<pre><code class="hljs">$ touch index.js
$ touch dbseed.js
</code></pre>
<h3 id="tablecreationscript">Table Creation Script</h3>
Let's start off with the <code>dbseed.js</code> file:
<pre><code class="hljs">const mysql = require(&#x27;mysql&#x27;);

const con = mysql.createConnection({
 host: &quot;&lt;DB_ENDPOINT&gt;&quot;,
 user: &quot;admin&quot;,
 password: &quot;&lt;DB_PASSWORD&gt;&quot;
});

con.connect(function(err) {
 if (err) throw err;
 console.log(&quot;Connected!&quot;);
 con.end();
});
</code></pre>
Make sure to swap out <code>&lt;DB_ENDPOINT&gt;</code> for the endpoint that we noted down earlier, and fill in the password. What this piece of code will do is attempt to connect to the database - if it succeeds, it'll run an anonymous function that logs 'Connected!', and then immediately close the connection.
We can quickly check to see if it's properly set up by running:
<pre><code class="hljs">$ node dbseed.js
</code></pre>
The app should return 'Connected!'. If it doesn't, there's likely an issue with the security settings - go back to the RDS set-up and make sure you've done everything correctly.
Now that we know that we can definitely connect to our database, we need to create a table. Let's modify our anonymous function:
<pre><code class="hljs">con.connect(function(err) {
 if (err) throw err;

 con.query(&#x27;CREATE DATABASE IF NOT EXISTS main;&#x27;);
 con.query(&#x27;USE main;&#x27;);
 con.query(&#x27;CREATE TABLE IF NOT EXISTS users(id int NOT NULL AUTO_INCREMENT, username varchar(30), email varchar(255), age int, PRIMARY KEY(id));&#x27;, function(error, result, fields) {
 console.log(result);
 });
 con.end();
});
</code></pre>
The expected output should look something like:
<pre><code class="hljs">OkPacket {
 fieldCount: 0,
 affectedRows: 0,
 insertId: 0,
 serverStatus: 2,
 warningCount: 0,
 message: &#x27;&#x27;,
 protocol41: true,
 changedRows: 0
}
</code></pre>
Now that we've got a table to work with, let's set up the Express app to insert and retrieve data from our database.
<h3 id="insertuserendpoint">Insert User Endpoint</h3>
Let's write a <code>POST</code> request for user creation in our <code>index.js</code> file:
<pre><code class="hljs">app.post(&#x27;/users&#x27;, (req, res) =&gt; {
 if (req.query.username &amp;&amp; req.query.email &amp;&amp; req.query.age) {
 console.log(&#x27;Request received&#x27;);
 con.connect(function(err) {
 con.query(`INSERT INTO main.users (username, email, age) VALUES (&#x27;${req.query.username}&#x27;, &#x27;${req.query.email}&#x27;, &#x27;${req.query.age}&#x27;)`, function(err, result, fields) {
 if (err) res.send(err);
 if (result) res.send({username: req.query.username, email: req.query.email, age: req.query.age});
 if (fields) console.log(fields);
 });
 });
 } else {
 console.log(&#x27;Missing a parameter&#x27;);
 }
});
</code></pre>
What this code does is pretty straightforward - it packs the information from the <code>POST</code> request and inserts it into a query. This query will create a user in the RDS database and log the results.
Let's check if it works:
<pre><code class="hljs">$ node index.js
</code></pre>
In Postman we want to create a <code>POST</code> request to our server. Let's input the required parameters and send the request:
<img src="https://stackabuse.s3.amazonaws.com/media/working-with-aws-rds-with-node-and-express-5.png" alt="postman_request_to_rds">
We should be getting the same data back, which means that it's working correctly and our endpoint has inserted a user.
<h3 id="getusersendpoint">Get Users Endpoint</h3>
Let's devise a simple <code>GET</code> endpoint for a more user-friendly way to check for results. Below the <code>POST</code> request handler, let's make another handler:
<pre><code class="hljs">app.get(&#x27;/users&#x27;, (req, res) =&gt; {
 con.connect(function(err) {
 con.query(`SELECT * FROM main.users`, function(err, result, fields) {
 if (err) res.send(err);
 if (result) res.send(result);
 });
 });
});
</code></pre>
In your browser, navigate to <code>localhost:3000/users</code> and you should be presented with all the inserted users.
<h2 id="whatnext">What Next?</h2>
<h3 id="secureyourdatabase">Secure your Database</h3>
Earlier, we made our RDS instance publicly accessible, and with a completely open security group. You could <a target="_blank" href="/deploying-node-js-apps-to-aws-ec2-with-docker/">get set up on EC2</a> and begin to tighten the security on your instance by removing public access and locking down your security group.
You should also take a look at the codebase as well - it's functional, but might be vulnerable to attacks such as SQL injection - it's worth spending time to make sure that users can't perform actions on your database that you don't intend.
<h3 id="experimentwithreadwrite">Experiment with Read/Write</h3>
If you dive a bit deeper into RDS, you can set up instances specifically to read or write from - this can help with securing your instance, but also if you're dealing with lots of database operations, this can help optimize your database's performance.
<h3 id="trydifferentconfigurations">Try Different Configurations</h3>
We used AWS' 'Easy create' to make our database - it's worth going back and trying out the various configurations that you could set RDS up with to meet your particular needs.
<h3 id="terminateyourrdsinstance">Terminate your RDS Instance!</h3>
If you're not planning on continuing to use your RDS instance, make sure to terminate it! Otherwise you'll rack up a hefty bill within a month.
<h2 id="conclusion">Conclusion</h2>
You've created an RDS instance and populated it with data through a Node/Express endpoint. This is a great springboard to leap into more complex web applications that store and serve data for its users, and with data rising meteorically as a valuable commodity this is a good time to think on what sort of data you want to operate with.
To end, remember that any data you store is your duty to protect - always make sure you understand how to build a secure application before you start putting people's personal details in it!!

Josh Simpson

Amazon's RDS provides an easy way to get a database set up with a wide range of relational database technologies. In this article, we'll be using AWS RDS with Node.js.

Using AWS RDS with Node.js and Express.js

Janith Kasun

JWT are very popular for handling HTTP authentication and authorization, which we'll be doing through Node.js and Express in this article.

Authentication and Authorization with JWTs in Express.js

<h2 id="introduction">Introduction</h2>
<a rel="nofollow" target="_blank" href="https://aws.amazon.com">Amazon Web Services</a> (AWS) offers a wide range of on-demand and reliable computing services. It does this by hiding the infrastructure management and its complexities, thus simplifying the process of provisioning and running cloud infrastructure.
AWS allows IT companies and developers to focus on creating better solutions for their products with scalable and on demand web services which make it easier to increase or decrease any resource as the application evolves over time.
One of these products is the Simple Storage Service, or S3, which allows you to cheaply store files at scale.
<h3 id="s3bucket">S3 Bucket</h3>
Amazon's <a rel="nofollow" target="_blank" href="https://aws.amazon.com/s3">Simple Storage Service</a> allows users to manage their static data reliably and efficiently by storing them on Amazon's servers. The stored data can be accessed at any time from anywhere over the Internet.
Data stored in an S3 bucket is accessible through Amazon Management Console, which is a UI interface, as well as the <a rel="nofollow" target="_blank" href="https://aws.amazon.com/cli/">AWS Command Line Interface</a> and <a rel="nofollow" target="_blank" href="https://docs.aws.amazon.com/AmazonS3/latest/API/Welcome.html">S3 REST API</a> for developers.
<h3 id="springcloudaws">Spring Cloud AWS</h3>
AWS services can be integrated into Java applications using <a rel="nofollow" target="_blank" href="https://spring.io">Spring</a>, which is a well known and the most commonly used Java web framework. <a rel="nofollow" target="_blank" href="https://spring.io/projects/spring-cloud-aws">Spring Cloud for Amazon Web Services</a> allows developers to access AWS services with a smaller code footprint and simple integration.
<h2 id="springamazons3client">Spring Amazon S3 Client</h2>
The S3 Bucket in which our data is stored is accessible through Spring's Amazon S3 client, offering general operations for managing data on the server. In this section we'll show how to include this client library in your project, and then later we'll take a look at some of the common S3 operations available via the client.
<h3 id="mavendependencies">Maven Dependencies</h3>
The first step to integrating AWS into a Spring project is, of course, to import the required dependencies. In this case, we'll be using <code>speing-cloud-starter-aws</code>, which is contains the <code>spring-cloud-aws-context</code> and <code>spring-cloud-aws-autoconfigure</code> dependencies:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.springframework.cloud&lt;/groupId&gt;
 &lt;artifactId&gt;spring-cloud-starter-aws&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
<h3 id="springcloudawsconfiguration">Spring Cloud AWS Configuration</h3>
Since we're using Spring Boot, naturally, most of the configuration is done by the framework itself. Though, AWS-related configurations should be specified in the <code>application.yaml</code> file:
<pre><code class="hljs">cloud:
 aws:
 region.static: &quot;[S3 Bucket region]&quot;
 credentials:
 accessKey: &quot;xxxxxxx&quot;
 secretKey: &quot;xxxxxxx&quot;
</code></pre>
Please keep in mind that the names and structures of the properties are strictly formatted and will be used by Spring Boot to set up a valid connection with the AWS Services.
The &quot;overseeing&quot; object for the management of requests to the S3 bucket, using Amazon's S3 client, is an instance of the <code>AmazonS3</code> class:
<pre><code class="hljs">@Autowired
private AmazonS3 amazonS3Client;
</code></pre>
We'll be autowiring it as a standard Spring bean and the properties from our <code>.yaml</code> file will be used to strap it up and prep it for work.
<h2 id="uploadingfilestos3">Uploading Files to S3</h2>
Any type of file can be uploaded to an S3 Bucket, although one of the most common use-cases is for image storage. Keeping the files/images stored in the cloud makes it easier to access them and keep them safe in a stable and fast service that's able to scale up the resources required to serve your files.
<h3 id="directfilemultipartfileupload">Direct File/Multipart File Upload</h3>
Once Amazon's S3 Client is functional, you can upload a new file simply by calling the <code>putObject()</code> method:
<pre><code class="hljs">amazonS3Client.putObject(new PutObjectRequest(&quot;bucketName&quot;, &quot;fileKey&quot;, file));
</code></pre>
Where <code>bucketName</code> is the S3 bucket name to which you want to upload the file. <code>fileKey</code> is a String value which will uniquely identify the file being uploaded and <code>file</code> is a valid <code>File</code> object.
If you have a multi-part file coming into your application or microservice through an exposed REST endpoint, it can also be uploaded. This requires little additional code and we simply convert the <code>MultipartFile</code> to a <code>File</code>:
<pre><code class="hljs">File file = new File(&quot;FileName&quot;);
try {
 FileOutputStream fileOutputStream = new FileOutputStream(file)
 fileOutputStream.write(multipartFile.getBytes());
} catch (IOException e) {
 /* Handle Exception */
}
</code></pre>
What we've done is simply convert a multipart to a regular Java <code>File</code> object using a <code>FileOutputStream</code>. Once converted, it can be uploaded to S3 bucket using the same <code>putObject()</code> method from before.
<h3 id="uploadingfilesasmetadata">Uploading Files as Metadata</h3>
When handling requests and data received through API end-points, keeping a copy of the data on our own server before uploading it to our S3 bucket is cost-ineffective and just increases our application's size unnecessarily since the main resource for file storage will be the S3 Bucket.
To avoid needing to keep a copy, we can use the <code>PutObjectRequest</code> from Amazon's API to upload the file to the bucket by sending it via an <code>InputStream</code> and providing file details in the form of metadata:
<pre><code class="hljs">ObjectMetadata objectMetaData = new ObjectMetadata();
objectMetaData.setContentType(multipartFile.getContentType());
objectMetaData.setContentLength(multipartFile.getSize());

try {
 PutObjectRequest putObjectRequest = new PutObjectRequest(&quot;bucketName&quot;, &quot;fileName&quot;, multipartFile.getInputStream(), objectMetaData);
 amazonS3Client.putObject(putObjectRequest);
} catch (IOException e) {
 /* Handle Exception */
}
</code></pre>
The size and the content type of the file are specified via the <code>ObjectMetaData</code> object. The file's input stream is added to the <code>PutObjectRequest</code> along with S3 bucket name to which we're uploading as well as the file name to associate with.
Once the <code>PutObjectRequest</code> object is created, it can be sent to the S3 Bucket using the <code>putObject()</code> method, just like before.
<h3 id="uploadingfileswithpublicview">Uploading Files with Public View</h3>
Sometimes we may wish for the uploaded files to be publicly available. A reader shouldn't need authorization to view the images on a blog post, for example. So far, we've uploaded files that require our authorization to view.
AWS' S3 provides us with options to set the access level on each uploaded file, during their upload.
To change the access level and give public access, let's slightly modify the data upload request:
<pre><code class="hljs">new PutObjectRequest(&quot;bucketName&quot;, &quot;fileName&quot;, multipartFile.getInputStream(), objectMetaData)
 .withCannedAcl(CannedAccessControlList.PublicRead)
</code></pre>
Adding the <code>CannedAccessControlList.PublicRead</code> property to the <code>PutObjectRequest</code> gives read-only public access for the file being uploaded - allowing anyone with the correct URL to access/view the file.
Once the <code>PutObjectRequest</code> object is created, it can then be uploaded to an S3 bucket using the same <code>putObject()</code> method as before.
<h2 id="downloadingfilesfroms3">Downloading Files from S3</h2>
Once uploaded, you can easily download files from your bucket using the <code>getObject()</code> method via the <code>AmazonS3</code> class's instance.
The returned object is packed in an <code>S3Object</code> instance, which can then be streamed into a regular <code>Object</code>:
<pre><code class="hljs">S3Object s3Object = amazonS3Client.getObject(&quot;bucketName&quot;, &quot;fileName&quot;);
S3ObjectInputStream inputStream = s3Object.getObjectContent();
byte[] bytes = StreamUtils.copyToByteArray(inputStream);
File file = new File(&quot;File_Name&quot;);
try {
 FileOutputStream fileOutputStream = new FileOutputStream(file)
 fileOutputStream.write(bytes);
} catch (IOException e) {
 /* Handle Exception */
}
</code></pre>
If the request to download the file is made through a REST endpoint, we can return the file data to the calling entity without creating a <code>File</code> by using Spring's <code>ResponseEntity</code>:
<pre><code class="hljs">S3Object s3Object = amazonS3Client.getObject(&quot;bucketName&quot;, &quot;fileName&quot;);
S3ObjectInputStream inputStream = s3Object.getObjectContent();
byte[] bytes = StreamUtils.copyToByteArray(inputStream);
String contentType = s3Object.getObjectMetadata().getContentType();
return ResponseEntity.ok().contentType(contentType).body(bytes);
</code></pre>
This way we don't have to create a file on our server when downloading from the S3 bucket, the file is simply returned to the caller in the API response.
<h2 id="deletefilefroms3bucket">Delete file from S3 Bucket</h2>
Deleting files from an S3 bucket is the simplest task and all you need to know is the absolute path to the file.
Calling the <code>deleteObject()</code> method with the bucket name and the complete file name deletes the file from the server, if it exists:
<pre><code class="hljs">amazonS3Client.deleteObject(&quot;bucketName&quot;, &quot;fileName&quot;);
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Amazon's S3 provides a convenient way to store file data in the cloud and gives a reliable medium to access data whenever needed.
With Spring Cloud AWS, developers can easily access Amazon's S3 services from their application to perform necessary operations.
For Spring Boot applications all the connection management to the Amazon server is handled by Spring itself, making things simpler than using the regular <code>aws-java-sdk</code> with plain Java applications.
As evident from the code snippets above accessing S3 bucket using Spring Cloud AWS is quite simple and the code footprint is very small as well.
The source code for the project is available on <a rel="nofollow" target="_blank" href="https://github.com/TaimoorChoudhary/spring-boot-s3-bucket">GitHub</a>.

Taimoor Choudhary

AWS S3 allows users to manage their static data reliably and efficiently. Through Spring Cloud's module, we can easily access and use S3 from our Spring projects.

Spring Cloud: AWS S3

<h2 id="introduction">Introduction</h2>
Python allows you to convert strings, integers, and floats interchangeably in a few different ways. The simplest way to do this is using the basic <code>str()</code>, <code>int()</code>, and <code>float()</code> functions. On top of this, there are a couple of other ways as well.
Before we get in to converting strings to numbers, and converting numbers to strings, let's first see a bit about how strings and numbers are represented in Python.
Note: For simplicity of running and showing these examples we'll be using the Python interpreter.
<h2 id="strings">Strings</h2>
String literals in Python are declared by surrounding a character with double (&quot;) or single quotation (') marks. Strings in Python are really just arrays with a Unicode for each character as an element in the array, allowing you to use indices to access a single character from the string.
For example, we can access individual characters of these strings by specifying an index:
<pre><code class="hljs">&gt;&gt;&gt; stringFirst = &quot;Hello World!&quot;
&gt;&gt;&gt; stringSecond = &#x27;Again!&#x27;
&gt;&gt;&gt; stringFirst[3]
&#x27;l&#x27;
&gt;&gt;&gt; stringSecond[3]
&#x27;i&#x27;
</code></pre>
<h2 id="numerics">Numerics</h2>
A numeric in Python can be an <code>integer</code>, a <code>float</code>, or a <code>complex</code>.
Integers can be a positive or negative whole number. Since Python 3, integers are unbounded and can practically hold any number. Before Python 3, the top boundary was 231-1 for 32-bit runtimes and 263-1 for 64-bit runtimes.
Floats have unlimited length as well, but a floating-point number must contain a decimal point.
Complex numerics must have an imaginary part, which is denoted using <code>j</code>:
<pre><code class="hljs">&gt;&gt;&gt; integerFirst = 23
&gt;&gt;&gt; floatFirst = 23.23
&gt;&gt;&gt; complextFirst = 1 + 23j
</code></pre>
<h2 id="convertingstringstonumerics">Converting Strings to Numerics</h2>
<h3 id="usingtheintfunction">Using the int() Function</h3>
If you want to convert a string to an integer, the simplest way would be to use <code>int()</code> function. Just pass the string as an argument:
<pre><code class="hljs">&gt;&gt;&gt; x = &quot;23&quot;
&gt;&gt;&gt; y = &quot;20&quot;
&gt;&gt;&gt; z = int(x) - int(y)
&gt;&gt;&gt; z
3
</code></pre>
This works as expected when you're passing a string-representation of an integer to <code>int()</code>, but you'll run in to trouble if the string you pass doesn't contain an integer value. If there are any non-numeric characters in your string then <code>int()</code> will raise an exception:
<pre><code class="hljs">&gt;&gt;&gt; x = &quot;23a&quot;
&gt;&gt;&gt; z = int(x)
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
ValueError: invalid literal for int() with base 10: &#x27;23a&#x27;
</code></pre>
This same exception will even be raised if a valid float string is passed:
<pre><code class="hljs">&gt;&gt;&gt; x = &quot;23.4&quot;
&gt;&gt;&gt; z = int(x)
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
ValueError: invalid literal for int() with base 10: &#x27;23.4&#x27;
</code></pre>
The <code>int()</code> function does have another useful feature than just converting strings to integers, it also allows you to convert numbers from any base to a base 10 integer. For example, we can convert the following binary string to a base 10 integer using the <code>base</code> parameter:
<pre><code class="hljs">&gt;&gt;&gt; int(&#x27;1101100&#x27;, base=2)
108
</code></pre>
The same can be done for any other base, like hexadecimal (base 16):
<pre><code class="hljs">&gt;&gt;&gt; int(&#x27;6C&#x27;, base=16)
108
</code></pre>
<h3 id="usingthefloatfunction">Using the float() Function</h3>
Converting string literals to floats is done via the <code>float()</code> function:
<pre><code class="hljs">&gt;&gt;&gt; x = &quot;23.23&quot;
&gt;&gt;&gt; y = &quot;23.00&quot;
&gt;&gt;&gt; z = float(x) - float(y)
&gt;&gt;&gt; z
0.23000000000000043
</code></pre>
Notice that the resulting value is not entirely accurate, as it should just be <code>0.23</code>. This has to do with <a rel="nofollow" target="_blank" href="https://0.30000000000000004.com/">floating point math</a> issues rather than the conversion from string to number.
The <code>float()</code> function offers a bit more flexibility than the <code>int()</code> function since it can parse and convert both floats and integers:
<pre><code class="hljs">&gt;&gt;&gt; x = &quot;23&quot;
&gt;&gt;&gt; y = &quot;20&quot;
&gt;&gt;&gt; z = float(x) - float(y)
&gt;&gt;&gt; z
3.0
</code></pre>
Unlike <code>int()</code>, <code>float()</code> doesn't raise an exception when it receives a non-float numeric value.
However, it will raise an exception if a non-numeric value is passed to it:
<pre><code class="hljs">&gt;&gt;&gt; x = &quot;23a&quot;
&gt;&gt;&gt; z = float(x)
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
ValueError: could not convert string to float: &#x27;23a&#x27;
</code></pre>
While <code>float()</code> does not have the ability to convert non-base 10 numbers like <code>int()</code> does, it does have the ability to convert numbers represented in scientific notation (aka e-notation):
<pre><code class="hljs">&gt;&gt;&gt; float(&#x27;23e-5&#x27;)
0.00023
&gt;&gt;&gt; float(&#x27;23e2&#x27;)
2300.0
</code></pre>
<h3 id="usingthecomplexfunction">Using the complex() Function</h3>
Converting string literals to complex numerics is done via the <code>complex()</code> function. To do so, the string must follow specific formatting. Particularly, it must be formatted without white spaces around the <code>+</code> or <code>-</code> operators:
<pre><code class="hljs">&gt;&gt;&gt; x = &quot;5+3j&quot;
&gt;&gt;&gt; y = &quot;3+1j&quot;
&gt;&gt;&gt; z = complex(x) + complex(y)
&gt;&gt;&gt; z
(8+4j)
</code></pre>
Having any extra spaces between the <code>+</code> or <code>-</code> operators will result in a raised exception:
<pre><code class="hljs">&gt;&gt;&gt; z = complex(&quot;5+ 3j&quot;)
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
ValueError: complex() arg is a malformed string
</code></pre>
Like the <code>float()</code> function, <code>complex()</code> is also more relaxed in the types of numbers it allows. For example, the imaginary part of the number can be completely omitted, and both integers and floats can be parsed as well:
<pre><code class="hljs">&gt;&gt;&gt; complex(&quot;1&quot;)
(1+0j)
&gt;&gt;&gt; complex(&quot;1.2&quot;)
(1.2+0j)
</code></pre>
As you can see, however, this should not be used as a more flexible replacement for <code>int</code>/<code>float</code> since it automatically adds the imaginary part of the number to the stringified version.
<h2 id="convertingnumericstostrings">Converting Numerics to Strings</h2>
<h3 id="usingthestrfunction">Using the str() Function</h3>
The <code>str()</code> function can be used to change any numeric type to a string.
The function <code>str()</code> is available from Python 3.0+ since the strings in Python 3.0+ are Unicode by default. However, this is not true for Python versions below 3.0 - in which to achieve the same goal, the <code>unicode()</code> function is used:
<pre><code class="hljs">&gt;&gt;&gt; str(23) # Integer to String
&#x27;23&#x27;
&gt;&gt;&gt; str(23.3) # Float to String
&#x27;23.3&#x27;
&gt;&gt;&gt; str(5+4j) # Complex to String
&#x27;(5+4j)&#x27;
</code></pre>
The nice thing about <code>str()</code> is that it can handle converting any type of number to a string, so you don't need to worry about choosing the correct method based on what type of number you're converting.
<h3 id="usingtheformatfunction">Using the format() Function</h3>
Another way of converting numerics to strings is using the <code>format()</code> function, which allows you to set placeholders within a string and then convert another data type to a string and fill the placeholders.
To use the function, simply write a string followed by <code>.format()</code> and pass the arguments for the placeholders.
Here's an example:
<pre><code class="hljs">&gt;&gt;&gt; &quot;My age is {}&quot;.format(21)
&#x27;My age is 21&#x27;
</code></pre>
The arguments in the <code>.format()</code> function can also be referred to individually, using their positions or variable names:
<pre><code class="hljs">&gt;&gt;&gt; &quot;You get {product} when you multiply {1} with {0}&quot;.format(5.5, 3, product=16.5)
&#x27;You get 16.5 when you multiply 3 with 5.5&#x27;
</code></pre>
Note that underneath the hood, the <code>.format()</code> function simply uses <code>str()</code> to convert the arguments to strings. So essentially this is a similar way of converting numbers to strings as the previous section, but <code>.format()</code> acts as a convenience function for formatting a string.
<h2 id="conclusion">Conclusion</h2>
Python allows you to convert strings, integers, and floats interchangeably in a few different ways. The simplest way to do this is using the basic <code>str()</code>, <code>int()</code>, and <code>float()</code> functions. On top of this, there are a couple of other ways as well such as the <code>format()</code> function. Just keep in mind that the <code>int()</code>, <code>float()</code>, and <code>complex()</code> functions have their limitations and may raise exceptions if the input string isn't formatted exactly as they expect.

Guest Contributor

Converting data types is a common and trivial task in any developer's workflow. Python provides several ways to go about this task.

Convert Strings to Numbers and Numbers to Strings in Python

Robley Gori

AWS EC2 offers provisioning and hosting applications on the cloud with automatic scaling. We'll be deploying a Django app to EC2 with Docker.

Deploying Django Applications to AWS EC2 with Docker

<h2 id="introduction">Introduction</h2>
The sweetest <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Syntactic_sugar">syntactic sugar</a> added to Java up until now are definitely <a target="_blank" href="/lambda-expressions-in-java">Lambda Expressions</a>.
Java is a verbose language and that can get in the way of productivity and readability. Reducing boilerplate and repetitive code has always been a popular task with Java developers, and clean, readable, concise code is generally sought after.
Lambda Expressions removed the need to type cumbersome boilerplate code when it comes to some common tasks by allowing developers to call them without them belonging to a class and passing them as if they were objects.
These expressions have seen major usage with the <a target="_blank" href="/introduction-to-java-8-streams/">Java Streams API</a>, and Spring's <a rel="nofollow" target="_blank" href="https://docs.spring.io/spring/docs/current/spring-framework-reference/web-reactive.html">WebFlux</a> framework for creating reactive, dynamic applications.
Another, really useful feature added to Java 8, are method references, which make Lambda Expressions just that much more concise and simple, by invoking (referencing) the methods using a method name when the Lambda Expression would've been used simply to call a method.
<h2 id="methodreferences">Method References</h2>
Method references are essentially shortened Lambda Expressions, used for invoking methods.
They consist of two parts:
<pre><code class="hljs">Class::method;
</code></pre>
And a common example would be printing out the results of say, subscribing to a publisher service or a Java Stream:
<pre><code class="hljs">someCodeChain.subscribe(System.out::println);
</code></pre>
Let's go over an example of imperative code, which we'll then turn to functional code via Lambda Expressions and then finally shorten via Method References.
We'll be making a simple class:
<pre><code class="hljs">public class Employee {
 private int id;
 private String name;
 private int wage;
 private String position;

 // Constructor, getters and setters

 @Override
 public String toString() {
 return &quot;Name: &quot; + name + &quot;, Wage: &quot; + wage + &quot;, Position: &quot; + position;
 }

 public int compareTo(Employee employee) {
 if (this.wage &lt;= employee.wage) {
 return 1;
 } else {
 return -1;
 }
 }
}
</code></pre>
If we formed this class into a collection, such as an <code>ArrayList</code>, we couldn't sort it using the utility method <code>.sort()</code> since it doesn't implement the <code>Comparable</code> interface.
What we can do is define a <code>new Comparator</code> for these objects while calling the <code>.sort()</code> method:
<pre><code class="hljs">Employee emp1 = new Employee(1, &quot;David&quot;, 1200, &quot;Developer&quot;);
Employee emp2 = new Employee(2, &quot;Tim&quot;, 1500, &quot;Developer&quot;);
Employee emp3 = new Employee(3, &quot;Martha&quot;, 1300, &quot;Developer&quot;);

ArrayList&lt;Employee&gt; employeeList = new ArrayList&lt;&gt;();
employeeList.add(emp1);
employeeList.add(emp2);
employeeList.add(emp3);

Collections.sort(employeeList, new Comparator&lt;Employee&gt;() {
 public int compare(Employee emp1, Employee emp2) {
 return emp1.compareTo(emp2);
 }
});

System.out.println(employeeList);
</code></pre>
Running this code will yield:
<pre><code class="hljs">[Name: Tim, Wage: 1500, Position: Developer, Name: Martha, Wage: 1300, Position: Developer, Name: David, Wage: 1200, Position: Developer]
</code></pre>
Here, the anonymous class (<code>Comparator</code>) is defining the comparison criteria. We can make it a lot simpler and shorter by using a Lambda Expression:
<pre><code class="hljs">Collections.sort(employeeList, (e1, e2) -&gt; e1.compareTo(e2));
</code></pre>
Running this piece of code will yield:
<pre><code class="hljs">[Name: Tim, Wage: 1500, Position: Developer, Name: Martha, Wage: 1300, Position: Developer, Name: David, Wage: 1200, Position: Developer]
</code></pre>
Then again, since all we're doing with this Lambda Expression is call a single method, we can reference just that method:
<pre><code class="hljs">Collections.sort(employeeList, Employee::compareTo);
</code></pre>
And this will also yield:
<pre><code class="hljs">[Name: Tim, Wage: 1500, Position: Developer, Name: Martha, Wage: 1300, Position: Developer, Name: David, Wage: 1200, Position: Developer]
</code></pre>
<h2 id="methodreferencetypes">Method Reference Types</h2>
Method references can be used in a couple of different scenarios:
<ul>
<li>Static Methods: <code>Class::staticMethodName</code></li>
<li>Instance Methods of Particular Objects: <code>object::instanceMethodName</code></li>
<li>Instance Methods of Arbitraty Objects: <code>Class::methodName</code></li>
<li>Constructor Reference: <code>Class::new</code></li>
</ul>
Let's go over all of these types through some simple examples.
<h3 id="staticmethodreferences">Static Method References</h3>
You can reference any <code>static</code> method of a class by simply calling its containing class with the method name.
Let's define a class with a <code>static</code> method and then reference it from another class:
<pre><code class="hljs">public class ClassA {
 public static void raiseToThePowerOfTwo(double num) {
 double result = Math.pow(num, 2);
 System.out.println(result);
 }
}
</code></pre>
And now, from another class, let's use the <code>static</code> utility method:
<pre><code class="hljs">public class ClassB {
 public static void main(String[] args) {
 List&lt;Double&gt; integerList = new ArrayList&lt;&gt;();
 integerList.add(new Double(5));
 integerList.add(new Double(2));
 integerList.add(new Double(6));
 integerList.add(new Double(1));
 integerList.add(new Double(8));
 integerList.add(new Double(9));

 integerList.forEach(ClassA::raiseToThePowerOfTwo);
 }
}
</code></pre>
Running this piece of code will yield:
<pre><code class="hljs">25.0
4.0
36.0
1.0
64.0
81.0
</code></pre>
There are many Java classes that offer <code>static</code> utility methods which can be used here. In our example we've used a custom method, albeit not a very useful one in this instance.
<h3 id="instancemethodsofparticularobjects">Instance Methods of Particular Objects</h3>
You can call a method from a particular instantiated object by referencing the method using the reference variable of the object.
This is most often illustrated through a custom comparator. We'll use the same <code>Employee</code> class from before and the same list to highlight the difference between these two:
<pre><code class="hljs">public class Employee {
 private int id;
 private String name;
 private int wage;
 private String position;

 // Constructor, getters and setters

 @Override
 public String toString() {
 return &quot;Name: &quot; + name + &quot;, Wage: &quot; + wage + &quot;, Position: &quot; + position;
 }

 public int compareTo(Employee employee) {
 if (this.wage &lt;= employee.wage) {
 return 1;
 } else {
 return -1;
 }
 }
}
</code></pre>
Now, let's define a <code>CustomComparator</code>:
<pre><code class="hljs">public class CustomComparator {
 public int compareEntities(Employee emp1, Employee emp2) {
 return emp1.compareTo(emp2);
 }
}
</code></pre>
And finally, let's populate a list and sort it:
<pre><code class="hljs">Employee emp1 = new Employee(1, &quot;David&quot;, 1200, &quot;Developer&quot;);
Employee emp2 = new Employee(2, &quot;Tim&quot;, 1500, &quot;Developer&quot;);
Employee emp3 = new Employee(3, &quot;Martha&quot;, 1300, &quot;Developer&quot;);

ArrayList&lt;Employee&gt; employeeList = new ArrayList&lt;&gt;();
employeeList.add(emp1);
employeeList.add(emp2);
employeeList.add(emp3);

// Initializing our CustomComparator
CustomComparator customComparator = new CustomComparator();

// Instead of making a call to an arbitrary Employee
// we&#x27;re now providing an instance and its method
Collections.sort(employeeList, customComparator::compareEntities);

System.out.println(employeeList);
</code></pre>
Running this code will also yield:
<pre><code class="hljs">[Name: Tim, Wage: 1500, Position: Developer, Name: Martha, Wage: 1300, Position: Developer, Name: David, Wage: 1200, Position: Developer]
</code></pre>
The main difference is that by adding another layer, through the <code>CustomComparator</code>, we can add more functionality for comparison and take it away from the class itself. A class like <code>Employee</code> shouldn't be burdened with complex comparison logic and this results in cleaner and more readable code.
On the other hand, sometimes we don't wish to define custom comparators and introducing one is simply too much of a hassle. In such cases, we'd call a method from an arbitrary object of a particular type, shown in the next section.
<h3 id="instancemethodsofarbitraryobjects">Instance Methods of Arbitrary Objects</h3>
This example has already been shown in the beginning of the article when we've boiled down the imperative approach into a functional approach via Lambda Expressions.
Though, for good measure, since this approach is used really often, let's take a look at another example:
<pre><code class="hljs">List&lt;Integer&gt; integerList = new ArrayList&lt;&gt;();
integerList.add(new Integer(5));
integerList.add(new Integer(2));
integerList.add(new Integer(6));
integerList.add(new Integer(1));
integerList.add(new Integer(8));
integerList.add(new Integer(9));

// Referencing the non-static compareTo method from the Integer class
Collections.sort(integerList, Integer::compareTo);

// Referencing static method
integerList.forEach(System.out::print);
</code></pre>
Running this piece of code would yield:
<pre><code class="hljs">125689
</code></pre>
While this may seem like it's the same as a call to a static method, it's not. This is equivalent to calling the Lambda Expression:
<pre><code class="hljs">Collections.sort(integerList, (Integer a, Integer b) -&gt; a.compareTo(b));
</code></pre>
Here, the distinction is more obvious. If we were to call a <code>static</code> method, it would look like:
<pre><code class="hljs">Collections.sort(integerList, (Integer a, Integer b) -&gt; SomeClass.compare(a, b));
</code></pre>
<h3 id="referencingconstructors">Referencing Constructors</h3>
You can reference a class' constructor in the same way you'd reference a <code>static</code> method.
You could use a reference to a constructor instead of classic class instantiation:
<pre><code class="hljs">// Classic instantiation
Employee employee = new Employee();

// Constructor reference
Employee employee2 = Employe::new;
</code></pre>
Based on the context, if multiple constructors are present, the adequate one will be used if referenced:
<pre><code class="hljs">Stream&lt;Employee&gt; stream = names.stream().map(Employee::new);
</code></pre>
Due to a stream of names, if a <code>Employee(String name)</code> constructor is present, it will be used.
Another way you could use constructor references is when you'd wanna map out a stream into an array, while keeping the particular type. If you were to simply map it and then call <code>toArray()</code>, you'd get an array of <code>Object</code>s instead of your particular type.
If we tried, say:
<pre><code class="hljs">Employee[] employeeArray = employeeList.toArray();
</code></pre>
Of course, we'd be greeted with a compiler error since we <code>.toArray()</code> returns an array of <code>Object</code>s. Casting it won't help either:
<pre><code class="hljs">Employee[] employeeArray = (Employee[]) employeeList.toArray();
</code></pre>
But this time, it'll be a runtime exception - <code>ClassCastException</code>.
We can avoid that with:
<pre><code class="hljs">// Making a list of employees
List&lt;String&gt; employeeList = Arrays.asList(&quot;David&quot;, &quot;Scott&quot;);

// Mapping a list to Employee objects and returning them as an array
Employee[] employeeArray = employeeList.stream().map(Employee::new).toArray(Employee[]::new);

// Iterating through the array and printing information
for (int i = 0; i &lt; employeeArray.length; i++) {
 System.out.println(employeeArray[i].toString());
}
</code></pre>
And with that, we get the output:
<pre><code class="hljs">Name: David, Wage: 0, Position: null
Name: Scott, Wage: 0, Position: null
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Method References are a type of Lambda Expressions that are used to simply reference a method in their call. With them, writing code can be a lot more concise and readable.
Lambda Expressions have introduced Java Developers to a more functional approach in programming which allows them to avoid writing verbose code for simple operations.

David Landup

Reducing boilerplate code has always been a popular task for Java developers. Method References allow us to shorten Lambda Expressions further down into concise, readable statements.