“JavaScript”的版本间的差异

//声明一个"人"的构造函数,目的是通过new出来的对象都是一个个的具体的"人"
var Person = function () {
    var prx = "other"; //私有属性，该属性new出来的对象时无法获取到的。
    var prxMethond = function () {
        console.log("in prxMethod");
    }; //用var申明私有方法，该方法不能被new Person调用到。一般的，我们只需要再内部使用到的方法可最好声明称私有方法。
 
    this.name = "double"; //定义实例属性，也就是说，通过new出来的对象都具备这个属性。
    this.say = function () {
        console.log("hi i am " + this.name);
    } //say是一个实例方法，new出来的对象都有say的方法。
};
 
Person.prototype.eat = function () {
    console.log(this.name + "eat something...");
}; //为Person定义了一个原型方法eat，该方法为公共方法。每一个通过new Person 实例出来的对象都共享同一个eat方法。
 
Person.staticMethod = function () {
    console.log("this is static method");
}; //定义静态方法，该方法目的在于不用new Person 就能调用该方法。我们把不用实例化就能调用的方法叫做静态方法。

var zhangsan = new Person();
 
// 实际上内部是这样的：
var zhangsan = {};
zhangsan.__proto__ = Person.prototype;
Person.call(zhangsan);

var f = function () {
    this.name = "f_name";
    this.say = function () {
        console.log("say");
    };
    console.log("in f");
};
console.log(f());
//我们用chrome执行上面代码获取的结果为:
//in f
//undefined
 
var fo = new f();
console.log(fo);
//返回的是:执行完fo.__proto__=f.prototype绑定关系和f.call(fo)调用的fo对象。

var f=function(){
  this.name="f_name";
  this.say=function(){
    console.log("say");
  }
  return '123';
}
//非 new调用:
f(); //返回"123"的字符串,这相当于就是调用的一个普通函数
 
//new 调用
new f();
//返回值同返回undefined时相同的{__proto__:f,name:"f_name",say:function()arguments: null,caller: null,length: 0,name: "",prototype....}

var f = function () {
    this.name = "f_name";
    this.say = function () {
        console.log("say");
    };
    return {"age": 25}
};
//非 new调用:
console.log(f()); //返回{"age":25}的字符串,这相当于就是调用的一个普通函数
 
//new 调用
console.log(new f()); //返回值是:{age: 25}

Person().staticMethod()//报错,因为Person()是一般的函数调用,因为Person没有明确的返回值所以默认返回为undefined,所以 调用代码实际上是undefined.方法,所以error了
Person.staticMethod()//打印结果为:this is static method,此次调用的是静态方法,如何定义的就如何调用
Person.prototype.eat()//调用原型链中的方法,但eat中的this,指定的是window 所以打印结果为:undefined eat something...
var zhangsan = new Person()
//先在zhangsan对象中找是否有eat方法发现没有,
//则通过__proto__去找,上面我们提到过,
//new 关键字调用会将: zhangsan,__proto__=Person.prototype,
//所以就会去Person.prototype找eat方法,找到了调用,
//而关于this.name获取到值原因同样是因为new 关键字的 Person.call(zhangsan)的执行操作,
//将Person中的this相关的内容都进行了"copy",其实就是this复制到了zhangsan对象中,
//关于这点我们前面已验证过了.所以zhangsan.name是能找到值的
//输出结果就成了:double eat something...
zhangsan.eat()//double eat something...
zhangsan.name//同上

var yx01 = new function () {
    return "圆心"
};
console.log(yx01);
 
//我们运行代码，将返回显示“[object object] ”，此时该代码等价于：
//function 匿名类(){
//    return "圆心";
//}
 
var yx01 = new function () {
    return new String
};
console.log(yx01);
 
var yx02 = function () {
    return "圆心"
}();
console.log(yx02);

var doAdd = new Function("iNum", "console.log(iNum + 10)");
var alsodoAdd = doAdd;
doAdd(10);	    //输出 "20"
alsodoAdd(10);	//输出 "20"
 
console.log(doAdd.valueOf());
console.log(doAdd.toString());

function doAdd(iNum) {
    alert(iNum + 10);
}
 
function sayHi() {
    alert("Hi");
}
 
console.log(doAdd.length);	//输出 "1"
console.log(sayHi.length);	//输出 "0"
 
// 形式一
var foo01 = function () //or fun01 = function()
{
    var temp = 100;
    this.temp = 200;
    return temp + this.temp;
}
 
console.log(typeof(foo01));
console.log(foo01());
 
// 形式二
var foo02 = new function () {
    var temp = 100;
    this.temp = 200;
    return temp + this.temp;
};
 
console.log(typeof(foo02));
console.log(foo02.constructor());
 
// 形式三
var foo3 = new Function('var temp = 100; this.temp = 200; return temp + this.temp;');
 
console.log(typeof(foo3));
console.log(foo3());
 
// 形式四：这个方式是不常使用的，效果和方法三一样，不过不清楚不用new来生成有没有什么副作用，
// 这也体现了JavaScript一个最大的特性：灵活！能省就省。
var foo4 = Function('var temp = 100; this.temp = 200; return temp + this.temp;');
 
console.log(typeof(foo4));
console.log(foo4());

window.local = 'hi';
(function () {
    var local = 1;
    console.log(typeof local);  //number
    Function("console.log(typeof local);")();  //string
}());

Person.prototype.constructor == Person;
person1.__proto__ == Person.prototype;
person1.constructor == Person;

function Person() {
}
 
var p = new Person();
 
p.__proto__ === Person.prototype // true
 
Person.prototype.constructor === Person // true

function Person(){}
var p = new Person();
Person.prototype = {
    name: 'tt',
    age: 18
}
 
Person.prototype.constructor === Person // false
 
p.name // undefined

Person.prototype = {
    constructor: Person
}

function Person(name, age, job) {
 this.name = name;
 this.age = age;
 this.job = job;
 this.sayName = function() { alert(this.name) } 
}
var person1 = new Person('Zaxlct', 28, 'Software Engineer');
var person2 = new Person('Mick', 23, 'Doctor');

console.log(person1.constructor == Person); //true
console.log(person2.constructor == Person); //true

Person.prototype.constructor == Person

 
function Person(){};
console.log(Person.prototype) //Person{}
console.log(typeof Person.prototype) //Object
console.log(typeof Function.prototype) // Function，这个特殊
console.log(typeof Object.prototype) // Object
console.log(typeof Function.prototype.prototype) //undefined

var A = new Function ();
Function.prototype = A;

var Person = function (name) {
    this.name = name; // tip: 当函数执行时这个 this 指的是谁？
};
Person.prototype.getName = function () {
    return this.name;  // tip: 当函数执行时这个 this 指的是谁？
};
var person1 = new Person('Mick');
person1.getName(); //Mick

var person1 = new person('Mick');
person1.name = 'Mick'; // 此时 person1 已经有 name 这个属性了
person1.getName(); //Mick

Person.prototype.constructor == Person;
person1.__proto__ == Person.prototype;
person1.constructor == Person;

var obj = {}
//它等同于下面这样：
var obj = new Object()
 
//obj 是构造函数（Object）的一个实例。所以：
obj.constructor === Object
obj.__proto__ === Object.prototype

Number.__proto__ === Function.prototype  // true
Number.constructor == Function //true
 
Boolean.__proto__ === Function.prototype // true
Boolean.constructor == Function //true
 
String.__proto__ === Function.prototype  // true
String.constructor == Function //true
 
// 所有的构造器都来自于Function.prototype，甚至包括根构造器Object及Function自身
Object.__proto__ === Function.prototype  // true
Object.constructor == Function // true
 
// 所有的构造器都来自于Function.prototype，甚至包括根构造器Object及Function自身
Function.__proto__ === Function.prototype // true
Function.constructor == Function //true
 
Array.__proto__ === Function.prototype   // true
Array.constructor == Function //true
 
RegExp.__proto__ === Function.prototype  // true
RegExp.constructor == Function //true
 
Error.__proto__ === Function.prototype   // true
Error.constructor == Function //true
 
Date.__proto__ === Function.prototype    // true
Date.constructor == Function //true

Math.__proto__ === Object.prototype  // true
Math.construrctor == Object // true
 
JSON.__proto__ === Object.prototype  // true
JSON.construrctor == Object //true

// 函数声明
function Person() {}
// 函数表达式
var Perosn = function() {}
console.log(Person.__proto__ === Function.prototype) // true
console.log(Man.__proto__ === Function.prototype)    // true

console.log(typeof Function.prototype) // function
console.log(typeof Object.prototype)   // object
console.log(typeof Number.prototype)   // object
console.log(typeof Boolean.prototype)  // object
console.log(typeof String.prototype)   // object
console.log(typeof Array.prototype)    // object
console.log(typeof RegExp.prototype)   // object
console.log(typeof Error.prototype)    // object
console.log(typeof Date.prototype)     // object
console.log(typeof Object.prototype)   // object

console.log(Function.prototype.__proto__ === Object.prototype) // true

Object.prototype.__proto__ === null // true

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
 
  toString() {
    return '(' + this.x + ', ' + this.y + ')';
  }
}
 
// 可以这么改写
function Point(x, y) {
  this.x = x;
  this.y = y;
}
 
Point.prototype.toString = function () {
  return '(' + this.x + ', ' + this.y + ')';
};

function Person(){}
var p = new Person();
 
p instanceof Person // true
p instanceof Object // true

function Person() {}
Person.prototype = {
    name: 'tt'
}
var p = new Person();
p.age = 15;
 
p.hasOwnProperty('age') // true
p.hasOwnProperty('name') // false

function Person(){}
Person.prototype.arr = [1, 2, 3, 4];
 
var person1 = new Person();
var person2 = new Person();
 
person1.arr.push(5) 
person2.arr // [1, 2, 3, 4, 5]

var currency = /((^([1-9]\d*))|^0)(\.\d{1,2})?$|(^0\.\d{1,2}$)/;
var people = /^([1-9]\d*)?$/;

//为每个匹配元素的特定事件绑定事件处理函数
bind(type,[data],fn) 
$("a").bind("click",function(){alert("ok");});
 
//给所有匹配的元素附加一个事件处理函数，即使这个元素是以后再添加进来的
live(type,[data],fn) 
$("a").live("click",function(){alert("ok");});
 
//指定的元素（属于被选元素的子元素）添加一个或多个事件处理程序，并规定当这些事件发生时运行的函数
delegate(selector,[type],[data],fn) 
$("#container").delegate("a","click",function(){alert("ok");})
 
//在选择元素上绑定一个或多个事件的事件处理函数
on(events,[selector],[data],fn)

//JS
function isWeiXin(){
    var ua = window.navigator.userAgent.toLowerCase();
    if(ua.match(/MicroMessenger/i) == 'micromessenger'){
        return true;
    }else{
        return false;
    }
}

//IE8下没有
str.trim()
 
//替代方案
Ext.string.trim(str) //Extjs用法
$.trim(str)             //jquery用法

/*global var1,var2,var3,var4,var5*/

//倒计定时器：
timer = setTimeout(func_a, delaytime_ms); 
clearTimeout(timer);      //清除已设置的setTimeout对象
 
//循环定时器：
timer = setInterval(func_b, delaytime_ms); 
clearInterval(timer);     //清除已设置的setInterval对象