浏览器内核
原理：浏览器运行的核心程序代码
内核的主要模块组成：
1、主线程
Js引擎模块：负责js程序的编译和运行
Css、html负责文档解析模块：页面文档的解析
Dom/css模块：负责dom和css在文档中的处理
布局和渲染模块：负责页面的布局和效果的绘制
2、·分线程
定时器模块：负责定时器管理
事件响应模块：负责事件管理
网络请求模块：负责ajax请求
Js编写的4中位置
<button onclick="alert('标签属性位置');">标签属性</button>
<!-- //2、超链接中 -->
<a href="javascript: alert('超链接位置');">超链接</a>
<!—3、javascript模块中内部写 -->
<!—4、外部写js，进行位置的引入 src引入js–>
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<b?document.write(‘a大’):document.write(‘B大’);
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');
}
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);
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);//读取属性值
3、修改对象的属性值（更新）
语法：
对象.属性名=新值；
案例：
var obj=new Object();
obj.name="曹操";
obj.name="hyh";//name属性直接赋予新值从而覆盖旧的属性值
console.log(obj.name);//输出hyh
4、删除对象的属性（删除）
语法： 对象.属性名
案例
var obj=new Object();
obj.name="曹操";
delete obj.name;//删除对象属性
console.log(obj.name);//控制台输出undefined
特殊的属性名【】中操作：
语法：对象名[“属性”]=属性值；
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);
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();//调用函数
说明：形式参数可有可无
三、使用函数表达式创建函数（常用方式）----匿名函数
语法：
var 函数名=function（形参1、形参2……形参N）｛
语句…..
｝
函数调用：
函数名（）；
解析：将匿名函数function(){
Console.log(“匿名函数”);
}；赋值于变量本质相当于给变量进行赋值
案例：
var fun3=function(){
console.log("我是匿名函数");
}；
fun3(); //函数调用
js函数的形式参数
形式参数：1、函数中可以指定一个或者对个形式参数。
3、形式参数相当于占用位置空间，可用也可不用。（形参名称和实参名称可以不同名/可以同名）
4、形式参数之间用“逗号”隔开。
5、声明形式参数相当于在函数内部声明了对应的变量、但是并没有赋值。
语法：
function fun(形参1，形参2……形参N){
};
案例1：
function fun4(a,b){
console.log(a+b);// 输出NaN
}
fun4();
案例2：
function fun5(a,b){
// 声明形式参数相当于在函数内部声明了对应的变量、但是并没有赋值。
function fun5(a,b){
var a;
var b;
console.log(a+b);//输出NaN
}
Fun5();
解析：fun4()和fun5()实质效果一样
Js函数的实参
实参：
1、调用函数时，传入实际参数，实参将会赋值于函数中对应的形参(实际参数和形参名称可以相同也可以不相同)
案例1：
function fun6(a,b){
console.log(a+b);//输出300
}
fun6(100,200);
案例2：
function fun6(a,b){
console.log(a+b);//输出300
}
fun6(x,y);
2、调用函数时解析器不会检查实参的类型。所以要检查非法的参数传入(实参类型可以人任意数据类型)
案例1；
function fun7(a,b){
console.log(a+b);//输出100hello
}
Fun7(100,"hello");
3、调用函数时，解析器不会检查实参的数量，多余的实参不会被赋值
案例：
function fun8(x,y){
console.log(x+y);//调用函数输出579
}
fun8(123,456,null,"hello");
4、如果实参的数量小于形参的数量，则没有对应的实参的形参将是undefined
案例：
function fun9(a,b){
console.log("a="+a);//456
console.log("b="+b);// undefined
console.log(a+b);//NaN
}
fun9(456)//实参数量小于形参数量
6、实参可以是任何数据类型（基本数据类型和对象）。
7、实参可以是一个对象（参数过多时可以将对象封装到对象中然后通过对象传递）
案例：
//定义一个函数
function fun1(o){//函数的形参
console.log("我是"+o.name+"现在"+o.age+"是一个"+o.sex+"人");
}
//字面量创建一个对象
var obj={
age:50,
name:"张三",
sex:"男"
};
fun1(obj);//调用函数将对象作为实参传给函数（实参可以是任何数据类型）
8、实参可以是一个函数
案例：
//定义函数fun
function fun1(o){//函数的形参
console.log("我是"+o.name+"现在"+o.age+"是一个"+o.sex+"人");
}
//定义函数fun2
function fun2(a){
console.log(a);
}
fun2(fun1);//将fun1函数作为fun2的实参传入
9、匿名函数作为实参：
案例：
function fun2(a){
//形参=实参
//a=function (){alert(“匿名函数”)}
console.log(a);
}
//将匿名函数作为函数的实参进行传入
fun2(function (){
alert("匿名函数");
})
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);
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);
4.return后不写返回任何值相当于返回一个undefined
function fun2(a,b){
var x=a+b;
return ;
}
var result=fun2(1,5);
console.log(result);// undefined
5.函数中不写return也会返回undefined
function fun3(a,b){
var x=a+b;
}
var result=fun3(1,5);
console.log(result);// undefined
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
案例2：
function fu(){
//字面量创建对象
return {name:"张三",age:18};//返回类型为对象
document.write("return后所有的代码停止运行了");
}
var s=fu();
document.write(s.age,s.name);
8、返回值可以是函数
案例：
function fun(){
//console.log(“我是外部函数-------”);
function fun1(){
console.log(“我是内部函数------”);
}
return fun1;
}
var a=fun();
console.log(a);
返回 fun和fun()的区别：
1.返回fun是返回整个函数
function fun(){
//console.log(“我是外部函数-------”);
function fun1(){
console.log(“我是内部函数------”);
}
return fun1;
}
var a=fun();
console.log(a);
2.返回fun（）：返回函数的返回结果
案例：
function fu(a,b){
return a+b;
}
function fu1(x){
return x*2;
}
var a=fu1(fu(4,5));//调用的函数返回结果值
console.log(a);
立即执行函数：
语法：
（
function fun(形参){
语句
}
）（）；
案例：
//立即执行函数
(
function fun(a,b){
console.log(“a=”+a);
console.log(“b=”+b);
}
)(1,6);//直接调用函数并且传入参数
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());//调用方法
第二种：
//字面量创建对象
var obj2={
name:"李四",
age:5555,
sex:function(){//定义方法
console.log("第二种写法");
}
};
console.log(obj2.sex());//调用方法
js中的作用域
1、全局作用域：
1、全局作用域在页面打开时创建、页面关闭时销毁。
2、全局作用域中有一个window对象可以直接使用。
全局作用域中，
1、创建的变量都会作为window对象的属性进行保存。
2、创建的函数将作为window对象的方法保存
3、全局作用域中的变量为全局变量
2、 函数作用域（局部作用域）；
1、调用函数时创建函数作用域，函数执行完毕后函数作用域销毁
2、每调一次函数就会创建一个函数作用域，他们之间都是相互独立的互不影响。
3、函数作用域（局部作用域）中可以访问到全局作用域中变量
案例：
var a=10;//全局作用域表量
function fun1(){
//函数作用域中访问全局变量
console.log("a="+a);//输出10
}
fun1();//调用函数
5、全局作用域中不能访问函数作用域中的变量
案例：
function fun1(){
var b=20;//定义函数变量
}
fun1();
console.log(b);//全局作用域中调用函数作用域中变量
Uncaught ReferenceError: b is not defined
6、全局变量和局部变量同时定义的情况下，遵守就近原则然后由内往外依次访问调用，如果局部和全局都未定义变量则为 undefined
案例1：
var a=10;//全局作用域表量
function fun1(){
var a=20;//定义局部变量
console.log(a);//输出局部变量20
}
fun1();
案例2：当函数局部变量未定义时，遵守由内往外的原则可以进行访问调用
var a=10;//全局作用域表量
function fun1(){
var a=20;//定义局部变量
console.log(a);
var b=30;
function fun2(){
console.log(b);//输出30
}
fun2();//调用函数
}
fun1();//调用函数
7、全局变量和局部变量同时存在的情况下调用全局变量利用window对象调用
案例：
var d=1000;
function fu(){
var c=100;
console.log(window.d);//调用全局变量-----1000
}
fu();
8、函数作用域中也有声明提前的特性，使用var关键字声明变量，会在函数执行前被声明，
案例：
function f(){
console.log(x);// undefined
var x=100;//先声明后赋值
}
f();
9、函数作用域中变量如果不用var声明，则会被当做全局变量被调用
案例：
var x=999;
function f(){
x=99;//局部变量未被声明，则会当做全局变量赋值
}
debugger;
f();
console.log(x);//99
10、形参相当于在函数作用域中声明了变量
案例1：
var a=10;
function f(a){
//相当于var a=100；
alert(a);//100
}
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);
解析：工厂模式创建的对象都是object这个类型，导致无法无法区分多种不同类型的对象
Js构造函数
1、构造函数就是一个普通的函数、创建方式和普通函数没有区别
2、构造函数首字母大写，普通函数首字母小写
//构造函数创建
function Add(){
}
//普通函数创建
function add(){
}
2、普通函数和构造函数的区别就是调用方式不同：
1、普通函数直接进行调用
语法：函数名（）
add()
2、构造函数使用关键字new进行调用
语法：New 函数名（）
New Add()
3、构造函数执行的流程：
1.立刻创建一个新的对象
2.将新的对象设置为函数的this
3.逐行执行函数中的代码
4.将新建的对象作为返回值返回
案例：
function Fun(){
}
var f=new Fun();
解析：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);
无参构造：
案例：
function Fun(){
}
var f=new Fun();
console.log(f);
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
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
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个空间
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其他索引会被删除
5．3数组的最后位置添加元素
语法：
数组[数组.length]=值
案例：
var arr=new Array();
arr[0]=10;
arr[1]=20;
arr[2]=30;
arr[3]=40;
arr[arr.length]=50;//数组最后位置添加元素（值）
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: "孙悟空"}
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（）验证正则要求是否符合规则
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（）—添加对象----对象作为参数
案例：
喜欢的城市
- 上海
- 北京
- 天津
- 新疆
</div>
</head>
<body>
</body>
总结：2者的效果一样，前者是创建后添加到父节点元素中，后者是先获取父节点后创建再添加。
父节点元素下指定位置新增子节点元素
语法：父节点. insertBefore（）；
insertBefore(li,bj)------参数为新节点和旧节点
案例：
喜欢的城市
- 上海
- 北京
- 天津
- 新疆
</div>
<script>
function myName(bt,fun){
var bt= document.getElementById(bt);
bt.onclick=fun;
}
myName("b",function(){
//父节点元素中指定的位置新增子元素节点
//获取父节点元素
var b=document.getElementById("b");
var li=document.createElement("li");
var gs=document.createTextNode("甘肃");
li.appendChild(gs);
b.insertBefore(li,bj);//参数为新节点和旧节点
})
替换指定位置的元素节点
b.replaceChild(p,bj)：
语法：父节点. replaceChild（）
案例：
myName(“b”,function(){
var p=document.createElement("p");
var city=document.createTextNode("城市");
p.appendChild(city);
var b=document.getElementById("b");
b.replaceChild(p,bj);//新的节点，旧节点
})
删除父节点中的子节点：
语法：父节点. removeChild()—参数为删除子节点对象
案例： var b=document.getElementById(“b”);
b.removeChild(bj);
innerText、innerHTML读取元素节点的内容
语法：
元素节点.innerTEXT/innerHTML
innerText、innerHTMl修改元素节点的文本元素内容
语法：
元素节点.innerTEXT=“内容”;
元素节点.innerHTML=“内容”;
案例：
var bj=document.getElementById(“bj”);
bj.innerText=“西安”;
二、dom元素操作css样式
1、
2、/* 当前样式 */
#div {
height: 100px;
width: 100px;
background-color: #FF0000;
}
/* 当前样式 */
1、设置样式：语法：对象.style.样式名=数值;
2、读取样式属性：语法：对象.style.样式名
案例“
<body>
<button id="#btn1">提交</button>
</body>
1、onclick（）绑定单击事件
案例：
var btn1 = document.getElementById(“#btn1”);
btn1.onclick = function() {
//alert(1);
}
2、addEventListener（）绑定多个响应事件
案例：
//addEventListener可以绑定多个响应函数事件、
//参数：click字符串和回调函数，布尔类型false
btn1.addEventListener(“click”,function(){
alert(3);
},false)
btn1.addEventListener("click",function(){
alert(4);
},false)
3、attachEvent()可以绑定多个响应函数事件
案例：
//attachEvent()可以绑定多个响应函数
//参数：onclick字符串和回调函数
btn1.attachEvent(“onclick”,function(){
alert(5);
});
btn1.attachEvent("onclick",function(){
alert(6);
});
总结：浏览器兼容性不同所使用的绑定事件函数响应结果不一样。
BOM浏览器对象模型
浏览器对象模型 (BOM) 使 JavaScript 有能力与浏览器"对话"。
一、Navigator对象
代表当前浏览器的消息，通过该对象可以识别不同的浏览器。
2906
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
