Javascript

Adrian Yang

Adrian Yang

Front End Engineer @ Facebook

Javascript 高级程序设计

L4 变量 作用域 和 内存问题

探讨了 JavaScript处理松散类型的变量

还讨论了 原始值 和 引用值之间的差别 以及变量有关的执行环境的相应内容

最后 通过介绍JavaScript的垃圾收集机制 解释了变量在退出作用域时释放其内存的问题

本章内容:

  • 理解基本类型和引用类型的数值
  • 理解执行环境
  • 理解垃圾收集

JS 变量松散类型的本质,决定了它只是在特定的事件用于保存特定值的一个名字而已

由于不存在定义某个变量必须要保存何种类型值的规则,变量的数值及其数据类型可以在脚本的生命周期内改变 (JS变量实际上的复杂程度不止于此

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

基本类型

简单的数据段

引用类型

指 那些可能多个值构成的对象

引用类型的值按引用进行 访问 因为JS中不允许直接访问内存的位置,就不能直接操作对象的内存空间.在操作对象的时候 ,实际是操作对象的引用而不是实际的对象

4.1.2 复制变量值

基本类型复制:

在变量对象上创建一个新值.两个变量之间相互独立

引用类型的复制:

复制 指针的副本, 两个指针同时指向存储在堆中的对象

4.1.3 传递参数

所有参数都是值传递 如同基本类型变量的复制 而不是按引用的方式

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

在函数内部重写obj 时, 这个变量的引用就是一个局部的对象了.这个局部对象会在函数执行后被销毁

4.2 执行环境和作用域 execution context

内部的环境可以通过作用域链访问到所有的外部环境,但外部环境不能访问内部环境中任何变量和函数.

这写环境之间的联系是 线性 有序的

4.3 垃圾收集

垃圾收集机制:

找出不再使用的变量,释放其占用的内存

垃圾收集器跟踪哪个变量有用 对不再使用的变量打上标记

标记清除 (mark and sweep)

当变量进入环境,则标记变量进行环境,从逻辑上,永远不能和释放进入环境的变量所占用的内存

引用计数 (reference counting)

循环引用问题:

function problem(argument) {
var ObjectA = new Object();
var ObjectB = ner Object();
ObjectA.someOtherObject = ObjectB;
ObjectB.anotherObject = ObjectB;
}

他们之间的引用次数永远不会是0 大量调用后 内存不会得到回收

BOM DOM 对象基于 C++ 中的COM (Component Object Model) 实现,而COM 仍采用引用计数策略,现在 DOM 和 BOM 都是JavaScript 真正的对象

4.4 小结

  • 基本类型数值在内存中占据固定大小的空间,因此被保留在栈内存中
  • 确定值是那种基本类型: typeof 操作符, 确定值是哪种引用类型可以使用instanceof 操作符

执行环境

  • 执行环境有全局执行环境 和 函数执行环境之分
  • 每进入一个执行环境, 都会创建一个用于搜索变量 和 函数的作用链
  • 变量的执行环境决定 如何释放内存

垃圾收集机制

  • 离开作用域的值被自动标记为回收, 因此在垃圾收集期间被删除
  • "标记清除" 主流垃圾收集算法
  • "引用算法" 当代码中出现循环引用的现象时 会导致问题
  • 解除变量的引用不仅有助于消除循环引用的现象, 而且对于垃圾收集也有好处,为了确保有效地回收内存,应该及时解除不再使用的全局对象,全局对象属性,以及 循环变量的引用

L5 引用类型

详尽的介绍了JavaScript的所有的引用类型 如: Object Array...

这一章对 ECMA-262 规范描述中每一种理论类型即做了理论上的阐释 用从浏览器实现的角度给出了介绍

引用类型的值是引用类型的一个实例, 在ECMAScript 中, 引用类型是一种数据结构,也被常常成为类,但不准确,尽管ECMAScript是面向对象的语言,但是并不具有面向对象语言所支持的类和接口等基本结构.

5.1 Object 类型

大多数引用类型值都是Object 的实例

new + Object 构造函数创建实例

var person = new Object();
person.name = "Nicholas";
person.age = 29;

对象字面量 表示法

这个语法要求的代码量少, 更有数据封装的感觉, 同时也是向函数传递大量可选参数的首选方式

var person = {
name : "Nicholas",
age : 29
};

5.2 Array类型

检测数组

如果网站有多个框架,那么就有多个不同的全局执行环境,从而有不同的Array的构造函数

Array.isArray( ) 最终确定是否为数组 不管在哪个全局的环境中创建

5.2.1 检测数组

tostring() 返回数组的字符串表示

valueof() 返回数组 但也调用数组汇总报告每一项的 tostring() 方法

栈: array.pop( ) array.push( )

队列: array.push array.shift

array.concat() 基于当前数组创建一个新数组

5.2.8 迭代方法

定义了五个迭方法, 每个方法接受两个参数,要在每一项上运行的函数和运行该函数的作用域对象,影响this 本身的值

传入三个参数: (数组项的值(item),该项在数组中的位置(index),数组对象的本身(array))

5.3 Data 类型

var allFives = new Date(Data.UTC(2005,4,5,17,55,55));
//2005.05.05 17:55:55
var start = Date.now(); //调用日期和时间的毫秒数
dosomething();
var stop = Date.now(),
result = stop - start;

5.4 RegExp 类型

pattern: 任何简单或复杂的表达式

5.4.1 RegExp实例属性

实例属性不会重置

  • global 表示是否设置 g 标志
  • ignoreCase 是否设置 i 标志
  • lastIndex 整数 表示开始搜索下一个匹配项的字符位置 从0 开始
  • multiline 是否设置 m 标志
  • source 正则表达式字符串表示, 按照字面量形式 而非 传入构造函数中的字符串模式返回
var re = null;
for (var i = 0; i < 10; i++) {
re = /cat/g;
re.test("catastrophe"); // 仅一次返回 再次调用test() 失败
}
for ( i=0; i<10 ; i++){
re = new RegExp("cat",g);
re.test("catastrophe"); //true
}

正则表达式每一次使用都要创建新的实例

5.4.2 RegExp实例方法

.exex("应用的字符串") 返回第一个匹配信息的数组

.test("字符串参数") 与该参数匹配的模式下返回true

5.5 Function 类型

函数名仅仅是指向函数的指针, 所以没有重载,创建第二个函数的时候,实际上覆盖率第一个函数的变量

5.5.4 函数内部的特殊属性:

argument 是一个类数组对象,包含传入函数中的所有函数

arguments.callee

function facorial (num) {
if (num <=1) {
return 1;
}else{
return num * argument.callee(num-1); // 解除函数体内和函数名的耦合状态
}
}
var trueFactorial = facorial; //在另一个位置保持了函数指针
facorial = function () {
return 0;
}
alert(trueFactorial(5)); //120
alert(facorial(5)) ; //0

This 引用的是函数据以执行的环境对象(全局作用域中为 window)

window.color = "red";
var o = { color: "blue"};
function sayColor(){
alert(this.color);
}
sayColor(); //"red"
o.sayColor = sayColor(); //全局的sayColor 与 o.sayColor 都是指向的用一个函数
o.sayColor(); //"blue"
// 扩充函数的作用域
sayColor.call(this); //red
sayColor.call(window); //red
sayColor.call(o); //blue'
//bind()
var objectSayColor = sayColor.bind(o); //创建函数实例 其this值 被绑定到传给bind()函数的值
objectSayColor(); //blue

5.5.5 函数的属性和方法

length: 表示函数希望接收的参数命名个数

prototype: 保存引用类型的所有实例方法 在创建 自定义引用类型以及实现继承时, prototype 属性很重要

每个函数都包含两个非继承而来的方法:

都是在特定的作用域中 调用函数, 实际上等于设置函数体内this 对象的值

apply( 作用域(this), 参数数组) :

call() : 必须明确每一个传入的参数

function sum(num1,num2) {
return num1 + num2;
}
function callSum(num1,num2){
return sum.call(this,num1,num2);
}
function callSum2(num1,num2) {
return sum.apply(this,arguments)
}
alert(callSum(10,10)); //20
alert(callSum1(10,10)); //20

5.6 基本包装类型

为了便于操作基本类型的值 提供了三个特殊的基本类型值: Boolean Number String.

当读取一个基本类型的值的时候,就创造一个对应的基本包装类型的对象

var falseObject = new Boolean(false);
var result - falseObject && true;
alert(result); // true
var falseValue = false;
result = falseValue && true;
alert(result); //false

5.7单体内置对象

不依赖宿主环境的对象 在程序之前就已经存在了 z.B Object Array String

5.7.1 Global 对象

总计兜底对象,不属于任何其他对象的属性和方法 最终都是他的属性和方法

eval()方法:

当浏览器发现代码调用eval() 时 它会将传入的参数当作实际的ECMAScript 语句来解析

通过 eval() 调用的代码被认为是包含该次调用的一部分, 因此被执行的代码具有与该执行代码环境相同的作用链

5.8 小结

  • 引用对象 与 传统面向对象程序设计中的类类似,但实现不同
  • Object 是一个基础类型 所有其他类型都从Object 继承了 基本的行为
  • Array 类型是一组值的有序列表 同时提供了转换和操作这些值的功能
  • Date 类型提供了有关日期和时间的信息 包括当前日期和时间 以及相关的基本功能
  • RegExp 类型是 支持正则表达式的一个接口, 提供基本和一些高级的正则表达式的功能

函数 是 Function 类型的实例 函数也是对象 函数也拥有方法 ,可以增强行为

因为有了包装类型 ,所以基本类型的值可以被当作对象来访问, 以下为他们的共同的特质

  • 每个包装类型都能映射到同名的基本类型
  • 在读取模式下访问基本类型的值时,就会创建一个包装类的一个对象,方便数据操作
  • 操作基本类型的值语句完毕,就销毁新的包装对象

L6 面向对象程序设计

讲诉了 JavaScript如何实现面向对象的程序设计

由于 JavaScript没有类的概念 因此这一章从创建对象和继承的层面上展示了一些流行的技术

此外 这一章还讲解了函数原型的概念,并对函数原型与整个面向对象方法的关系进行了探讨

本章内容:

  • 理解对象属性
  • 理解并创建对象
  • 理解继承

面向对象的语言都有类的概念,通过类可以创建多个具有相同属性和方法的对象,但ECMAScript 没有对象的概念,因此它的对象定义为"无序属性的集合,其属性包含值,对象,或者函数",可以理解成散列表,是一组名值对,其中的值可以是数据或者函数

6.1 理解对象

6.1.1 属性类型

数据属性

  • [[Configurable]]
  • [[Enumerable]]
  • [[Writable]]
  • [[Value]]

访问器属性

  • [[Configurable]]
  • [[Enumerable]]
  • [[Get]]
  • [[Set]]

6.2 创建对象

工厂模式: 虽然解决创造多个对象的问题,但是没有解决对象识别的问题

构造函数模式

  • 没有显式创建对象
  • 直接将属性和方法赋值给了this 对象
  • 没有return 语句
//工厂模式
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")
//构造函数模式
// 更优雅的工厂函数:构造函数
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.sayname = function () {
alert(this.name);
}
}
//将函数移到构造函数外 不再将函数绑到特定对象上面,但毫无封装性
function sayName(){
alert(this.name);
}

调用构造函数的四个步骤

  • 创建一个新的对象
  • 将构造函数的作用域赋给新的对象 ( 因此this 就指向了这个对象)
  • 执行构造函数中的代码 (为这个对象添加属性)
  • 返回新对象
6.2.3 原型模式

JavaScript 规定,每一个构造函数都有一个 prototype 属性,指向另一个对象。 这个对象的所有属性和方法,都会被构造函数的所拥有。

prototype 原型属性, 这个属性是一个指针,指向一个对象,这个对象的用途可以包含由特定类型所有实例共享的属性和方法

prototype 通过调用构造函数而而创建的那个对象实例的原型对象,使用原型对象可以让所有对象实例共享他们所办含的属性和方法(不必再构造函数中定义对象实例的信息,而是将这些信息直接添加到原型对象中)

function Person(name,age,job){
Person.prototye.name = "Nichlos";
Person.prototye.age = 29;
Person.prototye.job = "Software Engineer"
Person.prototye.sayName = function () {
alert(this.name);
}
}
var person1 = new Person();
Person1.sayName(); //Nichlas
var person2 = new Person();
Person2.sayName(); //Nichlas
alert(person1.sayName == person2.sayName)

理解原型对象

原型对象含有constructor 属性,这个属性里有指向prototype函数所在的指针

使得实例虽然不包含属性和方法,但却可以调用方法(),这个过程通过查找对象 的属性来实现

constructor 记录了创建该对象的构造函数

person1.name = "Greg";
alert(person1.name); // "Greg" 来自实例
alert(person2.name);//"Nicholas" 来自原型
delete person1.name;
alert(person1.name); //"Nicholas" 来自原型

当我们为对象添加一个属性的时候,这个属性就会屏蔽原型对象中保存的同名属性

构造函数、实例、原型三者之间的关系

任何函数都具有一个 prototype 属性,该属性是一个对象。

function F () {}
console.log(F.prototype) // => object
F.prototype.sayHi = function () {
console.log('hi!')
}

构造函数的 prototype 对象默认都有一个 constructor 属性,指向 prototype 对象所在函数。

console.log(F.prototype.constructor === F) // => true

通过构造函数得到的实例对象内部会包含一个指向构造函数的 prototype 对象的指针 __proto__。

var instance = new F()
console.log(instance.__proto__ === F.prototype) // => true

`__proto__` 是非标准属性。

实例对象可以直接访问原型对象成员。

instance.sayHi() // => hi!

总结:

  • 任何函数都具有一个 prototype 属性,该属性是一个对象
  • 构造函数的 prototype 对象默认都有一个 constructor 属性,指向 prototype 对象所在函数
  • 通过构造函数得到的实例对象内部会包含一个指向构造函数的 prototype 对象的指针 __proto__
  • 所有实例都直接或间接继承了原型对象的成员

原型 与 in操作符

in 单独使用: 通过对象能够访问到属性时返回true

更简单的原型语法

//更简单的原型语法
function Per(argument) {
Person.prototye = {
name : "Nicholas",
age : 29,
job : "Software Engineer",
sayName : function(){
alert(this.name);
}
}
}

这样的语法重写prototype对象,对象获得新的constructor属性 断开与之前构造函数的链接 (重新原型链) , constructor 属性不再指向Person了,指向Object

原型对象的问题

对于含有引用类型的值的属性来说,牵一发动全身

6.2.4 组合使用构造函数模式和原型模式
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.friends = ["shelby","Court"];
}
}
Person.prototype = {
constructor = Person;
sayName : function(){
alert(this.name);
}
}
var person1 = new Person("Nichlos",29,"Software Engineer");
var person2 = new Person("Greg",27,"Doctor");
person1.friends.push("Van"); //只改变 person1 实例

6.3 继承

接口继承: 只继承方法签名

实现继承: 则继承实际的方法

由于函数没有签名,在 ECMAScript中无法实现接口继承,其实现继承是依靠原型链的

6.3.1 原型链

若一个原型对象 等于 另一个类型的实例 则层层递进,构成了实例和原型的链条

更简单的原型语法

我们注意到,前面例子中每添加一个属性和方法就要敲一遍 Person.prototype 。 为减少不必要的输入,更常见的做法是用一个包含所有属性和方法的对象字面量来重写整个原型对象:

function SuperType(){
this.property = true;
}
SuperType.prototye.getSuperValue = function (){
return this.property;
}
//继承 SuperTyope
SubType.prototye = new SuperType(); // 原型2 = 实例1
SubType.prototye.getSubValue = function (){
return this.subproperty;
}
var instance = new SubType();
alert(instance.getSuperValue()); // true

继承通过创建 SuperType 的实例,并将该实例赋值给 SubType.prototype来实现的,其本质是重写原型对象,代之以一个新类型的实例

修改掉 prototype之后 我们constructor 的指向就不对了

属性成员的搜索原则:原型链

了解了 构造函数-实例-原型对象 三者之间的关系后,接下来我们来解释一下为什么实例对象可以访问原型对象中的成员。

每当代码读取某个对象的某个属性时,都会执行一次搜索,目标是具有给定名字的属性

  • 搜索首先从对象实例本身开始
  • 如果在实例中找到了具有给定名字的属性,则返回该属性的值
  • 如果没有找到,则继续搜索指针指向的原型对象,在原型对象中查找具有给定名字的属性
  • 如果在原型对象中找到了这个属性,则返回该属性的值

也就是说,在我们调用 person1.sayName() 的时候,会先后执行两次搜索:

  • 首先,解析器会问:“实例 person1 有 sayName 属性吗?”答:“没有。
  • ”然后,它继续搜索,再问:“ person1 的原型有 sayName 属性吗5?”答:“有。
  • ”于是,它就读取那个保存在原型对象中的函数。
  • 当我们调用 person2.sayName() 时,将会重现相同的搜索过程,得到相同的结果。

而这正是多个对象实例共享原型所保存的属性和方法的基本原理。

总结:

  • 先在自己身上找,找到即返回
  • 自己身上找不到,则沿着原型链向上查找,找到即返回
  • 如果一直到原型链的末端还没有找到,则返回 `undefined
6.3.3 组合继承 (combination inheritance)

使用原型链: 使用原型链实现对原型属性和方法的继承,实现函数的复用

使用构造函数: 实现对于实例属性的继承 确保每一个实例都有自己的属性 方法不会在函数中被定义

function SuperType(nam
this.name = name;
this.color = ["red","blue","green"];
}
SuperType.prototye.sayName = function (){
alert(this.name);
}
function SubType(name,age){
//继承属性,同时传递了参数
SuperType.call(name,age);
this.age = age; // 实例属性
}
//继承方法
SubType.prototye = new SuperType(); // 原型2 = 实例1
SubType.prototye.constructor = SubType;
SubType.prototye.sayAge = function (){
alert(this.age);
}
var instance1 = new SubType("Nichloas",29);
instance1.colors.push("black"); // 不影响其他实例的引用属性

小结

ECMAScript 支持面向对象编程,但不使用类或者接口. 对象可以在代码的执行过程中创建和增强,因此具有动态性而非严格的实体

  • 工厂模式: 使用简单的函数创建对象,为对象添加属性和方法 然后返回对象,被构造函数取代 (无法识别对象)
  • 构造函数: 可以创建自定义引用类型, 使用new 操作符 缺点:每个成员无法得到复用,尤其是函数 因为函数不局限于对象,没有理由不在多个对象间共享函数
  • 原型模式: 使用构造函数的 prototype 属性来指定那些应该共享的属性和方法, 组合使用构造函数和原型模式时, 使用构造函数定义实例属性,使用原型链定义共享的属性和方法

Javascript 通过原型链实现继承, 原型链是通过将一个实例复制另一个构造函数的原型来实现的,这样子,子类可以访问超类型素有的属性和方法

原型链的问题在于,对象实例共享所有继承的属性和方法,因此不宜单独使用,借用构造函数来做到每一个实例都有自己的属性,同时还能保持只使用构造函数来定义类型, 使用最多的是组合继承,原型链共享属性和方法 借用构造函数来继承实例属性

此外还有几种可供选择的继承模式

  • 原型式继承: 可以再不必预先定义构造函数的情况下继承,其本质是执行对给定对象的浅复制么人复制得到的副本进一步改造
  • 寄生式继承: 与原型继承相似,基于某个对象的信息创建一个新对象,然后增强对象,最后返回对象,
  • 寄生组合:

L7 函数表达式

集中介绍了 JavaScript最为强大的一个特性 -- 函数表达式

相关的内容 设计闭包 this对象的角色 模块模式 以及创建私有对象成员等等

本章内容

  • 函数表达式的特征
  • 使用函数实现递归
  • 使用闭包定义私有变量

定义函数的方式有两种, 一是 函数声明,二是函数表达式

函数声明中的重要特性 函数声明提升(function declaration hoisting)

执行代码之前,会先读取函数声明,// 你可以将函数声明放在调用它的语句后面

7.1 递归

argument.callee() 是一个正在指向执行函数的指针,用它实现对于函数的递归调用

后者在严格模式下 使用命名函数来达成相同的结果

var factorial = (function f(num){
if(num <= 1){
return 1;
}else{
return num * f(num-1);
}
});
递归应用场景
  • 深拷贝
  • 菜单树
  • 遍历 DOM 树

7.2 闭包

闭包

是指有权访问另一个函数作用域中的变量函数

常见的闭包的创建方式: 在一个函数内部创建另一个函数,

作用域链:

放某个函数被调用的时候: 创建一个执行环境(execution context) 及 相应的作用链, 然后使用arguments和其他命参数来初始化函数活动对象(activation object)

7.2.1 闭包与变量

作用链这种配置机制,引出一个副作用,即闭包只能取得包含函数中任何变量的最后一个值

//闭包保存的是整个变量对象,而不是某个特殊的变量

7.2.2 关于this 对象

this对象是运行时基于函数的执行环境绑定的,不过匿名函数的执行环境具有全局性,因此this 对象通常指向window,为什么 匿名函数没有取得其包含作用域的this对象呢?

每个函数在调用的时候都会自动取得两个变量 this和arguments,内部函数在搜索这两个变量的时候,只会搜索到其活动对象为止

7.3 模仿块级作用域

无论在什么地方 只要临时需要一些变量,就可以使用私有作用域

var someFunction = function(){
//块级作用域
}
(function(){
//块级作用域
})
function outputNumbers(count) {
(function (){
for (var i = 0; i < count; i++) {
alert(i);
}
})
alert(i); // Error
}

7.4 私有变量

JS 没有私有成员的概念,所有对象属性都是公有的,不过倒是有一个私有变量的概念,任何定义在函数中的变量,都可以认为是私有变量,因为不能在函数的外部访问这些变量

特权方法(privilege method): 有权访问私有变量和私有函数的公有方法

(function(){
var privateVariable = 10;
function privateFunction(){
return false;
}
//构造函数 是全局变量 MyObject可以在私有作用域之外被访问到
MyObject = function(){
};
//公有 特权方法 在原型上进行定义
MyObject.prototye.publicMethod = function(){
privateVariable++;
return privateFunction();
}
})
小结

Js中,函数表达式一项很有用的技术,使用函数表达式可以无须对函数命名,从而实现动态编程,匿名函数(lamba)是一种JavaScript强大的函数模式,函数表达式的特点如下:

  • 函数表达式不同于函数声明,函数声明要求函数有名字.但是函数表达式不需要,
  • 递归函数通过argument.callee() 调用自身,不需使用函数名,因为函数名可能会发生变化

当在函数内部定义了其他函数时,就创建了闭包,闭包有权访问函数内部所有的变量,原理如下

  • 在后台的执行环境中,闭包的作用域链包含着自己作用域,函数的作用域和全局作用域
  • 通常,函数作用域以及所有变量都会在函数执行后销毁
  • 但是,在函数返回一个闭包,这个函数作用域将会一直在内存中,直到闭包不存在为止

使用闭包可以在JavaScript模仿块级作用域,要点如下

  • 即使JavaScript中没有正式的私有对象属性的概念,但是可以使用闭包来实现公有方法,而通过公有方法可以访问在包含作用域中的变量
  • 有权访问私有变量的公有方法叫特权方法
  • 可以使用构造函数模式,原型模式来实现自定义类型的特权方法,也可以使用模块模式,增强的模块模式来实现单例的特权方法

JavaScript 中的函数表达式和闭包都是及其有用的特性,利用他们可以实现很多功能,不过创建闭包必须维护额外的作用域 所以过度使用它们可能会占用大量内存

L8 BOM

浏览器对象模型

即负责处理与浏览器自身有关的交互操作对象的集合

这一章全面的介绍了每一个BOM 对象:

Window document location navigator screen

ECMAscript是JavaScript的核心,但如果要在Web中使用JavaScript,那么BOM,才是真正的核心,

本章内容

  • 理解windows对象 -- BOM的核心
  • 控制窗口, 框架 和 弹出窗口
  • 利用location 对象中的页面信息
  • 使用navigator 对象了解浏览器

8.1 window 对象

BOM 对象的核心是window. 它表示浏览器的一个实例,在浏览器中,window对象即使JavaScript访问浏览器的一个接口,也是ECMAScript规定的GLobal 对象,这意味着在网页中定义任何一个对象,变量和函数,都以window作为global对象,有权访问parseInt() 方法

8.1.1 全局作用域

全局变量不能通过delete 操作符删除,而直接在windo 对象上的定义的属性可以 // delete window.age

var newValue = window.oldValue 这里oldValue还没定义,这里是一次属性查询,赋值为undefined

8.1.2 窗口关系及框架

top 始终指向最高最外层的框架,也就是浏览器窗口

window.frames[0] 来引用上方的框架

8.1.3 窗口位置

window.screenLeft / window.screenTop

8.1.4 窗口大小

innerWidth innerHeight outerHeight outerWidth

跨浏览器确定窗口大小很困难

页面视图容器大小

页面视图区的大小

视口大小 != 浏览器窗口大小

8.1.6间歇调用和超时调用

JavaScript是单线程语言,运行代码在特定的上时刻执行,前者在指定的时间过后执行代码,而后者是每隔指定的事件执行

通过返回的数值ID 来取消调用

// 间歇调用 超时调用
// 不建议传递 字符串 会导致性能损失
var timeoutID = setTimeout(function() {
alert("Hello World!");
},1000);
clearTimeout(timeoutID);

一般不使用间歇调用,使用潮湿调用来模拟,因为每次执行完代码后,如果不再设置另一次超时调用,调用就会自行停止,但间歇调用可能会在前一间歇调用完成之前启动

8.2 Location 对象

提供当前窗口加载的文档的有关信息,还提供了一些导航功能

还可以讲URL 解析为独立的片段

8.2.1 查询字符串参数

解析查询的字符串 然后返回包含所有参数的一个对象

function getQueryStringArgs(){
//取得并去掉开头的问号
var qs = (location.search.length > 0 ? location.search.substring(1):""),
args = {}, //保存数据对象
items = qs.length ? qs.split("&") : [], //取得每一项
item = null,
name = null,
value = null,
for (var i = 0; i < items.length; i++) {
item = items[i].split("=");
name = decodeURIComponet(item[0]);
value = decodeURIComponet(item[1]);
if (name.length) {
args[name] = value;
}
}
return args;
}
str = ?q=javascript&num=10
var args = getQueryStringArgs(str)
alert(args[q]); // "JavaScript"
8.2.2 位置操作

replace() 禁止后退行为,

reload(true) // 强行从服务端加载页面

8.3 navigator 对象

识别客户端浏览器的事实标准

plugins 数组

8.4 screen 对象

在编程中用处不大,基本只是用来表明客户端的能力

8.5 history 对象

可以创建自定义的后退 和 前进按钮

8.6 小结

BOM 以windows 对象作为依托.表示浏览器窗口以及页面可见区域,同时 window对象还是ECMAScript 中的Global 对象,因而所有的全局变量和函数都是它的属性,而且原生的构造函数和其他函数都存在于它的命名空间下,本章讨论了BOM 的组成部分

  • 在使用框架时,每个框架都有自己 的window 对象,以及所有原生构造函数以及其他副本,每个框架都有保存在frames 集合,可以通过位置或通过名称来访问
  • 有一些窗口的指针,可以用来引用其框架,包括父框架
  • Top 对象始终指向最外围框架,也就是整个浏览器窗口
  • parent 对象表示包含当前框架的框架, 而self对象则指回window
  • 使用location 对象可以通过编程的方式来访问浏览器导航系统,设置相应的属性,逐个或逐段修改浏览器的URL
  • replace() 的方法可以导航到一个新的URL,同时URL会替换当前浏览器历史记录中当前显示的页面
  • navigator 对象提供了与浏览器相关的信息 到底提供了那些信息取决于用户浏览器 UsrAgent 存在于所有浏览器中

Screen 对象中保存与客户端显示器有关的信息, 这些信息一般只用于站点分析

History对象为浏览器的历史记录打开缝隙,开发人员可以据此判定历史记录的数量,导航到任意的界面.

L10 DOM

文档对象模型

简要介绍了XML 与 DOM 的关系

为深入探讨所有DOM规范及其定义的操纵网页的方式奠定了基础