# js 基础

// 1.创建ajax对象
var xhr = null;
if(window.XMLHttpRequest) {
    xhr = new XMLHttpRequest();
} else {
    //为了兼容IE6
    xhr = new ActiveXObject('Microsoft.XMLHTTP');
}

// 2.连接服务器
// 连接服务器open(方法GET/POST，请求地址， 异步传输)
xhr.open('GET',  'data.txt',  true);

// 3.发送请求
xhr.send();

// 4.接收返回数据
/*
** 每当readyState改变时，就会触发onreadystatechange事件
** readyState属性存储有XMLHttpRequest的状态信息
** 0 ：请求未初始化
** 1 ：服务器连接已建立
** 2 ：请求已接受
** 3 : 请求处理中
** 4 ：请求已完成，且相应就绪
*/
xhr.onreadystatechange = function() {
    if(xhr.readyState == 4) {
        /*
        ** Http状态码
        ** 1xx ：信息展示
        ** 2xx ：成功
        ** 3xx ：重定向
        ** 4xx : 客户端错误
        ** 5xx ：服务器端错误
        */
        if(xhr.status == 200) {
            success(xhr.responseText);
        } else {
            if(failed) {
                failed(xhr.status);
            }
        }
    }
}

function Person () {}
var person = new Person();

// 常用的继承方法： 寄生组合式继承  see: https://zhuanlan.zhihu.com/p/25578222
function Parent(name) {
    this.name = name;
}
Parent.prototype.sayName = function() {
    console.log('parent name:', this.name);
}

function Child(name, parentName) {
    // 借用构造函数实现对实例属性的继承，类似 super()
    Parent.call(this, parentName);  
    this.name = name;    
}

// 使用原型链实现对原型属性和方法的继承
Child.prototype = Object.create(Parent.prototype);   // 这里的几种其他写法，见下
Child.prototype.constructor = Child;

Child.prototype.sayName = function() {
    console.log('child name:', this.name);
}

var parent = new Parent('father');
parent.sayName();      // parent name: father

var child = new Child('son', 'father');
child.sayName();       // child name: son

// 1： 手动实现 Object.create
function create(proto) {
    function F() {};
    F.prototype = proto;
    return new F();
}

Child.prototype = create(Parent.prototype);
Child.prototype.constructor = Child; 

// 2：es6  setPrototypeOf   慢  see: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf
Object.setPrototypeOf(Child, Parent);

// 3：__proto__
    Child.prototype.__proto__ = Parent.prototype;
    // 或
    Child.__proto__ = Parent;

// es6 继承
class Super {}
class Sub extends Super {}

const sub = new Sub();

Sub.__proto__ === Super;

// es5 继承
function Super() {}
function Sub() {}

Sub.prototype = new Super();
Sub.prototype.constructor = Sub;

var sub = new Sub();

Sub.__proto__ === Function.prototype;

function MyES5Array() {
  Array.call(this, arguments);
}

// it's useless
const arrayES5 = new MyES5Array(3); // arrayES5: MyES5Array {}

class MyES6Array extends Array {}

// it's ok
const arrayES6 = new MyES6Array(3); // arrayES6: MyES6Array(3) []

    typeof Symbol(); // symbol 有效
    typeof ''; // string 有效
    typeof 1; // number 有效
    typeof true; //boolean 有效
    typeof undefined; //undefined 有效
    typeof new Function(); // function 有效

    typeof null; //object 无效
    typeof [] ; //object 无效
    typeof new Date(); //object 无效
    typeof new RegExp(); //object 无效

    [] instanceof Array; //true
    {} instanceof Object;//true
    new Date() instanceof Date;//true
    new RegExp() instanceof RegExp//true

    var aa=[1,2];
    console.log(aa.constructor===Array);//true
    console.log(aa.constructor===RegExp);//false
    console.log((1).constructor===Number);//true

    var reg=/^$/;
    console.log(reg.constructor===RegExp);//true
    console.log(reg.constructor===Object);//false

    Object.prototype.toString.call('');   // [object String]
    Object.prototype.toString.call(1);    // [object Number]
    Object.prototype.toString.call(true); // [object Boolean]
    Object.prototype.toString.call(undefined); // [object Undefined]
    Object.prototype.toString.call(null); // [object Null]
    Object.prototype.toString.call(new Function()); // [object Function]
    Object.prototype.toString.call(new Date()); // [object Date]
    Object.prototype.toString.call([]); // [object Array]
    Object.prototype.toString.call(new RegExp()); // [object RegExp]
    Object.prototype.toString.call(new Error()); // [object Error]
    Object.prototype.toString.call(document); // [object HTMLDocument]
    Object.prototype.toString.call(window); //[object Window] window是全局对象global的引用

isFinite(25) // true
isFinite("25") // true

Number.isFinite(25) // true
Number.isFinite("25") // false

isNaN(NaN) // true
isNaN("NaN") // true

Number.isNaN(NaN) // true
Number.isNaN("NaN") // false
Number.isNaN(1) // false