javascript学习笔记

主要针对java与javascript之间的差别学习。

数据类型

首先加入print方法：

function print(s) {
     console.log(s);
 }

apply与call

实现了调用的函数的this的引用，可以指向任何指定的对象。

var obj = { x:2 ,
    doit: function() { print('method is called.' + this.x); }
};
var obj2 = { x:3 };
obj.doit.apply(obj);
obj.doit.call(obj);

//不同点，apply后面的参数使用**数组**，而call是依次传递。
var obj = { 
    x:2 , 
    doit: function(a,b) {
  print('method is called.' + this.x);
  print(a+b);  } 
};
var obj2 = {   x:3 };  
obj.doit.apply(obj,[2,3]);
obj.doit.call(obj,2,3);

javascript中类的生成

• 在基于类的面向对象方式中，对象（object）依靠类（class）来产生。
  而在基于原型的面向对象方式中，对象（object）则是依靠构造器（constructor）利用原型（prototype）构造出来的。

  1. 声明对象直接量:JSON

    var obj = {
        name: "jack",
        eat: "bread"
    }
    console.log(typeof obj);

1. 使用构造函数生成一个新的对象

var Foo = function(name){
    this.name = name; //私有属性
}
//原型方法和属性,被继承时候才会调用
Foo.prototype.run = function(){
    print(this.name);
}
var kick = new Foo("kick");
console.log(typeof kick);
console.log(kick.name);
kick.run();

1. 使用使用Object.create
   下面为Object.create的内部构造：

Object.create = function (parent) {
    function F() {}
    F.prototype = parent;
    return new F();
};

它先是声明了一个构造器,然后将其原型设置为你想要的值,最后返回生成的新对象.
下面是原型继承代码：

var Point = {
    x: 0,
    y: 0,
    print: function () { console.log(this.x, this.y); }
};
var p = Object.create(Point); //new一个对象
p.x = 10;
p.y = 20;
p.print(); // 10 20

首先是声明了一个构造函数,构造函数和普通函数有什么区别?
构造函数可以使用new调用,生成一个新的对象. 如果想要在对象上添加方法,可以将方法写在对象的原型上.
子类继承父类,只需要把父对象复制给自对象的原型上即可.

原型继承

• 格式为：
  类名.prototype.方法名 = function(方法的参数) {方法体}

function MyClass(x, y) {
     this.x=x;
     this.y=y;
}
MyClass.prototype.show = function() {
     print(this.x,this.y);
};
var obj = new MyClass(3, 2);
obj.show();

• 原型链

有两个前提：
1. 所有的对象都有prototype属性。
2. 所有对象都含有一个隐藏的连接，用来指向在对象生成过程中所使用的构造函数的prototype对象。

对象对属性的读取顺序：
1. 对象自身的属性。
2. 隐式链接所引用的对象(构造函数的prototype对象)的属性。
3. 引用对象的引用对象的属性，递归至查找完毕。

原型链的操作：

//读取
function MyClass() {  this.x = 'x in MyClass';  } 
var obj = new MyClass();
print(obj.x);
print(obj.z);
MyClass.prototype.z = 'z in MyClass.prototype';
print(obj.z); 
//x in MyClass
//undefined

//写入
var obj1 = new MyClass();
obj.z = 'override';
print(obj.z);
print(obj1.z);
//override
//z in MyClass.prototype

//删除
print(delete obj.z);
print(obj.z);
//true
//z in MyClass.prototype
//删除自身的属性，却无法删除原型链中的属性。

• 原型对象
  对象的隐式链接(_proto属性)所引起的对象称为原型对象。
  MyClass.prototype与obj.proto指同一对象，MyClass.prototype的引用对象并不是MyClass的原型对象

function MyClass() {
 this.x = 'x in MyClass';
}
var obj = new MyClass();
MyClass.prototype.z = 'z in MyClass.prototype';
MyClass.prototype.getX = function() {
 return this.x;
}
print(obj.__proto__);
print(Object.getPrototypeOf(obj));
print(obj.constructor.prototype);
//MyClass { z: 'z in MyClass.prototype', getX: [Function] }

总结：
上面的关系图：