javascript（一）

一、javascript中的数组

javascript数组的定义方法有三种：
1、var arr1 = new Array();//var arr1 = new Array(2);
     arr1[0] = "苹果";
     arr1[1] = "桔子";
2、var arr2 = new Array("苹果","桔子");


3、var arr3 = ["苹果","桔子"];//推荐使用


表示数组的长度用属性length;


常用数组对象方法：
  1、join([分隔符])：数组元素组合为字符串，
                     当不传参数时，默认为','；


  2、toString()以字符串表示数组；
  3、reverse()数组反转，得到数组仍然是原数组；
  4、valueOf()返回数组值；
  5、数组既可以当队列来看，也可以当做栈来看
     push，往数组里放元素。array.push("苹果");


  二维数组：
     var fruit = new Array(3);
        fruit[0] = new Array("苹果",2);
fruit[1] = new Array("桔子",3);
fruit[2] = new Array("香蕉",5);

二、javascript定时器

1、用以指定在一段特定的时间后执行某段程序。
    setTimeout();
    格式：
       [定时器对象名=] setTimeout("表达式",毫秒);
       执行【表达式】一次。

2、setInterval();
    格式：
       [定时器对象名=] setInterval("表达式",毫秒);


     重复执行【表达式】，直至窗口、框架被关闭或执行
       clearInterval.

      clearInterval():终止定时器
      格式：
        clearInterval(定时器对象名);

三、javascript内置对象

  --图像对象
  --导航对象
  --窗口对象   window
  --屏幕对象  screen获得用户当前窗口
  --事件对象  event.属性 
              document.onmousedown = getEvent;等同于下面代码
      <input type = "text" onclick = "getEvent()"/>
  --历史对象
        用以存储客户端最近访问的网址清单
用于返回事件history.back();
即可不用判断是来自于那个地址
         history.back(-1);return false;
        history.属性
history.方法（参数）
  --文件对象（重点）
  --锚点对象
  --连接对象
  --框架对象
  --表单对象（重点）
  --位置对象


窗口对象：
   [window.]属性
   [window.]方法（参数）
   opener.属性
   opener.方法（参数）
   窗口名称.方法（参数）

4、写入Cookie:
     格式：
        document.cookie = "关键字 = 值[;expires = 有效日期][;...]"

四、javascript对象

5、看例子：函数的本质是对象，并且在js中不存在函数重载的概念
<script type = "text/javascript">
  function add(number){
     alert(number+20);
  }
  function add(number){
     alert(number+30);
  }
  add(10);
</script>
弹出结果为40
<script type = "text/javascript">
 function add(number){
    alert(number+20);
 }
 function add(number,number1){
    alert(number+30);
 }
 add(10);
 </script>
弹出结果为40
<script type = "text/javascript">
  function add(number){
     alert(number+30);
  }
  function add(number){
     alert(number+20);
  }
  add(10);
  弹出结果为30
</script>
根据以上运行结果看出，后面的函数将前面的覆盖了
真是这样的吗？？
===当然不是。

   在js中函数(function)本源是一个对象.也就是说：
    function add(number){
     alert(number+30);
    }
   等同于==> var add = function(number){
 alert(number+30);
                       }
这样add就指向了函数对象的一个引用。
     function add(number){
alert(number+20);
     }
     等价于 ==> var add = function(number){
                             alert(number+20);
  }
也就是代码运行到这里时，add重新赋值为
 后面那个函数对象的一个引用了。
 所以从你本质上来说是对变量的“重新赋值”
 而不是函数的覆盖。

6、在javascript中(function)函数本质是一个对象，
   那么对象是具有类型的，函数所属的类型是Function类型的，
   所有的自定义的函数都是Function对象类型的。
     var add = function(number){
        alert(number+20);
     }
     add(10);
     又等价于==> var add = new Function("number","alert(number+20);");
                  add(10); 
     如何理解这种表示方式呢？
     ===>
     1）由于Function对象接受的参数时不定长的，其原因是我们自定义的
     函数对象都是Function对象，而自定义函数的参数是可变的，这就是为
     什么Function对象接受的参数不定长，从而又导致了我们自定义的函数在
     调用时，参数可以不定。
     2）Function对象接受的参数虽然不定长，但是有一个特点：
        他最后一个参数是我们自定义函数函数体的内容。除了最后一个参数
的其他参数都是我们自定义函数接受的参数，虽然是这样但是对于
Function对象而言所有的参数都是字符串型的    
     3）所以我们自定义函数的本质是声明了一个Funcition对象，而函数名
        只是对该对象的一个引用而已 
     4）Function对象有一个属性arguments,表示给函数实际传递的参数。
          arguments相当于一个数组的概念。取值为arguments[0]取的是
 实际传递的第一个参数。arguments.length实际参数个数。
        在实际运用中还是通过对arguments.length的判断来确定用户传递参数的个数的。
     5）当我们对一个对象调用length属性，表示该函数对象期望接受的函数的个数。

7、javascript中有五种原始数据类型：
   Undefined:undefined 是从Null派生出来的undefined == null 值为true
   Null:null
   Boolean:只要不返回undefined或null，判断都是true
   Number:
   String:


    我们判断某个变量或是对象是什么类型可以使用
     var s = "hello"; //s是原始类型
     alert(typeof s); //string
     var s = new String("hello");//s 是对象类型
     alert(typeof s); //结果是：object




     typeof 变量名字：一元运算符，用来获取变量名称
       其返回值有5个：undefined/boolean/string/object/number

8、对于函数对象而言，如果没有返回值则返回值是undefined。

9、强制类型转换：存在3中强制类型转换
     Boolean(value);Number(value);String(value);

10、所有的对象都是Object类型的，Object是内置对象
    Object对象是有很多属性，是不可以被枚举出来的
    也就是不能用for..in查看出来的
    可以通过propertyIsEnumerable("prototype");
    得到的结果是false表示该prototype是不可以被枚举出来的

11、js可以为一个对象动态的添加属性和方法，也可以进行动态删除
    var object = new Object();
    alert(object.username);//undefined
    object.username = "nihao";//或者也可以表示为：object["username"] = "nihao";
    alert(object.username);//nihao
    delete object.username;//username属性已经从对象中删除（delete是一元运算符）


    //定义一个对象，拥有两个属性，格式如下：
    //这种方式是js中最常见的方式
    var object = {username:"zhangsan",password:"123"};

12、关于js中的数组
   数组有一个sort可以进行排序，是对原数组进行排序，也就是排序完之后原数组内容改变了，默认为升序
   sort方法在计较时，会将比较的值分别调用toString()方法，然后按照字符串进行排序
   所以这种排序是不可靠的，所以一般都是我们来定义：
     function compare(num1,num2){
         var t1 = parseInt(num1);
var t2 = parseInt(num2);
if(t1<t2){
   return -1;
}else if(t1 == t2){
   return 0;
}else{
   return 1;
}
     }
     
     var array = [1,3,25,34];


     array.sort(compare);//将自定义的排序规则赋予给sort方法

  13、js中定义对象的几种方式：
      1）：基于已有对象来扩充其属性和方法
           var object = new Object();
  object.name = "zhangsan";
  object.sayName = function(name){
     this.name = name;
     alert(this.name);
  }


  object.sayName("lisi");//调用


      2）：工厂方式
          function createObject(username,password){
      var object = new Object();


      object.username = username;


      object.password = password;


      object.get = function(){
  alert(this.username+"  "+this.password);
      }
      return object;
 }
          
 
 var o1 = createObject("zhangsan","123");
 vasro2 = createObject("xiaoming","456");


 o1.get();
 o2.get();


      3): 工厂方法的改进（多个对象每个拥有一份对象，方法共享一份）  
              
 function get(){
    alert(this.username+"  "+this.password);
 }
 function createObject(username,password){
      var object = new Object();
      object.username = username;
      object.password = password;


      object.get = get; 
      return object;
 }


 var o1 = createObject("zhangsan","123");
 var 02 = createObject("xiaoming","456");
 o1.get;
 o2.get; 


       4):构造函数方式  
            function Preson(){
   //当我们使用new在执行第一行代码前，js引擎会为我们生产一个对象
      this.username = "zhangsan";
      this.password = "123";
      this.getInfo = function(){
         alert(this.username+"   "+this.password);
      }
     //在此处有一个隐藏的return语句，用于将之前生成的对象返回。
   }
   var p1 = new Person();
   p1.getInfo();


   function Preson(username,password){
   //当我们使用new在执行第一行代码前，js引擎会为我们生产一个对象
      this.username = username;
      this.password = password;
      this.getInfo = function(){
         alert(this.username+"   "+this.password);
      }
     //在此处有一个隐藏的return语句，用于将之前生成的对象返回。
   }
   var p1 = new Person("zhangsan","123");
   p1.getInfo();


 5):原型方式prototype//这种方式没办法传参，也会导致程序错误（变量共享）。
               由于prototype是object对象所拥有的，所以
      每一个对象都会拥有一个该属性。
      function Person(){
      
      }
      Person.prototype.username = "zhangsan";
      Person.prototype.password = "123";
      Person.prototype.getInfo = function(){
          alert(this.username+"  "+this.password);
      }
               var p = new Person();


          6）：原型方式加构造函数来定义对象
   function Person(){
      this.username = new Array();
      this.password = "123";
   }
   Person.prototype.getInfo = function(){
      alert(this.username+"  "+this.password);
   }
        
7):动态原型方式
             function Person(){
        this.username = "zhangsan";
this.password = "123";


if(typeof Person.flag == "undefined"){
    Person.prototype.getInfo = function(){
       alert(this.username +"  "+this.password);


    }
   Person.flag = true;
}
    }

14、javascript中的继承：
    1）：对象冒充的方式。(可以实现多重继承)
      //父类
       function Parent(useranme){
           this.username = username;


  this.sayHello = function(){
    alert(this.username);
  }
       }
       //子类继承父类
       function Chlid(username,password){
          //将父类的username继承到子类中
 this.method = Parent;//将父类当做是子类的一个方法
 this.method(username);//当在调用方法时，父类中的this变成了子类的this从而使得username就变成了子类的username了
 delete this.method;//然后删掉中间属性method


 this.password = password;


 this.sayword = function(){
    alert(this.password);
 }
       }




     2）:call方法，call方法是Function对象中的方法，
        而所有的自定义函数对象都是Function对象类型的
所以任何一个函数都有call方法,call方法中的第一个参数会被
传递给函数中的this，从第二个参数开始，注意赋值给函数中的其他参数。
function test(str){
   alert(this.name +"   "+str);
}
var object = new Object();
object.name = "zhangsan";
        
//test.call相当于调用了test函数,
//call方法中的第一个参数永远是赋值给函数中的this
test.call(object,"lisi");




     call方式实现对象的继承
        //定义父类
function Parent(username){
  this.username = username;
  this.get = function(){
     alert(this.username);
  }
}
        //子类继承父类
function Child(username,password){
    Parent.call(this,username);
    this.password = password;


    this.getword = function(){
        alert(this.password );
    }
}


    3):apply方法方式实现对象继承
    applay 与call 方法很像，唯一的不同是从第二个参数开始，
    call是进行一一赋值，而在apply中将从第二个参数开始都将
    参数放置在一个数组中，然后将该数组作为参数传递
    //定义父类
    function Parent(username){
       this.username = username;


       this.sayHello = function(){
           alert(this.username);
       }
    }
    function child(username,password){
        Parent.apply(this,["zhangsan"]);
this.password = function(){
 alert(this.password);
}
    }


    4）：原型链方式实现对象的继承(没法传参数)
      
     //定义父类
     function Parent(){
     
     }
     Parent.prototype.hell = "hello";
     Parent.prototype.sayHello = function(){
        alert(this/.hello);
     }
     //子类继承父类
     function Child(){
        
     }
     Child.prototype = new Parent();
     Child.prototype.world = "world";
     Child.prototype.sayworld = function(){
        alert(this.world);
     }
 
     5）：混合方式(推荐)
        //function Parent(hello){
  this.hello = hello;
}
Parent.prototype.sayhello = function(){
  alert(this.hello);
}
       //子类继承父类
       function Child(hello,world){
          Parent.call(this,hello);
 this.world = world;
       }
       Child.prototype = new Parent();