Deividy'

github source code

video

O unico jeito de criar escopo em JavaScript é definindo uma função, sempre que uma função é definida ela cria um escopo, esse escopo tem uma ligação com o escopo de onde a função foi definida, e isso é o que conhecemos como Scope Chain, ou cadeia de escopo.

Por definição toda função em JavaScript é um closure, pois são objetos, e tem uma cadeia de escopo associada a elas.

Ou seja:

var scope = 'global';

function fnOuter() {
    console.log(scope);         // => undefined
    var scope = 'outer';

    return (function() {
        console.log(scope);     // => 'outer'
        scope = 'inner';
        return scope;
    }());
}

console.log(scope)  // => 'global'
fnOuter();          // => 'inner'

Tudo em JavaScript, com exceção de null e undefined, é um objeto, até mesmo os valores primitivos (String, Number or Boolean) herdam de Object.prototype. A diferença é que os valores primitivos são objetos imutáveis. Isso quer dizer que mesmo sendo objetos não podemos setar propriedades neles, podemos apenas ‘pegar’ suas propriedades/métodos (Isso não quer dizer que não podemos modificar os seus prototypes).

Quando tentamos setar alguma propriedade em algum valor primitivo, ao invés do interpretador retornar um erro, ele cria um objeto temporário para isso, conhecido como Wrapper Object, e em seguida exclui esse objeto.

Wrapper objects são os objetos criados temporariamente quando setamos alguma propriedade em um valor primitivo.

var s = 'Deividy';    // => undefined
s.test = 123;         // => 123
s.test;               // => undefined;

var b = true;         // => undefined
b.test = 123;         // => 123
b.test;               // => undefined;

Boolean.prototype.testMethod = function() { 
    return "test”; 
};

true.testMethod()     // => test

var S = new String(‘Deividy’);       // => undefined
S;                                   // => String { 0:’D', 1:’e', 2:’i', 3:’v', 4:’i', 5:’d', 6:’y’ };
S.toString();                        // => Deividy
S.test = 123;                        // => null
S.test;                              // => 123

Remember: Valores primitivos são imutáveis, objetos são mutáveis.

Definições de variáveis e funções, são ‘hoisted’, ao topo da função onde foram definidos.

Considere o seguinte código JavaScript:

fnExpression();          // => throw TypError!
var fnExpression = function() {
    return "I'm a expression assigned to a variable";
}
fnExpression();         // => "I'm a expression assigned to a variable"

fnStatement();          // => "I'm a statement with name"
fuction fnStatement() {
    return "I'm a statement with name";
}
fnStatement();          // => "I'm a statement with name"

var scope = 'global';
function fn() {
    return scope;          
    var scope = 'local';
}
fn();                   // => undefined

O interpretador JavaScript transforma nisso:

var fnExpression, scope;
function fnStatement() {
    return "I'm a statement with name";
}
function fn() {
    var scope;
    return scope;
    scope = 'local';
}

fnExpression();
fnExpression = function() {
    return "I'm a expression assigned to a variable";
}
fnExpression();

fnStatement();
fnStatement();

scope = 'global';
fn();