function A () {}　　　　
　　function B(a) {    　　　　　　
　　　　this.a = a;    　　　　
　　}　　　
　　function C(a) {　　　　　　
　　　　if (a) {　　　　　　　　
　　　　　　this.a = a;　　　　　　
　　　　}　　　　
　　}　　
　　A.prototype.a = 1
　　B.prototype.a = 1;
　　C.prototype.a = 1;　 
　　console.log(new A().a); // 1    　 　　　
　　console.log(new B().a); // undefined    　　　　
　　console.log(new C(2).a); // 2

　　function Fn() {
　　　　console.log(1);
　　}
　　var fn = new Fn()；
　　console.log(fn); 　　　　　　　　　　　　　　　　　　　　　　　　　　　　// FN
　　console.log(fn.__proto__ == Fn.prototype); 　　　　　　　　　　　　 // true
　　console.log(Fn.__proto__ == Function.prototype); 　　　　　　　　  // true
　　console.log(Function.prototype.__proto__ == Object.prototype);   // true
　　console.log(Object.prototype.__proto__); 　　　　　　　　　　　　　　// null 

　　class Animal {
　　　　constructor(){
　　　　　　this.type = ‘animal‘
　　　　}
　　　　says(say){
　　　　　　console.log(this.type + ‘ says ‘ + say)
　　　　}
　　}
　　let animal = new Animal()
　　animal.says(‘hello‘) 　　　　　　　　　　　// animal says hello
　　console.log(animal.constructor); 　　　　// FUN Animal
　　class Cat extends Animal {
　　　　constructor(){
　　　　　　super(); //修改this指向
　　　　　　this.type = ‘cat‘
　　　　}
　　}
　　let mini = new Cat();

　　console.log(mini.constructor == Cat); //    true 实例的constructor指向构造函数
　　console.log(mini.type);    // cat
　　console.log(mini.__proto__ == Cat.prototype);    // true
　　console.log(Cat.prototype.__proto__ == Animal.prototype); // true
　　console.log(Animal.prototype.__proto__ == Object.prototype);// true
　　console.log(Object.prototype.__proto__); // true

1. 最近的作用域声明过，则去就近取
　　var tt = "a";
　　function test(){ 
　　　　//函数内部作用域声明过，所以会就近取。var 有声明提升。 
　　　　//相当于在本作用域前声明
　　　　console.log(tt); // undefined
　　　　var tt = "b" 
　　　　console.log(tt); // b
　　}
　　test();

　　function test2(){ 
　　　　//函数内部作用域没有声明过，
　　　　//直接从外部取值，调用。
　　　　console.log(tt); // a
　　}
　　test2();

2. 作用域发生变化
　　var length = "aaa" 　　　　　　　　　　　　　　//若注释这句， window的length就为0
　　function fn(){
　　　　console.log(this.length); 
　　}
　　var obj = {
　　　　length:"bbb",
　　　　test:function(fn){
　　　　　　fn(); 　　　　　　　　　　　　　　　　　　// aaa 　　　　 this 为 window
　　　　　　console.log(this.length); 　　　　　　·// bbb 　　　　 this 为 obj
　　　　　　arguments[0](); 　　　　　　　　　　　　// 1 　　　　　　this 为 arguments 对象   arguments的length为1
　　　　}
　　}
　　obj.test(fn);

3. this 指向
　　function fn(a,b){
　　　　alert(this+","+a);
　　}
　　fn.call("web",4,10)    　　　　 　　// web,4

　　var _name = "window name";
　　var hero = {
　　　　_name:"John Doe",
　　　　getName:function(){
　　　　　　return this._name;
　　　　}
　　}
　　var st=hero.getName;
　　console.log(st()); 　　　　　　　　　　　　// window name 此处this为window
　　console.log(hero.getName()) 　　 　　　　// John Doe 此处this为hero对象

4. 原型，继承
　　function SuperType(){ 
　　　　this.car="宝马";
　　　　this.home="大别墅";
　　}
　　function SubType(){ 

　　}

　　SubType.prototype=new SuperType() 
　　var pp=new SubType()
　　console.log(pp.car) 　　　　　　　　　　// 宝马

5. 函数别名作用域

　　var func = function a (){
　　　　console.log(typeof a); // function
　　}
　　func();
　　console.log(typeof a) // undefined

　　// 在函数内部可以找到a,
　　// 但在外部a不存在，只有func;

6. 函数内修改值
　　var a = 1; 
　　var obj = {b:2};
　　var fn = function(){};
　　fn.c = 3;
　　function test(x,y,z){
　　　　x = 4;
　　　　y.b = 5;
　　　　z.c = 6;
　　　　return z
　　}
　　test(a,obj,fn);    
　　console.log(a+obj.b+fn.c); // 12    1, 5, 6

　　// 在函数内部，若直接修改参数的值，该值不会传递在外部，
　　// 但修改参数内部的某属性时，则可以改变

7. 作用域优先级问题
　　var a = 1;
　　function fn(a){
　　　　console.log(a);
　　　　var a = 3; 
　　　　function a (){}; 
　　}
　　fn(2); // function

　　// 函数作用域同名变量，函数优先打印出来，其次是参数，再然后是局部变量，最后是全局变量。
　　// 那么意味着，暂且抛开全局变量不谈，局部变量 var 先声明提升，再然后是参数，最后是函数。
　　// 所以在程序开始运行的时候只能找到函数的值。
　　// 可能语言描述不清，看例子即可。

　　// 若注释 function a (){}; 打印值为 2 
　　var a = 1;
　　function fn(a){
　　　　console.log(a);
　　　　var a = 3; 
　　}
　　fn(2); 　　　　　　// 2

　　// 若再去掉参数 打印值为 undefined 声明提升。
　　var a = 1;
　　function fn(){
　　console.log(a);
　　　　var a = 3; 
　　}
　　fn(); 

　　// 若再去掉var a = 3; 打印值为 1
　　var a = 1;
　　function fn(){
　　　　console.log(a);
　　}
　　fn(); 

　　// 整体声明提升遵循这样一个规律， 局部变量 var > 参数 > 函数