<h2 id="introduction">Introduction</h2>
With Spring, we map requests to request handlers via the <code>@RequestMapping</code> annotation. Spring Boot introduced us to derived types of this annotation - <code>@GetMapping</code>, <code>@PostMapping</code>, <code>@DeleteMapping</code>, etc.
These requests contain different types of information and data - and depending on what our endpoint does with the request, we may want to retrieve the body of a <code>POST</code> request either for logging or further processing.
The <code>@RequestBody</code> annotation allows us to retrieve the request's body. We can then return it as a String or deserialize it into a Plain Old Java Object (POJO).
Spring has built-in mechanisms for deserializing JSON and XML objects into POJOs, which makes this task a lot easier as well.
In this article, we'll get the body of a <code>POST</code> HTTP request and pack it into a String, as well as deserialize it into a POJO.
<h2 id="gettinghttppostbodyasastring">Getting HTTP POST Body as a String</h2>
Let's start out with a <code>@Controller</code> class to handle an incoming request:
<pre><code class="hljs">@ResponseBody
@Controller
@RequestMapping(&quot;/response&quot;)
public class HomeController {}
</code></pre>
What's worth noting here is that we've added the <code>@ResponseBody</code> annotation to the <code>@Controller</code>. This way, it won't render a template as the response body, but rather, will return a response body. Specifically, we'll pack it in a String and return that.
Spring Boot introduced us to another derived type - <code>@RestController</code> which is just a combination of the previous two annotations. Let's use that instead for brevity:
<pre><code class="hljs">@RestController
@RequestMapping(&quot;/response&quot;)
public class HomeController {}
</code></pre>
Now, let's go ahead and define a request handler. Since we're handling a <code>POST</code> request, we'll use the <code>@PostMapping</code> annotation for it:
<pre><code class="hljs">@RestController
@RequestMapping(&quot;/response&quot;)
public class HomeController {

 @PostMapping(&quot;/postbody&quot;)
 public String postBody(@RequestBody String fullName) {
 return &quot;Hello &quot; + fullName;
 }
}
</code></pre>
To retrieve the body of the <code>POST</code> request sent to the handler, we'll use the <code>@RequestBody</code> annotation, and assign its value to a String. This takes the body of the request and neatly packs it into our <code>fullName</code> String. We've then returned this name back, with a greeting message.
Let's test this controller out via <code>curl</code>:
<pre><code class="hljs">curl -X POST -H &quot;Content-type: application/json&quot; -d &quot;John Smith&quot; &quot;http://localhost:8080/response/postbody&quot;
</code></pre>
This results in:
<pre><code class="hljs">Hello John Smith
</code></pre>
<h2 id="deserializehttppostintopojo">Deserialize HTTP POST into POJO</h2>
Now, typically, we won't be working with Strings, although they serve as a good example for learning. In most cases, we'll want to do some processing, or at the least, serialize the request into a POJO. Let's define a <code>Person</code> POJO with a <code>firstName</code> and <code>lastName</code>:
<pre><code class="hljs">public class Person {
 private String firstName;
 private String lastName;
 
 // Constructor, getters and setters
}
</code></pre>
We'll perform the same process as in the previous example - with the same controller. However, this time, we'll specify that the controller is accepting JSON and XML values and that it produces JSON or XML responses back.
We'll retrieve a <code>POST</code> request body in JSON format, deserialize it into a POJO for further processing (saving into a database, for example) and return a JSON response.
Although Spring Boot can automatically match the JSON body to our POJO, given the variable names match, we'll explicitly set this option. We'll set the input and output formats using the <code>consumes</code> and <code>produces</code> flags in the <code>@PostMapping</code>:
<pre><code class="hljs">@RestController
@RequestMapping(&quot;/response&quot;)
public class HomeController {

 @PostMapping(
 value = &quot;/postbody&quot;,
 consumes = {MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE},
 produces = {MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
 public ResponseEntity&lt;Person&gt; postBody(@RequestBody Person person) {
 Person persistedPerson = personService.save(person);
 return ResponseEntity
 .created(URI
 .create(String.format(&quot;/persons/%s&quot;, person.getFirstName())))
 .body(persistedPerson);
 }
}
</code></pre>
Here, we're accepting JSON and XML, as well as producing it back. We've annotated the <code>Person</code> instance as the <code>@RequestBody</code>, which we'll also be expecting from the request. Then, we've used a <code>PersonService</code> instance to save the person to a database, which also returns the persisted object for further processing.
For brevity's sake, we've omitted the <code>PersonService</code> implementation as it's a standard service-layer implementation.
Finally, we've returned a <code>ResponseEntity</code> object. It's just an extension of the <code>HttpEntity</code> class that also has a status code. We've set the status code as <code>CREATED</code> with a <code>URI</code> location where the new created resource is located. Then, we've set the body of the <code>ResponseEntity</code> as the <code>persistentPerson</code> instance and built the response.
Let's test this controller out via <code>curl</code> again:
<pre><code class="hljs">curl -X POST -H &quot;Content-type: application/json&quot; -d &quot;{\&quot;firstName\&quot; : \&quot;John\&quot;, \&quot;lastName\&quot; : \&quot;Smith\&quot;}&quot; &quot;http://localhost:8080/response/postbody&quot;
</code></pre>
Here, we've made a <code>POST</code> request with a JSON body, containing the first and last name of a person and sent it to our endpoint. Jackson kicks off the deserialization process and maps the incoming JSON to our POJO:
<img src="https://s3.stackabuse.com/media/articles/spring-boot-get-http-post-body.png" alt="json to pojo mapping">
The endpoint, after saving the <code>Person</code> entity, responds with:
<pre><code class="hljs">{&quot;firstName&quot;:&quot;John&quot;,&quot;lastName&quot;:&quot;Smith&quot;}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've covered two ways to capture a <code>POST</code> HTTP request's body in a Spring Boot controller.
Using the <code>@RequestBody</code> annotation, we've mapped the body to a String and returned it. Afterwards, we've defined a POJO to deserialize incoming JSON contents into, processed it and finally returned a <code>ResponseEntity</code>.

David Landup

In this article, we'll see how to get the HTTP POST body in Spring using the @RequestBody annotation and deserialize its JSON contents into a POJO for processing.

Get HTTP POST Body in Spring Boot with @RequestBody

<h2 id="introduction">Introduction</h2>
Websites generally need additional files such as images, CSS, and JavaScript files that are necessary to render complete web pages in a browser. In small projects, we can work our way around by providing absolute paths to our resources or by writing inline CSS and JavaScript functions in the HTML files. This is not only against the best coding practices but it also gets tricky when we are handling bigger projects, especially with multiple applications.
<blockquote>
In Django, the files required for interactive user experience, presentation of documents, and functional web pages are called static files.
</blockquote>
In this article, we will see how we can deal with multiple sets of static files provided by each application to customize the look and feel of a website.
<h2 id="configuringstaticfiles">Configuring Static Files</h2>
Django provides tremendous flexibility on how you can serve the static files. We will cover using the static files in local development as well as in production which is slightly more complex. First things first, let's do the basic configuration.
Django provides <a rel="nofollow noopener" target="_blank" href="https://docs.djangoproject.com/en/3.1/ref/contrib/staticfiles/#module-django.contrib.staticfiles"><code>django.contrib.staticfiles</code></a> to help you collect static files from each of your applications (and any other places you specify) into a single location that can easily be served in production.
In your <code>settings.py</code> file, your <code>INSTALLED_APPS</code> should look like this:
<pre><code class="hljs">INSTALLED_APPS = [
 &#x27;django.contrib.auth&#x27;,
 &#x27;django.contrib.sites&#x27;,
 &#x27;django.contrib.contenttypes&#x27;,
 &#x27;django.contrib.admin&#x27;,
 &#x27;django.contrib.sessions&#x27;,
 &#x27;django.contrib.messages&#x27;,
 &#x27;django.contrib.staticfiles&#x27;, # To serve static files
]
</code></pre>
<code>STATIC_ROOT</code> is the path that defines where your static files will be collected. We'll provide an absolute path to <code>STATIC_ROOT</code> in <code>settings.py</code>.
To do this, we'll use the <code>os</code> module's <code>dirname()</code> function to get the name of the directory we'd like to host these files in and define the path:
<pre><code class="hljs">import os

PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
STATIC_ROOT = os.path.join(PROJECT_ROOT, &#x27;staticfiles&#x27;)
</code></pre>
Then, you need to specify a <code>STATIC_URL</code> which is the URL used when referring to static files. It must end with <code>/</code> if it is set to any value except <code>None</code>. The following path means that static files will be stored in the location <code>http://localhost:8000/static/</code> or <code>http://127.0.0.1:8000/static/</code>:
<pre><code class="hljs">STATIC_URL = &#x27;/static/&#x27;
</code></pre>
Django has a list of finders as <a rel="nofollow noopener" target="_blank" href="https://docs.djangoproject.com/en/3.1/ref/settings/#std:setting-STATICFILES_FINDERS"><code>STATICFILES_FINDERS</code></a> that it uses to locate static files. One of the default finders is <code>AppDirectoriesFinder</code> that looks for a folder named <code>static</code> within each of your <code>INSTALLED_APPS</code>.
For example, if your project contains an application named <code>users</code>, you might create a directory such as <code>project_name/users/static/index.css</code> to add CSS files related to that app.
Even though this works, it is a better idea to create another subdirectory with your application name such as <code>project_name/users/static/users/index.css</code>. This is important when we have two or more static files with similar names.
Let's consider you have an <code>index.css</code> in every app each containing different CSS styles. Django will look for the first <code>index.css</code> it could find in <code>app/static/</code> directories. It will not be able to distinguish between various <code>index.css</code> that we have in each application's <code>static</code> directory. That is why we created a subdirectory with the application name <code>app/static/app/</code>.
Furthermore, most projects have multiple applications that can have common static files so it is usually better to make a folder <code>static</code> in your project's root directory instead of making a <code>static</code> folder in each application:
<img src="https://stackabuse.s3.amazonaws.com/media/serving-static-files-in-python-with-django-aws-s3-and-whitenoise-1.png" alt="static folder directory">
To use a commonplace for all static files in your project directory, we need to configure <code>STATICFILES_DIRS</code> to inform Django about our new directory because <code>AppDirectoriesFinder</code> will look for <code>static</code> in <code>app</code> directories only. We can also define multiple locations for our static files.
This is the place to define individual project's static folders if you have multiple ones:
<pre><code class="hljs">STATICFILES_DIRS = (
 os.path.join(PROJECT_ROOT, &#x27;static&#x27;),
 # Extra lookup directories for collectstatic to find static files
)
</code></pre>
Note that <code>STATICFILES_DIRS</code> will only work if you do not remove <code>FileSystemFinder</code> from <code>STATICFILES_FINDERS</code>.
As a brief recap, our <code>settings.py</code> include:
<pre><code class="hljs">import os

PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
STATIC_ROOT = os.path.join(PROJECT_ROOT, &#x27;staticfiles&#x27;)
STATIC_URL = &#x27;/static/&#x27;

# Extra lookup directories for collectstatic to find static files
STATICFILES_DIRS = (
 os.path.join(PROJECT_ROOT, &#x27;static&#x27;),
)
</code></pre>
The static files are ready to be used in your project. We just need to load the <code>static</code> template tag by <code>{% load static %}</code> and then use the <code>static</code> template tag to build the URL for the given relative path. Let's see how we can use static files in our template file <code>base.html</code>:
<pre><code class="hljs">&lt;!doctype html&gt;
{% load static %}
&lt;html lang=&quot;en&quot;&gt;
 {% include &#x27;head.html&#x27; %}
 &lt;style&gt;
 body{
 background: url(&#x27;{% static &quot;bg.png&quot; %}&#x27;) no-repeat center center fixed; 
 -webkit-background-size: cover;
 -moz-background-size: cover;
 -o-background-size: cover;
 background-size: cover;
 }
 &lt;/style&gt;
 &lt;body&gt;
 &lt;div class=&quot;row justify-content-center&quot;&gt;
 &lt;div class=&quot;col-8&quot;&gt;
 &lt;h1 class=&quot;mainbtn&quot;&gt;MY CUSTOM CSS CLASS&lt;/h1&gt;
 {% block content %}
 &lt;hr class=&quot;mt-0 mb-4&quot;&gt;
 {% endblock %}
 &lt;/div&gt;
 &lt;/div&gt;
 &lt;/div&gt;
 &lt;/body&gt;
&lt;/html&gt;
</code></pre>
The <code>base.html</code> includes a <code>head.html</code> template for proper segregation as bigger projects usually contain lengthy code in <code>head</code> tags. The <code>mainbtn</code> class for <code>h1</code> is defined in the <code>static/index.css</code> file. The background image <code>bg.png</code> is also present in the <code>static</code> directory.
The <code>head.html</code> looks like this:
<pre><code class="hljs">&lt;head&gt;
 {% block css_block %}{% endblock %}
 {% load static %}
 &lt;meta charset=&quot;utf-8&quot;&gt;
 &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1, shrink-to-fit=no&quot;&gt;
 
 &lt;link rel=&quot;stylesheet&quot; href=&quot;{% static &#x27;css/index.css&#x27; %}&quot;&gt;
 &lt;script src=&quot;{% static &#x27;js/functions.js&#x27; %}&quot;&gt;&lt;/script&gt;
 &lt;script src=&quot;https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js&quot;&gt;&lt;/script&gt;
 
 &lt;title&gt;{% block title %} Title to be changed in included files {% endblock %}&lt;/title&gt;
&lt;/head&gt;
</code></pre>
<h3 id="servingstaticfiles">Serving Static Files</h3>
In addition to the above configurations, we also need to actually serve the static files. It is automatically done by Django's <code>runserver</code> command if <code>Debug = True</code>. You should use this method in the development phase as it is easy, however, it is not recommended for production because it is inefficient and insecure.
Django comes with a built-in command <code>collecstatic</code>. It compiles all static files into a single directory <code>STATIC_ROOT</code> which we already set. The final piece is the storage engine used when collecting static files with the <code>collectstatic</code> command. The storage engine can be configured by <code>STATICFILES_STORAGE</code>. Django has its own storage engine so the default value of <code>STATICFILES_STORAGE</code> is set to <code>django.contrib.staticfiles.storage.StaticFilesStorage</code>.
<h3 id="staticfilesinproduction">Static Files in Production</h3>
There are two main steps to put static files in a production environment:
<ul>
<li>Run the <code>collectstatic</code> command whenever the static files change</li>
<li>Arrange for <code>STATIC_ROOT</code> to be moved to the static file server and served</li>
</ul>
The <code>post_process()</code> method of the <code>Storage</code> class can take care of the second step but it really depends on your storage engine i.e. <code>STATICFILES_STORAGE</code>.
Note: You should know that serving static files in every production will be different due to the difference in environments but the basic idea and steps remain the same. There are three main tactics to handle the static files in production:
<ul>
<li>
Serve the static files and site from the same server: Use this method if you want your static files to be served from the server that is already running your web application. Despite its potential performance issue, it could be cost-effective as you only need to pay for one server hosting. To do this, push your code to the deployment server then run <code>collectstatic</code> to copy all files to <code>STATIC_ROOT</code>. Lastly, configure your webserver to serve the static files under <code>STATIC_URL</code>.
</li>
<li>
Serving static files from a dedicated server: The most common choices for dedicated static files servers are <a rel="nofollow noopener" target="_blank" href="https://nginx.org/en/">nginx</a> and <a rel="nofollow noopener" target="_blank" href="https://httpd.apache.org/">stripped-down version of Apache</a>. The web application runs on an entirely different server while your static files are deployed on a dedicated server which gives faster performance overall. Run <code>collectstatic</code> locally whenever static files change then push <code>STATIC_ROOT</code> to your dedicated server's directory that is being served. For detailed instructions, you should check the documentation of the respective server.
</li>
<li>
Serving static files from a cloud service: Another common tactic is to serve static files from a cloud storage provider such as Amazon, Microsoft Azure, and Alibaba Cloud.
</li>
</ul>
Let's see how we can use <a rel="nofollow noopener" target="_blank" href="https://aws.amazon.com/s3/">Amazon S3</a> for this purpose. First, install two Python libraries by using these commands:
<pre><code class="hljs">$ python -m pip install boto3
$ pip install django-storages
</code></pre>
The <code>boto3</code> library is a public API client to access Amazon S3 and other Amazon Web Services (AWS). The <code>django-storages</code> manages storage backends such as Amazon S3, OneDrive etc. It plugs in the built-in Django storage backend API. You will also need to add <code>storages</code> in your <code>INSTALLED_APPS</code>. Our <code>INSTALLED_APPS</code> like looks like this by now:
<pre><code class="hljs">INSTALLED_APPS = [
 &#x27;django.contrib.auth&#x27;,
 &#x27;django.contrib.sites&#x27;,
 &#x27;django.contrib.contenttypes&#x27;,
 &#x27;django.contrib.admin&#x27;,
 &#x27;django.contrib.sessions&#x27;,
 &#x27;django.contrib.messages&#x27;,
 &#x27;django.contrib.staticfiles&#x27;,
 &#x27;users&#x27;,
 &#x27;storages&#x27;, # New
]
</code></pre>
After that add the following configurations in your <code>settings.py</code>:
<pre><code class="hljs">AWS_ACCESS_KEY_ID = your_access_key_id
AWS_SECRET_ACCESS_KEY = your_secret_access_key
AWS_STORAGE_BUCKET_NAME = &#x27;sibtc-static&#x27;
AWS_S3_CUSTOM_DOMAIN = &#x27;%s.s3.amazonaws.com&#x27; % AWS_STORAGE_BUCKET_NAME
AWS_S3_OBJECT_PARAMETERS = {
 &#x27;CacheControl&#x27;: &#x27;max-age=86400&#x27;,
}
AWS_LOCATION = &#x27;static&#x27;
 
STATIC_URL = &#x27;https://%s/%s/&#x27; % (AWS_S3_CUSTOM_DOMAIN, AWS_LOCATION)
STATICFILES_STORAGE = &#x27;storages.backends.s3boto3.S3Boto3Storage&#x27;
</code></pre>
Finally, run <code>python manage.py collectstatic</code> and you are done with configuring Amazon S3 for your static files.
<h3 id="servingstaticfilesusingwhitenoise">Serving Static Files Using WhiteNoise</h3>
People often don't use third-party cloud services like Amazon S3 for a couple of reasons including paid subscriptions. WhiteNoise allows your Django project to serve its own static files, making it a self-contained unit that we can deploy anywhere without depending on service providers.
Although it works with any WSGI-compatible web application, it is most easily configured with a Django project.
<h4 id="configurationforwhitenoise">Configuration for WhiteNoise</h4>
Let's install <a rel="nofollow noopener" target="_blank" href="https://pypi.org/project/whitenoise/">WhiteNoise</a> with:
<pre><code class="hljs">$ pip install whitenoise
</code></pre>
In your <code>settings.py</code>, add WhiteNoise to the <code>MIDDLEWARE</code> list in the following order:
<pre><code class="hljs">MIDDLEWARE = [
 &#x27;django.middleware.security.SecurityMiddleware&#x27;,
 # WhiteNoise Middleware above all but below Security
 &#x27;whitenoise.middleware.WhiteNoiseMiddleware&#x27;, 
 &#x27;django.contrib.sessions.middleware.SessionMiddleware&#x27;,
 &#x27;django.middleware.common.CommonMiddleware&#x27;,
 &#x27;django.middleware.csrf.CsrfViewMiddleware&#x27;,
 &#x27;django.contrib.auth.middleware.AuthenticationMiddleware&#x27;,
 &#x27;django.contrib.messages.middleware.MessageMiddleware&#x27;,
 ]
</code></pre>
To use the compression support and forever-cacheable files, add this in your <code>settings.py</code> 
<code>STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'</code>
Run <code>python manage.py collectstatic</code>.
That's it! You can now deploy your web application to any hosting platform such as <a rel="nofollow noopener" target="_blank" href="https://www.heroku.com/python">Heroku</a>.
<h2 id="conclusion">Conclusion</h2>
Every website developer needs static files to make a beautiful and functional website. Django not only offers easy configuration of static files but also tremendous flexibility to play with their deployment.
In this article, we covered several ways to integrate static files in a Django web application in local development as well as production.

Muhammad Hashir Hassan

In this article, we take a look at how to serve static files using Django, including ing examples of serving static files locally and in production using AWS S3 and WhiteNoise.

Serving Static Files in Python With Django, AWS S3 and WhiteNoise

Guest Contributor

In this article, we'll explore how to lazy-load routes using Vue Router to improve page performance, as well as implement a progress bar to visualize the loading progress.

Lazy-Loading Routes with Vue Router

Lazy-Loading Routes with Vue Router with a Progress Bar

<h2 id="introduction">Introduction</h2>
The <code>cat</code> command is a Unix tool used for manipulating and displaying file contents. The command gets its name from the word &quot;concatenate&quot; because it has, among other things, the ability to concatenate files.
In this article, we'll go through a few easy ways to use this command to write text to a file with examples. Using <code>cat</code> is very straightforward, so no prior programming or Unix experience is needed to follow along.
<h2 id="catcommandbasics">cat Command Basics</h2>
Starting, we'll just sum up the basics of the <code>cat</code> command to help you out if you've never used it before or need a brief overview.
<h3 id="syntax">Syntax</h3>
The syntax looks like this:
<pre><code class="hljs">cat [OPTION]... [FILE]...
</code></pre>
To quickly look up the syntax or command options, run cat with the help option:
<pre><code class="hljs">$ cat --help
</code></pre>
Or, you can use the manual pages:
<pre><code class="hljs">$ man cat
</code></pre>
These commands should display the following list of options:
<pre><code class="hljs"> -A, --show-all equivalent to -vET
 -b, --number-nonblank number non empty output lines, overrides -n
 -e equivalent to -vE
 -E, --show-ends display $ at end of each line
 -n, --number number all output lines
 -s, --squeeze-blank suppress repeated empty output lines
 -t equivalent to -vT
 -T, --show-tabs display TAB characters as ^I
 -u (ignored)
 -v, --show-nonprinting use ^ and M- notation, except for LFD and TAB
 --help display this help and exit
 --version output version information and exit
</code></pre>
<h3 id="displayingfilecontentsonthestandardoutput">Displaying File Contents on the Standard Output</h3>
To print the contents of a file to the standard output just name the file you want to display:
<pre><code class="hljs">$ cat filename1 
</code></pre>
If the file is in a different directory, you'll have to navigate to it:
<pre><code class="hljs">$ cat /dir1/dir2/filename1 
</code></pre>
We'll be expecting to see the contents of this file, printed to the standard output, in this case - the terminal:
<pre><code class="hljs">Content of filename1!
</code></pre>
This is the most common use of the cat command since it makes it easy to peek into the contents of a file without opening a text editor.
<h2 id="writingtexttoafileusingcat">Writing Text to a File Using cat</h2>
To redirect the output of the <code>cat</code> command from the standard output to a file, we can use the output redirection operator <code>&gt;</code>:
<pre><code class="hljs">$ cat filename1 &gt; filename2
</code></pre>
This will overwrite the contents of <code>filename2</code> with the contents of <code>filename1</code>, so make sure that <code>filename2</code> doesn't contain anything you would mind losing. Now, <code>filename2</code> contains:
<pre><code class="hljs">Content of filename1!
</code></pre>
The output redirection operator will redirect the output of any command we call. For example, let's try it out with the <code>pwd</code> command, which prints the name of the current working directory:
<pre><code class="hljs">$ pwd &gt; testfile
</code></pre>
If we take a look at the <code>testfile</code> now:
<pre><code class="hljs">$ cat testfile
</code></pre>
It contains the current working directory's path:
<pre><code class="hljs">/home/kristina
</code></pre>
If the file you are redirecting to doesn't exist, a file by that name will be created:
<pre><code class="hljs">$ cat filename1 &gt; newfilename
</code></pre>
<h2 id="concatenatingfileswithcat">Concatenating Files with cat</h2>
Concatenating multiple files using <code>cat</code> is simple - just list the files in the desired order:
<pre><code class="hljs">$ cat filename1 filename2 &gt; outputfile
$ cat outputfile
</code></pre>
This takes the <code>filename1</code> and <code>filename2</code> files, concatenates them, and outputs the into a new <code>outputfile</code>:
<pre><code class="hljs">Content of filename1!
Content of filename2!
</code></pre>
<h2 id="standardinputbetweenfiles">Standard Input Between Files</h2>
When the name of the input file isn't listed, <code>cat</code> starts reading from the standard input until it reaches <code>EOF</code> (end-of-file). The end-of-file signal is sent by the <code>ctrl+d</code> command line shortcut:
<pre><code class="hljs">$ cat &gt; outputfile
Hello
World
$ cat outputfile
</code></pre>
This would output:
<pre><code class="hljs">Hello 
World
</code></pre>
We can even add text from the standard input in between files we wish to concatenate by using <code>-</code> to indicate where we expect standard input. If we have files such as <code>filename1</code>, <code>filename2</code>, and <code>filename3</code>, and we want some text from the standard input in between <code>filename1</code> and <code>filename2</code>, we would write:
<pre><code class="hljs"> $ cat filename1 - filename2 filename3 &gt; output
 Text from standard input!
 $ cat output
</code></pre>
Checking <code>output</code>, we'll see something along the lines of:
<pre><code class="hljs">Content of filename1!
Text from standard input!
Content of filename2!
Content of filename3!
</code></pre>
<h2 id="appendingfileswithcat">Appending Files with cat</h2>
In the previous examples, using the redirection operator discarded the previous contents of the <code>output</code> file. What if we want to append the new content to the old content? To append files we use the <code>&gt;&gt;</code> operator:
<pre><code class="hljs">$ cat filename1 filename2 &gt;&gt; output
$ cat output
</code></pre>
And that should result in:
<pre><code class="hljs">Original output file contents.
Content of filename1!
Content of filename2!
</code></pre>
<h2 id="concatenatingcontentsofallfilesdirectorywithcat">Concatenating Contents of all Files Directory with cat</h2>
To concatenate all contents of all files in a directory, we use the wildcard <code>*</code>:
<pre><code class="hljs">$ cat /dir1/dir2/* &gt; output
</code></pre>
To concatenate all contents of all files in the current working directory, we'd use:
<pre><code class="hljs">$ cat * &gt; output
</code></pre>
<code>*</code> can also be used to concatenate all files with the same extension:
<pre><code class="hljs">$ cat *.txt &gt; output
</code></pre>
<h2 id="enumeratinglinenumbers">Enumerating Line Numbers</h2>
Enumeration of all lines of output is done with the <code>-n</code> option:
<pre><code class="hljs">$ cat -n filename1 filename2 filename3 &gt; output
$ cat output
</code></pre>
Which would write something along the lines of:
<pre><code class="hljs"> 1 Content of filename1!
 2 Content of filename2!
 3 Content of filename3!
</code></pre>
<h2 id="writeattheendofeveryline">Write $ at the End of Every Line</h2>
The <code>-E</code> option marks the end of every line in the file with the <code>$</code> character:
<pre><code class="hljs">$ cat -E filename1 filename2 filename3 &gt; output
$ cat output
</code></pre>
<h2 id="sortinglinesofconcatenatedfilesbypiping">Sorting Lines of Concatenated Files by Piping</h2>
This one is a bit of a cheat. The <code>cat</code> command can't sort, but we can use piping to achieve that. The pipe command (<code>|</code>) is used to turn the output of one command into the input of another. To sort the lines of a file, we'll use both <code>cat</code> and another command, called <code>sort</code>:
<pre><code class="hljs">$ cat filename2 filename3 filename1 | sort &gt; output
$ cat output
</code></pre>
This results in:
<pre><code class="hljs">Content of filename1!
Content of filename2!
Content of filename3!
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Cat is a simple, yet powerful Unix tool that comes preinstalled on most systems. It can be used on its own or in combination with other commands using pipes. Originally made by Ken Thompson and Dennis Ritchie in 1971, <code>cat</code>'s easy to use and intuitive functionalities stand the test of time.
In this article, we've explored some of the possibilities of using the <code>cat</code> command to write text to files, check contents, concatenate and append files as well as enumerate lines and sort them.

Kristina Popovic

In this article, we'll be taking a look at the cat command on Linux. We'll explore how to write text to a file, read the input stream, append and concatenate files, as well as other operations.

Writing to Files Using cat Command on Linux

Aniuchi Adaobi

In this article, we'll give an introduction to using GraphicsMagick and ImageMagick to manipulate images in Node.js, as well as examples of various supported functions.

Working with Images in Node.js - GraphicsMagick and ImageMagick

<h2 id="introduction">Introduction</h2>
NPM stands for Node Package Manager and refers to either the online project repository or the Command Line Interface (CLI) tool used to interact with the online repository.
Currently, NPM is the world's largest software registry with over 1.4M+ code packages. For example, if you wanted to use Node.js to send emails - you could do a quick search on their repository and find a module like <a rel="nofollow noopener" target="_blank" href="https://www.npmjs.com/package/nodemailer">Nodemailer</a>, which can save you a lot of time.
You might want to share a tool you've created with the community, that streamlines some boilerplate task. In this article, we'll take a look at how to publish a Node.js module to NPM.
<h2 id="gettingstartedwithnpm">Getting Started with NPM</h2>
To publish a module to NPM, we need to have an NPM account. If you don't have one, you can create it <a rel="nofollow noopener" target="_blank" href="https://www.npmjs.com/signup">here</a>.
When you install Node.js, the <code>npm</code> tool is automatically installed as well.
To check whether <code>npm</code> has been installed properly, you can check what the currently installed version is by running:
<pre><code class="hljs">$ npm -v
</code></pre>
Once ascertained that we've indeed got <code>npm</code> installed, we can log in:
<pre><code class="hljs">$ npm login
</code></pre>
The tool will prompt us for our id, email and password created while signing up.
Note: You don't need to have an account to use NPM, but to publish a module, you'll need one as it's tied to you as the author.
<h2 id="creatingapackage">Creating a Package</h2>
Let's create a directory for our project and move into it:
<pre><code class="hljs">$ mkdir publish-to-npm
$ cd publish-to-npm
</code></pre>
Next, we'll initialize the project:
<pre><code class="hljs">$ npm init 
</code></pre>
The command will then prompt you with several questions that, when filled in, produce a <code>package.json</code> file:
<pre><code class="hljs">{
 &quot;name&quot;: &quot;publish-to-npm&quot;,
 &quot;version&quot;: &quot;1.0.0&quot;,
 &quot;description&quot;: &quot;\&quot;Sample module for publishing\&quot;&quot;,
 &quot;main&quot;: &quot;index.js&quot;,
 &quot;scripts&quot;: {
 &quot;test&quot;: &quot;echo \&quot;Error: no test specified\&quot; &amp;&amp; exit 1&quot;
 },
 &quot;author&quot;: &quot;your@email.com&quot;,
 &quot;license&quot;: &quot;ISC&quot;
}
</code></pre>
The main entry point, by default, is the <code>index.js</code>, so we'll want to create that file and add something to it.
If you used the <code>-y</code> flag alongside the <code>init</code> command, these would've been set to their defaults.
<h2 id="addingdependencies">Adding Dependencies</h2>
Let's add some code to our <code>index.js</code> file and add a dependency, such as another NPM module for it to use.
First, we'll install a dependency:
<pre><code class="hljs">$ npm install node-fetch --save
</code></pre>
Then, we'll import it to our <code>index.js</code> file and add some logic:
<pre><code class="hljs">const fetch = require(&#x27;node-fetch&#x27;);

fetch(&#x27;https://google.com&#x27;)
 .then(res =&gt; res.text())
 .then(text =&gt; console.log(text))
</code></pre>
To verify this is working, we can run:
<pre><code class="hljs">$ node index.js
</code></pre>
And the output is:
<pre><code class="hljs">&lt;!doctype html&gt;
&lt;html itemscope=&quot;&quot; itemtype=&quot;http://schema.org/WebPage&quot; lang=&quot;en-RS&quot;&gt;
 &lt;head&gt;
 &lt;meta charset=&quot;UTF-8&quot;&gt;
 &lt;meta content=&quot;origin&quot; name=&quot;referrer&quot;&gt;
 &lt;!-- Rest of the page --&gt;
</code></pre>
When checking the <code>package.json</code> file now, we can see <code>node-fetch</code> in our dependencies:
<pre><code class="hljs">{
 &quot;name&quot;: &quot;publish-to-npm&quot;,
 &quot;version&quot;: &quot;1.0.0&quot;,
 &quot;description&quot;: &quot;\&quot;Sample module for publishing\&quot;&quot;,
 &quot;main&quot;: &quot;index.js&quot;,
 &quot;scripts&quot;: {
 &quot;test&quot;: &quot;echo \&quot;Error: no test specified\&quot; &amp;&amp; exit 1&quot;
 },
 &quot;author&quot;: &quot;your@email.com&quot;,
 &quot;license&quot;: &quot;ISC&quot;
 &quot;dependencies&quot;: {
 &quot;node-fetch&quot;: &quot;2.6.1&quot;
 }
}
</code></pre>
Note: The <code>--save</code> flag tells <code>npm</code> to update the project with the module as a dependency. This has been lifted in the newer versions and the module will be added to the dependency list even without the <code>--save</code> flag, though, for older versions, you'll have to use it.
<h2 id="publishingtonpm">Publishing to NPM</h2>
Now, we can publish the module to NPM via the <code>publish</code> command:
<pre><code class="hljs">$ npm publish
</code></pre>
If you get any error, it's most probably because of a name collision. i.e., a package with the same name already exists on npm. We have to change the name of our project to something unique.
You can search for existing package names through the search bar on the <a rel="nofollow noopener" target="_blank" href="https://www.npmjs.com/">home page</a>.
After you come up with a unique name, you have to change the package name in our <code>package.json</code> file. For the sake of consistency, it's also advised to update the folder name to match the package name.
If you are not able to come up with a unique name, you should check out <a rel="nofollow noopener" target="_blank" href="https://docs.npmjs.com/about-scopes">scoped packages</a>. This essentially gives you your own namespace on NPM, so you can name your packages whatever you want.
It's generally advised that, if you plan to make a module public, you still avoid using the same name as another package to avoid unnecessary confusion. However, it's very practical for personal use.
This is one of those settings we avoided changing by using the <code>-y</code> flag. If you wanted to make a scoped module, you would need to initialize your project with:
<pre><code class="hljs">$ npm init --scope=@your-username
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've written up a simple app and published it to NPM as a public module for other developers to use at their convenience.
You might come across a situation in the future where you don’t find a module readily available to solve your particular problem. You can write the solution yourself and upload it to NPM, and maybe help out other developers with the same problem.

Abhilash Kakumanu

In this article, we'll write a simple Node module and publish it to NPM for other developers to use.

Publishing a Node.js Module to NPM

<h2 id="introduction">Introduction</h2>
String padding refers to adding, usually, non-informative characters to a string to one or both ends of it. This is most often done for output formatting and alignment purposes, but it can have useful practical applications.
A frequent use case for padding strings is outputting table-like information in a table-like fashion. You can do this in a variety of ways, including using Pandas to convert your data to an actual table. This way, Python would handle the output formatting on its own.
In this article, we'll cover how to pad strings in Python.
Say, we've got these three lists:
<pre><code class="hljs">medicine1 = [&#x27;Morning&#x27;, &#x27;dispirine&#x27;, &#x27;1 mg&#x27;]
medicine2 = [&#x27;Noon&#x27;, &#x27;arinic&#x27;, &#x27;2 mg&#x27;]
medicine3 = [&#x27;Evening&#x27;, &#x27;Long_capsule_name&#x27;, &#x27;32 mg&#x27;]
</code></pre>
We can form these into a string, using the <code>join()</code> function:
<pre><code class="hljs">print(str.join(&#x27; &#x27;, medicine1))
print(str.join(&#x27; &#x27;, medicine2))
print(str.join(&#x27; &#x27;, medicine3))
</code></pre>
Would give us the rather untidy output of:
<pre><code class="hljs">Morning Dispirine 1 mg
Noon Arinic 2 mg
Evening Long_capsule_name 32 mg
</code></pre>
To combat this, we could write <code>for</code>/<code>while</code> loops and append spaces to the strings until they reached a certain length, and make sure that all the data is aligned properly for easy visual inspection. Or, we could use built-in functions that can achieve the same goal.
The functions we'll be taking a look at in this article are: <a href="#ljust"><code>ljust()</code></a>, <a href="#center"><code>center()</code></a>, <a href="#rjust"><code>rjust()</code></a>, <a href="#zfill"><code>zfill()</code></a> and <a href="#format"><code>format()</code></a>. Any of these functions can be used to add a certain number of characters to either end of strings, including spaces.
<h2 id="paddingtypes">Padding Types</h2>
Before we take a closer look at the functions mentioned above, we'll take a look at different types of padding so we can reference them when talking about the functions.
<h3 id="leftpadding">Left Padding</h3>
Adding left padding to a string means adding a given character at the start of a string to make it of the specified length. Left padding, outside of simple formatting and alignment reasons can be really useful when naming files that start with a number generated in a sequence.
For example, you need to name 11 files, and each of them starts with a number from 1 to 11. If you simply added the number at the beginning of the file, most operating systems would sort the files in the following order: <code>1</code>, <code>10</code>, <code>11</code>, <code>2</code>, and so on.
This happens of course because of the rules of lexicographical sorting, but you can avoid these situations by naming files with one or more leading zeroes, depending on how many files you expect, i.e.: <code>01</code>, <code>02</code>, <code>03</code>...
This can be achieved by effectively left padding the numbers with the appropriate number of zeroes, which keeps their original value.
This gives the effect of strings being left-justified.
<h3 id="centerpadding">Center Padding</h3>
This means that the given character is added in equal measure to both sides of the string until the new string reaches the given length. Using this effectively centers the string in the provided length:
<div>This is a normal string.</div>
<div style="text-align:center">This is a center padded string.</div>
<h3 id="rightpadding">Right Padding</h3>
Right padding is analogous to left padding - the given character is added to the end of the string until the string reaches a certain length.
<h2 id="pythonfunctionsforstringpadding">Python Functions For String Padding</h2>
Python offers many functions to format and handle strings, their use depends on the use case and the developer's personal preference. Most of the functions we'll discuss deal with text justification which is essentially adding padding to one side of the string. For example, for a string to be left-justified, we need to add padding to the end (right side) of the string.
Note: In all the functions that expect a <code>width</code> or <code>len</code> parameter, in case the original string is longer than the specified <code>width</code> or <code>len</code> the entire string will be kept without changes. This can have the undesired effect of long strings ruining the formatting, so when choosing a <code>width</code> value, make sure you take your longest string into account or a top length boundary.
<h3 id="ljust">ljust()</h3>
The <code>ljust()</code> function aligns a string to the left by adding right padding.
The <code>ljust()</code> function takes two parameters: <code>width</code> and <code>fillchar</code>. The <code>width</code> is mandatory and specifies the length of the string after adding padding, while the second parameter is optional and represents the character added pad the original string.
The default value is a space character, i.e. <code>' '</code>. This is a particularly good option to use when printing table-like data, like in our example at the beginning:
<pre><code class="hljs">medicine1 = [&#x27;Morning&#x27;, &#x27;Dispirine&#x27;, &#x27;1 mg&#x27;]
medicine2 = [&#x27;Noon&#x27;, &#x27;Arinic&#x27;, &#x27;2 mg&#x27;]
medicine3 = [&#x27;Evening&#x27;, &#x27;Long_capsule_name&#x27;, &#x27;32 mg&#x27;]

for medicine in [medicine1, medicine2, medicine3]:
 for entry in medicine:
 print(entry.ljust(25), end=&#x27;&#x27;)
 print()
</code></pre>
Which gives us the output:
<pre><code class="hljs">Morning Dispirine 1 mg 
Noon Arinic 2 mg 
Evening Long_capsule_name 32 mg 
</code></pre>
<h3 id="center">center()</h3>
The <code>center()</code> function aligns a string in the center of the specified <code>width</code>, by adding padding equally to both sides. The parameters are the same as with the <code>ljust()</code> function, a required <code>width</code>, and optional <code>fillchar</code> parameter:
<pre><code class="hljs">list_of_strings = [&quot;This can give us&quot;, &quot;text that&#x27;s center aligned&quot;, &quot;within the specified width&quot;]

for s in list_of_strings:
 print(s.center(50, &#x27; &#x27;))
</code></pre>
Output:
<pre><code class="hljs"> This can give us 
 text that&#x27;s center aligned 
 within the specified width 
</code></pre>
<h3 id="rjust">rjust()</h3>
Analogous to the previous two functions, <code>rjust()</code> aligns the string to the right by adding padding to the left (beginning) of the string.
Again, the parameters are the required <code>width</code> and optional <code>fillchar</code>. Like we mentioned previously, this function is very useful when naming files that start with numbers because of the more intuitive sorting:
<pre><code class="hljs">list_of_names_original = []
list_of_names_padded = []

for n in range(1, 13):
 list_of_names_original.append(str(n) + &quot;_name&quot;)
 list_of_names_padded.append(str(n).rjust(2, &#x27;0&#x27;) + &quot;_name&quot;)

print(&quot;Lexicographical sorting without padding:&quot;)
print(sorted(list_of_names_original))
print()

print(&quot;Lexicographical sorting with padding:&quot;)
print(sorted(list_of_names_padded))
</code></pre>
Running this code would give us:
<pre><code class="hljs">Lexicographical sorting without padding:
[&#x27;10_name&#x27;, &#x27;11_name&#x27;, &#x27;12_name&#x27;, &#x27;1_name&#x27;, &#x27;2_name&#x27;, &#x27;3_name&#x27;, &#x27;4_name&#x27;, &#x27;5_name&#x27;, &#x27;6_name&#x27;, &#x27;7_name&#x27;, &#x27;8_name&#x27;, &#x27;9_name&#x27;]

Lexicographical sorting with padding:
[&#x27;01_name&#x27;, &#x27;02_name&#x27;, &#x27;03_name&#x27;, &#x27;04_name&#x27;, &#x27;05_name&#x27;, &#x27;06_name&#x27;, &#x27;07_name&#x27;, &#x27;08_name&#x27;, &#x27;09_name&#x27;, &#x27;10_name&#x27;, &#x27;11_name&#x27;, &#x27;12_name&#x27;]
</code></pre>
<h3 id="zfill">zfill()</h3>
The <code>zfill()</code> function performs very similarly to using <code>rjust()</code> with zero as the specified character. It left-pads the given string with zeros until the string reaches the specified length.
The only difference is that in case our string starts with a plus(<code>+</code>) or minus(<code>-</code>) sign, the padding will start after that sign:
<pre><code class="hljs">neutral = &#x27;15&#x27;
positive = &#x27;+15&#x27;
negative = &#x27;-15&#x27;
length = 4

print(neutral.zfill(length))
print(positive.zfill(length+1))
print(negative.zfill(length+1))
</code></pre>
This is done to keep the original value of the number in case the string was a number. Running this code would give us:
<pre><code class="hljs">0015
+0015
-0015
</code></pre>
<h3 id="format">format()</h3>
The <code>format()</code> function is the most advanced in the list. This single function can be used for left, right, and even center padding. It is also used for <a target="_blank" href="/formatting-strings-with-python/">other formatting</a> too, but we'll only take a look at the padding functionality it provides.
It returns the string after formatting the specified values and putting them inside the string placeholders which are defined by <code>{}</code>.
The placeholders can be identified by either named indexes, numbered indexes, or even empty curly brackets. A quick example of how these placeholders look before we see how we can use this function to add padding:
<pre><code class="hljs">print(&quot;Placeholders can given by {0}, or with {value}&quot;.format(&quot;adding a number&quot;, value=&quot;a named value&quot;))
print(&quot;They can also be given {}, without adding a {} or {}&quot;.format(&quot;implicitly&quot;, &quot;number&quot;, &quot;name&quot;))
</code></pre>
Which would give us:
<pre><code class="hljs">Placeholders can given by adding a number, or with a named value
They can also be given implicitly, without adding a number or name
</code></pre>
These placeholders accept a variety of formatting options. Let's see how we can achieve different types of string padding by using these options:
<ul>
<li>
Left Padding: Use <code>&gt;</code> inside the placeholder and a number to specify the desired width, to right align a string (append characters at the start):
<pre><code class="hljs">txt = &quot;We {:&gt;8} Python.&quot;
print(txt.format(&#x27;love&#x27;))
</code></pre>
Which gives us:
<pre><code class="hljs">We love Python.
</code></pre>
</li>
<li>
Center Padding: Similarly, we can use <code>^</code> for center padding/alignment:
<pre><code class="hljs">txt = &quot;We {:^8} Python.&quot;
print(txt.format(&#x27;love&#x27;)) 
</code></pre>
<pre><code class="hljs">We love Python.
</code></pre>
</li>
<li>
Right Padding: Use <code>&lt;</code> inside placeholders to left align a string:
<pre><code class="hljs">txt = &quot;We {:&lt;8} Python.&quot;
print(txt.format(&#x27;love&#x27;)) 
</code></pre>
<pre><code class="hljs">We love Python.
</code></pre>
</li>
</ul>
You can also append characters other than white spaces, by adding the specified characters before the <code>&gt;</code>, <code>^</code> or <code>&lt;</code> character:
<pre><code class="hljs">print(&#x27;{:*^50}&#x27;.format(&#x27;Center padding with a specific character&#x27;))
</code></pre>
<pre><code class="hljs">*****Center padding with a specific character*****
</code></pre>
You can read more about the different possibilities of the <code>format()</code> function in our <a target="_blank" href="/formatting-strings-with-python/">Guide to Formatting Strings with Python</a>.
<h2 id="conclusion">Conclusion</h2>
Adding padding to strings in Python is a relatively straight-forward process that can noticeably increase the readability of your output, especially if the data you have can be read in a table-like fashion.
In this article, we've covered the <code>ljust()</code>, <code>rjust()</code>, <code>center()</code>, <code>zfill()</code> and <code>format()</code> function as built-in approaches to string padding in Python.

In this article, we take a look at what types of padding exist, and examples of how to efficiently add it in Python using ljust(), center(), rjust(), zfill() and format().

Padding Strings in Python

<h2 id="introduction">Introduction</h2>
Replacing all or n occurrences of a substring in a given string is a fairly common problem of string manipulation and text processing in general. JavaScript offers a few ways to get this done fairly easily.
In this tutorial, we'll cover some examples of how to replace occurrences of a substring in a string, using JavaScript.
We'll be working with this sentence:
<pre><code class="hljs">The grey-haired husky has one blue and one brown eye.
</code></pre>
We'll want to replace the word <code>&quot;blue&quot;</code> with <code>&quot;hazel&quot;</code>.
<h2 id="replace">replace()</h2>
The simplest way to do this is to use the built-in <code>replace()</code> function. It accepts a regular expression as the first argument, and the word(s) we're replacing the old ones with as the second argument. Alternatively, it accepts a string as the first argument too.
Since strings are immutable in JavaScript, this operation returns a new string. So if we want to make the changes permanent, we'll have to assign the result to a new string on return.
Let's see how we can use the function:
<pre><code class="hljs">const regex = /blue/;

let originalStr = &#x27;The grey-haired husky has one blue and one brown eye.&#x27;;
let newStr = originalStr.replace(regex, &#x27;hazel&#x27;);

console.log(originalStr);
console.log(newStr);
</code></pre>
Here, we've used a regular expression literal instead of instantiating a <code>RegExp</code> instance. This results in:
<pre><code class="hljs">The grey-haired husky has one blue and one brown eye.
The grey-haired husky has one hazel and one brown eye.
</code></pre>
Alternatively, we could've defined the regular expression as:
<pre><code class="hljs">let regex = new RegExp(&#x27;blue&#x27;);
</code></pre>
The result would've been the same. The difference between a regex literal and a <code>RegExp</code> object is that literals are compiled ahead of execution, while the object is compiled at runtime.
The former is more efficient if the regular expression stays constant, while the latter is typically used if the regex can be dynamic, such as an expression defined by the user.
To perform a case-insensitive replacement, you can pass the <code>i</code> flag to the regular expression:
<pre><code class="hljs">const regex = /blue/i;

let originalStr = &#x27;The grey-haired husky has one Blue and one brown eye.&#x27;;
let newStr = originalStr.replace(regex, &#x27;hazel&#x27;);

console.log(originalStr);
console.log(newStr);
</code></pre>
Now, this results in:
<pre><code class="hljs">The grey-haired husky has one Blue and one brown eye.
The grey-haired husky has one hazel and one brown eye.
</code></pre>
Without the <code>i</code> flag, <code>Blue</code> wouldn't match to the <code>/blue/</code> regex.
Finally, you can use a string instead of a regular expression:
<pre><code class="hljs">let originalStr = &#x27;The grey-haired husky has one blue and one brown eye.&#x27;;
let newStr = originalStr.replace(&#x27;blue&#x27;, &#x27;hazel&#x27;);

console.log(originalStr);
console.log(newStr);
</code></pre>
This also results in:
<pre><code class="hljs">The grey-haired husky has one blue and one brown eye.
The grey-haired husky has one hazel and one brown eye.
</code></pre>
Note: This approach works only for the first occurrence of the search string. To replace all occurrences, you can use the <code>replaceAll()</code> function.
If we update the string:
<pre><code class="hljs">let originalStr = &#x27;The grey-haired husky a blue left eye and a blue right eye.&#x27;;
let newStr = originalStr.replace(&#x27;blue&#x27;, &#x27;hazel&#x27;);
</code></pre>
The result would be:
<pre><code class="hljs">The grey-haired husky has a blue left eye and a blue right eye.
The grey-haired husky has a hazel left eye and a blue right eye.
</code></pre>
Notice how only the first occurance of &quot;blue&quot; is replaced, but not the second.
Note that we actually can replace all instances of a string when using the regex approach and <code>.replace()</code>. To make this happen, we'll want to use the <code>g</code> regex flag, which stands for &quot;global&quot;. This matches all instances in a string. For example:
<pre><code class="hljs">const regex = /blue/g;

let originalStr = &#x27;The grey-haired husky a blue left eye and a blue right eye.&#x27;;
let newStr = originalStr.replace(regex, &#x27;hazel&#x27;);

console.log(originalStr);
console.log(newStr);
</code></pre>
<pre><code class="hljs">The grey-haired husky has a blue left eye and a blue right eye.
The grey-haired husky has a hazel left eye and a hazel right eye.
</code></pre>
<h2 id="replaceall">replaceAll()</h2>
As of August 2020, as defined by the ECMAScript 2021 specification, we can use the <code>replaceAll()</code> function to replace all instances of a string.
It accepts a string we're searching for and a string we'd like to replace it with:
<pre><code class="hljs">let originalStr = &#x27;The grey-haired husky has a blue left eye and a blue right eye.&#x27;;
let newStr = originalStr.replaceAll(&#x27;blue&#x27;, &#x27;hazel&#x27;);

console.log(originalStr);
console.log(newStr);
</code></pre>
This results in:
<pre><code class="hljs">The grey-haired husky has a blue left eye and a blue right eye.
The grey-haired husky has a hazel left eye and a hazel right eye.
</code></pre>
Now all instances of the search word have been replaced.
<h2 id="splitandjoin">split() and join()</h2>
If <code>replaceAll()</code> isn't supported in your JavaScript runtime, you can use the trusty old <code>split()</code> and <code>join()</code> approach:
<pre><code class="hljs">let originalStr = &#x27;The grey-haired husky has a blue left eye and a blue right eye.&#x27;;
let newStr = originalStr.split(&#x27;blue&#x27;).join(&#x27;hazel&#x27;);

console.log(originalStr);
console.log(newStr);
</code></pre>
The <code>split()</code> function splits the string into an array of substrings on the given string - <code>'blue'</code>. Upon splitting, we have an array of:
<pre><code class="hljs">[&quot;The grey-haired husky has a &quot;, &quot; left eye and a &quot;, &quot; right eye.&quot;]
</code></pre>
Then, when se use <code>join()</code> with a string, we join it back into the original sentence, with the string passed to the function inserted in the breaks.
Now, we're left with all occurrences of the original string replaced with a new one:
<pre><code class="hljs">The grey-haired husky has a blue left eye and a blue right eye.
The grey-haired husky has a hazel left eye and a hazel right eye.
</code></pre>
Note: While this approach does work, it is not recommended for use if one of the other previously explained methods are available to use. The reason for this is that the purpose behind this approach is not as obvious at first-glance, and therefore it makes the code less readable.
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over a few examples of how you can replace occurrences of a substring in a string, using JavaScript.

In this tutorial, we'll go over examples of how to replace all or a single occurrence(s) of a substring in a string using JavaScript. We'll use the replace(), replaceAll(), split() and join() functions.

Replace Occurrences of a Substring in a String with JavaScript

Replace Occurrences of a Substring in String with JavaScript

<h2 id="introduction">Introduction</h2>
Facial detection is a powerful and common use-case of Machine Learning. It can be used to automate routine tasks such as tracking school attendance, assist law enforcement, secure devices through biometric authentication, and even power fun experiences like <a target="_blank" rel="noopener noreferrer" href="https://www.banuba.com/tint-makeup-virtual-try-on">virtual makeup try-ons</a> that track facial features in real time.
In this article, we'll perform facial detection in Python, using OpenCV.
<h2 id="opencv">OpenCV</h2>
OpenCV is one of the most popular computer vision libraries. It was written in C and C++ and also provides support for Python, besides Java and MATLAB. While it's not the fastest library out there, it's easy to work with and provides a high-level interface, allowing developers to write stable code.
Let's install OpenCV so that we can use it in our Python code:
<pre><code class="hljs">$ pip install opencv-contrib-python
</code></pre>
Alternatively, you can install <code>opencv-python</code> for just the main modules of OpenCV. The <code>opencv-contrib-python</code> contains the main modules as well as the contrib modules which provide extended functionality.
<h2 id="detectingfacesinanimageusingopencv">Detecting Faces in an Image Using OpenCV</h2>
With OpenCV installed, we can import it as <code>cv2</code> in our code.
To read an image in, we will use the <code>imread()</code> function, along with the path to the image we want to process. The <code>imread()</code> function simply loads the image from the specified file in an <code>ndarray</code>. If the image could not be read, for example in case of a missing file or an unsupported format, the function will return <code>None</code>.
We will be using an image from <a rel='nofollow noopener' target='_blank' href='https://www.kaggle.com/mksaad/wider-face-a-face-detection-benchmark'>Kaggle dataset</a>:
<pre><code class="hljs">import cv2

path_to_image = &#x27;Parade_12.jpg&#x27;
original_image = cv2.imread(path_to_image)
</code></pre>
The full RGB information isn't necessary for facial detection. The color holds a lot of irrelevant information on the image, so it's more efficient to just remove it and work with a grayscale image. Additionally, the Viola-Jones algorithm, which works under the hood with OpenCV, checks the difference in intensity of an image's area. Grayscale images point this difference out more dramatically.
Note: In the case of color images, the decoded images will have the channels stored in BGR order, so when changing them to grayscale, we need to use the <code>cv2.COLOR_BGR2GRAY</code> flag:
<pre><code class="hljs">image = cv2.cvtColor(original_image, cv2.COLOR_BGR2GRAY)
</code></pre>
This could have been done directly when using <code>imread()</code>, by setting the <code>cv2.IMREAD_GRAYSCALE</code> flag:
<pre><code class="hljs">original_image = cv2.imread(path_to_image, cv2.IMREAD_GRAYSCALE)
</code></pre>
The OpenCV library comes with several pre-trained classifiers that are trained to find different things, like faces, eyes, smiles, upper bodies, etc.
The <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Haar-like_feature">Haar</a> features for detecting these objects are stored as XML, and depending on how you installed OpenCV, can most often be found in <code>Lib\site-packages\cv2\data</code>. They can also be found in the <a rel='nofollow noopener' target='_blank' href='https://github.com/opencv/opencv/tree/master/data/haarcascades'>OpenCV GitHub repository</a>.
In order to access them from code, you can use a <code>cv2.data.haarcascades</code> and add the name of the XML file you'd like to use.
We can choose which Haar features we want to use for our object detection, by adding the file path to the <code>CascadeClassifier()</code> constructor, which uses pre-trained models for object detection:
<pre><code class="hljs">face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + &quot;haarcascade_frontalface_default.xml&quot;)
</code></pre>
Now, we can use this <code>face_cascade</code> object to detect faces in the Image:
<pre><code class="hljs">detected_faces = face_cascade.detectMultiScale(image=image, scaleFactor=1.3, minNeighbors=4)
</code></pre>
When object detection models are trained, they are trained to detect faces of a certain size and might miss faces that are bigger or smaller than they expect. With this in mind, the image is resized several times in the hopes that a face will end up being a &quot;detectable&quot; size. The <code>scaleFactor</code> lets OpenCV know how much to scale the images. In our case, <code>1.3</code> means that it can scale <code>30%</code> down to try and match the faces better.
As for the <code>minNeighbors</code> parameter, it's used to control the number of false positives and false negatives. It defines the minimum number of positive rectangles (detect facial features) that need to be adjacent to a positive rectangle in order for it to be considered actually positive. If <code>minNeighbors</code> is set to <code>0</code>, the slightest hint of a face will be counted as a definitive face, even if no other facial features are detected near it.
Both the <code>scaleFactor</code> and <code>minNeighbors</code> parameters are somewhat arbitrary and set experimentally. We have chosen values that worked well for us, and gave no false positives, with the trade-off of more false negatives (undetected faces).
The <code>detectMultiScale()</code> method returns a list of rectangles of all the detected objects (faces in our first case). Each element in the list represents a unique face. This list contains tuples, <code>(x, y, w, h)</code>, where the <code>x, y</code> values represent the top-left coordinates of the rectangle, while the <code>w, h</code> values represent the width and height of the rectangle, respectively.
We can use the returned list of rectangles, and use the <code>cv2.rectangle()</code> function to easily draw the rectangles where a face was detected. Keep in mind that the color provided needs to be a tuple in RGB order:
<pre><code class="hljs">for (x, y, width, height) in detected_faces:
 cv2.rectangle(
 image,
 (x, y),
 (x + width, y + height),
 color,
 thickness=2
 )
</code></pre>
Now, let's put that all together:
<pre><code class="hljs">import cv2

def draw_found_faces(detected, image, color: tuple):
 for (x, y, width, height) in detected:
 cv2.rectangle(
 image,
 (x, y),
 (x + width, y + height),
 color,
 thickness=2
 )

path_to_image = &#x27;Parade_12.jpg&#x27;
original_image = cv2.imread(path_to_image)

if original_image is not None:
 # Convert image to grayscale
 image = cv2.cvtColor(original_image, cv2.COLOR_BGR2GRAY)

 # Create Cascade Classifiers
 face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + &quot;haarcascade_frontalface_default.xml&quot;)
 profile_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + &quot;haarcascade_profileface.xml&quot;)
 
 # Detect faces using the classifiers
 detected_faces = face_cascade.detectMultiScale(image=image, scaleFactor=1.3, minNeighbors=4)
 detected_profiles = profile_cascade.detectMultiScale(image=image, scaleFactor=1.3, minNeighbors=4)

 # Filter out profiles
 profiles_not_faces = [x for x in detected_profiles if x not in detected_faces]

 # Draw rectangles around faces on the original, colored image
 draw_found_faces(detected_faces, original_image, (0, 255, 0)) # RGB - green
 draw_found_faces(detected_profiles, original_image, (0, 0, 255)) # RGB - red

 # Open a window to display the results
 cv2.imshow(f&#x27;Detected Faces in {path_to_image}&#x27;, original_image)
 # The window will close as soon as any key is pressed (not a mouse click)
 cv2.waitKey(0) 
 cv2.destroyAllWindows()
else:
 print(f&#x27;En error occurred while trying to load {path_to_image}&#x27;)
</code></pre>
We used two different models on this picture. The default model for detecting front-facing faces, and a model built to better detect faces looking to the side.
Faces detected with the <code>frontalface</code> model are outlined in green, and faces detected with the <code>profileface</code> model are outlined with red. Most of the faces the first model found would have also been found by the second, so we only drew red rectangles where the <code>profileface</code> model detected a face but <code>frontalface</code> didn't:
<pre><code class="hljs">profiles_not_faces = [x for x in detected_profiles if x not in detected_faces]
</code></pre>
The <code>imshow()</code> method simply shows the passed image in a window with the provided title. With the picture we selected, this would provide the following output:
<img src="https://stackabuse.s3.amazonaws.com/media/facial-detection-in-python-with-opencv-1.png" alt="frontal and profile face detection">
Using different values for <code>scaleFactor</code> and <code>minNeighbors</code> will give us different results. For example, using <code>scaleFactor = 1.1</code> and <code>minNeighbors = 4</code> gives us more false positives and true positives with both models:
<img src="https://stackabuse.s3.amazonaws.com/media/facial-detection-in-python-with-opencv-4.png" alt="face detection lower scale factor">
We can see that the algorithm isn't perfect, but it is very efficient. This is most notable when working with real-time data, such as a video feed from a webcam.
<h2 id="realtimefacedetectionusingawebcam">Real-Time Face Detection Using a Webcam</h2>
Video streams are simply streams of images. With the efficiency of the Viola-Jones algorithm, we can do face detection in real-time.
The steps we need to take are very similar to the previous example with only one image - we'll be performing this on each image in the stream.
To get the video stream, we'll use the <code>cv2.VideoCapture</code> class. The constructor for this class takes an integer parameter representing the video stream. On most machines, the webcam can be accessed by passing <code>0</code>, but on machines with several video streams, you might need to try out different values.
Next, we need to read individual images from the input stream. This is done with the <code>read()</code> function, which returns <code>retval</code> and <code>image</code>. The <code>image</code> is simply the retrieved frame. The <code>retval</code> return value is used to detect whether a frame has been retrieved or not, and will be <code>False</code> if it hasn't.
However, it tends to be inconsistent with video input streams (doesn't detect that the webcam has been disconnected, for example), so we will be ignoring this value.
Let's go ahead and modify the previous code to handle a video stream:
<pre><code class="hljs">import cv2

def draw_found_faces(detected, image, color: tuple):
 for (x, y, width, height) in detected:
 cv2.rectangle(
 image,
 (x, y),
 (x + width, y + height),
 color,
 thickness=2
 )

# Capturing the Video Stream
video_capture = cv2.VideoCapture(0)

# Creating the cascade objects
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + &quot;haarcascade_frontalface_default.xml&quot;)
eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + &quot;haarcascade_eye_tree_eyeglasses.xml&quot;)

while True:
 # Get individual frame
 _, frame = video_capture.read()
 # Covert the frame to grayscale
 grayscale_image = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
 
 # Detect all the faces in that frame
 detected_faces = face_cascade.detectMultiScale(image=grayscale_image, scaleFactor=1.3, minNeighbors=4)
 detected_eyes = eye_cascade.detectMultiScale(image=grayscale_image, scaleFactor=1.3, minNeighbors=4)
 draw_found_faces(detected_faces, frame, (0, 0, 255))
 draw_found_faces(detected_eyes, frame, (0, 255, 0))

 # Display the updated frame as a video stream
 cv2.imshow(&#x27;Webcam Face Detection&#x27;, frame)

 # Press the ESC key to exit the loop
 # 27 is the code for the ESC key
 if cv2.waitKey(1) == 27:
 break

# Releasing the webcam resource
video_capture.release()

# Destroy the window that was showing the video stream
cv2.destroyAllWindows()
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've created a facial detection application using Python and OpenCV.
Using the OpenCV library is very straight-forward for basic object detection programs. Experimentally adjusting the <code>scaleFactor</code> and <code>minNeighbors</code> parameters for the types of images you'd like to process can give pretty accurate results very efficiently.

In this article, we'll perform facial detection on images and a live webcam using Python and OpenCV.