javascript-引用类型

引用类型

object类型

创建object的两种方式

1. new操作符跟object构造函数: var a=new object(){}
2. 对象字面量表示法: var object={};

特点

1. 在对象中的最后一个属性不能添加逗号，原因是会在IE7及更早的版本和Opera中导致错误。
2. 使用对象字面量时，属性也可以使用字符串。
3. 通过对象字面量定义对象时，不会调用object构造函数
4. 访问对象属性时，一般使用点表示法，这是在很多面向语言中通用的语法。在JS中也可以使用方括号表示法。
5. 方括号表示法的优点在于可以通过变量来访问属性。

Array类型

与其它语言相比

• 相同点：ES数组与其它语言中的数组都是有序列表。
• 不同点：ES数组每一项可以保存任何类型的数据，并且大小是可以动态调整的，既可以随着数据的添加自动增长以容纳新增数据。

创建数组的两种方式

1. new操作符跟Array构造函数: var b=new Array(n)
2. 数组字面量表示法: var colors=[“red”,“blue”];

特点

1. 在数组的最后一项不要增加逗号，这样在IE8之前的浏览器会产生一个新的值
2. 当通过索引值访问时，若索引值超出，数组就会自动增加到该索引。
3. 当数组中有3个值时，通过length改变该数组的长度时，则会移除第三项。
4. 可以通过.length一直为数组添加新项。（数组最后一项为length-）
5. alert()接收字符串参数，通过alert()输出数组时，它会在后台调用toString()方法。

检测数组

Array.isArray(value)方法

if(Array.isArray(value)){
    //对数组进行某些操作
}

栈方法

定义：栈是一种后进先出的数据结构，即最新添加的项最早被移除。
ES为数组提供了push() 和 pop() 方法。

push():逐个添加到数组的末尾，并返回数组的长度。

pop():从数组的末尾移除最后一项，并返回移除的项。

var colors=new Array();
var count=colors.push("red","green");
alert(count)//2

var item=colors.pop();
alert(item); //"green"
alert(count.length); //1 

队列方法

定义：队列是一种先进先出的数据结构，即最新添加的项最早被移除。
ES为数组提供了shift() 和 unshift() 方法。

shift():从数组的开始移除第一项，并返回移除的项。

unshift():从数组的开始添加任意项，并返回数组的长度。

var colors=new Array();
var count=colors.shift("red","green");
alert(count)//"red"

var item=colors.unshift("black");
alert(item); //"2"
alert(count.length); //2 

重排序方法

reverse() 和 sort()

reverse()：降序，从大到小排列
sort()：升序，从小到大排列

注意：sort（）方法会调用每个数组项的toString（）转型方法，比较得到的字符串。

function compare(value1,value2){
    if(value1<value2){
        return -1;
    }
    else if(value1>value2){
        return 1;
    
    }
    else{
        return 0
    }
}

操作方法

1. concat（）:基于当前创建的数组创建一个新数组；
2. splice()：主要用途向数组的中部插入项；

//concat
var color=["red","blue"];
var color1=color.concat("yello");
alert(color1) //["red","blue","yello"]

//splice
var color=["red","blue"];

var remove=colors.splice(0,1); //删除第一项
alert(remove) //blue

remove=color.splice(1,0,"red") //从位置1开始插入red
alert(remove) //["red","red","blue"];

remove=color.splice(1,1,"red") //插入一项，删除一项
alert(remove) //["red","red","blue"];

位置方法

• indexOf(value,index):返回查找的项在数组中的位置，从头开始
• lastindexof(value,index):返回查找的项在数组中的位置，从末尾开始

都是接收的两个参数，第二个参数是可选的。

var number=[1,2,3,4,5,6,7,8,9]
alert(number.indexof(4)) //5
alert(number.lastindexof(5)) //4

迭代方法

数组的5个迭代方法，每个方法都接收两个参数。

1、every()：对数组中的每一项运行给定函数，如果该函数对每一项都返回true，则返回true。

2、filter()：对数组中的每一项运行给定函数，返回该函数会返回true的项组成的数组。

3、forEach()：对数组中的每一项运行给定函数。这个方法没有返回值。

4、map()：对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。

5、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;
　});
　alert(everyResult);　　　　// false

归并方法 （适用于数组的所有值的和）

reduce()、reduceRight()：都接收四个参数（前一个值、当前值、项的索引和数组对象），两者作用相同，只是计算时起始方向相反。

//使用reduce对数组进行求和;
var value=[1,2,3,4,5];
var sum=values.reduce(function(prev,cur,index,array){
    return prev+cur;
})

相比起用for或者while，足足少了53ms

循环类型	最终值(和)	所费时间
for	21	54.965ms
while	21	53.056ms
reduce	21	0.417ms

Date类型

暂未补充

FUNCTION 类型

函数实际上是对象，每个函数都是function类型的实例。并且都与其它引用类型一样具有属性和方法。由于函数时对象，因此函数名实际上也是一个指向函数对象的指针。

特点

• 使用不带圆括号的函数名是访问函数指针，而非调用函数。
• 函数没有重载的概念。
• 函数声明与函数表达式在执行时，解析器会率先读取函数声明

作为值的函数

function callSomeFunction(someFunction,someArgument){
    return someFunction(someArgument)
}

function add10(num){
    return num + 10；
}

var result = callSomeFunction(add10,10);

console.log(result);        //20

//作为值的函数
function createComparisonFunction(propertyName){
    return function(object1,object2){
        var value1=object1[propertyName];
        var value2=object2[propertyName];
 
        if(value1<value2) return -1;
        if(value1>value2) return 1;
        else return 0;
    }
}
 
 
var data = [{name:'Z',age:28},{name:'N',age:29}];
 
data.sort(createComparisonFunction('name'));
console.log(data[0].name);//N
data.sort(createComparisonFunction('age'));
console.log(data[0].name)//Z

函数内部属性

在函数内部，有两个特殊的对象。arguments 和 this。

argument

• arguments是一个类数组对象，包含着传入函数中的所有参数。
• arguments里有个名叫callee的属性指向这个arguments对象函数。

function fac(num){
    if(num<=1){
        return 1;
    }
    else{
    return  num*arguments.callee(num-1)
    }
}
alert(fac(5))//120

this

this引用的是函数执行的环境对象。当在全局环境中调用函数时,this引用的就是window。

window.red="red";
var o={color:"blue"};
function saycolor(){
    alert(this.color);
}
sayColor();//"red"
o.sayColor();//"blue"

caller

caller属性中保存着调用当前函数的函数引用。

function outer(){
    inner();
}

function inner(){
    alert(inner.caller);
}
outer();

callee与 caller容易混淆，记得区分。

函数属性和方法

因为函数对象，所以函数也有属性和方法。

属性

每个函数都拥有两个方法
length和prototype;

length 表示函数希望接收的命名参数的个数，例子如下。

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

prototype是保存所有实例方法的所在。特点：prototype是不可枚举的。因此无法用for-in。
诸如toString()、valueof()等方法都保存在prototype名下。

方法

每个函数都包含两个非继承下来的方法：apply()和call()，这两个方法都是在特定的作用域中调用函数，即设值函数体内this对象的值。

apply(windows,Array) 接收两个参数：一个是运行函数的作用域，另一个是数组。
数组可以是Array的实例，也可以是arguments对象

function sum(num1,num2){
    return num1+num2
}
function callsum(num1,num2){
    return sum.apply(this,[num1,num2])//Array
     return sum.apply(this,arguments)//arguments对象
}

call(windows,value) 与apply方法作用相同，只是第二个参数只能通过直接传入，不能使用数组

function sum(num1,num2){
    return num1+num2
}
function callsum(num1,num2){
    return sum.call(this,num1,num2)//Array
}

apply()和call()方法都能扩充函数作用域

window.color="red"
var o={color："blue"};
function sayColor(){
    alert(this.color);
}
sayColor();//red
sayColor.call(o);//blue

基本包装类型

3个特殊的引用类型boolean、Number、String；同时也具有与各自的基本类型相应的特殊行为。

每当读取一个基本类型值的时候，后台就有创建一个对应的基本包装类型的对象。

var s1="some text";
s1.substring(2);// 1.创建了一个实例 2.在实例调用方法 3.销毁实例

特点

• 引用类型与基本包装类型的主要区别就是对象的生存期;
• 对基本类型的实例调用typeof会返回“object”;
• 所有基本包装类型的对象在转换为布尔类型时值都是true;

Number类型

tofixed(n) 保留几位小数

toExponential() 返回指数。

var num=10;
console.log(Num.tofixed(2));//100.00
console.log(Num.toExponential(1));//1.0e+1

String类型

访问字符串的特点字符:charAt()和charCodeAt();

拼接字符串方法:concat()