JavaScript备忘录(0106更新ing......)

虚函数是类成员中的概念，是只做了一个声明而未实现的方法，具有虚函数的类就称之为抽象类，这些虚函数在派生类中才被实现。
抽象类是不能实例化的，因为其中的虚函数并不是一个完整的函数，不能被调用。所以抽象类一般只作为基类被派生以后再使用。

这里Class是一个全局对象，具有一个方法create，用于返回一个函数（类），从而声明一个类，可以用如下语法：
var class1=Class.create();
但实际上可以把Class.create()返回的类看作所有类的共同基类，它在构造函数中调用了一个虚方法initialize，所有继承于它的类都必

须实现这个方法，完成构造函数的功能

   var Class = {
   create: function() {
     return function() {
       this.initialize.apply(this, arguments);
     }
   }
}

        var class1 = Class.create();
        class1.prototype={
            initialize:function(strname){
                alert(strname);
            }
        }
var c = new class1("www");
这样，每次创建类的实例时，initialize方法都会得到执行，从而实现了将类的构造函数和类成员一起定义的功能
当new一个函数时，这个函数就是所代表的类构造函数

function fun1()
        {
            this.p = "fun1-";
            this.A= function(arg){
                alert(this.p+arg);
            }
        }
var obj1 = new fun1();

在JS中 每个对象看做是多个属性，方法的集合
每个函数也是一个对象
对于有名函数，它可以出现在调用之后再定义；
而对于无名函数，它必须是在调用之前就已经定义。
arguments对象存储的是实际传递给函数的参数

 

也可以使用new操作符来操作一个对象的方法来返回一个对象，
这样一个对象的方法也就可以定义为类的形式，
其中的this指针则会指向新创建的对象。
var namespace1=new Object();
namespace1.class1=function(){
     //初始化对象的代码
 this.p="";
}

原型对象的定义必须在创建类实例的语句之前，否则它将不会起作用
//定义一个只有一个属性prop的类
function class1(){
      this.prop=1;
      this.showProp();
}
//使用函数的prototype属性给类定义新成员
class1.prototype.showProp=function(){
      alert(this.prop);
}
//创建class1的一个实例
var obj1=new class1();

//通过指定prototype对象来实现类的成员定义
class1.prototype={
      someProperty:"sample",
      someMethod:function(){
          //方法代码
      },
      …//其他属性和方法.
}
静态成员属于一个类的成员，它可以通过“类名.静态成员名”的方式访问
function class1(){//构造函数
}
//静态属性
class1.staticProperty="sample";
//静态方法
class1.staticMethod=function(){
      alert(class1.staticProperty);
}
//调用静态方法
class1.staticMethod();

//var x=Class.create();  //Class.create() 声明一个类
//extend(destination, source)用从 source 到 destination复制所有属性和方法的方式 来提供一种继承机制。
//用于将参数中source的所有属性都赋值到destination对象中，并返回destination的引用Object.extend(父,子）;

  //找一个页面的全部input 然后根据条件选择要的控件

var arrList = document.getElementsByTagName("input");
       for (var i = 0; i < arrList.length; i++)
       {
           if (arrList[i].name == "radData" && arrList[i].checked)
          {
                strFileName = arrList[i].value;
               break; 
          } 
       }

label for 属性 设置或获取给定标签对象指定到的对象
reset 重置表单  form.reset () 

<a href="javascript://" onclick="SysProduct();"></a> 
<a id="m0" href="javascript:SysProduct();">aaa</a>
在事件中用SysProduct()

在普通属性中用javascript:SysProduct()

el[eventType]= 
e.eleventType=

[]和.记号是等同的  对象.属性  对象['属性']

div 一段 英文 最后是空格换行

this指针，它表示当前运行的对象。
在实现对象的方法时，可以使用this指针来获得该对象自身的引用。

this[this.length] = 4; //向数组添加一个

<SELECT id="ClassListB" name="ClassListB">
<OPTION></OPTION>
</SELECT>

ClassListB.options[ClassListB.options.length] = new Option(ClassListB.options[ClassListB.selectedIndex].text,'a');
obj.options[obj.options.length] = new Option(text,value);

var num = [1,2,3];
this[this.length] = 4; //向数组添加一个

<link rel='stylesheet' type='text/css' href="hello.css" />
<script type="text/javascript" src="hello.js" />

但实际上可以把Class.create()返回的类看作所有类的共同基类，它在构造函数中调用了一个虚方法initialize，
所有继承于它的类都必须实现这个方法，完成构造函数的功能。它们得以实现的本质就是对prototype的操作
这样，每次创建类的实例时，initialize方法都会得到执行，从而实现了将类的构造函数和类成员一起定义的功能

var x=Class.create();  //Class.create() 声明一个类
    x.prototype={          
        initialize:function(uname)  //intialize函数是类的构造函数 当new这个类时便会执行．达到了面向对象中的构造函数的效果．
        {
            this.name = uname;
        }
        show:function()
        {
            alert(this.name);
        }
    }
    var a = new x('aaa');
    a.show();

myobj.funsize = funsize; // 省略括号 调用函数  

//funsize表示这个函数的返回值付给myobj.funsize     传递的是一个Function对象 而不是对那个对象的调用
var myobj = new Object();          
            myobj.size = '12';
            myobj.funsize = function(){
                alert('');
            }
            function funsize()
            {
                alert('');
            }
            myobj.funsize = funsize; 
            //省略()括号调用函数  funsize()表示这个函数的返回值付给myobj.funsize