js005-引用类型

1、 new

2、对象字面量

var obj1 = new Object();

obj1.name = "meimei";

var person{

name : "meimei";

   age : 18;

      }

var person = {}

person.name = "meimei";

person.age = 18;

1、使用Array构造函数

var colors = new Array();

var colors = new Array(20);//数组长度为20

var colors = new Array(“gread”);

//省略new操作符

var colors = new Array(3);

var name = Array("gread");

2、使用数组字面量表示方法

var colors = ["red", "blue", "yellow"];   //创建一个包换3个字符串的数组

var names = [];               //创建一个空数组

var values = [1,2，];           //别这样做，这样会创建一个2或者3项的数组。

var options = [,,,,];         //别这样，这样会创建一个5或者6项的数组

var colors = ["red", "blue", "yellow"];

alert(colors[0]);           //显示第一项

colors[2] = "black";        //修改第三项

colors[3] = "green";        //新增第四项

var colors = ["red", "blue", "yellow"]; //创建一个包含三个字符串的数组

alert(colors.toString());       //red,blue,green

alert(colors.valueOf());        //red,blue,green

alert(colors);                //red,blue,green

var colors = new Array();

var account = colors.push("red", "black");

alert(account);   //2

account = colors.push("yellow", "pink");

alert(account);   //4

var item = colors.pop();

alert(item);   //pink

var colors = new Array();

var account = colors.push("red", "black");

alert(account);   //2

account = colors.push("yellow", "pink");

alert(account);   //4

var item = colors.shift();

alert(item);   //red

alert(colors.length);

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

values.reverse();

alert(values);

反转数组项的顺序

var values = [1,20,10,36,5];

values.sort();

alert(values);   //1,10,20,36,5

sort()方法是进行升序排序。是进行字符串比较。会先调用toString()方法。一般不是最佳的方法。一般sort()方法接收一个比较函数作为参数比较好。

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

var colors2 = colors.concat("yellow" , ["red", "green", "blue"]);

alert(colors);  //red,green,blue

alert(colors2);  //red,green,blue,yellow red,green,blue

concat()方法

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

var colors2 = colors.slice(1);

var colors3 = colors.slice(1,2);

alert(colors2);  //green,blue

alert(colors3);  //green

slice()

传入1，表示从数组下标为1的开始；

传入1,2表示从1开始到2结束

删除

可以删除任意数量的项，指定两个参数：要删除的第一项的位置和要删除的项数。如：splice(0, 2);  表示删除前两项

插入

可以向指定位置插入任意数量的项，提供三个属性：起始位置，0（要删除的项），要插入的项。如：splice(2, 0, “green” , “red”);

替换

可以向指定位置插入任意数量的项，同时删除任意数量的项。提供三个属性：起始位置，要删除的项，要插入的项。如：splice(2,2, “green” , “red”);在第二个位置（包括该项），删除两项后，插入green和red。

indexOf()

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

alert(numbers.indexOf(4));    //3

alert(numbers.lastIndexOf(4));    //5

alert(numbers.indexOf(4, 4));    //5

alert(numbers.lastIndexOf(4, 4));    //3

var person = {name ："meimei"};

var people = [{name ："meimei"}];

var morePeople = [person];

alert(people.indexOf(person));    //-1

alert(morePeople.indexOf(person))    //0

lastIndexOf()

every()

对数组中的每一项运行给定函数，如果该函数每一项都返回true则返回true

filter()

对数组中的每一项运行给定函数，返回函数会返回true的项组成的数组

forEach()

对数组中的每一项运行给定函数，没有返回值

map()

对数组中的每一项运行给定函数，返回函数每次调用的结果组成的数组

some()

对数组中的每一项运行给定函数，如果该函数对任意一项返true，则返回true

reduce()    reduceRight() 两种方法。相同点：

都会迭代数组的所有项，然后构建一个最终返回的值。都接收两个参数：一个在每一项上调用过得函数和（可选）作为归并基础的初始值。传给这两个函数接收的4个参数：前一个值、当前值、项的索引和数组对象。函数返回的任何值都会被作为第一个参数自动传给下一项。第一次迭代发生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数是数组的第二项；

reduce()

从第一项开始，逐个遍历到最后

reduceRight()

从最后一项开始，逐个遍历到最前面

var start = +new Date();

//调用函数

dosomething();

//取得停止时间

var stop = +new Date();

       result = stop - start;

toDateString()

以特定于实现的格式显示星期几、月、日、年

toTimeString()

以特定于实现的格式显示时、分、秒、时区

toLocaleDateString()

以特定于地区的格式显示星期几、月、日、年

toTimeeDateString()

以特定于实现的格式显示时、分、秒

toUTCString()

以特定于实现的格式完整的UTC日期

方法

说明

g

表示全局(global)模式，即模式将被英语与所有字符串，而非在发现第一个匹配项时立即停止；

i

表示不区分大小写(case-insensitive)

m

表示多行（multiline）模式

global

布尔值，表示是否设置了g标志

ignoreCase

布尔值，表示是否i标志

lastIndex

整数，表示开始搜索下一个匹配项的字符位置，从0算起

multiline

布尔值，表示是否设置了m标志

source

正则表达式的字符串表示，按照字面量的形式而非传入构造函数的字符串欧式返回。

           var text = "mom and dad and baby";

           var patttern = /mom(and dad(and baby)?)?/gi;

           var matches = patttern.exce(text);

           alert(matches.index);  //0

           alert(matches.input);  //"mom and dad and baby"

           alert(matches[0]);     //"mom and dad and baby"

           alert(matches[1]);     //"and dad and baby"

           alert(matches[2]);     //"and baby"

长属性名

短属性名

说明

input

$_

最近一次要匹配的字符串。Opera为实现此属性

lastMatch

$&

醉经一次的匹配项，Opera未实现此属性

lastParen

$+

最近一次匹配的捕获组。Opera未实现此属性

leftContext

$’

input字符串中的lastMatch之前的文本

multiline

$*

布尔值，表示是否所有表达式都是使用多行模式。IE和Opera未实现此属性

rightContext

$’

Input字符串中的lastMatch之后的文本

匹配字符串开始和结尾的\A  和\Z 锚

向后查找（lookbehind）

并集和交集类

原子组

Unicode支持（单个字符除外）

命名的捕获组

s （single 单行）和x（free-spacing 无间隔）匹配模式

条件匹配

正则表达式注释

function add(num1 , num2){

                    var sum = num1 + num2;

                    return sum;

             }

function addSomeNunber(num){

       return num + 100;

}

function addSomeNunber(num){

       return num + 200;

}

var result = addSomeNunber(100);  //300

var addSomeNunber = function(num){

              return num + 100;

}

var addSomeNunber = function(num){

              return num + 200;

}

var result = addSomeNunber(100);  //300

这两个例子声明了两个同名函数，结果是后面的函数覆盖了前面的函数。

alert(sum(10,10));

function sum(num1,num2){

       return num1 + num2;

}

alert(sum(10,10));

var sum = function(num1,num2){

       return num1 + num2;

};

function factorial(num){

       if (num <= 1) {

              return 1;

       }else {

              return num * factorial(num - 1);

       }

}

如果函数名不变的话，这个方法是正确的。但是问题是这个函数的执行与函数名factorial紧密耦合在一起，未消除这种现象可以使用一下arguments.callee。

function factorial(num){

       if (num <= 1) {

              return 1;

       }else {

              return num * arguments.callee(num - 1);

       }

}

在重写的函数体内没有引用函数名factorial，这样无论函数名使用什么样的名字，都可以保证正常完成递归调用

function sayName(name){

       alert(name);

}

function sum(num1 , num2){

       return num1 + num2;

}

function sayHi(){

       alert("hi");

}

alert(sayName.length); //1

alert(sum.length);     //2

alert(sayHi.length);   //0