JavaScript总结

建立自己的JavaScript动态库，积累比较好的函数

 

1.编写JavaScript是要大小写严格限制。冒号不要省略。

2.注释： //  /* */

3.标识符：字母，数字,'_',$。第一个字符不能使数字。

4.JavaScript中的Boolean值很容易转换，和Java中的有些不同的。非空对象，数组或者函数等，TRUE就转换为数字1，

  0或者NaN，null,为定义的值,空字符串，转化为FALSE。

5.JavaScript中的函数是真正的数值，意味着可以存储在变量，数组和对象中。

6.两种定义函数的方法：function square(x){return x*x;}  || var squery=function(x){return x*x ;}

这种方式用的很少,效率低：var squery =new function("x","return x*x;");

7.JavaScript中的对象可以最为关联数组使用。image.width  和用法一样 image["width"]

8.对象直接量：var rectangle = { upperleft:{x: 2, y:2 },lowerRight:{x: 4, y:4}};

9.数组：var a=  new Array(); a[0]=1.2;a[1]={s:1,y:2}; ==>var a = new Array(1.2,{s:1,y:2});

  数组直接量：var a=[1.2,{s:1,y:2}]; var spareArray =[1,,,,5];其中有三个为定义

10.in 运算符：要求左边的运算符是一个字符串，或者可以转换为字符串。又边是一个对象或者

数组，如果该运算符左边的值是其右边对象的一个属性名，则返回TRUE。

var point ={x:1,y:2}; var has_x_coord= "x" in point; var ts ="toString" in point;

11.instanceof运算符。左边是一个对象，右边是对象类的名字，返回为TRUE

如果左边不是对象，或者右边的运算符是一个对象，而不是一个构造函数，返回FALSE

 

12.typeof运算符：是一元运算符，放在一个运算符之前，这个运算符可以使任意类型的，返回一个

字符串。数字---number || 字符串---string || 布尔值---Boolean

对象，数组，null --- object || 为定义---undefined

 

13.with语句：用于暂时修改作用域 with(Object) statement

如果要多次访问fram[1].document.forms[0]这个表单，可以使用with语句将这个表单添加到作用域链中：

with(frames[1].document.forms[0]){

name.value="";

address.value="";

}//这种方式不建议使用。这种方式可以用下面的语句代替

var form = frames[1].document.forms[0];

form.name.value="";

form.address.value="";

14.for..in..语句  遍历一个对象的属性。

 

15.通用的Object对象属性和方法：

        constructor属性：var d = new Date();  ==> d.constructor == Date //TRUE

 if(typeof o == "object" && o.constructor ==Date) ==> if(typeof o=="object" && o.instanceof Date)

toString 和toLocaleString方法

valueOf()方法 把一个对象转换为某种基本类型的数据类型，也就是一个数字而不是一个字符串的时候才调用的方法

hasOwnProperty()方法 //如果对象用一个单独的字符串参数所指定的名字来本地定义一个非继承的属性

 var o={}；

 o.hasOwnProperty("toString"); //false,toString is an inherited property

 o.hasOwnProperty("undef"); //false

 Math.hasOwnProperty("cos");//true,Math has a cos property

 

propertyIsEnumerable()方法 //对象用一个单独的字符串参数所指定的名字来本地定义一个非继承的属性

var o= { x:1 };

o.propertyIsEnumerable("x");//true

o.propertyIsEnumerable("y");//false

 

isPrototypeOf()方法  //这个方法所属的对象是参数的原型对像返回TRUE。else false

var o={ x:1};

o.prototype.isPrototypeOf(o); //true

Object.isPrototypeOf(o); //false

o.isPrototypeOf(Object.prototype);//false

Function.prototype.isPrototypeOf(Object) //true

 

16.JavaScript数组

 

Javascript是基于prototype的面向对象语言，没有类的概念，所有的一切是现有对象的副本

JavaScript对象：

function对象，alert();作为函数，可以用参数进行调用

  作为构造函数的function，必须通过new关键字来实例化

  var myFunction = new Function(",");//不推荐使用,影响性能,注意这是F大写

  function myFunction(){}//推荐

Object对象，无法将像function类对象那样调用，而且具有固定的功能。

  var obj = new Object();也可以简单的写为 var obj = {};创建简单的对象

  obj("Error");//出错了，没有产生构造函数

Array对象，是一种特殊的属性和方法的集合 var array = new Array();<==>var array = [];

String,Boolean,Number,Math,Date,RegExp对象

Javascript中的继承：与传统的面向对象不同，在JS中的继承是通过简单的从一个对象原型向

另外一个对象原型复制而实现的

var person ={};//定义person对象

person.getName=function(){//为person对象构造了方法

alert("person name");

}

var student = {};

student.getName=person.getName;//继承了person的方法

person.getName=function(){

alert("person1 name");

}

student.getName(); //person name

person.getName(); //person1 name

Javascript对象是什么？

数组的两种的实现方案，顺序数组、散列数组（key,value）

对象==关联数组==属性包==存储体

对象只有成员访问这一个操作

JavaScript原型、对象

原型只存在于function中，它实质上是一个对象被创建后引擎自动创建一个空的prototype对象

由于对象是属性包所以原型就是一个属性包

原型中读的时候从原型链上读，写的时候往自己里面写

构造自己的构造函数：

function myConstructor(a){//.....} <==> var myConstructor=new Function('a',"/*某些代码*/");

var myObject = new myConstructor();//实例化后会执行代码

 

例如：function myConstructor(message){ this.myMessage = message ;}

var obj = new myConstructor();//这样obj中也包含了myMessage这个属性

如果加入参数var obj = new myConstructor("hello word");//这样myMessage这个属性的值为hello word

如果这样会出错的：

var myObject = new Object();

var obj = new myObject();//出错了！！因为myObject不是构造函数

 

能够的使实例化的对象包含的方法称为公有方法，需要修改函数的原型。

当修改一个对象的原型时，任何继承该对象的对象和已经存在的所有实例立即继承同样的变化。根据用法的不同这一特性

功能既强大也会导致问题。因此当你修改自己的当不是你的原型时候要特别小心

例如：//添加公有的属性：

function myConstructor(message){ this.myMessage = message ;}

//添加公有的方法：

myConstructor.prototype.clearMessage=function(string){

this.myMessage+=' '+string;

}

var myObject = new myConstructor("hello word");

myObject.clearMessage("12");//但是不能直接在myConstructor上调用这个方法

 

添加静态属性和方法：

--|在prototype下添加的属性和方法。能够被继承下来的。上面已经介绍过

--|   //secondObject既是一个实例也是一个构造函数

var secondObject = function(){

}

secondObject.name='hj';//添加新的静态成员属性name

secondObject.alertName=function(){//添加新的静态成员方法

alert(this.name);

}

secondObject.alertName();

//静态成员name和alertName成员不能用到新的实例中

var obj= new secondObject();//出错了，obj不是一个function

obj.alertName();

 

添加私有的方法和属性(以及特权方法)：

私有成员就是在构造函数中定义的变量和函数，例如：

function myConstructor(message){

    this.myMessage = message ;

    var myOwner=this;//私有属性

    var separator='_'//私有属性

    function alertMessage(){ alert(myOwner.message);}//私有方法

    alertMessage();//实例化是显示信息

    ..........

    //特权方法：

特权方法，与私有方法不同的是，特权方法能够公开访问，而且还能访问私有

成员。特权方法是指在构造函数的作用域中是用This关键字定义的 方法

 

    this.appendToMessage=function(string){

 

this.myMessage+=separator+string;

alertMessage();

    }

}

 

公有，私有，特权，静态的总结：

私有和特权成员在函数的内部，他们会被带到函数的每一个实例中，因而占用大量的内存

公有的原型成员是对象蓝图的一部分，适用于用new关键字实例化该对象的一个实例，它是

   能够被继承的

静态成员只适用于对象的一个特殊的实例