The Branding Store | Logo Design, Web Design and E-commerce specialists.| Pembroke Pines, Florida. | Getting Archives - Page 3 of 6 - The Branding Store | Logo Design, Web Design and E-commerce specialists.| Pembroke Pines, Florida.

10 Feb

Getting The Most Out Of Git

by TBSCategories: News

Not a single project today will get away without some sort of version control with Git under the hood. Knowing Git well helps you become a better developer, boost your developer’s workflow and truly improve the quality of your code base. However, that requires going a little bit outside of the comfort zone that we are all familiar with. As it turns out, there is a bit more to Git than just commit, push and pull.

Some developers stay true to the main principles in Git, and often that’s absolutely understandable. In the front-end world of ours, there are just so many sophisticated things to understand and get better at, that frankly Git is often not a high priority. As a side effect, many of the valuable techniques that can boost a developer’s workflow remain unnoticed and rarely discovered.

In this article, we’ll explore four advanced Git tools, and hopefully, whet your appetite to learn even more about Git!

Recovering Deleted Commits

You’re convinced that you’ve programmed yourself into a dead end because your last two commits lead nowhere! Understandably, you might want to undo them and start over.

Here’s one way to do this:

$   git reset --hard 2b504be

But let’s also say that, moments later, you notice that you made a mistake: actually, the commits contained important data and you just lost valuable work! 😱

Your heart starts pumping, the sweat starts running — you know the drill. 🤯

Now, the million-dollar question is: How can we get those seemingly deleted commits back? Luckily, there is an answer: the “Reflog”!

Using the Reflog to Recover Lost States

You can think of the Reflog as Git’s “diary”: it’s the place where Git protocols every movement of the HEAD pointer. Or, in other words: all of the more interesting actions like when you commit, merge, checkout, rebase, cherry-pick and others. This, of course, makes it a perfect tool for those inevitable situations when things go wrong.

Let’s open the Reflog for our example scenario and see how it can help us:

$   git reflog

The first and most important thing to know about the Reflog is that it’s ordered chronologically. And indeed: the topmost (in other words: newest) item is our mishap when we had hastily used git reset and lost some commits.

The solution to fix our problem is pretty easy: we can simply return to the state before the mistake. And that state is clearly protocoled in the Reflog, right below our fatal reset command. To undo our mistake, we can simply use git reset once more to recover this seemingly lost state:

$   git reset e5b19e4

You can also accomplish the same result a little bit faster. As a group of friendly and passionate developers on “Tower” Git desktop GUI, we’ve been aiming to resolve common pain points around Git heads-on. So in our little tool, you can achieve the same results by simply hitting CMD + Z — as if you wanted to correct a simple typo in your text editor. In fact, the same hotkey is available for a family of different actions, e.g. when you’ve wrongfully deleted a branch, made a mistake with a merge operation, or committed something on the wrong branch.

to correct this mistake, we’ll initiate an Interactive Rebase session, starting at the faulty commit’s parent revision:

git rebase -i 2b504be

An editor window will then open and allow us to manipulate the selected part of our commit history:

In our case, since we want to delete a commit, we simply mark up the respective line in the editor with the drop action keyword. Once we hit “Save” in our editor and close the window, the Interactive Rebase is completed — and the unwanted commit will have disappeared!

(Just a quick note: again, if you’re using a desktop GUI like Tower, you can take a shortcut: simply right-click the unwanted commit and select the “Delete…” option from the contextual menu.)

As mentioned above, Interactive Rebase has a lot more use cases to offer! If you’d like to learn more about Interactive Rebase and what it can do, take a look at the free “First Aid Kit for Git”: a collection of short, helpful, and free videos, all around undoing mistakes with Git.

Using Submodules To Manage Third-Party Code

In today’s complex software world, there’s hardly a project that doesn’t include code from other sources: a module or library from a third party or even from your own team. Managing these modules in an elegant, pragmatic way greatly helps to reduce headaches!

In theory, you could simply copy and paste the necessary code files into your project and then commit them to your code base. But this comes with a couple of downsides. Most importantly, you’ll have a very hard time updating third-party code when new versions become available. You’d have to download the code again and copy-paste it — again and again.

Additionally, it’s considered bad practice if you squeeze multiple projects (your actual project and all the third-party libraries you might need) into a single Git repository. This mixes external code with our own, unique project files.

A much better way to do this is to use Git’s “Submodule” structure: this allows you to include third-party code simply as a Git repository inside your actual project’s Git repository. This means that all code bases remain neatly separated.

Including a third-party module / library is as easy as executing the following Git command:

$   git submodule add https://github.com/djyde/ToProgress

This command will download a clone of the specified Git repository into your project. You’ll be left with a fully-functional, nicely separated Git repository of your third-party code. Tidy, clean and flexible.

Submodules, admittedly, are quite a complex topic when it comes to handling them in practice. If you want to understand them a bit more thoroughly, check out the “Submodules” chapter of the free “Learn Version Control with Git” online book.

Composing Commits With Precision

There’s a golden rule in version control: a commit should only contain changes from a single issue! When you stick to this rule, you will create commits that are easy to understand. When you don’t — when multiple issues and topics get crammed into the same commit — you will inflict chaos on your code base in almost no time.

In practice, this means that you create separate commits for each and every topic. Even if it’s just a small bug fix where you’re changing only a semicolon: it’s a topic of its own, so it gets a commit of its own!

But in the messy real world, we often don’t work at only one topic at a time. Or we think we do, and only later discover that our code from the last three hours actually involves three different topics. This trickles down to individual files: often, the changes in a single file belong to multiple topics.

That’s when adding a complete file to the next commit isn’t the best strategy anymore.

Staging Selected Parts of Your Changed Files

In the example case below, you can see that we currently have two chunks (= parts or areas) of modifications in our file imprint.html:

Let’s say that the first chunk belongs to one topic (maybe we’re in the process of unifying and cleaning up all page titles in our project). And let’s also say that the second chunk belongs to another, completely unrelated topic.

A simple git add imprint.html, i.e. adding the whole file to Staging, would cram all of its changes into the same commit. Our colleagues, then, would have a hard time understanding what this particular commit was really about. Seeing some titles being changed, they might think it was only about the “title clean-up project”, but they might very well overlook the other changes.

Luckily, Git allows us to precisely select the chunks we want to put into the next commit! All we have to do is add the -p flag to our git add command:

$   git add -p imprint.html

Git now takes us by the hand and walks us through each and every chunk of changes in that file. And for each one, it asks us a simple question: “Stage this chunk?”

Let’s type Y (for “Yes”) for the first one and N for the second one. When we then actually make our commit, only the first chunk of changes will be included. The second one remains as an uncommitted local change in our working copy for a later, separate commit.

If you’re using Git in a desktop GUI, you might be able to do this right through the interface:

Becoming More Productive with Git

This short article was just a short glimpse into some of the advanced features in Git. But I sincerely hope it shows that Git has so many powerful features under the hood! From Interactive Rebase to Submodules and from the Reflog to File History, it pays to learn these advanced features because they help you become more productive and make fewer mistakes.

If you want to dive deeper, here are some helpful (and free) resources:

Git Cheat Sheet
If you want to keep the most important commands at hand, the “Git Cheat Sheet” might be for you. Available in English, German, Spanish, Portuguese, Arabic and Chinese.
Undoing Mistakes
Git is a perfect safety net for when things go wrong. Learning about the different “undo” features in Git is time well spent for any developer. The “First Aid Kit for Git”, a collection of short videos, provides a great introduction.

Have fun becoming a better developer!

Articles on Smashing Magazine — For Web Designers And Developers

10 Feb

Getting The Most Out Of Git

by TBSCategories: News

In this article, we’ll explore four advanced Git tools, and hopefully, whet your appetite to learn even more about Git!

Recovering Deleted Commits

You’re convinced that you’ve programmed yourself into a dead end because your last two commits lead nowhere! Understandably, you might want to undo them and start over.

Here’s one way to do this:

$   git reset --hard 2b504be

But let’s also say that, moments later, you notice that you made a mistake: actually, the commits contained important data and you just lost valuable work! 😱

Your heart starts pumping, the sweat starts running — you know the drill. 🤯

Now, the million-dollar question is: How can we get those seemingly deleted commits back? Luckily, there is an answer: the “Reflog”!

Using the Reflog to Recover Lost States

Let’s open the Reflog for our example scenario and see how it can help us:

$   git reflog

$   git reset e5b19e4

to correct this mistake, we’ll initiate an Interactive Rebase session, starting at the faulty commit’s parent revision:

git rebase -i 2b504be

An editor window will then open and allow us to manipulate the selected part of our commit history:

(Just a quick note: again, if you’re using a desktop GUI like Tower, you can take a shortcut: simply right-click the unwanted commit and select the “Delete…” option from the contextual menu.)

Using Submodules To Manage Third-Party Code

Including a third-party module / library is as easy as executing the following Git command:

$   git submodule add https://github.com/djyde/ToProgress

Composing Commits With Precision

That’s when adding a complete file to the next commit isn’t the best strategy anymore.

Staging Selected Parts of Your Changed Files

In the example case below, you can see that we currently have two chunks (= parts or areas) of modifications in our file imprint.html:

Luckily, Git allows us to precisely select the chunks we want to put into the next commit! All we have to do is add the -p flag to our git add command:

$   git add -p imprint.html

Git now takes us by the hand and walks us through each and every chunk of changes in that file. And for each one, it asks us a simple question: “Stage this chunk?”

If you’re using Git in a desktop GUI, you might be able to do this right through the interface:

Becoming More Productive with Git

If you want to dive deeper, here are some helpful (and free) resources:

Git Cheat Sheet
If you want to keep the most important commands at hand, the “Git Cheat Sheet” might be for you. Available in English, German, Spanish, Portuguese, Arabic and Chinese.
Undoing Mistakes
Git is a perfect safety net for when things go wrong. Learning about the different “undo” features in Git is time well spent for any developer. The “First Aid Kit for Git”, a collection of short videos, provides a great introduction.

Have fun becoming a better developer!

Articles on Smashing Magazine — For Web Designers And Developers

10 Feb

Getting The Most Out Of Git

by TBSCategories: News

In this article, we’ll explore four advanced Git tools, and hopefully, whet your appetite to learn even more about Git!

Recovering Deleted Commits

You’re convinced that you’ve programmed yourself into a dead end because your last two commits lead nowhere! Understandably, you might want to undo them and start over.

Here’s one way to do this:

$   git reset --hard 2b504be

But let’s also say that, moments later, you notice that you made a mistake: actually, the commits contained important data and you just lost valuable work! 😱

Your heart starts pumping, the sweat starts running — you know the drill. 🤯

Now, the million-dollar question is: How can we get those seemingly deleted commits back? Luckily, there is an answer: the “Reflog”!

Using the Reflog to Recover Lost States

Let’s open the Reflog for our example scenario and see how it can help us:

$   git reflog

$   git reset e5b19e4

to correct this mistake, we’ll initiate an Interactive Rebase session, starting at the faulty commit’s parent revision:

git rebase -i 2b504be

An editor window will then open and allow us to manipulate the selected part of our commit history:

(Just a quick note: again, if you’re using a desktop GUI like Tower, you can take a shortcut: simply right-click the unwanted commit and select the “Delete…” option from the contextual menu.)

Using Submodules To Manage Third-Party Code

Including a third-party module / library is as easy as executing the following Git command:

$   git submodule add https://github.com/djyde/ToProgress

Composing Commits With Precision

That’s when adding a complete file to the next commit isn’t the best strategy anymore.

Staging Selected Parts of Your Changed Files

In the example case below, you can see that we currently have two chunks (= parts or areas) of modifications in our file imprint.html:

Luckily, Git allows us to precisely select the chunks we want to put into the next commit! All we have to do is add the -p flag to our git add command:

$   git add -p imprint.html

Git now takes us by the hand and walks us through each and every chunk of changes in that file. And for each one, it asks us a simple question: “Stage this chunk?”

If you’re using Git in a desktop GUI, you might be able to do this right through the interface:

Becoming More Productive with Git

If you want to dive deeper, here are some helpful (and free) resources:

Git Cheat Sheet
If you want to keep the most important commands at hand, the “Git Cheat Sheet” might be for you. Available in English, German, Spanish, Portuguese, Arabic and Chinese.
Undoing Mistakes
Git is a perfect safety net for when things go wrong. Learning about the different “undo” features in Git is time well spent for any developer. The “First Aid Kit for Git”, a collection of short videos, provides a great introduction.

Have fun becoming a better developer!

Articles on Smashing Magazine — For Web Designers And Developers

09 Feb

Getting The Most Out Of Git

by TBSCategories: News

In this article, we’ll explore four advanced Git tools, and hopefully, whet your appetite to learn even more about Git!

Recovering Deleted Commits

You’re convinced that you’ve programmed yourself into a dead end because your last two commits lead nowhere! Understandably, you might want to undo them and start over.

Here’s one way to do this:

$   git reset --hard 2b504be

But let’s also say that, moments later, you notice that you made a mistake: actually, the commits contained important data and you just lost valuable work! 😱

Your heart starts pumping, the sweat starts running — you know the drill. 🤯

Now, the million-dollar question is: How can we get those seemingly deleted commits back? Luckily, there is an answer: the “Reflog”!

Using the Reflog to Recover Lost States

Let’s open the Reflog for our example scenario and see how it can help us:

$   git reflog

$   git reset e5b19e4

to correct this mistake, we’ll initiate an Interactive Rebase session, starting at the faulty commit’s parent revision:

git rebase -i 2b504be

An editor window will then open and allow us to manipulate the selected part of our commit history:

(Just a quick note: again, if you’re using a desktop GUI like Tower, you can take a shortcut: simply right-click the unwanted commit and select the “Delete…” option from the contextual menu.)

Using Submodules To Manage Third-Party Code

Including a third-party module / library is as easy as executing the following Git command:

$   git submodule add https://github.com/djyde/ToProgress

Composing Commits With Precision

That’s when adding a complete file to the next commit isn’t the best strategy anymore.

Staging Selected Parts of Your Changed Files

In the example case below, you can see that we currently have two chunks (= parts or areas) of modifications in our file imprint.html:

Luckily, Git allows us to precisely select the chunks we want to put into the next commit! All we have to do is add the -p flag to our git add command:

$   git add -p imprint.html

Git now takes us by the hand and walks us through each and every chunk of changes in that file. And for each one, it asks us a simple question: “Stage this chunk?”

If you’re using Git in a desktop GUI, you might be able to do this right through the interface:

Becoming More Productive with Git

If you want to dive deeper, here are some helpful (and free) resources:

Git Cheat Sheet
If you want to keep the most important commands at hand, the “Git Cheat Sheet” might be for you. Available in English, German, Spanish, Portuguese, Arabic and Chinese.
Undoing Mistakes
Git is a perfect safety net for when things go wrong. Learning about the different “undo” features in Git is time well spent for any developer. The “First Aid Kit for Git”, a collection of short videos, provides a great introduction.

Have fun becoming a better developer!

Articles on Smashing Magazine — For Web Designers And Developers

09 Feb

Getting The Most Out Of Git

by TBSCategories: News

In this article, we’ll explore four advanced Git tools, and hopefully, whet your appetite to learn even more about Git!

Recovering Deleted Commits

You’re convinced that you’ve programmed yourself into a dead end because your last two commits lead nowhere! Understandably, you might want to undo them and start over.

Here’s one way to do this:

$   git reset --hard 2b504be

But let’s also say that, moments later, you notice that you made a mistake: actually, the commits contained important data and you just lost valuable work! 😱

Your heart starts pumping, the sweat starts running — you know the drill. 🤯

Now, the million-dollar question is: How can we get those seemingly deleted commits back? Luckily, there is an answer: the “Reflog”!

Using the Reflog to Recover Lost States

Let’s open the Reflog for our example scenario and see how it can help us:

$   git reflog

$   git reset e5b19e4

to correct this mistake, we’ll initiate an Interactive Rebase session, starting at the faulty commit’s parent revision:

git rebase -i 2b504be

An editor window will then open and allow us to manipulate the selected part of our commit history:

(Just a quick note: again, if you’re using a desktop GUI like Tower, you can take a shortcut: simply right-click the unwanted commit and select the “Delete…” option from the contextual menu.)

Using Submodules To Manage Third-Party Code

Including a third-party module / library is as easy as executing the following Git command:

$   git submodule add https://github.com/djyde/ToProgress

Composing Commits With Precision

That’s when adding a complete file to the next commit isn’t the best strategy anymore.

Staging Selected Parts of Your Changed Files

In the example case below, you can see that we currently have two chunks (= parts or areas) of modifications in our file imprint.html:

Luckily, Git allows us to precisely select the chunks we want to put into the next commit! All we have to do is add the -p flag to our git add command:

$   git add -p imprint.html

Git now takes us by the hand and walks us through each and every chunk of changes in that file. And for each one, it asks us a simple question: “Stage this chunk?”

If you’re using Git in a desktop GUI, you might be able to do this right through the interface:

Becoming More Productive with Git

If you want to dive deeper, here are some helpful (and free) resources:

Git Cheat Sheet
If you want to keep the most important commands at hand, the “Git Cheat Sheet” might be for you. Available in English, German, Spanish, Portuguese, Arabic and Chinese.
Undoing Mistakes
Git is a perfect safety net for when things go wrong. Learning about the different “undo” features in Git is time well spent for any developer. The “First Aid Kit for Git”, a collection of short videos, provides a great introduction.

Have fun becoming a better developer!

Articles on Smashing Magazine — For Web Designers And Developers

Deprecated: Function create_function() is deprecated in /home2/thebrand/public_html/wp-content/plugins/wp-spamshield/wp-spamshield.php on line 1884

08 Jan

Getting Started With The GetX Package In Flutter Applications

by TBSCategories: News

Flutter is one of the fastest ways to build truly cross-platform native applications. It provides features allowing the developer to build a truly beautiful UI experience for their users.

However, most times to achieve things like navigating to screens, state management, and show alerts, a lot of boilerplates are needed. These boilerplates tend to slow down the development efficiency of developers trying to go about building features and meeting their deadlines.

Take for example the boilerplate needed to navigate to a screen in a Flutter application. Let’s say you want to navigate to a screen called AboutScreen. you will have to write:

Navigator.push(     context,     MaterialPageRoute(builder: (context) => AboutScreen()),   );

It would be more efficient and developer-friendly to do something like:

Get.to(AboutScreen());

When you need to navigate back to the previous page in Flutter you will have to write:

Navigator.pop(context);

You will notice we are always depending on context property for something as commonplace as navigating between screens. What if instead, we can do something like this:

Get.back();

The above examples are some of the ways where application development in Flutter can be improved to be more intuitive and efficient with less boilerplate. If you favor simplicity and being efficient in building out features and ideas, in Flutter then the Get package will interest you.

What Is GetX

Get or GetX is a fast, stable, extra-light framework for building Flutter applications.

GetX ships out of the box with high-performance state management, intelligent dependency injection, and route management in a simplistic and practical way.

GetX aims to minimize boilerplates while also providing simple and intuitive syntax for developers to use while building their applications. At the core of GetX are these 3 principles:

Performance
GetX focuses on the performance of your application by implementing its features to consume as little resources as possible.
Productivity
GetX wants developers to use its features to be productive as quickly as possible. It does so by employing easy to remember syntax and practices. For example, generally, the developer should be concerned to remove controllers from memory but GetX out of the box provides smart management that monitors controllers in your application and remove them when they are not being used by default.
Organization
GetX allows the decoupling of the View, presentation logic, business logic, dependency injection, and navigation in your Flutter application. You do not need context to navigate between routes, so you are not dependent on the widget tree for navigation. You don’t need context to access your controllers/blocs through an inheritedWidget, so you can completely decouple your presentation logic and business logic from your view layer. You do not need to inject your Controllers/Models/Blocs classes into your widget tree through multiproviders, for this GetX uses its own dependency injection feature, decoupling the DI from its view completely.

Features Of GetX

GetX comes with a couple of features you will need in your daily app development in Flutter. Let’s look at them:

State Management

One of the flagship features of GetX is its intuitive state management feature. State management in GetX can be achieved with little or no boilerplate.

Route Management

GetX provides API for navigating within the Flutter application. This API is simple and with less code needed.

Dependency Management

GetX provides a smart way to manage dependencies in your Flutter application like the view controllers. GetX will remove any controller not being used at the moment from memory. This was a task you as the developer will have to do manually but GetX does that for you automatically out of the box.

Internationalization

GetX provides i18n out of the box allowing you to write applications with various language support.

Validation

GetX provides validation methods for performing input validation in your Flutter applications. This is quite convenient as you wouldn’t need to install a separate validation package.

Storage

GetX provides a fast, extra light, and synchronous key-value in memory, which backs up data to disk at each operation. It is written entirely in Dart and easily integrates with the core GetX package.

Getting Started With GetX

Now that you have seen what GetX is and the features and benefits it provides, let’s see how to set it up in your application. We will build a demo app to see most of the features we have mentioned in action. Let’s get started.

Create A Brand New Flutter Application

We will get started by creating a brand new Flutter application through the Flutter CLI. I am assuming your machine is already set up for application development with Flutter. So we run:

flutter create getx_demo

This will generate the basic code needed for a Flutter application. Next, open up the project you just created in your editor of choice (We will be using VS Code for this article). We will then run the project to make sure it’s working alright (Make sure you have either a device connected or an emulator/simulator running).

When the application runs, you will see the default counter application that Flutter scaffold for you when you create a new Flutter application. What we are going to do is to implement the very same counter application but with GetX to manage the state of the app (which is the count variable).

We will start with clearing main.dart and leaving only this snippet of code:

# main.dart import 'package:flutter/material.dart';  void main() {   runApp(MyApp()); }  class MyApp extends StatelessWidget {   // This widget is the root of your application.   @override   Widget build(BuildContext context) {     return MaterialApp(       title: 'Flutter Demo',       theme: ThemeData(         primarySwatch: Colors.blue,         visualDensity: VisualDensity.adaptivePlatformDensity,       ),       home: MyHomePage(title: 'Flutter Demo Home Page'),     );   } }

By now our application would have been broken since there is no MyHomePage widget anymore. Let’s fix that. With GetX, we don’t need stateful widgets and also our UI can be clearly separated from our business logic. So we will create two directories inside lib/. These directories are:

`views/`	To hold the screens in our application.
`controllers/`	To hold all controllers for the screens in our application.

Let’s create MyHomePage widget inside views/. The name of the file will be my_home_page.dart. After you create it, add the following code snippet to it:

import 'package:flutter/material.dart';  class MyHomePage extends StatelessWidget {   final String title;    MyHomePage({this.title});   @override   Widget build(BuildContext context) {     return Scaffold(       appBar: AppBar(         title: Text(title),       ),       body: Center(         child: Column(           mainAxisAlignment: MainAxisAlignment.center,           children: <Widget>[             Text(               'You have pushed the button this many times:',             ),             Text(               '0',               style: Theme.of(context).textTheme.headline4,             ),           ],         ),       ),       floatingActionButton: FloatingActionButton(         onPressed: null,         tooltip: 'Increment',         child: Icon(Icons.add),       ),     );   } }

Now we have the MyHomePage widget, let’s import it in main.dart. Add the import statement to the top of main.dart below import 'package:flutter/material.dart';

import './views/my_home_page.dart';

Now your main.dart file should look like this:

import 'package:flutter/material.dart'; import './views/my_home_page.dart';  void main() {   runApp(MyApp()); }  class MyApp extends StatelessWidget {   // This widget is the root of your application.   @override   Widget build(BuildContext context) {     return MaterialApp(       title: 'Flutter Demo',       theme: ThemeData(         primarySwatch: Colors.blue,         visualDensity: VisualDensity.adaptivePlatformDensity,       ),       home: MyHomePage(title: 'Flutter Demo Home Page'),     );   } }

When you save your application now, all errors should have been fixed and the app will run. But you will notice when you click the button again, the counter won’t be updated. If you look at the views/my_home_page.dart code, you will see we are just hard coding 0 as the value of the Text widget and passing null to the onPressed handler of the button. Let’s bring in GetX to the mix to get the application functional again.

Installing GetX

Head over to the install page for GetX on pub.dev and you will see the line of code to copy to place in your pubspec.yml file to install GetX. As of the time of writing this article, the current version of GetX is 3.23.1. So we will copy the line:

get: ^3.23.1

And then paste it under the dependencies section of our pubspec.yml file. When you save the file, get should be automatically installed for you. Or you can run manually in your terminal.

flutter pub get

The dependencies section of your pubspec.yml file should look like this:

dependencies:   flutter:     sdk: flutter   get: ^3.23.1

`GetxController`

We have mentioned that GetX allows you to separate the UI of your application from the logic. It does this by providing a GetxController class which you can inherit to create controller classes for the views of your application. For our current app, we have one view so we will create a controller for that view. Head over to the controllers/ directory and create a file called my_home_page_controller.dart. This will hold the controller for the MyHomePage view.

After you’ve created the file, first import the GetX package by adding this to the top of the file:

import 'package:get/get.dart';

Then you will create a class called MyHomePageController inside it and extend the GetxController class. This is how the file should look like:

import 'package:get/get.dart';  class MyHomePageController extends GetxController {}

let’s add the count state to the class we’ve created.

final count = 0;

In GetX, to make a variable observable — this means that when it changes, other parts of our application depending on it will be notified. To do this we simply need to add .obs to the variable initialization. So for our above count variable, we will add .obs to 0. So the above declaration will now look like this:

final count = 0.obs;

This is how our controller file looks like at the moment:

import 'package:get/get.dart';  class MyHomePageController extends GetxController {   final count = 0.obs; }

To wrap things up with the MyHomePageController we will implement the increment method. This is the snippet to do that:

increment() => count.value++;

You will notice we needed to add .value to the count variable to increment it. We did this because adding .obs to a variable makes it an observable variable and to get the value of an observable variable, you do so from the value property.

So we are done with the controller. Now when the value of count changes, any part of our application using it will be updated automatically.

We will now head over to our view and let it know about the controller we just created. We will do so by instantiating the controller class using GetX dependency management feature. This will ensure that our controller won’t be in memory when it is no longer needed.

In views/my_home_page.dart import the Get package and also the controller you created like so:

import 'package:get/get.dart'; import '../controllers/my_home_page_controller.dart';

Then inside the MyHomePage class we will instantiate the MyHomePageController:

final MyHomePageController controller = Get.put(MyHomePageController());

Now we have an instance of the MyHomePageController, we can use the state variable as well as the method. So starting with the state, in GetX to mark a part of your UI to be rebuilt when a state variable changes, you will wrap that part with the Obx widget. GetX provides other ways of doing this, but this method is much simpler and cleaner.

For our count application we want the Text widget to be updated with the current count. So we will wrap the Text widget with Obx widget like so:

Obx(() => Text('0',style: Theme.of(context).textTheme.headline4,),)

Next, we will replace the static string 0 with the count variable from the MyHomePageController like so:

Obx(() => Text('$  {controller.count.value}', ,style: Theme.of(context).textTheme.headline4,),)

Lastly, we will call the increment method when the floatingActionButton is pressed like so:

floatingActionButton: FloatingActionButton(         onPressed: controller.increment,         tooltip: 'Increment',         child: Icon(Icons.add),       ),

So overall, our MyHomePage view file should now look like this:

import 'package:flutter/material.dart'; import 'package:get/get.dart'; import '../controllers/my_home_page_controller.dart';  class MyHomePage extends StatelessWidget {   final String title;   final MyHomePageController controller = Get.put(MyHomePageController());   MyHomePage({this.title});   @override   Widget build(BuildContext context) {     return Scaffold(       appBar: AppBar(         title: Text(title),       ),       body: Center(         child: Column(           mainAxisAlignment: MainAxisAlignment.center,           children: <Widget>[             Text(               'You have pushed the button this many times:',             ),             Obx(               () => Text(                 '$  {controller.count.value}',                 style: Theme.of(context).textTheme.headline4,               ),             )           ],         ),       ),       floatingActionButton: FloatingActionButton(         onPressed: controller.increment,         tooltip: 'Increment',         child: Icon(Icons.add),       ),     );   } }

When you save your application or you rerun it, the counter app should be working as it did when we first created the application.

I believe you have seen how intuitive state management is with GetX, we didn’t have to write a lot of boilerplate and this simplicity will be more obvious as your application get complex. You will also notice our view doesn’t hold or maintain any state so it can be a stateless widget. The brain of the view in turn is now a controller class that will hold the state for the view and methods.

Navigation In GetX

We have seen state management in GetX. Let’s now look at how GetX supports Navigation within your application. To activate the Navigation feature of GetX, you only need to make one change in main.dart which is to turn the MaterialApp widget to a GetMaterialApp widget. Let’s do that by first importing Get in the top of main.dart

import 'package:get/get.dart';

Then we make the change to MaterialApp so our main.dart file now look like this:

import 'package:flutter/material.dart'; import 'package:get/get.dart'; import './views/my_home_page.dart';  void main() {   runApp(MyApp()); }  class MyApp extends StatelessWidget {   // This widget is the root of your application.   @override   Widget build(BuildContext context) {     return GetMaterialApp(       title: 'Flutter Demo',       theme: ThemeData(         primarySwatch: Colors.blue,         visualDensity: VisualDensity.adaptivePlatformDensity,       ),       home: MyHomePage(title: 'Flutter Demo Home Page'),     );   } }

Now our app has been set up to support GetX navigation. To test this out we will create another view in views/ directory. We will call this on about_page.dart and it will contain the following code:

import 'package:flutter/material.dart'; import 'package:get/get.dart'; import '../controllers/my_home_page_controller.dart';  class AboutPage extends StatelessWidget {   final MyHomePageController controller = Get.put(MyHomePageController());   @override   Widget build(BuildContext context) {     return Scaffold(       appBar: AppBar(         title: Text('About GetX'),       ),       body: Center(         child: Column(           mainAxisAlignment: MainAxisAlignment.center,           children: <Widget>[             Padding(               padding: const EdgeInsets.all(16.0),               child: Text(                 'GetX is an extra-light and powerful solution for Flutter. It combines high performance state management, intelligent dependency injection, and route management in a quick and practical way.',               ),             ),           ],         ),       ),     );   } }

We will then go over to MyHomePage and add a button that when pressed will navigate us to the AboutPage. Like so. The button should be below the Obx widget. Here it is:

 FlatButton(onPressed: () {}, child: Text('About GetX'))

We will also need to import the AboutPage on top of the MyHomePage file:

import './about_page.dart';

To tell GetX to navigate to the AboutPage all we need is one line of code which is:

Get.to(AboutPage());

Let’s add that to the onPressed callback of the FlatButton widget like so:

 FlatButton(      onPressed: () {        Get.to(AboutPage());               },   child: Text('About GetX'))

When you save your application now, you will now be able to navigate to the AboutPage.

You can also choose to replace the MyHomePage view with the AboutPage so the user won’t be able to navigate back to the previous page by hitting the device back button. This is useful for screens like login screens. To do this, replace the content of the onPressed handler with the below code:

  Get.off(AboutPage());

This will pop the MyHomePage view and replace it with AboutPage.

Now that we can navigate to the AboutPage, I think it won’t be so bad to be able to go back to MyHomePage to do this we will add a button in AboutPage after the Padding widget and in it’s onPressed handler we will make a call to Get.back() to navigate back to the MyHomePage:

 FlatButton(     onPressed: () {         Get.back();     },     child: Text('Go Home') )

Snackbar

In Flutter conventionally to show a Snackbar, you will need to write something like this:

final snackBar = SnackBar(content: Text('Yay! A SnackBar!')); // Find the Scaffold in the widget tree and use it to show a SnackBar. Scaffold.of(context).showSnackBar(snackBar);

You can observe we are still depending on the context property. Let’s see how we can achieve this in GetX. Go into the MyHomePage view and add another FlatButton widget below the last button we added. Here is the snippet for the button:

 FlatButton(       onPressed: () {          // TODO: Implement Snackbar        },       child: Text('Show Snackbar'))

Let’s display the message ‘Yay! Awesome GetX Snackbar’. Inside the onPressed handler function add the below line of code:

 Get.snackbar('GetX Snackbar', 'Yay! Awesome GetX Snackbar');

Run your application and when you click on the “Show Snackbar button” you will see a snackbar on top of your application!

See how we reduced the number of lines needed to show a snackbar in a Flutter application? Let’s do some more customization on the Snackbar; Let’s make it appear at the bottom of the app. Change the code to this:

Get.snackbar('GetX Snackbar', 'Yay! Awesome GetX Snackbar',snackPosition:SnackPosition.BOTTOM, );

Save and run your application and the Snackbar will now appear at the bottom of the application. How about we change the background color of the Snackbar as it is at the moment transparent. We will change it to an amberAccent color from the Colors class in Flutter. Update the code to this:

Get.snackbar('GetX Snackbar', 'Yay! Awesome GetX Snackbar',snackPosition:SnackPosition.BOTTOM, backgroundColor: Colors.amberAccent );

Overall, the button code should look like this:

 FlatButton(                 onPressed: () {                   Get.snackbar('GetX Snackbar', 'Yay! Awesome GetX Snackbar',                       snackPosition: SnackPosition.BOTTOM,                       backgroundColor: Colors.amberAccent);                 },                 child: Text('Show Snackbar'))

Dialog

GetX provides a simple method for creating AlertDialog in Flutter. Let’s see it in action. Create another button below the previous one:

 FlatButton(                 onPressed: () {                  // TODO: Show alert dialog                 },                 child: Text('Show AlertDialog'))

Let’s call GetX to display an alert Dialog:

Get.defaultDialog();

That will show a default Alert Dialog that is dismissable by tapping outside the Dialog. You can see how in one line of code we have a working alert dialog. Let’s customize it a bit. Let’s change the title and the message:

 Get.defaultDialog(                       title: 'GetX Alert', middleText: 'Simple GetX alert');

Save and run your app and you will see the changes when you hit the “Show AlertDialog” button. We can add confirm and Cancel buttons like so:

Get.defaultDialog(                       title: 'GetX Alert',                       middleText: 'Simple GetX alert',                       textConfirm: 'Okay',                       confirmTextColor: Colors.amberAccent,                       textCancel: 'Cancel');

There are a lot of ways to customize the GetX dialog and the API is quite intuitive and simple.

Conclusion

GetX was created to improve the productivity of Flutter developers as they build out features. Instead of having to search for boilerplate needed to do things like state management, navigation management, and more, GetX provides a simple intuitive API to achieve these activities without sacrificing performance. This article introduces you to GetX and how to get started using it in your Flutter applications.

You can find the demo here →

Articles on Smashing Magazine — For Web Designers And Developers

Deprecated: Function create_function() is deprecated in /home2/thebrand/public_html/wp-content/plugins/wp-spamshield/wp-spamshield.php on line 1884

08 Dec

Getting Started With Next.js

by TBSCategories: News

Lately, Next.js has termed itself The React Framework for Production, and with such bold claim comes a bevy of features that it offers to help you take your React websites from zero to production. These features would matter less if Next.js isn’t relatively easy to learn, and while the numerous features might mean more things and nuances to learn, its attempt at simplicity, power, and perhaps success at it is definitely something to have in your arsenal.

As you settle in to learn about Next.js, there are some things you might already be familiar with and you might even be surprised at how it gives you a lot to work with that it might seem almost overwhelming at face value. Next.js is lit for static sites and it has been well-engineered for that purpose. But it also takes it further with its Incremental Static Regeneration that combines well with existing features to make development a soothing experience. But wait, you might ask. Why Next.js?

This tutorial will be beneficial to developers who are looking to get started with Next.js or have already begun but need to fill some knowledge gaps. You do not need to be a pro in React, however, having a working experience with React will come in handy.

But Why Next.js?

Relatively easy to learn.
That’s it. If you’ve written any React at all, you’d find yourself at home with Next.js. It offers you advanced tools and a robust API support, but it doesn’t force you to use them.
Built-in CSS support.
Writing CSS in component-driven frameworks comes with a sacrosanct need for the “cascade”. It’s why you have CSS-in-JS tools, but Next.js comes out of the box with its own offering — styled-jsx, and also supports a bevy of styling methodologies.
Automatic TypeScript support.
If you like to code in TypeScript, with Next.js, you literally have automatic support for TypeScript configuration and compilation.
Multiple data fetching technique.
It supports SSG and/or SSR. You can choose to use one or the other, or both.
File-system routing.
To navigate between one page to another is supported through the file-system of your app. You do not need any special library to handle routing.

There are many more other features, e.g. using experimental ES features like optional-chaining, not importing react everywhere you use JSX, support for APIs like next/head that helps manage the head of your HTML document, and so on. Suffice to say the deeper you go, the more you enjoy, appreciate, and discover many other features.

Requirements For Creating A Next.js App

Creating a Next.js app requires Node.js, and npm (or npx) installed.

To check if you have Node.js installed, run the command in your terminal:

# It should respond with a version number node -v

Ideally, npm (and npx) comes with your Node.js installation. To confirm that you have them installed, run the commands in your terminal:

# Run this. It should respond with a version number npm -v  # Then run this. It should also respond with a version number npx -v

In case any of the commands above fails to respond with a version number, you might want to look into installing Node.js and npm.

If you prefer the yarn package manager instead, you can run install it with the command:

# Installs yarn globally npm i -g yarn

Then confirm the installation with:

# It should also respond with a version number yarn -v

Creating A Next.js App

Getting the requirements above out of the way, creating a Next.js can be done in two ways, the first being the simplest:

With create-next-app, or
Manually

Creating A Next.js App With `create-next-app`

Using create-next-app is simple and straightforward, plus you can also get going with a starter like Next.js with Redux, Next.js with Tailwind CSS, or Next.js with Sanity CMS etc. You can view the full list of starters in the Next.js examples repo.

# Create a new Next.js app with npx npx create-next-app <app-name>  # Create a new Next.js app with npm npm create-next-app <app-name>  # With yarn yarn create next-app <app-name>

If you’re wondering what the difference between npm and npx is, there’s an in-depth article on the npm blog, Introducing npx: an npm package runner.

Creating A Next.js Project Manually

This requires three packages: next, react, and react-dom.

# With npm npm install next react react-dom  # With yarn yarn add next react react-dom

Then add the following scripts to package.json.

"scripts": {   "dev": "next dev",   "start": "next start",   "build": "next build" }

dev starts Next.js in development mode.
start starts Next.js in production mode.
build builds your Next.js app for production.

Folder Structure

One salient thing you might notice after creating a Next.js app is the lean folder structure. You get the bare minimum to run a Next.js app. No more, no less. What you end up with as your app grows is up to you more than it is to the framework.

The only Next.js specific folders are the pages, public, and styles folder.

# other files and folders, .gitignore, package.json... - pages   - api     - hello.js   - _app.js   - index.js - public   - favicon.ico   - vercel.svg - styles   - globals.css   - Home.module.css

Pages

In a Next.js app, pages is one of the Next-specific folders you get. Here are some things you need to know about pages:

Pages are React components
Each file in it is a page and each page is a React component.

 // Location: /pages/homepage.js // <HomePage/> is just a basic React component export default HomePage() {   return <h1>Welcome to Next.js</h1> }

Custom pages
These are special pages prefixed with the underscore, like _app.js.
- _app.js: This is a custom component that resides in the pages folder. Next.js uses this component to initialize pages.
- _document.js: Like _app.js, _document.js is a custom component that Next.js uses to augment your applications <html> and <body> tags. This is necessary because Next.js pages skip the definition of the surrounding document’s markup.
File-based routing system based on pages
Next.js has a file-based routing system where each page automatically becomes a route based on its file name. For example, a page at pages/profile will be located at /profile, and pages/index.js at /.

# Other folders - pages   - index.js # located at /   - profile.js # located at /profile   - dashboard     - index.js # located at /dashboard     - payments.js # located at /dashboard/payments

Routing

Next.js has a file-based routing system based on pages. Every page created automatically becomes a route. For example, pages/books.js will become route /book.

- pages   - index.js # url: /   - books.js # url: /books   - profile.js # url: /profile

Routing has led to libraries like React Router and can be daunting and quite complex because of the sheer number of ways you might see fit to route section of your pages in your Next.js app. Speaking about routing in Next.js is fairly straightforward, for the most part of it, the file-based routing system can be used to define the most common routing patterns.

Index Routes

The pages folder automatically has a page index.js which is automatically routed to the starting point of your application as /. But you can have different index.jss across your pages, but one in each folder. You don’t have to do this but it helps to define the starting point of your routes, and avoid some redundancy in naming. Take this folder structure for example:

- pages   - index.js   - users     - index.js     - [user].js

There are two index routes at / and /users. It is possible to name the index route in the users folder users.js and have it routed to /users/users if that’s readable and convenient for you. Otherwise, you can use the index route to mitigate the redundancy.

Nested Routes

How do you structure your folder to have a route like /dashboard/user/:id.

You need nested folders:

- pages   - index.js   - dashboard     - index.js     - user       - [id].js # dynamic id for each user

You can nest and go deeper as much as you like.

Dynamic Route Segments

The segments of a URL are not always indeterminate. Sometimes you just can’t tell what will be there at development. This is where dynamic route segments come in. In the last example, :id is the dynamic segment in the URL /dashboard/user/:id. The id determines the user that will be on the page currently. If you can think about it, most likely you can create it with the file-system.

The dynamic part can appear anywhere in the nested routes:

- pages   - dashboard     - user       - [id].js           - profile

will give the route /dashboard/user/:id/profile which leads to a profile page of a user with a particular id.

Imagine trying to access a route /news/:category/:category-type/:league/:team where category, category-type, league, and team are dynamic segments. Each segment will be a file, and files can’t be nested. This is where you’d need a catch-all routes where you spread the dynamic parts like:

- pages   - news     - [...id].js

Then you can access the route like /news/sport/football/epl/liverpool.

You might be wondering how to get the dynamic segments in your components. The useRouter hook, exported from next/router is reserved for that purpose and others. It exposes the router object.

import { useRouter } from 'next/router';  export default function Post() {   // useRouter returns the router object   const router = useRouter();    console.log({ router });   return <div> News </div>; }

The dynamic segments are in the query property of the router object, accessed with router.query. If there are no queries, the query property returns an empty object.

Linking Between Pages

Navigating between pages in your apps can be done with the Link component exported by next/link. Say you have the pages:

- pages   - index.js   - profile.js   - settings.js   - users     - index.js     - [user].js

You can Link them like:

import Link from "next/link";  export default function Users({users) {   return (     <div>       <Link href="/">Home</Link>       <Link href="/profile">Profile</Link>       <Link href="/settings">         <a> Settings </a>       </Link>       <Link href="/users">         <a> Settings </a>       </Link>       <Link href="/users/bob">         <a> Settings </a>       </Link>     </div>   ) }

The Link component has a number of acceptable props, href — the URL of the hyperlink — been the only required one. It’s equivalent to the href attribute of the HTML anchor (<a>) element.

Other props include:

Prop	Default value	Description
`as`	Same as `href`	Indicates what to show in the browser URL bar.
`passHref`	false	Forces the `Link` component to pass the `href` prop to its child./td>
`prefetch`	true	Allows Next.js to proactively fetch pages currently in the viewport even before they’re visited for faster page transitions.
`replace`	false	Replaces the current navigation `history` instead of pushing a new URL onto the `history` stack.
`scroll`	true	After navigation, the new page should be scrolled to the top.
`shallow`	false	Update the path of the current page without re-running `getStaticProps`, `getServerSideProps`, or `getInitialProps`, allows the page to have stale data if turned on.

Styling

Next.js comes with three styling methods out of the box, global CSS, CSS Modules, and styled-jsx.

There’s an extensive article about Styling in Next.js that has been covered in Comparing Styling Methods in Next.js

Linting And Formatting

Linting and formatting I suspect is a highly opinionated topic, but empirical metrics show that most people who need it in their JavaScript codebase seem to enjoy the company of ESLint and Prettier. Where the latter ideally formats, the former lints your codebase. I’ve become quite accustomed to Wes Bos’s ESLint and Prettier Setup because it extends eslint-config-airbnb, interpolate prettier formatting through ESLint, includes sensible-defaults that mostly works (for me), and can be overridden if the need arises.

Including it in your Next.js project is fairly straightforward. You can install it globally if you want but we’d be doing so locally.

Run the command below in your terminal.

# This will install all peer dependencies required for the package to work npx install-peerdeps --dev eslint-config-wesbos

Create a .eslintrc file at the root of your Next.js app, alongside the pages, styles and public folder, with the content:

{   "extends": [     "wesbos"   ] }

At this point, you can either lint and format your code manually or you can let your editor take control.

To lint and format manually requires adding two npm scripts lint, and lint:fix.

"scripts": {   "dev": "next dev",   "build": "next build",   "start": "next start"   "lint": "eslint .", # Lints and show you errors and warnings alone   "lint:fix": "eslint . --fix" # Lints and fixes },

If you’re using VSCode and you’d prefer your editor to automatically lint and format you need to first install the ESLint VSCode plugin then add the following commands to your VSCode settings:

# Other setting "editor.formatOnSave": true, "[javascript]": {   "editor.formatOnSave": false }, "[javascriptreact]": {   "editor.formatOnSave": false }, "eslint.alwaysShowStatus": true, "editor.codeActionsOnSave": {   "source.fixAll": true }, "prettier.disableLanguages": ["javascript", "javascriptreact"],

Note: You can learn more on how to make it work with VSCode over here.

As you work along you most likely will need to override some config, for example, I had to turn off the react/jsx-props-no-spreading rule which errors out when JSX props are been spread as in the case of pageProps in the Next.js custom page component, _app.js.

function MyApp({ Component, pageProps }) {   return <Component {...pageProps} />; }

Turning the rule off goes thus:

{   "extends": [     "wesbos"   ],   "rules": {     "react/jsx-props-no-spreading": 0   } }

Static Assets

At some or several points in your Next.js app lifespan, you’re going to need an asset or another. It could be icons, self-hosted fonts, or images, and so on. To Next.js this is otherwise known as Static File Serving and there is a single source of truth, the public folder. The Next.js docs warns: Don’t name the public directory anything else. The name cannot be changed and is the only directory used to serve static assets.

Accessing static files is straightforward. Take the folder structure below for example,

- pages   profile.js - public   - favicon.ico #url /favicon.ico   - assets     - fonts       - font-x.woff2       - font-x.woff # url: /assets/fonts/font-x.woff2     - images       - profile-img.png # url: /assets/images/profile-img.png - styles   - globals.css

You can access the the profile-img.png image from the <Profile/> component:

// <Profile/> is a React component export default function Profile() {   return {       <div className="profile-img__wrap">         <img src="/assets/images/profile-img.png" alt="a big goofy grin" />       </div>   } }

or the fonts in the fonts folder in CSS:

/* styles/globals.css */ @font-face {   font-family: 'font-x';   src: url(/assets/fonts/font-x.woff2) format('woff2'),        url(/assets/fonts/font-x.woff) format('woff'); }

Data Fetching

Data fetching in Next.js is a huge topic that requires some level of undertaken. Here, we’ll discuss the crux. Before we dive in, there’s a precursory need to have an idea of how Next.js renders its pages.

Pre-rendering is a huge part of how Next.js works as well as what makes it fast. By default, Next.js pre-renders every page by generating each page HTML in advance alongside the minimal JavaScript they need to run, through a process known as Hydration.

It is possible albeit impractical for you to turn off JavaScript and still have some parts of your Next.js app render. If you ever do this, consider doing it for mechanical purposes alone to show that Next.js truly Hydrates rendered pages.

That being said, there are two forms of pre-rendering:

Static Generation (SG),
Server-side Rendering (SSR).

The difference between the two lies in when data is been fetched. For SG, data is fetched at build time and reused on every request (which makes it faster because it can be cached), while in SSR, data is fetched on every request.

What they both have in common is that they can be mixed with Client-side Rendering wit fetch, Axios, SWR, React Query etc.

The two forms of pre-rendering isn’t an absolute one-or-the-other case; you can choose to use Static Generation or Server-side Rendering, or you can use a hybrid of both. That is, while some parts of your Next.js app uses Static Generation, another can use SSR.

In both cases, Next.js offers special functions to fetch your data. You can use one of the Traditional Approach to Data Fetching in React or you can use the special functions. It’s advisable to use the special functions, not because they’re supposedly special, nor because they’re aptly named (as you’ll see) but because they give you a centralized and familiar data fetching technique that you can’t go wrong with.

The three special functions are:

getStaticProps — used in SG when your page content depends on external data.
getStaticPaths — used in SG when your page paths depends on external data.
getServerSideProps — used in Server-side Rendering.

`getStaticProps`

getStaticProps is a sibling to getStaticPaths and is used in Static Generation. It’s an async function where you can fetch external data, and return it as a prop to the default component in a page. The data is returned as a props object and implicitly maps to the prop of the default export component on the page.

In the example below, we need to map over the accounts and display them, our page content is dependent on external data as we fetched and resolved in getStaticProps.

// accounts get passed as a prop to <AccountsPage/> from getStaticProps() // Much more like <AccountsPage {...{accounts}} /> export default function AccountsPage({accounts}) {   return (     <div>       <h1>Bank Accounts</h1>       {accounts.map((account) => (         <div key={account.id}>           <p>{account.Description}</p>         </div>       ))}     </div>   ) }  export async function getStaticProps() {   // This is a real endpoint   const res = await fetch('https://sampleapis.com/fakebank/api/Accounts');   const accounts = await res.json();    return {     props: {       accounts: accounts.slice(0, 10),     },   }; }

As you can see, getStaticProps works with Static Generation, and returns a props object, hence the name.

`getStaticPaths`

Similar to getStaticProps, getStaticPaths is used in Static Generation but is different in that it is your page paths that is dynamic not your page content. This is often used with getStaticProps because it doesn’t return any data to your component itself, instead it returns the paths that should be pre-rendered at build time. With the knowledge of the paths, you can then go ahead to fetch their corresponding page content.

Think about Next.js pre-rendering your page in the aspect of a dynamic page with regards to Static Generation. For it to do this successfully at build time, it has to know what the page paths are. But it can’t because they’re dynamic and indeterminate, this is where getStaticPaths comes in.

Imagine you have a Next.js app with pages States and state that shows a list of countries in the United States and a single state respectively. You might have a folder structure that looks like:

- pages   - index.js   - states     - index.js # url: /states     - [id].js # url /states/[id].js

You create the [id].js to show a single state based on their id. So, it the page content (data returned from getStaticProps) will be dependent on the page paths (data returned from getStaticPaths).

Let’s create the <States/> components first.

// The states will be passed as a prop from getStaticProps export default function States({states}) {   // We'll render the states here }  export async function getStaticProps() {   // This is a real endpoint.   const res = await fetch(https://sampleapis.com/the-states/api/the-states);   const states = await res.json();    // We return states as a prop to <States/>   return {     props: {       states     }   }; }

Now let’s create the dynamic page for a single state. It’s the reason we have that [id].js so that we can match the path /states/1, or /states/2 where 1 and 2 are the id in [id].js.

// We start by expecting a state prop from getStaticProps export default function State({ state }) {     // We'll render the states here }  // getStaticProps has a params prop that will expose the name given to the // dynamic path, in this case, id that can be used to fetch each state by id. export async function getStaticProps({ params }) {   const res = await fetch(     https://sampleapis.com/the-states/api/the-states?id=$  {params.id}   );   const state = await res.json();    return {     props: {       state: state[0]     }   }; }

If you try to run the code as it is, you’d get the message: Error: getStaticPaths is required for dynamic SSG pages and is missing for /states/[id].

// The state component // getStaticProps function // getStaticPaths export async function getStaticPaths() {   // Fetch the list of states   const res = await fetch("https://sampleapis.com/the-states/api/the-states");   const states = await res.json();    // Create a path from their ids: /states/1, /states/2 ...   const paths = states.map((state) => /states/$  {state.id});    // Return paths, fallback is necessary, false means unrecognize paths will   // render a 404 page   return { paths, fallback: false }; }

With the paths returned from getStaticPaths, getStaticProps will be made aware and its params props will be populated with necessary values, like the id in this case.

Extras

Absolute Imports

There’s support for absolute import starting from Next.js 9.4 which means you no longer have to import components relatively like:

import FormField from "../../../../../../components/general/forms/formfield"

instead you can do so absolutely like:

import FormField from "components/general/forms/formfield";

To get this to work, you will need a jsconfig.json or tsconfig.json file for JavaScript and TypeScript respectively, with the following content:

{   "compilerOptions": {       "baseUrl": "."   } }

This assumes that the components folder exists at the root of your app, alongside pages, styles, and public.

Experimental ES Features

It is possible to use some experimental features like Nullish coalescing operator (??) and Optional chaining (?.) in your Next.js app.

export default function User({user) {   return <h1>{person?.name?.first ?? 'No name'}</h1> }

Conclusion

According to the Next.js team, many of the goals they set out to accomplish were the ones listed in The 7 principles of Rich Web Applications, and as you work your way in and deep into the ecosystem, you’d realize you’re in safe hands like many other users who have chosen to use Next.js to power their websites/web applications. Give it a try, if you haven’t, and if you have, keep going.

Resources

Articles on Smashing Magazine — For Web Designers And Developers

Deprecated: Function create_function() is deprecated in /home2/thebrand/public_html/wp-content/plugins/wp-spamshield/wp-spamshield.php on line 1884

26 May

Getting Started With Axios In Nuxt

by TBSCategories: News

Getting Started With Axios In Nuxt

Timi Omoyeni

2020-05-26T09:00:00+00:00 2020-05-26T11:08:51+00:00

Nuxt.js provides an Axios module for easy integration with your application. Axios is a promise-based HTTP client that works in the browser and Node.js environment or, in simpler terms, it is a tool for making requests (e.g API calls) in client-side applications and Node.js environment.

In this tutorial, we’re going to learn how to use the Axios module and how to make a request on the server-side using asyncData and fetch. These two methods make a request on the server-side but they have some differences which we’re also going to cover. Finally, we’ll learn how to perform authentication and secure pages/routes using the auth module and auth middleware.

This article requires basic knowledge of Nuxtjs and Vuejs as we’ll be building on top of that. For those without experience with Vuejs, I recommend you start from their official documentation and the Nuxt official page before continuing with this article.

What Is The Nuxt.js Axios Module?

According to the official Documentation,

“It is a Secure and easy Axios integration with Nuxt.js.”

Here are some of its features:

Automatically set base URL for client-side & server-side.
Proxy request headers in SSR (Useful for auth).
Fetch Style requests.
Integrated with Nuxt.js Progressbar while making requests.

To use the axios module in your application, you will have to first install it by using either npm or yarn.

YARN

yarn add @nuxtjs/axios

NPM

npm install @nuxtjs/axios

Add it into your nuxt.config.js file:

modules: [     '@nuxtjs/axios',   ],    axios: {     // extra config e.g     // BaseURL: 'https://link-to-API'   }

The modules array accepts a list of Nuxt.js modules such as dotenv, auth and in this case, Axios. What we’ve done is to inform our application that we would be using the Axios module, which we reference using @nuxtjs/axios. This is then followed by the axios property which is an object of configurations like the baseURL for both client-side and server-side.

Now, you can access Axios from anywhere in your application by calling this.$ axios.method or this.$ axios.$ method. Where method can be get, post, or delete.

Making Your First Request Using Axios

For this tutorial, I’ve put together a simple application on Github. The repository contains two folders, start and finish, the start folder contains all you need to get right into the tutorial. The finish folder contains a completed version of what we would be building.

After cloning the repo and opening the start folder, we would need to install all our packages in the package.json file so open your terminal and run the following command:

npm install

Once that is done, we can start our app using the npm run dev command. This is what you should see when you go to localhost:3000.

Our application’s landing page. (Large preview)

The next thing we have to do is to create a .env file in the root folder of our application and add our API URL to it. For this tutorial, we’ll be using a sample API built to collect reports from users.

API_URL=https://ireporter-endpoint.herokuapp.com/api/v2/

This way, we do not have to hard code our API into our app which is useful for working with two APIs (development and production).

The next step would be to open our nuxt.config.js file and add the environmental variable to our axios config that we added above.

/*    ** Axios module configuration    */   axios: {     // See https://github.com/nuxt-community/axios-module#options     baseURL: process.env.API_URL,   },

Here, we tell Nuxt.js to use this baseURL for both our client-side and server-side requests whenever we use this Axios module.

Now, to fetch a list of reports, let us open the index.vue file and add the following method to the script section.

async getIncidents() {   let res = await this.$ store.dispatch("getIncidents");   this.incidents = res.data.data.incidents; }

What we have done is to create an async function that we call getIncidents() and we can tell what it does from the name — it fetches a list of incidents using the Vuex store action method this.$ store.dispatch. We assign the response from this action to our incidents property so we can be able to make use of it in the component.

We want to call the getIncidents() method whenever the component mounts. We can do that using the mounted hook.

mounted() {     this.getIncidents()   }

mounted() is a lifecycle hook that gets called when the component mounts. That will cause the call to the API to happen when the component mounts. Now, let us go into our index.js file in our store and create this action where we’ll be making our Axios request from.

export const actions = {   async getIncidents() {     let res = await this.$ axios.get('/incidents')     return res;   } }

Here, we created the action called getIncidents which is an async function, then we await a response from the server and return this response. The response from this action is sent back to our getIncidents() method in our index.vue file.

If we refresh our application, we should now be able to see a long list of incidents rendered on the page.

A list of dummy incidents. — List of incidents on landing page. (Large preview)

We have made our first request using Axios but we won’t stop there, we are going to be trying out asyncData and fetch to see the differences between them and using Axios.

AsyncData

AsyncData fetches data on the server-side and it’s called before loading the page component. It does not have access to this because it is called before your page component data is created. this is only available after the created hook has been called so Nuxt.js automatically merges the returned data into the component’s data.

Using asyncData is good for SEO because it fetches your site’s content on the server-side and also helps in loading content faster. Note that asyncData method can only be used in the pages folder of your application as it would not work in the components folder. This is because asyncData hook gets called before your component is created.

An Image showing the Nuxt life cycle. — Image from Nuxt blog. (Large preview)

Let us add asyncData to our index.vue file and observe how fast our incidents data loads. Add the following code after our components property and let us get rid of our mounted hook.

async asyncData({ $ axios }) {     let { data } = await $ axios.get("/incidents");     return { incidents: data.data.incidents };   },   // mounted() {   //   this.getIncidents();   // },

Here, the asyncData method accepts a property from the context $ axios. We use this property to fetch the list of incidents and the value is then returned. This value is automatically injected into our component. Now, you can notice how fast your content loads if you refresh the page and at no time is there no incident to render.

Fetch

The Fetch method is also used to make requests on the server-side. It is called after the created hook in the life cycle which means it has access to the component’s data. Unlike the asyncData method, the fetch method can be used in all .vue files and be used with the Vuex store. This means that if you have the following in your data function.

data() {     return {       incidents: [],       id: 5,       gender: 'male'     }; }

You can easily modify id or gender by calling this.id or this.gender.

Using Axios As A Plugin

During the process of development with Axios, you might find that you need extra configuration like creating instances and interceptors for your request so your application can work as intended and thankfully, we can do that by extending our Axios into a plugin.

To extend axios, you have to create a plugin (e.g. axios.js) in your plugins folder.

export default function ({   $ axios,   store,   redirect }) {   $ axios.onError(error => {     if (error.response && error.response.status === 500) {       redirect('/login')     }   })   $ axios.interceptors.response.use(     response => {       if (response.status === 200) {         if (response.request.responseURL && response.request.responseURL.includes('login')) {           store.dispatch("setUser", response);         }       }       return response     }   ) }

This is an example of a plugin I wrote for a Nuxt application. Here, your function takes in a context object of $ axios, store and redirect which we would use in configuring the plugin. The first thing we do is to listen for an error with a status of 500 using $ axios.onError and redirect the user to the login page.

We also have an interceptor that intercepts every request response we make in our application checks if the status of the response we get is 200. If that is true we proceed and check that there is a response.request.responseURL and if it includes login. If this checks out to be true, we then send this response using our store’s dispatch method where it then mutated in our state.

Add this plugin to your nuxt.config.js file:

plugins: [     '~/plugins/axios'   ]

After doing this, your Axios plugin would intercept any request you make and check if you have defined a special case for it.

Introduction To The Auth Module

The auth module is used for performing authentication for your Nuxt application and can be accessed from anywhere in your application using $ this.auth. It is also available in fetch, asyncData, middleware and NuxtInitServer from the context object as $ auth.

The context provides additional objects/params from Nuxt to Vue components and is available in special nuxt lifecycle areas like those mentioned above.

To use the auth module in your application, you would have to install it using yarn or npm.

YARN

yarn add @nuxtjs/auth

NPM

npm install @nuxtjs/auth

Add it to your nuxt.config.js file.

modules: [   '@nuxtjs/auth' ], auth: {   // Options }

The auth property accepts a list of properties such as strategies and redirect. Here, strategies accepts your preferred authentication method which can be:

local
For username/email and password-based flow.
facebook
For using Facebook accounts as a means of authentication.
Github
For authenticating users with Github accounts.
Google
For authenticating users with Google accounts.
Auth0
Laravel Passport

The redirect property accepts an object of links for:

login
Users would be redirected to this link if login is required.
logout
Users would be redirected here if after logout current route is protected.
home
Users would be redirected here after login.

Now, let us add the following to our nuxt.config.js file.

/*  ** Auth module configuration  */ auth: {   redirect: {     login: '/login',     logout: '/',     home: '/my-reports'   },   strategies: {     local: {       endpoints: {         login: {           url: "/user/login",           method: "post",           propertyName: "data.token",         },         logout: false,         user: false,       },       tokenType: '',       tokenName: 'x-auth',       autoFetchUser: false     },   }, }

Please note that the auth method works best when there is a user endpoint provided in the option above.

Inside the auth config object, we have a redirect option in which we set our login route to /login, logout route to / and home route to /my-reports which would all behave as expected. We also have a tokenType property which represents the Authorization type in the header of our Axios request. It is set to Bearer by default and can be changed to work with your API.

For our API, there is no token type and this is why we’re going to leave it as an empty string. The tokenName represents the Authorization name (or the header property you want to attach your token to) inside your header in your Axios request.

By default, it is set to Authorization but for our API, the Authorization name is x-auth. The autoFetchUser property is used to enable user fetch object using the user endpoint property after login. It is true by default but our API does not have a user endpoint so we have set that to false.

For this tutorial, we would be using the local strategy. In our strategies, we have the local option with endpoints for login, user and logout but in our case, we would only use the *login* option because our demo API does not have a *logout* endpoint and our user object is being returned when *login* is successful.

Note: The auth module does not have a register endpoint option so that means we’re going to register the traditional way and redirect the user to the login page where we will perform the authentication using this.$ auth.loginWith. This is the method used in authenticating your users. It accepts a ‘strategy’ (e.g local) as a first argument and then an object to perform this authentication with. Take a look at the following example.

let data {           email: 'test@test.com',           password: '123456' } this.$ auth.loginWith('local', { data })

Using The Auth Module

Now that we have configured our auth module, we can proceed to our registration page. If you visit the /register page, you should see a registration form.

Register form page — Register page. (Large preview)

Let us make this form functional by adding the following code:

methods: {   async registerUser() {     this.loading = true;     let data = this.register;     try {       await this.$ axios.post("/user/create", data);       this.$ router.push("/login");       this.loading = false;       this.$ notify({         group: "success",         title: "Success!",         text: "Account created successfully"       });     } catch (error) {       this.loading = false;       this.$ notify({         group: "error",         title: "Error!",         text: error.response           ? error.response.data.error           : "Sorry an error occured, check your internet"       });     }   } }

Here, we have an async function called registerUser which is tied to a click event in our template and makes an Axios request wrapped in a try/catch block to an endpoint /user/create. This redirects to the /login page and notifies the user of a successful registration. We also have a catch block that alerts the user of any error if the request is not successful.

If the registration is successful, you would be redirected to the login page.

Login form page — Login page with notification component. (Large preview)

Here, we’re going to make use of auth authentication method this.$ auth.loginWith('local', loginData) after which we would use the this.$ auth.setUser(userObj) to set the user in our auth instance.

To get the login page working, let’s add the following code to our login.vue file.

methods: {   async logIn() {     let data = this.login;     this.loading = true;     try {       let res = await this.$ auth.loginWith("local", {         data       });       this.loading = false;       let user = res.data.data.user;       this.$ auth.setUser(user);       this.$ notify({         group: "success",         title: "Success!",         text: "Welcome!"       });     } catch (error) {       this.loading = false;       this.$ notify({         group: "error",         title: "Error!",         text: error.response           ? error.response.data.error           : "Sorry an error occured, check your internet"       });     }   } }

We created an async function called logIn using the auth method this.$ auth.loginWith('local, loginData). If this login attempt is successful, we then assign the user data to our auth instance using this.$ auth.setUser(userInfo) and redirect the user to the /my-report page.

You can now get user data using this.$ auth.user or with Vuex using this.$ store.state.auth.user but that’s not all. The auth instance contains some other properties which you can see if you log in or check your state using your Vue dev tools.

If you log this.$ store.state.auth to the console, you’ll see this:

{   "auth": {     "user": {       "id": "d7a5efdf-0c29-48aa-9255-be818301d602",       "email": "tmxo@test.com",       "lastName": "Xo",       "firstName": "Tm",       "othernames": null,       "isAdmin": false,       "phoneNumber": null,       "username": null     },     "loggedIn": true,     "strategy": "local",     "busy": false   } }

The auth instance contains a loggedIn property that is useful in switching between authenticated links in the nav/header section of your application. It also contains a strategy method that states the type of strategy the instance is running (e.g local).

Now, we will make use of this loggedIn property to arrange our nav links. Update your navBar component to the following:

<template>   <header class="header">     <div class="logo">       <nuxt-link to="/">         <Logo />       </nuxt-link>     </div>     <nav class="nav">       <div class="nav__user" v-if="auth.loggedIn">         <p>{{ auth.user.email }}</p>         <button class="nav__link nav__link--long">           <nuxt-link to="/report-incident">Report incident</nuxt-link>         </button>         <button class="nav__link nav__link--long">           <nuxt-link to="/my-reports">My Reports</nuxt-link>         </button>         <button class="nav__link" @click.prevent="logOut">Log out</button>       </div>       <button class="nav__link" v-if="!auth.loggedIn">         <nuxt-link to="/login">Login</nuxt-link>       </button>       <button class="nav__link" v-if="!auth.loggedIn">         <nuxt-link to="/register">Register</nuxt-link>       </button>     </nav>   </header> </template> <script> import { mapState } from "vuex"; import Logo from "@/components/Logo"; export default {   name: "nav-bar",   data() {     return {};   },   computed: {     ...mapState(["auth"])   },   methods: {     logOut() {       this.$ store.dispatch("logOut");       this.$ router.push("/login");     }   },   components: {     Logo   } }; </script> <style></style>

In our template section, we have several links to different parts of the application in which we are now using auth.loggedIn to display the appropriate links depending on the authentication status. We have a logout button that has a click event with a logOut() function attached to it. We also display the user’s email gotten from the auth property which is accessed from our Vuex store using the mapState method which maps our state auth to the computed property of the nav component. We also have a logout method that calls our Vuex action logOut and redirects the user to the login page.

Now, let us go ahead and update our store to have a logOut action.

export const actions = {     // ....   logOut() {     this.$ auth.logout();   } }

The logOut action calls the auth logout method which clears user data, deletes tokens from localStorage and sets loggedIn to false.

Routes like /my-reports and report-incident should not be visible to guests but at this point in our app, that is not the case. Nuxt does not have a navigation guard that can protect your routes, but it has is the auth middleware. It gives you the freedom to create your own middleware so you can configure it to work the way you want.

It can be set in two ways:

Per route.
Globally for the whole app in your nuxt.config.js file.

router: {   middleware: ['auth'] }

This auth middleware works with your auth instance so you do not need to create an auth.js file in your middleware folder.

Let us now add this middleware to our my-reports.vue and report-incident.vue files. Add the following lines of code to the script section of each file.

middleware: 'auth'

Now, our application would check if the user trying to access these routes has an auth.loggedIn value of true. It’ll redirect them to the login page using our redirect option in our auth config file — if you’re not logged in and you try to visit either /my-report or report-incident, you would be redirected to /login.

If you go to /report-incidents, this is what you should see.

Form for reporting incidents — Report incident page. (Large preview)

This page is for adding incidents but that right now the form does not send incident to our server because we are not making the call to the server when the user attempts to submit the form. To solve this, we will add a reportIncident method which will be called when the user clicks on Report. We’ll have this in the script section of the component. This method will send the form data to the server. Update your report-incident.vue file with the following:

<template>   <section class="report">     <h1 class="report__heading">Report an Incident</h1>     <form class="report__form">       <div class="input__container">         <label for="title" class="input__label">Title</label>         <input           type="text"           name="title"           id="title"           v-model="incident.title"           class="input__field"           required         />       </div>       <div class="input__container">         <label for="location" class="input__label">Location</label>         <input           type="text"           name="location"           id="location"           v-model="incident.location"           required           class="input__field"         />       </div>       <div class="input__container">         <label for="comment" class="input__label">Comment</label>         <textarea           name="comment"           id="comment"           v-model="incident.comment"           class="input__area"           cols="30"           rows="10"           required         ></textarea>       </div>       <input type="submit" value="Report" class="input__button" @click.prevent="reportIncident" />       <p class="loading__indicator" v-if="loading">Please wait....</p>     </form>   </section> </template> <script> export default {   name: "report-incident",   middleware: "auth",   data() {     return {       loading: false,       incident: {         type: "red-flag",         title: "",         location: "",         comment: ""       }     };   },   methods: {     async reportIncident() {       let data = this.incident;       let formData = new FormData();       formData.append("title", data.title);       formData.append("type", data.type);       formData.append("location", data.location);       formData.append("comment", data.comment);       this.loading = true;       try {         let res = await this.$ store.dispatch("reportIncident", formData);         this.$ notify({           group: "success",           title: "Success",           text: "Incident reported successfully!"         });         this.loading = false;         this.$ router.push("/my-reports");       } catch (error) {         this.loading = false;         this.$ notify({           group: "error",           title: "Error!",           text: error.response             ? error.response.data.error             : "Sorry an error occured, check your internet"         });       }     }   } }; </script> <style> </style>

Here, we have a form with input fields for title, location, and comment with two-way data binding using v-model. We also have a submit button with a click event. In the script section, we have a reportIncident method that collects all the information provided in the form and is sent to our server using FormData because the API is designed to also accept images and videos.

This formData is attached to a Vuex action using the dispatch method, if the request is successful, you get redirected to /my-reports with a notification informing you that this request was successful otherwise, you would be notified of an error with the error message.

At this point, we don’t have reportIncident action in our store yet so in your browser console, you would see an error if you try to click submit on this page.

error message that reads ‘[Vuex] unknown action type: reportIncident' — Vuex error message. (Large preview)

To fix this, add the reportIncident action your index.js file.

    export const actions = {   // ...   async reportIncident({}, data) {     let res = await this.$ axios.post('/incident/create', data)     return res;   } }

Here, we have a reportIncident function that takes in an empty context object and the data we’re sending from our form. This data is then attached to a post request that creates an incident and returns back to our report-incident.vue file.

At this point, you should be able to add a report using the form after which you would be redirected to /my-reports page.

An empty my reports page — My reports page empty. (Large preview)

This page should display a list of incidents created by the user but right now it only shows what we see above, let’s go ahead to fix that.

We’re going to be using the fetch method we learned about to get this list. Update your my-reports.vue file with the following:

<script> import incidentCard from "@/components/incidentCard.vue"; export default {   middleware: "auth",   name: "my-reports",   data() {     return {       incidents: []     };   },   components: {     incidentCard   },   async fetch() {     let { data } = await this.$ axios.get("/user/incidents");     this.incidents = data.data;   } }; </script>

Here, we use fetch method to get user-specific incidents and assign the response to our incidents array.

If you refresh your page after adding an incident, you should see something like this.

My reports page with one report — My Reports page with a report. (Large preview)

At this point, we would notice a difference in how fetch method and asyncData loads our data.

Conclusion

So far, we have learned about the Axios module and all of its features. We have also learned more about asyncData, and how we can fetch both of them together despite their differences. We’ve also learned how to perform authentication in our application using the auth module and how to use the auth middleware to protect our routes. Here are some useful resources that talk more about all we’ve covered.

Getting started with meta tags in Nuxjs.
Using the dotenv module in Nuxt.
Using Fetch in your Nuxt app.
Getting started with asyncData.

Resources

“Auth Module,” NuxtJS.org
“Axios Module: Introduction,” NuxtJS.org
FormData, MDN web docs
“API: The asyncData Method,” NuxtJS.org
“The Vue Instance: Lifecycle Diagram,” VueJS.org
“Understanding How fetch Works In Nuxt 2.12,” NuxtJS.org

(ks, ra, yk, il)

Articles on Smashing Magazine — For Web Designers And Developers

Deprecated: Function create_function() is deprecated in /home2/thebrand/public_html/wp-content/plugins/wp-spamshield/wp-spamshield.php on line 1884

27 Apr

Getting Started With Nuxt

by TBSCategories: News

Getting Started With Nuxt

Timi Omoyeni

2020-04-27T10:30:00+00:00 2020-04-27T16:06:23+00:00

Web developers build a lot of Single Page Applications using JavaScript frameworks (Angular, React, Vue). SPAs dynamically populate the contents of their pages on load which means by the time google crawls their site, the important content is yet to be injected into the site. Part of this problem can be solved by pre-rendering your application’s content. This is where server-side applications come in, and for Vuejs developers, we can build server-side applications using Nuxt.js.

We’re going to assume that you have not used it before, as such it will start from the ground-up — introducing you to Nuxt.js, its file structure and how routing works. While also touching how you can get it to work with Vuex.

At the end of this tutorial, you should be able to go on to build basic web applications in Nuxt.js, and if you have been wondering how to get started with Nuxt.js, this will do justice to that.

This article is targeted at those that are fairly familiar with Vue.js and it’s a concept, For those without knowledge of Vue.js, consider starting from the official Vuejs documentation and The Net Ninja’s Vuejs playlist.

What Is Nuxt.js?

According to their official page:

“Nuxt is a progressive framework based on Vue.js to create modern web applications. It is based on Vue.js official libraries (vue, vue-router and vuex) and powerful development tools (webpack, Babel and PostCSS). Nuxt’s goal is to make web development powerful and performant with great developer experience in mind.”

It allows you to create three types of applications, depending on the purpose it’s intended for:

Static Generated pages (Pre-rendering)
Static generated applications do not require API requests to fetch the contents of the pages, i.e. the contents are already included in the HTML file. An example of a static site is a portfolio website or a landing page for a product.
Single Page Application
Most JavaScript frameworks (React, Angular, Emberjs, Vue, etc) are single page application whose contents are dynamically populated with faster transitions. Most SPAs make use of the HTML5 history API or the location Hash for routing.
Server Side Rendered Applications (SSR)
Server-Side Rendering is a technique used to fetch and display client-side data on the server to send a fully rendered page to the client. This is a good approach to get good SEO for your application.

Creating Your First Nuxt.js Application

You can create a Nuxt.js application in two ways:

Using the scaffolding tool create-nuxt-app.
From scratch.

In case you just want to see the finished app that we would be building, here’s a link to the GitHub repo.

In this tutorial, we would be focused on using create-nuxt-app so let’s get started. If you have npx installed, open your terminal and run this command:

$  npx create-nuxt-app nuxt-tutorial-app

$  yarn create nuxt-app nuxt-tutorial-app

For the purpose of this tutorial, nuxt-tutorial-app is the name of the application but feel free to name yours differently.

This would be followed by a list of options that help in configuring your application with what you might need for development.

Here’s what my configuration looks like:

Nuxt conguration options. (Large preview)

For the purpose of this tutorial, we do not need axios, linting and Prettier configurations.

Once that is done, we’ll run the following command in our terminal:

$  cd nuxt-tutorial-app $  npm run dev

Your app should now be running on http://localhost:3000 and this is what you should see:

Nuxt scaffolding default landing page. (Large preview)

At this point, your app is ready for development.

Understanding Nuxt Folder Structure

Scaffolding the application as we did creates different files and folders which we can start working with. For someone who hasn’t work with Nuxt before, this might throw you off balance. So we’ll be looking at the folders, getting to understand their importance.

Assets
This folder is for un-compiled files such as images, font files, SASS, LESS or JavaScript files. Let us add create a styles folder and a main.css file and copy and paste the following in it.

a {   text-decoration: none;   color: inherit;   cursor: pointer; } .header {   width: 100%;   max-width: 500px;   margin-left: auto;   margin-right: auto;   height: 60px;   top: 0;   position: sticky;   background-color: #fff;   display: flex;   justify-content: space-between;   align-items: center; } .logo {   width: 40%;   max-width: 200px;   height: 40px; } .logo .NuxtLogo {   max-width: 30px;   margin-left: 10px;   max-height: 40px; } .nav {   width: 60%;   height: 40px;   display: flex;   justify-content: space-between;   padding-right: 10px;   max-width: 300px; } .nav__link {   width: 80px;   display: flex;   align-items: center;   border-radius: 4px;   justify-content: center;   height: 100%;   border: 1px solid #00c58e;   cursor: pointer; } .nav__link:active {   background-color: #00c58e;   border: 1px solid #00c58e;   color: #fff;   box-shadow: 5px 3px 5px 2px #3f41468c; } .home {   padding-top: 30px; } .home__heading {   text-align: center; } .directories {   display: flex;   box-sizing: border-box;   padding: 10px;   max-width: 1000px;   margin: 0 auto;   flex-wrap: wrap;   justify-content: center; } @media (min-width: 768px) {   .directories {     justify-content: space-between;   } } .directory__container {   width: 100%;   max-width: 220px;   cursor: pointer;   border-radius: 4px;   border: 1px solid #00c58e;   display: flex;   height: 60px;   margin: 10px 5px;   margin-right: 0;   justify-content: center;   align-items: center; } .directory__name {   text-align: center; } .directory {   width: 100%;   margin: 50px auto;   max-width: 450px;   border-radius: 4px;   border: 1px solid #00c58e;   box-sizing: border-box;   padding: 10px 0; } .directory__info {   padding-left: 10px;   line-height: 22px;   padding-right: 10px; }

The styles above will be used across the application for what we’ll be building. As you can see we have styles for the navigation and other aspects which we’ll plug into the application as we progress.

Components
This folder is one we’re familiar with from Vue.js, it contains your reusable components.

Now, let’s create our first component and name it navBar.vue, and add the following code to it. We want the navbar of the site to display the logo and link to the Home and About pages which we will create in future. This navbar will be visible across the application. It will also make use of some styles that we have added above.

<template>   <header class="header">     <div class="logo">       <nuxt-link to="/">         <Logo />       </nuxt-link>     </div>     <nav class="nav">       <div class="nav__link">         <nuxt-link to="/">Home</nuxt-link>       </div>       <div class="nav__link">         <nuxt-link to="/About">About</nuxt-link>       </div>     </nav>   </header> </template> <script> import Logo from "@/components/Logo"; export default {   name: "nav-bar",   components: {     Logo   } }; </script> <style> </style>

The template section contains what will be visible to the user. We have a header element which contains our logo and nav links. For us to link to the pages, we make use of nuxt-link which provides navigation between component pages.

In the script section, we import the logo component using Nuxt alias @ and declared it in our component for use by adding it as a component. This makes it possible for us to render it in the template.

Layout
Here, we’ll be storing our application layouts. This is particularly useful if your application’s design calls for two or more layouts, e.g. one for authenticated users and another for guests or admins. For the purpose of this tutorial, we’ll be sticking to the default layout.

Let us open our default.vue file and add our navBar component to the layout of our application.

<template>   <div>     <Nav />     <nuxt />   </div> </template> <script> import Nav from "~/components/navBar.vue"; export default {   components: {     Nav   } }; </script>

In the template section, we’ve added our Nav component inside the layout container to always appear at the top after importing it into the file and declaring it in the script section.

The next thing after our Nav component is <nuxt />, which tells Nuxt where to render all its routes.

This Nav component is the one we created above. By adding it here, the Nav component will be used across the application.

Middleware
This folder was created to house JavaScript files that are required to run before a page(s) is rendered. If you’ve ever used the Vuejs navigation guard, this folder was created for files like that.
Pages
This is another folder that developers with Vuejs background would not be familiar with. It works in such a way that every *.vue file is created as a route in your application so it serves as both views and a router folder at the same time, we’ll talk more about this in the next section.
Plugins
This is where you store files that you want to run before mounting the root Vue.js application. It is not a required folder so it can be deleted.
nuxt.config.js
This file is used to configure your application, it is usually pre-populated based on the config when creating your app. An ideal nuxt.config.js file should look like this by default:

export default {   mode: 'universal',   /*   ** Headers of the page   */   head: {     title: process.env.npm_package_name || '',     meta: [       { charset: 'utf-8' },       { name: 'viewport', content: 'width=device-width, initial-scale=1' },       { hid: 'description', name: 'description', content: process.env.npm_package_description || '' }     ],     link: [       { rel: 'icon', type: 'image/x-icon', href: '/favicon.ico' }     ]   },   /*   ** Customize the progress-bar color   */   loading: { color: '#fff' },   /*   ** Global CSS   */   css: [   ],   /*   ** Plugins to load before mounting the App   */   plugins: [   ],   /*   ** Nuxt.js dev-modules   */   buildModules: [   ],   /*   ** Nuxt.js modules   */   modules: [   ],   /*   ** Build configuration   */   build: {     /*     ** You can extend webpack config here     */     extend (config, ctx) {     }   } }

Each time a change is made to this file, your application will automatically restart to reflect the changes. Let’s go over what the properties used in the file mean.

Mode
The type of application; either universal or spa. By selecting universal, you’re telling Nuxt that you want your app to be able to run on both the server-side and the client-side.
Head
All the default meta tags properties and favicon link found inside the head tag in your app is found here. This is because Nuxt.js doesn’t have a default index.html file, unlike Vue.js.
loading
All Nuxt applications come with a default loader component and the color can be customized here.
css
You’re expected to enter the link to all your global CSS files so your application can take it into account when mounting the application. We’re going to add the link to our css file to this and restart our application.

 /*    ** Global CSS    */   css: ["~/assets/styles/main.css"]

plugins
This is where you connect all the plugins in your plugins folder to the application. It takes in an object with properties such as src that accepts the file path to the plugin and a mode that configures how your application treats such plugin; either as a server-side plugin or a client-side plugin. For example:

{ src: '~/plugins/universal-plugin.js' }, // for server and client plugins { src: '~/plugins/client-side.js', mode: 'client' }, // for client only plugins { src: '~/plugins/server-side.js', mode: 'server' }, // for server side only plugins

This is important to avoid error either on the server-side or client-side especially if your plugin requires something like localStorage that is not available on the server-side.

For more info about the nuxt.config.js file, check out the official doc.

Nuxt Pages And Routing System

The pages folder in your Nuxt application is used to configure your application’s routes, i.e. your route name is dependent on the name of each file in this folder, e.g. if you have an about.vue file inside your pages file, it means you now have an /about route in your app, but that’s not all. What happens if you want a dynamic route for your application? Or a nested route? How do you go about it? let’s find out.

Basic Routes

Basic routes can be classified as routes that do not require extra configuration for them to work. For example, a direct route /work or a /contact route. So if your pages folder looks like this:

pages/ --| me/  -----| index.vue  -----| about.vue --| work.vue --| contact.vue --| index.vue

Nuxt would automatically generate a router config that looks like this:

router: {   routes: [     {       name: 'index',       path: '/',       component: 'pages/index.vue'     },     {       name: 'work',       path: '/work',       component: 'pages/work'     },     {       name: 'contact',       path: '/contact',       component: 'pages/contact'     },     {       name: 'me',       path: '/me',       component: 'pages/me/index.vue'     },     {       name: 'me-about',       path: '/me/about',       component: 'pages/me/about.vue'     }   ] }

These paths can then be used to access the components tied to them. You can see that the path does not contain pages. And Nuxt handles the components named index.vue as it should without an additional config for that.

Nested Routes

To create a nested route, create a folder called dashboard inside the pages folder. This folder should contain all the files you want to nest in it. For example, user.vue and settings.vue. Then at the root of pages folder, create a file called dashboard.vue.

pages/  --| me/  -----| index.vue  -----| about.vue  --| dashboard/  -----| user.vue  -----| settings.vue  --| dashboard.vue  --| work.vue  --| contact.vue  --| index.vue

This would automatically generate a router with routes that look like this:

router: {   routes: [     {       name: 'index',       path: '/',       component: 'pages/index.vue'     },     {       name: 'work',       path: '/work',       component: 'pages/work'     },     {       name: 'contact',       path: '/contact',       component: 'pages/contact'     },          {       name: 'me',       path: '/me',       component: 'pages/me/index.vue'     },     {       name: 'me-about',       path: '/me/about',       component: 'pages/me/about.vue'     },     {       name: 'dashboard',       path: '/dashboard',       component: 'pages/dashboard.vue',       children: [         {           name: 'dashboard-user',           path: '/dashboard/user',           component: 'pages/dashboard/user.vue'         },         {           name: 'dashboard-settings',           path: '/dashboard/settings',           component: 'pages/dashboard/settings.vue'         }       ]     }   ] }

Notice that the route name always follows a regular pattern:

name of the folder + '-' + name of the file

With this, you can be sure that each route will have a unique name.

Dynamic Routes

Dynamic routes are routes that are defined by a variable, this variable can either be a name, number or an id gotten from client data on the app. This comes in handy when working with an API, where the id will likely be the id of the item coming from the database.

In Nuxt, dynamic routes are defined by appending an _ to a file name or folder name in the pages folder. For instance, if you want a dynamic route whose variable name is id, all you need is to name your file _id.vue and Nuxt automatically creates a dynamic route for you. For example:

pages/ --| me/ -----| index.vue -----| about.vue -----| _routeName -------| index.vue -------| info.vue --| dashboard/ -----| user.vue -----| settings.vue --| dashboard.vue --| work.vue --| _id.vue --| contact.vue --| index.vue

This would automatically create a router file with the following routes,

   {       name: 'work',       path: '/work',       component: 'pages/work'     },     {       name: 'contact',       path: '/contact',       component: 'pages/contact'     },     {       name: 'id',       path: '/:id',       component: 'pages/_id.vue'     }     {       name: 'me',       path: '/me',       component: 'pages/me/index.vue'     },     {       name: 'me-about',       path: '/me/about',       component: 'pages/me/about.vue'     },     {       name: 'me-routeName',       path: '/me/:routeName',       component: 'pages/me/_routeName/index.vue'     },     {       name: 'me-routeName-info',       path: '/me/:routeName/info',       component: 'pages/me/route.vue'     },     {       name: 'dashboard',       path: '/dashboard',       component: 'pages/dashboard.vue',       children: [         {           name: 'dashboard-user',           path: '/dashboard/user',           component: 'pages/dashboard/user.vue'         },         {           name: 'dashboard-settings',           path: '/dashboard/settings',           component: 'pages/dashboard/settings.vue'         }       ]     }   ] }

Although some of the Vue.js router tags work in Nuxt and can be used interchangeably, it is recommended that we use Nuxt router components. Here are some of the differences between the Nuxt Router tags and Vue.js Router tags.

VueJs	NuxtJS
router-link	nuxt-link
router-view (for nested routes)	nuxt-child
router-view(default)	nuxt

Difference between vue.js router and nuxt.js router

At this point, Here’s what your app should look like this, with the navigation shown at the top.

Now that we understand how Nuxt pages and Routes work, let’s add our first page and route about.vue. This page would list some directories in the application with a link to a new page that shows more information about such directory.

Let us add the following code to it:

<template>   <section class="home">     <h1 class="home__heading">About Nuxtjs Directory Structure</h1>     <div class="directories">       <div class="directory__container" v-for="directory in directories" :key="directory.id">         <p class="directory__name">           <nuxt-link             :to="{ name: 'id', params: { id: directory.id, dir: directory } }"           >{{ directory.name }}</nuxt-link>         </p>       </div>     </div>   </section> </template> <script> export default {   name: "about-nuxt",   data() {     return {       directories: [         {           id: 0,           name: "The Assets Directory",           info:             "By default, Nuxt uses vue-loader, file-loader and url-loader webpack loaders for strong assets serving. You can also use the static directory for static assets. This folder is for un-compiled files such as images, font files, SASS, LESS or JavaScript files"         },         {           id: 1,           name: "The Components Directory",           info:             "The components directory contains your Vue.js Components. You can’t use asyncData in these components."         },         {           id: 2,           name: "The Layouts Directory",           info:             "The layouts directory includes your application layouts. Layouts are used to change the look and feel of your page (for example by including a sidebar). Layouts are a great help when you want to change the look and feel of your Nuxt.js app. Whether you want to include a sidebar or having distinct layouts for mobile and desktop"         },         {           id: 3,           name: "The Middleware Directory",           info:             "The middleware directory contains your Application Middleware. Middleware lets you define custom functions that can be run before rendering either a page or a group of pages (layouts)."         },         {           id: 4,           name: "The Pages Directory",           info:             "The pages directory contains your Application Views and Routes. The framework reads all the .vue files inside this directory and creates the application router. Every Page component is a Vue component but Nuxt.js adds special attributes and functions to make the development of your universal application as easy as possible"         },         {           id: 5,           name: "The Plugins Directory",           info:             "The plugins directory contains your Javascript plugins that you want to run before instantiating the root Vue.js Application. This is the place to register components globally and to inject functions or constants. Nuxt.js allows you to define JavaScript plugins to be run before instantiating the root Vue.js Application. This is especially helpful when using your own libraries or external modules."         },         {           id: 6,           name: "The Static Directory",           info:             "The static directory is directly mapped to the server root (/static/robots.txt is accessible under http://localhost:3000/robots.txt) and contains files that likely won’t be changed (e.g. the favicon). If you don’t want to use Webpack assets from the assets directory, you can create and use the static directory (in your project root folder)."         },         {           id: 7,           name: "The Store Directory",           info:             "The store directory contains your Vuex Store files. The Vuex Store comes with Nuxt.js out of the box but is disabled by default. Creating an index.js file in this directory enables the store. Using a store to manage the state is important for every big application. That’s why Nuxt.js implements Vuex in its core."         }       ]     };   } }; </script> <style> </style>

Starting from the script section, we created an array which we store in the directories variable. Each array contains an object with id, name, and info. This is the data we’ll show to the user when this page is opened. We want to show it to the user such that the names are clickable.

We do that in the template section, using v-for to loop through the array. This makes it possible to get each item in the array, which we can access using directory. In the loop, we use nuxt-link to handle the linking of each time. Using nuxt-link, we pass the details (id, name and info) of each directory item via nuxt router. We do this because we want to be able to display this on the show page when the user clicks on an item.

If you navigate to the /about route using your browser, you should see something like this:

Now, let’s create a new file and name it _id.vue. This would automatically create a dynamic route that takes the id param from the link display a little information about any directory clicked on from the About page.

Let us add this to our file:

<template>   <section class="directory">     <h1 class="directory__name">{{ directory.name }}</h1>     <p class="directory__info">{{ directory.info }}</p>   </section> </template> <script> export default {   name: "directory-info",   data() {     return {       directory: this.$ route.params.dir     };   } }; </script> <style> </style>

What we have done is to create a page that fetches data from the route param dir using the this.$ route.params. This gets us the name and info of the clicked directory, which we then display to the user.

So if you click on any directory link (e.g. store directory), you should see this.

What the ID page looks like. (Large preview)

But there’s a problem, if you refresh this page, your directory info gets lost and you get an error. This would be fixed using our Vuex Store so let’s dive into it.

Using Vuex Store In Nuxt

Vuex can be accessed in Nuxt using two modes:

Classic mode (deprecated).
Modules mode.

Modules mode

Nuxt automatically creates a Store folder upon the creation of your app. In Modules mode, Nuxt would treat every file inside this folder as a module but index.js is required for Vuex store to be activated in your app. So let’s create an index.js file in our store folder and set it up for use. Let us add the following to our file.

index.js

export const state = () => ({    })  export const getters = {  }  export const mutations = {    }  export const actions = {    }

All we have done is to set up the store for our file with all we might need; the state for storing data, getters for performing extra manipulation to our state, mutations for modifying our state and actions for committing mutations.

Nuxt also allows users to separate each core concept into different files which means we can have store.js, getters.js, mutation.js and action.js and this is good as it makes for easy maintainability. Now, we fix the problem of directory disappearing on refresh, we’ll use the store, but first, we need to install and set up Vuex persist for our store.

Install Vuex persist from npm using either command below, depending on your preference.

$  npm install --save vuex-persist

$  yarn add vuex-persist

After installing, we’re going to create a vuex-persist.js file in our plugins folder and add the following:

import VuexPersistence from 'vuex-persist'  export default ({   store }) => {   window.onNuxtReady(() => {     new VuexPersistence({       storage: window.localStorage     }).plugin(store);   }); }

Here, we import our plugin from node-modules and configure it to save your store in localStorage. This plugin allows you to choose other storage options such as sessionStorage too so feel free to explore their documentation for more info.

Remember to add it to your nuxt.config.js file.

/*    ** Plugins to load before mounting the App    */   plugins: [{     src: '~/plugins/vuex-persist',     mode: 'client'   }],

Here, we added the file path to our plugin and told Nuxt to only run this plugin on the client side of this application.

Now, we can set our store up to accept and store directory info. Update your store to handle directory info like this:

export const state = () => ({   directory: '' }) export const getters = { } export const mutations = {   saveInfo(state, payload) {     state.directory = payload.directory   } } export const actions = { }

What we’ve done is to add a directory state to our store and a mutation function saveInfo that modifies the value of the directory state we added to our store in anticipation of the data we’d be passing it soon.

Next, in your about.vue file, update it to look like this.

<template>   <section class="home">     <h1 class="home__heading">About Nuxtjs Directory Structure</h1>     <div class="directories">       <div         class="directory__container"         v-for="directory in directories"         :key="directory.id"         @click.prevent="storeDirectoryInfo(directory)"       >         <p class="directory__name">           <nuxt-link             :to="{ name: 'id', params: { id: directory.id, dir: directory } }"           >{{ directory.name }}</nuxt-link>         </p>       </div>     </div>   </section> </template> <script> export default {   name: "about-nuxt",   data() {     return {       directories: [         //remains the same       ]     };   },   methods: {     storeDirectoryInfo(dir) {       this.$ store.commit("saveInfo", {         directory: dir       });     }   } }; </script> <style> </style>

Now, we’ve added a click event to every directory container that passes the directory info as an argument to the storeDirectoryInfo. In this function, we commit the directory object to our store.

Finally, we would go back to our _id.vue file and replace the directory variable with our data from the store like this:

<template>   <section class="directory" v-if="directory">     <h1 class="directory__name">{{ directory.name }}</h1>     <p class="directory__info">{{ directory.info }}</p>   </section> </template> <script> import { mapState } from "vuex"; export default {   name: "directory-info",   computed: {     ...mapState(["directory"])   } }; </script> <style></style>

Here, we refactor our code to use directory object directly from our store by first importing mapState from Vuex.

import { mapState } from 'vuex';

Instead of first checking if this.$ route.params.dir is undefined before accessing the data from our store, we decide to use our store by reading the data that’s in the store.

<script> import { mapState } from "vuex"; export default {   name: "directory-info",   computed: {     ...mapState(["directory"])   } }; </script>

Then we update our template to make sure it doesn’t render while directory is undefined.

<template>   <section class="directory" v-if="directory">     <h1 class="directory__name">{{ directory.name }}</h1>     <p class="directory__info">{{ directory.info }}</p>   </section> </template>

On doing this, no matter how many times we refresh our app, our directory object is safe in our store and can be easily accessed using the …mapState(['stateVariable']) method.

Deploying To Heroku

Now that our nuxt-tutorial-app app is complete, what’s next? Deploying our shiny new app to production.

We’ll be deploying our Nuxt.js app to Heroku using Github for easy deployment so if you’ve not set up a repository for your app, now would be a time to do so. The next thing would be to open Heroku and create a new app, choose a name and connect it to GitHub and the repo created above. Next, go to your settings, you should see something like this.

Heroku App settings page. (Large preview)

Now, add the following config variables.

NPM_CONFIG_PRODUCTION=false HOST=0.0.0.0 NODE_ENV=production

The next thing we have to do is to create a Procfile in the root folder of our app (same level as nuxt.config.js) and enter this command:

web: nuxt start

This will run the nuxt start command and tell Heroku to direct external HTTP traffic to it.

After adding the Procfile to your app, commit and push your changes to your repo. If you have automatic deploys enabled for your app, your app should be live and accessible from its URL. If you can see your app live, congratulations! 🎆 you have successfully built and deployed your first Nuxt.js application.

Conclusion

Now that we know how to create a basic Nuxt application and deploy to Heroku, what’s next? Here are some resources that cover things like using Axios in Nuxt and implementing authentication in your app.

Using the axios module.
Implementing Authentication in Nuxt.
Nuxt.js official documentation.
nuxt-tutorial-app Github repo.

(ks, ra, yk, il)

Articles on Smashing Magazine — For Web Designers And Developers

10 Apr

Getting Started With The React Hooks API

by TBSCategories: News

Getting Started With The React Hooks API

Shedrack Akintayo

2020-04-10T09:30:00+00:00 2020-04-10T15:04:47+00:00

When React 16.8 was released officially in early February 2019, it shipped with an additional API that lets you use state and other features in React without writing a class. This additional API is called Hooks and they’re becoming popular in the React ecosystem, from open-sourced projects to being used in production applications.

React Hooks are completely opt-in which means that rewriting existing code is unecessary, they do not contain any breaking changes, and they’re available for use with the release of React 16.8. Some curious developers have been making use of the Hooks API even before it was released officially, but back then it was not stable and was only an experimental feature. Now it is stable and recommended for React developers to use.

Note: We won’t be talking about React or JavaScript in general. A good knowledge of ReactJS and JavaScript will come in handy as you work through this tutorial.

What Are React Hooks?

React Hooks are in-built functions that allow React developers to use state and lifecycle methods inside functional components, they also work together with existing code, so they can easily be adopted into a codebase. The way Hooks were pitched to the public was that they allow developers to use state in functional components but under the hood, Hooks are much more powerful than that. They allow React Developers to enjoy the following benefits:

Improved code reuse;
Better code composition;
Better defaults;
Sharing non-visual logic with the use of custom hooks;
Flexibility in moving up and down the components tree.

With React Hooks, developers get the power to use functional components for almost everything they need to do from just rendering UI to also handling state and also logic — which is pretty neat.

Motivation Behind The Release Of React Hooks

According to the ReactJS official documentation, the following are the motivation behind the release of React Hooks:

Reusing stateful logic between components is difficult.
With Hooks, you can reuse logic between your components without changing their architecture or structure.
Complex components can be difficult to understand.
When components become larger and carry out many operations, it becomes difficult to understand in the long run. Hooks solve this by allowing you separate a particular single component into various smaller functions based upon what pieces of this separated component are related (such as setting up a subscription or fetching data), rather than having to force a split based on lifecycle methods.
Classes are quite confusing.
Classes are a hindrance to learning React properly; you would need to understand how this in JavaScript works which differs from other languages. React Hooks solves this problem by allowing developers to use the best of React features without having to use classes.

The Rules Of Hooks

There are two main rules that are strictly to be adhered to as stated by the React core team in which they outlined in the hooks proposal documentation.

Make sure to not use Hooks inside loops, conditions, or nested functions;
Only use Hooks from inside React Functions.

Basic React Hooks

There are 10 in-built hooks that was shipped with React 16.8 but the basic (commonly used) hooks include:

useState()
useEffect()
useContext()
useReducer()

These are the 4 basic hooks that are commonly used by React developers that have adopted React Hooks into their codebases.

`useState()`

The useState() hook allows React developers to update, handle and manipulate state inside functional components without needing to convert it to a class component. Let’s use the code snippet below is a simple Age counter component and we will use it to explain the power and syntax of the useState() hook.

function App() {   const [age, setAge] = useState(19);   const handleClick = () => setAge(age + 1)    return        <div>            I am {age} Years Old          <div>          <button onClick={handleClick}>Increase my age! </button>       </div>    </div> }

If you’ve noticed, our component looks pretty simple, concise and it’s now a functional component and also does not have the level of complexity that a class component would have.

The useState() hook receives an initial state as an argument and then returns, by making use of array destructuring in JavaScript, the two variables in the array can be named what. The first variable is the actual state, while the second variable is a function that is meant for updating the state by providing a new state.

This is how our component should look when it is rendered in our React application. By clicking on the “Increase my Age” button, the state of the age will change and the component would work just like a class component with state.

`useEffect()`

The useEffect() hook accepts a function that would contain effectual code. In functional components, effects like mutations, subscriptions, timers, logging, and other effects are not allowed to be placed inside a functional component because doing so would lead to a lot of inconsistencies when the UI is rendered and also confusing bugs.

In using the useEffect() hook, the effectual function passed into it will execute right after the render has been displayed on the screen. Effects are basically peeked into the imperative way of building UIs that is quite different from React’s functional way.

By default, effects are executed mainly after the render has been completed, but you have the option to also fire them when certain values change.

The useEffect() hook mostly into play for side-effects that are usually used for interactions with the Browser/DOM API or external API-like data fetching or subscriptions. Also, if you are already familiar with how React lifecycle methods work, you can also think of useEffect() hook as component mounting, updating and unmounting — all combined in one function. It lets us replicate the lifecycle methods in functional components.

We will use the code snippets below to explain the most basic way that we can by using the useEffect() hook.

Step 1: Define The State Of Your Application

import React, {useState} from 'react'; function App() {     //Define State     const [name, setName] = useState({firstName: 'name', surname: 'surname'});     const [title, setTitle] = useState('BIO');          return(         <div>             <h1>Title: Getting Started With The React Hooks API</h1>             <h3>Name: {name.firstName}</h3>             <h3>Surname: {name.surname}</h3>         </div>     ); }; export default App

Just like we discussed in the previous section on how to use the useState() hook to handle state inside functional components, we used it in our code snippet to set the state for our app that renders my full name.

Step 2: Call The useEffect Hook

import React, {useState, useEffect} from 'react'; function App() {     //Define State     const [name, setName] = useState({firstName: 'name', surname: 'surname'});     const [title, setTitle] = useState('BIO');         //Call the use effect hook     useEffect(() => {       setName({name: 'Shedrack', surname: 'Akintayo'})     }, [])//pass in an empty array as a second argument          return(         <div>             <h1>Title: Getting Started With The React Hooks API</h1>             <h3>Name: {name.firstName}</h3>             <h3>Surname: {name.surame}</h3>         </div>     ); }; export default App

We have now imported the useEffect hook and also made use of the useEffect() function to set the state of our the name and surname property which is pretty neat and concise.

You may have noticed the useEffect hook in the second argument which is an empty array; this is because it contains a call to the setFullName which does not have a list of dependencies. Passing the second argument will prevent an infinite chain of updates (componentDidUpdate()) and it’ll also allow our useEffect() hook to act as a componentDidMount lifecycle method and render once without re-rendering on every change in the tree.

Our React app should now look like this:

React app using the `useEffect` Hook (Large preview)

We can also use change the title property of our application inside the useEffect() function by calling the setTitle() function, like so:

import React, {useState, useEffect} from 'react'; function App() {     //Define State     const [name, setName] = useState({firstName: 'name', surname: 'surname'});     const [title, setTitle] = useState('BIO');         //Call the use effect hook     useEffect(() => {       setName({name: 'Shedrack', surname: 'Akintayo'})       setTitle({'My Full Name'}) //Set Title     }, [])// pass in an empty array as a second argument          return(         <div>             <h1>Title: Getting Started With The React Hooks API</h1>             <h3>Name: {name.firstName}</h3>             <h3>Surname: {name.surame}</h3>         </div>     ); }; export default App

Now after our application has rerendered, it now shows the new title.

`useContext()`

The useContext() hook accepts a context object, i.e the value that is returned from React.createContext, and then it returns the current context value for that context.

This hook gives functional components easy access to your React app context. Before the useContext hook was introduced you would need to set up a contextType or a <Consumer> to access your global state passed down from some provider in a class component.

Basically, the useContext hook works with the React Context API which is a way to share data deeply throughout your app without the need to manually pass your app props down through various levels. Now, the useContext() makes using Context a little easier.

The code snippets below will show how the Context API works and how the useContext Hook makes it better.

The Normal Way To Use The Context API

import React from "react"; import ReactDOM from "react-dom";  const NumberContext = React.createContext(); function App() {   return (     <NumberContext.Provider value={45}>       <div>         <Display />       </div>     </NumberContext.Provider>   ); } function Display() {   return (     <NumberContext.Consumer>       {value => <div>The answer to the question is {value}.</div>}     </NumberContext.Consumer>   ); } ReactDOM.render(<App />, document.querySelector("#root"));

Let’s now break down the code snippet and explain each concept.

Below, we are creating a context called NumberContext. It is meant to return an object with two values: { Provider, Consumer }.

const NumberContext = React.createContext();

Then we use the Provider value that was returned from the NumberContext we created to make a particular value available to all the children.

function App() {   return (     <NumberContext.Provider value={45}>       <div>         <Display />       </div>     </NumberContext.Provider>   ); }

With that, we can use the Consumer value that was returned from the NumberContext we created to get the value we made available to all children. If you have noticed, this component did not get any props.

function Display() {   return (     <NumberContext.Consumer>       {value => <div>The answer to the question is {value}.</div>}     </NumberContext.Consumer>   ); } ReactDOM.render(<App />, document.querySelector("#root"));

Note how we were able to get the value from the App component into the Display component by wrapping our content in a NumberContext.Consumer and using the render props method to retrieve the value and render it.

Everything works well and the render props method we used is a really good pattern for handling dynamic data, but in the long run, it does introduce some unnecessary nesting and confusion if you’re not used to it.

Using The useContext Method

To explain the useContext method we will rewrite the Display component using the useContext hook.

// import useContext (or we could write React.useContext) import React, { useContext } from 'react';  // old code goes here  function Display() {   const value = useContext(NumberContext);   return <div>The answer is {value}.</div>; }

That’s all we need to do in order to display our value. Pretty neat, right? You call the useContext() hook and pass in the context object we created and we grab the value from it.

Note: Don’t forget that the argument that is passed to the useContext hook must be the context object itself and any component calling the useContext will always re-render when the context value changes.

`useReducer()`

The useReducer hook is used for handling complex states and transitions in state. It takes in a reducer function and also an initial state input; then, it returns the current state and also a dispatch function as output by the means of array destructuring.

The code below is the proper syntax for using the useReducer hook.

const [state, dispatch] = useReducer(reducer, initialArg, init);

It is sort of an alternative to the useState hook; it is usually preferable to useState when you have complex state logic that has to do with multiple sub-values or when the next state is dependent on the previous one.

Other React Hooks Available

`useCallback`	This hook returns a callback function that is memoized and that only changes if one dependency in the dependency tree changes.
`useMemo`	This hook returns a memoized value, you can pass in a “create” function and also an array of dependencies. The value it returns will only use the memoized value again if one of the dependencies in the dependency tree changes.
`useRef`	This hook returns a mutable ref object whose `.current` property is initialized to the passed argument (`initialValue`). The returned object will be available for the full lifetime of the component.
`useImperativeHandle`	This hook is used for customizing the instance value that is made available for parent components when using refs in React.
`useLayoutEffect`	This hook similar to the `useEffect` hook, however, it fires synchronously after all DOM mutations. It also renders in the same way as `componentDidUpdate` and `componentDidMount`.
`useDebugValue`	This hook can be used to display a label for custom hooks in the React Dev Tools. It is very useful for debugging with the React Dev Tools.

Custom React Hooks

A “custom Hook” is a JavaScript function whose names are prefixed with the word use and can be used to call other Hooks. It also lets you to extract component logic into reusable functions; they are normal JavaScript functions that can make use of other Hooks inside of it, and also contain a common stateful logic that can be made use of within multiple components.

The code snippets below demonstrate an example of a custom React Hook for implementing infinite scroll (by Paulo Levy):

import { useState } from "react";  export const useInfiniteScroll = (start = 30, pace = 10) => {   const [limit, setLimit] = useState(start);   window.onscroll = () => {     if (       window.innerHeight + document.documentElement.scrollTop ===       document.documentElement.offsetHeight     ) {       setLimit(limit + pace);     }   };   return limit; };

This custom Hook accepts two arguments which are start and pace. The start argument is the starting number of elements to be rendered while the pace argument is the subsequent number of elements that are to be rendered. By default, the start and pace arguments are set to 30 and 10 respectively which means you can actually call the Hook without any arguments and those default values will be used instead.

So in order to use this Hook within a React app, we would use it with an online API that returns ‘fake’ data:

import React, { useState, useEffect } from "react"; import { useInfiniteScroll } from "./useInfiniteScroll";  const App = () => {   let infiniteScroll = useInfiniteScroll();    const [tableContent, setTableContent] = useState([]);    useEffect(() => {     fetch("https://jsonplaceholder.typicode.com/todos/")       .then(response => response.json())       .then(json => setTableContent(json));   }, []);    return (     <div style={{ textAlign: "center" }}>       <table>         <thead>           <tr>             <th>User ID</th>             <th>Title</th>           </tr>         </thead>         <tbody>           {tableContent.slice(0, infiniteScroll).map(content => {             return (               <tr key={content.id}>                 <td style={{ paddingTop: "10px" }}>{content.userId}</td>                 <td style={{ paddingTop: "10px" }}>{content.title}</td>               </tr>             );           })}         </tbody>       </table>     </div>   ); };  export default App;

The code above will render a list of fake data (userID and title) that make use of the infinite scroll hook to display the initial number of data on the screen.

Conclusion

I hope you enjoyed working through this tutorial. You could always read more on React Hooks from the references below.

If you have any questions, you can leave them in the comments section and I’ll be happy to answer every single one!

The supporting repo for this article is available on Github.

Resources And Further Reading

“Hooks API Reference,” React.js Docs
“What Are React Hooks?,” Robin Wieruch
“How The useContext Hook Works,” Dave Ceddia
“React Hooks: How To Use useEffect(),” Hossein Ahmadi, Medium
“Writing Your Own Custom React Hooks,” Aayush Jaiswal, Medium
“Easy To Understand React Hook Recipes,” Gabe Ragland, useHooks(🐠)

(ks, ra, yk, il)

Articles on Smashing Magazine — For Web Designers And Developers

Newer posts

Older posts

Tag: Getting

Recovering Deleted Commits

Using the Reflog to Recover Lost States

Using Submodules To Manage Third-Party Code

Composing Commits With Precision

Staging Selected Parts of Your Changed Files

Becoming More Productive with Git

Recovering Deleted Commits

Using the Reflog to Recover Lost States

Using Submodules To Manage Third-Party Code

Composing Commits With Precision

Staging Selected Parts of Your Changed Files

Becoming More Productive with Git

Recovering Deleted Commits

Using the Reflog to Recover Lost States

Using Submodules To Manage Third-Party Code

Composing Commits With Precision

Staging Selected Parts of Your Changed Files

Becoming More Productive with Git

Recovering Deleted Commits

Using the Reflog to Recover Lost States

Using Submodules To Manage Third-Party Code

Composing Commits With Precision

Staging Selected Parts of Your Changed Files

Becoming More Productive with Git

Recovering Deleted Commits

Using the Reflog to Recover Lost States

Using Submodules To Manage Third-Party Code

Composing Commits With Precision

Staging Selected Parts of Your Changed Files

Becoming More Productive with Git

What Is GetX

Features Of GetX

State Management

Route Management

Dependency Management

Internationalization

Validation

Storage

Getting Started With GetX

Create A Brand New Flutter Application

Installing GetX

GetxController

Navigation In GetX

Snackbar

Dialog

Conclusion

But Why Next.js?

Requirements For Creating A Next.js App

Creating A Next.js App

Creating A Next.js App With create-next-app

Creating A Next.js Project Manually

Folder Structure

Pages

Routing

Index Routes

Nested Routes

Dynamic Route Segments

Linking Between Pages

Styling

Linting And Formatting

Static Assets

Data Fetching

getStaticProps

getStaticPaths

Extras

Absolute Imports

Experimental ES Features

Conclusion

Resources

What Is The Nuxt.js Axios Module?

Making Your First Request Using Axios

AsyncData

Fetch

Using Axios As A Plugin

Introduction To The Auth Module

Using The Auth Module

Conclusion

Resources

What Is Nuxt.js?

`GetxController`

Creating A Next.js App With `create-next-app`

`getStaticProps`

`getStaticPaths`

`useState()`

`useEffect()`

`useContext()`

`useReducer()`