JavaScript

来源：互联网发布：怎么发淘宝链接编辑：程序博客网时间：2024/05/24 01:56

js包含三个部分：

一.核心：ECMAScript

1.语法：

区分大小写

变量时弱类型

分号可有可无

2.变量

变量可以不用初始化：var test;

var aaa="str"; bbb=111;这样是可以的。

三种命名变量的命名规则

Camel：首字母小写，接下来大写

Pascal：首字母大写，接下来也大写

匈牙利类型标记法：小写字母（变量的类型）+Pascal标记

另外：变量不必声明也可以使用。但是最好声明

3.关键字：

break else new var case finally return void catch for switchwhile continue function this with default if in trythrow try do typeof deletewhile instranceof

另外还有保留字：只要是程序中使用的语法关键字，最好不要用。

4.原始值和引用值

原始值：栈

Undefined、Null、Boolean、Number、String.

引用值：堆

5.typeof

五种原始类型：

Undifined类型:当变量没有初始化时，默认值是undefined.————他只有一个值

当函数无明确的返回值时，返回的也是undefined.

Null类型：只有一个值的类型。即字面值。值undefined是从null派生而来。

但是null和undifined 含义不同：

uull是表示尚未存在的对象

undifined是声明了变量但未对其初始化时赋予它的值。

Boolean类型：包含两个值：true和false

Number类型：可以：32位的整数，还可以：64位的浮点数。

String类型：唯一没有固定大小的原始类型。

由16位整数表示。

名词解释：字符串字面量（stringliteral）是指双引号引住的一系列字符，双引号中可以没有字符，可以只有一个字符，也可以有很多个字符。

字符串字面量：由双引号或单引号声明的。

另外还包括几种字符字面量：

6.转换：

ECMAScript：(1)Boolean值(2)数字(3)字符串的原始值都是伪对象。

所以：他们都有：length属性和toString()方法喽。

这里：Number类型的toString()方法比较特殊，可以分为：

(1)默认模式：如：num.toString();

(2)基模式：意思就是可以对一个数转换成他的二、八、十六进制来。

二进制的基：2，八：8；十六：16

部分转换：

另外：转换成数字：

转整：parseInt()和转浮：pareFloat()

注意：只有String类型调用这些方法，才能正确运行，其他类型：返回NaN

函数：1.isNaN()可以判断一个数是不是数字。

parseInt()1234abc将返回1234，1234.999将返回1234,小数点是无效字符。

parseFloat()

强制类型转换：非常有用，不过要确保值的正确性。

(1)Boolean(value)：

空字符串，0，null或undefined ：返回 false

非空非0 对象：返回 true

Number(value)转换成整个值：

(2)如：Number(4.5.6)=NaN

相反，如果字符串值能被完整地转换，Number()将判断是调用parseInt()方法还是调用parseFloat()方法。

Number(false)=0;

Number(true)=1;

(3)String(value) 和toString()方法

唯一不同之处：String(value)：value=null或value=define时不会报错，而toString()报错。

String(null)："null";

null.toString(); error;

下面是引用类型：

1.Object类。所有类的父类。

2.Boolean类。

3.Number类。

创建对象：var anum=new Number(55);

（1）得到对象的Number原始值：var yuannum=anum.valueOf();

（2）返回具有小数位数的数字的字符串表示：（0-20）非常适用于货币。

var numa=new Number(100);

var numb=numa.toFixed(2);//输出100.00

（3）String:这里面的方法要记住，很有用：

1.charAt();

2.concat()连接并保持原来的字符串不变

3.indexOf()和lastIndexOf()indexOf()：从前到后检索lastindexOf()从后到前检索。——检索位置。

4.localeCompare(strAAA)排序，在strAAA前：-1，相同：0，后：正数，1

下面是函数：很重要。

1.参数arguments可以实现原本不能实现的重载。

2.创建Function类

   <scriptlanguage="javascript"type="text/javascript">
    vardoAdd=new Function("num1","alert(num1+100);");
   var doAdd=new Function("num1","alert(num1+10);");
doAdd(10);
  </script> //这里体现了重载

函数也可以当作参数：

Function对象也有与所有对象共享的valueOf()方法和toString()方法。——返回的是函数的源代码。

第三章——对象

一个好习惯：当使用完对象之后：废除对象，objectAAA=null;

一：本地对象

1.Array类。

定义方式

（1）var AAA=new Array(9);或：
（1）var AAA=new Array(); AAA[0]="aaa";AAA[1]="bbb";

（2）var AAA=new Array{"aaa","bbb","ccc"}知道大小和具体的数值。

（3）字面量的形式var AAA=["aaa",'bbb","ccc"]——未明确使用Array类。

方法：

（1）toString()方法和valueOf()方法。

得到的是：用逗号连接的字符串

由此而引申的数组之外的方法:join(",");

（2）concat()——连接

（3）添加项——push("aaa","bbb");可以传递多个参数。

（4）删除最后一项——pop();——返回被删除的那个项。

（5）删除第一项：shift()； ——返回被删除的那个项。

在第一项插入数据，后面的项依次向后挪：unshift("aaa")

（6）颠倒顺序的方法：reverse();

排序的方法：

（7）更加有用的方法：splice()——使用不同的参数就可以达到不同的目的：

a.splice(index,num)——删除从index开始的num位数字

b.splice(index,0,"aaa","bbb")——插入从index开始的字符串"aaa","bbb"

c.splice(index,num,"aaa",...)——替换从index开始的num位字符串为:"aaa","bbb"

Date类：

创建Date对象：var d=new Date();

设置Date对象：（创建时）

（1）只声明1970年1月1日凌晨12点的毫秒数：

var d=new Date(0);

（2）parse()和UTC()两种方法

parse()例子：parse():var d=new Date(Date.parse(May,25,2009));

UTC()：比价好：

var d=new Date(UTC(年，月，日，时，分，秒，毫秒));

注意的是：（1）月份是从0开始的。（2）小时要采用24小时制

比较有用的字符串表示方法：

字符串： d.toLocaleDateString()——日期部分；d.toLocaleDateString() ——时间部分。

Math对象：

这里主要说一下方法：

（1）最大值最小值：

Math.max(num1,num2,num3);

Math.min(num1,num2,num3);

好处：可以避免用for循环来判断大小。

（2）绝对值：Math.abs(num);
（3）等等。。。

以上是系统的对象。而js真正的强大之处在于能够创建自己专用的对象——可以自定义对象。

（1）工厂方式

例子：

var car=new Object();
    car.name="法拉利";
    car.color="红色";
    car.showdes=function()
    {
       alert("法拉利是："+this.color);
    };

    car.showdes();

这只是创建了一个对象，如果想创建很多和这一样的对象，就需要用到工厂方式：

    functioncreatecar(name,color)
   {
       var car=new Object();
       car.name=name;
       car.color=color;
       car.showdes=function()
       {
        alert(this.name+"是："+this.color+"的");
       };
       return car;
   }
   var car=createcar("法拉利","红色");
car.showdes();
  </script>

但是创建对象用一个function，function里面也有function,这样方法里有方法，重复。。。

为了避免这种重复，可以这样：

function showdes(car)
   {
        alert(car.name+"是："+car.color+"的");
   }
    functioncreatecar(name,color)
   {
       var car=new Object();
       car.name=name;
       car.color=color;
       car.showdes=showdes(car);
       return car;
   }
   var car=createcar("法拉利","红色");
car.showdes();

  </script>

把看着重复的方法剥离出来就好了。或：

    functionshowdes()
   {
        alert(this.name+"是："+this.color+"的");
   }
    functioncreatecar(name,color)
   {
       var car=new Object();
       car.name=name;
       car.color=color;
       car.showdes=showdes;
       return car;
   }
   var car=createcar("法拉利","红色");
car.showdes();
  </script>

都是可以的。

缺点是：每次创建一个对象，虽然引用的是同一个函数，但是函数里面的方法却要重复的创建。

要么就是看起来不像是该对象的方法。

（2）构造函数的方式：

function Car(name,color)
   {
          this.name=name;
          this.color=color;
         this.showdes=function()
         {
            alert(this.name+"是："+this.color+"的");
         };
   }
var car=new Car("宝马","白色");
car.showdes();
  </script>

这和上面的工厂模式差不多都是一样的。缺点也是一样的。

（3）原型方法：

function Car(){}

Car.prototype.color="red";

Car.showdes=function AAA(){"aaa"};

但是缺点是：不能传参数；更大的缺点是：由于引用的是同一个对象——原型，所以属性的改变，导致创建的不同的对象之间紊乱。

（4）混合的，牛逼的——构造方法和原型混合的方法

实现的思路是这样的：

属性：用构造方法的形式

方法：用原型的形式

这样：既不会重复创建方法，也解决了所有的属性看起来不是同一个对象的问题。（从语义上讲）

function Car(name,color)
    {
          this.name=name;
          this.color=color;
    }
  Car.prototype.showdes=function()
    {
       alert(this.name+"是"+this.color+"的");
    } ;
    var car=newCar("宝马","白色");
   car.showdes();
  </script>

注意的一点是：有可能重要：因为使用了原型，所以仍然能够利用insanceof运算符来判断对象的类型。

(5)最后一种就是动态的

原型方法：就是在混合的基础上加了一个判断就可以了。

修改对象：也很有趣

prototype属性：无论是自己构造的函数还是本地对象都有一个prototype属性。

0 0