‚undefined‚ bedeutet, dass eine Variable nicht initialisiert wurde, z.B.:
let myVar;

Eigentlich ist ‚undefined‘ die falsche Benennung, da ja die Variable tatsächlich deklariert wurde! Eine Variable, die nicht deklariert wurde, kann man gar nicht abprüfen. Versucht man das wird das mit Fehlermeldung „… is not defined“ quittiert.

null ist eine Variable nur, wenn ’null‘ explizit zugewiesen wurde:
let myVar = null;

Check for null

myVar === null

Check for undefined

myVar === undefined

Check for null OR undefined

myVar == null

Truthy / Falthy

Als falsy gelten in JS:
0, „“ (leerer String), false, null und undefined

Diese Werte werden als false interpretiert.

„“ ist false!
0 ist false!

Module Pattern

Ziel:
– Objekt mit privaten Variablen erstellen

let person = (function () {
  let name = 'Veronika'; //Private Objektvariable

  return  {
    getName: function () { // Objekt-Methode 1
      return name;
    },
    setName: function (myName){ // Objekt-Methode 2
      name = myName;
    }
  };
})(); // Immediatly invoked function expression

person.name;
// undefined
person.getName();
// 'Veronika'

person.setName('Not Veronika');
person.getName;
// 'Not Veronika'

Das pattern beinhalted eine IIFE.
Ich empfinde das allerdings eher als Limitierung und erbringt bezüglich des Ziels (Objekt mit privater Variable erstellen) nichts.

Revealing Module Pattern

Das RMP unterscheidet sich zum MP nur diesbezüglich, dass das die public Funktionen nicht innerhalb des „return“-Blocks codert werden, sondern derselbige nur referenzen auf die Funktionen enthält:

let person = (function () {
  let privateAge = 0;
  let privateName = 'Andrew';

  function privateAgeOneYear() {
    privateAge += 1;
    console.log(`One year has passed! Current age is ${privateAge}`);
  }

  function displayName() {
    console.log(`Name: ${privateName}`);
  }

  function ageOneYear() {
    privateAgeOneYear();
  }

  return {
    name: displayName,
    age: ageOneYear
  };
})();

Javascript kennt keine Mehrfachvererbung. Jedoch können mittel der Object.assign(target, source) Properties des einen Objektes auf ein anderes übertragen werden:

let target = {};

let source = { number: 7 };

Object.assign(target, source);

console.log(target);
// { number: 7 }

Einem Objekt können auch Properties von mehreren anderen Objekten injiziert werden:

const duck = {
  hasBill: true
};
const beaver = {
  hasTail: true
};
const otter = {
  hasFur: true,
  feet: 'webbed'
};

const platypus = Object.assign({}, duck, beaver, otter);

console.log(platypus);
// { hasBill: true, hasTail: true, hasFur: true, feet: 'webbed' }

Functional Mixins (–> Vererbungsmässige Komposition)

Code zeigt, wie mit Factory Funktionen geschachtelt aufgerufen werden um verschiedenen Eigenschaften/Methoden aus verschiedenen „Klassen“ zu komponieren:

function IceCreamFactory(obj) {
  let isCold = true;

  return Object.assign({}, obj, {
    melt: function () {
      isCold = false;
    },
    isCold: function () {
      return isCold;
    }
  });
}

let iceCream = IceCreamFactory({});

function ConeFactory(obj) {
  let isDry = true;

  return Object.assign({}, obj, {
    soggy: function () {
      isDry = false;
    },
    isDry: function () {
      return isDry;
    }
  });
}

let iceCreamCone = IceCreamFactory(ConeFactory({}));

console.log(iceCreamCone);