Hello world

strict mode:

"use strict";

case sensitive
numbers (all numbers are 64-bit floating type)
strings ('' and ""), there is no character type
Like python, strings are immutable
strings uses utf-16, like c#
array
boolean, true and false
null and undefined
string interpolation
`hello ${someVariable}`
semicolon is optional. Better to always add it
garbage collector
== supports type conversion
=== does not support type conversion. (Recommended to use this one)

console.log('hello world')
console.log(eval('3 + 5'))

To write multi-line javascript, use shift + Enter for a new line.

(function(){
  "use strict";
  /* Start of your code */
  function greetMe(yourName) {
    alert('Hello ' + yourName);
  }

  greetMe('World');
  /* End of your code */
})();

It is case sensitive. Statements are separated by ;. Comments are the same as in C/C++.

variables

./code/hello_world/variables.js

// use const to define a constant
const pizza = true;
console.log(pizza); // true

var foo = 'foo';
if (foo) {
  var foo = 'fooz'
  console.log('foo is', foo); // foo is fooz
}

// note it outputs foo is fooz below since
// we use `var` inside the `if` statement
console.log('foo is', foo); // foo is fooz

var bar = 'bar';

if (bar) {
  let bar = 'barz'
  console.log('bar is', bar); // foo is barz
}

// note it outputs bar is bar below since
// we use `let` inside the `if` statement
console.log('bar is', bar); // foo is bar

// we should use let as much as possible
// variables defined by `let` is scoped inside a block {}

array = [];
for (var i = 0; i < 3; i++) {

  array.push(function() { console.log(i); });
}
array[0](); // 3
array[1](); // 3
array[2](); // 3
// since we are using var in the for loop, the closures capture the same i

array2 = [];
for (let k = 0; k < 3; k++) {

  array2.push(function() { console.log(k); });
}
array2[0](); // 0
array2[1](); // 1
array2[2](); // 2

array

./code/hello_world/array.js

let a = [ 1, 2, 3 ];
function sum(arr) {
  let s = 0;
  for (let x of arr) {
    s += x;
  }
  return s;
}
// Sum of the array [1,2,3] is 6
console.log('Sum of the array [' + a + '] is ' + sum(a));

function sum2(arr) {
  let s = 0;
  for (let i = 0; i != arr.length; ++i) {
    s += arr[i];
  }
  return s;
}
console.log(sum2(a)); // 6

Note that there are two ways to iterate an array:

for(let x of array)

for(let i = 0; i != array.length; ++i) { ... }

To run the above code, use:

node array.js

class

./code/hello_world/class.js

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }

  distance() { return Math.sqrt(this.x * this.x + this.y * this.y); }
}

let p = new Point(1, 1);
console.log(p.distance()); // 1.4142135623730951

It defines a Point class with two fields x, y. Point has two methods: a constructor and a method distance().

Note that class names are by convention capitalized.

template strings

./code/hello_world/template_strings.js

let a = "a";
let b = "b";
console.log("a is " + a + ", b is " + b); // a is a, b is b

// using string interpolation
console.log(`a is ${a}, b is ${b}`); // a is a, b is b

// Note that it uses `${}`.
// It preserves spaces and line breaks

// multiline examples
let s = `
a is ${a}
b is ${b}
`
console.log(s);

Note that it is similar to the F-string, f" ", f' ', f""" """, f''' '''` in Python.

functions

./code/hello_world/functions.js

// note that is supports default arguments
function hello(msg = "hi") { console.log(msg); }
// the above is a function declaration, it is hoisted to the top
// in other words, we can invoke it before seeing it.

hello();        // hi
hello('world'); // world

// this is a function expression.
const hi = function(msg = 'hi') { console.log(msg); };
hi();        // hi
hi('world'); // world

const add = function(a, b = 1) { return a + b; };
console.log(add(1, 2)); // 3
console.log(add(1));    // 2

// arrow functions
// there is no keyword `function` and no `return`.
const inc = (a, b = 1) => a + b;
console.log(inc(1, 2)); // 3
console.log(inc(1));    // 2

const dec = a => a - 1;
console.log(dec(10)); // 9

// for multiline statement, use {}
const sub = a => {
  let b = a - 1;
  return b;
};
console.log(sub(100)); // 99

Note that it does not have keyword arguments.