javascript笔记整理（二）

14.常用子类

1.函数
2.数组
3.日期
4.正则
...

15.面向对象

16.（承接14）

1.函数

1.创建
   1>函数字面量
              var say=function(){}
   2>函数声明
	          function say(){}
   3>匿名函数
	          function(){1002}
	          var obj=1001->{}         
	          在被创建时立即调用
	          (function(){})()
	          (声明)()
   4>对象中
	          var obj={
		      name:'lisi',
		      say:function(){}
	          }

	          obj.name
	          obj.say()
	          obj["say"]()
js解析器优先解析函数声明，然后解析使用var操作符声明的变量，但是不赋值,
函数内部代码在函数被调用时执行

var a=10;
var a=20;
console.log(a);//20

function say(a){}
function say(a,b){}
say(10);
js中没有重载概念，只要函数名相同，即为重写


2.函数的调用
           函数名()：
           new 函数名()
           ...
3.函数的参数
           形式参数：当前函数需要的参数
           实际参数：实际调用方法时传递的参数
           function say(形式参数){}
           var say=function(形式参数){}
           say(实际参数);
           形式参数和实际参数的个数可以不一致，并且数据类型不限
           
           function say(a,b,c){
	       //1.var a;var b;var c;
	       //2.10-》a；20-〉b
	       console.log(a,b,c);
           }
           say(10,20);
4.函数的内部属性
  arguments：类数组对象
	         用来保存实际参数的对象
	         length：实际参数个数
	         callee:从函数内部指向当前拥有arguments的函数
  this:
	    this指向函数赖以生存的环境对象
	    函数this值什么时候确定？
		    在函数被调用时确定
	    指向谁？
		    当前拥有this的函数被谁调用,被谁调用就指向谁
5.作为值的函数和作为返回值的函数
  值：
		function say(){}

		var handler=say;
		handler();

		function run(h){
			//h->say
			h();
		}
		run(say);

  返回值：
	    {
		  toString:function(){
		  return 10
		 }
	    }

	    function say(){
		.....
		return function(){}
	    }
6.函数的属性
	function say(){}

	obj:{
		say:function(){}
	}

	对象名.属性名
		  obj.name
		  say.xxx

	length:
		      say.length:返回当前函数的形式参数的个数
		      
	prototype:原型对象
		      用来存储非静态方法/公有属性和方法

		      每一个函数都有一个原型对象(prototyoe)
		      每一个对象都有一个构造者(constructor)

	call():
		      函数的调用方式
		      函数名.call(this,实际参数列表)

		      say.call(this,1,2,3,4);
		      say(1,2,3,4);
	apply()
		      函数的调用方式
		      函数名.apply(this,[实际参数列表]);

		      say.apply(this,[1,2,3,4]);

---

2.数组

[]
一组数据的集合
数据中的所有数组元素，使用逗号隔开，每一个数组元素数据类型任意
数组长度可以动态修改

1.创建
  1>数组字面量
		var arr=[];//空数组
		var arr=[null,undefiend,false,"",function(){},{}];
  2>构造函数
		var arr=new Array();//空数组
		var arr=new Array("hello",false);//创建非空数组
		var arr=new Array(10);//创建一个数组长度为10的数组

		如果参数为1个参数，并且参数类型为number类型，相当于创建一个以number为长度的数组
		如果两个以上参数，相当于将参数作为数组元素创建数组

        function Array(){
	      if(arguments.length==1){
		    if(typeof arguments[0]== 'number'){
			  //底层：创建一个以argumnets[0]为长度的数组
		    }else{
			  //底层：创建一个以1为长度的数组,数组元素为arguments[0]
		    }
	      }else if(argumnets.length==0){
		      创建一个以0为长度的数组
	      }else if(arguments.length>1){
		      创建一个以arguments.length为长度的数组,数组元素为arguments中每一个数组项
	      }
        }

        new Array(10);
2.访问数组元素 
  每一个数组元素都对应一个数组下标(属性名),数组下标从0开始（number）

  arr[index]:访问+设置
		var arr=[1,2,3,4];
		console.log(arr[2]);

  length:
		访问数组长度
		增加/删除数组元素
3.检测数组
	function:
		     typeof function:function
	arr:
		     typeof arr:object
	isArray():
		     Array.isArray(arr);对于数组返回true，非数组返回false
		     当前arr是否为Array类型
		     静态方法
4.转换数组
	toString():arr.tostring()//1,2,3,4
	join("-");将数组转换为string

5.方法
  添加/删除数组元素
  栈方法：先入后出
		 pop():
				删除数组元素
				参数：不需要
				返回值：删除的数组元素
		 push()：
				添加数组元素
				参数：添加的数组项
				返回值：添加之后的数组长度

  队列方法：先入先出
		  unshift():
				添加数组元素
				参数：添加的数组项
				返回值：添加之后的数组长度
		  shift():
				删除数组元素
				参数：不需要
				返回值：删除的数组元素
				
  排序：
	   reverse：
	            数组反转
			    参数：不需要
			    返回值：反转之后的数组
			    修改原数组
	   sort():
			    数组排序
			    修改原数组
			    参数：
				0:每一个数组项，相当于会调用toString()之后进行比较，按照字符编码顺序进行排序
		       1:
			      回调函数function(a,b){
				     if(a>b){
					    return 正数：将a放在b之后
					    return 负数：将a放在b之前
				      }
			       }

			      返回值：排序之后的数组(在原数组基础上进行排序)

3.操作方法（非静态方法）

concat（数组的实例对象调用的方法）:
			数组拼接
			(arr,arr1)
			参数：想要拼接的数组
			返回值：拼接后的新数组
slice():（不修改原数组）
			数组切割/截取
			参数：
			0:
				返回值：切割后的新数组
				默认从数组开头开始切割，切割到数组末尾，组成新数组
			1:
				参数：index
				开始切割位置
				返回值：从当前位置开始切割，到数组末尾的新数组
			2:
				begin end
				返回值：从begin位置开始切割，切割到end位置结束，不包含结束位置
splice():   数组切割（修改原数组）
            参数：
	        0:
		        返回值：为空数组
	        1:
		        index:begin
		        返回值：从begin位置开始切割，到数组末尾结束；修改原数组
	        2:
		        begin number
		        返回值：从begin位置开始切割，切割number个数组元素所组成的新数组，     number>剩余元素个数=》剩余元素个数
	        3:
		        begin number "content":
		        替换：
		 	        begin number 'content'
		 	        从begin位置开始，删除number个数组元素，在begin位置插入content
		        插入：
		 	        begin 0 'content'
		 	        从begin位置开始，删除0个数组元素，在begin位置插入content

indexOf(key，index):
            查找数组元素
            通过全等操作符进行比较
            参数：key  index
            返回值：
	               找到了返回当前数组元素的下标
	               找不到返回-1
	               默认从前向后查找，找到一个满足条件的元素返回
lastIndexOf():
            查找数组元素
            默认从后向前查找
content index
            找不到返回-1
            找到返回当前数组元素的下标

4.迭代方法

var arr=[11,2,13,4,5];
	for(var i=0;i<arr.length;i++){
		i:index
		console.log(arr[i]);
}

every():
		如果每一个数组元素都满足条件，返回true
some()：
		只要一个数组元素满足条件，返回true
map()：
		对每一个数组元素进行操作，返回值操作后的数组
filter()
		数组过滤
		将满足条件的数组元素筛选出来放在一个新数组中


forEach(funnction(){
	this->{}
},{})：
	for(){}
	循环体
	index item


参数：
		回调函数 this
		回调函数：有几个数组元素，回调函数被执行几次
	    参数：item index arr
	    item：每次循环所获取的数组元素
		index：每次循环的数组元素所对应的数组下标
		
		this：
			用来指定回调函数内部的this
myForEach():
	1.声明位置
	2.判断参数个数以及类型
	3.如何循环执行回调函数
	4.回调函数中的this值指向
	
reduce():
	回调函数 this
	回调函数：
		    pre item index arr
		    pre：上一次回调函数执行的返回值
			如果第一次执行时,并且没有设置第二个参数时，pre为数组第一个元素；如果设置了第二个参数，第一次的pre为第二个参数
			this：回调函数中的this