好好学一遍JavaScript 笔记(二)

 

/**
  * encodeURI跟encodeURIComponent的区别在于encodeURI不对
  * 特殊字符进行编码如：冒号、前斜杠、问号和英镑符号.
  * 而encodeURIComponent则对它发现的所有非标准字符进行编码.
  */
 var d = "古道西风";
 //这样的URL在后台转码获取过后就可以解决get方式提交的乱码问题了.
 <%--var url = "<%=path%>/users.action?name="+encodeURI(d);--%>
 //后台action或者servlet这样转码获取
 //String Name=new String(URLDecoder.decode(request.getParameter("name"),"utf-8"));

 alert(encodeURI(d));
 alert(encodeURIComponent(d));

 /**
  * 自然还有解码方法：decodeURI跟decodeURIComponent
  *
  */
 alert(decodeURI(encodeURI(d)));
 alert(decodeURIComponent(encodeURIComponent(d)));

javaScript——Math：

/**
  * 判断一组数中的最大值
  */
 var iMax = Math.max(3,5,56,7,13,79);
 alert(iMax);

 /**
  * 判断一组数中的最小值
  */
 var iMin = Math.min(3,5,56,7,13,79);
 alert(iMin);

 /**
  * 返回数字的绝对值
  */
 alert(Math.abs(-9));

/**
  * 把小数舍入成整数
  * ceil 表示向上取整
  * round 常规、4舍5入
  * floor 表示向下取整
  */
 alert(Math.ceil(25.1));  //out26
 alert(Math.round(25.6));  //out26
 alert(Math.floor(25.9));  //out25

//常数；一个用作自然对数的底的数学常数，表示为 e。e 的近似值为 2.718281828459045。
//alert(Math.E);
/**
 * exp()方法用于把Math.E升到指定的幂(mi)
 * log()方法用于返回特定的数字的自然对数
 * pow()方法用户把指定的数字升到指定的幂
 * sqrt()返回指定数字的平方根
 * acos(x)       返回x的反余弦值
 * asin(x)       返回x的反正弦值
 * atan(x)       返回x的反正切值
 * atan2(y,x)    返回y/x的反余弦值
 * cos(x)        返回x的余弦值
 * sin(x)        返回x的正弦值
 * tan(x)        返回x的正切值
 */
alert(Math.log(Math.exp(12)));

alert(Math.pow(2,10));  //1024

/**
 * 数字的平方根就是它的2/1次幂
 * 2的2/1次幂就是2的平方根
 */
alert(Math.sqrt(4));

/**
  * Math的random()方法
  * 该方法返回0到1之间的随机数、不包括0和1
  */
 alert(Math.random());

 /**
  * 返回iFirstValue到iLastValue的之间(包括)的随机数
  * @param {Object} iFirstValue 起始值
  * @param {Object} iLastValue 结束值
  * @return {TypeName}
  */
 function selectFrom(iFirstValue,iLastValue){
     var iChoices = iLastValue - iFirstValue + 1 ;
     return Math.floor(Math.random() * iChoices + iFirstValue) ;
 }
 //返回1到9的随机数、包括1跟9
 alert(selectFrom(1,9));

 /**
  * 随机获取数组中的元素
  */
 var array = new Array(45,452,451,4,42,437,343);
 alert(array[selectFrom(0,array.length-1)]);

javaScript——创建对象(Object)：

类工厂方式：

/**
  * 类工厂
  */
 function createCar(sColor,iDoors,iMpg){
     var oTempCar = new Object;
     oTempCar.color = sColor;
     oTempCar.doors = iDoors ;
     oTempCar.mpg = iMpg ;
     oTempCar.showColor = function(){
         alert(this.color);
     };
     return oTempCar ;
 }
 var oCar1 = createCar("red",5,33);
 var oCar2 = createCar("blue",6,23);
 alert(oCar1.color);
 oCar2.showColor() ;

类工厂方式二：

/**
  * 类工厂2
  */
 function showColor(){
     alert(this.color);
 }

 function createCar(sColor,iDoors,iMpg){
     var oTempCar = new Object;
     oTempCar.color = sColor;
     oTempCar.doors = iDoors ;
     oTempCar.mpg = iMpg ;
     oTempCar.showColor = showColor;
     return oTempCar ;
 }
 var oCar1 = createCar("red",5,33);
 var oCar2 = createCar("blue",6,23);
 alert(oCar1.color);
 oCar2.showColor();

构造函数：

/**
  * 构造函数
  * @param {Object} sColor
  * @param {Object} iDoors
  * @param {Object} iMpg
  * @memberOf {TypeName}
  */
 function Car(sColor,iDoors,iMpg){
     this.color = sColor;
     this.doors = iDoors ;
     this.mpg = iMpg ;
     this.showColor = function(){
         alert(this.color);
     };
 }
 var oCar1 = new Car("red",5,33);
 var oCar2 = new Car("blue",6,23);
 alert(oCar1.color);
 oCar2.showColor();

原型方式：

/**
  * 原型方式
  */
 function Car(){
 }
 Car.prototype.color = "red";
 Car.prototype.doors = 2 ;
 Car.prototype.mpg = 23 ;
 Car.prototype.array = new Array(1,2);
 Car.prototype.showColor = function(){
     alert(this.color);
 };
 var oCar1 = new Car();
 var oCar2 = new Car();
 oCar1.color = "blue";
 oCar1.array.push(3,4) ;
 alert(oCar1.color);
 alert(oCar2.color);

 //由于Array是引用值、array都指向同样数组
 alert(oCar1.array);
 alert(oCar2.array);

联合使用构造函数和原型方式：

/**
  * 联合使用构造函数和原型方式、就可像用其他程序设计语言一样创建对象。
  * 这种概念非常简单、即用构造函数定义对象的所有非函数属性、用原型方式定义对象的函数属性(方法)。
  * 结果所有函数都只创建一次、而每个对象都具有自己的对象属性实例。
  */
 function Car(sColor,iDoors,iMpg){
     this.color = sColor;
     this.doors = iDoors ;
     this.mpg = iMpg ;
     this.array = new Array(1,2);
     this.showColor = function(){
         alert(this.color);
     };
 }
 Car.prototype.array = function (){
     alert(this.color);
 };
 var oCar1 = new Car("red",5,33);
 var oCar2 = new Car("blue",6,23);
 oCar1.array.push(4,9);
 alert(oCar1.array);
 alert(oCar2.array);

动态原型方法：

/**
  * 动态原型方法
  */
 function Car(sColor,iDoors,iMpg){
     this.color = sColor;
     this.doors = iDoors ;
     this.mpg = iMpg ;
     if(typeof Car._initialized == "undefined"){
         Car.prototype.showColor = function(){
             alert(this.color);
         };
         Car._initialized = true ;
     }
 }
 var oCar1 = new Car("red",5,33);
 var oCar2 = new Car("blue",6,23);
 alert(oCar1.color);
 oCar2.showColor();

混合工厂方式：

/**
  * 混合工厂方式
  */
 function Car(){
     var oTempCar = new Object;
     oTempCar.color = "red";
     oTempCar.doors = 2 ;
     oTempCar.mpg = 23 ;
     oTempCar.showColor = function(){
         alert(this.color);
     };
     return oTempCar ;
 }
 var oCar1 = new Car();
 var oCar2 = new Car();
 alert(oCar1.color);
 oCar2.showColor();

利用json创建对象：

/**
  * 利用json创建对象
  */
 var Car = {};
 Car.color = "red";
 Car.doors = 2;
 Car.mpg = 23;
 Car.array = new Array(1,2);
 Car.showArray = function(){
   alert(this.array);
 };
var oCar = Car;
oCar.showArray();

目前使用最广泛的是混合的构造函数/原型方式。此外、动态原型方法也很流行、
在功能上与构造函数/原型方式等价。可采用这两种方式的任何一种、
不过不要单独使用经典的构造函数或原型方式、因为这样会给代码引入问题。