JavaScript与传统静态语言比较几点奇葩的地方

1. 变量不用var声明就能使用，如果变量未赋值默认为undefined，仍然建议使用var声明，而且更符合未来ES6标准，主要浏览器已经支持众多ES6新特性
2. 可直接给对象添加属性和方法
3. 函数的参数类型可以省略
4. javascript默认没有函数重载，当然可以通过一些方式实现，感兴趣可查相关资料

1. 通过本地对象直接创建对象

p1=new Object();// 没有参数()都可省 person=new Object
p1.firstname="Bill";
p1.lastname="Gates";
p1.age=56;
p1.eyecolor="blue";
p1.showColor=function () {
    console.log(this.eyecolor);
}
console.log(p1); //{firstname: "Bill", lastname: "Gates", age: 56, eyecolor: "blue", showColor: ƒ}
p1.showColor(); // blue

2. 通过字面量创建对象

p2={firstname:"Bill",lastname:"Gates",age:56,eyecolor:"blue"};

p2.showColor=function () {
    console.log(this.eyecolor)
};

console.log(p2); // {firstname: "Bill", lastname: "Gates", age: 56, eyecolor: "blue", showColor: ƒ}

p2.showColor(); // blue

本质上是第一种方式

3. 工厂函数创建对象

function createPerson(firstname,lastname,age,eyecolor) {
    var p3=new Object();
    p3.firstname=firstname;
    p3.lastname=lastname;
    p3.age=age;
    p3.eyecolor=eyecolor;
    p3.showColor=function () {
        console.log(this.eyecolor);
    }
    return p3;
}
var p3_fact1=createPerson("Li","Lin",18,"black");

p3_fact1.showColor(); // black

创建对象都重新创建了showColor函数,这种内存开销是没必要的

4. 定义构造函数，通过构造函数创建对象

function Person(firstname,lastname,age,eyecolor)
{
    this.firstname=firstname;
    this.lastname=lastname;
    this.age=age;
    this.eyecolor=eyecolor;
    this.showColor = function() {
        alert(this.eyecolor);
    };
}

构造函数会重复生成函数，为每个对象都创建独立的函数版本。与工厂方式差别不大

5. 原型方式创建对象

function Person(){}
Person.prototype.firstname="Bill";
Person.prototype.lastname="Gates";
Person.prototype.age=56;
Person.prototype.color="blue";
Person.prototype.showColor=function () {
    alert(this.color)
}

原型方式的问题:解决了多份函数对象的问题，引入的问题是不能通过构造函数传入参数并且原型上的属性和方法全部会被所有对象共享。

我举个例子说明：

function Car(){}
Car.prototype.color="blue";
Car.prototype.doors=4;
Car.prototype.drivers=new Array("jack","David");
Car.prototype.showColor=function () {
    alert(this.color);
}
var car1=new Car();
car1.drivers.push("Lily");
var car2=new Car();

console.log(car1.drivers); //["jack", "David", "Lily"]
console.log(car2.drivers); //["jack", "David", "Lily"]

我们预期的结果是只给car1加个司机,却被car2共享了

6. 混合构造函数和原型方式创建对象

function Car(color,doors){
    this.color=color;
    this.doors=doors;
    this.drivers=new Array("jack", "David");
}

Car.prototype.showColor=function () {
    console.log(this.color);
}

var car1=new Car("red",4);
car1.drivers.push("Bruce");
var car2=new Car("blue",5);
console.log(car1.drivers); //["jack", "David", "Bruce"]
console.log(car2.drivers); //["jack", "David"]

这种方式结合了混合构造函数的和原型方式的优点。没副作用，要说唯一不完美的地方就是不符合传统面向对象的封装性

7 动态原型方法

function Car(sColor,iDoors) {
    this.color = sColor;
    this.doors = iDoors;
    this.drivers = new Array("Mike","John");
    if (typeof Car._initialized == "undefined") {
        Car.prototype.showColor = function() {
            alert(this.color);
        };
        Car._initialized = true;
    }
}
var car1=new Car("red",4);
var car2=new Car("blue",5);
console.log(car1.drivers); //["jack", "David"]
console.log(car2.drivers); //["jack", "David"]
car1.showColor(); //red
car2.showColor(); //blue

本质上就是混合构造函数和原型方式。优点是很符合传统语言的封装性，而且原型方法只会被添加一次

怎么样简单吧，如果有点帮助，帮忙点个赞O(∩_∩)O谢谢！