JS简单入门学习笔记一

JS的HelloWorld

在页面中输出一个内容
document.write();
向控制台输出一个内容
console.log();

/**1.JS中严格区分大小写*2.JS中每一条语句以分号结尾*  - 如果不写分号，浏览器会自动添加，但是会消耗一些系统资源。*  - 而且有时候浏览器会加错分号，所以必须写*3.JS中会忽略多个空格和换行
*/

JS注释

/*多行注释
*/

// 单行注释

字面量和变量

变量的声明方式var a = ""

标识符

在JS中所有可以由我们自主命名的都可以称标识符
例如：变量名、函数名、属性名等
命名规则：
可以含有字母、数字、_、$
不能以数字开头
不能使ES中的关键字或保留字
一般采用驼峰命名法
JS底层保存标识符时实际上是采用的Unicode编码
所以理论上讲，所有的utf-8中含有的内容都可以作为标识符

数据类型

`String`–字符串，用单双引号

可以用\进行转义
- \" 表示"
- \’ 表示’
- \n 表示换行
- \t 制表符
- \\ 表示\，（打印\也需要转义）
字符串属性
- .length
字符串方法
- str.charAt(索引) 返回指定索引位置的字符
- str.charCodeAt(索引) 返回指定索引位置字符的 Unicode 值
- String.fromCharCode(Unicode) 将 Unicode 转换为字符串
- str.concat("str2","str3") 连接两个或多个字符串，返回连接后的字符串
- str.indexOf("内容",索引) 检索字符串是否含有指定内容并返回第一次出现的位置
  - 没有找到返回-1
  - 指定第二个参数表示开始查找的位置
- str.lastIndexOf("内容",索引) 从后往前找，用法同indexOf()
- str.slice(开始位置,结束位置(不包括)) 提取字符串的片断，并在新的字符串中返回被提取的部分
- str.substring(开始位置,结束位置(不包括)) 提取字符串中两个指定的索引号之间的字符
  - 和slice()类似，但是不能接收负值，否则默认使用0，
  - 如果第二个参数小于第一个，则自动交换位置
- str.substr(开始位置,截取长度) 从起始索引号提取字符串中指定数目的字符
- str.toUpperCase() 把字符串转换为大写并返回
- str.toLowerCase() 把字符串转换为小写并返回
- str.split() 把字符串分割为子字符串数组
  - 参数：需要一个字符串作为参数，会根据该字符串进行拆分
  - 也可以传递一个正则表达式作为参数str.split(/[A-z]/)
  - 默认全局匹配
- str.search() 搜索字符串中是否含有指定内容
  - 用法类似indexOf()，但是可以接收正则表达式作为参数
  - 只会查找一个，设置全局匹配没用
- str.match() 找到一个或多个正则表达式的匹配
  - 默认，只会找到要第一个符合要求的内容，然后停止，可以设置正则表达式为全局汽配模式
  - 可设置多个匹配模式
  - match()会将匹配到的内容封装到一个数组中返回
- str.replace(被替换,新内容) 替换与正则表达式匹配的子串
  - 参数
    被替换的内容可以接收一个正则表达式
  - 默认只会替换一个，可以设置全局匹配模式

`Number`–数值

Number.MAX_VALUE 数字的最大值：1.7976931348623157e+308
Number.MIN_VALUE 大于0的最小值：5e-324
1/0–JavaScript Infinity(正无穷)（如果数字超过了最大值则会返回Infinity）
1/0–Java 报错
NaN–not a number

`Boolean`布尔值

`Null`–空值

使用typeof检查null时，会返回object

`Undefined`–未定义，声明了并没有赋值

`Object`–对象

new Array()
new Date()

查看变量类型typeof，会将值的类型以字符串形式返回

强制转换类型

string

.toString();
打印一个对象时，实际上输出的是对象的toString()方法的返回值[object Object]，可以为对象添加一个toString()方法来打印出字符串
该方法不会影响到原变量，它会将转换的结果返回
注：null和undefined这两个值没有toString()方法
调用String()函数
对于Number和Boolean实际上就是调用的toString()方法
对于null和undefined就不会调用toString()方法
将null直接转换为"null"
将undefined直接转换为"undefined"

number

使用Number()函数

字符串----->数字
如果是纯数字的字符串，则直接转换
如果字符串中有非数字，则转换成NaN
如果字符串为空，或全是空格，则转换为0
布尔----->数字
true 转成1
false 转成0
Null---->数字
0
undefined------>数字
NaN

parseInt() 字符串转为一个整数
可以将字符串中有效的整数内容取出来
可以传递第二个参数，来只懂数字的进制parseInt(a,10)
parseFloat() 字符串转换为一个浮点数
获取有效的小数
对于非String，会先将其转换为String，然后再操作

Boolean

使用Boolean()函数

数字—>布尔
除了0和NaN，其余都是true
字符串—>布尔
除了空串其余都是true
null和undefined都会转换为false
对象也会转换为true

constructor 属性

constructor属性返回所有JavaScript变量的构造函数。

"John".constructor                      // 返回函数 String()
(3.14).constructor                      // 返回函数 Number()
false.constructor                       // 返回函数 Boolean(
[1,2,3,4].constructor                   // 返回函数 Array()
{name: 'John', age: 34}.construcor      // 返回函数 Object()
new Date().constructor                  // 返回函数 Date()
function() {}.constructor               // 返回函数 Function()

正则表达式

语法：

构造函数方法：var reg = new RegExp("正则表达式","匹配模式")，更加灵活
字面量方法：var reg = /正则表达式/匹配模式，更加简单

使用字符串方法

`search()`

str.search(/w3cschool/i);

`replace()`

str.replace(/microsoft/i, “w3cschool”);

正则表达式方法

`test()`

test() 检测一个字符串是否符合正则表达式规则true或false

/e/.test("The best things in life are free!");

`exec()`

exec() 方法用于检索字符串中的正则表达式的匹配。

/e/.exec("The best thing in life are free!");

字符串中含有与“e”,所以返回 e。

`compile()`

compile()方法用于改变RegExp。
既可以改变减速模式，也可以添加或删除第二个参数。

var patt1=/e/;
console.log(patt1.test("We are family!"))  // true
var patt2=/d/;
patt1.compile(patt2);
console.log(patt1.test("We are family!"))  // false

正则表达式模式

| 表示或
[] 里面内容也是或的关系。
- [ab] == a|b
  /a[a-z]c/ 表示 “a任意字母c”
- [a-z] 任意小写字母
- [A-Z] 任意大写字母
- [A-z] 任意字母
- [0-9] 任意数字
- [^ ] 除了
(x|y) 查找任何以 | 分隔的选项。

匹配模式

i 忽略大小写
g 全局匹配模式
m 多行匹配

量词，设置一个内容出现的次数
- 只对前边一个内容作用
- {n} 设置出现n次
- {m,n} 出现m-n次
- {m,} 出现m次以上
- s+ 至少一个 s ,相当于{1,}
- s* 零个或多个 s，相当于{0,}
- s? 零个或一个 s，相当于{0,1}
- ^a 以a开头
- a$ 以a结尾
元字符
- . 查找单个字符
  - 使用\转义字符\.表示.
  - \\ 表示\
- \w 任意字母、数字、_ [A-z0-9]
- \W 除了字母、数字、_ [^A-z0-9]
- \d 任意数字 [0-9]
- \D 除了数字 [^0-9]
- \s 空格
  - 去空格
```
//全局
str = str.replace(/\s/g,"")
// 开头所有空格
str = replace(/^\s*/,"")
// 结尾所有空格
str = str.replace(/s*$/,"")
// 开头结尾所有空格
str = str.replace(/^\s*|\s*$/g,"")
```
  - 电子邮件正则表达式
    [\w]
- \S 除了空格
- \b 单词边界
- \B 除了单词边界

其他进制的数字

表示16进制的数字，要以0x开头
表示8进制的数字，要以0开头
表示2进制的数字，要以0b开头，但不是所有浏览器都支持

运算符

算术运算符 + - * / %(取模，余数)

除了字符串加法，非数字都先转换为Number再运算
任何数字和NaN做运算都得NaN
两个字符串进行加法运算则会做拼串
任何值和字符串做运算都会先转换为字符串然后再拼串
可以用任意数据类型 + 空串转换为字符串
可以用任意数据类型 - 0 * /、任意数据类型 * 1、任意数据类型 / 1转换为Number

一元运算符

+ 正号，可以用其将值转换为Number，原理和Number()函数一样
- 负号

自增自减

自增
a++; 等自增前的值，先使用再加1
++a; 等于自增后的值，先加1再使用
实例：

var a  = 10
var result = a++ + ++a +  a;
alert(result); //等于几？
/*
a++ = 10
a = 11
++a = 12
a = 12
result = 34
*/

自减
a--; 等自减前的值，先使用再减1
--a; 等于自减后的值，先减1再使用

逻辑运算符

! 非
用来对一个值进行非运算
对一个布尔值进行取反操作
对非布尔值，则先转换为布尔值，可以用该特点将数值类型取两次反，转换为布尔值
&&（与） ||（非）
对于非布尔值，先转换为布尔值，再运算并返回原值
– && 与，属于短路与
---- 如果两个值都是true则返回后边的值
---- 如果有false，则返回靠前的false的值
– || 或，属于短路或
---- 如果第一个值为true，则直接返回第一个值
---- 如果第一个值为false，则返回第二个值

赋值运算符

= 将右侧的值赋值给左侧的变量
+= a +=5等价于a = a +5
-= a -=5等价于a = a - 5
*= a *= 5等价于a = a * 5
/= a /=5等价于a = a / 5
%= a %=3等价于a = a % 5

ddd +=10*3 - 4 + 8
即，ddd = ddd + (10 * 3 - 4 + 8)

比较运算符

关系运算符

– 非数值比较时，先将其转换为数值
– 任何值和NaN比较都是false
– 如果负号两侧的值都是字符串，不会将其转换成数字，而是分别比较Unicode字符编码
– 比较字符编码时是一位一位的比较
– 比较字符串型的数字时，可能会得到不可预期的结果，一定一定一定要转型

> 大于号
>=大于等于
< 小于号
<= 小于等于

等于运算符

==等于
- 先转换成相同类型在比较
- undefined==null返回true
- NaN不和任何值相等，包括自己
- 可以通过isNaN()函数判断一个值是否是NaN
!= 不等于
- 用法同==
=== 绝对等于
- 不自动转换类型
!== 不绝对等于

Unicode编码

在字符串中使用\u四位编码
在网页中使用&#编码（这里的编码是十进制的）

条件运算符（三元运算符）

条件表达式?语句1:语句2;

执行流程
- 首先对条件表达式进行求值
  - true，则执行语句1
  - false，则执行语句2

实例：

// 取a/b/c中的最大值
var a = 30;
var b = 43;
var c= 50;
// 先获取a和b中的最大值
var max = a > b ? a : b;
// 取a/b/c中的最大值
max = max > c ? max : c;
// 或者
// var max = a>b ? (a > c ? a : c) : (b > c ? b : c)// 不推荐，不方便阅读
alert(max)

运算符的优先级

可以通过()改变优先级

代码块

{}
JS中的代码块只具有分组的作用，里面的内容在外部可见

对象

语法一：

obj = new Object();
obj.name = "John"；
obj.age = 18;

语法二（常用）：

obj = {name:"John",age:18}

属性名可以加引号也可以不加，建议不加

枚举对象中的属性

for(var 变量 in 对象) {alert("变量")  // 取出属性名alert("obj[变量]")  //取出属性值
}

注：该方法在用原型对象构建对象时，如果对象中没有但原型中有，也会返回true

内置（内建）对象

String 对象

属性 .length
常见方法
//转换大小写
-toLowerCase()转换为小写；
-toUpperCase() 转换为大写；
// 判断是否包含
-indexOf() 检索字符串；
-lastIndexOf() 从后向前检索字符串；
-match() 找到一个或多个正则表达式匹配；
// 取出指定位置字符
-charAt() 指定位置的字符串；
// 替换字符串
-replace() 替换与正则表达式匹配的子串；
// 取出字符串
-substr() 从起始索引号提取指定数目的字符；
-substring() 提取两个指定索引号之间的字符；
-concat 连接字符串；
// 字符串分割
-split() 把字符串分割为字符串数组；

链式编码

Date 对象

创建时间对象

new Date();

new Date(2019, 3, 30, 10,10, 10);

new Date("2019/4/30");

年

new Date().getYear(); //从1900年开始算
new Date().getFullYear() ;

月

new Date().getMonth();

日

new Date().getDate();

星期

new Date().getDay();

时

new Date().getHours();

分

new Date().getMinutes();

秒

new Date().getSeconds();

毫秒

new Date().getMilliseconds();

全部毫秒

new Date().getTime(); //1970年到现在的毫秒

Math 对象

Math不是一个构造函数
对象属性
-E 返回算数常量e，自然对数的底数（约等于2.781）；
-LN2 返回2的自然对数（约等于0.693）；
-LN10 返回10的自然对数（约等于2.302）；
-LOG2E 返回以2为底e的对数（约等于1.414）；
-LOG10E 返回10为底的e的对数（约等于0.434）；
-PI 返回圆周率（约等于3.14159）；
-SQRT1_2 返回2的平方根的倒数（约等于0.707）；
-SQRT2 返回2的平方根（约等于1.414）。
对象方法
-abs(x) 返回绝对值；
-ceil(x) 进行上舍入；
-floor(x) 进行下舍入；
-max(x,y) 返回x和y中的最高值；
-min(x,y) 返回x和y中最小值；
-pow(x,y) 返回x和y的次幂；
-random() 返回0~1之间的随机数；
-round(x) 把数四舍五入为最接近的整数；
-sqrt(x) 返回数的平方根；
-toSource() 返回该对象对的源代码；
-valueOf() 返回Math对象的原始值；
-acos asin atan atan2 tan sin cos exp log

Number 对象

RegExp

Function

Events

包装类（基本不用）

String() 将字符串转换为Srting对象
Number() 将数字转换为Number对象
Boolean() 将布尔值转换为Boolean对象

创建对象的五种方式

工厂方式

function factoryModel(name,age) {// 创建一个object对象var obj = new Object();// 设置对象的属性和方法obj.name = name;obj.age = age;obj.learn = function() {alert("好好学习，天天向上")}//返回对象return obj;
}
function testCreate() {var student = factoryMOdel("张晓红",18)；student.learn();
}

构造函数方式

就是一个普通函数，但用首字母大写来区分
调用方式不同，要用new关键字调用
使用构造函数创建的对象，称为一类对象，也将构造函数称为一个类

//类
function Student(name,age) {// 实例变量this.name = name;this.age = age;this.learn = function() {alert("书山有路勤为径")}
}
function testCreate() {var st1 = new Student("王晓伟"，18)；//实例alert(st1.age + "--" st1.name);
}

使用对象 instanceof 构造函数 检查一个对象是否是一个类的实例

原型方式

当函数以构造函数调用，它所调用的函数都有一个隐含的属性原型对象
可以通过__proto__来访问该属性
把共有的属性和方法统一添加到构造函数原型对象中，就不用为每一个对象添加，也不会影响到全局作用域

function Teacher(){Teacher.prototype.uname = "zhangsan";Teacher.prototype.age = 28;Teacher.prototype.fav = ["足球","篮球","乒乓球"];Teacher.prototype.teach = function(){alert("诲人不倦")}
function testCreate() {var t1 = new Teacher();var t2 = new Teacher(); //修改t1 t2会不会被修改t1.fav.push("保龄球")；t1.uname = t1.uname.toUpperCase();alert(t1.uname);
}

使用.hasOwnPropert("")来检查对象自身是否含有该属性
原型对象也是对象，也有原型，object的原型就没有原型了

混合的构造函数和原型(推荐)

function Person(name,age,gender) {//设置属性this.name = name;this.age = age;this.gender = gender;
}
person.prototype.speak = function() {alert(this.name + "向您问好")；
}
function testCreate() {var p1 = new Person("丁鹏" 18，"男")；var p2 = new Person("谢晓峰",48,"男")p1.speak();p2.speak();
}

动态原型方式

function Dog(name) {//设置属性this.name = name
};
//设置原型的时候需要作判定，防止重复
if(typeof Dog._run == "undefined") {Dog.prototype.run = function(){alert("狗带铃铛跑的欢")}//设置判定，别人就不能再设置了Dog._run = true;
}
function testCreate() {var d1 = new Dog("旺财");alert (d1.run())
}

垃圾回收

当一个对象没有任何变量或属性对他进行引用，此时我们将永远无法操作该对象，这种对象就是垃圾。

数组

创建一个数组

1: 常规方式:

var myCars=new Array();
myCars[0]="Saab";
myCars[1]="Volvo";
myCars[2]="BMW";

2: 简洁方式:
var myCars=new Array("Saab","Volvo","BMW");

3: 字面:
var myCars=["Saab","Volvo","BMW"];

访问数组

数组[索引]; 访问某个特定的元素
数组[索引] = ""; 设置数组的值

数组属性

数组.length 获取数组的长度
数组.length = 10 设置数组的长度
数组[数组.length] = "" 向数组最后一个位置添加元素
数组.indexOf("值") 获取值的索引

数组方法

数组.push() 向数组末尾添加一个或多个元素，并返回数组新的长度
数组.pop() 删除数组的最后一个元素并返回删除的元素
数组.unshift() 向数组的开头添加一个或多个元素，并返回新的长度
数组.forEach() 数组每个元素都执行一次回调函数。只支持ie8以上，需要一个函数做参数
数组.slice(0,2) 提取出指定元素
- 参数
  - 截取开始位置的索引，包含；
  - 截取结束位置的索引，不包含，
    - 第二个参数省略不写，会截取从开始往后的所有元素，
    - 传递负值则从后往前计算，如：-1指倒数第一个
数组.splice(index,num,"新值") 从数组添加或删除元素，并返回删除的元素
- 参数
  - 第一个，开始位置的索引；
  - 第二个，删除的数量
  - 第三个及以后参数，可以传递新的元素插入到删除开始位置索引前边
数组.concat(数组2) 连接两个或更多的数组，并返回结果。
数组.join("连接符") 把数组的所有元素放入一个字符串。
数组reverse() 反转数组的元素顺序。
数组sort() 对数组的元素进行排序。按照Unicode编码排序，对数字会产生错误
- 可以在sort()中添加回调函数来指定排序规则

arr.sort(function(a,b) {return a-b //升序排列return b-a //降序排列
})

浏览器会根据回调函数的返回值来决定排序，
- 返回大于0的值，元素交换位置，
- 返回小于0 的值，位置不变
- 返回0，则认为两个元素相等，位置不变

遍历数组

for (var i = 0; i < arr.length; i++) {alert(arr[i]);
}

arr.forEach(function(value, index, obj) {alert(value)
})
// 会传递三个参数// 第一个参数是遍历的元素// 第二个参数是遍历的元素的索引// 第三个参数是遍历的数组

数组去重

var arr = [1,2,3,2,2,1,3,4,2,5];
for (var i=0; i<arr.length; i++) {for (var j=i+1; j<arr.length; j++) {if (arr[i] == arr[j]) {arr.splice(j,1);//删除j之后后边自动补位，直接跳过了// 使用j自减j--;}}
}
alert(arr)

函数

函数也是对象
可以封装一些功能

创建函数

构造函数方式式

var f1 = new Function("alert('zhangsan')");

函数声明方式式

function f2() {aler("lisi");
}

函数表达式方式

var f3  = function(){alert("wangwu");
}

函数参数

推荐书籍<<JavaScript语言精粹>>

在函数的()中可以指定一个或多个形参
调用函数时可以在()中指定实参
调用函数时不会检查实参的类型，可能会受到非法参数，如果有可能要对参数进行类型检查
也不会检查实参的数量，一般要求形参和实参数目一致，而且相对应

/**
* @param {string} name 类似于局部变量
*/
function sayHello(name) {alert("早上好：" + name);
}
sayHello("刘诗诗");

实参可以是任何值

实参过多时可以声明一个对象来传递

function sayHello(o) {alert("我是" + o.name + "，我今年" + o.age + "岁了，" + "我住在" + o.add);
}
var obj = {name: "孙悟空",age: 18,add: "花果山"
};
sayHello(obj);

函数返回值

function sayBack(){return "666"//后面的代码不会被执行
}
var test = sayBack();
alert(test);

return后的语句都不执行
如果不写return或者return后不跟任何值，就相当于返回undefined

返回值可以是任意的数据类型

立即执行函数

(function(){alert("")
})()

call和apply

调用call()和apply()，都会调用函数执行
可以将一个对象指定为第一个参数，此时这个对象将会成为函数执行时的this

fun.call(obj,2,3) 可以将实参在对象之后依次传递
fun.apply(obj,[2,3]) 需要将实参封装到一个数组中统一传递

函数的重载

function test() {alert("我没有任何形参");
}
function test(a) {alert("我有一个形参");
}
function test(a,b) {alert("形参：" + test.length + "个 ，" + "实参：" + arguments.length + "个");
}

// 测试函数的重载
// 在js中形参的数目和实参的数目可以不同
// 实现函数的重载：参数的类型、数目

function sayHello() {// 判断参数的类型、数目var args = arguments;// 判断参数的数目if(args.length == 1 && typeof args[0] == "string"){alert("执行一个参数的方法========字符串");} else if (args.length == 2 && typeof args[0]=="number"){alert("执行2个参数方法========数字");}else {alert("暂无对应处理方法");}
}
sayHello(1);

作用域

全局作用域

函数作用域（局部作用域）

函数作用于执行完毕，函数作用域销毁

debug

call和apply

0

.call(obj,2,3) 可以将实参在对象之后依次传递
.apply(obj,[2,3]) 需要将实参统一封装到一个数组中统一传递
当对函数调用这两个函数时都会调用函数执行
在调用时可以将一个对象指定为第一个参数，此时这个对象将会成为函数执行时的this

this

解析器在调用函数时每次都会向函数内部传一个隐含的参数，this
this指向一个对象，这个对象我们成为函数执行的上下文对象
根据函数的调用方式的不同，this会指向不同的对象
1. 以函数形式（fun()）调用时，this永远都是window
2. 以方法形式（obj.fun()）调用，this就是调用方法的对象obj
3. 以构造函数的形式调用时，this就是新创建的那个对象new obj
4. 使用call()和apply()调用时，this是指定的那个对象

argument

封装实参的对象，是一个类数组对象
在调用函数时，所传递的实参都在argument中保存
argument.length可以获取实参长度
不定义形参，也可以用argument来使用实参，不过比较麻烦
- argument[0] 表示第一个实参
- argument[1] 表示第二个实参
属性callee
- 这个属性对应一个函数对象，就是当前正在指向的函数对象

if语句（条件语句）

if() {执行语句
}

if() {执行语句1
}else{执行语句2
}

if(){执行语句1
}elae if(){执行语句2
}else{执行语句3
}

switch语句（条件分支语句）

实例1：

var num = 3;
switch(num){case 1:alert("壹");break;// 退出语句case 2:alert("贰");break;default:alert("这是默认");break;
}

实例2：

var score = 30;
switch(true){case score >= 60:alert("合格");break;// 退出语句default:alert("不合格");break;
}

for循环

for (初始化表达式; 条件表达式; 更新表达式)
{被执行的代码块
}

嵌套的for循环

while 循环

while

while (条件)
{需要执行的代码
}

do…while

do
{需要执行的代码
}
while (条件);

两者比较：

do while 保证循环体至少执行一次
while 不一定

事件机制和常见事件

单双击事件

onclick=""alert('单击')"
ondblclick=""alert('双击')"

鼠标事件

onmouseout="alert('移出')"onmouseover="alert('移入')"

键盘事件

onkeyup="alert('按下并弹起')"
onkeydown="alert('按下，系统接收到输入信息')"
onkeypress="alert('按下，系统还未接收到输入信息')"

页面时间

<!--onload = alert(页面加载完成) 加在body上-->

表单事件

onfocus="alert('我获取到了焦点')"
onblur="alert('丢失焦点')"
onchange="alert(' 被改变了')"

全局对象的属性和函数

全局对象的属性
-Infinity 正的无穷大的数值
-java java.*包层级的一个JavaPackage
-NaN 指示某个值不是数字值
-Packages 根JavaPackage 对象
-Undefined 指示未定义的值
全局对象的方法
// 编码
-decodeURI() 解码某个编码的URI；
-decodeURIComponent() 解码一个编码的URI组件；
-encodeURI() 把字符串编码为URI；
-encodeURICooomponent() 把字符串编码为URI组件；
-escape() 对字符串进行编码；
-unescape() 对由escape() 编码的字符串进行解码；
//
-eval() 计算JavaScript字符串，并把它作为脚本代码来执行；
// 判断
-isFinite() 检查某个值是否为有穷大的数；
-isNaN() 检查某个数是否是数字；

面向对象编程

原型继承

function animal(){this.color = "red";
}
Animal.prototype.run = function(){alert("gogogo...")
}function Dog(){this.name = "旺财"：
}
//通过prototype实现继承
Dog.prototype = new Animal();// 先继承父类，再添加自己的原型
Dog.prototype.hou = function() {alert("旺旺旺...")
}
function testExtend(){//创建DOG对象var d1 = new Dog();alert(d1.name +"--" + d1.color);d1.hou;d1.run;
}

JSON对象

    function testJson() {//数组var arr1 = new Array();var arr2 = [];//声明一个JSONvar obj1 = new Object();var obj2 = {};var obj3 = {"uname":"zhangsan","realname":"张三丰","age": 10,run:function () {alert("gogoggo...")}};obj3.run()}

操作JSON

    function operJson() {//高版本浏览器中操作JSONvar j01 = '{"uname":"zhangsan","realname":"张三"}';var j02 = {"uname":"zhangsan","realname":"张三"};//将字符串转成JSON对象// eval("var jj = " + j01);// alert(jj.uname);// var jj = JSON.parse(j01);// alert(jj.uname)//将JSON转成字符串alert(JSON.stringify(j02));}

数组

//数组的创建

    var a1 = new Array();var a2 = new Array(2);var a3 = new Array("张三","李四","王五");// alert(a1 + "|" + a2 + "|" + a3);

// 简介创建方式

var aa1 = [];
var aa2 = ["章子怡","刘诗诗","杨颖"];
// alert(aa1 + "|" + aa2);

// 数组的长度

var a = ["aa","bb","cc","dd","ee"];
// alert(a.length);
// 数组中元素的获取（索引从0开始）
// alert(a[1]);//取bb

//数组上下限是0和length-1
// 遍历元素

for (var i = 0; i < a.length; i++){// alert(a[i]);
}

// 数组的长度是可变的

a.length = 3;
a.length = 30;
alert(a);

数组的常见方法

var a = ["a","b","c","d","e","f","g","h"];

// 添加元素

a.unshift("http");
a.push("www");

// 移除元素

a.pop();
a.shift();

// 即可添加也可移除

a.splice(1,3);// 从1开始到三结束；
a.splice(3,0,"http"); //3后面添加http

// 更改指定索引对应的值

a[3] = 10;
a[3] = null;// 位置还保留

//其他方法

var aa = ["a","b","c","d","e","f","g","h"];

// 取出指定索引的子串[1,3),但不包括3

var bb = aa.slice(1,3);

// 拼接数组

var cc = aa.concat(["6","2","3","4"]);

// 反转数组

cc.reverse();

// 排序

cc.sort();

// 划分

cc.join("/");