JavaScript高程复习(1) -- 基础语法

2017-08-16  本文已影响21人  小雄子

第三章 基本概念

3.1 语法

3.3 变量

3.4 数据结构

3.4.2 Undefine类型

3.4.3 Null类型

alert(null == undefined)   //true

3.4.5 Number类型

3.4.6 String类型

3.4.7 Object类型

Object 的每个实例都具有下列属性和方法

  • constructor ：保存着用于创建当前对象的函数。对于前面的例子而言，构造函数（constructor）就是 Object() 。
  • hasOwnProperty(propertyName) ：用于检查给定的属性在当前对象实例中（而不是在实例的原型中）是否存在。其中，作为参数的属性名（ propertyName ）必须以字符串形式指定（例如： o.hasOwnProperty("name") ）。
  • isPrototypeOf(object) ：用于检查传入的对象是否是传入对象的原型
  • propertyIsEnumerable(propertyName) ：用于检查给定的属性是否能够使用 for-in 语句，与 hasOwnProperty() 方法一样，作为参数的属性名必须以字符串形式指定。
  • toString() ：返回对象的字符串表示
  • valueOf() ：返回对象的字符串、数值或布尔值表示。通常与 toString() 方法的返回值相同

3.5 操作符

第四章 变量、作用域和内存问题

4.1 基本类型和引用类型的值

  • ECMAScript 变量可能包含两种不同数据类型的值：基本类型值和引用类型值。基本类型值指的是简单的数据段，而引用类型值指那些可能由多个值构成的对象
  • 当从一个变量向另一个变量复制引用类型的值时，同样也会将存储在变量对象中的值复制一份放到为新变量分配的空间中。不同的是，这个值的副本实际上是一个指针，而这个指针指向存储在堆中的一个对象。复制操作结束后，两个变量实际上将引用同一个对象。因此，改变其中一个变量，就会影响另一个变量
var obj1 = new Object();
var obj2 = obj1;
obj1.name = "Nicholas";
alert(obj2.name); //"Nicholas"

function setName(obj) {
    obj.name = "Nicholas";
    obj = new Object();
    obj.name = "Greg";
}
var person = new Object();
setName(person);
alert(person.name); //"Nicholas"

实际上，当在函数内部重写 obj 时，这个变量引用的就是一个局部对象了。而这个局部对象会在函数执行完毕后立即被销毁。

虽然在检测基本数据类型时 typeof 是非常得力的助手，但在检测引用类型的值时，这个操作符的用处不大。通常，我们并不是想知道某个值是对象，而是想知道它是什么类型的对象。为ECMAScript
提供了 instanceof 操作符

alert(person instanceof Object);  // 变量 person 是 Object 吗？
alert(colors instanceof Array); // 变量 colors 是 Array 吗？
alert(pattern instanceof RegExp); // 变量 pattern 是 RegExp 吗？

第5章 引用类型

5.1 Object类型

5.2 Array类型

5.4 Date类型

5.5 RegExp类型

var pattern=/s$/
var pattern=new RegExp('s$')

5.5 Function类型

  • 函数是对象，每个函数都是Function类型的实例，函数名是一个指向函数对象的指针。
  • 使用不带圆括号的函数名是访问函数指针，而非调用函数
//函数声明提升，函数正常运行，没有报错
alert(sum(10,10));
function sum(num1, num2){
    return num1 + num2;
}
//报错
alert(sum(10,10));
var sum = function(num1, num2){
    return num1 + num2;
};

5.6 基本包装类型

5.6.1 Boolean类型

  • 由于 Boolean 对象是 Boolean 类型的实例，所以使用 instanceof操作符测试 Boolean 对象会返回 true ，而测试基本类型的布尔值则返回 false
  • 理解基本类型的布尔值与 Boolean 对象之间的区别非常重要——当然，我们的建议是永远不要使用 Boolean 对象

5.6.2 Number类型

var num = 10;
alert(num.toString()); //"10"
alert(num.toString(2)); //"1010"
alert(num.toString(8)); //"12"
alert(num.toString(10)); //"10"
alert(num.toString(16)); //"a"

5.6.3 String类型

String 类型的每个实例都有一个 length 属性，表示字符串中包含多个字符

var stringValue = "hello world";
alert(stringValue.length); //"11"

5.7 单体内置对象

5.7.1 Global对象

本书前面介绍过的那些函数，诸如 isNaN() 、 isFinite() 、parseInt() 以及 parseFloat() ，实际上全都是 Global对象的方法。除此之外， Global 对象还包含其他一些方法

5.7.2 Math对象

    var max = Math.max(3, 54, 32, 16);
    alert(max); //54
    var min = Math.min(3, 54, 32, 16);
    alert(min);

面向对象的程序设计

6.2 创建对象

6.2.1 工厂模式

用函数来封装以特定接口创建对象的细节

function createPerson(name, age, job){
    var o = new Object();
        o.name = name;
        o.age = age;
        o.job = job;
        o.sayName = function(){
        alert(this.name);
    };
        return o;
}
var person1 = createPerson("Nicholas", 29, "Software Engineer");
var person2 = createPerson("Greg", 27, "Doctor");

alert(person1 instanceof createPerson)  //false

6.2.2 构造函数模式

function Person(name, age, job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function(){
        alert(this.name);
    };
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");

6.2.3 原型模式

原型链

6.2.4 组合使用构造函数模式和原型模式

创建自定义类型的最常见方式，就是组合使用构造函数模式与原型模式。

function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.friends= ["Shely","Court"];
}

Person.prototype = {
    constructor :Person,
    sayName : function(){
        alert(this.name);
    }
}

var person1 = new Person("Nicholas",20,"Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");

person1.friends.push("Van");
alert(person1.friends);    //"Shelby,Count,Van"
alert(person2.friends); //"Shelby,Count"
alert(person1.friends === person2.friends); //false
alert(person1.sayName === person2.sayName); //true

6.2.5 动态原型模式

function Person(name, age, job){
    //属性
    this.name = name;
    this.age = age;
    this.job = job;
    // 方法
    if (typeof this.sayName != "function"){
        Person.prototype.sayName = function(){
            alert(this.name);
        };
    }
}
var friend = new Person("Nicholas", 29, "Software Engineer");
friend.sayName();

6.2.6 寄生构造函数模式

形式上可看作是工厂模式+构造函数模式

//工厂模式
function Person(name,age,job){  
    var o =new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function(){
        alert(this.name);
    }
    return o;
}
//构造函数模式
var friend = new Person("Nicholas", 29, "Software Engineer");
friend.sayName()  //"Nicholas"

关于寄生构造函数模式，有一点需要说明：首先，返回的对象与构造函数或者与构造函数的原型属性之间没有关系；也就是说，构造函数返回的对象与在构造函数外部创建的对象没有什么不同。为此，不能依赖 instanceof 操作符来确定对象类型。由于存在上述问题，我们建议在可以使用其他模式的情况下，不要使用这种模式

6.2.7 稳妥构造函数模式

稳妥构造函数遵循与寄生构造函数类似的模式，但有两点不同：一是新创建对象的实例方法不引用 this ；二是不使用 new 操作符调用构造函数

function Person(name, age, job){
    //创建要返回的对象
    var o = new Object();
    //可以在这里定义私有变量和函数
    //添加方法
    /*除了使用sayName()方法之外，没有其他办法可以访问name的值*/
    o.sayName = function(){   
        alert(name);
    };
    //返回对象
    return o;
}
var friend = Person("Nicholas", 29, "Software Engineer");
friend.sayName(); //"Nicholas"

6.3 继承

每个构造函数都有一个原型对象prototype，原型对象都包含一个指向构造函数的指针constructor，而实例都包含一个指向原型对象的内容指针proto。
所有函数的默认原型都是Object的实例，因此默认原型都会包含一个内部指针，指向Object.prototype。这也正是所有自定义类型都会继承toString()，valueOf()等默认方法的根本原因。

--- 未完待续---

上一篇 下一篇

猜你喜欢

热点阅读