javascript 4-5章2

var color=["red","blcak","yellow","blue"];

var removed=color.splice(0,2);   //从位置0开始，删除2个项。

alert(color);  //yellow,blue

alert(removed);  //red,black

var color=["red","blcak","purple"];

var removed2=color.splice(1,0,"white","orange");  //从位置1开始，删除0个项，并在删除项后添加“white”,"orange"

alert(color);  //red,black,white,orange,purple

根据项找位置

var num=[1,2,3,4,5,4,3,2,1];

alert(num.indexOf(4));  //3  找项4，从前往后找

alert(num.indexOf(4,4);  //5   找项 为4,从位置4往后找

alert(num.lastIndexOf(4));  //5   找项4，从后往前找

alert(num.lastIndexOf(4，4));  //3   找项 为4,从位置4往前找

var num=99;

alert(num.toFixed(3));  //99.000(四舍五入 保留三位小数)

Math.floor(num)  //舍去 保留整数

Math.ceil(num)  //入  保留整数

Math.round(num)   //四舍五入 保留整数

var num=[1,2,3,4,5,4,3,2,1];

every()  //如果该函数对每一项都返回true，则返回true

var everyResult=num.every(function(item,index,array){

return  (item>2);

});

alert(everyResult);  //false

var num=[1,2,3,4,5,4,3,2,1];

some()  //如果该函数对任一项返回true,则返回true

var someResult=num.some(function(item,index,array){

return(item>2);

});

alert(someResult);  //true

var num=[1,2,3,4,5,4,3,2,1];

fliter()  //返回一个数组，返回该函数返回该函数返回true的项组成数组

var filterResult=num.filter(function(item,index,array){

return(item>2);

});  //[3,4,5,4,3]

var num=[1,2,3,4,5,4,3,2,1];

map()  //返回一个数组，返回在原始数组的项上运行函数后的数组

var mapResult=num.map(function(item,index,array){

return(item*2);

});  //[2,4,6,8,10,8,6,4,2]

var num=[1,2,3,4,5];

reduce（）和reduceRight（）

var sum=num.reduce(function(pre,cur,index,array){

return pre+cur;

});

alert(sum);  //15   第一次迭代pre=1  cur=2   pre+cur=3=第二次迭代的pre;  第二次迭代：pre=3 cur=3  pre+cur=6=第3次迭代的pre,依次计算sum=15

获取对象的时间戳

var srart =Date.now();

dosomething();

var stop=Date.now();

result stop-start;

获取当前时间

var date=new Date();

比较日期值

var date1=new Date(2017,0,1);  // "January 1,2017"

var date2=new Date(2017,1,1);  //"February 1,2017"

alert(date1<date2); //true

alert(date1>date2); //false

date1.toDateString();   //星期几 月 日 年

function getWeek(date) {

var arr = ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"];

console.log(arr[newDate().getDay()]);

let obj = {

"0": "星期日", "1": "星期一", "2": "星期二", "3": "星期三", "4": "星期四", "5": "星期五", "6": "星期六"

}

console.log(obj[newDate().getDay()]);

}

getWeek();

getFullYear();

getMonth();

getDate();

getHours();  //获取24小时的时间

getMinutes();

getSeconds();

getUTCFullYear();

getUTCMonth();

getUTCDate();

getUTCHours();  //获取24小时的时间

getUTCMinutes();

getUTCSeconds();

getUTCMillionsecond();

设置时间，如上面

setFullYear();

正则表达式

g  //全局变量

i //不区分大小写

m //在到达一行文本末尾时会继续查找下一行中是否存在与模式匹配的项

所有元字符都需要转义

元字符：（【 { \ } 】） ^ $ | ? * + .

var a=/\.at/i  //   在转义字符前加 \

var b=/\.at/gi  //匹配所有以 .at 结尾的字符的组合，不区分大小写

var b=/.at/gi  //匹配所有以 at 结尾的3个字符的组合，不区分大小写

var c=/[bc]at/  //匹配第一个“bat”或“cat”

var c=new RegExp("[bc]at","i");

function sum(value1,value2){

return value1+value2

}

alert(sum(10,10));//20

var anothersum=sum//使用不带圆括号的函数名是访问函数指针，而非调用函数

alert(anothersum(10,10));

sum=null;//即使将sum设置为null，让它与函数断绝联系，但仍可以正常调用anothersum

alert(anothersum(10,10));

function sum(num1,num2){

return num1+num2;

}

构造函数:函数名首字母大写，构造函数的作用：创建

function Animal（name，age）{

this.name=name;

this.age=age;

this.a= age>=3?"老了"："年轻"；

}

var cat=new Animal("小猫"，"2");  //构造函数的调用

var dog=new Animal("小狗"，"4");

函数声明提升，函数表达式不会提升。

1、函数声明提升

alert(sum(10,10));

function sum(num1,num2)

{return num1+num2;}

2、函数表达式不会提升

alert(sum(10,10));

var sum=function (num1,num2)

{return num1+num2;};  // 函数末尾有一个分号，就像其他变量时一样。

function fun1(name){

return {

"nameqq":name

}

}

function fun2(func,arg) {

return func(arg);

}

console.log(fun2(fun1,"臭笨"))

var yue = fun1("lele");

function fun1(yue) {

return {

name: yue

}

}

console.log({ name:"lele" });

function fun2() { }

function callfunction(someFunction,someArgument){

return someFunction(someArgument);

}

function add(num){

return num+10;

}

alert(callfunction(add,10));  //20

有一个对象数组，根据对象的属性对数组进行排序。

function compare(propertyName){

return function(object1,object2){

var value1=object1.propertyName;

var value2=object2.propertyName;

if(value1<value2){

return -1;}else if(value1>value2){

return 1;}else{return 0;}

}}

var arr=[{name:"qq",age"2"},{name:"aa",age:5}];

arr.sort(compare("name"));

alert(arr[0].name);  //aa

arr.sort(compare("age"));

alert(arr[0].age);  //aa

阶乘函数一般都会用到递归算法

function factorial(num){

if(num<=1){

return 1;

}else{

return num*factorial(num-1);

}

}

消除耦合

function factorial(num){

if(num<=1){

return 1;

}else{

return num*grgument.calee(num-1);

}

}

消除耦合后方便使用实例

var antherFactorial=factorial;

var factorial=null;

alert(antherFactorial(5));  //120

alert(factorial(5));  //0

var color="red";

var o={color:"blue"};

function sayColor(){

alert (this.color);

}

sayColor()  //red

o.sayColor=sayColor;  //把函数赋给对象o

o.sayColor();  //blue

caller 保存着调用当前函数的函数的引用，实例中警告框中显示outer函数的源代码。因为outer()调用了inner（），所以inner.caller就指向outer（）。（为了实现耦合可以把inner.caller改成argument.callee.caller）

function outer(){

return inner();

}

function inner(){

alert(inner.caller);

}

outer();

比较形参和实参个数是否一致，即比较arguments.length是否等于arguments.callee.length

传递参数

1、apply()   //在特定作用域中调用函数，实际上等于设置函数内this的值，都有两个参数，第一个参数是在其中运行函数的作用域，另一个参数是数组（可以是arry的实例，也可以是arguments对象），

2、call()   //在特定作用域中调用函数，实际上等于设置函数内this的值，第一个参数是在其中运行函数的作用域，其余参数都直接传递给函数

3、  bind()

apply()

function sum（num1，num2）{

return num1+num2;

}

function callSum1(num1，num2){

  return sum.apply(this, arguments);  //传入arguments对象

}

function callSum2(num1，num2){

  return sum.apply(this, [num1,num2]);  //传入数组

}

alert(callSum1(10，10));  //20

alert(callSum2(10，10));  //20

call()

function sum（num1，num2）{

return num1+num2;

}

function callSum1(num1，num2){

  return sum.call(this, num1，num2);  //传递给函数的参数必须都列举出来

}

alert(callSum1(10，10));    //20

扩充作用域(最大好处就是对象不需要与方法有任何耦合关系)

window.color=“red”;

var o={color:"blue"};

function saycolor(){

alert(this.color);

}

saycolor();  //red

saycolor().call(this);  //red

saycolor().call(windows);  //red

saycolor().call(o);  //blue

o.saycolor=saycolor;

o.saycolor();  //blue

不建议实例化number和bolean类型，原因是在使用type()和intanceOf()测试基本类型和引用类型数值时得到的结果完全不同。

var numObj=new number(10);

var numvalue=10;

alert(typeOfnumObj )；  //object

alert(typeOf numvalue)；  //number

alert(numObj  intanceOf  number)；  //true

alert(numvalue intanceOf  number)；  //false

var value1=“hello world”；

slice(3) // lo world 从第三位开始向后获取

slice(3,7)  //lo wo  获取位置（3到7之间）

slice(3,-4)  // lo w  获取位置3 到-4（-4不算）之间

substr(3) // lo world 从第三位开始向后获取

substr(3,7)  //lo worl  从位置3开始，共获取七个字符

substr(3,-4)  // “”空字符串  把-4转换成0

substring(3) // lo world 从第三位开始向后获取

substring(3,7)  //lo wo  获取位置（3到7之间）

substring(3,-4)  // hel  把-4转换为0，把较小的数作为开始位置,所以:

substring(3,-4)=substring(0,3)

var string="qqqe wrte ";

var arr=new Array();

var pos=string.indexOf("e");

if(pos>-1){

arr.push(pos);

var position=string.indexOf("e" ，pos+1);

}

trim()  //删除前置和后缀的空格，

var value="   ww"  

var trimevalue=value.trim();

alert(value);  //"  ww"

alert(trimvalue);  //"ww"

var string="hello"

alert(string.toLocalUpperCase());  //HELLO  转换为大写

alert(string.toLocalLowerCase());  //hello   转换为小写

字符串的模式匹配法

1、match（）只接受一个参数(正则表达式/RegExp对象)，返回项

var text="cat,bat,sat,fat";

var pa=/.at/;

var matches=text.match(pa);

alert(matches.index);//0

alert(matches[0])//"cat"

alert(matches)//cat

2、search()只接受一个参数（字符串或regExp对象指定的正则表达式）,返回第一个匹配的索引，如果没找到匹配项，则返回-1，始终是从字符串开头向后查找。

var text="cat,bat,sat,fat";

var pos=text.search(/at/);

alert(pos); //1

3、replace() 两个参数，第一个参数：正则表达式/字符串，第二个参数字符串/函数。

var text="cat,bat,sat,fat";

var result=text.replace("at","ond");

alert(result);//"cond,bond,song,fond"

var result2=text.replace(/at/g,"ond");

alert(result2);//"cond,bond,song,fond"

4、split()

var color="red,blue,green";

var color1=color.split(",");  //["red","blue","green"]

var color2=color.split(",",2);  //["red","blue"]

var color3=color.split(/[^\,}+/);  //["","",""]

5、localeCompare()

(1)var color="yellw" 首字母与比较字符串的首字母比较，若应该在后面，则返回1；若相等，则返回0,；若应该排在前面，则返回-1.大写字母排在小写字母后面。

      alert(color.localeCompare("blue"));   //1  

       alert(color.localeCompare("ypp"));   //0

       alert(color.localeCompare("zo"));   //-1

(2)确保代码在任何视线中都可以运行，用下面的代码：

var color="yellw"

function a(value){

var result=color.localCompare(value);

if(result<0){

}else if(result>0){

}else{

}

}

a("blue");

a("ypp");

a("zo");

6、URI编码方法

     encodeURI()不对特殊字符进行编码

     encodeURIComponent（）对任何非标准字符都编码

     decodeURI( )  解码，对应encodeURI（）

    decodeURIComponent( )  解码，对应decodeURIComponent（）

7、eval()只接受一个参数，且参数一定是字符串,不会被提升。

1、var msg="hello";

eval("alert(msg)");  //hello

2、eval（function sayHi({

alet("hello");

}）；

sayHi();

8、创建一个立即调用的函数

var a=function(){

return this;

}();

9、Math();首字母大写

var num=[1,2,3,4,5];

var max=Math.max.apply(Math,num);  //最大值 ，关键是把Math对象作为apply()的第一个参数，从而正确的设置this,然后将数组作为第二个参数。

min  //最小值

ceil  //入

floor  //舍

round  //四舍五入

random  //返回0<= Math.random() <1

选择一个介于1到10之间的值

var num=Math.floor(Math.random()*10+1);

选择一个介于2到10之间的值

var num=Math.floor(Math.random()*9+2);

function a(lowerValue,upperValue){

var num=upperValue-lowerValue+1;

var result=Math.floor(Math.random()*num+lowerValue);

}

var b=a(2,10);

alert(num);  //介于2到10之间的数

var colors=["red","blue","green","black"];

var color=colors[a(0,colors.length-1)];

alerrt(color);  //可能是数组中任何一项