AZ JavaScript

var earth = function(spec) {
    var that = planet{spec};   // No need for new keyword!
    that.peopleLeave = function() {
        // ... people leave
    }
    return that;
}

var jupiter = function(spec) {
    var that = planet(spec); 
    that.peopleArrive = function() {
       // .. people arrive
    }
    return that;
}

Теперь приведите Землю и Юпитер в движение …

var myEarth = earth({name:"earth",numberofmoons:1});
var myjupiter=jupiter({name:"jupiter",numberofmoons:66});

Три ключевых момента здесь:

1. Есть повторное использование кода.
2. Существует инкапсуляция. Свойства name и numberOfMoons инкапсулированы.
3. Дочерние объекты могут добавлять свои специфические функции.

Теперь объяснение синтаксиса:

1. Планета базового объекта принимает некоторые данные в объекте спецификации .
2. Базовый объект планеты создает замыкания, называемые тем, что возвращается. , Что объект имеет доступ ко всему , в спецификации объекта. Но больше ничего не делает. Это обеспечивает уровень инкапсуляции.
3. Дочерние объекты, Земля и Юпитер , устанавливают свои собственные данные и передают их объекту базовой планеты.
4. Объект планеты возвращает замыкание, которое содержит базовую функциональность. Дочерние классы получают это замыкание и добавляют к нему дополнительные методы и переменные.

Подъем 

Независимо от того, где переменные объявлены в функции, javascript будет «поднимать» их, что означает, что они ведут себя так, как если бы они были объявлены в верхней части функции.

mylocation = "dublin"; // global variable
function outputPosition() {
    console.log(mylocation);  // outputs "undefined" not "dublin"
    var mylocation = "fingal" ; 
    console.log(mylocation);  // outputs "fingal"
}
outputPosition(); 

В приведенной выше функции объявление var в функции означает, что первый журнал «увидит» mylocation в области действия функции, а не тот, который объявлен в глобальной области действия. После объявления локальная переменная mylocation будет иметь значение «undefined», поэтому сначала она выводится. Функции, которые назначены переменным, также могут быть подняты. Единственное отличие состоит в том, что когда функции поднимаются, их определения также — не только их объявления.

Непосредственные функциональные выражения

Непосредственные функциональные выражения выполняются, как только они определены.

(function() {

    console.log("I ain't waiting around");

}());

Здесь нужно отметить два аспекта синтаксиса. Во-первых, сразу после определения функции есть (), это заставляет ее выполняться. Во-вторых, функция может выполняться, только если она является выражением функции, а не объявлением функции. Функция external () делает функцию выражением. Другой способ определить непосредственное выражение функции:

var anotherWay = function() {
    console.log("I ain't waiting around");
}()

JSON

JavaScript Object Notation (JSON) — это нотация, используемая для представления объектов. Это очень похоже на формат, используемый для литералов Javascript Object, за исключением того, что имена свойств должны быть заключены в кавычки. Формат JSON не является эксклюзивным для javascript; он может использоваться любым языком (Python, Ruby и т. д.). JSON позволяет легко увидеть, что такое массив и что такое объект. В XML это будет намного сложнее. С внешним документом, таким как XSD, нужно будет ознакомиться. В этом примере у Митта Ромни есть массив, описывающий, кто может за него болеть, и объект, который является его сыном.

{"name": "Mitt Romney", "party": "republicans", "scary": "of course", "romneysMostLikelyVoters": ["oilguzzlers", "conservatives"], son : {name:'George Romney}}

Слабая типизация

Javascript свободно набирается. Это означает, что переменные не нужно вводить. Это также означает, что нет сложной иерархии классов и нет приведения.

var number1 = 50;
var number2 = "51";

function output(varToOutput) {
    // function does not care about what type the parameter passed is.
    console.log(varToOutput);
}
output(number1);  // outputs 50
output(number2);  // outputs 51

Мемоизация

Мемоизация — это механизм, посредством которого функции могут кэшировать данные из предыдущих выполнений.

function myFunc(param){
    if (!myFunc.cache) {
        myFunc.cache = {}; // If the cache doesn't exist, create it.
    }
    if (!myFunc.cache[param]) {
        //... Imagine the code to work out result below
        // is computationally intensive.
        var result = {
            //...
        };
        myFunc.cache[param] = result;  // now result is cached.
    }
    return myFunc.cache[param];
}

Метод

Когда функция сохраняется как свойство объекта, она называется методом.

var myObject {
    myProperty: function () {
       //...
       // the this keyword in here will refer to the myObject instance.
       // This means the "method" can read and change variables in the
       // object.
    }
}

Модули

Цель модулей — сделать базы кода JavaScript более модульными. Функции и переменные объединяются в модуль, и затем модуль может решать, какие функции
и какие переменные может видеть внешний мир — так же, как инкапсуляция работает в объектно-ориентированных парадигмах. В javascript мы создаем модули, комбинируя характеристики замыканий и непосредственные выражения функций.

var bankAccountModule = (function moduleScope() {
    var balance = 0; //private
    function doSomethingPrivate(){  // private method
        //...
    }  
    return { //exposed to public
        addMoney: function(money) {
             //...   
        },
        withDrawMoney: function(money) {
             //...
        },
        getBalance: function() {
            return balance;
    }
}());

В приведенном выше примере у нас есть модуль банковского счета:

• Выражение функции moduleScope имеет свою область видимости. Закрытая переменная balance и закрытая функция doSomethingPrivate существуют только в этой области и видны только функциям в этой области.
• Функция moduleScope возвращает литерал объекта. Это замыкание, которое имеет доступ к закрытым переменным и функциям moduleScope. Свойства возвращаемого объекта являются «общедоступными» и доступны для внешнего мира.
• Возвращенный объект автоматически присваивается bankAccountModule
• Синтаксис немедленной функции ()) используется. Это означает, что модуль инициализируется немедленно.

Поскольку возвращенный объект (замыкание) назначен для
bankAccountModule , это означает, что мы можем получить доступ к
bankAccountModule как:

bankAccountModule.addMoney(20);
bankAccoumtModule.withdrawMoney(15);

По соглашению, имя файла модуля должно соответствовать его пространству имен. Так что в этом примере имя файла должно быть bankAccountModule.js.

DUBLINTECH.myName = "Alex"
DUBLINTECH.myAddress = "Dublin

var ireland = {
    capital: "Dublin",
    getCapital: function () {
        return this.capital;
    }
};

function IrishPersonBoughtInTheBoom(){
}

var mary = new IrishPersonBoughtInTheBoom ();
var tony = new IrishPersonBoughtInTheBoom ();
var peter = new IrishPersonBoughtInTheBoom ();
...

IrishPersonBoughtInTheBoom.prototype.debt = "ouch";

console.log(mary.debt);   // outputs "ouch"
console.log(tony.debt);   // outputs "ouch"
console.log(peter.debt);   // outputs "ouch"

var counter = function() {
    //...
    var count = 0;
    return function () {
        return count = count + 1;
    }
}

var nextValue = counter(); 
nextValue();   // outputs 1
nextValue();   // outputs 2

console.log(typeof "tony");          // outputs string
console.log(typeof 6);               // outputs number
console.log(false);                  // outputs boolean
console.log(this.doesNotExist);   // outputs undefined if the global scope has no such var
console.log(typeof function(){});    // outputs function
console.log(typeof {name:"I am an object"});  //outputs object
console.log(typeof ["I am an array"]) // typedef outputs object for arrays
console.log(typeof null)              // typedef outputs object for nulls

if (myobject === null) {
    ...
}

var myFunction = function () {
    //set up code only to this once
    alert("set up, only called once");

    // set up code now complete.
    // redefine function so that set up code is not re-executed
    myFunction = function() {
         alert("no set up code");
    }
}
myFunction();  // outputs - Set up, only called once
myFunction();  // outputs - no set up code this time
myFunction();  // outputs - no set up code this time

var myFunction = function () {
var noBlockScope = function ( ) {
    if (true) { 
        // you'd think that d would only be visible to this if statement
        var d = 24;   
    }
    if (true) {
        // this if statement can see the variable defined in the other if statement
        console.log(d); 
    }
}
noBlockScope();

function scrum() {
    var numberOfProps = 2,
        numberOfHookers = 1,
        numberOfSecondRows = 2,
        numberOfBackRow = 3
    // function body...
}

console.log(1 == true)    // outputs true
console.log(1 === true)   // outputs false
console.log(45 == "45")   // outputs true
console.log(45 === "45")  // outputs false

// This will output 'Wow, they were all true'
if ({} && {sillyproperty:"sillyvalue"} && [] &&
        ['element'] && function() {} && "string" && 89) {
   console.log("wow, they were all true");
}

// This will out put: 'none of them were true'
if (!("" || undefined || null || 0)) {
    console.log("none of them were true");
}