AJAX与JavaScript脚本语言

发布时间：2020-12-16 00:44:17 所属栏目：百科来源：网络整理

导读：上一篇博客中提到了 ajax并非是一种新的技术，而是几种原有技术的结合体， XMLHttpRequest对象是AJAX的核心技术，而JavaScript也起到了不小的作用， XMLHttpRequest对象我们已经介绍过了，详情请见点击打开链接，下面我将介绍JavaScript的高级知识部分

上一篇博客中提到了ajax并非是一种新的技术，而是几种原有技术的结合体，XMLHttpRequest对象是AJAX的核心技术，而JavaScript也起到了不小的作用，XMLHttpRequest对象我们已经介绍过了，详情请见点击打开链接，下面我将介绍JavaScript的高级知识部分

一.数组的使用

1.创建数组

（1）一维数组

//使用new Array()

var array1 = newArray();

//使用[]操作符

var array2 = [];

//创建的同时定义数组中的元素，使用new Array()方式

var array3 = newArray(1,2,3);

//使用[]操作符

var array4 = [1,3];

（2）多维数组

//使用new Array()

var array5 = newArray(1,new Array(2,3),4);

//使用[]操作符

var array6 =[1,[2,3],4];

2.元素的获取

（1）一维数组

//利用数组下标进行元素的获取

array3[1]; //获取到array3中的第二个元素

（2）多维数组

array5[1][0];

3.元素的设置

（1）一维数组

array4[2] = 111;//设置array4中的第三个元素的值为111

（2）多维数组

array5[1][0] = 222;

注：JavaScript中的数组是可以动态改变大小的，因此可以直接给一个不存在的下标设置元素值

array6[99] = 100;

4.数组中的方法

（1）concat

这个方法可以用来做数组的连接或者说合并,原数组内容不会变更,将返回一个新的数组

var array41 =array4.concat(101,102,103);

var array42 =array4.concat([104],[105]);

var array43 =array4.concat(array4);

（2）join

这个方法可以将数组当中的元素,按照制定的分隔符连接成字符串的输出,原数组的内容不会改变

var strarray431 =array43.join("");//返回的结果为1211112111

var strarray432 =array43.join("+");//返回的结果为1+2+111+1+2+111

（3）slice

这个方法可以返回当前数组的子数组，原数组的内容不会改变

var slicearray1 =array43.slice(0,3);//从0下标开始，到3下标之前的元素返回成新的数组,返回结果为1,111

var slicearray2 =array43.slice(4);//从4下标开始，到数组尾部的所有元素返回成新的数组,返回结果为2,111

var slicearray3 =array43.slice(-2,-1);//从当前数组的倒数第二个元素开始,到倒数第1个元素之前的所有内容,返回成新的数组,返回结果为2

（4）push,pop

在数组尾端追加（push）或删除（pop）元素，将会改变原数组的内容

array43.push(200);

array43.push(201,202);

array43.push([203,204]);

array43.push(array41);

var arraypop =array43.pop();

var arraypop =array43.pop();

（5）unshift,shift

在数组的开头进行追加（unshift）或删除（shift）的操作，将会改变数组的内容

array43.unshift(300);

array43.unshift(301,302);

array43.unshift([303,304]);

var arrayshift =array43.shift();

var arrayshift2 =array43.shift();

（6）reverse

这个方法可以翻转数组中的元素，修改原数组的内容

array43.reverse();

（7）sort

这个方法可以对数组中的元素进行排序，修改原数组的内容

array43.sort();//没有参数，是按照字母序对数组中的元素进行升序的排序

array43.sort(function(a,b){ return a - b;});//就是按照数值大小进行的一个升序的排序,如果返回的是负值,则a会出现的b前面

array43.sort(function(a,b){return b - a; });//就是按照数值大小进行了一个降序的排序

（8）splice

可以删除数组中的一部分元素,并且把删除的内容进行返回;也可以在制定的位置添加元素,原数组的内容发生改变var splicearray1 = array43.splice(4,2);//从下标为4的元素开始删除，删除2个元素

var splicearray2 =array43.splice(4);//从下标为4的元素开始删除,直到数组末尾的元素都被删除array43.splice(1,400,401);//在下标为1之前,插入400,401

array43.splice(1,[400,401]);//在下标为1之前,插入数组[400,401]

二.对象的创建与属性的操作

1.创建对象

//方式1

var obj1 = new Object();

//方式2

var obj2 = {};

2.增加属性，使用.操作符

obj1.num = 1;

obj1.str = "String";

obj1.hello = function(){alert("hello!"); }

obj2.obj = obj1;

3.属性的访问

//方法1，使用.操作符

alert("obj2.obj.num");alert("obj2.obj.str"); obj1.hello();

//方法2，使用[]操作

alert(obj2["obj"]["num"]);

alert(obj2["obj"]["str"]);

obj1["hello"]();

4.对象直接量定义方法，利用{}

var obj3 = { num:1,str:"String",hello:function(){ alert("hello"); }}

三.类

1.类的定义

function 模拟

function ClassName(){

}*/

提示：建议采用下面的形式来定义一个js中的类，可以和普通的function进行区分；建议类名首字母大写，以便更好的和普通的function进行区分

var ClassName=function(){

}

举例：

           //定义一个Book类，这个function还承担了模拟构造函数的工作
           //在使用new操作符创建Book类的对象时，这个function中的代码会被执行
           //this代表当前对象，下面执行book1的时候this指book1，执行book2的时候this指book2     
            var Book =function(name){
               //定义公有有的属性
                this.name= name;
               //定义公有的方法
               this.getName = function(){
                    returnthis.name;
                };
               this.setName = function(nname){
                   this.name = nname;
                };
            };     
            functionooTest(){
               var book1 = new Book("AJAX");//这个new操作符相当于先创建了一个简单对象，调用了类的构造函数
                var book2= new Book("AJAX2");
               alert(book1.getName());
               alert(book2.getName());
               book1.setName("Java");
               alert(book1.getName());        
            }

改进之后的，使用上了原型,prototype

              var Book =function(name){
               //共有属性在构造方法里面定义，通过this关键字
                this.name= name;
                if(typeofBook._init ==="undefined"){
                   //共有方法在构造方法外定义，通过原型定义
                    Book.prototype.setName = function(nname){
                    this.name= nname;
                     };
                    Book.prototype.getName = function(){
                    return this.name;
                     };
                }
                Book._init= true;
            };
   
            functionooTest(){  
               var book1 = new Book("AJAX");//这个new操作符相当于先创建了一个简单对象，调用了类的构造函数
               var book2= new Book("AJAX2");
               alert(book1.getName());
               alert(book2.getName());
               book1.setName("Java");
               alert(book1.getName());
          }

2.类的属性和方法的定义

(1)私有的属性和方法的定义及调用

                 //普通的方法
                var priObj = new function(){
                    var priname ="wang";
                    this.getName = function(){
                        return priname;
                    };
                    this.setName=function(nname){
                        priname = nname;
                    };
                };
       
               //利用匿名方法直接调用的方式,来实现一个对象拥有私有的信息
                var priObj = (function(name){
                    var priname = name;
                    return{
                        getName:function(){
                            return priname;
                        },setName:function(nname){
                            priname = nname;
                        }
                    };
                })("wang");

(2)定义公有的静态属性

            Book.staticValue = 10;
            //定义公有的静态方法
            Book.changeValue = function(){
                Book.staticValue++;
            };

改进之后的，使用上了原型,prototype

  var Book =function(name){
               //共有属性在构造方法里面定义，通过this关键字
                this.name= name;
                if(typeofBook._init ==="undefined"){
                   //共有方法在构造方法外定义，通过原型定义
                    Book.prototype.setName = function(nname){
                    this.name= nname;
                     };
                    Book.prototype.getName = function(){
                    return this.name;
                     };
                    Book.prototype.getCount = function(){
                    addCount();
                    return count;
                     };
                }
                Book._init= true;

(3)利用局部变量来模拟私有属性和方法

	var count= 0;
                varaddCount = function(){
                   count++;
                };
            };
    
            functionooTest(){
                //根据类名反射生成对象，只知道Book,只要要传的参数"wang"
                var book =reflect("Book",["wang"]);
               alert(book.getName());
                //判断一个对象是否拥有某个属性
               //hasOwnProperty这个方法只能判断在对象上直接定义的属性，对于继承来的属性不能直接判断
                var bool =book.hasOwnProperty("name");
               alert(bool);
                //需要有一个替代方法，让getName这种继承的属性也能被判断
                var bool2 =book.hasProperty("getName");
               alert(bool2);
               
               //遍历book对象上的所有属性
                for(varproName in book){
                   alert(book[proName]);
                }
               
               //如果我们需要获得一个对象上,所有属性值不是function的属性
                varproArray = [];
                for(varproName in book){
                    vartemp = book[proName];
                   if(typeof temp !== "function"){
                       proArray.push(proName);
                    }
                }
               alert(proArray);

四.创建命名空间

1.方法:createNameSpace("SpaceName");

我想再创建一个Book类，为了避免与刚刚创建的Book冲突,因此需要一个命名空间,使新建的Book在此命名空间中,它就相当于一个包,也可以理解为这两个Book类的路径不一样了.

  //我需要一个叫做com.wang的命名空间，然后这个Book类属于这个命名空间
    createNameSpace("com.wang");
  //定义com.wang这个命名空间上的 Book类
   com.wang.Book = function(){
                    
     }
   varcomwangBook = new com.wang.Book ();
               
   };

2.创建命名空间上的辅助方法

functioncreateNameSpace(nameSpace){
                 //com.wang，如果需要建立命名空间，实际上就是要保证有一个com的对象，并且com中有一个wang的属性值，这个属性值也是一个对象
                  varattrs = nameSpace.split(".");

(1)判断根节点对象是否存在，不存在才进行创建

                 var obj;
                  try{
                      obj= eval(attrs[0]);
                 }catch(e){
                     window[attrs[0]] = [];
                      obj= window[attrs[0]];
                  }

(2)对根节点对象（命名空间）下面的子孙对象进行逐一的遍历判断，如果不存在，就进行创建

   for (vari = 1;i<attrs.length ; i++){
                    if(obj[attrs[i]] === undefined){
                        obj[attrs[i]] = {};
                     }
                    
                    //修改当前对象，继续进行遍历
                     obj =obj[attrs[i]];
                 }
              }

(3)扩展Object类的方法,判断当前对象是否有某个属性

  Object.prototype.hasProperty=function(){
                   return(this && this[proName])!== undefined;
                }

(4)反射创建对象方法

    //第一个参数是类名
          //第二个参数是创建对象需要的所有参数组成的数组
           functionreflect(className,args){
               try{
                  //如何把字符串类型的className转换成对应的一个函数
                   varrClass = eval(className);
                  //为了创建对象需要的所有参数在一个数组里面["1","2"];
                  //最终我们调用new创建的时候,参数表的写法应该("1","2");
                   varoargs = args.join(",");
                   var obj= new rClass(oargs);
                   returnobj;
               }catch(e){
                   returnnull;
               }         
           }

以上为JavaScript中的一些知识,其实都是最基础的,与之前的学习进行对比,好多地方也是相似的,上面提到的类的创建的,还有他的一些属性,方法,不管是私有的还是公有的,都是模拟的,貌似它的很多东西都是模仿来的,以后的学习还需要不断的总结分析,不能与之前的脱了干系,JavaScript也是面向对象,与C#的面向对象编程学习也有很多不同之处,需要对比学习,这些东西还需要不断的学习.

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!