js笔记

第一章1,什么叫程序：程序就是计算机按照人类完成事物的步骤和逻辑，通过计算机命令来逐步执行最终实现目标的一种机器语言。程序语言最大的特点：1，输入数据，2，处理数据，3，输出数据。javascript简介：1，概述：javascript简称js，这是一种典型的基于浏览器运营环境进行运行的一种程序脚本语言。什么叫基于浏览器运营环境：这种语言可以直接被浏览器解释执行出来。脚本：程序一经写定，一旦调用就直接执行。js能做什么？1，用户交互。什么叫用户交互：用户输入数据，计算机处理并反馈结果。2，页面端的验证处理页面端验证：就是在页面上能够看到信息输入的规则，并且直接能看到验证后的处理结果。3，页面端运算处理在页面能看到参与运算的数据，并且能直接得到运算后的结果。前端的运算和验证处理，能够最大程度的减轻服务器压力。同时提高了处理的速度，提升了用户的体验。4，制作特效。用替代Flash实现页面特效。5，用户实现前后台数据传递。js的基本组成部分：1，基本核心语法：ECMAscript 我们现在学习的时5.0版本的。es5;es6就是ECMAscript的6.0版本；2，利用js操作HTML 的DOM方法。//DOM对象3，操作浏览器插件的BOM方法。//BOM 对象js的运行环境：一，在HTML页面内运行1， 输入js语言

2，在HTML标签内直接输入：3,直接建立js文件，在里面写js语法。通过直接加以引用。二，就是在浏览器的运行环境内直接运行。就时浏览器的控制台内。js的数据输出方法：1，在页面上写出：document.write("");document//指的就是我们的文档页面即html--->document是所有在浏览器内显示的文档统称，HTML仅仅是其中的一种。2,在浏览器内弹出信息：window.alert("");window//浏览器，document是属于window的一部分。alert是弹出的意思。3,在控制台直接打印输出：console.log("");console//浏览器运行环境的控制台。log打印输出的意思。上述语法中的“.”是指什么什么的 什么什么的在同一个页面上window.alert()比document.write()优先执行，并且阻断程序的继续执行。------重点记忆js的特点：1，js语言可以使用任何的页面编辑器进行编写2，js语言不需要安装运行环境，既可以通过浏览器自带的js解释器直接执行3，js是一种弱类型语言。4，js是一种基于对象的前端程序语言。（暂时这么写。）js基本语法：所有的js语句都是由js表达式，关键字，运算符组合起来的。所有的js语法严格区分大小写。所有的js语句结束必须换行或者以分号结束。js的注释语法：//代表单行注释。/*多行注释*/运算符：加减乘除，大于号，小于号都属于运算符。一切代表运算符号的都是运算符。关键字：方法名称，变量名称，对象名称，数组名称一切名称都是关键字。表达式：以关键词结合运算符形成一句代码叫做表达式，表达式一定有结果产生。语句：由表达式结合基本语法形成多行代码叫做语句。变量：概念：在内存中直接开辟一个空间用来存放所需要的任意数据。优点：变量空间内的值可以随意更改，这样就实现了内存的灵活使用。变量的基本语法：变量的声明：var  变量的名称num 变量的赋值符号“=”变量的值：12；var num=12；这就是一个变量的创建。创建变量等于在内存开辟空间。看到一个var就开辟一个空间。变量的名称就是给空间起名，变量的值就是往空间内存储数据。不同的变量，命名可以同名，但是同名的变量输出以最新的变量结果输出。var a=12;vara=13;console.log(a);//13;console.log(a);//13同一个变量，变量可以重复赋值，最后的输出以最新的值为准。var a=12;a=13;console.log(a);//13;console.log(a);//13变量的命名规则：1，不许数字在前，可以字母，$,%做第一个名称。2，如果出现两个单词拼成一个变量名称，中间不许使用-连接，必须两个单词靠在一起，每一个单词的首字母大写叫做：大驼峰命名法。第一个单词小写，后面的单词首字母大写叫做：小驼峰命名法。3.所起名字不许和js程序中的标准关键字，保留关键词重名。标准关键字break  case  catch  continue  deflault  delete  do  else  false  finallyor  function  if  in  instanceof  new  null  return  switch  this  thow  true  try  typeof  var  with  undefined保留字 abstract  enum  int  short  boolean  export  interface  staticbyte  extends  long  super  char  final  native  synchronized class  float  package  throws  const  goto  private  transientdebugger  implements  protected  volatile  double  importpublic变量的传值：var a=13;var b=a;变量的传值，将一个变量a的值复制一次，粘贴给变量b,所以b的结果为：13；变量的使用：直接使用变量的名称就是直接使用变量的值。直接使用变量名称不用添加引号var c="中国";console.log(c);常量：常量就是一个固定的值。在ES5版本里面，常量的表示方法：PI=3.14;ES6版本里面，常量的声明：const PI=3.14;在常量中，一般常量的名称采用大写的字母表示。数据类型：计算机将世界上全部的数据以及数据出现的错误的状态都统统通过数据类型来加以存储和识别。基础数据类型/原始数据类型：undefined，定义了变量名，但是没有赋值。undefined ---》未赋值，未定义。null;--》空的，没有的。在对象中，null代表的是为空的对象string：--》字符串---》引号下所有的内容均为字符串。在内存每个字符都占两个字节数。number:--》数字类型包含了：整数，小数。整数在内存中：占4个字节数，小数占据：8个字节数Boolean：--》只有两个结果true,false这些数据类型都是存储在栈内存中的。栈内存：就是我们人为在内存中开辟的一块内存空间，这部分空间内存储的是程序中最小的基本数据类型，而且经常性的频繁使用，栈内存中存放的都是基础数据类型和所有数据类型的名称。那么栈内存会引申出来一个堆内存。堆内存 ：主要是存放：不经常使用，但是代码量很大的数据。这种数据我们一般一分为二两部分存储。将数据的名字存放在栈内，将数据的代码主体存放在堆内。中间以路径的形态连接起来。这种需要通过路径形态进行数据调用的数据类型被称为引用数据类型。js中常见的数据类型：object对象类型，array数组类型，function函数类型引用数据类型的值传递:不是复制值进行粘贴，而是直接复制堆内数据的（链接路径）重新链接到栈内的新名称上。凡是从网页上获取的数据统统都是string类型。***typeof()//进行数据类型判断的方法。具体的用法：将我们要判断的目标，直接写在typeof的圆括号内。var a="hello";var res=typeof(a);//我们这个方法得到结果显示的都是数据类型名称。例如：string类型，number类型，null类型，undefined类型,boolean类型，（字符串）  （数字）（空值）（只有名字没有值）boolean类型。object类型(对象类型/引用类型)。（对错值）console.log(res);  console.log(typeof(a));简写isNaN（c）//返回的结果是对错的判断标准。第二章数据的运算：说直白点：就是利用数学的运算方式来对我们变量中存储的数据进行：计算，对比，条件设置，赋值等处理运算所使用的符号叫做运算符：运算符分为：算术运算符，关系运算符，逻辑运算符，赋值运算符，三目运算；算术运算符：加号：+：当+号在运算中遇到字符串，加号变成拼接符,所有数据类型都变成字符串；当布尔值参与数字相加的时候，布尔值自动转化为数字，true=1;false=0;var a=10;var b="12";var c=a+b;console.log(c)//1012console.log(typeof(c))//stringvar a=true;var b=false;var c=a+b//1,数据类型：number。减号：-；当数字与数字类型的字符串进行减法运算的时候，计算机先强制将数字类型字符串转变位数字在参与计算。得到结果是一个number类型。var a=10;var b="12";var c=a-b;console.log(c)//-2console.log(typeof(c))//numbervar a=10;var b="12a";var c=a-b;console.log(c);//NaNconsole.log(typeof(c));//number所有的数据类型在参与减法运算中，都会被强制转化为数字，在参与计算。当非数字字符串参与减法运算，结果出现NaN。乘号：*一切乘法运算中，先把数据类型转化为数字，然后相乘。当非数字字符串参与乘法运算得到NaN结果。当我们遇到NaN数据的时候，我们不能直接使用typeof()进行判断，而是需要isNaN()进行判断，判断的结果是：TRUE或者FALSE在我们做算术运算中，如果出现小数的加减乘除运算的时候，出现小数点后的取值出现误差，这样的误差叫做舍入误差。解决方案：c.toFixed(2);意思是将变量c的结果取小数点后两位数，并且自动四舍五入。例如：var c=1.2-0.5;//0.7000000001;c.toFixed(2)//0.70;除法：/，所有的数据先转化为数字类型，然后参与相除，1除以0//infinity，无穷大。、求模运算：a%bvar a=123;var b=10;var c=a%b;c的结果是123除以10之后所剩余的量。结果为3.所以求模运算就是一种取除法中的余数运算。自增运算：var a=10;console.log(a+a++);a++在运算中先参与运算在第二步运算的时候才开始加1； a + a++=10+10=20//这个时候的a++必须等待第三个a出来才会让第三个a+1；a++ +a =10+11=21//此时a++参与第一步运算，遇到第二a,所以他将加1之后的值赋给了第二个a.练习作业：var a=2;var b=3;a+b++ +a++ +b=?在自增运算中，n++和++n的区别是什么？n++是先运算后自加，只有公式中出现第二个n才会讲增加的1赋值给第二个n上。++n是先自加后运算。在不参与运算的情况下，n++,与++n的值是一样的。计算机的计算顺序：1，先算括号内，2，再算乘除，3，算加减var a=1;var b=2;var c=3;(a++*++a -++b)/++c=?关系运算符：其实就是求几个数据之间的大小关系。有大于>,小于<大于等于>=小于等于<===等于===绝对等于！=不等于；关系运算结果返回的是一个boolean值，只有true或者false;面试题：==和===的区别。==是先进行数据类型转化，然后再比较是否相等。===是不进行数据类型转化，直接比较，更加严格一些、在关系运算中，一切数据类型遇到数字，都先转化为数字再对比。如果无法转化为数字，就会出现false结果再字符串的关系对比中，按照大小顺序是根据Unicode编码顺序来进行的。A-Z之间的Unicode编码顺序：65-90；a-z之间的unciode编码顺序：97-122；0-9之间的顺序：48-57；汉字的Unicode编码顺序：u4e00-9fa05逻辑运算：其实就是设置运算的条件，有“与”“或”“非”三种var a=prompt("请输入数字")if(!(a>70)){//逻辑非运算，凡是小于等于70才成立alert("你好");}if(a>70||a>90){//逻辑或运算,多个条件满足其一即可alert("你好");}if(a>70&&a<90){//逻辑与运算。多个条件必须同时满足才行。alert("你好");}赋值符运算：赋值运算 =  +=  -=  *=  /=  %=等号：将等号右侧的内容赋值给左侧的名字。+=：str+=5;str=str+5 //此时返回的结果是11面试题：var str="hello";var str=str+"world";创建了几个变量？标准答案：3个；解析过程：因为字符串变量一旦创建，空间不可改变，所以为了容纳helloworld，我们必须创建一个新变量他的值就是helloworld。加上之前的hello变量和world变量，总共是3个。条件三目运算：其实就是一个条件判断运算。其中语法包含：条件？“条件成立执行的结果”：“条件不成立执行的结果”数据类型的转化：隐式转化：在数据运算中，js程序自动根据运算的环境，对数据类型进行自动转化，例如在加运算中，所有数据遇到字符串，都会变成字符串，在关系运算中，所有数据遇到number都会转变成number类型。这样的转化被称为隐式转化。隐式转化：会自动根据环境进行转化，不需要人工操作，缺点：转化不可控为了能够让数据的使用可控，我们需要能够将数据转化人为可控制。这种需要人为转化的：我们称为显式转化或者强制转化。强制转化就需要我们使用相应的数据类型转化的方法；1，所有数据变成string类型：方法1，String（“内容”）;常用方法2，x.toString();2, 所有数据转化为number类型：方法1：Number(x);//将所有数据转化为number类型，如果遇到非数字类型转化结果为：NaN；带有小数点的数字内容直接转化为小数。方法2：parseInt(x);将所有数据转化为整数。遇到数字在前，文字内容在后的，该方法直接读取能够读到的数字部分转化为整数。，小数只显示整数部分方法3：parseFloat(x);将所有数据读取出来，如果有小数将显示小数内容。总结：parseInt(),parseFloat()，只是将字符串string转化为数字类型number，所以在上述两种方法中。圆括号内如果直接写内容就必须加双/单引号。练习：做一个超市的收银程序：1，工作流程：3，Boolean(x)//将所有数据类型转化为布尔值。除了，null，undefined，""空字符，0，false这些返回结果是false之外，其他都是返回true。第三章控制语句：我们已经学习了常变量来存储数据，学了数据类型来区分数据，学了运算符来计算数据，转化方法来转化需要的数据。但是我们获得数据之后怎么做。这就是我们学习控制语句的主要意义。    控制语句就相当于我们在日常生活中说话的语法控制语句分为两大类：    分支控制语句和循环语句。    分支语句：1，if（条件成立？）{写出条件成立执行的命令}2，if（条件成立）{执行条件成立的命令}else{执行其他的命令。}练习题：超市购物，计算结果之后，根据你给的钱做判断，确定你是应该找零还是应该补钱。练习题：1，写出五个档次的评价：优秀，良好，及格，不及格，弱爆了。2，自己制定一个10人的成绩单，3，输入任一学员名称，给出分数，并且给出评价。我们学习的if（）{}else if(){}else{}这种条件判断是先判断条件。再执行结果。switch（）{case 1:执行结果;}var a=prompt();switch(true){//圆括号内填写的是一个表达式。作为结果case a>90://冒号前面写上当前的条件判断，如果条件判断等于switch圆括号中的结果，执行命令。console.log("优秀");break;//执行完命令之后，跳出当前程序。case a>80:console.log("良好");break;case a>60:console.log("及格");break;default :console.log("不及格");break;}循环控制语句：  循环分三部分：1，循环变量；就是随着循环执行的命令逐次在增加或者减少的一个变量。2，循环条件。满足程序一直在循环执行的一个条件设置。3，循环执行的程序内容：我们称为循环体var th=null;while(th<(yfmoney-sfmoney)){th=parseFloat(prompt("请输入退货金额"));yfmoney=yfmoney-th;}while循环的特点是：先判断条件，然后再执行循环。do{}while()执行在前，判断在后。先执行一次程序，然后根据条件判断是否后续继续执行。do{} while();是先执行后判断，while(){}是先判断再执行。for循环。基本语法：for( var i=0;i<10;i++ ){循环体内容。}作业：利用while循环输出“*”打印出一个三角形。for循环是一种经常用作已知上限的有限循环。while经常用来做未知上限的条件循环。在switch  case中我们学习了break；跳出程序，阻断程序执行。但是当我们需要仅仅是跳出当前这一步，后面的继续执行，我们就需要用到continue；语法使用:for(var n=1;n<=100;n++){if(n==10){continue;}console.log(n)}输出的结果就会跳出10，继续执行下一步。作业：打印出九九乘法表，凡是乘数中有奇数存在，则不输出当前公式，继续输出下一步。奇数的判断标准：不能被2 整除的数为奇数。第四章1,函数/方法：就像变量拥有自己的声明一样，函数也拥有自己的类声明。function 就是一个类声明，函数/方法是一个典型的引用数据类型函数的基本语法是：声明：function 名字aa()//参数列表{//方法 }创建函数：有两种创建方法：1，使用类声明直接创建：function aa(){};//声明及值提前2，使用直接量创建；var aa=function (){};函数的使用：调用函数的名称aa()//返回的是：函数花括号内的程序过程或者结果值如果直接使用函数名称本身aa的话，输出的结果就是整个函数本体。如果调用函数的名称加上参数列表：aa()那么输出的结果就是函数方法体内的程序执行结果。函数的定义：我们称之为方法：它是一个封装了一段代码过程的容器。方法一般输出的结果有两大类：1，程序执行的过程，2，程序算出的结果值函数声明：function 名字aa()//参数列表{//方法体：封装需要重复执行的代码 }函数的变量：函数的全局变量//写在函数之外的变量称为全局变量，函数的参数变量//在函数的参数列表写的变量，函数的局部变量//在函数的方法体内声明的变量称为局部变量。函数变量执行的优先级别是什么？如果同时存在相同变量名称，那么输出的变量顺序是：局部变量优先，参数变量在中间，最后是全局变量。局部变量的结果输出：需要使用return命令实现。return的意思是返回。function a(){var c=100;return c;}console.log(a());//输出的结果是100；什么情况下使用return：  如果我们该函数的目的不是利用函数体内的程序过程，而是利用程序执行之后的一个结果，那么我们就需要在方法体  的底部使用return 后面跟我们需要使用的结果代码return是一次返回一个结果值。函数的参数：什么叫函数的参数？function aa(name,age){};凡是写在函数名称后方圆括号内的变量或者数据都是函数的参数/叫做方法的参数。备注：在我们以后所学程序中，我们经常会遇到 afc();这就是一个方法。凡是写在方法圆括号内的数据，都叫参数。参数分为：“形参”和“实参“两种。形参是一种形式的参数，不代表具体的内容。实参是一种代表了具体事物的内容。我们可以把形参看做参数变量的名称，实参看做参数变量的值。所以实参实际上实在给形参赋值，赋值的过程叫做函数的传参。在方法内，形参是不需要添加引号的，多个形参中间以逗号隔开。但是我们在调用方法的时候，在参数列表内添加一个实例化的参数，此时该参数为实参，实参如果是字符串，需要添加引号名词解释：实例化就是将一个形参写出一个实际的参数，这叫做实例化。初始化：如果我们新建一个变量或者方法，就直接写一个值作为默认存在的，就叫做初始化。function aa(name1,age1){//name1是形参，并且做局部变量name的值var name=name1;//局部变量var age=age1;document.write("我的名字是"+name+",我的年龄"+age);}aa("朱克泽",21);//朱克泽就是name1的实参。函数内调用函数：就是我们创建了几个基础函数，并且将这几个基础函数的结果直接调用在一个综合函数内。例如：//函数Afunction A(a){var num1=a;return num1;}//函数Bfunction B(b){var num2=b;return num2;}//函数Cfunction c(){var num3=A(1)+B(2);return num3;}console.log(c())//函数Cfunction c(f,e){var num3=A(f)+B(e);return num3;}console.log(c(3,5))内存的清理机制：引用数据类型的名称和路径直接存储在栈内存的。引用的数据类型主体是存储在堆内存的，他们之间是通过路径的方法加以调用。这个时候，计算机为保证内存的空间得到合理利用，会定期清理不用的代码段。ie浏览器判断的标准是：赋予每个代码段一定的使用次数，如果次数没有了则视为垃圾予以清除。非IE浏览器则根据代码的调用路径数量来判断，如果没有任何一个路径指向该代码。则视为垃圾予以清除。function 的值传递：在js中，所有的值发生重新赋值的时候都是按值传递。在引用类型中，发生的值传递都是值的路径进行改变的。function 的作用：1，封装代码段实现程序的重复调用。2，函数之间的调用本质上是一种数据的传递。1，函数的创建方法：1，声明创建。2，直接量创建2，函数的调用方法：函数名称+()；直接使用函数的名称相当于打印整个函数3，函数的变量：1，全局，2，局部，3，参数变量。优先执行的顺序是：2>3>1,作于范围：1>3>24,形参和实参，传参。5，函数内调用函数6，按值传递7，声明提前。面试题：声明提前：1，什么叫声明提前：当计算机在读取程序的时候，首先计算机会先预览全部程序，将变量var ，function同时提升到程序的最前方，优先执行。2，变量声明提前和函数声明提前的区别？1，变量声明提前只提前声明及名称，不提前值。2，函数声明提前是声明，名称及值同时提前。使用类声明直接创建的才会出现声明提前现象。第五章1,数组的概念：数组是一种空间，主要是用来存储批量数据的空间。2，数组的语法：var a=[1,2,3];//使用直接量创建数组数组的名称：a数组的元素：1 2  3数组中排第一位的序号是：0,那么0这种序号被称为数组的下标号。 var arr=[1,2,3,4];

//alert(arr[0]);//数组元素的读取，利用数组的名称[数组元素的下标号]来读取元素

//数组元素的添加,就是利用数组的下标号来进行赋值的方式添加或者修改

arr[3]=12;

console.log(arr);

3，数组的元素类型：在同一个数组中，元素的数据类型可以是不一样的。数组内的元素也可以是数组。4，数组长度的获取：length语法：arr.length//返回的结果是一个统计了数组中元素的数量。练习：输出数组中所有的元素。5,无序的数组，但是我们需要得到一个从小到大的数组。冒泡排序：var arr=[5,2,9,8,1,7,6,3,4];\冒泡排序实际上就是一种按照从小到大的顺序排列数组元素的。一帮常用语数字类型的数组。冒泡排序的原理，就是使用两个for循环从同一个数组中任意取出一个元素进行大小对比，通过值的转换，将小的元素排在大的元素之前。代码如下：var arr=[5,2,9,8,1,7,6,3,4];for(var i=0;iarr[j]){var c=arr[j];arr[j]=arr[i];arr[i]=c;}}}console.log(arr);数组中的内置方法：数组的底部插入和底部删除。push(元素,元素);数组名称.push(元素,元素);//这种方法是在数组的尾部自动增加元素，无法修改元素。和数组名称[i]="元素";//一次添加一个元素，但是可以修改已经存在的元素。arr.pop();在数组的底部取出元素。圆括号内没有参数，默认为取出数组中最后的一个元素。如果我们需要连续删除每个元素从后面往前删除的话，我们需要结合循环进行删除。栈存储，同时使用push,pop两种方法对数组进行修改的，我们将这种数据修改称为栈存储。表现出来的数据存储顺序为后进，先出  在数组的头部删除或者插入元素，在头部删除：arr.shift()面试题：写出pop(),push(),shift(),unshift()的作用和区别。练习题：总共15张票，排在奇数位的人都选择放弃买票。那么你的排位是32,请问你能否买到票。如果能买到，你是第几个买到票，如果不能你应该排在第几位。                                                      arr.sort(自定义排序规则);sort排序是根据Unicode编码进行升序排列。所以直接利用sort排序无法解决9以上数字的排序。此时我们就需要对sort排序进行自定义排序规则var arr=[3,4,1,5,2,8,6,9,7,12,15,35];arr.sort(function(a,b){return a-b;});document.write(arr);//sort排序中的自定义排序，只能对数字类型进行排序。//如果对字符串进行排序直接使用sort()方法即可。回调函数：直接写在方法圆括号内的函数被称为回调函数。其他的数组预定义方法：数组拼接：concat();这个拼接和push()的区别是：arr.concat(元素)是将原来数组arr和新添加的元素拼接形成新数组，老数组就需要手动清空。push();是在原数组基础上进行元素 内容添加修改。var arr=[1,2,3,4,5];arr=arr.concat(6,7);console.log(arr);//手动清空原数组 var arr=[1,2,3,4,5];var b=arr.concat(6,7);console.log(b)arr=null;join()合并；var arr=[1,2,3,4,5];arr=arr.concat(6,7);console.log(arr);console.log(arr.join());//不加双引号，代表将数组中的全部元素输出console.log(arr.join(""));//增加了双引号，代表将元素拼接在一起输出。截取：slice(start,end):slice()截取在内存变化中，实际上在原数组基础上，将截取的新元素重新创建一个新数组出来。老的数组如果不用就手动清楚，清空内存。slice截取元素依靠元素的下标来实现截取的范围。start是指开始的那个元素的下标号，end是所需截取的最后一个元素的下一位元素的下标。var arr=[1,2,3,4,5,6,7,8,9];arr.slice(1,3);//所截取的数组是[2,3];var arr=[1,2,3,4,5];arr=arr.concat(6,7);console.log(arr);console.log(arr.join());//不加双引号，代表将数组中的全部元素输出console.log(arr.join("！"));//增加了双引号，代表将元素拼接在一起输出。console.log(arr.slice(0,4));//新建一个新的子数组，原来的老数组依然存在。console.log(arr);console.log(arr.toString(""));//和join的相同点和区别点：//join（“”）相当于将每个元素转化为字符串并且拼接起来。join（）;直接将数组转化为字符输出不拼接。//arr.toString()加不加双引号都是直接将数组转化为字符串输出，不拼接。以上的数组方法均为内置方法：厂家已经定义好的方法我们直接使用就可以实现效果的。需要我们自己一个代码处理过程的程序，这样的方法叫做自定义方法。console.log(arr.slice(1,))//从第二位开始，一直到数组的最后一个元素全部截取。function slice(a,b){var arr=[1,2,3,4,5,6];var c=[];for(var i=a;i");//求多个值中最小的一个。

//随机数random();返回的是一个从0-1的随机数。

document.write(Math.random())

//50-100random()*50+50求出随机数生成的数字范围random()*(max-min)+min

练习作业：

使用随机数产生一个4位数验证码。验证码需要有数字和字母

Date日期对象：

概述：专门获取计算机日期的一个对象。

日期对象的创建方法：

var dat=new Date();

var dat=new Date();//获取的是计算机现行的时间

console.log(dat)

var mydat=new Date("2017/12/10 12:30");

console.log(mydat)//自定义时间

var pcdat=new Date(0);//得到的是计算机初始时间

console.log(pcdat)

get是获取日期对象的某一个具体的时间点。

但是他不能修改日期对象。

如果我们需要一个能修改日期对象的方法：就需要一个set();

例如我们需要修改下时间的小时数：

var dat=new Date();

dat.setHours(10);//此时运用set方法修改小时数为10

console.log(dat)//此时间已经修改。

我们在Date()对象中获取的时间差值，不仅仅是页面上的一个显示的内容，而且是一个时间差的

毫秒数，他在程序背后自动根据计算机的时间进度来前进。

所以我们说时间的进程变化不受到我们的页面程序的影响。

var nowdate=new Date();

var futuredate=new Date("2017/12/28 17:30");

var time=futuredate-nowdate;

document.write(time/1000/60);

练习题：算出距离过年还有多少：天，小时，分钟，秒的倒计时

第八章

1,function对象

function可以被称为函数对象。

在前端开发过程中，我们经常会遇到同名的函数，这个时候我们传参只能将参数传递给最新的函数

，js无法像Java这样的后台语言一样去根据参数的个数和类型来识别给那个函数传参。

为了解决这个问题，我们今天学习一个类数组类对象arguments来解决这个问题。

arguments：是函数对象创建的时候才会产生，指的就是function中的参数列表。

这是一种对象，但是具有数组的特点 ，所以被称为类数组类对象。

特点：1，可以获取对象的长度。有length属性

arguments.length获得是实际参数所传的实参个数。

2，可以根据下标号来查找参数。

arguments对象的主要作用：根据长度和数据类型判断所传数据是否为函数对象所需数据。

模拟Java中的函数重载。

函数的创建：

1，直接量创建： var aa=function(){

this//代表的是全局对象window

};

2，函数类声明创建：function aa(){};

3，构造函数创建：var aa=new Function()

在对象中 this//代表的是函数名：aa

匿名函数：匿名函数的自调，回调；

匿名函数：没有命名的函数 ，匿名函数的调用：(function(){})()//自调；

将整个匿名函数放入方法的参数使用。例如sort(function(){})//回调函数。

闭包：

闭包的作用：防止全局变量的值污染。

因为js中变量var可以实现同名变量的创建，这样会导致在后续的赋值过程中出现值的误传。

闭包实现的原理：

局部变量不会被外部所访问。

代码实例：

function cc(){

var n=10;

return function (){

return n+3;

}

}

n=100;//为了不被n=100的值污染，我们使用了闭包；

var c=cc();//cc()//function (){return n+3}//c=function (){return n+3}

console.log(cc())

document.write(c());//function (){return n++}

//var c=aa();//var c=function(){return n++}

//document.write(c());

闭包的三个特点：

1，存在内环和外环两个函数嵌套。

2，在内环和外环之间存在一个局部变量。

3，内环函数是一个匿名函数并且由外环函数return。

自定义对象：

对象：从代码使用上来说。对象就是我们所要描述的目标，以及为了描述目标所封装的属性存储，处理及运算方法，等统称为对象。

从代码表现上来说：对象实际就是一系列没有序列的属性和值的集合

自定义对象：开发人员根据需要自我定义的对象；

自定义对象的创建：

1，直接量创建：/原始对象；

var obj={

name:"tom",

age:21,

say:function(){this.name+this.age}

}

//缺点：原始对象主要是针对某一个实例来写的，如果我们后续要多个实例创建，就需要重复创建。

2,为了缩减代码，减少重复创建，我们使用工厂函数进行创建：

//工厂函数创建对象方式:

function stu(name,age,party,core){

var obj={};

obj.name=name;

obj.age=age;

obj.party=party;

obj.core=core;

obj.say=function(){

return this.name+this.age+this.party+this.core;

}

return obj;

}

//工厂函数，就是使用常规函数包装对象。通过不同值的传递，实现不同对象的输出。规避了代码的重复

//缺点：对于不同属性的同名函数，他无法识别函数的种类。

//构造函数对象

function Obj(name,age,core){

this.name=name;

this.age=age;

this.core=core;

this.say=function(){

return this.name+this.age+this.core;

}

}

var first=new Obj("tim",21,75);

var first1=new Obj("tmm",28,65);

console.log(first.say());

//特点：可以规避代码重复创建，同时清晰只想所传参数的归属。

缺点：每次实例化传参都等于在堆内存中重新开辟空间，内存的性能很差。

属性的遍历输出：

对象的属性遍历输出可以通过for in 循环的方式予以读取。

对象的属性值添加，通过 对象.属性名=“属性值”;的方式予以修改的。

对象["属性名"]="属性值"

对象属性是否存在的判断方法：

1，通过利用属性名in对象的方式予以判断，返回结果为：boolean值

2，通过hasOwnProperty()方法予以判断

function stu(name,age,sex,core){

var obj=new Object();

obj.name=name;

obj.age=age;

obj.sex;

obj.core=core;

obj.say=function(){

}

return obj;

}

for(var key in stu()){

document.write(stu("tom",1,"男",45)[key]);

}//遍历输出

document.write("height" in stu())//属性判断

document.write(stu().hasOwnProperty("age"));//属性判断

document.write(stu().age===undefined);//属性判断

封装：

原型：在js中，我们所有面向对象都是基于原型的面向对象。原型就是每个函数对象在创建的时候，都会有一个默认的属性

prototype，该属性数据类型是一个object类型，所以我们称原型为原型对象。

原始对象没有原型prototype.

原型获取：

function B(){

this.name="tom";

}

console.log(B.prototype);//object

document.write(Object.getPrototypeOf(B))//function(){[native code]}

对象的原型直接全部复制对象的属性和方法，对象改变，原型改变。如果原型改变了，对象不会被影响到。

练习作业：

1，两个对象A，B （代码题）

实现a1继承b1的身高

实现a1,a2,a3,统统继承b1身高

如果只是通过原型继承，第一题怎么做？

基础题：继承的三种方法代码抄写，及区别

预习：自有属性，共有属性，属性的扩展，this关键词的用法。

继承：

使用继承的原因，因我们在实际开发工作，我们将所有的方法都封装为独立的对象，那么独立的对象如果

需要形成一个完整的程序，我们就需要在对象之间形成相互调用，这样就需要使用继承这一功能。

继承的定义：对象A能够直接使用对象B的属性，这就叫做A继承B;

继承的方法：

1,A.prototype=new B();此时就实现了对象A对对象B的全面继承。

主要表现在A的原型链指向B的原型

2,实现单一一个对象继承另一个对象，不影响其他的同类对象。

Object.setPrototypeOf(子对象a，父对象的实例new B());

3,实现A对B的原型继承：

A.prototype=B.prototype;//就是将B的原型直接赋值给A的原型，从而实现A对B的继承。

对象和原型的关系

对象的改变会影响原型的改变。

原型的改变不会影响到对象。

共有属性和自有属性：

如果有一个父类B,和子类b，父类的所有属性都会被子类b所继承使用，那么父类的属性被称为共有属性

如果子类中有一个自己独特的属性。那么这个属性被称为自有属性。

父类无法使用子类的自有属性。

子类可以直接使用父类的原型属性/共有属性。

给父类添加共有属性/原型属性的时候我们需要写成 父类.prototype.属性名=“属性值”；

给子类添加自有属性：子类.属性名=“属性值”

this关键词：意思是替代指向；

在构造函数中，对象中，this代表的是对象自身。

在常规函数中，this代表的全局对象window。

call()//参数第一个值里面放的是this，

apply()

以上两种都是替代函数，主要作用是 做对象指向的改变。参数的第一个为this，指的那个对象，第二个参数

call最多可以填写两个元素，做具体单一传值。

apply()第二个参数是一个类数组类对象，里面可以包含一组元素。指向范围更加广阔一些。

function add(a,b)

{

alert(a+b);

}

function sub(a,b)

{

alert(a-b);

}

add.call(sub,3,1); //1，此时相当于我们将add替代了对象sub.，输出sub直接使用是add的运算公式

输出结果为4

sub(3,1)//2，但是如果我们单独给sub对象提供参数，sub依然是按照自己原有的公式计算结果

输出结果为：2；