javascript

浏览器内核
原理：浏览器运行的核心程序代码
内核的主要模块组成：
1、主线程
Js引擎模块：负责js程序的编译和运行
Css、html负责文档解析模块：页面文档的解析
Dom/css模块：负责dom和css在文档中的处理
布局和渲染模块：负责页面的布局和效果的绘制
2、·分线程
定时器模块：负责定时器管理
事件响应模块：负责事件管理
网络请求模块：负责ajax请求
Js编写的4中位置

标签属性
	
	超链接
1
2
3

Js标识符：
js标识符：1字母 2.下划线 3.美元符号

2.如果字符串中有非数字的内容，则转化为NaN
var a=“100JHJK”;
a =Number(a);//strng—>Number
console.log(a)//输出NaN
console.log(typeof a)//输出Number
3.如果字符串为一个空格或者全部为空格时，则转化为0
var a=“”;
a =Number(a);//strng—>Number
console.log(a)//输出0
console.log(typeof a)//输出Number

Boolean–Number：

var a=true;
a= Number(a);
console.log(a)//输出1
console.log(typeof a)//输出number

var a=false;
a= Number(a);
console.log(a)//输出0
console.log(typeof a)//输出number

null---- Number：
var a=null;
a= Number(a);
console.log(a)//输出0
console.log(typeof a)

undefined— Number

var a=undefined;
a= Number(a);
console.log(a)//输出NaN
console.log(typeof a)
第二种转换方式：
1.字符中包含数字和字符的装换为Number
2.parseInt(变量)函数----获取整数
专门对付字符串的装换
var a=‘123px’;
a=parseInt(a);
console.log(a);//输出123
console.log(typeof a)

parseInt()函数将字符串中的有效数字从左往右依次取出来，然后转化为Number,遇到违法字符直接终止
var a=‘123.4545px’;
a=parseInt(a);
console.log(a);//输出123
console.log(typeof a)

2：parseFloat(变量)----获取小数
var a=‘123.545px’;
a=parseFloat(a);//123.545
console.log(a)

总结：String Null undefined转化为Number使用Number()、parseInt（）、parseFloat()等函数进行装换。

二、其他数据类型装换为Boolean类型
Number— Boolean:
1.调用Boolean（）函数
当变量为0时进行装换返回false

var a=0;
a=Boolean(a);
console.log(a);// false
console.log(typeof a)

当变量为其他整数时进行转换返回true
var a=53465;
a=Boolean(a);
console.log(a);// true
console.log(typeof a)

备注：0 返回flaset，其他的整数返回true

String— Boolean
1.调用Boolean（）函数
当字符串为空值时转化为Boolean返回false：
var a=“”;
a=Boolean(a);
console.log(a)//输出fales
当字符串为其他字符时装换为Boolean时返回true
var a=“sdf”;
a=Boolean(a);
console.log(a)

Null----Boolean：返回false
undefined-Boolean:返回false

总结：javascript的基本数据类型包含String Number NaN Boolean undefine等数据之间可以通过调用相应的函数进行转化

运算符

加法：
1.对两个数值进行加法运算，并将结果返回。
2.如果两个字符串相加运算，则会做拼接操作会将两个字符串拼接成为一个新字符串返回。
3.任何的值和字符串做加法运算，都会先转化为字符串，然后再和字符串做拼接返回新的字符串。
减法:
减法（-）
1.对2个值进行减法运算返回结果
乘法（*）
2.1 对2个值进行乘法运算返回结果
除法（/）
3. 对2个值进行除法运算返回结果
取余（%）
4. 对2个值进行取余运算返回结果

一元运算符
正号（+）；
正号对任何数字不会产生影响
负号（-）；
负号可以对数字进行取反
2.对于非Number类型的值：先转化为number类型的、然后进行运算。
var a=9;
a=a+true;//1+9//将boolean类型转化为number然后进行运算
console.log(a);//输出10
document.write(a);
自增：后++（a++）和前++（++a）
相同点：2者都会使原变量自增1
不同点：++a和a++的值不同，a++等于原变量值，++a等于原变量的新值
赋值运算符
A=a+5等价于 a+=5;
A=a-5等价于a-=5;
A=a/5等价于a /=5;
A=a*5等价于a *=5;
A=a%5等价a%=5;

=和区别：
相同点：进行比较
不同点；
=：全等，两个不同类型的值进行比较直接返回false，不会进行数据类型的自动转化
：相等，两个不同类型的值进行比较时会进行自动转换再比较
！=和！
！=：不相等：
不相等会进行进行自动的类型转化，如果转换后相等返回false
！：不全等：
不全等不作类型的自动转换，如果类型不相同直接返回true。
三元运算符（三目表达式）：
语法：
判断条件？返回值1:返回值2（返回值直接时任何数据类型或者表达式）

var a=10;
var b=20;
a>b?alert(‘a大’):alert(‘b大’);
a a>b?console.log(‘a’):document.write(‘b’);
a>b?console.log(‘1’):console.log(‘2’);
if语句的写法

}else{//if嵌套if进行判断
if(a>30&&a<60){
alert(‘2’);

}else if(a>50&&a<99){
	
	alert('3');
}

alert('4');
1
2
3
4
5
6

}

While循环循环语句：

创建一个循环，往往需要三个步骤：
1.初始化一个变量
2.循环中设置一个条件表达式
3.定义一个更新表达式，每次更新初始化变量

var a=1;//1.定义初始化变量
//2.设置条件表达式
while(a<10){
//3.定义更新表达式，每次更新初始化变量
a++;
document.write(a++ +‘
’)
//alert(a);
}
说明；while（）｛｝特点，先判断后执行代码块

For

for (var i = 0; i <10;i++) {
console.log(i);
}

语法：
For(1初始化表达式；2条件表达式；4更新表达式){
3语句

}
执行顺序：
执行初始化表达式、初始化变量1
执行条件表达式、判断是否执行循环2。
如果为true、则执行循环3
如果为false、则终止循环
执行更新表达式、更新表达式4执行完毕后继续执行2
1—》2—》3—》4—》2 ：循环执行

练习：

			//1.获取1-100数字
			var sum=0;
			debugger;
			for(var i=1;i<=100;i++){
			
			//判断奇数
			if(i%2!=0){
				//console.log(i)
				
				sum=sum+i;		
				
			}	
			debugger;	
			}
			console.log(sum);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2、

Js对象基础篇
对象中有属性，有方法，属性有属性值，方法有方法体
对象：属于一种复合的数据类型，在对象中可以保存不同的数据属性（基本数据类型，方法、对象）
对象的分类：
1、内建对象：内置对象
2、宿主对象：有运行环境提供、目前浏览器提供的对象
3、自定义对象：开发人员自己创建

属性：对象中保存的值成为“属性值”。
Js创建对象的2种方式
一、Js中使用new关键字创建对象
1、向对象定义属性和添加属性值：（新增）
语法：对象.属性名=属性值；
案例：
//1、创建对象
var obj=new Object();
//3、对象添加属性值
obj.name=“曹操”;
2、读取对象中的属性值：（查询）
语法： 对象名.属性名
var obj=new Object();

	obj.name="曹操";
	console.log(obj.name);//读取属性值
1
2

3、修改对象的属性值（更新）
语法：
对象.属性名=新值；
案例：
var obj=new Object();

	obj.name="曹操";
	obj.name="hyh";//name属性直接赋予新值从而覆盖旧的属性值
	console.log(obj.name);//输出hyh
1
2
3

4、删除对象的属性（删除）
语法： 对象.属性名
案例
var obj=new Object();

	obj.name="曹操";

	delete obj.name;//删除对象属性
	console.log(obj.name);//控制台输出undefined
1
2
3
4

特殊的属性名【】中操作：

语法：对象名[“属性”]=属性值；
var obj=new Object(); //创建对象
obj[“name”]=“三国演义”;//对象中添加属性
obj[“age”]=1999; //对象中添加属性
console.log(obj[“name”]);//读取属性值
console.log(obj[“age”]);//读取属性值

属性值：js对象的属性值可以是任何数据类型
案例：
var obj=new Object();
obj[“name”]=“三国演义”;
obj[“age”]=1999;

     var obj1=new Object();
   obj1.name="猪八戒";//添加属性值
  obj.name=obj1;//将对象obj1对象的所有属性赋值于obj的name属性值
console.log(obj.name);
1
2
3
4

in运算符：
in运算符检查一个对象中是否含有属性，如果有则返回true、没有返回fales
语法： “属性名” in 对象
案例：

var obj1=new Object();
obj1.name=“猪八戒”;//添加属性值
console.log(“age” in obj1);//检查obj1对象中是否含有age属性—false
console.log(“name” in obj1);//输出true
js中变量都保存在栈内存中的
1、基本数据类型的值直接在栈内存中储存
2、值与值之间都独立存在，修改一个人变量不会影响其他的变量。
Js中的对象是保存在堆内存中的，每创建一个新的对象就会在堆内存中开辟出一个新的空间，而变量保存的是一个对象的内存地址（对象引用）、如果两个变量保存的是同一个对象引用、当一个变量修改属性时、另一个也会受到影响。
当比较两个基本数据类型的值时、就是比较值。（基本类型保存的是值）
当比较引用数据类型时，就是比较对象的内存地址。（引用类型保存的时地址）

二、使用对象字面量创建对象
语法：
var obje={
定义属性
name:”张三”；
age:55
sayName:function(){}//定义方法

};

Js函数基础篇
一、new关键字创建（构造）函数（不推荐使用—代码维护难）

函数创建语法
Var fun =new Function(“console.log(‘有参构造函数’);”);
函数调用：当调用函数时，函数中封装的代码会按照顺序依次执行。
语法：函数对象（）；
案例：
/ /1创建函数
var fun=new Function(“console.log(‘这是我的第一个函数’);”);
//2调用函数
fun();

二、使用函数声明创建函数（推荐使用—方便代码维护）
语法：
function 函数名（形参1，形参2….）｛
语句

｝
function 函数名1（形参1，形参2….）｛
语句
function 函数名2（形参1，形参2….）｛
语句

｝

｝

函数也可以进行嵌套使用
案例：

		function fun1(){
			
			console.log("声明式创建函数");
		}
		fun1();//调用函数
1
2
3
4
5

说明：形式参数可有可无

三、使用函数表达式创建函数（常用方式）----匿名函数
语法：
var 函数名=function（形参1、形参2……形参N）｛

    语句…..
1

｝
函数调用：
函数名（）；

解析：将匿名函数function(){
Console.log(“匿名函数”);

}；赋值于变量本质相当于给变量进行赋值

案例：

		var fun3=function(){
			
			
			console.log("我是匿名函数");
		}；
		fun3();	//函数调用
1
2
3
4
5
6

js函数的形式参数
形式参数：1、函数中可以指定一个或者对个形式参数。
3、形式参数相当于占用位置空间，可用也可不用。（形参名称和实参名称可以不同名/可以同名）
4、形式参数之间用“逗号”隔开。
5、声明形式参数相当于在函数内部声明了对应的变量、但是并没有赋值。
语法：

function fun(形参1，形参2……形参N){

};
案例1：
function fun4(a,b){

		console.log(a+b);// 输出NaN
		}
		fun4();
1
2
3

案例2：
function fun5(a,b){
// 声明形式参数相当于在函数内部声明了对应的变量、但是并没有赋值。
function fun5(a,b){
var a;
var b;

		console.log(a+b);//输出NaN
		}
		Fun5();
1
2
3

解析：fun4()和fun5()实质效果一样

Js函数的实参
实参：
1、调用函数时，传入实际参数，实参将会赋值于函数中对应的形参(实际参数和形参名称可以相同也可以不相同)
案例1：

function fun6(a,b){

			console.log(a+b);//输出300
			
		}
		fun6(100,200);
1
2
3
4

案例2：

function fun6(a,b){

			console.log(a+b);//输出300
			
		}
		fun6(x,y);
1
2
3
4

2、调用函数时解析器不会检查实参的类型。所以要检查非法的参数传入(实参类型可以人任意数据类型)
案例1；

		function fun7(a,b){
			
			console.log(a+b);//输出100hello
			
		}
		Fun7(100,"hello");
1
2
3
4
5
6

3、调用函数时，解析器不会检查实参的数量，多余的实参不会被赋值

案例：

		function  fun8(x,y){
			
			console.log(x+y);//调用函数输出579
			
		}
		fun8(123,456,null,"hello");
1
2
3
4
5
6

4、如果实参的数量小于形参的数量，则没有对应的实参的形参将是undefined
案例：
function fun9(a,b){

			console.log("a="+a);//456
			console.log("b="+b);// undefined
			console.log(a+b);//NaN
			
			
		}
		
		        fun9(456)//实参数量小于形参数量
1
2
3
4
5
6
7
8

6、实参可以是任何数据类型（基本数据类型和对象）。
7、实参可以是一个对象（参数过多时可以将对象封装到对象中然后通过对象传递）
案例：

//定义一个函数
function fun1(o){//函数的形参

 console.log("我是"+o.name+"现在"+o.age+"是一个"+o.sex+"人");
			
		}	
			
		//字面量创建一个对象
		
		var obj={

			age:50,
			name:"张三",
		
			sex:"男"
			
		};
		
fun1(obj);//调用函数将对象作为实参传给函数（实参可以是任何数据类型）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

8、实参可以是一个函数
案例：
//定义函数fun
function fun1(o){//函数的形参

			console.log("我是"+o.name+"现在"+o.age+"是一个"+o.sex+"人");
			
		}
1
2
3

//定义函数fun2

function fun2(a){

				console.log(a);
				
			}
			fun2(fun1);//将fun1函数作为fun2的实参传入
1
2
3
4

9、匿名函数作为实参：
案例：
function fun2(a){
//形参=实参
//a=function (){alert(“匿名函数”)}

				console.log(a);
				
			}
		//将匿名函数作为函数的实参进行传入
			fun2(function (){
				
				alert("匿名函数");
			})
1
2
3
4
5
6
7
8

Js函数返回值
Js函数函数返回值：return关键字
语法：
return 返回值；
1、return后的值将作为函数执行结果返回，可以定义一个变量来接受
2、调用函数时变量result的值就是函数执行的结果
3、函数返回什么result值就是什么
案例：
function fun1(a,b,c){
var d=a+b+c;

			return d;//返回函数执行结果
			
			
		}
		
		
		var result=fun1(10,20,30);//返回函数执行结果进行接收
		console.log(result);
1
2
3
4
5
6
7
8

4、result后面的代码将不会被执行：
function fun1(a,b,c){
var d=a+b+c;

			return d;//将函数执行结果返回后，后面的代码将不会被执行。
			
			alert('123');
		}
		
		
		var result=fun1(10,20,30);//返回函数执行结果进行接收
		console.log(result);
1
2
3
4
5
6
7
8

4.return后不写返回任何值相当于返回一个undefined

		function fun2(a,b){
			var x=a+b;
			return ;
			
			
			
		}
		var result=fun2(1,5);
		console.log(result);// undefined
1
2
3
4
5
6
7
8
9

5.函数中不写return也会返回undefined

		function fun3(a,b){
			var x=a+b;
							
			
			
		}
		var result=fun3(1,5);
		console.log(result);// undefined
1
2
3
4
5
6
7
8

6.return可以返回任何数据类型（基本数据类型、对象、函数）
7.return返回值是一个对象：
案例1：
//return返回值可以是任何数据类型
function fu(){

			//字面量创建对象
			var obj={
				
			name:"hyh",
			age:18
				
				
			};
			return obj;//返回类型为对象
		}
		
		var s=fu();
		document.write(s.age,s.name);//输出 hyh 18
1
2
3
4
5
6
7
8
9
10
11
12
13

案例2：
function fu(){

//字面量创建对象

			return {name:"张三",age:18};//返回类型为对象
			document.write("return后所有的代码停止运行了");
		}
		
		var s=fu();
		document.write(s.age,s.name);
1
2
3
4
5
6

8、返回值可以是函数
案例：
function fun(){
//console.log(“我是外部函数-------”);
function fun1(){
console.log(“我是内部函数------”);

			}
			
			return fun1;
				
		}
		var a=fun();
		console.log(a);
1
2
3
4
5
6
7

返回 fun和fun()的区别：
1.返回fun是返回整个函数
function fun(){
//console.log(“我是外部函数-------”);
function fun1(){
console.log(“我是内部函数------”);

			}
			
			return fun1;
				
		}
		var a=fun();
		console.log(a);
1
2
3
4
5
6
7

2.返回fun（）：返回函数的返回结果
案例：

function fu(a,b){

			return a+b;
		}
		
		function fu1(x){
			
			return x*2;
			
		}
		
		var a=fu1(fu(4,5));//调用的函数返回结果值
		console.log(a);
1
2
3
4
5
6
7
8
9
10
11

立即执行函数：
语法：
（
function fun(形参){
语句
}
）（）；

案例：

//立即执行函数
(
function fun(a,b){
console.log(“a=”+a);
console.log(“b=”+b);

		}	
		)(1,6);//直接调用函数并且传入参数
1
2

Js方法
Js方法：函数也可以是对象的属性、当函数作为对象的属性值保存的时候，这个函数被称为方法，调用函数就是调用对象的方法就是名称上的区别，没有其他区别。
1、方法的2种写法：

第一种：
//关键字new创建对象
var obj=new Object();
obj.name=“张三”,
obj.age=4444,
obj.sex=function(){//定义方法

		console.log(obj.name);
		console.log("第一种写法");
		
	}
		
		console.log(obj.sex);//调用函数返回结果
		console.log(obj.sex());//调用方法
1
2
3
4
5
6
7

第二种：
//字面量创建对象
var obj2={

			name:"李四",
			age:5555,
			sex:function(){//定义方法
			
				console.log("第二种写法");
				
				
			}				
			
			
			
		};
		console.log(obj2.sex());//调用方法
1
2
3
4
5
6
7
8
9
10
11
12
13

js中的作用域

1、全局作用域：

		 1、全局作用域在页面打开时创建、页面关闭时销毁。
		 2、全局作用域中有一个window对象可以直接使用。
		 全局作用域中，
		 1、创建的变量都会作为window对象的属性进行保存。
		 2、创建的函数将作为window对象的方法保存
		 3、全局作用域中的变量为全局变量
1
2
3
4
5
6

2、 函数作用域（局部作用域）；

		 1、调用函数时创建函数作用域，函数执行完毕后函数作用域销毁
		 2、每调一次函数就会创建一个函数作用域，他们之间都是相互独立的互不影响。
  3、函数作用域（局部作用域）中可以访问到全局作用域中变量
1
2
3

案例：

	var a=10;//全局作用域表量
	
	
	function  fun1(){
		//函数作用域中访问全局变量
		console.log("a="+a);//输出10
		
	}
	
	
	fun1();//调用函数
1
2
3
4
5
6
7
8
9
10
11

5、全局作用域中不能访问函数作用域中的变量
案例：
function fun1(){

		var b=20;//定义函数变量
		
	}
	
	
	fun1();
	console.log(b);//全局作用域中调用函数作用域中变量
1
2
3
4
5
6
7

Uncaught ReferenceError: b is not defined
6、全局变量和局部变量同时定义的情况下，遵守就近原则然后由内往外依次访问调用，如果局部和全局都未定义变量则为 undefined
案例1：
var a=10;//全局作用域表量

	function  fun1(){
		
		
		var a=20;//定义局部变量
		console.log(a);//输出局部变量20
		
	}
	
	
	fun1();
1
2
3
4
5
6
7
8
9
10

案例2：当函数局部变量未定义时，遵守由内往外的原则可以进行访问调用
var a=10;//全局作用域表量

	function  fun1(){
		
		
		var a=20;//定义局部变量
		console.log(a);
		var b=30;
		
		function fun2(){
			
			console.log(b);//输出30
			
			
		}
		fun2();//调用函数
		
	}
	
	
	fun1();//调用函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

7、全局变量和局部变量同时存在的情况下调用全局变量利用window对象调用
案例：
var d=1000;

	function fu(){
		
		var c=100;
		console.log(window.d);//调用全局变量-----1000
		
		
		
	}
	fu();
1
2
3
4
5
6
7
8
9

8、函数作用域中也有声明提前的特性，使用var关键字声明变量，会在函数执行前被声明，
案例：
function f(){

		console.log(x);// undefined
		
		
		var x=100;//先声明后赋值
		
	}
	f();
1
2
3
4
5
6
7

9、函数作用域中变量如果不用var声明，则会被当做全局变量被调用
案例：
var x=999;
function f(){

		x=99;//局部变量未被声明，则会当做全局变量赋值
		
	}
	debugger;
	f(); 
	console.log(x);//99
1
2
3
4
5
6

10、形参相当于在函数作用域中声明了变量
案例1：
var a=10;
function f(a){
//相当于var a=100；

   alert(a);//100
1

}
f(100);
案例2：
var a=10;
function f(a){
//相当于var a= undefined；
alert(a);// undefined

}
f();

使用工厂方法创建对象：通过此方法可以大批量生产对象
案例：

//使用工厂方法创建对象
function createPon(name,age){
//1、创建对象
var obj=new Object();
//2、对象添加属性
obj.name = name;
obj.age = age;
obj.sayName=function(){

						alert(this);
						
					};
					
			return obj;//对象返回函数
			
		}
		debugger;
                          //向函数中传入形参
		var obj2=createPon("s孙悟空",18);
		var obj3=createPon("猪八戒",18);
		var obj4=createPon("汤神",18);
		//console.log(typeof obj2);
		console.log(obj2);
		console.log(obj3);
		console.log(obj4);	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

解析：工厂模式创建的对象都是object这个类型，导致无法无法区分多种不同类型的对象

Js构造函数

1、构造函数就是一个普通的函数、创建方式和普通函数没有区别
2、构造函数首字母大写，普通函数首字母小写
//构造函数创建
function Add(){

		}
		//普通函数创建
		function add(){
			
			
		}
1
2
3
4
5
6

2、普通函数和构造函数的区别就是调用方式不同：
1、普通函数直接进行调用
语法：函数名（）
add()
2、构造函数使用关键字new进行调用
语法：New 函数名（）
New Add()
3、构造函数执行的流程：
1.立刻创建一个新的对象
2.将新的对象设置为函数的this
3.逐行执行函数中的代码
4.将新建的对象作为返回值返回
案例：

		function Fun(){	
		}
		
		var f=new Fun();
1
2
3
4

解析：new Fun()—使用关键字调用构造函数，并且立刻创建一个新对象
var f=new Fun();–将新建的对象作为返回值返回由变量f接受
有参构造：
function f(形参1,形参2……形参N){}
var z=new f(实参1,实参2……实参N);
案例：

		function Fun(name,age){
			
			this.name=name,
			this.age=age
			
		}
		
		var f=new Fun("孙悟空",15);
		
		console.log(f);
1
2
3
4
5
6
7
8
9
10

无参构造：
案例：

		function Fun(){
			
			
			
		}
		
		var f=new Fun();
		
		console.log(f);
1
2
3
4
5
6
7
8
9

this:
1、已函数调用的情况下，this就是window
2、以方法形式调用时、谁调用方法谁就是this
3、以构造函数的形式时，this就是新创建的对象。

Js数组基础篇

索引：从0开始的整数
1构造函数创建数组

Var arr=new Array()//构造函数创建数组

2数组添加值
语法：数组[索引]=数值
3读取数组值
语法：数组【索引】
如果读取索引不存在的情况下不会报错而是返回undefined
案例：//创建数组
var arr=new Array();
debugger;
//数组添加属性值
//索引是从整数0开始的 数组[索引]=数值 数组【索引】
arr[0]=10;
arr[1]=20;
arr[2]=30;
arr[3]=40;
console.log(arr[2]);//30
console.log(arr[3]);//40
4获取数组的长度：
语法：数组.length
Arr.length
4.1对于连续的数组使用length可以获取数组的长度（元素个数）
案例：
var arr=new Array();

		arr[0]=10;
		arr[1]=20;
		arr[2]=30;
		arr[3]=40;

	
		console.log(arr.length);//获取长度等于4
1
2
3
4
5
6
7

4.2对于不连续的数组使用length可以获取数组最大索引+1
案例：
//创建数组
var arr=new Array();

		arr[0]=10;
		arr[1]=20;
		arr[2]=30;
		arr[3]=40;
		
		arr[8]=80;

	
		console.log(arr.length);//获取长度等于9
1
2
3
4
5
6
7
8
9

5修改length
5.1当length修改后的长度大于原有长度时部分会空出来

案例：
var arr=new Array();

	    arr[0]=10;
		arr[1]=20;
		arr[2]=30;
		arr[3]=40;
		
		console.log(arr);

	
		console.log(arr.length);//原有长度等4
		arr.length=10;//修改后的长度为10
		
		console.log(arr);
			
				
		console.log(arr.length);//输出时会多出6个空间
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5.2修改后的长度小于原有长度时，多出的索引会被删除
var arr=new Array();

	    arr[0]=10;
		arr[1]=20;
		arr[2]=30;
		arr[3]=40;
		
		console.log(arr);

	
		console.log(arr.length);//原有长度等4
		arr.length=2;//修改后的长度为2
		
		console.log(arr);
			
				
		console.log(arr.length);//10，20其他索引会被删除
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5．3数组的最后位置添加元素
语法：
数组[数组.length]=值
案例：
var arr=new Array();

	     arr[0]=10;
		arr[1]=20;
		arr[2]=30;
		arr[3]=40;
		arr[arr.length]=50;//数组最后位置添加元素（值）
1
2
3
4
5

1数组中的元素是任意数据类型
案例：
var arr=[1,2,3,null,true,undefined];
console.log(arr);// [1, 2, 3, null, true, undefined, undefined]
2数组中的元素可以是对象
案例：

		var  arr=["hello",1,null,true];
			
		 //数组元素可以是对象
				  
		 var obj={name:"孙悟空"};//字面量创建对象
		 arr[arr.length]=obj;//数组中最后位置添加元素为对象
		  console.log(arr);//  ["hello", 1, null, true, {…}]
                             console.log(arr[4].name);// 输出对象的具体属性孙悟空
                              console.log(arr[4]);   //输出对象 {name: "孙悟空"}
1
2
3
4
5
6
7
8
9

3数组中元素可以是函数；

案例：

Var arr= [function(){console.log(“函数1”)},function(){console.log(“函数2”)}];
console.log(arr);// [ƒ, ƒ]
js中数组常用的的4种方法

push（）
1.改方法可以向数组末尾添加一个或者多个元素并且返回新的长度
2.将添加的元素作为方法的参数进行传递，这些元素会自动添加到数组的末尾
3.改方法将数组新的长度作为返回值返回
案例：
var arr=[1,2,3,4,5];
var result=arr.push(7,8,9,10);//返回数组新的长度
console.log(arr);
console.log(“新的长度”+result);

pop()
1.改方法可以删除数组末尾的一个或者多个元素，依次进行删除
案例：
var arr = [1, 2, 3, 4, 5];
var result1=arr.pop();//删除数组倒数第二个
var result2=arr.pop()//删除数组最后一个元素
unshift（）
1.改方法向数组开头添加一个或者多个多个元素，并且返回新数组的长度
2.将添加的元素作为方法的参数进行传递，这些元素会自动添加到数组的开头
3.向前边插入元素后，其他的元素索引会依次调整
案例
var arr = [1, 2, 3, 4, 5];
var result3 = arr.unshift(6, 7, null, true, undefined);//数组开头添加多个元素
console.log(arr);//新数组输出结果：6, 7, null, true, undefined, 1, 2, 3, 4, 5
console.log(result3);//新数组的长度：10

shift()
1.此方法删除数组开头元素，并且返回新数组的长度
案例：
var arr = [1, 2, 3, 4, 5];
arr.shift();//删除第一个元素
console.log(arr); //2345
console.log(arr.length)//新数组长度4

concat（）
1.该方法向数组中添加一个或者多个数组，返回结果值，不会影响原数组
案例：
var arr = [1, 2, 3];
var arr1 = [4, 5, 6];
var arr2 = [7, 8, 9];
var x=arr.concat(arr1,“属性值”,null,100);//可以添加任何属性类型
var y=arr.concat(arr2);
console.log(x);
console.log(y);

正则表达式

1.语法：
构造函数创建正则（使用灵活）
var 变量=new RegExp(“正则表达式”,“匹配模式”)
案例：
var reg=new RegExp(“a”);//创建正则对象

	  var str="a";
               //test()方法验证是否符合正则要求
	  console.log(reg.test(str));//利用test（）验证正则要求是否符合规则
1
2
3

2.字面量创建正则表达式(创建简单)
语法： var 变量=/正则表达式/匹配模式
案例： var reg=/a/b;

JSDOM
DOM=文档对象模型
一、节点：Node
1、文档节点
整个html
2、元素节点（标签）
Html中所有标签
3、属性节点
标签属性
4、文档节点
标签中的文本
一、Dom的属性：
1、all获取页面所有标签
var a=document.all;
2、获取head标签
var body=document.head;
3、getElement获取所有html标签
var html=document.getElement;
二、dom操作元素对象（新增）
父节点元素下新增子节点元素
语法：父节点. appendChild（）
1、createElement（”li”）创建新的节点对象----节点为参数
2、createTextNode(“新疆”)—创建新的文本节点对象—字符串为参数
3、appendChild（）—添加对象----对象作为参数
案例：

• 1