js判断是否为JSON对象(转载)

1
2
3
4

jm.isJson = function(obj){
var isjson = typeof(obj) == "object" && Object.prototype.toString.call(obj).toLowerCase() == "[object object]" && !obj.length; 
return isjson;
}

JS对象之JSON详解 转载▼

JavaScript对象与传统的面向对象中的对象几乎没有相似之处，传统的面向对象语言中，创建一个对象必须先有对象的模板：类，类中定义了对象的属性和操作这些属性的方法。通过实例化来构筑一个对象，然后使用对象间的协作来完成一项功能，通过功能的集合来完成整个工程。而Javascript中是没有类的概念的，借助JavaScript的动态性，我们完全可以创建一个空的对象(而不是类)，通过像对象动态的添加属性来完善对象的功能。

JSON是JavaScript中对象的字面量，是对象的表示方法，通过使用JSON，可以减少中间变量，使代码的结构更加清晰，也更加直观。使用JSON，可以动态的构建对象，而不必通过类来进行实例化，大大的提高了编码的效率。

Javascript对象

JavaScript对象其实就是属性的集合，这里的集合与数学上的集合是等价的，即具有确定性，无序性和互异性，也就是说，给定一个JavaScript对象，我们可以明确的知道一个属性是不是这个对象的属性，对象中的属性是无序的，并且是各不相同的(如果有同名的，则后声明的覆盖先声明的)。

一般来说，我们声明对象的时候对象往往只是一个空的集合，不包含任何的属性，通过不断的添加属性，使得该对象成为一个有完整功能的对象，而不用通过创建一个类，然后实例化该类这种模式，这样我们的代码具有更高的灵活性，我们可以任意的增删对象的属性。

如果读者有python或其他类似的动态语言的经验,就可以更好的理解JavaScript的对象，JavaScript对象的本身就是一个字典(dictionary)，或者Java语言中的Map，或者称为关联数组，即通过键来关联一个对象，这个对象本身又可以是一个对象，根据此定义，我们可以知道JavaScript对象可以表示任意复杂的数据结构。

对象的属性

属性是由键值对组成的，即属性的名字和属性的值。属性的名字是一个字符串，而值可以为任意的JavaScript对象(JavaScript中的一切皆对象，包括函数)。比如，声明一个对象：

//声明一个对象
var jack = new Object();
jack.name = “jack”;
jack.age = 26;
jack.birthday = new Date(1984, 4, 5);

//声明另一个对象
var address = new Object();
address.street = “Huang Quan Road”;
address.xno = “135”;

//将addr属性赋值为对象address
jack.addr = address;

这种声明对象的方式与传统的OO语言是截然不同的，它给了我们极大的灵活性来定制一个对象的行为。

对象属性的读取方式是通过点操作符(.)来进行的，比如上例中jack对象的addr属性，可以通过下列方式取得：
var ja = jack.addr;
ja = jack[addr];
后者是为了避免这种情况，设想对象有一个属性本身包含一个点(.)，这在JavaScript中是合法的，比如说名字为foo.bar，当使用jack.foo.bar的时候，解释器会误以为foo属性下有一个bar的字段，因此可以使用jack[foo.bar]来进行访问。通常来说，我们在开发通用的工具包时，应该对用户可能的输入不做任何假设，通过[属性名]这种形式则总是可以保证正确性的。

属性与变量

在第二章，我们讲解了变量的概念，在本章中，读者可能已经注意到，这二者的行为非常相似，事实上，对象的属性和我们之前所说的变量其实是一回事。

JavaScript引擎在初始化时，会构建一个全局对象，在客户端环境中，这个全局对象即为window。如果在其他的JavaScript环境中需要引用这个全局对象，只需要在顶级作用域(即所有函数声明之外的作用域)中声明：

var global = this;
我们在顶级作用域中声明的变量将作为全局对象的属性被保存，从这一点上来看，变量其实就是属性。比如，在客户端，经常会出现这样的代码：

var v = “global”;
var array = [“hello”, “world”];
function func(id){
var element = document.getElementByIdx_x(id);
//对elemen做一些操作
}
事实上相当于：

window.v = “global”;
window.array = [“hello”, “world”];
window.func = function(id){
var element = document.getElementByIdx_x(id);
//对elemen做一些操作
}

原型对象
原型(prototype)，是JavaScript特有的一个概念，通过使用原型，JavaScript可以建立其传统OO语言中的继承，从而体现对象的层次关系。JavaScript本身是基于原型的，每个对象都有一个prototype的属性来，这个prototype本身也是一个对象，因此它本身也可以有自己的原型，这样就构成了一个链结构。
访问一个属性的时候，解析器需要从下向上的遍历这个链结构，直到遇到该属性，则返回属性对应的值，或者遇到原型为null的对象(JavaScript的基对象Object的prototype属性即为null)，如果此对象仍没有该属性，则返回undefined.
下面我们看一个具体的例子：

//声明一个对象base
function Base(name){
this.name = name;
this.getName = function(){
return this.name;
}
}
//声明一个对象child
function Child(id){
this.id = id;
this.getId = function(){
return this.id;
}
}
//将child的原型指向一个新的base对象
Child.prototype = new Base(“base”);
//实例化一个child对象
var c1 = new Child(“child”);
//c1本身具有getId方法
print(c1.getId());
//由于c1从原型链上”继承”到了getName方法，因此可以访问
print(c1.getName());

得出结果：
child
base
由于遍历原型链的时候，是有下而上的，所以最先遇到的属性值最先返回，通过这种机制可以完成重载的机制。
this指针
JavaScript中最容易使人迷惑的恐怕就数this指针了，this指针在传统OO语言中，是在类中声明的，表示对象本身，而在JavaScript中，this表示当前上下文，即调用者的引用。这里我们可以来看一个常见的例子：

//定义一个人，名字为jack
var jack = {
name : “jack”,
age : 26
}
//定义另一个人，名字为abruzzi
var abruzzi = {
name : “abruzzi”,
age : 26
}
//定义一个全局的函数对象
function printName(){
return this.name;
}
//设置printName的上下文为jack, 此时的this为jack
print(printName.call(jack));
//设置printName的上下文为abruzzi,此时的this为abruzzi
print(printName.call(abruzzi));

运行结果：
jack
Abruzzi
应该注意的是，this的值并非函数如何被声明而确定，而是被函数如何被调用而确定，这一点与传统的面向对象语言截然不同，call是Function上的一个函数，详细描述在第四章。
使用对象
对象是JavaScript的基础，我们使用JavaScript来完成编程工作就是通过使用对象来体现的，这一小节通过一些例子来学习如何使用JavaScript对象：
对象的声明有三种方式：
◆ 通过new操作符作用域Object对象，构造一个新的对象，然后动态的添加属性，从无到有的构筑一个对象。
◆ 定义对象的“类”:原型，然后使用new操作符来批量的构筑新的对象。
◆ 使用JSON，这个在下一节来进行详细说明
这一节我们详细说明第二种方式，如：

//定义一个”类”，Address
function Address(street, xno){
this.street = street || ‘Huang Quan Road’;
this.xno = xno || 135;
this.toString = function(){
return “street : “ + this.street + “, No : “ + this.xno;
}
}
//定义另一个”类”，Person
function Person (name, age, addr) {
this.name = name || ‘unknown’;
this.age = age;
this.addr = addr || new Address(null, null);
this.getName = function () {return this.name;}
this.getAge = function(){return this.age;}
this.getAddr = function(){return this.addr.toString();}
}
//通过new操作符来创建两个对象，注意，这两个对象是相互独立的实体
var jack = new Person(‘jack’, 26, new Address(‘Qing Hai Road’, 123));
var abruzzi = new Person(‘abruzzi’, 26);
//查看结果
print(jack.getName());
print(jack.getAge());
print(jack.getAddr());
print(abruzzi.getName());
print(abruzzi.getAge());
print(abruzzi.getAddr());

运行结果如下：
jack
26
street : Qing Hai Road, No : 123
abruzzi
26
street : Huang Quan Road, No : 135

JSON及其使用

JSON全称为JavaScript对象表示法(JavaScript Object Notation)，即通过字面量来表示一个对象，从简单到复杂均可使用此方式。比如：

var obj = {
name : “abruzzi”,
age : 26,
birthday : new Date(1984, 4, 5),
addr : {
street : “Huang Quan Road”,
xno : “135”
}
}

这种方式，显然比上边的例子简洁多了，没有冗余的中间变量，很清晰的表达了obj这样一个对象的结构。事实上，大多数有经验的JavaScript程序员更倾向与使用这种表示法，包括很多JavaScript的工具包如jQuery，ExtJS等都大量的使用了JSON。JSON事实上已经作为一种前端与服务器端的数据交换格式，前端程序通过Ajax发送JSON对象到后端，服务器端脚本对JSON进行解析，还原成服务器端对象，然后做一些处理，反馈给前端的仍然是JSON对象，使用同一的数据格式，可以降低出错的概率。

而且，JSON格式的数据本身是可以递归的，也就是说，可以表达任意复杂的数据形式。JSON的写法很简单，即用花括号括起来的键值对，键值对通过冒号隔开，而值可以是任意的JavaScript对象，如简单对象String，Boolean，Number，Null，或者复杂对象如Date，Object，其他自定义的对象等。

JSON的另一个应用场景是：当一个函数拥有多个返回值时，在传统的面向对象语言中，我们需要组织一个对象，然后返回，而JavaScript则完全不需要这么麻烦，比如：

function point(left, top){
this.left = left;
this.top = top;
//handle the left and top
return {x: this.left, y:this.top};
}
直接动态的构建一个新的匿名对象返回即可：

var pos = point(3, 4);
//pos.x = 3;
//pos.y = 4;
使用JSON返回对象，这个对象可以有任意复杂的结构，甚至可以包括函数对象。

在实际的编程中，我们通常需要遍历一个JavaScript对象，事先我们对对象的内容一无所知。怎么做呢?JavaScript提供了for..in形式的语法糖：

for(var item in json){
//item为键
//json[item]为值
}
这种模式十分有用，比如，在实际的WEB应用中，对一个页面元素需要设置一些属性，这些属性是事先不知道的，比如：

var style = {
border:”1px solid #ccc”,
color:”blue”
};
然后，我们给一个DOM元素动态的添加这些属性：

for(var item in style){
//使用jQuery的选择器
$(“div#element”).css(item, style[item]);
}
当然，jQuery有更好的办法来做这样一件事，这里只是举例子，应该注意的是，我们在给$(“div#element”)添加属性的时候，我们对style的结构是不清楚的。

另外比如我们需要收集一些用户的自定义设置，也可以通过公开一个JSON对象，用户将需要设置的内容填入这个JSON，然后我们的程序对其进行处理。

function customize(options){
this.settings = $.extend(default, options);
}

DOCTYPE 严格模式与混杂模式

本文链接,作者翻译了Peter-Paul Koch的文章，讲述了严格模式与混杂模式的由来以及发展

原文链接：Quirks mode and strict mode 地址是：http://www.quirksmode.org/css/quirksmode.html

怪异模式和严格模式（译注：一般称为标准模式：Standards Mode,下文中的严格模式都可以理解为标准模式）是浏览器解析CSS时的两种‘模式’。这篇文章将简单阐述这两种模式之间的差异。

译注：一个网页一般由两部分组成即：HTML（Hypertext Markup Language）和CSS（Cascade Style Sheets）。
HTML负责描述网页的结构和内容（如标题，导航栏等），而CSS则负责网页的表现（外观）（如背景颜色，字体样式等）。

问题的产生：

当Netscape4（译注：网景公司早期的浏览器）和IE4（微软公司早期的浏览器）实现CSS机制时，并没有遵循W3C提出的标准。Netscape4 提供了糟糕的支持，而IE4 虽然接近标准，但依旧未能完全正确的支持标准。尽管IE 5 修复了IE4 许多的问题（bugs），但是依然延续CSS实现中的其它故障（主要是盒模型（box model）问题）。

为了保证自己的网站在不同的浏览器中都能正确展现，网页开发者不得不依据各个浏览器的自身的规范来使用CSS。因此大部分网站的CSS实现并未符合W3C的标准。

然而随着标准一致性变得越来越重要，浏览器开发商不得不面临一个艰难的抉择：逐渐遵循W3C的标准是前进的方向。但是改变现有CSS的实现，完整去遵循标准，会使许多网站或多或少受到破坏。如果浏览器突然以正确的方式解析现存的CSS，陈旧的网站显示必然受到影响。

因此立即遵循标准会产生问题，然而忽略标准则又会维持浏览器大战时（译注：微软和网景之间的一段竞争）所产生的混乱。

解决方案：

任何的解决方案必须跟随如下两个方面：

1：允许网站开发者能够选择他们所熟知的模式。
2：依然使用旧式规则显示陈旧的网站。

换句话说，所有的浏览器需要提供两种模式：怪异模式（即兼容模式）服务于旧式规则，严格模式服务于标准规则。Mac平台的IE浏览器最先实现这两种模式，Mozilla， Safari、Opera和Windows平台的IE6也相继实现了这两种模式。WIndows平台的IE5和Netscape4则只提供了怪异模式。

选择使用哪种模式需要一个触发器，而 “DOCTYP切换” 则用于此目的。依照标准，任何一个(X)HTML文档必须拥有一个DOCTYPE（译注：DTD（文档类型定义）是一组机器可读的规则，它们指示(X)HTML文档中允许有什么，不允许有什么，DOCTYPE正是用来告诉浏览器使用哪种DTD,一般放在(X)HTML文档开头声明）用以告诉其他人这个文档的类型风格

1：产生于标准化浪潮以前的网页并没有DOCTYPE声明。因此'没有DOCTYPE'意味着触发怪异模式：既依据旧式的CSS规则渲染网页。
2：相反，如果开发者明确知道包含DOCTYPE，他们应该明白他们想要怎么做。因此大部分的DOCTYPE声明将触发严格模式：即依据标准的CSS规则渲染网页。
3：任何新的或未知的DOCTYPE将触发严格模式。
4：一些页面依据怪异模式而写，但是却包含DOCTYPE。这种情况下各个浏览器依据自己的DOCTYPE规则列表来触发怪异模式，参照这个浏览器比较图表 。

注意：你的网页并不一定要依据所选择的DOCTYPE去获得有效性验证，一个DOCTYPE标签足以触发严格模式。

我在大部分网页中使用如下的DOCTYPE。它除了声明我的网页是XHTML 1.0 过渡类型之外，还将在所有浏览器中触发“准严格模式”（译注：下文将介绍这个模式）

完美的解决方案？

就个人而言，我并不十分满意“DOCTYPE切换”方案。一个DOCTYPE所提供的信息是(X)HTML文档所拥有的类型风格，即文档的结构，而不应该提供任何关于文档表现（外观）的信息，因为那违反了CSS关于页面结构和表现分离的原则。

并发症：准严格模式

在早些时候，尝试使用严格模式总是会产生关于图片会突然获得旧式的底部边距，并且无法移除的讨论。产生这个现象的原因是严格模式将怪异模式和严格模式标签当成行内元素，这意味着一些空间将被保留给一些拥有”尾部“的字符如（g, j, q），而图片并没有“尾部”字符，所以这些空间将不会被使用，但是却依旧保留着。

解决办法是声明图片为块级元素{display:block}

浏览器厂商，尤其是Mozilla，认为这是一种产生困惑的情况，于是他们引入了“准严格模式”（译注：也称为准标准模式 Almost Standards Mode），这与严格模式一样，除了它将图片当作块级元素而不是行内元素。

JavaScript函数声明与函数表达式

文章源地址，文章内容有删改

这两种方式在解析上的区别
函数声明，js解析器会优先读取，确保在所有代码执行之前声明已经被解析，而函数表达式，如同定义其它基本类型的变量一样，只在执行到某一句时也会对其进行解析，所以在实际中，它们还是会有差异的，具体表现在，当使用函数声明的形式来定义函数时，可将调用语句写在函数声明之前，而后者，这样做的话会报错。

创建函数的最常用的两个方法

在ECMAScript中，创建函数的最常用的两个方法是函数表达式和函数声明，两者期间的区别是有点晕，因为ECMA规范只明确了一点：函数声明必须带有标示符（Identifier）（就是大家常说的函数名称），而函数表达式则可以省略这个标示符：

函数声明：

function 函数名称 (参数：可选){ 函数体 }

函数表达式：

function 函数名称（可选）(参数：可选){ 函数体 }

所以，可以看出，如果不声明函数名称，它肯定是表达式，可如果声明了函数名称的话，如何判断是函数声明还是函数表达式呢？

ECMAScript是通过上下文来区分的，如果function foo(){}是作为赋值表达式的一部分的话，那它就是一个函数表达式，如果function foo(){}被包含在一个函数体内，或者位于程序的最顶部的话，那它就是一个函数声明。

function foo(){} // 声明，因为它是程序的一部分

var bar = function foo(){}; // 表达式，因为它是赋值表达式的一部分

new function bar(){}; // 表达式，因为它是new表达式

(function(){
function bar(){} // 声明，因为它是函数体的一部分
})();

还有一种函数表达式不太常见，就是被括号括住的(function foo(){})，他是表达式的原因是因为括号 ()是一个分组操作符，它的内部只能包含表达式，我们来看几个例子：

function foo(){} // 函数声明
(function foo(){}); // 函数表达式：包含在分组操作符内
try {
(var x = 5); // 分组操作符，只能包含表达式而不能包含语句：这里的var就是语句
} catch(err) {
// SyntaxError
}

你可以会想到，在使用eval对JSON进行执行的时候，JSON字符串通常被包含在一个圆括号里：eval(‘(‘ + json + ‘)’)，这样做的原因就是因为分组操作符，也就是这对括号，会让解析器强制将JSON的花括号解析成表达式而不是代码块。

try {
{ “x”: 5 }; // “{“ 和 “}” 做解析成代码块
} catch(err) {
// SyntaxError
}

({ “x”: 5 }); // 分组操作符强制将”{“ 和 “}”作为对象字面量来解析
表达式和声明存在着十分微妙的差别，首先，函数声明会在任何表达式被解析和求值之前先被解析和求值，即使你的声明在代码的最后一行，它也会在同作用域内第一个表达式之前被解析/求值，参考如下例子，函数fn是在alert之后声明的，但是在alert执行的时候，fn已经有定义了：

1
2
3
4
5

>alert(fn());

function fn() {
    return 'Hello world!';
}

另外，还有一点需要提醒一下，函数声明在条件语句内虽然可以用，但是没有被标准化，也就是说不同的环境可能有不同的执行结果，所以这样情况下，最好使用函数表达式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

// 千万别这样做！

// 因为有的浏览器会返回first的这个function，而有的浏览器返回的却是第二个

if (true) {

  function foo() {

    return 'first';

  }

}

else {

  function foo() {

    return 'second';

  }

}

foo();

// 相反，这样情况，我们要用函数表达式

var foo;

if (true) {

  foo = function() {

    return 'first';

  };

}

else {

  foo = function() {

    return 'second';

  };

}

foo();

函数声明的实际规则如下：

函数声明只能出现在程序或函数体内。从句法上讲，它们 不能出现在Block（块）（{ … }）中，例如不能出现在 if、while 或 for 语句中。因为 Block（块） 中只能包含Statement语句， 而不能包含函数声明这样的源元素。另一方面，仔细看一看规则也会发现，唯一可能让表达式出现在Block（块）中情形，就是让它作为表达式语句的一部分。但是，规范明确规定了表达式语句不能以关键字function开头。而这实际上就是说，函数表达式同样也不能出现在Statement语句或Block（块）中（因为Block（块）就是由Statement语句构成的）。

delete用来删除一个对象的属性，比如

var people={“name”:”liming”}
undefiend
delete people.name
ture

则将对象people的属性name删除，不存在了

数组也是对象，索引只是特殊的属性，所以我们可以使用删除对象属性的方法,使用delete 删除数组元素

var arr=[2,4,3,9];
delete arr[0]
true

查看arr数则怎会变成arr=[undefined*1,4,3,9]，说明已将arr[0]删除。

这里可以看一下全局变量声明与未声明的区别

下面例子
var a=1;
b=2；

console中：

• delete b回车返回true，查看b则返回错误。
• delete a回车返回false，查看a依然存在。

说明在未声明的情况下，b是作为window对象的一个属性存在的，即window.b可以访问b
var声明后才是一个全局的数值或其他类型数据。

JavaScript提供了一个splice方法用于一次性解决数组添加、删除（这两种方法一结合就可以达到替换效果），方法有三个参数

1.开始索引
2.删除元素的位移
3.插入的新元素，当然也可以写多个

splice方法返回一个由删除元素组成的新数组，没有删除则返回空数组

• var a = new Array(1,2,3,4,5);

• 删除

指定前两个参数，可以使用splice删除数组元素，同样会带来索引调整及length调整

var a = new Array(1,2,3,4,5);
console.log(a.splice(1,3));//[2, 3, 4]
console.log(a.length);//2
console.log(a);//[1,5]

如果数组索引不是从0开始的，那么结果会很有意思，有一这样数组

var a = new Array();
a[2]=2;
a[3]=3;
a[7]=4;
a[8]=5;

console.log(a.splice(3,4)); //[3]
console.log(a.length); //5
console.log(a); //[2: 2, 3: 4, 4: 5]

上面例子可以看到，splice的第一个参数是绝对索引值，而不是相对于数组索引，第二个参数并不是删除元素的个数，而是删除动作执行多少次,或者说向后删除的绝对索引个数，并不是按数组实际索引移动，而是连续移动。同时调整后面元素索引，前面索引不理会

• 插入与替换

只要方法第二个参数，也就是删除动作执行的次数设为0，第三个参数及以后填写要插入内容就splice就能执行插入操作，而如果第二个参数不为0则变成了先在该位置删除再插入，也就是替换效果

var a = new Array(1,2,3,4,5);
a.splice(1,0,9,99,999);
console.log(a.length); //8
console.log(a);//[1, 9, 99, 999, 2, 3, 4, 5]
a.splice(1,3,8,88,888);
console.log(a.length);//8
console.log(a);//[1, 8, 88, 888, 2, 3, 4, 5]

创建数组

• 构造函数

1. 无参构造函数，创建一空数组

var a1 = new Array();

2.一个数字参数构造函数，指定数组长度（由于数组长度可以动态调整，作用并不大），创建指定长度的数组

var a2 = new Array(5);

3.带有初始化数据的构造函数，创建数组并初始化参数数据

var a3 = new Array(4, ‘hello’, new Date());

• 字面量

1.使用方括号，创建空数组，等同于调用无参构造函数

var a4 = [];

2.使用中括号，并传入初始化数据，等同于调用带有初始化数据的构造函数

var a5 = [10];

注意点

1.在使用构造函数创建数组时如果传入一个数字参数，则会创建一个长度为参数的数组，如果传入多个，则创建一个数组，参数作为初始化数据加到数组中

1
2
3
4
5
6
7

var a1 = new Array(5);
   console.log(a1.length);//5
   console.log(a1); //[] ,数组是空的

   var a2 = new Array(5,6);
   console.log(a2.length);//2
   console.log(a2); //[5,6]

2.但是使用字面量方式，无论传入几个参数，都会把参数当作初始化内容

1
2
3
4
5
6
7

var a1 = [5];
console.log(a1.length);//1
console.log(a1); //[5]

var a2 = [5,6];
console.log(a2.length);//2
console.log(a2); //[5,6]

• 使用带初始化参数的方式创建数组的时候，最好最后不要带多余的”,”，在不同的浏览器下对此处理方式不一样

var a1 = [1,2,3,];
console.log(a1.length);
console.log(a1);
这段脚本在现代浏览器上运行结果和我们设想一样，长度是3，但是在低版本IE下确实长度为4的数组，最后一条数据是undefined

立即执行函数在js中是作为一个单独的语句存在的，是一个独立的表达式，（）括号能够求得一个数值，使得函数执行。

表达式是由数字、运算符、数字分组符号（如括号）、自由变量和约束变量等以能求得数值的有意义排列方法所得的组合。

先看一个最简单的形式：

(function(){})();

我们了解了表达式就能很清楚的看明白这是什么结构了

(函数定义表达式)函数调用表达式

也就是说先创建了一个匿名函数，然后不传入参数调用它，这就变成了立即执行函数，知道了这些看个传入参数调用的立即执行函数题目

• 看一个列子。

  1 2 3

  (function f(f){ return typeof f(); })(function(){return 1;});// "number"

这个题目事实上还涉及了一些其它的知识，立即执行函数不再是以空括号()来调用了，同时传入了一个function作为参数传入调用。

再一个疑惑就是typeof f() 中的f究竟指谁，简单说一下，当函数执行有命名冲突的时候，函数依次填入 变量＝>函数＝>参数，所以最后被填入的参数f会覆盖函数定义f，typeof f()是对参数的调用，参数是立即执行函数传入的function参数，返回数字1，typeof 1是 “number”。

• 另外（）括号将整个函数和调用包含起来也可以

  1 2 3

  (function f(f){ return f; }(3));// "number"

• 或者常常将函数名省去

  1 2 3

  (function(f){ return f; })(3);// "number"

此处未涉及到作用域，立即执行函数本质上是一个表达式，所以它会执行，执行后就被释放了，语句在（）括号内有效

数组对象的3个属性

1、length 属性

• Length属性表示数组的长度，即其中元素的个数。因为数组的索引总是由0开始，所以一个数组的上下限分别是：0和length-1。

和其他大多数语言不同的是，JavaScript数组的length属性是可变的，这一点需要特别注意。当length属性被设置得更大时，整个数组的状态事实上不会发生变化，仅仅是length属性变大；当length属性被设置得比原来小时，则原先数组中索引大于或等于length的元素的值全部被丢失。

下面是演示改变length属性的例子：

var arr=[12,23,5,3,25,98,76,54,56,76];
//定义了一个包含10个数字的数组
alert(arr.length); //显示数组的长度10
arr.length=12; //增大数组的长度
alert(arr.length); //显示数组的长度已经变为12

alert(arr[8]); //显示第9个元素的值，为56
arr.length=5; //将数组的长度减少到5，索引等于或超过5的元素被丢弃
alert(arr[8]); //显示第9个元素已经变为”undefined”
arr.length=10; //将数组长度恢复为10
alert(arr[8]); //虽然长度被恢复为10，但第9个元素却无法收回，显示”undefined”

由上面的代码我们可以清楚的看到length属性的性质。但length对象不仅可以显式的设置，它也有可能被隐式修改。JavaScript中可以使用一个未声明过的变量，同样，也可以使用一个未定义的数组元素（指索引超过或等于length的元素），这时，length属性的值将被设置为所使用元素索引的值加1。

• 例如下面的代码：

  var arr=[12,23,5,3,25,98,76,54,56,76];
  alert(arr.length);
  arr[15]=34;
  alert(arr.length);

代码中同样是先定义了一个包含10个数字的数组，通过alert语句可以看出其长度为10。随后使用了索引为15的元素，将其赋值为15，即 arr[15]=34，这时再用alert语句输出数组的长度，得到的是16。无论如何，对于习惯于强类型编程的开发人员来说，这是一个很令人惊讶的特性。事实上，使用new Array()形式创建的数组，其初始长度就是为0，正是对其中未定义元素的操作，才使数组的长度发生变化。

由上面的介绍可以看到，length属性是如此的神奇，利用它可以方便的增加或者减少数组的容量。因此对length属性的深入了解，有助于在开发过程中灵活运用。

2、prototype 属性

返回对象类型原型的引用。

prototype 属性是 object 共有的。

objectName.prototype
objectName 参数是object对象的名称。

说明：用 prototype 属性提供对象的类的一组基本功能。 对象的新实例“继承”赋予该对象原型的操作。

• 对于数组对象，以以下例子说明prototype 属性的用途。

给数组对象添加返回数组中最大元素值的方法。要完成这一点，声明一个函数，将它加入 Array.prototype， 并使用它。

function array_max( )
{
var i, max = this[0];
for (i = 1; i < this.length; i++)
{
if (max < this[i])
max = this[i];
}
return max;
}
Array.prototype.max = array_max;
var x = new Array(1, 2, 3, 4, 5, 6);
var y = x.max( );

该代码执行后，y 保存数组 x 中的最大值，或说 6。

3、constructor 属性

表示创建对象的函数。
object.constructor //object是对象或函数的名称。

说明：constructor 属性是所有具有 prototype 的对象的成员。它们包括除 Global 和 Math 对象以外的所有 JScript 固有对象。constructor 属性保存了对构造特定对象实例的函数的引用。

例如：

x = new String(“Hi”);
if (x.constructor == String) // 进行处理（条件为真）。
或
function MyFunc {
// 函数体。
}
y = new MyFunc;
if (y.constructor == MyFunc) // 进行处理（条件为真）。
对于数组来说：
y = new Array();

转载自http://1632004.blog.163.com/blog/static/29991497201172254724797/

• 1、数组的创建
  var arrayObj = new Array();　//创建一个数组
  var arrayObj = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度
  var arrayObj = new Array([element0[, element1[, …[, elementN]]]]);　创建一个数组并赋值
  要说明的是，虽然第二种方法创建数组指定了长度，但实际上所有情况下数组都是变长的，也就是说即使指定了长度为5，仍然可以将元素存储在规定长度以外的，注意：这时长度会随之改变。
• 2、数组的元素的访问
  var testGetArrValue=arrayObj[1]; //获取数组的元素值
  arrayObj[1]= “这是新值”; //给数组元素赋予新的值
• 3、数组元素的添加
  arrayObj. push([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组结尾，并返回数组新长度
  arrayObj.unshift([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组开始，数组中的元素自动后移，返回数组新长度
  arrayObj.splice(insertPos,0,[item1[, item2[, . . . [,itemN]]]]);//将一个或多个新元素插入到数组的指定位置，插入位置的元素自动后移，返回””。
• 4、数组元素的删除
  arrayObj.pop(); //移除最后一个元素并返回该元素值
  arrayObj.shift(); //移除最前一个元素并返回该元素值，数组中元素自动前移
  arrayObj.splice(deletePos,deleteCount); //删除从指定位置deletePos开始的指定数量deleteCount的元素，数组形式返回所移除的元素
• 5、数组的截取和合并
  arrayObj.slice(start, [end]); //以数组的形式返回数组的一部分，注意不包括 end 对应的元素，如果省略 end 将复制 start 之后的所有元素
  arrayObj.concat([item1[, item2[, . . . [,itemN]]]]); //将多个数组（也可以是字符串，或者是数组和字符串的混合）连接为一个数组，返回连接好的新的数组
• 6、数组的拷贝
  arrayObj.slice(0); //返回数组的拷贝数组，注意是一个新的数组，不是指向
  arrayObj.concat(); //返回数组的拷贝数组，注意是一个新的数组，不是指向
• 7、数组元素的排序
  arrayObj.reverse(); //反转元素（最前的排到最后、最后的排到最前），返回数组地址
  arrayObj.sort(); //对数组元素排序，返回数组地址
• 8、数组元素的字符串化
  arrayObj.join(separator); //返回字符串，这个字符串将数组的每一个元素值连接在一起，中间用 separator 隔开。
  toLocaleString 、toString 、valueOf：可以看作是join的特殊用法，不常用

转载自http://1632004.blog.163.com/blog/static/29991497201172254724797/