引用类型

一、object类型

var person = new Object();
person.name = "Nicholas";
person.age = 29; ```

var person = {name : "Nicholas",age : 29}; ```

var person = {}; //与 new Object()相同
person.name = "Nicholas";
person.age = 29; ```

从功能上看，下面这两种访问对象属性的方法没有任何区别。

alert(person["name"]); //"Nicholas"
alert(person.name); //"Nicholas"

但方括号语法的主要优点是可以通过变量来访问属性，例如：

var propertyName = "name";
alert(person[propertyName]); //"Nicholas"```
如果属性名中包含会导致语法错误的字符，或者属性名使用的是关键字或保留字，也可以使用方括号表示法。例如：

person["first name"] = "Nicholas";```
由于"first name"中包含一个空格，所以不能使用点表示法来访问它。然而，属性名中是可以包含非字母非数字的，这时候就可以使用方括号表示法来访问它们。通常，除非必须使用变量来访问属性，否则我们建议使用点表示法。 

##二、Array类型

//在使用 Array 构造函数时也可以省略 new 操作符
var colors = new Array(3); // 创建一个包含 3 项的数组
var names = new Array("Greg"); // 创建一个包含 1 项，即字符串"Greg"的数组 ```
第二种创建数组的方法：

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
var names = []; // 创建一个空数组 ```

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
colors[99] = "black"; // （在位置 99）添加一种颜色
alert(colors.length); // 100
//位置 3 到位置 98 实际上都是不存在的，所以访问它们都将返回 undefined ```

1. 检测数组

if (Array.isArray(value)){//对数组执行某些操作} ```
2. 转换方法
所有对象都具有toString()和 valueOf()方法。其中，调用数组的 toString()方法会返回由数组中每个值的字符串形式拼接而成的一个以逗号分隔的字符串。而调用 valueOf()返回的还是数组。实际上，为了创建这个字符串会调用数组每一项的 toString()方法。来看下面这个例子。

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
alert(colors.toString()); // red,blue,green
alert(colors.valueOf()); // red,blue,green
alert(colors); // red,blue,green ```

3. 函数属性和方法
   每个函数都包含两个属性： length 和 prototype。其中， length 属性表示函数希望接收的命名参数的个数 。
   每个函数都包含两个非继承而来的方法： apply()和 call()
   apply()方法接收两个参数：一个是在其中运行函数的作用域，另一个是参数数组。其中，第二个参数可以是 Array 的实例，也可以是arguments 对象。例如：

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()方法与 apply()方法的作用相同，它们的区别仅在于接收参数的方式不同。对于 call()方法而言，第一个参数是 this 值没有变化，变化的是其余参数都直接传递给函数。换句话说，在使用call()方法时，传递给函数的参数必须逐个列举出来，如下面的例子所示。

function sum(num1, num2){return num1 + num2;}
function callSum(num1, num2){return sum.call(this, num1, num2);}
alert(callSum(10,10)); //20 ```
事实上，传递参数并非 apply()和 call()真正的用武之地；它们真正强大的地方是能够扩充函数赖以运行的作用域。下面来看一个例子。

window.color = "red";
var o = { color: "blue" };
function sayColor(){alert(this.color);}
sayColor(); //red
sayColor.call(this); //red
sayColor.call(window); //red
sayColor.call(o); //blue ```
ECMAScript 5 还定义了一个方法： bind()。这个方法会创建一个函数的实例，其 this 值会被绑定到传给 bind()函数的值。例如：

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

4. Boolean类型

var falseObject = new Boolean(false);
var result = falseObject && true;alert(result); //true
var falseValue = false;result = falseValue && true;alert(result); //false```
在这个例子中，我们使用 false 值创建了一个 Boolean 对象。然后，将这个对象与基本类型值 true构成了逻辑与表达式。在布尔运算中， false && true 等于 false。可是，示例中的这行代码是对falseObject 而不是对它的值（false）进行求值。前面讨论过，布尔表达式中的所有对象都会被转换为 true，因此 falseObject 对象在布尔表达式中代表的是 true。结果， true && true 当然就等于 true 了。 
5. String类型
concat()，用于将一或多个字符串拼接起来，返回拼接得到的新字符串 
与concat()方法一样， slice()、 substr()和 substring()也不会修改字符串本身的值——它们只是返回一个基本类型的字符串值，对原始字符串没有任何影响。请看下面的例子。

var stringValue = "hello world";alert(stringValue.slice(3)); //"lo world"
alert(stringValue.substring(3)); //"lo world"
alert(stringValue.substr(3)); //"lo world"
alert(stringValue.slice(3, 7)); //"lo w"
alert(stringValue.substring(3,7)); //"lo w"
alert(stringValue.substr(3, 7)); //"lo worl" ```

6. Math对象
   要找到数组中的最大或最小值，可以像下面这样使用 apply()方法。

var values = [1, 2, 3, 4, 5, 6, 7, 8];
var max = Math.max.apply(Math, values);```
这个技巧的关键是把 Math 对象作为 apply()的第一个参数，从而正确地设置 this 值。
Math.ceil()执行向上舍入
Math.floor()执行向下舍入
Math.round()执行四舍五入
  -  random方法
Math.random()方法返回大于等于 0 小于 1 的一个随机数。 
值 = Math.floor(Math.random() * 可能值的总数 + 第一个可能的值) 

function selectFrom(lowerValue, upperValue) {
var choices = upperValue - lowerValue + 1;
return Math.floor(Math.random() * choices + lowerValue);
}
var num = selectFrom(2, 10);alert(num);
// 介于 2 和 10 之间（包括 2 和 10）的一个数值 ```