求一个字符串的字节长度

注意点:汉字的字节长度是两个

// 求一个字符串字节长度(汉字是两个字节)
function bytesLength(str) {var count = 0;for(var i=0; i<str.length;i++) {if(str.charCodeAt(i) > 255) {count += 2;}else {count ++;}}return count;
}
复制代码

原型

定义: 原型是function对象的一个属性,它定义了构造函数制造出的对象的公共祖先。通过该构造函数产生的对象可以继承该原型的属性和方法 (原型也是对象)

可以利用原型的特点和概念,可以提取共有属性

proto&构造函数&new(object)

//Person的对象-原型对象
Person.prototype.name = "abc";
//构造函数 Person
function Person() {// var this = {//      _proto_: Person.prototype  //}
}
var person = new Person();
复制代码

在new person时 发生:

this -> _proto:Person.prototype()-原型对象 可以person可以调用原型中的属性和方法 person.proto = obj(可以被修改-之后就会继承obj的内容)

插入一个小问题:代码

Person.prototype.name = "sunny";
function Person() {// var this = {//      _proto_: Person.prototype  //}
}
var person = new Person();Person.prototype = {name:"cherry"
}
console.log(person.name) // sunny
复制代码

原因(对象空间的引用或者指向)

1. person.name -> this.proto(Person.prototype原型)上的name属性
2. Person.prototype -> 一个对象空间 -> {name:"sunny"}
3. person.name -> this.proto -> 一个对象空间 -> {name:"sunny"}
4. 修改指向引用 Person.prototype -> 一个对象空间 -> {name:"cherry"} 5.由于person.name 先new -> this.proto -> 的指向空间没有变 -> {name:'sunny'} 所以:person.name = 'sunny'

如果纯粹修改Person.prototype.name = "cherry"; 则person.name = 'cherry'

原型连

概念:new对象沿着作用域链去查找属性和方法的 链 引出:

// 如果要求打印出son.lastName
son this._porto_: Son.prototypefather this._porto_: Father.prototypegrand this._porto_: Object由于 son this._porto_ -> father this._porto_ -> father grand._porto_ -> {lastName,Object.prototype} 所以son.lastName 顺这链找到了grand.lastName = "Deng"console.log(son.lastName) // "Deng"
复制代码

Object.create()

创建对象 Object.create(原型) 创建对象、指定原型

var obj = { name:'sunny'}
var obj1 = Object.create(obj)// obj1 = {} 并且obj1的原型是obj obj1.name= "sunny"
复制代码

不是所有对象都是继承自Object Object.create(null)是特例

判断类型

Object.prototype.toString.call(123)
"[object Number]"
复制代码

call/apply

作用: 改变this指向 区别: 后面传的参数形式不同

1. 改变this指向1

function Person(name, age) {// Person.call() 会将this -> objthis.name = name;this.age = age;
}var person = new Person("deng", 100)
var obj = {};
Person.call(obj, "cheng",300) //改变this指向 借用方法复制代码

1. 改变this指向2

function Person(name, age, sex) {this.name = name;this.age = age;this.sex = sex;
}function Student(name, age, sex, tel, grade) {// var this = StudentPerson.call(this, name, age, sex); //Student则有了Person的属性this.tel = tel;this.grade = grade;
}var student = new Student('sunny',123,'male',139,2017)student -> {name: "sunny", age: 123, sex: "male", tel: 139, grade: 2017}
复制代码

1. call/apply传参形式不同 Person.apply(obj, ["cheng",300]) Person.call(this, [name, age, sex]);

继承那点方式

1. 传统的形式-> 原型链

   过多的继承了没有用的属性

   // Animal构造函数
   function Animal(){ }
   // Animal原型山添加一个属性species
   Animal.prototype.species = "动物";// 将Cat的prototype对象指向Animal的prototype对象
   Cat.prototype = Animal.prototype;// 原型的修改会导致Cat的构造器的修改,所以需要将cat的构造器重新指向Cat它自己
   function Cat(){ }
   Cat.prototype.constructor = Cat;
   var cat1 = new Cat("大毛","黄色");
   // cat的对象中就有了species这个属性
   alert(cat1.species); // 动物
   复制代码

2. 借用构造函数(call/apply)

   不能继承借用构造函数的原型 每次构造函数都要多走apply/call函数

   function Person(name, age, sex) {this.name = name;this.age = age;this.sex = sex;
   }function Student(name, age, sex, tel, grade) {// var this = StudentPerson.call(this, name, age, sex); //Student则有了Person的属性 用apply也行this.tel = tel;this.grade = grade;
   }
   var student = new Student();
   复制代码

3. 共享原型(多个构造函数共用一个原型)

   一个原型修改另一个也在修改

   // 标准方法
   function inherit(Target, Origin) {Target.prototype = Origin.prototype;
   }
   复制代码

4. 圣杯模式(完善)

   function Father() {}
   function Son() {}function F() {} // 中间层
   F.prototype = Father.prototype;// son就形成了继承
   Son.prototype = new F();//如果一个修改这样不会影响另一个(因为new F是独立存在的一个空间)
   复制代码

   标准方法:

   function inherit(Target, Origin) {function F() {};F.prototype = Origin.prototype;Target.prototype = new F();// 构造器重新修改过来Target.prototype.constructor = Target;// 继承自谁(保存值)Target.uber = Origin.prototype;
   }
   复制代码

   高级写法(一般是库写法)

   私有化属性(形成了闭包,变量引用与保留了inherit() 上下文)

   var inherit = (function () {var F = function() {}return function (Target, Origin) {F.prototype = Origin.prototype;Target.prototype = new F();// 构造器重新修改过来Target.prototype.constructor = Target;// 继承自谁(保存值)Target.uber = Origin.prototype;}
   }())
   复制代码

5. 深拷贝继续(数组和对象)

   function deepCopy(p, c) {
      var c = c || {};
      for (var i in p) {
        if (typeof p[i] === 'object') {
          c[i] = (p[i].constructor === Array) ? [] : {};
          deepCopy(p[i], c[i]);
        } else {
           c[i] = p[i];
        }
      }
      return c;
   }
   复制代码