Save Content

Variables are declared with the var keyword. JavaScript is 

 so every variable can hold a value of any data type.

var foo; var bar = 42; var foo, bar, baz; var foo = 42, bar = 'baz', z;

Variables that don’t explicitly get assigned an initial value have the value undefined.

Since ES2015, let and const can be used in addition to var. We will learn how they differ from var later. For now, lets have a look how const differs from var or let: const can be assigned a value only 

ant).
Reassigning a value will either throw an error (in strict mode, see below) or is silently ignored:

const foo = 42; foo = 21; // error or ignored

Valid characters for variable names include 

 start with a letter, _ or $. Not doing so will result in a syntax error.

var π = 3.141; var _foo = π; var 0_bar = '...'; // Syntax error

var foo; console.log(bar); // ReferenceError: bar is not defined.

 to an undeclared variable is valid by default. It will create an 

function foo() { bar = 42; } foo(); console.log(bar); // no error

, assigning to an undeclared variable throws an 

 is a mode of evaluating JavaScript that enforces stricter rules. It was introduced to “deprecate” certain patterns/behaviors that are considered bad or confusing.

Strict mode can be enabled for a JavaScript or a function by putting

Create a local variable with name foo and value 42. Use log(foo) to log the value of foo. Remember to open your browser’s 

1// Create variable2​3//4log(foo);5​RunResetSubmit

 data types. Five of those are so called 

Everything else that is not a value of one of the above types is an

 data type has two values, true and false.

This makes it very easy to work with them, since you don’t have to differentiate between integer values and floating point values.

There are various ways that numeric value can be expressed:

var x = 5; // "integer" var y = -4.2; // "float" var z = 5e3; // = 5 * 10^3

An issue with floating point numbers is the loss of precision, which of course occurs in JavaScript as well:

The maximum integer value that can be used without loss of precision is 253.

Math.pow(2, 53) // 9007199254740992 Math.pow(2, 53) + 1 // 9007199254740992

 are sequences of unicode characters and can either be delimited with a 

 quotation mark. Unlike in other languages, such as PHP, both are interpreted in the exact same way.

JavaScript has two data types to express the 

The difference between those two is subtle and is best explained by how to use them:

undefined is the value JavaScript itself uses to indicate the absence of a value.

null is the value the engineer should use to indicate the absence of a value.

var foo; // no value is assigned, foo has the value undefined var bar = null; // bar is explicitly set to null console.log(foo); // logs "undefined" console.log(bar); // logs "null"

There are other native occurrence of undefined which we will mention later.

 A variable that doesn’t exist cannot be accessed at all (it will throw a reference error). Instead of saying “the variable is undefined” we rather say “the variable is not 

var foo; console.log(foo); // logs `undefined` console.log(bar); // reference error

Everything else besides primitive data type values is an 

 stores. The "keys" of an object are called 

The syntax to create a plain object is {key: value, ...}, which is called an object literal. For example:

Note that the above example doesn’t use 

 around the property names. In an object literal, quotation marks can be be omitted if the property name would also be a 

Here are some more examples of valid and invalid property names in object literals:

var obj = { foo: 0, // valid, could be variable name 'bar': 0, // string literals are always valid 123: 0, // number literals are always valid 1.5: 0, // ^ foo-bar: 0, // invalid, would not be a valid variable name 'foo-bar': 0, // string literals are alwaus valid };

 No matter which value or syntax you use for a property name, the value will always be converted to a 

ES2015 adds two extensions to object values and object literals:

 are can be used as property names. They are not converted to strings.

var foo = 42; var obj = { [foo]: 0, }; // creates {42: 0}

Just like in Java and other object-oriented programming languages, objects are represented as 

. That means if a variable has an object as a value, it really has a reference to that object.

var user = {name: 'Tom'}: ┌──────────────┐ ┌─────┬──────────┐ │ Object#123 │ │user │ ref:123 ◆┼──────▶├──────┬───────┤ └─────┴──────────┘ │ name │ "Tom" │ └──────┴───────┘

Assigning the value to another variable makes both variables point to the same object:

var owner = user; ┌─────┬──────────┐ ┌──────────────┐ │user │ ref:123 ◆┼──┐ │ Object#123 │ ├─────┼──────────┤ ├───▶├──────┬───────┤ │owner│ ref:123 ◆┼──┘ │ name │ "Tom" │ └─────┴──────────┘ └──────┴───────┘

Assigning to user.name will therefore also “change” owner.name:

user.name = 'Joe'; console.log(user.name, owner.name); // Joe, Joe┌─────┬──────────┐ ┌──────────────┐ │user │ ref:123 ◆┼──┐ │ Object#123 │ ├─────┼──────────┤ ├───▶├──────┬───────┤ │owner│ ref:123 ◆┼──┘ │ name │ "Joe" │ └─────┴──────────┘ └──────┴───────┘

But assigning a new value to either user or owner will result in only that variable referring to the new value. The other variable will still refer to the same value.

owner = {name: 'Kim'}; ┌──────────────┐ │ Object#123 │ ┌───▶├──────┬───────┤ ┌─────┬──────────┐ │ │ name │ "Joe" │ │user │ ref:123 ◆┼──┘ └──────┴───────┘ ├─────┼──────────┤ │owner│ ref:456 ◆┼──┐ ┌──────────────┐ └─────┴──────────┘ │ │ Object#456 │ └───▶├──────┬───────┤ │ name │ "Kim" │ └──────┴───────┘

The JavaScript standard defines a couple of 

 with additional properties and special internal behavior, must notably 

, unlike other languages, such as Java, which are 

In short: A prototype is just another object. If an object A has this special connection to object B, then we say that "B is the prototype of A".

In addition to having “external” properties that can be accessed from code, objects also have 

 properties/state. These cannot be accessed from code and their concrete implementation depends on the JavaScript engine.

 property [[Prototype]] (internal properties are usually denoted with [[...]] around the name). This property points to another object.

JavaScript Basics

When working with Node and React, you will need to use the command line. On the Mac, this is called the Terminal. On a PC, it is called the Command Prompt. Run the following commands to check your current version on node and npm. If needed, instructions on how to install or upgrade are below.

First, check to see if you have Node.js installed:

If this returns a version number, Node.js is installed. If the command is not found, you'll need to 

 from the Node.js website. Download the installer, run it, and follow the instructions.

Then, if you are running anything less than version 8, you will need to update npm:

Make sure to run the Command Prompt with administrator privileges:

Yarn is a package manager created at Facebook. It is a compatible alternative to npm. Yarn's use is not required, but you can optionally install it if you like:

Finally, there are some nice options for switching Node versions. This is not required, but you can optionally install one of these version mangers:

Install Node Version Manager - mac only (optional)

This repository links to samples hosted on various platforms, so that you can immediately begin interacting with the files. For smaller samples, we've linked to JSBins to allow you to run the sample with limited overhead. We also have links to CodeSandboxes and other repos if the samples are more in-depth.

Finally, we have some links to resources and official documentation for the libraries that we will be using:

<a class="jsbin-embed" href="https://jsbin.com/hopomod/1/embed?js,console">JS Bin on jsbin.com</a><script src="https://static.jsbin.com/js/embed.min.js?4.1.8"></script>

If you take the time to understand what is going on behind the scenes you will be more efficient, especially when it comes time to debug.

Blog.

Building Up To React

Installing Node.js and NPM

Update npm on Mac

Update npm on PC

Installing the React Tools

Working with the Files

React Resources

Examples:

Pure React

Samples

Page Setup

React Elements

React Components

Comments:

More Stories

Save Content

JavaScript Basics