js权威指南读书笔记一

第二章语法结构
1. javasccript是用16位的Unicode字符集编写的，可以表示地球上通用的每一种语言。js程序中每个字符都是用两个字节表示的。
2. 注释两种表示方式--> //和 /* */

第三章数据类型和值
1. 在js中，所有数都是由浮点型表示的，并不区分整型和浮点型。 js数字格式允许表示+-9007199254740992(16位）之间的所有数，超过则会失去精确性。
2. js还是用了一些特殊的数值。当一个浮点值大于所能表示的最大值时，其结果是无穷大,js输出为Infinity,当一个负值比所能表示的最小的负值还小时，
结果就是负无穷大，输出为-Infinity。
当一个运算产生了未定义的结果或错误时，如0来除以0,就会返回NaN,它和任何数值都不相等，包括它自己在内，只能用isNaN()来检测。isFinite()用来
检测是否是NaN、Infinity、-Infinity
Number.MAX_VALUE Number.MIN_VALUE分别表示最大最小数字。
3 字符串中的转义字符\ ,如'You\'re right'
4 js1.5后新增toFixed用来格式化数字，如， var n = 123456.789 n.toFixed(0) //值为1234567 n.toFixed(2) //值为123456.79
5 字符串转化为数字，常用parseInt 和parseFloat方法， 如parseInt("3 blind") //值为3 parseInt("$73.3) //值为NaN
6 布尔值在数值环境中 true自动转为数字1，false转换为数字0
布尔值在字符串环境中，true转换为字符串"true" ，false转换为"false"
7 函数的两种定义方式。
function square(x) {return x*x;} 或var square = function(x) {return x*x;}
8 对象的创建 var point = new object(); point.x =2.3; point.y = 2; 或者 var point = {x:2.3,y:2}
对象属性访问方式： image.width 和image["width"]
另外var square = {"upperLeft":{x:point.x,y:point.y},...}
9 数组下标可以是字符串，也可以是0开始的数字。
数组的创建
a)var ar = new Array(); ar[0] =1.2;ar[1] = "javaScript"; ar[2] = {x:1,y:3};
b)var ar = new Array(1.2,"javaScript",{x:1,y:3});
c)var ar = [1.2,"javaScript",{x:1,y:3}];
清空数组可以用ar.length=0;
10 null
对象的特殊值，即代表无对象的值
布尔环境下它转换为false; 数字环境下，它为0;字符串环境下，它为"null"
undefined
使用了已声明但是还没有赋值的变量，又或者使用了一个并不存在的对象属性时，返回这个值。
布尔环境下它转换为false; 数字环境下，它为NaN;字符串环境下，它为"undefined"
虽然undefined和null值不同，但是==运算符却将两者看做相等。
如果必须区分两者，可以使用===或者typeof运算符。


第四章变量
1. 变量声明后，在没给赋值前，它的初始值为undefined
2. 局部变量的优先级比同名的全局变量高。也就是说给一个局部变量或者函数的参数声明的名字与某个全局变量名字相同，那么就有效地隐藏了这个全局变量。
如果变量声明赋值前不加var ，则该变量为全局变量，不管变量是不是在方法体内部声明的，如scope ="local",则声明或者覆盖原全局变量scope的值。
3. 没有块级作用域
函数中声明的所有变量，无论在哪里声明，在整个函数中他们都有定义（声明）。
function test(o) {
var i = 0;
if(typeof o == "object") {
var j=0;
for(var k=0;k < 10 ;k++) {...}
document.write(k); // 10
}
document.write(j); //0
}
由于这一规则，可以产生惊人的结果：
var scope = "global";
function f() {
alert(scope); //undefined
var scope ="local"; //在这里初始化，但是在函数体任意地方声明，这样就隐藏了全局变量。
alert(scope); //local
}
f();

4 in 运算符
var point = {x:1,y:1};
A:var has_x = "x" in point;
B:for(var pro in point)
5 typeof 和instanceof
typeof 运算符是数字、字符串或者布尔值，它返回结果是"number"、"string"、"boolean"，对对象、数组和null，它返回"object" ,
对函数它返回function ，如果未定义，它将返回"undefined".
(typeof i == "string")
instanceof 所有对象都是Object类的实例.常见有Date Object Number Array RegExp. a instanceof Object //返回true or false;

6 delete运算符
它将删除对象的属性、数组元素或者变量，如果删除成功，它将返回true，如果不能被删除，它将返回false。
用var 语句声明的变量不能被删除。
delete运算符删除一个不存在的属性，它将返回true
var o = {x:1,y:3};
delete o.x //return true
typeof o.x // property does not exist;return "undefined"
delete o.x //删除一个不存在的属性，return true;
delete o; //不能删除一个声明的变量(var),return false
x = 1;
delete x; //这种类型的变量能被删除，return true
x //runtime error; x is not defined
注：delete删除后，该属性将不存在，不是将他们的值设置为undefined. 而数组是将其置为 undefined,数组的length不变。

7 switch(expression)
{
case XXX : break;
default :

}

8 with语句
我们可以输入如下表达式来访问一个HTML表单元素：frames[1].document.forms[0].address.value
如果需要多次访问这个表单，可以用with语句
with(frames[1].document.forms[0]) {
name.value = "";
address.value = "";
}


第七章对象
1 属性的检查
var point = {x:1,y:3,z : null};
if(point.z == undefined){ point.z = 1} //属性z不存在或存在其值为null | undefined, 属性z都被置为1
if(point.hasOwnProperty("x")) { ....} //if内的条件为true ,属性是自己的，不是继承来的

注意：var t; alert(t == undefined);和var t = null; alert(t== undefined) 返回值都是true
2 constructor属性
每个对象都有一个constructor属性，它引用了初始化这个对象的构造函数。
如var d = new Date(); d.constructor == Date //返回true

3 isPrototypeOf()
对象是参数的原型对象则返回true,否则返回false
var o={};
Object.prototype.isPrototypeOf(o) //true
Object.isPortotypeOf(o) //false
Function.prototype.isPrototypeOf(Object) // true


第八章函数
1. js无限参数语法
function max(/*...*/)
{
var m = 0;
for(var i=0;i< arguments.length;i++)
{
if(arguments[i] > m) {
m = arguments[i];
}
}
return m;
}

2. callee
除了数组元素，Arguments对象还定义了callee属性，用来引用当前正在执行的函数，这个属性没什么太大用处，可以用于递归。
function(x) {
if(x<=1) return 1;
return x * arguments.callee(x-1);
}

3.可以忽略参数属性的函数调用
function arrayCopy(/* array */ from , /* array */ to) { ... }
var a = [1,2,3];
var b = new Array(4);
arrayCopy({from:a, to: b});


4. 函数的apply和call方法
执行的方式为：
fun.call(obj,1,2), 执行fun方法，参数为1、2，并改变方法内this对象为obj
fun.apply(obj,[1,2]) 执行fun方法，参数为1、2，并改变方法内this对象为obj
例子1
<input type="text" id="myText" value="input text">
<script>
function Obj(){this.value="对象！";}
var value="global 变量";
function Fun1(){alert(this.value);}

window.Fun1(); //global 变量
Fun1.call(window); //global 变量
Fun1.call(document.getElementById('myText')); //input text
Fun1.call(new Obj()); //对象！
</script>

例子2
function Person(name,age){
this.name=name //名字
this.age=age //年龄
this.sayhello=function(){alert("hello")}
}

function Student(name,age,grade,school){
Person.apply(this,arguments)
this.grade=grade //年级
this.school=school //学校
}

var p1=new Person("jake",10)
p1.sayhello()
var stu1=new Student("tom",13,6,"清华小学")
stu1.sayhello()
学生类本来不具备任何方法，但是在 Person.apply(this,arguments) 后，他就具备了 Person类的sayhello方法和 所有属性。

5.定义匿名函数，并执行
<script>
(function(){
alert(111)
})();
</script>

6闭包
正常情况下，在函数外部自然无法读取函数内的局部变量，出于种种原因，我们有时候需要得到函数内的局部变量，那就是在函数的内部，再定义一个函数，
并将这个函数作为外部函数的返回值。
function f1(){
　　　　var n=999;
　　　　function f2(){
　　　　　　alert(n);
　　　　}
　　　　return f2;
　　}
　　var result=f1();
　　result(); // 999
当函数f1的内部函数f2被函数f1外的一个变量result引用的时候，就创建了一个闭包f2函数，就是闭包。闭包就是能够读取其他函数内部变量的函数。闭包就是将函数内部和函数外部连接起来的一座桥梁。它的最大用处有两个，一个是前面提到的可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。
闭包的价值在于可以作为函数对象或者匿名函数，持有上下文数据。当一个内部函数在包含它们的外部函数之外被调用时，就会形成闭包。
var name = "The Window";
　　var object = {
　　　　name : "My Object",
　　　　getNameFunc : function(){
alert(this.name);//My Object
var name = "test";
　　　　　　 function f2(){
alert(name);　//test
alert(this.name);//The Window　　　　　　
　　　　　 };
return f2;
　　　　 }
};
object.getNameFunc()();

闭包的作用就是在a执行完并返回后，闭包使得Javascript的垃圾回收机制GC不会收回a所占用的资源，因为a的内部函数b的执行需要依赖a中的变量。这是对闭包作用的非常直白的描述，不专业也不严谨，但大概意思就是这样.


第九章 类、构造函数、原型
1原型
所有函数都有一个prototype属性，当这个函数被定义的时候，prototype属性自动创建和初始化。prototype属性的初始值是一个对象，这个对象只有一个属性，这个属性名constructor,它指回到和原型关联的那个构造函数。
原型对象只在读取属性的时候发生，而当写入属性值的时候，不会发生。
function Rectangle(w,h)
{
this.width = w;
this.height = h;
}
Rectangle.prototype.area = function(){return this.width * this.height;}
var r = new Renctangle(1,2);
r.hasOwnProperty("width"); //true
r.hasOwnProperty("area"); //false
"area" in r //true

2 扩展内建类
String.prototype.endsWith = function(c) {
return c == this.charAt(this.length -1)
}
var message = "abc";
message.endsWith('c');
注意，绝对不能为object.prototype添加属性，应为所添加的任何属性和方法都可以用for/in循环来枚举，一个空对象{}应该没有可以枚举的类型。

3 模拟类
function Circle(radius){ this. r = radius;}
Circle.PI = 3.14; //类的属性
Circle.max = function(a,b){if (a.r > b.r) return a; else return b;}//类的方法
Circle.prototype.area = function(){return Circle.PI * this.r * this.r;} //实例的共有的方法。
//类私有属性模拟
function Test(w,h)
{
this.getWidth = function() {return w;}
this.getHeight = function() {return h;}
}
Test.prototype.area = function() {
return this.getWidth() * this.getHeight();
}

4 为什么说Object是所有内建类的超类
所有对象有含有一个原型，原型本身就是一个对象，它是有Object构造函数创建的，这就意味着所有的原型对象都集成了，
Object.prototype属性。因此Complex了继承了Complex.prototype和Object.prototype的属性。

5 命名空间（一般一级就可以了）
var com_zhanghn = {};
com_zhanghn.hello = function() {alert("命名空间测试");};
com_zhanghn.hello();


第十三章web window
1. 常用
<form>
<select name="">
<option value="11">测试</option>
</select>
<input type="text" value="输入"/>
</form>
<script type="text/javascript">
var tt1 = document.forms[0].elements[0].options[0].value;
var tt2 = document.forms[0].elements[0].options[0].text;
var tt3 = document.forms[0].elements[1].value;
document.write(tt3);
</script>

2 浏览器Location和History
window对象的location属性是Location对象，代表该窗口，当前显示的文档的URL。Location的toString()方法返回的是href属性值，因此，可以使用location代表location.href.
window.location 和 document.location 有什么区别呢?一般没有区别，建议使用window.location.
在大多数情况下，document.location和location.href是相同的，但是，当存在服务器重定向时，document.location包含的是已经装载的URL，而location.href包含的则是原始请求文档的URL。
window对象的history属性是History对象，最常用的方法有back()和forward();

3 锚点
<a href="#top">跳到顶部</a>
…文字省略
<a name="top" id="top" ></a>
其实锚点只需name就可以可，加id是为了让它兼容性更好.
也可以用下面代码跳到顶部：window.location.hash = "#top";
另外，脚本产生的锚可能会打乱用户的浏览历史，为了滚动到一个指定的锚点上，且不产生新的历史项，可以使用 window.location.replace("#top");


4 重复执行。
setTimeout("function",milliseconds) 不会重复执行
setInterval("function",milliseconds) 自动重复执行
clearTimeout(对象) 清除已设置的setTimeout对象
clearInterval(对象)清除已设置的setInterval对象

<span id="countNum"></span>  second to close!
<input type="button" οnclick="stop()" value="stop"></input>
<script>
var index = 5;
function startCount()
{

document.getElementById('countNum').innerHTML=index;
if(index == 0)
{
window.opener=null;
window.open('','_self');
window.close();
}
index --;

}
var id = window.setInterval(startCount,1000);

function stop()
{
window.clearInterval(id);
}
</script>

5 窗口间关系
任何一个窗口的引用可以叫window或self。window对象open()方法返回代表新建窗口的window对象，其具有opener属性。此外还有frames、parent和top属性来引用其他的窗口。如果一个窗口是顶级窗口，而不是帧，那么parent属性引用的就是这个窗口的本身parent == self;
window和self可以省略，如window.parent可以直接写parent。
如果一个窗口包含一个帧，这个帧又包含另一个帧，则最里面的帧，可以用parent.parent来引用顶级窗口。无论一个帧被嵌套了几层，它的top属性引用的就是窗口自身。
帧通常由<frameset>和<frame>和<iframe>创建，可以用name属性为这个帧创建一个名字，在<a><form>的属性target可以用到。
如<a href="test01.html" target="mainFrame"></a>
如下代码创建一个帧<frame name="table_frame" src="toc.html">,在js中可以使用parent.table_frame找到它。
帧和帧之间是如果通信的？假设 A B 为兄弟帧，在A中定义var i = 3和函数f,则在B中可以parent.frames[0].i 和parent.frames[0].f();

第十五章 脚本化文档
Document
1. 遗留方法：document.write() document.writeln();
2. 重要属性和集合
referrer 获取将用户引入当前页面的位置 URL
title 位于<title>和</title>之间的文本
URL 一个字符串。声明了装载文档的URL。除非发生了服务器重定向，否则与Window对象的location.href相同
anchors[] 文档中锚点的集合 <a name="top" id="top" ></a>
forms[] 文档中from集合，每个Form对象都有自己的一个elements[]的集合属性。
images[] links[]
3. <form name="shipping">
<input type="text" name="zipcode">
</form>
访问的时候可以document.shipping.zipcode，如果名称相同， 则document.shipping则为数组，通常应确保name属性的唯一性。
4 事件onclick onsubmit等
在HTML中，事件属性不区分大小写，而javascript的所有事件属性，都必须用小写形式。

5 DOM树 父节点parent 子节点children 兄弟节点sibling 后代节点descendant 祖先ancestor
DOM树表现为不同种类的Node对象。Node接口定义了遍历和操作树的属性和方法，Node对象的childNodes属性返回节点的孩子列表。并且 firstChild,lastChild,nextSibling,previousSibling和parentNode属性提供了遍历树的一种方法。
每个Node对象都有一个nodeType属性，它指定了节点是什么类型。常见的类型有:
Element Node.ELEMENT_NODE 1
Text Node.TEXT_NODE 3
Attr Node.ATTRIBUTE_NODE 2

6 常用方法
document.getElementsByTagName("body")[0]
document.getElementsByName();
document.getElementById();
例:var table = document.getElementById("table");
var rows = table.getElementsByTagName("tr");
var rowNum = rows.length;