javascript小结

1.对象的声明：

1.1 function student(name,age...){

this.Name=name;

this.Age=age;

...

}

1.2 JSON (javascript object notation)

JSON是一种键/值对方式来描述内部成员的格式，其内部成员可以是几乎任何一种类型的对象，当然也可以是方法、类、数组，也可以是另外一个JSON对象。

var student = {

Name: "张三",

Age: 20,

Hobby: "读书",

Books: [

{

BookName : "C#" ,

Price : 70

},

{

BookName : "Java" ,

Price : 70

},

{

BookName : "Javascript" ,

Price : 80

}

]

};

上面静态的构造出了student对象，不同于其他语言的是JavaScript还可以添加新的属性。例如：

student.Introduce = function() {

            var stuInfo = "姓名:" + this.Name +

                         "，年龄:" + this.Age +

                         "，爱好:" + this.Hobby +

                         "，拥有的书:" +

                         this.Books[0].BookName + "、" +

                         this.Books[1].BookName + "、" +

                         this.Books[2].BookName;

            alert(stuInfo)

        };

        student.Introduce();

      student对象原来并没有Introduce方法，第一次为student.Introduce赋值会在student对象中创建一个新的成员，后面如果再为student.Introduce赋值则会覆盖上一次所赋的值。当然我们这的值是一个function。也可以用类似索引的方式来添加成员。

        student["Introduce"] = function() {

          ……

        };

 

        student.Introduce();

当然添加的成员也可以删除掉。删除掉之后则成为undefined，再访问该成员时则不支持。

        delete student.Introduce;

还有一个很有用的操作可以遍历对象的所有属性：

for (var key in student) {

            document.write(key + " : " + student[key] + "<br />");

        };

这里需要注意一个数组和对象的区别，先讲讲数组也有类似的索引方式：

var array = [];

        array["一"] = "A";

        array["二"] = "B";

        array["三"] = "C";

        array["四"] = "D";

        alert(array["一"] + array["二"] + array["三"] + array["四"]);

这种方式把数组当做了hashtable，不过注意把数组当成Hashtable来操作时，要注意，并非是为数组添加数组元素，而是在数组对象中添加新的属性成员。而且如果for(var key in array)循环遍历数组对象的话，key得到的却不是array对象的属性名称，而是数组元素的索引号。

2对象的操作

JavaScript不支持重载，如果你写了两个函数，第二个会覆盖第一个，不过我们还是有办法的。

function中有个arguments属性，可以把它看成一个数组，它按传递进来的参数的顺序来保存所有的参数。也就是说我们在定义方法时可以不声明参数名。

function Hello() {

            if (arguments.length == 0) {

                alert("hello , everybody!");

            }

            else {

                alert("hello , " + arguments[0] + "!");

            };

        };

 

        Hello();

        Hello("张三");

      基于参数个数不同的重载。

        function Increase(arg) {

            if (typeof arg == "undefined") {

                alert("请输入参数");

            }

            if (typeof arg == "string") {

                alert(String.fromCharCode(arg.charCodeAt(0) + 1));

            }

            if (typeof arg == "number") {

                alert(arg + 1);

            }

        };

        Increase();

 

        Increase("a");

        Increase(1);

      基于参数类型不同的重载

3匿名类和立即执行类

匿名类

function() {

            ……

        };

   在窗体加载时,在标题上显示当前时间

        window.onload = function() {

            document.title = new Date().toString();

        };

 

    也可以将匿名方法传入定时器中

       setInterval(function() {

            document.title = new Date().toString();

        }, 1000);

    使用匿名函数绑定事件和进行定时操作。

        var Hello = function() {

            alert("hello , everybody!");

        };

如果将匿名函数赋给变量，那和有名的普通函数就没区别了。但不管是变量引用还是普通地有名函数，这样的函数在内存上都持久的占有一定资源。有时候我们只想执行一次大不必使用有引用的函数，直接执行匿名函数可能是最好的选择。把匿名函数包起来，加个括号执行，一切ok，这就是由匿名函数延伸出来的立即执行函数。

        (function() {

            alert("hello ,  everybody!");

        })();

 

        (function(somebody) {

            alert("hello , " + somebody + "!");

        })("张三");

立即执行函数在做事件绑定，设置回调函数等方面往往会有意想不到的效果，可以解决诸如对象引用等问题。

        var student = {

            Name: "张三",

            Age: 20,

            Introduce: function() {

                alert("我叫" + this.Name + ",今年" + this.Age + "岁了!");

            } };

        window.onload = (function(obj) { return function() { obj.Introduce(); }; })(student);

因为javascript中函数的这些特点加之它的对象的特征，我们还可以写出一些有functional意味的程序出来。其实javascript中function真的是老大。

        function Sum(fun, x) {

            if (x <= 0)

                return 0;

            return fun(x) + Sum(fun, x - 1);

        };

4 类的私有性及相关操作

细节内容很多，大体有这么几个要注意的。

1定义类用function，创建用 var X= new x();如

function Lady() {

            var age = 30;

            var name = "菜花";

 

            var think = function() {

                alert("其实我今年" + age + "岁。");

            };

            

            function fancy(){

                alert("幻想变成20岁。");

            };

 

            this.Introduce = function() {

                alert("我叫" + name + " , 今年20岁。");

            };

        };

 

        var younglady = new Lady();

    但是这里就有了访问性问题，直接调用younglady.think（）是不可以的，因为他（用var定义）是私有的。

那么如何调用呢？有两个办法

a 特权成员：用this定义的成员

比如将上面例子的var think=改为this.think=就可以调用younglady.think（）

b 公共成员：prototype

    普通公共成员的创建，不在类的里面来编码，而是通过类的prototype来创建。添加普通公共成员都直接添加到类的prototype中，而prototype就是一个像JSON对象一样的成员集对象。当我们进行对象创建时，可以认为会将类prototype中的成员整体copy入新的Object对象中。

        var younglady = new Lady();

        younglady.Introduce(); //Introduce

 

        Lady.prototype.Hobby = "上网";

        Lady.prototype.GetName = function() {

            return this.Name;

        };

        

        var lady2 = new Lady();

        alert(lady2.GetName());

        alert(lady2.Hobby);

    在添加普通成员的时候也可以来个批量的添加，直接用一个新的JSON对象来赋给prototype就可以了。但是要注意，现在是将原先的prototype进行了替换，在替换之前创建的对象引用的是旧的prototype对象，所以对prototype替换之前创建的对象不会有Hobby和GetName成员。

        Lady.prototype = {

            Hobby: "上网",

            GetName: function() {

                return this.Name;

            }

        };

        var younglady = new Lady();

        alert(younglady.GetName());

        alert(younglady.Hobby);

    除了在构建类时可以添加公共成员，还可以对对象直接进行成员操作。对对象直接添加的成员，也是一种公共成员，这些成员也可以和类中原先具有的公共成员进行访问。

        younglady.SetName = function(name) {

            this.Name = name;

        };

        younglady.SetName("菜明");

        alert(younglady.GetName());

---

其实相当于读后感，大量借鉴了heros blog的东西，下面附上原帖地址

http://www.cnblogs.com/heros/archive/2009/09/17/1568411.html

原帖写的很好，可惜停了，继承那些可能还要自己看，到时候争取写出些自己原汁原味的东西吧

再次向作者致敬，要是文章触犯版权请联系我@@