自定义构造函数

this指向的是对象本身 -- 只有new了之后才有对象
函数不执行，this是不存在的

function Teacher (){
    this.name = "张三";
    this.age = 33;
    this.smoke = function (){
        console.log("I am smoking");
    }
}

// 实例化 这是两个完全不同的对象 互不影响 不同的两个对象
var teach1 = new Teacher();
var teach2 = new Teacher();

function Numadd() {
        this.arr = [];
        for (var i = 0; i < arguments.length; i++) {
            if (typeof (arguments[i]) !== "number") {
                console.log("参数必须全是数字类型");
                return;
            }
            this.arr.push(arguments[i]);
        }
        this.adds = function () {
            this.a = 0;
            for(var i = 0;i < this.arr.length;i++) {
                 this.a += this.arr[i];
            }
            return this.a;
        },
        this.chang = function () {
            this.a = 1;
            for(var i = 0;i < this.arr.length;i++) {
                 this.a *= this.arr[i];
            }
            return this.a;
        }
    }
    var add = new Numadd(1, 2, 3,4,5);
    console.log(add.adds());
    console.log(add.chang());


    function Car(opt) {
        this.pin = opt.pin;
        this.color = opt.color;
        this.pai = opt.pai;
    }

    function Maincar(opt) {
        this.name = opt.name;
        this.age = opt.age;
        this.inco = opt.inco;
        this.print = function () {
            var val = new Car(opt.sing);
            console.log("我选了一辆" + val.pin + " 颜色是 " + val.color + " 排量 " + val.pai);
        }
    }

    var main = new Maincar({
        name: 'Maincar',
        age: 25,
        inco: 9000,
        sing: {
            pin: '马自达',
            color: 'black',
            pai: '2.0'
        }
    });

    main.print();

构造函数的AO
其实new的时候，把原本指向window的this，转向实例化对象

function Car(color){
/*
    AO = {
        this:{ 
            color：color
        }
    }
*/
    this.color = color
    
    // 最后隐式的 return this；
}
   // 当被实例化的时候 只要一执行AO产生，自动保存this
var car1 = new Car("red");
// 其实new 关键字，主要是造出 this:{color:color}
// 把this返回给car1 ，所以this 是car1，而不是 new Car();

console.log(car1.color);

// 我们可以自己实现一个this，不用系统的

function Carx(color){
    var me = {};
    me.color = color;
    return me;
}

var car2 = Carx("red");
console.log(car2.color);// 也可以

当你return引用值的时候，函数，对象，数组，是会返回引用值，原始类型值不会改变。


function Car(){
    this.color = "red";
    // return {} [] function(){}
    // 隐式 return this；
}

包装类

原始值没有自己的方法和属性
内置的包装有三种
- new Number
- new String
- new Boolean

    var a  = 1;
    console.log(a);
    var b = new Number(a);// 实例化对象 这个时候就能赋值新属性
    b.len = 1;
    b.add = function (){};
    
    console.log(b.len);

var a = 123;// 原始值加属性加不上
a.len = 3;
// 首先变成数字类型对象 new Number(123).len = 3; 但是它保存不了，就给删掉了，在打印就是 undefined， 这是包装类的过程
console.log(a.len);// undefind

var a = new Number(123);// 保存起来就行了

var str = "abc";
// new String(str).length; 打印的是它，它里面是有length属性的，这个时候不需要保存
console.log(str.length);// 3

    var name = "languiji";
    name += 10; // languiji10
    var type = typeof(name); // string

    if(type.length === 6){ //true
        type.text = "string";
        // new String(type).text = "string"; delete
    }

    console.log(type.text);// undefined
    
    // 包装类
    var type = new String(typeof(name)); // 这样就能赋值属性方法了

    function test() {
        var d = 1;
        function f() {
            d++;
            console.log(d);
        }
        this.g = f;
        // return this; -> 闭包
      }
    var t = new test();
    t.g();// 2
    t.g();// 3
    var t1 = new test();
    t1.g();// 2
    
    // ------------------------------------------------------------
    
    var x = 1,y = z = 0;

    function add(n){
        return n = n + 1;
    }
    y = add(x);
    // y = 4
    function add(n){
        return n = n + 3;
    }

    z = add(x);
    // z = 4
    console.log(x,y,z);// 1 4 4
    // -------------------------------------------------------------
    function foo1(x){
        console.log(arguments);
        return x;
    }
    foo1(1,2,3,4,5);

    function foo2(x){
        console.log(arguments);
        return x;
    }(1,2,3,4,5);// 函数声明不能跟执行符号，如果没参数会报语法错误

    (function foo3(x) {
        console.log(arguments);
        return x;
    })(1,2,3,4,5);

 /*
        ASSCII码 表一 0 -127  表二  128 - 255
        ASSCII码所有字节 只占 1 个子节 byte
        
        unicode码  涵盖asscii码 2个字节
        0 -255 和 ASSCII码相同 256 以后全是2个字节
    */

    // var str = '19';
    // var pos = str.charCodeAt(1);

    // console.log(pos);// 97

    // 写一个函数接收任意一个字符串算出这个字符串的总字节数

    function setting(){
        var pos = arguments[0];
        var eit = 0;
        for(var i = 0;i < pos.length;i++){
            var end = pos[i].charCodeAt(0);
            if(end >= 0 && end <= 255){
                eit += 1;
            }else {
                eit += 2;
            }
        }
        return eit;
    }

    console.log(setting("122侯1111王"));// 11 个字节

数组的截断方法

var arr = [1,2,3,4,5,6];
arr.length = 3;
console.log(arr)；// [1,2,3] 后面的全部截断

JS基础学习（6）

自定义构造函数

包装类