javascript高级语言程序设计五

引用类型:的值是引用类型的一个实例。引用类型是一种数据结构，用于将数据和功能组织在一起，它也常被称为类。
Object类型:
定义方法一
var person =new Object();
person.name="nnoch";
person.age=29;
定义方法二 
         var person ={
  name:"niho";
age:29;
         }
定义方法三 
var person={};
person.name="Nicholas";
person.age=29;


定义方法四:
displayInfo({
name:"BUOFS",
age:36
})
访问方式:
alert(person["name"])
alert(person.name);
Array类型：
定义方式
var colors=new Array();
var colors=new Array("sfs","fsd","vcf");
var colors=new Array(20);
var colors=["red","blue","green"]
var values=[1,2]
方法:
var colors=["red","blue","green"]
alert(colors.length);//3
alert(colors.toString());//red,blue,green
alert(colors.valueOf())//red,blue,green
alert(colors.)//red blue green


var person1={
      toLocaleString:function(){
return "nihao";
      }
      toString:finction(){
return "nihao";
      }
}


var person2={
toLocalString:function(){
return "gif";
}
toString:function(){
return "gih";
}
}


var persons=[person1,person2]
alert(persons.toString());     //nihao gih
alert(persons.toLocalString())// nihao gif




数组集成了toLocaleString(),toString()和valueOf()方法。在默认情况下都会以"逗号"分隔的字符串的形式返回数组项。而如果使用join()方法，则可以使用不同的分隔符来构建这个字符串。
var colors =["red","blue","green"]
alert(colors.join(","));  /red,blue,green
alert(colors.join("||")); //red||blue||green
数组构建栈:先进后出,后进先出 push() 入栈  pop()出栈
var colors =new Array();
colors.push("red","blue");
                colors.push("black")
   
       top--> black
blue
bottom--> red
var color=colors.pop();
      alert(color);  //black


top--> blue
bottom--> red


2 数组构建队列:push()入栈 shift();出队列  unshift():入队列
var colors =new Array();
colors.push("red");
colors.push("blue");
colors.push("black");

top-->    red
 blue
bottom--> black


var color=colors.shift();
alert(color);   //red

top-->    red
 blue
bottom--> black
    var colors =new Array();
colors.unshift("red","green");
colors.unshift("black");

top-->    green
 red
bottom--> black
var color=colors.pop();
alert(color);//green

top-->     red
bottom--> black


var values=[1,2,4,5,8]
values.reverse();//1 2 4 5 8
var values=[2,4,6,19.5]
values.sort();  //2,4,5,6,19




也可以用比较器
function compare(value1,vavlue2){
 if(value1<value2){
return 1;
  }else if(value1>value2){
return -1;
}else{
return 0;
}
}


var values=[ 1,5,3,7,18]
values.sort(compare);
alert(values);  //1 3 5 7 18


操作:
concat():连接
var colors=["red","green","blue"]
var colors2=colors.contact("yellow",["black","brown"]);
alert(colors);   //red,green,blue
alert(colors2);//red green,blue,yellow,black,brown


sclice();取子项集合
var colors=["'red","green","blue","yellow","purple"]
var colors2=colors,slice(1);//green,blue,yellow,purple
var colors3=colors.slice(1,4);//green,blue,yellow


splice():
删除:splice(0,2);删除头两项
插入:splice(2,0,"red","green");从2的位置插入red,green
替换:splice(2,1,"red","green");从2的位置删掉一项，插入red,green
var colors=["red","green","blue"]
colors.splice(0,1);
alert(colors);//green blue

colors.splice(1,0,"yellow","oragan");
alert(colors);//green yellow orange blue

colors.splice(1,1,"red","purple")
alert(colors); //green red purple orange blue


indexOf()从前往后检查特殊项
lastIndexOf();从后往前检查特殊项
every();对数组中的每一项运行给定函数，如果该函数对每一项都返回true,则返回true
filter();对数组中的每一项运行给定函数，返回该函数返回true的项组成的数组。
foreach();对数组中的每一项运行给定函数，没有返回值。
map();对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。
some();对数组中的每一项运行给定函数，如果该函数对任意一项返回true 则返回true。


var numbers=[1,2,3,4,5,6,7]
var everyResult=numbers.every(
function(item,index,array){
return item>2;
})
alert(everyResult);//false


var somer=numbers.some(){function(item,index,array){
  return item>2;
}}
alert(somer);//true




var subArray=numbers.filter(){
function(item,index,array){
return item>2;
}
}
alert(subArray);//3,4,5,6,7


var mapResult=values.map(function(item,index,array){
  return item*2;
})
alert(mapResult);//[2,4,6,8,10,,12,14]


归并方法:
reduce() 正向归并
reduceRright();逆向归并
var values=numbers.reduce(){
  function(pre,cur,index,array){
return pre+cur;
 }
}
alert(values);//28
var values=numbers.reduceRight(pre,cur,index.array){
return pre+cur;
}
alert(values);//28
Date类型：

var date=new Date();
var date1 = new Date(2007 , 12, 1)


//调用当前时间Date.now()
var start=Date.now();
function add(x,y){return x+y};
console.log(add(5,5));
var stop=Date.now();
alert(stop-start);




//日期事件的基本方法
var date=new Date();
date.getFullYear();//年
date.getMonth();//月
date.getDate();//日
date.getHours()//时
date.getMinutes();//分
date.getSeconds();//秒
date.getMilliseconds();//毫秒

RegExp类型：

g: 表示全局(global) 模式，即模式将被应用于所有字符串，而非在发现第一个匹配项时立即停止;
i: 表示不区分大小写( case-insensitive )模式，即在确定匹配项时忽略模式与字符净的大小写;
m: 表示多行( multiline )模式，即在到达一行文本末尾时还会继续查找下一行中是否存在与模
式匹配的项。


RegExp的实例属性
globa1: 布尔值,表示是否设置了9 标志。
ignoreCase: 布尔值，表示是否设置了i 标志。
1astlndex:整数，表示开始搜索下一个匹配项的字符位置，从0 算起。
mu1ti1ine : 布尔值，表示是否设置了m 标志。
source: 正则表达式的字符串表示，按照字面量形式而非传入构造函数中的字符串模式返回。


var text="mom and dad and baby";
var pattern=/mom (and dad(and baby)?)?/gi;
var matches =pattern.exec(text);
matches.index//匹配字符串的索引位置
matches.input//匹配字符串的正则表达式
matches[0]//mom and dad and baby
matches[1]//and dad and baby
matches[2]//and baby




var text="cat,bat,sat,fat";
var pattern1=/.at/;


var matches=pattern.exec(text);
matches.index//0
matches[0]//cat
matches.lastIndex//0


var matchex=pattern.exec(text);
matches.index//0
matches[0]//cat
matches.lastIndex//0


var pattern2=/.at/g;


var matches=pattern2.exec(text)
matches.index//0
matches[0]//cat
matches.lastIndex//0


var matches=pattern2.exec(text)
matches.index//5
matches[0]//bat
matches.laseIndex//8




var text="0000-000-00";
var pattern=/0{0,4}-0{0,3}-0{0,2}/
if(pattern.test(text)){
  //匹配成功
}


//RegExp的一些属性
input 最近一次匹配的字符串
lastMatch   最近一次匹配的文本
lastParen   最近一次匹配的捕获组
leftContext 最近一次匹配项左边的内容 
rightContext 最近一次匹配项右边的内容
multiline 表式是否所有表达式都使用多行模式


var text="this has been a short summer";
var pattern=/(.)hort/;
if(pattern.test(text)){
  RegExp.input//this has been a short summer
  RegExp.lastMatch//short
  RegExp.leftContext//this has been a 
  RegExp.rightContext//summer
  RegExp.multiline//false
  RexExp.lastParen//s


}


如上所示的RexExp属性也可以通过上面的方式作转换
var text = 'this has been a short summer;
var pattern = /{.)hort/g;


i f (pattern.test(text))) {
alert ( RegExp.$_) ;this has been a short summer
alert (RegExp.$~) ;this has been a
alert(RegExp.$');summer
alert (RegExp.$&);short
alert(RegExp.$+) ;s
al.rt(RegExp.$*);false

Function类型:

function add(num1 ,num2){
  return num1+num2;
}


//
函数声明:js在加载时,已经作了函数提升
函数表达式:js在加载时不做函数提升


add(10,20)//30
function add(num1,num2){
   return num1+num2;
}
---------------------------------
add(10,20)//出错：函数表达式并不做函数提升 
var add=function(num1,num2){
  return num1+num2;
}


值函数
function compareValue(properName){
   return function(object1,object2){
var value1=object1[properName];
var value2=object2[properName];
if(value1>value2){
reutrn 1;
}else if(value1<value2){
return -1;
}else{
return 0;
}
   }
}


var data=
[
{name:'zhangsan',age:'23'},
{name:'lisi',age:'25'}
]


data.sort(compareValue("name"))
date.sort(compareValue("age"))




函数的内部属性
this:当前函数的主调函数
arguments:当前函数的参数
callee:指针，指向拥有参数arguments的函数
caller:指向调用者的指针
call|apply:调用一个函数


//阶乘函数(递归思想)
function  fac(n){
   var result=0;
  if(n<=1){
       result= 1;
  }else{
       result=result*fac(n-1)
  }
}
//如上代码块所示函数紧密耦合在一起，为了消除这样的紧密耦合


function fac(n){
 var result=0;
 if(n<1){
   result = 1;
 }else{
   result=result*arguments.callee(n-1);
 }
  return result;
}


//函数的调用者
function outer(){
  inner();  
}


function inner(){
  alert(arguments.callee.caller);
}


outer();//outer Object


//调用一个函数的两种方法
function add(num1,num2)
{
   return num1+num2;      
}


function callAdd(num1,num2){
   add.call(this,[num1,nume2]);
   add.call(this,arguments);
   add.apply(this.arguments)
}

基本包装类型：
Boolean类型：

var s1=new Boolean(true);
var result=s1&&false;
result instanceof Boolean//true

Number类型:

var num=new Number(10);
num.toString();  //10
num.toString(2); //1010
num.toString(8); //12
num.toString(10); //10
num.toString(16); //a


var num=10
num.toFixed(2) //10.00


var num=99;
num.toPrecision(1); //"1e+2"
num.toPrecision(2); //99
num.toPrecision(3); //99.0
String类型:

slice();
subString();
substr()
indexOf()
lastIndexOf()
toUpperCase()
toLowerCase();
search();
replace();






var stringValue="hello world";
var stringValues="aaa";
alert(stringValue.length)
alert(stringValue.charAt(1))//"e"
alert(stringValue.concat(stringValues))//"hello world aaa"


//字符串截取
var stringValue="hello world";
stringValue.slice(3); //lo world
stringValue.substring(3);//lo world
stringValue.substr(3);// lo world
stringValue.slice(3,7);// lo w
stringValue.substring(3,7);//lo w
stringValue.substr(3,7);// lo worl




substr与substring||slice不一样的地方就是substr(1,2)
的第二个参数表示的是取几个字符


stringValue.indexOf("o");     //4
stringValue.lastIndexOf("o")  //7


var StringValue="Lorem ìpsum dolor sit amet , consectetur adipisicing elit"。
var position =new Array();
int pos=StringValue.indexOf("e");
while(pos>-1){
    position.push(pos);
    pos=StringValue.indexOf("e");
}
position//2,24,32,35,52


//去出空白符
var text=" hello world   ";
var s=text.trim();
alert(s); //hello world


//字符串大小写转化
var test="hello world"
test.toUpperCase()//HELLO WORLD
test.toLowerCase();//hello world


//正则匹配.查找,替换
var text="cat,bat,sat,fat";
var pattern=/.at/;
var matches=text.match(pattern);//cat
var pos=text.search(/at/); //1
var pp=text.replace(/at/g,cond)

Math类型:

Math.abs(num) //返回num的绝对值
Math.exp(num) //返回Math.e的num次幂
Math.log(num) //返回自然对数
Math.pow(num,power) //返回num的power次幂
Math.sqrt(num) //返回num的平方根
Math.acos(x)   //返回x的反余炫值
Math.asin(x)   //返回x的反正炫值
Math.atan(x)   //返回x的反正切值
Math.cos(x)    //返回x的余炫值
Math.sin(x)    //返回x的正炫值
Math.tan(x)    //返回x的正切值