1.JS内容
包括： ECMAScript（国际标准）
DOM（JavaScript操作网页上的元素的API）
BOM（JavaScript操作浏览器的部分功能的API）
2.JS声明格式：
有三种：行内式 Fine
页内式:在head标签中使用script标签进行js代码声明
网页是从上至下加载，而js代码通常是给标签添加交互（操作元素），所以需要先加载HTML,否则如果执行js代码时HTML还未被加载，那么js代码将无法添加交互（操作元素）；
HTML页面中出script标签后，就会让页面暂停等待脚本的解析和执行，无论当前脚本是内嵌式还是外链式，页面的下载和渲染都必须停下来等待脚本执行完成才能继续，所以如果把js代码写在head中，那么js代码执行完毕之前后续网页无法被加载；
外链式：在head标签中使用script标签引入外部声明好的js文件
特点：实现JS代码的重复使用，比吗代码冗余；
3.js语法；
3.1 输出方式;在script中type=“text/html”表示不输出该脚本中的信息
1.在网页中弹出显示框，显示信息；
2.在控制台输出消息，一般用于调试程序；
3.在网页中弹出输入框，一般用于接收用户输入的信息；
4.在网页中弹出提示框，显示信息，该方法一般和if判断句结合使用；
注意：
1.编写js注意语法规则，一行代码结束后必须在代码最后加分号“；”；如果不加，浏览器会自动在该行代码最后自动添加，但会消耗一些系统资源；此外，不加也容易造成浏览器错加分号；
2.JS区分大小写；
3.JS中会自动忽略多个空格和换行
如console.log
( “Hello js” );//等于console.log(“Hello js”);
4.JS注释语法分单行注释（快捷键ctrl+/）和多行注释；
多行注释可以嵌套单行注释或多行注释；
//北京//北平
//北/平/
多行注释可以嵌套单行注释，但不能嵌套多行注释；
/*
//北平
*/
3.2 常量，变量，关键字，标识符：
1.常量：
数值常量；如console.log(3+3);
字符串常量(使用‘’或“”包含);
如console.log(‘A’);
console.log(“Hello中国”);
布尔常量(使用true和false表示)；
如console.log(1);//表示true,真
console.log(false);//表示假
特殊字符；
如console.log(‘\n’);//换行符
console.log(‘\t’);//制表符
2.变量：
js中所有变量声明只有var关键字；
使用关键字var定义变量;如var name;
=左右两边各加一个空格；
注意：js中赋值左侧必须是变量（“same”=name是错误写法）；js的变量名严格区分大小写，字符串可以使用双引号，也可以使用单引号；js中可以声明同名变量，后面声明的一个会覆盖前面声明的；
var a=123;//Number类型
var a=false;//覆盖前面的a
var a1=”js”;//string类型
var a2=true;//boolean类型
var a5=null;//空对象赋值，主要是和undefined进行区分,object类型；
var a3;//undefind类型，变量声明不赋值的情况下，默认值是undefined。
a4=123;//声明时没写var的都是成员变量，即使该声明在函数内部也是成员变量；
js变量特点：
A.变量声明只有var关键字，声明的变量可以存储任意类型的数据；
B.js中的代码可以不使用分号结尾，但是为了提升代码的阅读性，建议使用分号；
C.js中的变量允许出现同名变量，但后面会覆盖前面的变量；
D.声明不赋值，默认值为undefined,赋值为null,则为空对象；
3.关键字；
4.保留字；
5.标识符；
4.js数据类型：
4.1数据类型分类
简单数据类型：Number（数字类型）、String（字符串类型）、Boolean(布尔类型)、undefined（变量未初始化）、null（空类型）；
复杂数据类型：Array（数组类型）、Object(对象类型)；
数据类型判断关键字：typeof
注意：简单数据类型，放入栈里面；复杂数据类型放入堆里面；创建对象是在堆地址中分配内存空间给对象；
使用typeof操作符：将检查的结果字符串的形式返回给我们，但并不改变变量的类型；
如：console.log(typeof 100);//number类型
var name=”s”;
console.log(typeof name);//string类型
var b=new Date();
alert(typeof b);//object类型
4.1.1 Number类型：
±infinity表示无穷大和无穷小；
NaN非法数字（Not A Number）：
js中当对数值进行计算时没有结果返回，则返回NaN;
如var str=“中国”-10;//NaN
console.log(typeof str);//number
4.1.2 String类型：由单引号或双引号括起；
相同引号不能嵌套，不同引号可以嵌套；
如var s1 = ”hello “js””;//错误
var s2 = “hello ‘js’”;//正确
4.1.3 Boolean类型：逻辑值类型或真假值类型；
只能取true和false;
虽然其字面值只有两个，但ECMAScript中所有类型的值都有与这两个值等价的值；
1.任何非零数值都是true,包括正负无穷大，只有0和NaN是false;
2.任何非空字符串都是true,只有空字符串是false;
3.任何对象都是true,只有null和undefined是false;
4.1.4 Undefined类型：
如console.log(num);//undefined，num没有声明，没有初始化；
4.1.5 Null类型：是第二个只有一个值的型，值为null;
null表示的是一个空的对象，所以使用typeof检查null会返回一个Object；如var t=null;console.log(typeof t);
undeifined值实际上是由null值衍生出来的，所以如果比较两个的值会返回true;如果比较两个的类型会返回false,类型不同；
如var t1 = undefined;
var t2=null;
Console.log(t1 == t2);//true,==是值比较
Console.log(t1 === t2);//false ===是值和类型都要比较
4,2 数据类型转换；
4.2.1.toString：将其他类型的数据转换为字符串类型,null和undefined没有toString方法，强转会报错；toString不会影响到原变量，它只会将转回结果返回；
var num2，num = 123;
var str = num.toString();
console.log(str);//字符串123
console.log(num);//数值123
console.log(typeof str);//string
Console.log(typeof num);//number
console.log(num2.toString());//报错
4.2.2.String()函数：针对某些并没有toString()方法的值，可以使用String()将其返回结果转换为字符串类型；
对Number和Boolean的数据就是调用toString方法；
对null和undefined就是调用String方法；
var num;
console.log(String(num));//字符串undefined
4.2.3.+：任何数据和字符串相加到一起都会转换为字符串；而且是强转；
var num = true;
var r = num + “”;
console.log®;//字符串true
console.log(typeof r);//string
var num1 = undefined;
var num2 = num1 +“”；
console.Log(typeof num2);//string
4.2.4.Number()函数，Boolean()函数,Eval()函数：
Number()
如果是纯数字的字符串，则直接将其转换为数字；
var str = “666”;
var num = Number(str);
console.log(num);//数值666
console.log(typeof num);//number
如果是字符串中有非数字的内容，则转换为NaN；
var str = “123ss”;
var num1 = Number(str);
console.log(num1);//NaN
如果字符串为空串或者全是空格的字符串，则转换为0；
undefined转数字为NaN；null转数字为0；
布尔转数字true为1，false为0；
Boolean():
1.任何非零数值都是true,包括正负无穷大，只有0和NaN是false;
2.任何非空字符串都是true,只有空字符串是false;
3.任何对象都是true,只有null和undefined是false;
Eval函数():
将string类型的字符串转换为运算式；
如eval(string);//string是必需的。要计算的字符串，其中含有要计算的 JavaScript 表达式或要执行的语句。
4.2.5.parseInt和parseFloat函数：由于Number函数无法提取混合字符串中的有效数字，故利用这两个函数提取字符串中的有效数字；
前者只能提取整数值，后者可以提取小数值；
parseInt提取整数：
从第一位有效数字开始，直到遇到无效数字；
如第一位不是有效数字，什么都提取不到，会返回NaN；
第一个参数是要转换字符串，第二个参数是要转换的进制；
如var str = “123.12xu”;
console.log(parseInt(str));//123,第二个参数可以选择不写；
parseFloat提取字符串中数值（可以提取小数）；
会解析第一个”.”遇到第二个“.”或非数字结束；
如果第一位不是有效数字，什么都提取不到；
不支持第二个参数，且只能解析10进制数；
如果解析的内容只有整数，解析成整数；
如var str = “123.12xu”;
console.log(parseFloat(str));//123.12
` 对于非String的数据，使用parseInt和parseFloat会自动线将其转换为String类型然后再操作；
如var str = true;
console.log(parseInt(str));//NaN,相当于parseInt(“true”);
4.3 运算符;
JS运算符优先级从上到下是从高到低：
4.3.1.算术运算符；
1.加法：
1.非Number类型的值进行运算时会将这些值自动转换为Number类型然后再运算；如var num = true + 100;//true转换为1；num为101；
2.任何值和NaN运算结果都是NaN；
3.任何的值和字符串做加法运算，都会先转换为字符串，然后再和字符串做拼串的操作；
2.减法：
1.非Number类型的值进行运算时会将这些值自动转换为Number类型然后再运算；如var num = 100 - true;//true转换为1；num为99；
2.任何值和NaN运算结果都是NaN；
3.字符串做减法也会转换为Number类型；
如var num = 100 -“33”；//结果为67；
var num2 = 100 - “sda”;//结果为NaN；
3.乘法、除法：规律和减法相同；分母为0结果为infinity;
4.取余：m%n；n等于0则返回NaN；m等于0则返回0；其他规则和减法相同；
4.3.2.正负运算符；
+号不会对数字产生影响，对非Number的值，会先将其转换为Number再运算；-号可以对数字进行取反；
4.3.3.赋值运算符：
=：将右边的数据赋值个左边的变量；
+=，-+，=，/=,%=:如a+=1(a=a+1),a=10+1(a=a*11)；
4.3.4.自增自减运算符：无论如何都会改变变量的值；
后缀x++：表示先用x作为当前值，最后再进行自增运算；
前缀++x:表示先变后用；
4.3.5.关系运算符：左结合，返回值是boolean类型；
、<、>=、<=；
（值是否相等）、！=（值是否不等）；
=（值和类型是否相等）、！（值和类型是否不等）；
等值运算符:
先判断类型，类型一致则直接比较。
类型不一致，则先使用Number()进行强转后再进行比较。
等同运算符:===
先判断类型，类型一致则再比较内容，内容一致则返回true，内容不一致则返回false。
类型不一致则直接false
注意：null和undefined在做==判断时候返回true
如123 === “123”；//false
123 == “123”;//true
1.对于非数值进行比较，会先将其转换为数字然后进行比较；
2.如果符合两侧都是字符串时，不会将其转换为数字进行比较，而是直接比较两字符串的Unicode编码；
3.null、undefined、NaN比较；
1.NaN进行任何比较都是false;console.log(NaNNaN);//false
2.null就是null，不等于0；console.log(null0);//false
3.undefined也不等于0；console.log(undefined==0);//false
注意：可以使用isNaN函数判断是否为NaN；
如console.log(isNaN(3));//false
4.3.6.逻辑运算符；&&与、||或、！非
对于布尔类型数值，逻辑运算和java相同；
对于非布尔类型数值：
1.A&&B：对于非布尔类型的数值，逻辑与会自动转换为布尔类型进行判断，如果A不成立，则返回条件A数值本身；如果A成立，则不管B成不成立都返回B数值本身；
2.A||B:对于非布尔类型的数值，逻辑与会自动转换为布尔类型进行判断，如果A成立，则返回条件A数值本身；如果A不成立，则不管B成不成立都返回B数值本身；
3.！A：对非布尔值则会将其转换为布尔值再取反；
4.3.7.逗号运算符；左结合，整个逗号表达式的值是最后一个表达式的值；
如b=(a+=1,b=3*2,c=3/2);//逗号表达式的值就是c=3/2的值；
4.3.8.三目运算符；
A？B：C：A为true,则执行B，并返回结果；否则执行C，也返回结果；
本节注意：
num1 = Number(prompt(“请输入第一个数：”))；
num2 = +(prompt(“请输入第二个数：”))；
num3 = Number(window.prompt(“请输入第三个数：”))；
以上三句话，Number和+的作用一样，都是转换为数值类型；
window.prompt可包含两个参数，第一个是必须的为提示信息，第二个参数作为显示的默认答案，可修改；
如window.prompt(“请输入性别：”，”男”)；
4.4流程控制：顺序、选择、循环；
4.4.1.if；
但凡遇到比较一个变量等于或不等于常量时，把常量写在前面；
如3==c; “as”==bin;
Computer = Math.floor(Math.random()*3);//
//Math.random()方法返回大于等于0且小于1的随机数；乘以3表示0-3之间的随机数；
//Math.floor方法返回小于或等于给定数字的最大整数；
4.4.2.switch；
case判断是否相等是全等于(===)值和类型都相同，case后可以是常量也可以是变量；判断时会先计算表达式的值再判断结果；
如switch(22){
case 20+2:console.log（“相等”）；break;
//先计算20+2，再与其结果进行判断；
default:console.log（“相等”）；break;
//default可以放在任意位置
}
注意：判断的变量可以是number类型也可以是string类型，但是不要混用。
4.4.3.循环；
1.break:跳出循环语句；它只能用于循环语句或switch语句，放于其他地方浏览器会报错；多层循环中一个break只能向外跳出一层；
循环内break后的语句在执行break后不会执行；
var num = 0;
while(1){
if(5==num)break;
num++;
}
2.continue:跳过当前循环体中剩下的语句而继续下一轮循环判断；只能用于循环结构；
3.while,先判断，再执行；
4.do while,先执行，再判断；
5.for;
注意：window.document.write(“*”);//在文件流中写入该字符串；如果文件流关闭，那么他会自动调用document.open打开新的文件流，显示的则是新的文件流的数据，原文件流数据不显示；
5.数组和函数；
5.1.数组
5.1.1 数组构造，声明方式：
1js数组声明：
var arr =new Array();//声明一个空数组
var arr =new Array(length);//声明一个指定长度的数组
var arr = [元素]；声明数组(最常用);
注意：js中的数组声明不用指定长度，js的数组长度是不固定的，会随着元素的数量改变而改变。
2.js数组的赋值和取值
数组可以存储任意类型的数据
数组名[角标]=值;//角标可以是任意的正整数或者是0
数组的取出：
数组名[角标]//返回当前角标对应存储的值
如果角标不存在，返回undefined;
如：var arr=[];
arr[0]=2;
arr[1]=“abc”;
arr[2]=true;
arr[3]=new Date();
arr[10]=“哈哈”;//任意角标都可以存储数据；
3.
1.使用Array构造数组；
如var arr = new Array();//创建新的数组
console.log(arr)；//显示Array(0),length为0,表示创建了一个空的数组；
var arr1 = new Array(20);//创建一个长度为20的数组；
var arr2 = new Array(“20”,”3”,”2”);//创建一个长度为3数据分别为20，3,2的数组；
2.使用数组字面量创建数组；
如var arr3 = [],arr4 = [30];创建一个空的数组和长度为30的数组；
var arr5 = [20,3,2];//创建长度为3数据为20，3,2的数组；
栈是先进后出，队列先进先出；
数组属于栈存储；
5.1.2 数组使用方法；
1.定义数组长度length:
作用1：数组名.length//返回当前数组的长度。
作用于2：数组名.length=新的值//动态的改变数组的长度
注意：length>原有长度，则使用空进行填充。length<原有长度，则从后面进行截取，最后的数据会被删除。
如：var arr = [];arr.length = 100;//将数组arr长度定义为100；
2.输出数组信息var per = [“33”,”32”]console.log(per);//输出per内所有的信息；
遍历数组：var arr =[1,”32”,true,null]
for(var i=0;j<arr.length;i++){alert(arr[i]😉}//遍历一
for(var i in arr){alert(i);}//遍历二
3.数组常用方法；
1.join(separator)；将数组的所有元素放入一个字符串，以separator为分隔符，省略则默认用逗号为分隔符；返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入 separator 字符串而生成的；
如var arr=[“33”,”11”];
console.log(arr.join());//输入为33,11
2.push()和pop()；
push方法接收任意数量的参数，并把它们逐个添加到数组的末尾，并返回修改后数组的长度；
pop方法是删除数组的最后一个元素，并把数组长度-1,然后返回它被删元素的值，如果数组为空，则该方法不改变数组，则返回undefined；
如var arr = [“张三”]；
var num = arr.push(“赵四”，“王五”);//num为3；
console.log(arr.pop());//移除arr最后一个元素，并输出被删元素王五；
3.shift()和unshift();
unshift方法是向数组的开头添加一个或者多个元素，并返回修改后数组新的长度;
shift方法用于删除数组的第一个元素，并把数组长度-1，然后返回被删除元素的值；如果数组为空，则不进行任何操作，则返回undefined；
如var arr=[“王五”]；
var num = arr.unshift(“张三”，“李四”)；//num为3
var str = arr.shift();//str为张三
4.sort();
5.reverse();反转数组内元素的顺序；将正序变为反序；
var arr = [“张三”，“王五”]；
arr.reverse();//arr顺序变为王五，张三；
6.concat(参数);返回一个新的数组，该数组是通过将所有参数添加到指定的arrayObjeat中生成的，而原有数组的值不会被改变；如果要进行concat操作的参数是数组，那么添加的是数组中的元素，而不是数组；参数可以是具体值或者数组对象；该方法常用于连接两个或多个数组；
如var a = [1,2];
console.log(a.concat(3,4));//输出1,2,3,4
console.log(a);//输出1,2,原数组未被改变
var a1 = [3],a2 = [4];
console.log(a.concat(a1,a2))//输出1,2,3,4
//进行concat操作的参数是数组，添加则是该数组中的元素
concat和push的区别：
push修改的是原数组，concat不修改原数组，是将所有元素添加到新创建的数组里；push是直接把作为参数的数组中的所有元素放入原数组，而concat会先将该数组拆解，然后一个一个元素的放入新数组中；
7.slice();
8.splice();
9.indexOf()和lastIndexOf();
indexOf接收两个参数：要查找的项和要开始查找的位置的索引,如果不写查找的位置则默认从头(0)向后开始查找；（从前往后差）
lastIndexOf()接收两个参数:要查找的项和要开始查找的位置的索引，如不写查找位置则默认从尾部向前查找；（从后往前查）
两个方法返回的都是要查找项在数组中所在的位置，如果没找到则返回-1，如果找到后就停止查找，返回结果；查找项和数组每一项比较都使用的是全等符（===）；
10.forEach();
11.map();
12.filter();
13.every();
14.some();
15.reduce()和reduceRight();
5.2 函数；
函数是完成特定功能的一段代码，是可重复执行的代码块；
JS中会把当前作用域中的直接声明的函数自动提到作用域最前面；即无论该函数声明写在其作用域任何位置，都会被最先声明；而其他两种函数声明方式不会被提到作用域最前面；
5.2.1 函数的定义
1.函数直接声明方式；function 函数名(参数1,参数2。。。){函数体}
如
2.函数表达式声明方式；
var add = function(){console.log(1+3);}
add();
3.使用Function构造函数；
注意：此声明表明在js中函数是作为对象存在的；
var add2 = new Function(‘console.log(1+3);’);
add2();
5.2.2 函数的参数和属性
注意：js的代码声明区域和执行区域是一起的，都是在js代码的代码域中。
1.形参站位，实参为具体值；JS中实参和形参个数可以不等；
js中的函数在调用时，形参可以不赋值，不会报错
js中的函数在调用时，形参赋值可以不全部赋值，不会报错，但是实参会依次进行赋值。
如function sun(n1,n2)n1+n2;
sun(100,200);//结果为300（100+200）
sun(100)；结果为NaN(100+undefined)
sun(100,200,400,500);//结果为300（100+200）,多余的实参不计算
2.arguments对象，任何函数默认拥有一个实参arguments对象，它包含传入函数的所有实际参数，它不是一个数组，却类似于数组，除拥有length属性外，不具备有数组的属性和方法；此外，它还有一个callee属性的指针，指向拥有这个arguments对象的函数；
如function sun(){
var value = 0;
for(var i=0;i<arguments.length;i++){
value += arguments[i];
}
console.log(value);
}
sun(10,20,30);//结果为60；
3.函数中length包含两个，实参的arguments.length;形参sun.length;
如function sun(n1,n2){
var value = 0;
for(var i=0;i<arguments.length;i++)
value += arguments[i];
console.log(value);
Console.log(argunment.length);
Console.log(sun.length);
}
sun(2,3,4);//输出9（2+3+4），3（argunment.length），2（sun.length）
4.函数返回值return；return语句后面的所有语句将不被执行；
在js中如果函数有返回值则直接返回，没有返回值默认返回undefined;
如 function sun(){}//返回undefined;
function sun(){return ；}返回undefined;
5.函数的执行符；
在js中函数的执行符值()：
没有小括号则函数名其实就是一个变量；
加上小括号则会函数会被执行。
如：var test1=function(){}
alert(test1);//输出变量test1
alert(test1());//输出test1的执行结果
6.函数作为实参传递
在js中函数是可以作为实参进行传递的。
如：function testobj(a){
alert(a());//a()为执行实参函数
}
var testParam=function(){
alert(“我是函数参数”);
}
testobj(testParam); //传递函数实参
5.2.3匿名函数
没有命名的函数，
作用：1.用于绑定事件时；
document.οnclick=function(){alert(1);}//点击一次调用函数
2.定时器；
setInterval(function(){console.log(444);},1000);
//每隔1000ms调用一次function函数；
3.自调用函数；
(function(){alert(1);})();//闭包里放入匿名函数
5.2.4 回调函数
如果把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其指向的函数时，我们就说拥有这个指针的函数是回调函数；
如求斐波纳契数列：112358。。。
function f1(n){
if(n=1||n=2)return 1;
return f1(n-1)+f1(n-2);
}
5.3变量的作用域；
1.JS中函数外部的都是全局变量（包括只带花括号的语句块）,随处都可调用；函数内部的是局部变量，在该函数外部不可调用；
如if(3){var nim;}//nim是全局变量,判断不属于函数
function(){var n;}//n是局部变量
2.全局变量：定义在script中不属于某个函数的变量；
3.局部变量：定义在函数内部的变量属于局部变量，在外部是不可见的；
注意：不使用var声明的变量是全局变量(不管在函数内还是函数外)，不推荐；
如 n = “ss；或者function s(){n= “ss;}//两个n都是全局变量
function s(){var a=b=c;}//a是局部变量，b和c是全局变量；
变量退出作用域后会销毁，全局变量关闭网页或浏览器后会销毁；
查找变量时先在函数内部的作用域找该变量，找到则使用，找不到则去父级作用域找该变量；
注意：局部变量声明会提到该作用最前面，但赋值位置不变；
如var n=10;function s(){console.log(n);var n =20;}
等同于var n=10;function s(){var n;console.log(n); n=20;
//结果输入undefined;因为查找n先从内部找，在内部找到后则使用内部的值，此时内部n的值为undefined；
6.对象和面向对象；
面向对象：可以创建自定义类型，很好的支持继承、多态；面向对象的语言C++/java/C#；
基于对象：无法创建自定义类型，不能很好的支持继承、多态；语言如JS；
6.1JS中常见的对象
6.1.1.无序属性的集合：属性包含基本值，对象，函数；对象就是一组无序的值；
JS中的对象可想象成键值对，值可以是数据或函数；
6.1.2.对象的行为和特征：特征是属性，行为是方法；
6.1.3.字面量对象
如var p{ name:”xz”，age：28， friend：[“ch”,“jh”],
sayHi:function(){console.log(“xx”)}
}；//p.sayHi()b表示对象p调用sayHi()方法；
6.2.JSON是存储和交换文本的语法：灵活简单体积小，效率高，易解析；它是轻量级的文件数据交互格式；
JSON格式如下：
{
“name”：“旺财”，
“age”：10，
“friends”:[”阿黄”，”阿花”]
}
Xml数据交互格式传输不方便体积大，但内容清晰；
xml格式如下：
旺财
10
JSON(JavaScript Object Notation,JS对象表示形式)，用于数据传递；是JS的子集；
JSON的属性必须用双引号引起来，对象字面量可省略；
JSOn有两种结构：对象和数组，两种结构互相组合成各种复杂的数据结构；
6.3.遍历对象内容(使用for( …in)方法)
如var obj={}
for(var i=0;i<5;i++ )obj[i]=2*i;//为键值对赋值
for( var key in obj){
console.log(key);//遍历输出对象obj的键
console.log(obj[key]);遍历输出对象obj的值
}
或如上for(var key in p){
console.log(key);//遍历输出对象p的键
console.log(p[key]);遍历输出对象p的值
}
6.4创建自定义对象，类的声明和使用;
注意：js中类的内容只是对象的公共部分，每个对象还可以自定义的进行扩充；
6.4.1.通过构造函数new Object()来创建自定义对象，
对象的作用：用来存储整体数据。
原因：很多时候我们没有办法预先知道一个对象应该有哪些属性，所以只能临时的创建一个对象来自定义属性存储数据。来保证数据的完成性
应用：Ajax中会使用。
使用：
1、创建自定义对象
var 对象名=new Object();
对象名.属性名1=属性值1;
对象名.属性名2=属性值2;
对象名.属性名3=属性值3;
2.一般用来存储数据，不会再自定义对象中存储函数对象。
3、js中的对象属性和内容是可以自定义的扩充的，不是依赖于类的声明的，类只是对象公共部分的一种；
如function Persion(){
var obj=new Object();
//属性
obj.name=null;
obj.age=null;
//方法
obj.study=function(){
Console.log(this.name+”在学习”)；
}；
return obj；
}//构造函数
var p = Person();var p1=Person();//创建两个不同的对象并使用
p.name=”张三”；p.age=18;
6.4.2.直接构造函数function Dog(){}
如下function Dog(name,age,friends){
//属性
this.name=name;
this,age=age;
this.friends=friends;
//方法
this.eat=function(some){
console.log(this.name+”在吃”+some)
};
}
var sDog=new Dog(“阿黄”，1)；
6.4.3.封装对称构造函数function Dog(option){}
如下function Dog(option){
//属性
this.name=option.name;
this,age=option.age;
this.friends=option.friends;
//方法
this.eat=function(some){
console.log(this.name+”在吃”+some);
};
}
var ssDog=new Dog({name:“阿花”，age:1,})；
var sDog=new Dog({name:“阿黄”，age:1,friends:[“阿花”，”大白”]})；
6.5.this;this所在函数在哪个对象中，this就代表这个对象；而谁调用this则this就是表示谁；构造函数中的this始终是new的当前对象；
6.6数组对象
6.6.1.prototype为任何Array创建的数组增加方法或属性；通常用来存储共享的属性和方法；
类的"继承"：prototype关键字
通过prototype关键字实现了不同对象之间的数据共享。
作用1:实现某个类的所有子对象的方法区对象的共享，节省内存
如Array.prototype.eat= function(){alert(“eat”);};
Array.prototype.test=”测试”；
//任何Array创建的数组对象都会拥有该方法和属性
var arr = new Array();arr.eat();
var arr1 = new Array();arr1.eat();
如Dog.prototype.eat=function(some){
console.log(this.name+”在吃”+some);
};//所有Dog共享该方法空间，不用每次创建Dog对象时都开辟空间创建eat方法；
或
Dog.prototype={
eat：function(some){
console.log(this.name+”在吃”+some);
},
run：function (somew){}
}
6.6.2.constructor;
如console.log(arr.constructor)；//返回Array
console.log(arr1.constructor)；
console.log(Array.constructor)；//返回function，所有函数的父类
6.7数据类型和内存分析；
堆区(heap)和栈区（stack）：栈区由编译器自动分配释放，存放函数的参数值，局部变量的值等；堆区由程序员分配释放，若开发者不释放，程序结束后由OS回收；
栈区运行效率高于堆区，栈区和堆区类似于内存和硬盘的关系（栈区小，读取方便，堆区大，读取慢）；简单数据类型存储在栈区，复杂数据类型存储在堆区；
JS数据类型：简单数据类型(Number、String、Boolean、Null.Undefined)直接存储值；复杂数据类型(Object、Array、Date)存储引用；
6.8JS内置对象
Js本身已写好的对象；创建后直接就可以使用无需定义的对象；
常见的内置对象有Date,Array,Math,RegExp,Error,String;
以及Array高级API：
6.8.1 sort();按元素值的大小顺序（默认升序）排列数组项；
如var arr = [10,3,6];
console.log(arr.sort());//[3,6,10]
console.log(arr.sort(function(a,b){return a-b;}));//[3,6,10]
//通过回调函数进行规制设置， a-b升序，b-a降序，内部运用冒泡规制；
console.log(arr.sort(function(a,b){return b-a;}));//[10,6,3]
6.8.2 slice();返回从原数组指定开始下标到指定结束下标间的项组成的新数组；它可以接受一个或两个参数；一个参数时，slice()方法返回从该参数指定位置开始到当前数组末尾的所有项；二个参数时，则返回指定位置开始到结束位置之间但不包含结束位置的项；原始数组不变；
如var arr = [10,3,6,4,7];
var arr1= arr.slice(2);//arr1为[6,4,7]
var arr2=arr.slice(2,3)//arr2为[6,4]
var arr2=arr.slice(-3,-2)//arr2为[6,4]，如果参数为负数，则该参数长度为原数组长度加上该负数，即第一项为5+（-3），第二项为5+（-2）；
6.8.3 splice(a,b，c1，cn)；用于实现删除，插入和替换数组中的元素；或用于清空数组；返回被删除的元素。
1.删除：可以删除任意数量的项，这需指定2个参数：要删除的起始位置a和要删除的项数b；返回值为被删除的项目的新数组（如果有被删除项）；
如var arr = [10,3,6,4,7];
var arr2=arr.splice(0,2);//arr2为[10,3,6],arr为[4,7]
2.插入（替换）：可以向指定下标先删除指定的项数再插入任指定数量的元素，只需提供3种参数：起始位置a,要删除的项b，要插入的所有元素c1到cn；
如var arr = [10,3,6,7];
arr.splice(2,0,11,12);//arr为[10,3,6,11,12,7]，只插入不替换
arr.splice(2,3,4);
//arr为[10,3,4,7],删除从下标2开始的3个项并添加4；
arr.splice(2,1,5),将下标2的值替换为5；
3.清空数组；
arr.splice(0);//清空数组中所有元素；
6.8.4 forEach()；用于调用数组的每个元素，并将元素传递给回调函数；
如果是空数组则不执行回调函数；
格式如下：forEach(function(value,index,arr),thisValue)
value:必须，当前元素
index：可选，当前元素的下标（索引值）
arr;可选；当前元素所属的数组对象；
thisValue:可选；传递给函数的值一般用“this”值；如这个参数为空，则undefined会传递给“this”值；
返回值为undefined;
如var arr = [6,4,7];
arr.forEach(function（value,index）{
console.log(index+”:”+value;);
});遍历数组
6.8.5 map()；通过指定函数处理数组的每个元素，并返回处理后的数组；
格式如下：array.map（function(value,index,arr),thisValue）;
value:必须，当前元素
index：可选，当前元素的下标（索引值）
arr;可选；当前元素所属的数组对象；
thisValue:可选；对象作为该执行回调时使用，传递给函数，用作“this”值；如这个参数为空，则undefined会传递给“this”值；
返回一个新数组，数组中元素为原始数组调用函数处理后的值；
如var arr = [3,4,2];
var arr1=arr.map(function（value,index）{
return value*2;
});//arr1为[6,8,4]
6.8.6. filter();检查数组元素，并返回包含符合条件的所有元素的新数组；
格式:array.filter（function(value,index,arr),thisValue）
value:必须，当前元素
index：可选，当前元素的下标（索引值）
arr;可选；当前元素所属的数组对象；
thisValue:可选；对象作为该执行回调时使用，传递给函数，用作“this”值；如这个参数为空，则undefined会传递给“this”值；
返回一个新数组，包含符合条件的所有元素；都不符合则返回空数组；
如var arr = [1,3,4,2,5,7,9];
var arr2=arr.filter(function（value,index）{
return index%2===0||value>=4;
});//arr2为[4,5,9];
6.8.7 every();检查数组元素的每个元素是否都符合条件；都符合返回true，否则返回false;
格式:array.every（function(value,index,arr),thisValue）;
value:必须，当前元素
index：可选，当前元素的下标（索引值）
arr;可选；当前元素所属的数组对象；
thisValue:可选；对象作为该执行回调时使用，传递给函数，用作“this”值；如这个参数为空，则undefined会传递给“this”值；
返回值：都通过返回true,否则false（布尔值）;
如var arr = [1,3,4,2,5];
arr.every(function（value,index）{
return value<10;
});//结果为true，所有元素都满足;
6.8.8 some()；检查数组元素中是否有元素符合指定条件；如果都不满足返回false;否则返回true；
格式:array.some（function(value,index,arr),thisValue）;
value:必须，当前元素
index：可选，当前元素的下标（索引值）
arr;可选；当前元素所属的数组对象；
thisValue:可选；对象作为该执行回调时使用，传递给函数，用作“this”值；如这个参数为空，则undefined会传递给“this”值；
返回值：都没通过返回false,否则true（布尔值）;
如var arr = [1,3,4,2,5];
arr.some(function（value,index）{
return value>10;
});//结果为false，所有元素都不满足；
6.9 js常用方法和对象
String对象：操作字符串；
使用：字符串.函数名即可；
function testString(){
var str=”abcdefg”;
…//具体操作；
}
<input type=”button”id=””value=”测试String” οnclick=”
testString()”/>
//字符串大小写的转换
//alert(str.toUpperCase());//将字符串转换为大写
//alert(str.toLowerCase());//将字符串转换为小写
//字符串的切割
//var s=“哈哈,嘿嘿,呵呵”;
//var s1=s.split(",");//按照指定的字符切割字符串，返回数组。
//alert(s1.length);
//字符串的截取
//var s=“abcdef”;
//alert(s.substr(1,3));//从指定的开始位置截取指定长度的子字符串
//alert(s.substring(1,3));//从指定的开始位置和指定的结束位置截取子字符串，含头不含尾。
Date对象：
使用：var 变量名=new Date();
注意：获取的是客户端的时间，不能作为系统功能校验的时间；
//1、创建Date对象
function testDate(){
var d=new Date();
…//具体操作
}
<input type=”button”id=””value=”测试Date” οnclick=”
testDate()”/>
//获取当前年份
//alert(d.getYear());//返回的是1900年开始距今的年份数
//alert(d.getFullYear());//返回的是当前的年份
//alert(d.getMonth()+1);//返回的当前月份的角标值，需要+1
//alert(d.getDate());//返回的是当前的日期数
//alert(d.getDay());//返回的是当前的星期数，但是周天会返回值为0;
//alert(d.getHours());//返回当前时间的小时数
//alert(d.getMinutes());//返回当前时间的分钟数
//alert(d.getSeconds());//返回当前时间的秒数
Math对象；
使用：Math.函数名；
function testMath(){
…//具体操作
}
<input type=”button”id=””value=”测试Math” οnclick=”
testMath()”/>
//1、Math在使用的时候不能new，使用Math.方法名调用即可。
//创建随机数字
//alert(“Math.random():”+Math.random());//返回0-1间的随机数，含0不含1。
//alert(1000+Math.random()*9000);
//向下取整
//alert(Math.floor(1000+Math.random()*9000));
//向上取整
//alert(Math.ceil(“12.34”));
//四舍五入
//alert(Math.round(12.12));
//alert(Math.round(12.65));
//数值比较:求取最小值，求取最大值
//alert(Math.min(12,13,5,78));//获取最小值
//alert(Math.max(12,3,4,56));//获取最大值
Global对象；
function testGlobal(){
…//具体操作
}
<input type=”button”id=””value=”测试Global” οnclick=”
testGlobal()”/>
//1、该对象从不直接使用并且不能new，也是就直接写方法名调用即可。
//使用eval将字符串转换为可执行的js代码
var str=“var a=123”;
eval(str);
alert(a);
//使用isNaN判断是否值为NaN
alert(isNaN(“123”));
//获取字符中的浮点数
alert(parseFloat(“12.34a34a”));
6.10 JS的事件机制
js的事件机制：
解释：当我们的行为动作满足了一定的条件后，会触发某类事务的执行。
作用：主要是结合js的函数来使用。
内容:
1、单双击事件
单击：onclick 当鼠标单击的时候会触发
双击：ondblclick 当鼠标双击的时候会被触发
2、鼠标事件
onmouseover 当鼠标悬停在某个HTML元素上的时候触发
onmousemove 当鼠标在某个HTML元素上移动的时候触发
onmouseout 当鼠标在某个HTML元素上移出的时候触发
3、键盘事件
onkeyup 当键盘在某个HTML元素上弹起的时候触发
onkeydown 当键盘在某个HTML元素上下压的时候触发
4、焦点事件
onfocus 当某个HTML元素获取焦点的时候触发
onblur 当某个HTML元素失去焦点的时候触发
5、页面加载事件
onload 当页面加载成功后触发。
注意:
js中添加事件的第一种方式：
在HTML上直接使用事件属性进行添加，属性值为所监听执行的函数。
js中的事件只有在当前HTML元素上有效。
一个HTML元素可以添加多个不同的事件。
一个事件可以监听触发多个函数的执行,但是不同的函数要使用分号间隔
如：//单击事件
function testOnclick(){alert(“我是单击”);}
//测试双击
function testOndblclick(){alert(“我是双击”);}
//鼠标事件
function testOnmouseover(){alert(“我是鼠标悬停事件”);}
function testOnmousemove(){alert(“我被移动了”);}
function testOnmouseout(){alert(“我被移出了”);}
//键盘事件
function testOnkeyup(){alert(“我是键盘弹起事件”);}
function testOnkeydown(){alert(“我是键盘按下事件”);}
//焦点事件
function testOnfocus(){
document.getElementById(“showdiv”).innerHTML=“哈哈”;
alert(“我是获取焦点事件”);
}
function testOnblur(){alert(“我是失去焦点事件”);}
//页面加载
function testOnload(){alert(“我是页面加载事件”);}
//测试
function test(){alert(“测试一个事件的多个函数执行”);}
键盘下压事件：
获取焦点：
失去焦点：
1.给合适的HTML标签添加合适的事件；
onchange----select下拉框
onload------body标签
单双击-------用户会进行点击动作的HTML元素
鼠标事件------用户会进行鼠标移动操作的。
键盘事件------用户会进行键盘操作的HTML元素。
2.给HTML元素添加多个事件时，注意事件之间的冲突
举个栗子：单击和双击
当事件的触发条件包含相同部分的时候，会产生事件之间的冲突。
3、事件的阻断
当事件所监听的函数的将返回值返回给事件时：
值为false：则会阻断当前事件所在的HTML标签的功能
值为true:则继续执行当前事件所在的HTML标签的功能
4、超链接调用js函数
调用js函数
如：
//值改变事件
function testOnchange(){alert(“我被改变了”);}
//单击事件
function testOnclick(){alert(“今天天气真好，不冷不热，贼适合学习”);}
//双击事件
function testOndblclick(){alert(“老师说的对”);}
//事件的阻断
function testA(){alert(“事件的阻断”);return true;}
//超链接调用js函数
function testHref(){alert(“我是超链接调用”);}
值改变事件:
北京
上海
广州
事件的冲突：
事件的阻断：
百度一下
超链接调用js函数: 调用js函数
扫一扫
2972
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
