基于RPGMakerMV的JavaScript基础-2

第二章        JavaScript基础知识

第一节        基本语法
区分大小写

JavaScript是区分大小写的，也就是说，大写字母和小写字母会被认为是不同的部分，例如变量名rename，Rename以及RENAME是不同的三个变量，虽然它们看起来含义相同。

空白

大多数情况下，JavaScript是忽略空白部分的，所以你可以使用空格键、制表键等来缩进代码，使其变得好看许多。例如图2-1中的两端代码，虽然功能是一样的，但是下面的部分明显比上面的部分简洁、清晰。要是隔两天你再来看，那么你愿意看哪一种呢？

注释

注释必须好好写，注释必须好好写，注释必须好好写。（重要的事情说三遍）注释是帮助你理解的一部分文字，并不在代码中起作用。

c式的/*与*/，或者c++式的//都可以，其中/*和*/可以跨行注释其中的所有内容，//只能注释在它后面的这一行的内容。

 
图2-1
分号

分号对于JavaScript虽然不是必要的（事实上解释器会自动补全），但是这里推荐你老老实实的每句话后面加分号，否则会出现一些稀奇古怪的事情。

换行

换行用于把两条语句隔开，以增加可读性，一样推荐你老老实实的换行，不要偷懒。另外，不要把一句话拆开两行。

第二节        JavaScript语句

JavaScript有两种语句，简单语句和复合语句。

简单语句就是看着简单的，例如

1. x=5;

复制代码

复合语句就是看着很复杂的，包含了多个结构的，例如。

1. if(con==1){
   
2.         x=5;
   
3. }else{
   
4.         x=8;
   
5. }

复制代码

事实上这两者没什么本质不同，你也不必要区分的那么仔细，我也不打算详细区别这两个东西。

第三节        JavaScript的保留字

ECMA-262 描述了一组具有特定用途的关键字。这些关键字可用于表示控制语句的开始或结束，或者用于执行特定操作等。按照规则，关键字也是语言保留的，不能用作标识符。以下就是ECMAScript的全部关键字（带*号上标的是第5 版新增的关键字）：

• break       do        instanceof        typeof
• case        else        new        var
• catch        finally        return        void
• continue        for        switch        while
• debugger*        function        this        with
• default        if        throw        delete
• in        try
  

ECMA-262 还描述了另外一组不能用作标识符的保留字。尽管保留字在这门语言中还没有任何特定的用途。但它们有可能在将来被用作关键字。以下是ECMA-262 第3 版定义的全部保留字：

• abstract        enum        int        short
• boolean        export        interface        static
• byte        extends        long        super
• char        final        native        synchronized
• class        float        package        throws
• const        goto        private        transient
• debugger        implements        protected        volatile
• double        import        public
  

  

第5 版把在非严格模式下运行时的保留字缩减为下列这些：

• class        enum        extends        super
• const        export        import
  

      

在严格模式下，第5 版还对以下保留字施加了限制：

• implements        package        public        interface
• private        static        let        protected
• yield
  

                  

总之，这些词都不要使用做自己的变量名字就好，否则会跟系统预定义的功能起冲突。

第四节        变量和数据类型
变量是储存信息的容器。

变量需要起一个变量名。变量名须以字母、 $ 或 _ 符号开头，而且对大小写敏感。

建议大家平常都用字母开头，我个人比较讨厌美元和短命鬼。

使用变量前需要声明这个变量，我们使用var来声明一个变量，例如：

1. var a=5;
   
2. var b=10;
   
3. var c=a+b;
   
4. var pi=3.14;

复制代码

就像这样，我们就声明了一系列的变量，并且给他们赋了相应的值。也可以不赋值来声明一个变量，在后面的使用中再给它赋值，例如：

1. var m;
   
2. m=250;

复制代码

1. 赋值要使用=，叫做赋值号，注意，这东西不是等号，不表示两个相等，只是把右边的值给左边，或者说把左边的变量设置成和右边一样的。

复制代码

数据类型就是数据的类型。

JavaScript有字符串、数字、布尔、数组、对象、Null、Undefined这样几种基本数据类型。

而且，JavaScript拥有动态的数据类型，这意味着相同的变量可用作不同的类型，例如，前一刻它还是个数字，后面就变成字符串了：

1. var a;//声明一个变量a
   
2. a=5;//给a赋值5，此时a是个数字类型
   
3. a="hehe";//给a赋值“hehe”，此时a是个字符串类型

复制代码

字符串

一种比较特殊的（我不喜欢特殊……）类型，用引号包裹着的内容来表示。单引号可以，双引号也可以，例如：

1. var carname="Bill Gates";
   
2. var carname='Bill Gates';

复制代码

也可以用引号包裹引号，这种字符串是里面有引号的字符串，例如：

1. var answer="Nice to meet you!";
   
2. var answer="He is called 'Bill'";
   
3. var answer='He is called "Bill"';

复制代码

数字

这就是表示一个数字，没什么好说的，例如：

1. var x1=34.00;      //使用小数点来写
   
2. var x2=34;         //不使用小数点来写

复制代码

还可以用科学计数法，例如：

1. var y=123e5;      // 12300000
   
2. var z=123e-5;     // 0.00123

复制代码

布尔

布尔类型是逻辑运算的，只有两个值：true和false。

数组

数组就是一些变量的顺序组合，JavaScript中这样来创建一个数组：

1. var cars=new Array();
   
2. cars[0]="Audi";
   
3. cars[1]="BMW";
   
4. cars[2]="Volvo";

复制代码

或者 (condensed array):

1. var cars=new Array("Audi","BMW","Volvo");

复制代码

或者 (literal array):

1. var cars=["Audi","BMW","Volvo"];

复制代码

数组的下表是从0开始的，你可以用[]里面加数字的形式来访问数组里面存储的数据。

对象

对象由花括号分隔。在括号内部，对象的属性以名称和值对的形式 (name : value) 来定义。属性由逗号分隔：

1. var person={firstname:"Bill", lastname:"Gates", id:5566};

复制代码

上面例子中的对象 (person) 有三个属性：firstname、lastname 以及 id。

空格和折行无关紧要。声明可横跨多行：

1. var person={
   
2. firstname : "Bill",
   
3. lastname  : "Gates",
   
4. id        :  5566
   
5. };

复制代码

对象的访问有两种形式，一种是使用.来访问，一种是使用[]来访问，例如：

1. name=person.lastname;
   
2. name=person["lastname"];

复制代码

undefined和null

undefined 这个值表示变量不含有值，可以通过将变量的值设置为 null 来清空变量，例如：

1. cars=null;
   
2. person=null;

复制代码

声明指定类型的变量时，可以使用new来声明，例如：

1. var carname=new String;
   
2. var x=      new Number;
   
3. var y=      new Boolean;
   
4. var cars=   new Array;
   
5. var person= new Object;

复制代码

另外，JavaScript中的所有变量都是对象。

第五节        对象

事实上，JavaScript中所有事物都是对象，对象就是拥有属性和方法的数据。

属性和方法

属性是与对象相关的值，与游戏人物的属性类似。

方法是能够在对象上执行的动作，与游戏人物的技能类似。

举例：汽车就是现实生活中的对象。

汽车的属性：

1. car.name=Fiat
   
2. car.model=500
   
3. car.weight=850kg
   
4. car.color=white

复制代码

汽车的方法：

1. car.start()
   
2. car.drive()
   
3. car.brake()

复制代码

同样，游戏中的人物也有生命值，攻击力等属性，也有攻击，防御，放火球等方法。这样，我们就可以把游戏中的人物当做一个对象来设计。

当你像这样声明一个 JavaScript 变量时：

1. var txt = "Hello";

复制代码

你实际上已经创建了一个 JavaScript 字符串对象。字符串对象拥有已经按标准定义好的属性 length。对于上面的字符串来说，length 的值是 5。字符串对象同时拥有若干个内建的方法。

属性：

1. txt.length=5

复制代码

方法：

1. txt.indexOf()
   
2. txt.replace()
   
3. txt.search()

复制代码

除了使用JavaScript内建的几种对象外，我们还可以自己定制自己的对象，例如刚才说到的游戏人物，就可以像这样定义：

1. var person=new Object();
   
2. person.name="Xiao Rou"
   
3. person.hp=500;
   
4. person.atc=10;
   
5. person.def=5;
   
6. person.attack=function(){//……具体动作}

复制代码

访问对象的属性和方法都要使用.来访问，例如：

1. person.attack()//执行person的attack方法
   
2. var a=person.atc//给a赋值person的atc属性

复制代码

第六节        函数
函数是由事件驱动的或者当它被调用时执行的可重复使用的代码块。

在JavaScript中，函数用function来表示，是一种可以被调用的代码块，当你调用一个函数的时候，就会执行其中的代码。我们一般把会多次使用的语句组合在一起，形成一个函数，方便重复使用。

以下例子都可以采取事件中插入脚本的方法进行实际测试，定义好函数之后，一定要进行调用（请参看alert函数是怎么调用的）。

函数的定义如下所示：

1. function hello(){
   
2.         alert("Hello Xiao Rou!");
   
3. }

复制代码

由function打头，后面跟着给这个函数起的名字，之后是小括号，大括号里面是函数的内容，可以是任意的语句。例子中的alert也是一个函数，这个函数是JavaScript标准定义好的，跟那些数据类型相似，我们可以直接使用它，用途就是弹出一个对话框，对话框里面显示的是小括号里面的内容，在这里是一个字符串"Hello Xiao Rou!"。

函数还可以向里面传入参数，函数里面可以调用传入的参数，像alert函数，它所要传入的参数就是一个字符串。我们可以像这样定义一个带参数的函数：

1. function square( x ){
   
2.         var r=x*x;
   
3.         alert(x+"’s square is"+r);
   
4. }

复制代码

这个例子是一个square函数，它有一个参数x，功能就是求x的平方，并且用alert显示出来。参数可以有多个，它们之间用逗号隔开。

函数还可以有返回值，所谓返回值，可以看做函数运行结束后就变成了一个值，用法如下：

1. function power( x , n ){
   
2.         var r=1;
   
3.         for(var i=1;i<=n;i++){
   
4.                 r=r*x;
   
5.         }
   
6.         return r;
   
7. }

复制代码

函数用return来传出返回值，同时return也是函数的终点，函数内部的语句执行的return的时候就会退出来。这个例子中传入了两个参数x和n，在函数内完成了幂运算，计算出来x的n次幂并储存在了r中，最后返回了r的值。

没有返回值的时候，return也可以单独使用，只起到使函数结束的作用。

另外要注意，函数内部定义的变量在别的地方是不能使用的，这种变量叫做局部变量。同样还有全局变量，是在函数外面定义的，在函数里面也可以使用。

事实上，函数是Function类型的对象。

第七节        运算符
JavaScript 算术运算符

算术运算符用于执行变量与/或值之间的算术运算。

给定 y=5，下面的表格解释了这些算术运算符：

• 运算符        描述        例子        结果
• +        加        x=y+2        x=7
• -        减        x=y-2        x=3
• *        乘        x=y*2        x=10
• /        除        x=y/2        x=2.5
• %        求余数 (保留整数)        x=y%2        x=1
• ++        累加        x=++y        x=6
• --        递减        x=--y        x=4
  

JavaScript 赋值运算符

赋值运算符用于给 JavaScript 变量赋值。

给定 x=10 和 y=5，下面的表格解释了赋值运算符：

• 运算符        例子        等价于        结果
• =        x=y                 x=5
• +=        x+=y        x=x+y        x=15
• -=        x-=y        x=x-y        x=5
• *=        x*=y        x=x*y        x=50
• /=        x/=y        x=x/y        x=2
• %=        x%=y        x=x%y        x=0
  

特别的（我讨厌特别的），+可以连接两个字符串，而且，如果把数字和字符串相加会发生什么呢？可以试试（前面的例子中好像用到了）。

比较运算符

比较运算符在逻辑语句中使用，以测定变量或值是否相等，它们的返回值是一个布尔型的数据。

给定 x=5，下面的表格解释了比较运算符：

• 运算符        描述        例子
• ==        等于        x==8 为 false
• ===        全等（值和类型）        x===5 为 true；x==="5" 为 false
• !=        不等于        x!=8 为 true
• >        大于        x>8 为 false
• <        小于        x<8 为 true
• >=        大于或等于        x>=8 为 false
• <=        小于或等于        x<=8 为 true
  

逻辑运算符

逻辑运算符用于测定变量或值之间的逻辑，它们的返回值是一个布尔型的数据。

给定 x=6 以及 y=3，下表解释了逻辑运算符：

• 运算符        描述        例子
• &&        and        (x < 10 && y > 1) 为 true
• ||        or        (x==5 || y==5) 为 false
• !        not        !(x==y) 为 true
  

总之，这两种都是用来进行逻辑判断的。

最后，还有一种~特~殊~的~运算符，? : 。

1. variablename=(condition)?value1:value2

复制代码

这个格式很，，，总之我不经常使用，因为它的功能完全可以用if else来代替，例如：

1. greeting=(visitor=="PRES")?"Dear President ":"Dear ";

复制代码

如果变量 visitor 中的值是 "PRES"，则向变量 greeting 赋值 "Dear President "，否则赋值 "Dear"。

不过这东西形式短小精悍，特别适合用在填空的地方，（比如游戏的伤害公式里面，有人这么用过）。

第八节        判断语句
if...else...语句

上一节的最后的例子，实际上可以写成if else形式的，如下所示：

1. if(visitor=="PRES"){
   
2.         greeting="Dear President ";
   
3. }else{
   
4.         greeting="Dear ";
   
5. }

复制代码

如果if后面的小括号里面的条件满足的话（实际上是条件结果是true的话）就执行后面的大括号里面的部分，否则就执行后面的else大括号里面的部分。

如果我们不需要考虑否则的结果，那么可以只写if部分，例如：

1. if(visitor=="PRES"){
   
2.         greeting="Dear President ";
   
3. }

复制代码

或者，我们还想再加一种条件，我们就可以在中间在添加else if部分，例如：

1. if(visitor=="PRES"){
   
2.         greeting="Dear President ";
   
3. }else if(visitor=="CHAI"){
   
4.         greeting="Dear Chairman ";
   
5. }else{
   
6.         greeting="Dear ";
   
7. }

复制代码

else if后面也可以不加else，直接结束。

如果，我们还想再加一种条件，我们还可以在中间添加else if部分，例如：

1. if(visitor=="PRES"){
   
2.         greeting="Dear President ";
   
3. }else if(visitor=="CHAI"){
   
4.         greeting="Dear Chairman ";
   
5. }else if(visitor=="MANA"){
   
6.         greeting="Dear Manager ";
   
7. }else{
   
8.         greeting="Dear ";
   
9. }

复制代码

如果我们还想再添加条件，就可以再继续添加else if部分。

switch语句

不断的添加else if虽然也可以解决问题，但是还是显得太繁琐。而且，我们的这些条件都是对同一个变量的值进行判断，那么我们就可以使用switch语句了，上面的例子可以这样写：

1. switch(visitor)
   
2. {
   
3. case "PRES":
   
4.   greeting="Dear President ";
   
5.   break;
   
6. case "CHAI":
   
7.   greeting="Dear Chairman ";
   
8.   break;
   
9. case "MANA":
   
10.   greeting="Dear Manager ";
    
11.   break;
    
12. default:
    
13.   greeting="Dear ";
    
14. }
    

复制代码

switch会将变量与每个case后面的值进行比较，如果相同就执行这个case后面的语句，其中的break的作用是阻止自动的执行下一个case，可以去掉，但是建议不要乱去掉。最后的default也像是最后的else，如果前面的case都不成立，就执行这部分的语句，我们可以删去default，这样前面都不成立的时候会直接退出switch，执行后面的语句。

同样case可以有很多个。

第九节        循环

循环，可以帮你重复相同的工作。

for循环

JavaScript里面最常用的一种循环就是for循环，如果我们要依次输出一个数组里面的值，那么我们当然可以依次使用alert语句，如下所示：

1. var ary=[5,6,7,8,9];
   
2. alert(ary[0]);
   
3. alert(ary[1]);
   
4. alert(ary[2]);
   
5. alert(ary[3]);
   
6. alert(ary[4]);

复制代码

这样就可以完成目标了，但是，如果这个数组里面有100个对象，这样几乎就是不可能完成的（我是不会干这种傻事的，但是录入数据的人，，，可能经常干这种事，请不要对人家说这句话，更不要说是我说的）。

对于这种情况，我们用for语句来完成，如下：

1. for(var i=0 ; i<5 ; i++){
   
2.         alert(ary[i]);
   
3. }

复制代码

我们可以看到，for里面有三个语句，用分号隔开。第一句是在循环开始前执行的。中间一句是在每次循环前判断是否满足条件的，如果满足这个条件，就进行此次循环，否则退出。最后一句是在每次循环结束后进行的语句。

也就是说，可以这样来写：

1. var i=0;
   
2. for( ; i<5 ; ){
   
3.         alert(ary[i]);
   
4.         i++;
   
5. }

复制代码

此处注意这么一点，大括号内声明的变量都算是局部变量，外面是不可以直接使用的，而且像上一个例子，for后面的小括号里面声明的var i=0也是局部变量，外面不能用。而这个例子的i是在外面声明的，所以可以用。这种情况叫做变量的作用域，变量只在声明的作用域内有效。

还有，什么也没有的语句是空语句，也算是一个语句;;;;;;;;;;

中间的i<5，这个语句其实也可以省略掉的，那么就会变成这样的情况：

1. var i=0;
   
2. for( ; ; ){
   
3.         if(i<5){
   
4.                 alert(ary[i]);
   
5.                 i++;
   
6.                 continue;
   
7. }else{
   
8.         break;
   
9. }
   
10. }

复制代码

遇到break语句会直接跳出循环，遇到continue语句会直接开始下一次循环。嗯，这样的话，for就成了一个单纯的循环节。尽量不要这么自找麻烦的使用for循环……

这种依次访问一个数组的每个数据的行为，我们叫做遍历，还可以使用这样的语句：

1. for(var i in ary){
   
2.         alert(ary[i]);
   
3. }

复制代码

注意，这东西虽然看着简单，但是实在不太靠谱，尽量不要用。

while循环

while 循环会在括号内条件为真时循环执行里面的代码，用法如下：

1. var i=0;
   
2. while (i<5){
   
3.   alert(ary[i]);
   
4.   i++;
   
5. }

复制代码

一样可以达到上面的效果。

另外，还可以先循环一次，再判断条件，这就是do while循环，和while循环一样，也是括号内条件成立的话就执行循环里面的代码，用法如下：

1. var i=0;
   
2. do{
   
3.   alert(ary[i]);
   
4.   i++;
   
5. } while (i<5);

复制代码

注意，这里的while结束后要加分号。

break语句和continue语句一样可以使用在这两种循环里面。

第十节        错误

当 JavaScript 引擎执行 JavaScript 代码时，会发生各种错误：可能是语法错误，通常是程序员造成的编码错误或错别字。也可能是拼写错误或语言中缺少的功能（可能由于浏览器差异）。还可能是由于来自服务器或用户的错误输出而导致的错误。

当然，也可能是由于许多其他不可预知的因素。

总之，错误是不可避免的，我们需要考虑一种能够抛出错误的手段，就像电脑坏了会显示蓝屏的错误信息，计算器除以零的时候会报错一样。

我们用throw抛出错误信息，看下面的这个例子：

1. function divide(arg1 , arg2){
   
2.         if(arg2==0){
   
3.                 throw "divided by zero is not allowed";
   
4. }else{
   
5.         return arg1/arg2;
   
6. }
   
7. }

复制代码

throw会抛出错误信息，并且立即退出函数。

我们知道了错误信息，还需要把它显示出来。我们使用try catch语句来处理捕捉到的错误，如下：

1. var r;
   
2. try{
   
3.         r=divide(50,0);
   
4. }catch(err){
   
5.         alert(err);
   
6. }
   
7. if(r!=null) alert(r);

复制代码

这里使用try catch捕捉到了错误信息，并且放在了err里面，然后由alert输出了错误信息。

另外，try catch的使用，永远应该放在你的控制范围之内，而不应该防范未知的错误。也就是说你很清楚知道这里是有可能出错的，而且你很清楚知道什么前提下会出错，你就是要故意利用报错信息来区分错误，后续的程序会解决所有的出错，让程序继续执行。

简而言之，这个东西是用来区分错误的类型并且处理它的，其他情况下，有些不是很需要用这个语句。