javascript高级程序设计第五章【上】（5.1-5.2）引用类型笔记

5.1Object类型

两种创建Object实例的方式：
new操作符后跟Object构造函数

var person = new Object();
person.name = "yuan";
person.age = 20;

对象字面量表示法（一种简写方式，代码量少，是向函数传递大量可选参数的首选方法，建议使用）

var person = {
    name : "yuan",              //中间用，隔开 不是；
    age : 20,
    sex : "men"               //最后一个属性不用， 其实跟数组是一个道理
}；

向函数传递大量可选参数的例子

function displayIntro(args){
    var result = " ";
    if(typeof args.name == "string"){        //"string"，"number"要用引号，而且是小写
        result += "Name: " + args.name + "\n";
    }
    if(typeof args.age == "number"){
        result += "Age: " + args.age + "\n";
    }
     if(typeof args.sex == "string"){
        result += "Sex: " + args.sex + "\n";
    }
    console.log(result);
}
displayIntro({             //定义一个Object并向函数传递参数
    name : "yuan",
    age : 20,
    sex : "men"
});

“string”，"number"要用引号，而且是小写
自己非常sb的因为忘了这一茬，结果找了好久的错，要牢记
.
（因为上面用到了typeof，所以在这里顺便说一下typeof和instanceof的区别：
typeof只能区分出5种基本类型Null,Undefined,String,Number,Boolean和Object。
typeof a == “string”; //要用引号，首字母小写

instanceof能细致的区分各种引用类型，Array,RegExp正则表达式,Function,Object
console.log(a instanceof Object); //输出一个布尔值，首字母大写
)

5.2Array类型

js跟其他语言的数组都是表示数据的有序列表，但是js的数组更特殊一点，他可以保存任何类型的数据，如字符串，数字，布尔值，对象等

.length反应数组长度，但是还可以根据此性质加减数据

给数组增添了第4项数据

var colors = ["white","red","blue"];
colors[3] = "green";
console.log(colors);    //Array(4)0: "white"1: "red"2: "blue"3: "green"length: 4

或
给数组增添了、第4，5项数据

var colors = ["white","red","blue"];
colors[colors.length] = "green";
colors[colors.length] = "yellow";
console.log(colors);

给数组移除了第3项数据

var colors = ["white","red","blue"];
colors.length = 2;
console.log(colors[2]);          //undefined(若是长度赋值为4，则新加一个数据也是undefined)

.

5.2.3栈方法

后进先出

push()从数组末端进行栈中项的插入,并且返回插入后数组的长度

var colors = new Array();
var count = colors.push("black");
console.log(count);       //1

pop()从数组末端进行栈中项的删除，并且返回删除的项

var colors = ["black","red"];
var item = colors.pop();
console.log(item);           //red

也可以不在方法前创建变量，可以把其当作一个纯方法来使用
这些方法可以和前面的方法共同使用
.

5.2.4队列方法

跟排队一样，先进先出
.shift()移除数组的第一个数据并将返回这个数据
.unshift()从数组首端插入一个数据

.push() .shift()模拟队列

var colors = ["white","black"];
var count = colors.push("red");         //从末端推进red
var item = colors.shift();        //从前端拿走white
console.log(count);           //3
console.log(item);          //white

.pop() .unshift()

var colors = ["white","black"];         
var item = colors.pop();        //从末端将black移除
var count = colors.unshift("green");     //从前端将green移入
console.log(item);       //black
console.log(count);     //2

.

5.2.5重排序方法

.reverse() 将数组项顺序反转

var num = [1,3,8,9,10];
num.reverse();      //将数组项反向
console.log(num);

.sort() 将数组项全化为字符串，再按升序排列这些字符串

var num = [1,3,8,9,10];
num.sort();
console.log(num);   //[1,10,3,8,9]

可知所得结果是按照字符串的升序排列，并非是按照数字的字符排列
若要得到按照数字的顺序排列，则要增加一个判断数字顺序的函数

var num = [1,3,2,8,10];
function compare(num1,num2){
    if(num1 < num2){
	    return -1;
	}else if(num1 > num2){
		return 1;
	}else{
		return 0;
	}
}
num.sort(compare);      //数组num调用.sort()方法，.sort()调用compare函数
console.log(num);      //[1,2,3,8,10]

这是数字的升序排列，若想改为降序，直接再加个.reverse()方法或者是将函数改一下也行
.

5.2.6操作方法

.concat() 创建原数组的一个副本，将收到的参数（可以是数组项也可以是数组）添加到这个副本的末尾，组合成一个新的数组

var colors = ["white","black"];
var colors1 = colors.concat();     //复制一个副本，但没有添加新的数组项
var colors2 = colors.concat("red",["green","yellow"]);     //赋值副本并添加了新的数组项
console.log(colors1);       //["white","black"]
console.log(colors2);       //["white","black","red","green","yellow"]

.slice() 基于原数组的一项或多项创建一个新的数组

var colors = ["white","black","red","green","yellow"];
var colors1 = colors.slice(1,4);     //起始位置1，终止位置4-1
var colors2 = colors.slice(1);      //起始位置1，终止位置数组末端
console.log(colors1);       //["black","red","green"]
console.log(colors2);     //["black","red","green","yellow"]

若给的位置参数是负数，则等于拿数组长度加上这个负数所得的数，例如上面的数组长度是5，则.slice(-2,-1)等价于.slice(3,4),若终止位置小于起始位置则返回空数组
.
.splice()

可以有3个参数，也可以有两个参数，第一个参数是起始位置，第二个是删除元素的个数，第三个是添加的元素

删除

var colors = ["white","black","red","green"];
var remove1 = colors.splice(1,1);    //起始位置为1,删除一个数
console.log(colors);           //["white","red","green"]
console.log(remove1);       //black

插入

var remove2 = colors.splice(1,0,"pink");    //起始位置为1,加入一个数(加入的这个数在数组中的位置为1)
console.log(colors);       //["white","pink","red","green"]
console.log(remove2);      //空数组

代替（删除几个，插入几个）

var remove3 = colors.splice(1,1,"yellow");        //起始位置为1,删除一个数再加入一个数
console.log(colors);       //["white","yellow","red","green"]
console.log(remove3);       //pink

.

5.2.7位置方法

.indexOf() 从数组的开头向后查找并返回其位置
.lastIndexOf 从数组的末尾向后查找并返回其位置
第一个参数是要查找的元素，第二个是从哪儿个位置开始找（可选）

var numbers = [1,2,3,4,5,4,3,2,1];
var position1 = numbers.indexOf(4);    //从头找第4并返回其位置
var position2 = numbers.lastIndexOf(4);  //从末尾开始找4并返回其位置
var position3 = numbers.indexOf(4,4);   //从位置4开始从前往后找4并返回其位置
var position4 = numbers.lastIndexOf(4,4);    //从位置4开始从后往前找4并返回其位置
console.log(position1);       //3
console.log(position2);       //5
console.log(position3);       //5
console.log(position4);       //3

5.2.8迭代方法

每个方法都接受两个参数，要在数组每一项上运行的函数和运行该函数得到作用域对象——影响this的值
函数接受三个参数，数组项的值，该项在数组中的位置和数组对象本身（item，index，array）

.every() 数组中的每一项都运行函数，若函数对每一项都返回true，则返回true
.some() 数组中的每一项都运行函数，若函数对任一项返回true，则返回true

var numbers = [1,2,3,4,5,4,3,2,1];
var everyResult = numbers.every(function(item,index,array){      
    return (item > 2);     
})
var someResult = numbers.some(function(item,index,array){
	return (item > 2);
})
console.log(everyResult);   //fause
console.log(someResult);    //true

.filter() 数组中的每一项都运行函数，返回true的项组成数组并返回
.map() 数组中的每一项都运行函数，所有项组成数组并返回

var numbers = [1,2,3,4,5,4,3,2,1];
var filterResult = numbers.filter(function(item,index,array){      
    return (item > 2);     
})
var mapResult = numbers.map(function(item,index,array){
	eturn item * 2;
})
console.log(filterResult);   //[3,4,5,4,3]
console.log(mapResult);    //[2,4,6,8,10,8,6,4,2]

5.2.9归并方法

.reduce() 从数组第一项开始，逐个遍历到最后
.reduceRight() 从数组最后一项开始，逐个遍历到开头
这两个方法接收两个参数，一个是函数，一个是作为归并基础的初始值（可选）
函数有四个参数前一个值，当前值，项的索引和数组对象(prev, cur, index, array)

var numbers = [1,2,3,4,5];
var sum = numbers.reduce(function(prev,cur,index,array){
    return prev + cur;
var sum1 = numbers.reduceRight(function(prev,cur,index,array){
    return prev + cur;
})
console.log(sum);       //15
console.log(sum1);