JavaScript is a language that we can use to write programs that run in a browser or on a server using Node. Because of Node, you can use JavaScript to build full web applications like Twitter or multi-player games.
This is the first lesson in a four-part series where I will teach you the programming fundamentals you will need so you can learn to build your own apps. In part 1, I will introduce you to the syntax of JavaScript and ES6. ES6 stands for ECMAScript 6, which is a modern version of JavaScript. We will also cover some other basic concepts such as variables and data types.
First, we will set up our development environment so that we can run our code on our own computer. Alternatively, you can test code examples in an online editor like OneCompiler.
The easiest way to do so would be to use your web browser. This is especially true if you have no prior experience with programming in general. All you need to do is press Control-Shift-K in Firefox or Control-Shift-J in Chrome to get started. This should give you something like the image below, where I have already executed a line of code.
Alternatively, you can also consider using Node if you are comfortable with installing and setting up your own runtime environment. You will be able to put it on your resume and impress your employer later.
First, you will need a text editor to write your code in. I recommend Sublime Text or Visual Studio Code. Next, download and install Node to your computer. You can get the software on the Node.js website. Confirm that the installation worked by typing the command node -v
from your terminal. If everything is fine, you will see the version number of your Node installation.
One of the things you can do with Node is run JavaScript code from within your terminal. This takes place in what is called an REPL shell. The term REPL stands for Read-Eval-Print-Loop. Basically, the shell will Read the code you enter, Evaluate what you wrote, Print the result, and keep Looping until you exit. To try it out—enter the command node
in your terminal.
Next, let's print the message “Hello, World”. Type the following into the terminal:
> console.log("Hello, World");
To exit the REPL, press Control-C twice. Using the REPL comes in handy when you want to test simple statements like the example above. This can prove more convenient than saving code to a file—especially if you’re writing throwaway code.
To execute a program you have written in a file, in your terminal run the command node filename
, where filename is replaced with the name of your JavaScript file. You do not have to type the js
extension of the filename to run the script. And you must be in the root directory where the file lives.
Let’s try an example. Create a file named hello.js. Inside, we will put the following code:
console.log("Hello, World");
Run the code from the terminal:
$ node hello
If all is well, you will see the text "Hello, World" output to the terminal.
From now on, you can test the code examples from this tutorial either by using the Node REPL or by saving to a file.
Before you write any code, you should take the time to understand the problem. What data do you need? What is the outcome? What tests does your program need to pass?
When you understand the requirements of the program, then you can write the steps to solve it. The steps are your algorithm. Your algorithm is not code. It is plain English (replace English with your native language) instructions for solving the problem. For example, if you want to write an algorithm for cooking top ramen, it might look like this:
Yes, I was hungry when I thought of this. And no, this is not something you would actually be given as a programming problem. Here is an example of a problem that is more practical. It is an algorithm to calculate the average of a list of numbers.
Understanding the problem and coming up with an algorithm are the most important steps in programming. When you feel confident in your algorithm, then you should write some test cases. The tests will show how your code should behave. Once you have your tests, then you write code and tweak it until your tests pass. Depending on how complex your problem is, each one of the steps in your algorithm may need to be broken down further.
Write an algorithm to calculate the factorial of a number. The factorial of a number n
is the product of all integers from 1 to n
. For example, 4!
(4 factorial) is 1 x 2 x 3 x 4
= 24.
A program is similar to the language we speak with. The only difference is that a programming language is meant to communicate with the computer (and other programmers who have to use it). The rules for constructing the program are its syntax. Programs consist of statements. A statement can be thought of as a sentence. In JavaScript, you must put a semicolon at the end of a statement. Example:
a = 2 + 2;
Statements consist of expressions. Expressions are like the subject/predicate parts of a sentence. In a programming language, expressions have a value. Expressions consist of keywords like var
and for
which are the built-in vocabulary of the language; data like a number or string; and operators like +
and =
. Example:
2+2
Here is a list of arithmetic operators:
Operator | Meaning |
---|---|
+ | addition |
- | subtraction |
** | exponentiation |
* | multiplication |
/ | division |
% | remainder |
++ | increment |
-- | decrement |
The remainder operator returns the remainder after dividing two numbers. For example, 4 % 2
returns 0, and 5 % 3
returns 2. The remainder operator is commonly used to find out if a value is even or odd. Even values will have a remainder of 0.
One thing that I would like to mention is that the remainder operator is different from the modulo operator, which uses the same symbol. In short, the result of a modulo operation will always have the same sign as the divisor. On the other hand, the result of a remainder operation will always have the same sign as the dividend.
Find the value of the following expressions. Write down your answers first, and then check them in your REPL.
A variable is a name that represents a value in the computer’s memory. Any value we would like to store or use over and over should be placed in a variable. One way of creating variables is with the var
keyword, but the preferred way is to use the let
or const
keywords. Here are some examples of using let to create variables:
Declaring a variable:
let a;
Declaring and initializing a variable:
let a = 1;
Reassigning a variable:
a = 2;
Constants are variables that cannot change. Their value can only be assigned once, and it has to happen during initialization. Constants that have objects or arrays as values can still be modified because they are assigned by reference. The variables do not hold a value; instead, they point to the location of the object. Example:
const a = {foo:1,bar:2}; a.baz = 3; console.log( a ); // displays { foo: 1, bar: 2, baz: 3 }
However, this will give you an error:
const a = {foo:1,bar:2}; a = {}; console.log( a );
As a general rule, you should always create variables using the const
keyword and use let
only when you know that the variable value will be reassigned in the future. This will make debugging easier for you or anyone else browsing through your code as you will know that the value of a const
variable that you encountered again many lines later still has the same value that you assigned earlier.
When writing programs, you will usually have to deal with different kinds of data. This data is represented by different data types. Data types have rules for how they can be operated on. For example, if we add two numbers, we get their sum. But if we add a number with a string, we get a string.
Here is a list of the different data types:
undefined
: a variable that has not been assigned a valueBoolean
: an entity that has the value true or falseString
: a sequence of charactersSymbol
: a unique, unchanging keyNumber
: useful for working with integer and decimal valuesBigInt
: useful for operating on large numbers that can even go beyond the Number.MAX_SAFE_INTEGER
limitObject
: a collection of propertiesIn addition, there is null
, a special value of type Object
. null
is used to indicate an empty or non-existent object.
undefined
vs. null
While undefined
and null
might seem to be similar, they are in fact very different. Whenever there is an absence of some value, it is treated as undefined
. On the other hand, you have to explicitly make things null
. For example, a function that doesn't return any value is assumed to return undefined
instead of null
.
The Boolean
type represents two values, true
and false
. They are useful when you are writing code where you only want to know if something is true or not. For example, you can use a variable like isItNight
and check if its value is true
or false
to determine whether to apply a dark or light theme.
A String
is a data type that consists of characters. A string will be surrounded with single quotes, double quotes, or the backtick character.
We use strings to store textual data such as the name of a person. The String
object also has a variety of methods you can use to perform actions on them. The following are some examples of actions you can perform on strings.
Keep in mind that strings in JavaScript are immutable, and any method that you use on a string will result in the creation of new strings while leaving the original untouched. Here are a few examples of string methods.
Determine if a string begins with a substring:
"Hello, World".startsWith("Hello"); //true
Determine if a string ends with a substring:
"Hello, World".endsWith("World"); //true
Determine if a substring is located anywhere in a string:
"Hello, World".includes("World"); //true
Repeat a string a specified number of times:
"Hello".repeat(3); //HelloHelloHello
We can turn a string into an array of individual characters (strings of length 1) with the spread operator: ...
let str = [..."hello"]; console.log(str); //[ 'h', 'e', 'l', 'l', 'o' ]
Template literals are a special kind of string that use backticks. We can use them to insert variables within a string like this:
let name = "World"; let greeting = `Hello, ${name}`; console.log(greeting); //Hello, World
We can create multiline strings like this:
` <div> <h1>Hello, World</h1> </div> `
The Number
type in JavaScript comes in handy when you are dealing with, well, numbers. It allows you to store and manipulate numbers. You can use this type to work with positive or negative numbers as well as fractions. Here is an example:
function factorial(x) { let result = 1; while(x > 1) { result *= n; x -= 1; } return result; } // 120 console.log(factorial(5)); // 362880 console.log(factorial(10)); // 3.0414093201713376e+64 console.log(factorial(50)); // Infinity console.log(factorial(500));
Did you complete the task under the Designing a Program section where you had to write an algorithm to calculate the factorial of a number? The above code shows you how to implement something like that in JavaScript.
We defined our own function named factorial()
that accepts a number as input and gives us its factorial. Defining a function allows us to avoid repetition of code. For example, we did not have to write our code four times to calculate the factorial of four different numbers. You will learn about functions in more detail in a later tutorial.
There are two things that you might have noticed above. First, the function calculates the factorial as expected. However, it doesn't return an exact number for a factorial of 50. Second, it doesn't return any kind of number but simply says Infinity
when calculating the factorial of 500.
We all know that the factorial of 500 is not going to be Infinity. However, JavaScript will convert any number over Number.MAX_VALUE
or 21024 to Infinity
.
Is there any way for us to get an actual value for the factorial of 500? Yes, there is! We will learn about the BigInt
type next.
The BigInt
type allows you to work with numbers of arbitrary magnitude. This means that your values can go beyond Number.MAX_VALUE
without returning something vague like Infinity
.
There are two ways of creating a BigInt
. You can either append n at the end of your integral value or you can call the BigInt()
function. Let's rewrite the above code to get factorials using the BigInt
type.
function factorial(x) { let result = 1n; while(x > 1n) { result *= n; x -= 1n; } return result; } // 120n console.log(factorial(5n)); // 3628800n console.log(factorial(10n)); // 30414093201713378043612608166064768844377641568960512000000000000n console.log(factorial(50n)); // 1220136825991110068701238785423046926253574342803192842192413588385845373153881997605496447502203281863013616477148203584163378722078177200480785205159329285477907571939330603772960859086270429174547882424912726344305670173270769461062802310452644218878789465754777149863494367781037644274033827365397471386477878495438489595537537990423241061271326984327745715546309977202781014561081188373709531016356324432987029563896628911658974769572087926928871281780070265174507768410719624390394322536422605234945850129918571501248706961568141625359056693423813008856249246891564126775654481886506593847951775360894005745238940335798476363944905313062323749066445048824665075946735862074637925184200459369692981022263971952597190945217823331756934581508552332820762820023402626907898342451712006207714640979456116127629145951237229913340169552363850942885592018727433795173014586357570828355780158735432768888680120399882384702151467605445407663535984174430480128938313896881639487469658817504506926365338175055478128640000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000n console.log(factorial(500n));
As you can see, we do get an actual numeric value as our result for the factorial of 500. However, keep in mind that BigInt
is only helpful for storing integers. You cannot use it to do calculations with fractional numbers of arbitrary magnitude.
One more thing to remember is that you cannot mix BigInt
and regular Number
types while doing arithmetic operations. This is the reason we converted all our numbers, even small ones such as 1, to BigInt
type by appending n
at the end.
As mentioned earlier in the tutorial, objects in JavaScript are a collection of properties, and these properties are simply key-value pairs to store information. Functions in JavaScript are also basically objects which we can call. Arrays, which are used to store multiple values inside a single variable, are also objects.
Don't worry about objects and arrays for now as we will learn about them in more detail in other tutorials in the series.
A Symbol
is a built-in JavaScript primitive that is always guaranteed to be unique. This makes it ideal for creating unique property keys that won't collide with object keys that might be added by some other code.
Each call to Symbol()
returns a unique symbol. However, you can use the for()
method to get back the same symbol for a particular key.
const x = Symbol(); const y = Symbol(); const a = Symbol.for("potato"); const b = Symbol.for("potato"); // Symbol Mismatch if(x === y) { console.log('Same Symbol'); } else { console.log('Symbol Mismatch'); } // This should Match if(a === b) { console.log("This should Match"); }
We have seen how to set up our development environment using Node. The first step in programming is writing the steps to solve the problem. This is called the algorithm. The actual code will consist of many statements. Statements are the program’s instructions and are made up of expressions.
Expressions are useful in our program if we assign them to variables. Variables are created with the let
or const
keywords. Variables will usually store different types of data that we just discussed.
In the next part, I will explain conditionals that allow you to run a different set of tasks under different circumstances, e.g. whether a user is logged in or logged out.
This post has been updated with contributions from Monty Shokeen. Monty is a full-stack developer who also loves to write tutorials and to learn about new JavaScript libraries.
The Best Small Business Web Designs by DesignRush
/Create Modern Vue Apps Using Create-Vue and Vite
/Pros and Cons of Using WordPress
/How to Fix the “There Has Been a Critical Error in Your Website” Error in WordPress
/How To Fix The “There Has Been A Critical Error in Your Website” Error in WordPress
/How to Create a Privacy Policy Page in WordPress
/How Long Does It Take to Learn JavaScript?
/The Best Way to Deep Copy an Object in JavaScript
/Adding and Removing Elements From Arrays in JavaScript
/Create a JavaScript AJAX Post Request: With and Without jQuery
/5 Real-Life Uses for the JavaScript reduce() Method
/How to Enable or Disable a Button With JavaScript: jQuery vs. Vanilla
/How to Enable or Disable a Button With JavaScript: jQuery vs Vanilla
/Confirm Yes or No With JavaScript
/How to Change the URL in JavaScript: Redirecting
/15+ Best WordPress Twitter Widgets
/27 Best Tab and Accordion Widget Plugins for WordPress (Free & Premium)
/21 Best Tab and Accordion Widget Plugins for WordPress (Free & Premium)
/30 HTML Best Practices for Beginners
/31 Best WordPress Calendar Plugins and Widgets (With 5 Free Plugins)
/25 Ridiculously Impressive HTML5 Canvas Experiments
/How to Implement Email Verification for New Members
/How to Create a Simple Web-Based Chat Application
/30 Popular WordPress User Interface Elements
/Top 18 Best Practices for Writing Super Readable Code
/Best Affiliate WooCommerce Plugins Compared
/18 Best WordPress Star Rating Plugins
/10+ Best WordPress Twitter Widgets
/20+ Best WordPress Booking and Reservation Plugins
/Working With Tables in React: Part Two
/Best CSS Animations and Effects on CodeCanyon
/30 CSS Best Practices for Beginners
/How to Create a Custom WordPress Plugin From Scratch
/10 Best Responsive HTML5 Sliders for Images and Text… and 3 Free Options
/16 Best Tab and Accordion Widget Plugins for WordPress
/18 Best WordPress Membership Plugins and 5 Free Plugins
/25 Best WooCommerce Plugins for Products, Pricing, Payments and More
/10 Best WordPress Twitter Widgets
1 /12 Best Contact Form PHP Scripts for 2020
/20 Popular WordPress User Interface Elements
/10 Best WordPress Star Rating Plugins
/12 Best CSS Animations on CodeCanyon
/12 Best WordPress Booking and Reservation Plugins
/12 Elegant CSS Pricing Tables for Your Latest Web Project
/24 Best WordPress Form Plugins for 2020
/14 Best PHP Event Calendar and Booking Scripts
/Create a Blog for Each Category or Department in Your WooCommerce Store
/8 Best WordPress Booking and Reservation Plugins
/Best Exit Popups for WordPress Compared
/Best Exit Popups for WordPress Compared
/11 Best Tab & Accordion WordPress Widgets & Plugins
/12 Best Tab & Accordion WordPress Widgets & Plugins
1 /New Course: Practical React Fundamentals
/Preview Our New Course on Angular Material
/Build Your Own CAPTCHA and Contact Form in PHP
/Object-Oriented PHP With Classes and Objects
/Best Practices for ARIA Implementation
/Accessible Apps: Barriers to Access and Getting Started With Accessibility
/Dramatically Speed Up Your React Front-End App Using Lazy Loading
/15 Best Modern JavaScript Admin Templates for React, Angular, and Vue.js
/15 Best Modern JavaScript Admin Templates for React, Angular and Vue.js
/19 Best JavaScript Admin Templates for React, Angular, and Vue.js
/New Course: Build an App With JavaScript and the MEAN Stack
/Hands-on With ARIA: Accessibility Recipes for Web Apps
/10 Best WordPress Facebook Widgets
13 /Hands-on With ARIA: Accessibility for eCommerce
/New eBooks Available for Subscribers
/Hands-on With ARIA: Homepage Elements and Standard Navigation
/Site Accessibility: Getting Started With ARIA
/How Secure Are Your JavaScript Open-Source Dependencies?
/New Course: Secure Your WordPress Site With SSL
/Testing Components in React Using Jest and Enzyme
/Testing Components in React Using Jest: The Basics
/15 Best PHP Event Calendar and Booking Scripts
/Create Interactive Gradient Animations Using Granim.js
/How to Build Complex, Large-Scale Vue.js Apps With Vuex
1 /Examples of Dependency Injection in PHP With Symfony Components
/Set Up Routing in PHP Applications Using the Symfony Routing Component
1 /A Beginner’s Guide to Regular Expressions in JavaScript
/Introduction to Popmotion: Custom Animation Scrubber
/Introduction to Popmotion: Pointers and Physics
/New Course: Connect to a Database With Laravel’s Eloquent ORM
/How to Create a Custom Settings Panel in WooCommerce
/Building the DOM faster: speculative parsing, async, defer and preload
1 /20 Useful PHP Scripts Available on CodeCanyon
3 /How to Find and Fix Poor Page Load Times With Raygun
/Introduction to the Stimulus Framework
/Single-Page React Applications With the React-Router and React-Transition-Group Modules
12 Best Contact Form PHP Scripts
1 /Getting Started With the Mojs Animation Library: The ShapeSwirl and Stagger Modules
/Getting Started With the Mojs Animation Library: The Shape Module
/Getting Started With the Mojs Animation Library: The HTML Module
/Project Management Considerations for Your WordPress Project
/8 Things That Make Jest the Best React Testing Framework
/Creating an Image Editor Using CamanJS: Layers, Blend Modes, and Events
/New Short Course: Code a Front-End App With GraphQL and React
/Creating an Image Editor Using CamanJS: Applying Basic Filters
/Creating an Image Editor Using CamanJS: Creating Custom Filters and Blend Modes
/Modern Web Scraping With BeautifulSoup and Selenium
/Challenge: Create a To-Do List in React
1 /Deploy PHP Web Applications Using Laravel Forge
/Getting Started With the Mojs Animation Library: The Burst Module
/10 Things Men Can Do to Support Women in Tech
/A Gentle Introduction to Higher-Order Components in React: Best Practices
/Challenge: Build a React Component
/A Gentle Introduction to HOC in React: Learn by Example
/A Gentle Introduction to Higher-Order Components in React
/Creating Pretty Popup Messages Using SweetAlert2
/Creating Stylish and Responsive Progress Bars Using ProgressBar.js
/18 Best Contact Form PHP Scripts for 2022
/How to Make a Real-Time Sports Application Using Node.js
/Creating a Blogging App Using Angular & MongoDB: Delete Post
/Set Up an OAuth2 Server Using Passport in Laravel
/Creating a Blogging App Using Angular & MongoDB: Edit Post
/Creating a Blogging App Using Angular & MongoDB: Add Post
/Introduction to Mocking in Python
/Creating a Blogging App Using Angular & MongoDB: Show Post
/Creating a Blogging App Using Angular & MongoDB: Home
/Creating a Blogging App Using Angular & MongoDB: Login
/Creating Your First Angular App: Implement Routing
/Persisted WordPress Admin Notices: Part 4
/Creating Your First Angular App: Components, Part 2
/Persisted WordPress Admin Notices: Part 3
/Creating Your First Angular App: Components, Part 1
/How Laravel Broadcasting Works
/Persisted WordPress Admin Notices: Part 2
/Create Your First Angular App: Storing and Accessing Data
/Persisted WordPress Admin Notices: Part 1
/Error and Performance Monitoring for Web & Mobile Apps Using Raygun
/Using Luxon for Date and Time in JavaScript
7 /How to Create an Audio Oscillator With the Web Audio API
/How to Cache Using Redis in Django Applications
/20 Essential WordPress Utilities to Manage Your Site
/Introduction to API Calls With React and Axios
/Beginner’s Guide to Angular 4: HTTP
/Rapid Web Deployment for Laravel With GitHub, Linode, and RunCloud.io
/Beginners Guide to Angular 4: Routing
/Beginner’s Guide to Angular 4: Services
/Beginner’s Guide to Angular 4: Components
/Creating a Drop-Down Menu for Mobile Pages
/Introduction to Forms in Angular 4: Writing Custom Form Validators
/10 Best WordPress Booking & Reservation Plugins
/Getting Started With Redux: Connecting Redux With React
/Getting Started With Redux: Learn by Example
/Getting Started With Redux: Why Redux?
/Understanding Recursion With JavaScript
/How to Auto Update WordPress Salts
/How to Download Files in Python
/Eloquent Mutators and Accessors in Laravel
1 /10 Best HTML5 Sliders for Images and Text
/Site Authentication in Node.js: User Signup
/Creating a Task Manager App Using Ionic: Part 2
/Creating a Task Manager App Using Ionic: Part 1
/Introduction to Forms in Angular 4: Reactive Forms
/Introduction to Forms in Angular 4: Template-Driven Forms
/24 Essential WordPress Utilities to Manage Your Site
/25 Essential WordPress Utilities to Manage Your Site
/Get Rid of Bugs Quickly Using BugReplay
1 /Manipulating HTML5 Canvas Using Konva: Part 1, Getting Started
/10 Must-See Easy Digital Downloads Extensions for Your WordPress Site
/22 Best WordPress Booking and Reservation Plugins
/Understanding ExpressJS Routing
/15 Best WordPress Star Rating Plugins
/Creating Your First Angular App: Basics
/Inheritance and Extending Objects With JavaScript
/Introduction to the CSS Grid Layout With Examples
1Performant Animations Using KUTE.js: Part 5, Easing Functions and Attributes
Performant Animations Using KUTE.js: Part 4, Animating Text
/Performant Animations Using KUTE.js: Part 3, Animating SVG
/New Course: Code a Quiz App With Vue.js
/Performant Animations Using KUTE.js: Part 2, Animating CSS Properties
Performant Animations Using KUTE.js: Part 1, Getting Started
/10 Best Responsive HTML5 Sliders for Images and Text (Plus 3 Free Options)
/Single-Page Applications With ngRoute and ngAnimate in AngularJS
/Deferring Tasks in Laravel Using Queues
/Site Authentication in Node.js: User Signup and Login
/Working With Tables in React, Part Two
/Working With Tables in React, Part One
/How to Set Up a Scalable, E-Commerce-Ready WordPress Site Using ClusterCS
/New Course on WordPress Conditional Tags
/TypeScript for Beginners, Part 5: Generics
/Building With Vue.js 2 and Firebase
6 /Best Unique Bootstrap JavaScript Plugins
/Essential JavaScript Libraries and Frameworks You Should Know About
/Vue.js Crash Course: Create a Simple Blog Using Vue.js
/Build a React App With a Laravel RESTful Back End: Part 1, Laravel 5.5 API
/API Authentication With Node.js
/Beginner’s Guide to Angular: Routing
/Beginners Guide to Angular: Routing
/Beginner’s Guide to Angular: Services
/Beginner’s Guide to Angular: Components
/How to Create a Custom Authentication Guard in Laravel
/Learn Computer Science With JavaScript: Part 3, Loops
/Build Web Applications Using Node.js
/Learn Computer Science With JavaScript: Part 4, Functions
/Learn Computer Science With JavaScript: Part 2, Conditionals
/Create Interactive Charts Using Plotly.js, Part 5: Pie and Gauge Charts
/Create Interactive Charts Using Plotly.js, Part 4: Bubble and Dot Charts
Create Interactive Charts Using Plotly.js, Part 3: Bar Charts
/Awesome JavaScript Libraries and Frameworks You Should Know About
/Create Interactive Charts Using Plotly.js, Part 2: Line Charts
/Bulk Import a CSV File Into MongoDB Using Mongoose With Node.js
/Build a To-Do API With Node, Express, and MongoDB
/Getting Started With End-to-End Testing in Angular Using Protractor
/TypeScript for Beginners, Part 4: Classes
/Object-Oriented Programming With JavaScript
/10 Best Affiliate WooCommerce Plugins Compared
/Stateful vs. Stateless Functional Components in React
/Make Your JavaScript Code Robust With Flow
/Build a To-Do API With Node and Restify
/Testing Components in Angular Using Jasmine: Part 2, Services
/Testing Components in Angular Using Jasmine: Part 1
/Creating a Blogging App Using React, Part 6: Tags
/React Crash Course for Beginners, Part 3
/React Crash Course for Beginners, Part 2
/React Crash Course for Beginners, Part 1
/Set Up a React Environment, Part 4
1 /Set Up a React Environment, Part 3
/New Course: Get Started With Phoenix
/Set Up a React Environment, Part 2
/Set Up a React Environment, Part 1
/Command Line Basics and Useful Tricks With the Terminal
/How to Create a Real-Time Feed Using Phoenix and React
/Build a React App With a Laravel Back End: Part 2, React
/Build a React App With a Laravel RESTful Back End: Part 1, Laravel 9 API
/Creating a Blogging App Using React, Part 5: Profile Page
/Pagination in CodeIgniter: The Complete Guide
/JavaScript-Based Animations Using Anime.js, Part 4: Callbacks, Easings, and SVG
/JavaScript-Based Animations Using Anime.js, Part 3: Values, Timeline, and Playback
/Learn to Code With JavaScript: Part 1, The Basics
/10 Elegant CSS Pricing Tables for Your Latest Web Project
/Getting Started With the Flux Architecture in React
/Getting Started With Matter.js: The Composites and Composite Modules
Getting Started With Matter.js: The Engine and World Modules
/10 More Popular HTML5 Projects for You to Use and Study
/Understand the Basics of Laravel Middleware
/Iterating Fast With Django & Heroku
/Creating a Blogging App Using React, Part 4: Update & Delete Posts
/Creating a jQuery Plugin for Long Shadow Design
/How to Register & Use Laravel Service Providers
2 /Unit Testing in React: Shallow vs. Static Testing
/Creating a Blogging App Using React, Part 3: Add & Display Post
/Creating a Blogging App Using React, Part 2: User Sign-Up
20 /Creating a Blogging App Using React, Part 1: User Sign-In
/Creating a Grocery List Manager Using Angular, Part 2: Managing Items
/9 Elegant CSS Pricing Tables for Your Latest Web Project
/Dynamic Page Templates in WordPress, Part 3
/Angular vs. React: 7 Key Features Compared
/Creating a Grocery List Manager Using Angular, Part 1: Add & Display Items
New eBooks Available for Subscribers in June 2017
/Create Interactive Charts Using Plotly.js, Part 1: Getting Started
/The 5 Best IDEs for WordPress Development (And Why)
/33 Popular WordPress User Interface Elements
/New Course: How to Hack Your Own App
/How to Install Yii on Windows or a Mac
/What Is a JavaScript Operator?
/How to Register and Use Laravel Service Providers
/
waly Good blog post. I absolutely love this…