JavaScript for beginners

// It means whether they will execute their second operand is dependent on the first.
var name = o && o.getName();
var name = cachedName || (cachedName = getName());

123 == '123'; // true
1 == true; // true

123 === '123' // false
1 === true; // false

var allowed = (age > 18) ? 'yes' : 'no';

var input;
do {
  input = get_input();
} while (inputIsNotValid(input));

for (let myLetVariable = 0; myLetVariable < 5; myLetVariable++) {}

for (var myLetVariable = 0; myLetVariable < 5; myLetVariable++) {}

for (let value of array) {}

for (let property in object) {}

for (var i = 0; i < a.length; i++) {}

['dog', 'cat', 'hen'].forEach(function(currentValue, index, array)) {});

var name = 'kittens';
if (name == 'puppies') {
  name += ' woof';
} else if (name == 'kittens') {
  name += ' meow';
} else {
  name += '!';
}
name == 'kittens meow';

function personFullName() {
  return this.first + " " + this.last;
}

function personFullNameReversed() {
  return this.last + " " + this.first;
}

function Person(first, last) {
  this.first = first;
  this.last = last;
  this.fullName  = personFullName;
  this.fullNameReversed = personFullNameReversed;
}

var s = new Person('Simon', 'Willison');

var obj = new Object;
// or
var obj = {};

// the core of JSON format
var obj = {
  name: 'Carrot',
  _for: 'Max', // since for is a reserved word, _for is used instead.
  details: {
    color: 'orange',
    size: 12
  }
};

// Attribute access
obj.details.color; // orange
obj['details']['size']; // 12

obj.name = 'Simon';
var name = obj['name'];

var user = prompt('what is your key?')
obj[user] = prompt('what is its value?')

////

var person = Object.create(Object.prototype);
person.firstName = "Paul";
person.lastName  = "Irish";

function Person(name, age) {
  this.name = name;
  this.age = age;
}

// Define an object
var you = new Person('You', 24);

// If no return statement is used, it returns undefined.
function add(x, y) {
  var total = x + y;
  return total;
}

// You can also pass in more arguments than the function is expecting.
add(2, 3, 4); // 5

// You can't perform addition on undefined.
add(); // NaN

////

// function avg(...numbers)

// function avg() { arguments[i]... }

function avg(arr) {
  var sum = 0;
  for (var i = 0, j = arr.length; i < j; i++) {
    sum += arr[i];
  }
  return sum / arr.length;
}

avg([2, 3, 4, 5]); // 3.5

// if you want to call a function with an arbitrary array of arguments
avg.apply(null, [2, 3, 4, 5]);

// anonymous function the same as avg function above
var avg = function() {
  var sum = 0;
  for (var i = 0, j = arguments.length; i < j; i++) {
    sum += arguments[i];
  }
  return sum / arguments.length;
};

var a = ['dog', 'cat', 'hen']; // OR

var a = new Array();
a[0] = 'dog';
a[1] = 'cat';
a[2] = 'hen';

a.length; // 3
a.push(item1, item2);
a.toString();
a.join(sep);
a.pop();
a.slice(start[, end]);
a.reverse();

function hello(thing) {
  console.log(this + " says hello " + thing);
}

// The first parameter is thisValue := Bob (here)
hello.call("Bob", "world") //=> Bob says hello world

// We invoked the hello method with this set to "Bob" and a single argument "world".
// This is the core primitive of JavaScript function invocation.

const materials = [' Hydrogen', 'Helium'];

console.log(materials.map(material => material.length)); // [8, 6]

function (a) {
  return a + 100;
}

(a) {
  return a + 100;
}

(a) => a + 100;

a => a + 100;

function (a, b) {
  return a + b + 100;
}

(a, b) => a + b + 100;

let a = 4;
let b = 2;

function () {
  return a + b + 100;
}

let a = 4;
let b = 2;

() => a + b + 100;

function (a, b){
  let chuck = 42;
  return a + b + chuck;
}

(a, b) => {
  let chuck = 42;
  return a + b + chuck;
}

function bob (a){
  return a + 100;
}

let bob = a => a + 100;

(param1, paramN) => {
   let a = 1;
   return a + param1 + paramN;
}

(a=400, b=20, c) => expression

// Create the simplest object
var person = Object.create(null);

person['name'] // undefined

person.name // undefined

////

var Person = Object.create(null);

Object.defineProperty(person, 'firstName', {
  value: "Bob",
  writable: true,
  enumerable: true,
  configurable: true
});

Object.defineProperty(person, lastName, {
  value: "Alice",
  writable: true,
  enumerable: true,
  configurable: true
});

////

// OR

////

// Eliminate the common defaults
var config = {
  writable: true,
  enumerable: true,
  configurable: true
};

var defineProperty = function(obj, name, value) {
  config.value = value;
  Object.defineProperty(obj, name, config);
};

var person = Object.create(null);
defineProperty(person, 'firstName', "Bob");
defineProperty(person, 'lastName', "Alice");

var person = Object.create(null);
defineProperty(person, 'fullName', function() {
  return this.firstName + ' ' + this.lastName;
});

var man = Object.create(man);
defineProperty(man, 'sex', 'male');

var bob = Object.create(man);
defineProperty(bob, 'firstName', 'Bob');
defineProperty(bob, 'lastName', 'Alice');

bob.sex // male
bob.fullName() // Bob Alice

// OR //

var person = Object.create(null);

person['fullName'] = function() {
  return this.firstName + ' ' + this.lastName;
};

var man = Object.create(man);
bob['firstName'] = "Bob";
bob['lastName'] = "Alice";

bob.sex // male
bob.fullName() // Bob Alice

const numbers = [1, 4, 9];
const roots = numbers.map((num) => Math.sqrt(num)); // roots := [1, 2, 3]

const arr = [ {key: 1, value: 10} ]; // [{key: 1, value: 10}]
const newArr = arr.map(({key, value}) -> ({ [key]: value })); // [{1: 10}]

while (true) {}

switch (action) {
  case 'draw':
    drawIt();
    break;
  case 'eat':
    eatIt();
    break;
  default:
    doNothing();
}

// If you try to access a non-existent array index.
typeof a[90]; // undefined