第一章 Javascript简介
Javascript实现
- 核心（ECMAScript）
- 文档对象模型（DOM）
- 浏览器对象模型（BOM）
ECMA-262
- 语法
- 类型
- 语句
- 关键字
- 保留字
- 操作符
- 对象
文档对象模型
针对XML但经过扩展用于HTML的应用程序变成接口API。把整个页面映射为一个多层节点结构。提供访问和操作网页的方法和接口。
- DOM1映射文档结构
- DOM2
- DOM视图(Vidws)
- DOM事件(Events)
- DOM样式(Style)
- DOM遍历和范围(Traversal and Range)
- DOM3加载文档的方法、验证文档的方法
浏览器对象模型
提供与浏览器交互的方法和接口。
第二章 在HTML中使用JavaScript
引入外部javascript, 标签之间不能再添加额外的内容。否则不执行。
<script type="text/javascript" src="abc.js"></script>
defer属性，脚本延迟到整个页面解析完再执行。每个标签按顺序执行。
async属性，不能保证按先后顺序执行。
charset属性，字符集。
script内嵌文件中出现的内容要\转义。
外部文件的优点：
- 可维护
- 可缓存
- 适应未来
noscript元素
当浏览器不支持JavaScript的时候，显示noscript元素中的内容。“需要启用JavaScript”
所有script元素都会按照他们做页面中出现的先后顺序依次被解析。在不使用defer和async的情况下，只有在解析完前面script元素中的代码之后，才会开始解析后面script中的代码。一般放在文档的后面 。
使用defer属性可以 让脚本在文档完全呈现之后再执行，延迟脚本总是按照指定他们的顺序执行。
使用async属性可以表示当前脚本不必等待其他脚本，也不必阻塞文档呈现。
第三章 基本概念
语法
- 区分大小写
- 标识符：第一个字符必须是字母、下划线、美元符号，其他字符可以是字母、下划线、美元符号、数字。可以包含ASCII和Unicode字符，驼峰大小写格式。
- 注释 // 单行注释 /****多行注释****/
- 严格模式：不确定的行为得到处理，不安全的行为抛出错误，"use strict" 可以在顶部添加代码，也可以在指定函数下添加。
- 语句：结尾分号不是必须，但推荐使用。控制语句多行使用代码块，建议始终使用。
关键字和保留字
不一一列举了。
变量
松散型变量可以保存任何数据
var message; //undefined
var message="hi";
如果在函数中var定义一个变量，退出函数后会销毁。如果函数中不用var直接使用，全局变量退出后还能使用。
可以用逗号创建多个变量var message=1 , go="haha", age=29;
数据类型
基本数据类型 undefined，Null，Bollean，Number，String
复杂数据类型 Object
typeof操作符
- undefined 未定义
- boolean 布尔值
- string 字符串
- number 数值
- object 对象或者null
- function 函数
instanceof检测对象
person instanceof Array
undefined类型
声明变量但是没有初始化。没有必要显式的声明。
var message;
alert(message); //undefined
alert(age); //产生错误
但是他们typeof都能输出undefined。
Null类型
空对象类型 typeof 返回object
未来使用空变量，初始化为null。
null == undefined //ture
Boolean 类型
在使用if的时候用于默认条件判断。 使用Boolean()进行转换
|数据类型|转换为true的值|转换为false的值|
|-|-|
|Boolean|true|false|
|String|非空字符串|空字符串|
|Number|非零数字包括无穷大|0和NaN|
|Object|任何对象|null|
|Undefined|不使用|undefined|
Number类型
八进制第一位是0，如果字面值中数值超出范围。那么前导0忽略。八进制在严格模式无效。
十进制前两位是0x。在进行算数计算时，所有的十六进制和八进制被转换为十进制。
isFinite(123) 判断是否无限大
没有小数部分的浮点数，会转换为整数。
1.2e7
1.2e-7
浮点数表示法
最大能表示的数值 Number.MAX_VALUE
最小能表示的数值 Number.MIN_VALUE
0除以0返回NaN，NaN和任何数值都不相等，包括本身。使用isNaN(123)--false，isNaN(NaN)当然返回true，不能转换为数值的，也会返回true。isNaN("10")就是false，isNaN(true) 可以被转换成数值1，也是false。isNaN("blue")不能转换成数值，是false。
Number()数值转换规则
- 布尔值，转换为0和1
- 数字，简单传入返回
- null，返回0
- undefined，返回NaN
- 字符串，遵循以下规则。
- 如果只含数字，转换为十进制数字，前导0忽略
- 如果含浮点格式，转换为浮点数值
- 如果包含有效的十六进制字符，转换成十进制数字
- 如果字符串是空的，转换为0
- 除上述之外，转换为NaN
- 如果是对象，调用valueOf()方法，依照前面的规则返回的数值进行返回。如果结果是NaN，则调用对象的toString()方法，再依照前面进行返回。
parseInt()函数
找到第一个非空字符进行转换，如果第一个字符不是数字，返回NaN。因此，转换空字符串会返回NaN。而Number会返回0.第二个参数可以是基数。"22.5"返回22，小数点不是有效的数字字符。
parseFloat 函数
从第一个字符开始解析每个字符。一直解析到字符串末尾。或者解析遇见一个无效的浮点数字字符为止。第二个小数点无效。
String类型
字符字面量
\n \t \r
每个字面量长度是1
字符串不可变，要改变字符串，只能销毁原来的。
toString()方法
返回字符字面量，能传递基数，但是null和undefined没有这个方法。如果想把null和undefined转换成字符串，使用String()转型函数、
Object类型
var o = new Object()
每个实例都有下列属性和方法
- constructor 创建当前对象的函数
- hasOwnProperty 检查给定的属性在当前对象实例中是否存在
- isPrototypeOf 检查传入对象是否是传入对象的原型
- propertyIsEnumerable 检查给定对象能否使用for in语句
- toLocaleString() 返回对象字符串表示，与执行环境对应
- toString() 返回对象字符串表示
- valueOf() 返回对象字符串，数值，布尔值表示
操作符
一元操作符
递增和递减操作符，前置和后置。
- 包含有效数字字符的字符串，转换为数字后操作。
- 不包含有效数字的字符串，变量设置为NaN
- 布尔值转换为0和1再操作。
- 浮点数，执行加减1
- 对于对象，先调用valueOf方法，运用转换规则。如果结果是NaN，则调用toString()方法。
一元加减操作符。如果是非数值，用Number（）转换，如果是对象，先调用valueof和toString方法，然后再转换。
位操作符
负数是二进制的补码，补码是反码+1.
按位非NOT 负值减1
按位与AND &
按位或OR |
按位异或 XOR ^ 相同为0 不同为1
左移 << 用0填充
右移 >> 用0填充
布尔操作符
逻辑非!
对象返回false，
空字符串返回true，
非空字符串返回false，
操作数0返回true，
非零返回false，
null返回true，
NaN返回true，
undefined返回true。
两个逻辑非，可以转换为布尔值。和Boolean() 相同
逻辑与&&
- 第一个操作数是对象，返回第二个操作数
- 第二个操作数是对象，只有在第一个求值结果是true情况下才返回该对象。
- 两个操作数都是对象，返回第二个操作数。
- 有一个操作数是null、NaN、undefined，则返回他
- 短路操作
逻辑或||
- 如果第一个操作数是对象，返回第一个操作数
- 如果第一个操作数的求值结果为false，则返回第二个操作数。
- 如果两个操作数都是对象，则返回第一个操作数
- 如果两个都是null、NaN、undefined。
- 短路操作
乘性操作符
乘法*
- 如果操作符都是数值，按照常规乘法计算，超出范围变成无穷大。
- 有一个操作数是NaN，结果是NaN
- Infinity与0相乘，结果是NaN
- infinity与非0相乘，结果是infinity或者-infinity
- 两个Infinity相乘，返回Infinity
- 有一个操作数不是数值，调用Number()转换后，在执行上面的操作。
除法/
- 超过范围，结果是infinity或者-infinity
- 有一个操作符是NaN，返回NaN
- infinity除以infinity,返回NaN
- 0除以0，返回NaN
- 非零有限数被0除，结果是infinit或-Infinity
- 有一个操作数不是数值，后台调用Number()转换后，再用上面的规则。
求模%
- 数值返回正常值。
- 被除数无限大除数有限大，返回NaN
- 被除数有限大除数是0，返回NaN
- Infinity被Infinity除，结果是NaN
- 被除数有限大，除数无穷大，结果是被除数。
- 被除数是0，结果是0.
- 有一个操作数不是数值，调用Number（），再应用上述规则。
加性操作符
加法
- 有一个操作符是NaN，结果就是NaN
- 两个正无穷相加或者两个负无穷相加，结果就是正无穷和负无穷。
- 正无穷和负无穷相加，结果是NaN
- 字符串相加，就拼接
- 一个是字符串，则将另一个转换为字符串，再拼接。
- 如果操作数是对象、数值、布尔值，调用他们的toString()取得相应字符串的数值，对于undefined和null，分别调用string()取得字符串undefined和null
减法
- 两个操作符都是数值，执行常规计算。
- 有一个是NaN，结果都是NaN
- Infinity-Infinity=NaN
- -Infinity- -infinity = NaN
- infinity--infinity=infinity
- -infinity-infinity=-infinity
- 0-0=0
- 0--0=-0
- -0--0=+0
- 如果一个操作数是字符串、布尔值、null、undefined，后台调用number()将转换为数值，再根据前面的规则执行减法计算。如果转换的结果是NaN，那么整个结果是NaN
- 如果有一个操作符是对象，调用valueOf取得对象的数值，如果得到的是NaN，则结果是NaN，如果没有valueOf方法，则调用toString()方法并得到字符串转换为数值。
关系操作符
- 两个操作符都是数值，执行数值比较。
- 都是字符串，比较编码数值
- 如果一个操作数是数值，则将另一个操作数转换为一个数值进行比较。
- 如果一个操作数是对象，则调用这个对象的valueOf方法，用结果进行比较。如果没有，就调用toString方法。
- 如果一个操作数是布尔值，则现将其转换为数值，进行比较。
- 任何操作符和NaN比较，都是false。
相等操作符
相等和不相等 先转换再比较
- 有一个操作数是布尔值，转为数值再比较。
- 一个是字符串，另一个是数值，比较相等这钱先将字符串转换为数值。
- 一个是对象另一个不是，调用valueOf方法，用得到的基本类型和前面的比较。
- null和undefined相等。不能将null和undefined转换为其他任何数值。
- 有一个操作数是NaN，相等操作符返回false，不相等返回true。NaN不等于NaN。
NaN<3 false
NaN>=3 false - 两个操作数是对象，比较是否是同一个对象。
全等和不全等 仅比较不转换
条件操作符
variable = bollean_expression ? true_value : false_value;
赋值操作符
= += -= *= /= %= <<= >>= >>>=
逗号操作符
var num1=1,num2=2,num3=3;
var num=(2,4,5,6,7) //返回最后一个
语句
if语句
if(a>b){
alert("aaa");
}else if(i<0){
alert("aaa");
}else{
alert("aaa");
}
if (condition) statement1 else statement2
do-while语句
do{
statement
}while(expression);
while语句
while(expression) statement
for语句
for (initialization; expression; post-loop-expression) statement
for (;;;) statement 无限循环
for-in 语句
枚举对象属性,确认对象是不是或者undefined
for (property in expression) statement
label语句
label:statement
break和continue语句
可以返回标签
with语句
with(expression) statement
with(location){
var qs = qs
var hostname = hostname
}
var qs = location.qs
var hostname = location.qs
switch语句 每句要break
switch(i){
case 25:
alert("25");
break;
case 35:
alert("35");
break;
default:
alert("other");
}
如果不写break，就会合并2个的情况。
函数
function functionName(arg0,arg1,...,argN){
statements
}
return语句停止并立即退出，之后的语句不会执行。
ECMAScript函数不介意传递进来多少个参数，也不建议是什么数据类型。
arguments[0]可以获取第一个参数，并且时时保持同步。arguments.length确定传递进来多少参数。可以重写argument对应的值。如果没有赋值，那就是undefined。
没有重载
后面的函数覆盖前面的
第四章 变量、作用域和内存问题
基本类型和引用类型
动态属性
var person = new Object();
person.name = "abc";
alert(person.name); //"abc"
var name ="abc";
name.age =24;
alert(name.age); //undefied
不能给基本类型的数值添加属性。
复制变量值
基本类型的数值复制，两个变量相互独立。
引用类型对象复制，复制的为指针。
传递参数
所有函数的参数传递是按照数值传递。
function setName(obj){
obj.name = "Nicholas";
obj = new Object();
obj.name = "Greg";
}
var person = new Object();
setName(person);
alert(person.name) //"Nicholas"
内部的obj被赋予了其他的指针。
检测类型
基本类型使用 typeof
引用类型 result = variable instanceof constructor
执行环境及作用域
在web浏览器中，全局执行环境是windows对象。
代码在环境中执行，会创建变量对象的作用域链。
内部环境可以通过作用域链访问外部环境，但是外部环境不能访问内部环境中的变量和函数。
延长作用域链
try-catch语句的catch块
with语句
这两个语句都会在作用域链前端添加一个变量对象。对于with语句来说，会将指定的对象添加到作用域链中。对catch语句来说，会创建一个新的变量对象，其中包含的是被抛出的错误对象的生命。
没有块级作用域
在括号内的if或者for的变量是全局变量，不是局部变量。
在函数内，var是局部，不添加var是全局
查询标识符，由内部到外部。找到这个变量。
垃圾收集
以后再说标记清除、引用计数、性能问题、管理内存
第五章引用类型
Object 类型
创建对象
var person = new Object()
//对象字面量表示法
var person = {
name:"aaa";
age:29
}
var person = {
"name":"aaa";
"age":29
}
//对象最后不能加逗号
var a = {} //与new Object()相同
访问属性
person['name'] //可以用空格非数字，变量，关键字
person.name
Array 类型
var colors = new Array()
var colors = new Array(20) //预先知道长度
var colors = new Array("a","b","c")
var colors = Array(3) //3项
var colors = Array("aa")
var colors = Array(3) // 省略new 操作
var names = ['a','b'] //字面量法，
var names = [1,2,] //不要这样
var names = [,,,] //也不要这样
colors[0] //显示第0项，也可以修改，或者对新的项新增。
colors.length //显示长度
colors[colors.length] = "a" //添加新项
value instanceof Array 检测数组，一个环境
Array.isArray(value) 确定到底是不是数组，不管哪个环境
转换方法
array.valueof() 返回数组，对每一项toString
toLocaleString()
toString() 返回数组每个值的字符串形式拼接而成的一个以逗号分隔的字符串
array.join("|")
栈方法
后进先出LIFO(last in first out)
array.push(1,2,3) 返回修改后数组长度
array.pop() 返回移除的数组
队列方法
先进先出FIFO(first-in-first-out)
array.push(1，2，3)
array.shift()
前进后出
array.pop()
array.unshift
重新排列方法
array.reverse() 反序
array.sort(function compare(value1,value2){return value2-value1})
function compare(value1,value2){
if(value1 < value2){
return -1;
} else if (value1 > alue2){
return 1;
} else {
return 0
}
}
操作方法
array.concat([a,b,c])组合成新数组,没有参数的时候，只是返回副本。
array.slice(1,3) 按照python那种方式提取数组，不会影响原始数组
array.splice(1,0,[1,2]) 删除、插入、替换数组
位置方法
indexOf(4,4) 可以查找某个东西的位置，带参数从那个位置开始找。
lastIndexOf()
迭代方法
- every() 每项运行都运行函数，每一项都返回true，则返回true
- filter() 返回true的组成新数组
- forEach() 每一项运行给定函数，没有返回值
- map() 返回每次调用函数的结果
- some() 任何一项返回true，就返回true
function(item,index,array){
return(item>2);
}
归并方法
reduce() reduceRight()
var values = [1,2,3,4,5]
var sum = values.reduce(function(prev,cur,index,array){
return prev+cur
})
DATE类型
var now = new Date() 创建日期当前对象，可传入1970.1.1的毫秒数
var someDate = new Date(Date.parse("May 25, 2005")) 按照日期格式转换
var someDate = new Date(Date.UTC(2005,4,5,17,55,55)) 按照0的基数
var start = Date.now() 取得当前时间
valueOf返回毫秒表示，方便比较
toString和toLocalString 返回字符串
RexExp类型
暂缺
Function类型
function sum(num1, num2){
return num1 + num2
}
var sum = function(num1,num2){
return num1 + num2;
};
末尾分号
没有重载
函数声明与函数表达式
率先读取声明，读取到规定地方才读取表达式
function sum(sum1, sum2){} //这是声明,函数声明提升
var sum = function (){} //这是表达式
作为值的函数
把一个函数作为另一个函数的结果返回.return function(){}
函数内部属性
arguments 传入对象的所有参数
this 执行环境，在不同的环境表示
arguments.callee 是函数自己 比如阶乘可以用
caller 保存着调用当前函数的函数引用。
function outer(){
inner()
}
function inner(){
inner.caller; //outer();
}
arguments.callee.caller 更松散的耦合
函数的属性和方法
length 函数希望接收的命名参数的个数
prototype 属性，不可枚举，for-in无法发现
apply() 可以扩充作用域，在特定作用域中调用函数
call() 与apply作用相同，区别是接受参数的方式不同，传递的参数必须枚举出来
function sum(num1,num2){
return num1+num2
}
function callSum1(num1,num2){
return sum.apply(this,arguments);
}
function callSum2(num1,num2){
return sum.apply(this,[num1,num2]);
}
function callSum3(num1,num2){
return sum.call(this,num1,num2);
}
扩充作用域
window.color = "red"
var o = {color:blue}
function saycolor(){alert(this.color)}
saycolor.call(0)
bind() 绑定作用域
window.color = "red"
var o ={color:"blue"}
function sayColor(){
alert(this.color)
}
var objectSayColor = sayColor.bind(o);
objectSayColor(); //blue
基本包装类型
var s1 = "some text"
var s2 = s1.substring(2);
实际上完成的是以下操作
var s1 = new String("some text");
var s2 = s1.substring(2)
s1 = null
Boolean类型
因为所有对象会转换成true，所以用处不大。
valueOf() 返回基本类型true和false
toString() 返回字符串true
typeof基本类型会返回boolean，引用类型返回object，理解引用关系非常重要。
永远不要使用Boolean 对象
Number类型
var numberObject = new Number(10)
valueOf()返回基本类型的数值
toLocalString和toString返回字符串形式
num.toFix(2) 返回指定小数位，四舍五入
typeof基本类型返回number
typeof引用类型返回object
String类型
valueOf toString toLocalString 返回字符串
使用toString用于将数值格式化为字符串方法
字符方法
stringValue.charAt(1) //访问指定位置
stringValue.charCodeAt(1) //访问指定位置的编码
stringValue[1] //访问指定位置
操作方法
stringValue.concat("world") //字符串连接
slice substr substring //子字符串
indexOf lastIndexOf //位置方法
trim() //删除空格
toLowerCase toUpperCase //大小写转换
match() //接收正则表达式或者RegExp对象
search() //接收正则表达式或者REgExp对象 返回第一个匹配是索引
replace() //替换 可以用正则表达式
localeCompare() //方法
单体内置对象
Golbal对象
URL编码方法
encodeURI() //整个URL编码，不会对本身属于URL字符编码冒号斜杠
encodeURLComponent() //对一段编码，对任何非标准字符编码。
decodeURL()
decodeURLComponent() 解压
eval方法
解析语句
Golbal对象属性
各种类型，构造函数，错误，日期，regexp等
windows对象
访问Global对象，Web浏览器都是将这个全局对象作为windows对象实现。
Math对象
底数，自然数，最大值，最小值，四舍五入，随机数
第六章 面向对象的程序设计
var person = new Object();
person.name = "abc";
person.sayName = function(){
alert()
}
var person = {
name:"abc",
age:29.
sayName:function(){
alert(this.name);
}
}
属性类型
数据属性
[[Configurable]] 能否删除重新定义
[[Enumerable]] 能否通过for-in 循环返回属性
[[writable]]
[[Value]] 这个属性的数值
Object.defineProperty(aaa,"name",{
writable:false,
value:"aaaa"
})
访问器属性
[[Configurable]] 能否删除重新定义
[[Enumerable]] 能否通过for-in 循环返回属性
[[get]]读取属性调用的函数
[[set]]写入属性调用的函数
aaa._age=87;
Object.defineProperty(aaa,"age",{
get:function(){
return this._age;
},
set:function(newValue){
this._age=newValue;
}
})
aaa.age=88
alert(aaa.age)
定义多个属性
var book={};
Object.defineproperties(book,{
_year:{
value:2004
},
edition:{
value:1;
}
}
)
读取属性的特性
Object.getOwnPropertyDescriptor(book,"year")
如果是访问属性，那么是configurable,enumerable,get,set
如果是数据属性，那这个对象属性有configurable\enumerable\writable和value
var descriptor = Object.getOwnPropertyDescriptor(book,"_year");
descriptor.value
创建对象
工厂模式
function createObject(name,age,job){
var person = new Object;
person.name = name;
person.age = age;
person.job = job;
person.sayName = function(){
alert(this.name)
}
return person;
}
无法解决对象识别问题
构造函数模式
function Person(name,age,job){
this.name=name;
this.age=age;
this.job=job;
this.sayName = function(){
alert(this.name);
}
}
var person1= new Person("johnny",18,"workker")
没有显式创建对象，直接将属性和方法赋给this对象，没有return语句。构造函数要大写。
person1.constructor == Person //true
person1 instanceof Person //true
每次执行方法，都要重建一次。两个创造出来的sayname不相同。把函数移到外面，但是没有封装了。
原型模式
function Person(){}
Person.prototype.name = "Johnny"
Person.prototype.age = 20
Person.prototype.job = "Software Engineer"
Person.prototype.sayName = function(){
alert (this.name);
}
var person1 = new Person()
person1.sayName();
var person2 = new Person()
person2.sayName();
alert(person1.sayName == person2.sayName); //true
Person.prototype.isPrototypeOf(person1) //true
Object.getPrototypeOF(person1).name //"Johnny"
无法通过对象实例重写原型中的值，重写之后会给实例添加属性，却不能改写原型。使用delete删除属性，从而回复对原型的访问。使用person1.hasOwnProperty('name') 是否存在于实例中。
原型与in操作符
如果对象能通过原型或者实例访问到属性，in返回true。
确定是原型中的属性。
function hasPrototypeProperty(object,name){
return !object.hasOwnProperty(name) && (name in object);
}
使用for-in循环，返回的是所有能够通过对象访问的、可枚举属性，既包括存在于实例中的属性，也包括存在于对象中的属性。
原型简写
function Person(){}
Person.prototype = {
constrotor : Person,
name:"abc",
sayName : function(){
alert(this.name);
}
}
Object.defineProperty(Person.prototype,"constructor",{
enumerable:false,
value:Person
}
);
取得对象上可枚举实例的属性
var keys = Object.keys(Person.prototype);
alert(keys); //"name,age,job,sayName"
取得所有实例的属性，无论是否可枚举
Object.getOwnPropertyNames(Person.prototype);
要不然constructor无法确定对象类型。但是变成可枚举的enumerable。
更简单的原型语法
function Person(){}
Person.prototype = {
constructor:Person,
name:"Nicho",
age:18,
sayName:function(){
alert(this.name);
}
};
这样从这里创建的新对象的constructor就不再指向Person了。所以要重写constructor.但是会导致constructor 的Enumerable特性被设置成true。
Object.defineProperty(Person.prototype,"constructor",{
enumerable:false,
value:Person
})
原型的动态性
重写一个原型属性可以，但是重写整个原型会导致指向他的实例失去属性。
原型对象问题
没有传递参数，共享本性。
原型对象的问题
所有的实例在默认情况下都使用相同的属性。
组合使用构造函数模式和原型模式。
function Person(name, age, job){
this.name = name;
this.age=18
}
Person.prototype={
constructor:Person,
sayName:function(){
alert(this.name);
}
}
使用最广泛、认同度最高
动态原型模式
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);
}
}
}
不能使用对象字面量重写原型，会切断联系。
寄生构造模式
先不看了
稳妥构造模式
先不看了
继承
function SuperType(){
this.property = true;
}
SuperType.prototype.getSuperValue = function(){
return this.property
}
function SubType(){
this.subproperty = false
}
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function(){
return this.subproperty;
}
var instance = new SubType();
alert(instance.getSuperValue())
//确定原型和实例的关系
instance instanceof Object
instance instanceof SuperType
instance instanceof SubType
Object.prototype.isPrototypeOf(instance)
SuperType.prototype.isPrototypeOf(instance)
SubType.prototype.isPrototypeOf(instance)
谨慎定义方法，覆盖方法，给原型添加方法一定要放在替换语句之后。
重写subtype会阻断与super之间的联系。
不能通过字面量添加新方法，这样会重写原型。
SubType.prototype = {
getSubValue:function(){
return this.subproperty;
},
someOtherMethod: function(){
return false;
}
}
问题1 ，引用类型的原型，原型会变成另一个类型的实例，实例对原型的修改，提现在了其他的实例上。在创建子类型的时候，不能向超类型的构造函数传递参数。
借用构造函数？？？
function SuperType(name){
this.color = [1,2,3,"name"]
}
function SubType(){
SubType.call(this,"haha");
}
var instance1 = new SubType();
instance1.push("black")
var instance2 = new SubType();
instance2.color //没有变化
可以传递参数.缺点都在构造函数中定义，无法重复使用，超类型中定义的方法，在子类型中不可见。
组合继承？？？？
function SuperType(name){
this.name = name;
this.colors = ["red","blue","green"];
}
SuperType.prototype.sayName = function(){
alert (this.name);
}
function SubType(name,age){
SuperType.call(this,name);
this.age = age;
}
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
alert(this.age);
}
var instance1 = new SubType("Nicholas",29);
instance1.color.push("black");
alert(instance1,colors); //四个颜色
instance1.sayName(); //nigulasi
instance1.sayAge(); //29
var instance1 = new SubType("aaa",28);
instance1.color.push("black");
alert(instance1,colors); //三个颜色
instance1.sayName(); //aaa
instance1.sayAge(); //28
既避免了原型链和借用构造函数的缺陷，又融合了有点，是最常用的继承模式。
原型式继承
寄生式继承
寄生组合式继承
第七章 函数表达式
函数声明，函数声明提升。
函数表达式，类似于赋值语句。
递归
arguments.callee 返回函数本身，多用于递归。
网友评论