javascript征途笔记

基础
1、 只有函数有作用域
2、 如果在<script src>的src 中设置了src特性,则script元素包含的任意代码就无效了。应该分开放到不同的script块中。
3、 外部js脚本文件和页面内嵌的js代码的执行顺序是按它们在文档中的位置决定的,而不是先执行内嵌脚本,后执行外部脚本文件。
4、 建议通过外部文件形式导入js文件。
5、 使用接口技术解决js文件函数重名的冲突。问题是如果封装的接口也冲突了怎么办?定义接口的对象名也不能够相同,否则也会冲突。P46 这个例子没运行起来。
6、 Js为css设置样式,是以html文件为参考的,而不用考虑js文件的具体位置,而css文件是以它本身位置为参考的。
7、 浏览器是从上到下解析网页源码的。
8、 接口的概念?
9、 使用变量之前必须先声明。尽量少使用全局变量。
10、 怎么区分构造函数、类和一般的函数?在命名时构造函数和类名建议首字母大写,而函数小写开头
11、 使用alert和confirm进行手动调试

第四章 数据类型和变量
1、 实词和虚词。实词指标识符、关键字保留字、直接量等。虚词指空白符、换行符、注释等无意义的字符。实词是区分大小写的。
2、 Js只有三种数据类型:数值型(不区分浮点和整数,都是浮点型)、字符串型和数组型。null、undefined,number,string,Boolean是五种原始数据类型。
object
function是对象。是object的特殊情况。
棧存储值类型,堆存储引用类型。
3、 alert(Boolean(1));//返回的是true。书上返回的是13。有误
alert((a = 1,2,3,4));//4
alert(a=(1,2,3,4));//4
alert(Boolean(1));//true
a = 1,2,3,4;
alert(a);//1
var a = 1,2,3,4;
alert(a);//null
4、 JS仅支持定义一维数组。不支持多维数组。但是可以模拟多维数组。但是性能不好。
Var a = [[1,2,3],[4,5,6]];。数组可以放入不同的任意类型的数据,包括function和表达式。
5、 函数在js中是第一种类型(基类,父类),其他类型继承于function。Object也是由Function来实现的。这点很NB啊。
6、 函数如果没有返回值,责约定返回值是undefined。
7、 函数是一个独立的作用域,只能通过函数返回值读取函数内部的数据。而构造函数是可以通过this.属性,获取函数内部的属性值。构造函数是定义对象的模板,就是类。
8、 函数解析的机制:js解释器在预编译时就会把所有function语句声明的函数处理,如果存在同名函数,则后面的函数体会覆盖前面的函数体。而js解释器只是对var语句声明的变量名进行索引,变量的初始化值却被忽略,直到执行期才去为变量读取初始值。而对于function声明的函数体,js解释器不仅对函数盟按变量标识符进行索引,而且对于函数体也提前处理。
第一:JavaScript时按<script></script>编译,并执行的。
第二:JavaScript编译时完成对变量的声明,及函数处理。
第三:JavaScript后声明的函数将会覆盖前声明的函数
9、 处于同一个文档中的js教本,都属于同一个作用域:window。可以互相通信和调用。
10、 Constructor属性。表示构造函数的属性值,用来检测数据类型。(10).constructor。返回number。
Js习惯:先声明后读写,先赋值后运算。
变量的作用域:
1、 局部变量都比全局变量的优先权高
2、 内部局部变量比外层局部变量优先权高
3、 变量都是对象的属性。全局变量是window对象的属性。
第五章
Delete
如果删除内部对象的预定义成员和客户端对象成员,使用var语句申明的变量也是不允许删除的。
可以删除不存在的变量,返回true。
Delete操作是彻底删除所占用的存储空间。

Void运算符的优先级、void的运算结果返回undefined。

第七章
函数的作用域。
function和Function构造函数的作用域是不同的。Funtion有顶级作用域。而function是局部的。

函数的解析机制
Js解释器是一段段分析和执行程序的。在同一段代码中,function语句和函数直接量定义的函数结构总会被提取出来执行。只有当函数被解析和执行完毕之后,才会按顺序执行其它代码。但是Function构造函数定义的函数并非提前运行,而是在运行时动态地被执行。

函数的接收值个数没有限制。函数的返回值只能有一个。若要返回多个数据,则用数组存储。

函数的生命周期:
使用function语句声明的函数被预先编译,此时如果存在相同的函数名,则会按顺序覆盖。而函数直接量和构造函数定义的函数都属于表达式函数,因此在代码按行执行时,才被激活生命周期。

函数的形参通过length属性来获取。

Arguments对象。参数管理器
Arguments.length表示实参的个数。Arguments不是array对象,而是object对象,不能用for/in结构遍历。

可以通过arguments[i]下标动态改变实参的值。也可以通过修改length动态增大或减小实参的个数。

Arguments.Callee可以返回当前arugments对象所属的函数的引用,等价于函数名。Arguments.Callee.length表示函数形参的个数。

This关键字
Undefined+undefined=NaN。多个undefined相加会返回NaN。
函数作用域和实例化函数this的作用域是不同的。实例化只值向当前函数的作用域,而函数调用对象的作用域则是window。

函数属性的作用域:
函数体外定于的属性可以任意的访问,可以在函数体内或外部访问,而函数内部定义的属性在初始化状态只能在函数体内部被调用。但若函数被调用后,则可以在外部访问函数内部定义的属性。若属性是函数,作用域也是一样的。

Call和apply。Apply传递的是数组。
1、 Call和apply将函数转换成方法传递给某个对象,只是临时的,函数最终没有作为对象的方法存在,当函数被调用后,该对象方法会自动被注销。
2、 Call和apply避免了资源浪费。

闭包:数据存储的一种方式。在动态环境中,数据实时变化,为了避免前面的数据丢失,js提供了闭包来寄存动态数据。
特性:
自闭特性。外界无法访问闭包结构内部的数据。
包裹特性。

第八章
定义抽象对象的方法是通过构造函数来实现的。
Push()会添加新元素后返回数组长度。
创建对象时,存储在变量中的只是引用指针,并不是对象本身。删除变量后,对象本身依然存在。
Js的垃圾回收机制,自动收集无用存储单元,不需要专门销毁无用对象以释放内存。当对象没有被任何变量引用时,js会自动侦测并把所有废除的对象注销。
当我们把对象的所有引用变量都设置为null时,可以强制对象处于废除状态。并被回收。

当删除对象属性后,不是将属性设为undefined,而是真正从内存清除掉。

对象的作用域:
Js仅支持一种作用域,即公共作用域。对于js所有对象的所有属性和方法来说都是公开的。
Js对象的结构封闭性不如函数结构。函数有自己的私有作用域。外界是无法访问的。

通过命名规则以区分私有作用域。O.x._a_=1;

静态对象:static 声明。Math和Global都是静态对象。
Js不支持静态作用域。

构造对象:就是构造函数。如Object、Date、Function。构造对象的首字母要大写。
构造对象不能直接被引用。必须使用new来实例化。
alert(Point.name); //直接读取构造对象的属性
alert(p1.name); //但是不能够通过实例对象来读取构造对象的属性 返回 undefined。这个name是构造对象在函数外定义的。如果是在函数内定义的则可以访问。
对于构造对象的属性,实例对象是不能继承的,因此也不能够通过实例对象来读取构造对象的属性,反过来,构造对象也不能读取实例对象的属性。
构造对象不能使用this关键字来读去实例对象的属性。
function Point(x,y){
this.x = x;
this.y = y;
this.z = z;
}
Point.name = "类属性";
Point.money = "1203";
Point.saying = function(){
alert(this.length); //返回值2
}
Point.saying();
var p = new Point();
alert(p.name);// 实例对象不能访问构造对象的属性。抛错。

function Point(x){
this.x = x;
}
Point.saying = function(){ //构造对象的方法
alert("类方法");
}
Point.saying(); //直接调用构造对象的方法

Point.saying = function(){
alert(this.x);//不能通过this访问实例对象的属性
}
Point.saying(); //直接调用构造对象的方法 返回undefined

实例对象
实例对象的属性有两种:
第一种:从构造对象中继承过来的,这种属性每一个实力属性都有,但是他们拥有不同的副本。
第二种:自己创建的,这种属性只有这个实例对象所独有。

原型对象
就是构造函数的实例对象。它所包含的所有属性和方法能够供构造函数的所有实例共享。(类继承的实现),js叫原型继承。
原型对象时在使用构造函数创建对象是同时实例化的一个对象,所有的对象都共同拥有这个对象的引用。
通常我们在原型对象里面定义实例对象公用的方法,这样的好处是:
第一:所有的对象都共有这样一个方法实例,大大的节省的内存。
第二: 当我们想修改对象的方法是,只用修改原型对象的方法既可以了,不用再麻烦的修改每一个实例的方法。
如果原型属性和实例对象自定义的属性发生了命名冲突,则自定义的属性会“覆盖”原型属性的内容。这时由他的工作机制所决定的,但并不是真正的覆盖。如果我们删除这个属性,也是删除的实例的属性。
当js解释器在检索属性时,会先检查对象实例是否定义该属性,没有,则会检查构造函数的原型对象是否具有这个属性。属性的继承只发生在读属性值时,而在写属性时不会发生。

构造器
构造器是在Object类中定义的属性,该属性始终指向对象的构造函数。

对象的构造器属性是通过原型对象继承的,如果我们删除掉对象的原型,就可以看到他会自动查找到上一层的构造器属性。最终是要指向Ojbect的。

对于js内置对象来说,由于它们的原型是只读的,用户无法修改,所以可以使用constructor属性来判断内置对象的数据类型。

ToString ()、valueOf()方法。
hasOwnProperty 用来检测一个对象的属性是继承属性,还是私有属性。但是注意:如果是一个对象的继承属性则会返回false,但是对于这个对象的原型对象来说则会返回true
isPrototypeOf:判断一个对象的原形对象。函数的原型对象可以是Object.prototype,或者Function.prototype。

Global对象。是抽象类。JavaScript规定所有的对象和函数都不能独立存在,换句话说,所有的函数都必须是某个对象的方法, 所有的对象都必须是某个类的子类。

这就是全局对象,虽然是全局对象,但是global却没有方法调用全局的变量和方法。 这些方法却可以自己直接执行。

所以global有点像名誉zhuxi。没有实际的操控权利。
Date对象:
//获取本地系统的当前时间。
var now = new Date();
alert(now); //返回当前时间对象,如"Wed Apr 29 15 :37: 55 UTC +0800 2009 "

//通过多选参数来创建指定的时间对象。此时,构造函数Date()的参数格式如下:
new Date(year, month, day, hours, minutes, seconds, ms)

//除了前两个参数外(年和月)外,其他所有参数都是可选的,其中月数参数从0开始,如0表示第1个月,11表示第12个月。
var d1 = new Date(2009,4,1);
alert(d1); //返回时间对象,如"Fri May 1 00: 00:00 UTC+ 0800 2009"
var d2 = new Date(2009,4,1,5,30,30);
alert(d2); //返回时间对象,如"Fri May 1 00: 00:00 UTC+ 0800 2009"

//通过一个时间格式的字符串来创建指定的时间对象。此时,月份是从1开始,而不是从0开始。
var d1 = new Date("2009/4/1 5:30:30");
alert(d1); //返回时间对象,如"Wed Apr 1 05 :30: 30 UTC +0800 2009"

//通过传递一个毫秒数来创建指定的时间对象。这个毫秒数是距离1970年1月1日午夜(GMT时间)的毫秒数。
var d1 = new Date(1000000000000);
alert(d1); //返回时间对象,如"Sun Sep 9 09 :46 :40 UTC +0800 2001"

第九章 数组
数组的定义有两种方法:
1.使用new关键字,传入参数。
2.使用数组直接量,在中括号中添加元素。
建议使用第二种方法因为效率高一些。
Js的数组的长度可以任意伸缩,可以存储任意类型的数据内容。数组的下标可以不连续。Js在初始化数组时,只有真正存储在数组中的元素才能够被分配到内存中。
数组中的元素可以自由定义,例如如果只定义1和100则在内存中实际额只存在这两个元素。
所以在JavaScript中数组是否按顺序并不是那么重要。
Array.length返回的不是数组存储值的实际个数,而是当前数组的最大元素的个数。
数组和对象的一个区别就是:数组使用的是下标和具体的值相关联,而对象中则使用的是特定的字符串。
交换两个变量
var a = 10, b = 20; //变量初始化
//var temp = a; //定义临时变量存储a
//a = b; //把b的值赋值给a
//b = temp; //把临时变量的值赋值给b
a = [b, b = a ][0]; //通过数组快速交换数据
定义数组的基本方法:
第一步: 定义函数名,通过一个或表达式首先判断如果存在则直接使用如果不存在则定义。
第二步: 将第一的函数名付给Object,
Array.prototype._sum = Array.prototype.sum || //检测是否存在同名方法
( Array.prototype.sum = function(){ //定义该方法
var _n = 0; //临时汇总变量
for(var i in this){ //遍历当前数组对象
if( this[i] = parseFloat( this[i] ) ) _n += this[i]; //如果数组元素是数字,则进行累加
};
return _n; //返回累加的和
});
Object.prototype.sum = Array.prototype._sum //把数组临时原型方法赋值给对象的原型方法sum()


var a = [1, 2, 3, 4, 5, 6, 7, 8, "9"]; //定义数组直接量
alert( a.sum() ); //返回45

第十章字符串
Js解释器采用了引用的方法实现对字符串的操作。字符串数据被存储到堆,然后把字符串的引用地址存储在字符串变量中。同时为了避免错误操作,js解释器强制约定字符串在堆存储的数据是不可变的。相当于设置字符串在堆区存储的数据是只读的。
js对字符串的复制,传递操作,仅是简单的采用引用的方法,操作对象为堆区字符串的地址,即复制和传递地址。但是一旦编辑字符串本身的值,则js就会把堆区的字符串读取到棧区进行独立操作。
字符串的比较是逐字节比较的。先把两个变量的字符串读取到栈区,然后逐字节比较,最后返回比较结果。
字符串的操作是结合了值操作和引用操作的。当申明一个字符串时会把它的真实值存放在堆区,并且设定了堆区的内容是不可改变的,而在栈去存放堆区的地址。所以当进行复制和传递操作时只是进行了地址的传递,但是一旦要对字符串进行修改时则会复制一份放到栈区。实际是对栈区的内容进行改变,所以操作之后我们需要将这个值再次赋给引用,否则它会只是存放在栈区里,等待垃圾回收。
对于字符串类型的语句或表达式,可以使用静态方法eval()来执行。
var s = "alert('love')";
eval(s);
var s = new String(); //创建一个空字符串对象,并赋值给变量s.object类型。
var s = String( 123456 ); //包装字符串。String类型。
var s = String( 1, 2, 3, 4, 5, 6 ); //带有多个参数,只处理第一个参数并把它转换为字符串返回。
fromCharCode可以包含n个参数,参数代表字符的unicode编码。返回对应编码的字符的新字符串。
var a = [35835, 32773, 24744, 22909], b = [];//声明一个字符编码的数组
for( var i in a ){ //遍历数组
b.push( String.fromCharCode( a[i] ) ); //把每个字符编码都转换为字符串
}
alert( b ); //返回字符串"读,者,您,好"
alert( b.join( "" ) ); //返回字符串"读者您好"

第12章 BOM
BOM:浏览器对象模型。Browser Object Model
Bom对象包括:window,navigator,screen,history,location,document.
Window代表根节点,其它对象是window的属性。它是全局作用域
Window对象定义的3个人机交互方法:alert,confirm,prompt。

var url = "http://www.css8.cn/";
var features = "height=100, width=100, top=100, left=100,toolbar=no, menubar=no, scrollbars=no, resizable=no, location=no, status=no";
document.write('<a href="http://www.baidu.com/" target="newW" >切换到百度首页</a>');
var me = window.open (url, "newW", features);
setTimeout(function(){
me.close();
},30000);

使用write 方法时会覆盖掉前一个的内容。
Location.search 捕获url查询字符串信息。
第十三章 DOM
window.onload = function(){
var tag = document.getElementsByTagName("ul")[0];
var a = tag.childNodes;//获取列表结果所包含的所有列表节点
alert(a[0].nodeName);//显示第一个列表项的节点名称
node.childNodes[0] = node.firstChild
node.childNodes[node.childNodes.length-1] = node.lastChild
}
</script>
<ul>
<li>D表示文档,DOM的物质基础</li>
<li>O表示对象,DOM的思想基础</li>
<li>M表示模型,DOM的方法基础</li>
</ul>

DOM把元素之间的空格也当成文本节点。这在XML中是一样的。XML解析也是如此。
NodeType=1表示的是元素节点。
innerHTML返回元素包含的html信息内容。

第十四章 事件驱动模型
个人认为类似于as的事件机制。有父子元素冒泡和捕获的概念。
document.write('<script type="text/javascript">'); 写的js命令,必须放在<script></script>中。
4种事件处理模型:
1、0级 基本事件模型
2、标准事件模型
3、IE事件模型
4、Nerscape4事件模型

JS不支持多线程。支持异步回调。类似于as的回调函数。一旦异步执行完,根据执行返回条件执行对应的回调函数。

Js的事件流机制:捕获型和冒泡型。三个阶段:捕获阶段、目标阶段、冒泡阶段。
从IE6开始,html元素可以接受事件流。而这之前的版本是不行的。MOZILLA支持window对象。
<script language="javascript" type="text/javascript">
function f(a){
alert(a);//p点击时,FIREFOX的顺序是P,HTML,BODY。IE的顺序是P,BODY,HTML。
}
</script>
<html οnclick="f('HTML')">
<body οnclick="f('BODY')" bgcolor="#333333">
<p onClick="f('P')">冒泡型事件</p>
</body>
</html>

DOM2.0支持冒泡型事件流和捕获型事件流。但是规定捕获型事件流先进行响应。默认情况下,事件采用冒泡事件流,不采用捕获事件流。在firefox可以显示设置是否使用捕获型事件流。

一般来说事件处理函数都会有返回值,如果我们设置返回值为false就可以禁止它的默认行为。例如阻止超链接,阻止表单提交数据。

Event.srcElement。表示当前事件的源。利用该属性可以捕获当前对象。但是DOM2不支持该属性。在firefox浏览器要使用event.target。

alert(event.srcElement);//firefox:undefined,IE: object.firefox和 DOM2不支持srcElement属性

<button id="btn">按 钮</button>
<script language="javascript" type="text/javascript">
document.getElementById("btn").onclick = function(event){
event = event || window.event; //兼容FF和IE浏览器的event参数模式
var src = event.srcElement || event.target; //捕获当前事件的对象句柄
alert(src.innerHTML); //显示当前对象所包含的HTML文本信息
}
</script>

This对象
通常情况下this等于事件源对象。
<!--
通常情况下this等于事件源对象。
-->
<button id="btn" onClick="this.style.background='red';">按 钮</button>
<script language="javascript" type="text/javascript">
function btn1(){
this.style.background = "red"; //并非指向当前事件的目标对象.this指向window对象.
}
function btn2(event){
event = event || window.event;
var src = event.srcElement ? event.srcElement : event.target;
src.style.background = "red"; //指向当前事件的目标对象
}
</script>
<button onClick="btn1();">按 钮 1</button>
<button onClick="btn2(event);">按 钮 2</button>

再看个例子
<button id="btn1">按 钮 1</button>
<button id="btn2">按 钮 2</button>
<script language="javascript" type="text/javascript">
var b1 = document.getElementsByTagName("button")[0];
var b2 = document.getElementsByTagName("button")[1];
b1.f = function(){
this.style.background = "red"; //并非指向按钮1 按钮1 点击指向的是window,按钮2点击指向的是btn2.
}
b2.onclick = b1.f;
</script>

b2.onclick = function(){
b1.f(); //指向按钮1
}

这是因为函数的作用域造成的。
Js的函数总是运行在词法作用域中,即函数总是在定义它们的作用域中运行,而不在调用它们的作用域中运行。

元素的事件处理函数的作用域是独立的作用域,与局部作用域不同。
Js在引用变量值时,会根据作用域从内到外,从下到上检索,作用域顶部是window对象。但是对于html元素的属性的事件处理函数,它的作用域顶部是元素目标调用对象。

addEventListener()和removeEventListener()。在事件处理函数内部,this总是指向当前元素。
IE 7不支持DOM的addEventListener方法。

<p id="p">IE事件注册</p>
<script language="javascript" type="text/javascript">
/*
注销函数是不能够使用匿名函数,应为这样无法真正的删除这个绑定的函数。Firefox会把绑定和注销的两个结构相同的匿名函数视为不同函数。
*/
var p = document.getElementById("p");
p.attachEvent("onclick", f);
p.detachEvent("onclick", f);
function f(){
alert("p");
}
</script>
addEventListener()和removeEventListener()的第三个参数是否捕获,必须一致。

var event = event || window.event; //标准化事件对象 如果存在event则使用event,不存在则使用window.event


loading事件机制
<body onLoad="f1()">
<script language="javascript" type="text/javascript">
window.onload = f2;
function f1(){
alert('<body οnlοad="f1()">');
}
function f2(){
alert('window.onload = f2;');
}
</script>
如果同时使用两种方式定义load事件类型,会使用window对象注册的事件处理函数覆盖掉body元素定义的页面初始化事件属性。

window.onload = f1;
window.onload = f2;
以上写法f1会被f2覆盖掉。
window.addEventListener("load",f1,false); //为load添加事件处理函数
window.addEventListener("load",f2,false); //为load添加事件处理函数
这些写法就不会覆盖。两个监听都会执行。

DOMContentLoaded事件类型。
Load事件需要等到所有图像全部载入完成之后才会被触发。而DOMContentLoaded事件会在页面结构加载完毕后就能执行。先于load事件。IE7 不支持。

Onunload 和Beforeunload事件类型。关闭窗口之前的事件处理函数。

第十五章 样式
IE不支持DOM定义的style方法。
DOM的style定义方法
var box = document.getElementById("box");
box.style.setProperty("width","400px","");//第三个参数 priority表示是否为属性设置!important优先级命令。
IE的style定义方法
Box.style.width = “400px”;

看下面的例子:
<style type="text/css">
#box {
width:100px;
height:100px;
background-color:red;
border:solid 50px blue;
}
</style>
<div id="box"></div>
<script language="javascript" type="text/javascript">
var box = document.getElementById("box");
alert(box.style.border);//返回空值。使用style样式无法访问样式表中的样式属性。css样式信息并非存储在 style属性中,而是存储在css 类中。
</script>

<div id="box" style="width:100px; height:100px; background-color:red; border:solid 50px blue;"></div>
<script language="javascript" type="text/javascript">
var box = document.getElementById("box");
alert(box.getAttribute("style"));
</script>

要访问css类。可以使用document.styleSheet集合来实现。该集合包包含了文档中所有样式表的引用。如style 的link和import的外部样式表。和定义在本文档中的style样式。

DOM提供了cssRules集合,用来包含指定样式表中所有的样式。IE不支持。
<script language="javascript" type="text/javascript">
var cssRules = document.styleSheets[0].cssRules || document.styleSheets[0].rules;//判断浏览器的类型,是否支持cssRules。
alert(cssRules[0].style.border); //调用cssRules集合中的border属性
</script>

CssRules或rules集合的style对象在调用css属性时,使用的是js样式属性,不能够使用连字符,如cssRules[0].style.backgroundColor 不行,而必须使用cssRules[0].style.background-Color

如果同时存在css外部样式表,又存在定义在文档中的样式属性。按照它们的位置排列styleSheets数组的索引位置。
<link href="out.css" rel="stylesheet" type="text/css" media="all" />//styleSheets[0]
//styleSheets[1]
<style type="text/css">
#box { color:green; }
.red { color:red; }
.blue { color:blue; }
</style>

每个css规则都包含有selectorText属性,获取指定样式的选择符。在IE中大写显示,Firefox小写显示。
alert(cssRules[2].selectorText);
alert(cssRules[2].style.color);

动态添加样式insertRule和addRule
IE中支持addRule。FireFox支持insertRule
if(styleSheets.insertRule){ //判断浏览器是否支持insertRule()方法
//使用insertRule()方法在文档内部样式表中增加一个p标签选择符的样式,设置段落背景色为红色,字体颜色为白色,补白为一个字体大小。插入位置在样式表的末尾,
styleSheets.insertRule("p{background-color:red;color:#fff;padding:1em;}", index);
}else{ //如果哦浏览器不支持insertRule()方法
styleSheets.addRule("P", "background-color:red;color:#fff;padding:1em;", index);
}

addRule的Index表示样式插入的位置。默认是-1,表示在样式表末尾。
insertRule的Index表示样式插入的位置。默认是0,表示在样式表末尾。必须设置。

访问最终样式
IE: currentStyle对象,包含了所有元素的style对象定义的属性和任何未被覆盖的css规则的style属性。只有IE 支持。
alert("背 景 色:"+p.currentStyle.backgroundColor+"\n字体颜色:"+p.currentStyle.color);

DOM提供了getComputedStyle()方法。该方法需要在document.defaultView对象中访问。
var p = document.getElementsByTagName("p")[0];

alert("背 景 色:"+document.defaultView.getComputedStyle(p,null).backgroundColor+"\n字体颜色:"+document.defaultView.getComputedStyle(p,null).color);

offsetWidth表示元素在页面中的总宽度。
offsetHeight表示元素在页面中的总高度。
但是当为元素或者它的父元素定义了display:none,则offsetWidth和 offsetHeight都为0。

不同浏览器下获取style
function getStyle(e, n)
{
if(e.style[n])
{
return e.style[n];
}
else if(e.currentStyle)
{
return e.currentStyle[n];
}
else if(document.defaultView && document.defaultView.getComputedStyle)
{
n = n.replace(/([A-Z])/g, "-$1");
n = n.toLowerCase();
var s = document.defaultView.getComputedStyle(e, null);
if(s) return s.getPropertyValue(n);
}
else
return null;
}

显示和隐藏元素
css支持两种:visibility和display。
Visibility: 会保持元素在文档流中的影响力,隐藏后元素的位置保持不变。属性包括visible和hidden。
Display: 为none时,文档的结构会发生变化。被隐藏的元素及其子元素就被删除了。该元素不再占据文档位置。后面的元素会上移占据被删除的元素的位置。

透明度 :e.style.opacity = n / 100;

动画:
var out = setInterval(f, 1000); //定义周期性执行的函数.
clearTimeout(out); //则清除周期性调用函数
setTimeout();//只能被执行一次。如果要循环执行,采用以下嵌套的方式。

var t = document.getElementsByTagName("input")[0];
var i = 1;
function f(){
var out = setTimeout( //定义延迟执行的方法
function(){ //延迟执行函数
t.value = i ++ ; //递加数字
f(); //调用包含setTimeout()方法的函数
}, 1000); //设置每秒执行一次调用
if(i > 10){ //如果超过10次,则清除执行,并弹出提示信息
clearTimeout(out);
alert("10秒钟已到");
}
}
f(); //调用函数


第十六章 COOKIE
 有效期 expires属性
 可见性 path domain属性
 安全性 secure属性
以上都是cookie属性,而不是js属性。
Name:唯一的。不区分大小写。
Value:cookie信息。不超过4KB
Domain:
Path: 有效访问路径。Path=/。表示cookie信息将会与服务器根目录下所有网页相关联
Expires:失效日期
Secure:boolean。True表示安全方式传递。

Cookie字符串是一对名值对。

Cookie的封装:

function cookie(name, value, options)
{
if (typeof value != 'undefined')
{
options = options ||
{
}
;
if (value === null)
{
value = '';
options.expires = - 1;
}
var expires = '';
if (options.expires && (typeof options.expires == 'number' || options.expires.toUTCString))
{
var date;
if (typeof options.expires == 'number')
{
date = new Date();
date.setTime(date.getTime() + (options.expires * 24 * 60 * 60 * 1000));
}
else
{
date = options.expires;
}
expires = '; expires=' + date.toUTCString();
}
var path = options.path ? '; path=' + options.path : '';
var domain = options.domain ? '; domain=' + options.domain : '';
var secure = options.secure ? '; secure' : '';
document.cookie = [name, '=', encodeURIComponent(value), expires, path, domain, secure].join('');
}
else
{
var cookieValue = null;
if (document.cookie && document.cookie != '')
{
var cookies = document.cookie.split(';');
for (var i = 0; i < cookies.length; i ++ )
{
var cookie = (cookies[i] || "").replace( /^\s+|\s+$/g, "" );
if (cookie.substring(0, name.length + 1) == (name + '='))
{
cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
break;
}
}
}
return cookieValue;
}
}

第十七章 xml和json
XML :区分元素节点和文本节点。属性节点。

推荐使用JSON。
Json的数据结构基于对象和数组来构建。
对象:名值对。{“string1”:”value1”, “string2”:”value2”}
数组:

第十八章AJAX
注意 :客户端和服务器端的编码要一致。
JSON 异步通信协议 XMLHttpRequest 是 ajax异步交互的核心插件。和frame只能在同域中通信。
JSONP : JSON with Padding。能够通过在当前文档中生成脚本标记(script),来调用垮域脚本时使用的约定。
JSONP格式的数据就是把JSON数据作为参数传递给callback并传回。

ActiveXObject
XMLHRttpRequest。
encodeURIComponent() 函数可把字符串作为 URI 组件进行编码。

第十九章 OOP
Object,Function,Array,是内置的类。但是并不应该称为构造函数。我们在实例化的时候,会实例类的构造函数,但是类并不等于构造函数。

构造函数没有返回值,但是在js中构造函书可以返回一个对象值。构造函书内部并没有创造对象,而是使用this代替。This是新创建对象的引用指针。

原型模式
当在构造函书中定义prototype属性后,任何实例化的对象都拥有prototype属性所定义的属性。而实例化的对象不能通过prototype属性定义原型。
Js的内置对象都是构造函数结构体,因此都拥有prototype属性。

Prototype属性也是一个引用对象的指针,它值向一个隐形的对象,该对象存储着构造函书所有的原型属性。相当于基因库。一旦某个对象的属性被改动,则所有其他实例对象的属性也会变化。

构造函数属性和原型属性混合模式是ECMAScript的推荐标准。
function Book(title,pages){
this.title = title;
this.pages = pages;
Book.prototype.what = function(){
alert(this.title +this.pages);
};
}

动态原型模式
function Book(title,pages){
this.title = title;
this.pages = pages;
if(typeof Book.isLock == "undefined"){
Book.prototype.what = function(){
alert(this.title +this.pages);
};
Book.isLock = true;
}
}

修改原型属性,所有实例的原型值都会发生改变。
这章太复杂拉。可以单独写一本书出来了。


第20章
函数是第一型。表示。
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值