function

js

var x=2;
A();
var A=function(){
   var x=5;
   B();
}
var B=function(){
   console.log(x);
}

Result: 2

Even though B is called within A and A has its own x, what actually matters as far as resolving where x is coming from is its outer reference. And B is defined within the global scope. Therefore, the outer reference of function B is the global scope, not function A. What this means is that it does not matter where a particular function is executed. What matters as far as resolving scope of a variable is concerned is where that function is physically defined. Function B is physically defined inside the global scope. Therefore a reference of x inside function B Is going to look inside function B first. If it doesn't find it it's going to use its outer reference to look for it there and its outer reference is the global scope. Let's jump to the code editor and see an example of this.

null undefined 区别

JavaScript defines seven built-in types, one object and six primitives. Now object type is a collection of name value pairs. It is nothing more than that in JavaScript. A primitive type can only contain a single, immutable value. And remember thar immutable means that once you set it, it cannot be changed. You could create new values based on this values, but you cannot change the original value anymore. Now, there's a particular interesting type called undefined among the primitives, and undefined means variable memory has been allocated, but not value has ever been explicitly set yet. And it's important to distinguish between that and a variable that has never been defined, in which case if you try to use it, you're going to get a reference error.

function factory

function multiply(x,y) {
    return x*y;
    // body...
}
multiply.version="v1.0.0";
console.log(multiply.version);
//function factory
function MakeMultiplier(multiplier){
    var myFunc=function(x){
        return multiplier*x;
    }
    return myFunc;
}
var multiplyBy3=MakeMultiplier(3);
console.log(multiplyBy3(10));
//passing function as argument
function doOperation(x, operation){
    return operation(x);
}
var result=doOperation(50,multiplyBy3);
console.log(result);

constructors and prototype

//Function constructors
function Circle(argument) {
    this.radius=argument;
}
// prototype
Circle.prototype.getArea= function() {
    return Math.PI*Math.pow(this.radius,2);
};
Circle();
var myCircle=new Circle(10);
console.log(myCircle.getArea());

Object literals and "this"

// Object literals and "this"
var literalCircle={
    radius:10,
    getArea:function () {
        var self=this;
        console.log(this);
        function increaseRadius(){
          self.radius=self.radius*3;
        }
        increaseRadius();
        return Math.PI*Math.pow(this.radius,2)
    }
};
console.log(literalCircle.getArea());

闭包

子包可以一层层链式访问父包

Fake namespace

js1.js

var namesapce1={};
namespace1.name="zh";
namespace1.sayhi=function(name){
   console.log("hi"+namespace1.name);
}

js2.js

var namesapce2={};
namespace2.name="zh2";
namespace2.sayhi=function(name){
   console.log("hi"+namespace2.name);
}

html

namespace1.sayhi();
namespace2.sayhi();

Immediately Invoked Function

Immediately Invoked Function Expressions are usually used to place code into its own execution context not to conflict with the global scope.

(function(name){
  console.log("hello"+name);
  })("YY");
(function(window){
var namespace1={};
namespace1.name="zh";
namespace1.sayhi=function(name){
   console.log("hi"+namespace1.name);
window.namespace1=namespace1;
}
}
)(window);