js中函数 对象 和 this的理解【javascript吧】_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：156,858贴子：
js中函数 对象 和 this的理解收藏
刚学js好像function定义个函数，都需要new来创建个对象，又好像函数中的属性的this只有在new后才能有效，我都蒙了，js的函数不能当普通的函数用吗。函数，对象 this怎么理解，求高人
超高好评美国硅谷大佬亲授前端开发React培训课程,下一个硅谷抢手人才就是你了!七天无条件退款,每期席位有限,抓紧报名,进入名企薪资翻倍!
你在哪学的function一定要new的
函数声明一般用function name(){}使用函数表达式的较少。。。
new是用来创建实例。你有了一个对象Car， 可以有3种使用方式。（1）工厂模式，字面量.这个对象代表单例，即单一的实例，不能创建重复实例。var car = {color:'red',draw:function()={alert('red car'); }}使用： car.
car.draw();(2)“类”意义的对象表示这是个类型，此时的Car通过new的构造函数创建一个个实例，每个实例单独分配一个内存空间。function Car(color){this.color=this.draw=function(){alert(this.color); }}使用： var car1 = new Car('red'); car1.color='blue';car1.draw();(3)作为Function使用，function为对象的一种使用： var car1 = Car('red'); 这时候不调用构造函数，而是当做普通函数执行表达式的内容
this跟函数没有必然关系。 主要跟调用函数的环境有关，一般是 对象.函数，对象这时候便是函数的环境作用域，代码在离开对象的范围后自行销毁。如果对象省略，比如alert（）； 大部分情况是全局作用域window
new是创建一个对象 this是指向一个对象 如果没有对象 this就指window
登录百度帐号推荐应用js对象及new对象/函数的比较
作者：用户
本文讲的是js对象及new对象/函数的比较，
万物皆对象
在JavaScript的世界，万物皆对象。除了null和undefined，其他基本类型数字，字符串和布尔值都有对应有包装对象。对象的一个特征是你可以在它身上直接调用方法。对于数字基本类型，当试图在其身上调用toStr
万物皆对象
在JavaScript的世界，万物皆对象。除了null和undefined，其他基本类型数字，字符串和布尔值都有对应有包装对象。对象的一个特征是你可以在它身上直接调用方法。对于数字基本类型，当试图在其身上调用toString方法会失败，但用括号括起来后再调用就不会失败了，内部实现是用相应的包装对象将基本类型转为对象。所以(1).toString()相当于new Number(1).toString()。因此，你的确可以把基本类型数字，字符串，布尔等当对象使用的，只是注意语法要得体。
同时我们注意到，JavaScript中数字是不分浮点和整形的，所有数字其实均是浮点类型，只是把小数点省略了而以，比如你看到的1可以写成1.，这也就是为什么当你试图1.toString()时会报错，所以正确的写法应该是这样：1..toString()，或者如上面所述加上括号，这里括号的作用是纠正JS解析器，不要把1后面的点当成小数点。内部实现如上面所述，是将1.用包装对象转成对象再调用方法。
使用new则是将之当做构造函数来调用，会创建一个该类的实例对象，这个对象的type是这个函数名，中间使用this.propertyname=value会对该实例对象的属性赋值，并且无论有没有return，都会返回这个对象。
而如果是直接调用就是简单执行里面的代码，不会创建实例对象，this指向的调用环境下的this对象，如果是在全局中直接调用，就是window，没有默认返回值。
想要创建类，一般用前者（构造器模式），当然也可以使用后者，例如工厂模式和寄生构造器模式。
构造器模式:
function Person(name,age,job){
this.name=
this.introduce=function(){
alert("My name is "+this.name+", I am"+age+"year(s) old, I am a "+job+".");
工厂模式：
function createPerson(name,age,job){
var o=new Object();
寄生构造器模式:
function SpecialArray(){
var values=new Array();
values.push.apply(values,arguments);
values.toPipedString=function(){
return this.join("|");
后两种方法的缺点在于因为返回的还是object类型，所以不能通过instanceof来检测实际类型。
下面实例说明一下：
javascript函数能通过new操作符来调用构造器,比如new Chenqiguo()。就其定义而言,和普通的函数没有任何区别。事实上区别在于:当函数调用new操作符时,javascript为它提供了一个prototype对象;而当函数被用作构造器构建新的对象时,其内部的[[prototype]]属性就成为了被构建对象的引用
这句话是什么意思呢，我们先来看下面的代码
function Chenqiguo(){
alert('qiguo');
Chenqiguo()和new Chenqiguo()出来的效果都是一样的,都会打印qiguo这个字符串,而把代码换成如下的方式的话:
function Chenqiguo(){
alert('qiguo');
Chenqiguo.prototype.getName = function(){
alert('prototype qiguo');
我们分别用new实例化构造函数和用普通的函数执行对原型求值
var chenqiguo = new Chenqiguo();//打印qiguo
chenqiguo.getName(); //打印prototype name
var name = Chenqiguo();
//打印qiguo
name.getName();
//会报错, name is undefined
可以看到当我们用new 操作符创建的对象的时候能够打印原型上的值,而用常规函数的时候却不能,这样就解释了在我们当把函数当作构造函数创建新的对象的时候,其内部的prototype属性成为了被创建对象的一个引用.
抛开语言层次来观察函数和构造器的话,构造器的名称通常都使用首字母大写的形式来表表明其是一个构造函数，用小写字母的话就表示其是一个普通的函数.作为javascript的人员来说,应该严格区分这两种情况,如果是构造器就首字母大写,否则首字母就小写
以上是云栖社区小编为您精心准备的的内容，在云栖社区的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索对象
new 对象 构造函数、js new 对象、js new file对象、js new image对象属性、js new一个对象，以便于您获取更多的相关知识。
稳定可靠、可弹性伸缩的在线数据库服务，全球最受欢迎的开源数据库之一
6款热门基础云产品6个月免费体验；2款产品1年体验;1款产品2年体验
弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率
开发者常用软件，超百款实用软件一站式提供
云栖社区(yq.aliyun.com)为您免费提供相关信息，包括
，所有相关内容均不代表云栖社区的意见！博客分类：
这里所说的JavaScript指浏览器环境中的包括宿主环境在内的。第一种是ECMAScript Global Object，第二种是宿主环境(Host)下的全局对象/函数。一、核心JavaScript内置对象，即ECMAScript实现提供的不依赖于宿主环境的对象。
这些对象在程序执行之前就已经（实例化）存在了。ECMAScript称为The Global Object，分为以下几种
1， 值属性的全局对象(Value Properties of the Global Object)。有NaN，Infinity，undefined。
2， 函数属性的全局对象(Function Properties of the Global Object)。有eval，parseInt，parseFloat，isNaN，isFinite，decodeURI，encodedURI，encodeURIComponent
3，构造器(类)属性的全局对象(Constructor Properties of the Global Object)。有Object，Function，Array，String，Boolean，Number，Date，RegExp，Error，EvalError，RangeError，ReferenceError，SyntaxError，TypeError，URIError。
4，其它属性的全局对象(Other Properties of the Global Object)，可以看出成是Java中的静态类，可以直接用类名+点号+方法名使用。有Math，JSON。
ECMAScript规范提到这些全局对象(The Global Object)是具有Writable属性的，即Writable为true，枚举性(Enumerable)为false，即不能用for in枚举。ECMAScript有这么一段
Unless otherwise specified, the standard built-in properties of the global object have attributes {[[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}.
虽然规范提到The Global Object是可以被重写的，但不会有谁去重写它们的。这里仅仅做个测试。
Object = 33;
alert(NaN);
alert(eval);
alert(Object);
alert(Math);
分别取值属性的全局对象， 函数属性的全局对象，构造器(类)属性的全局对象，其它属性的全局对象NaN，eval，Object，Math。结果如下:
IE6/7/8 Firefox/Chrome/Opera
IE9/Safari
alert(NaN)
alert(eval)
alert(Object)
alert(Math)
结果可以看出除了NaN在IE9(pre3)/Safari不能被重写外，其它都被重写了。
这里只是列举了四个，感兴趣的可以将以上所有的The Global Object一一测试下。这里想表达的是核心JavaScript内置对象一般是可以被重写的
，虽然没人这么干。
下面测试下其枚举性
for(var a in NaN){
for(var a in eval){
for(var a in Object){
for(var a in Math){
所有浏览器都没有弹出，即属性不被枚举。感兴趣的可以将以上所有的The Global Object的枚举性一一测试下。
当然对于有些浏览器如Firefox，某些Global Object被重写后又是可以被枚举的。
二、宿主环境提供的全局对象/函数 。
如window,alert,setTimeout,document,location等，多数浏览器都会限制其重写，如
window = 55;
alert(window);
该句在IE下会出错提示非法复制，后面的弹出框没有执行。其它浏览器则当window=55不存在，仍然弹出了window。
再重写下alert
alert = 55;
console.log(alert);
IE下提示报错，Firefox/Chrome/Safari/Opera竟然被重写了，从对应的控制台可以看到输出了55。可以看出对于宿主环境提供的全局对象/函数，有的浏览器不支持重写，有的则可以重写
以下是两种方式声明全局变量
var a2 = 22;
for(a in window){
if(a=='a1'||a=='a2'){
上述代码在IE中不会弹出信息框，在IE中如下
with(host_object){//window
with(global_object){//Global
var a2 = 22;
即a1，a2是作为上面说的第一种，JS引擎提供的Global对象上的属性，而非第二种宿主环境提供的window对象上的属性。因此IE中for in window时a1，a2都不存在。如果IE中提供对象Global对象的引用，没准下面的代码可以弹出信息框。
for(a in Global){
if(a=='a1'||a=='a2'){
在Firefox/Safari/Chrome/Opera中大概是下面的样子
//Firefox/Safari/Chrome/Opera
with(host_object){//window
var a2 = 22;
with(global_object){//Global
即a1,a2是作为上面说的第二种，宿主环境提供的全局对象window上的属性。因此for in window时a1，a2都存在，弹出了信息框。
再看第三者方式声明全局变量window.a3 = 33，这样是显示的把a3挂在window上作为window的属性，因此在所有浏览器中for in window时都能获取到a3。
论坛回复 /
(3 / 2359)
浏览: 797961 次
来自: 北京
LZ 提供的链接地址失效了
LovingBaby 写道function fun() {}f ...
说的很清楚！jQuery作者为了实现简洁调用的苦心！高超的编程 ...
这不能算是任意进制之间的转换，例如二十六进制、十二进制又该如何 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'博客分类：
相信两种方式大家都用过，但未必所有人都知道其 ，内部原理。
function func1(x,y){
// your code
var func2 = function(x,y){
// your code
方式1 是典型的函数声明(Function declarations)。
方式2 是函数表达式(Function expressions)，将一个匿名函数赋值给一个变量。或者说方式2中创建了一个具有形参为x,y的匿名函数，然后把该匿名函数赋值给变量func2。
其主要区别在于：
1， 函数声明需显示的指定函数名，这里是func1；函数表达式则使用匿名函数
2， 方式1在代码执行之前(解释期)被加载到作用域中，方式2则需在代码执行时(运行期)加载
一个简单示例就明白了它们在使用上的区别
alert(func1); // --& func1源码
alert(func2); // --& undefined
function func1(x,y){
// your code
var func2 = function(x,y){
// your code
可以看到，第一次弹出的是func1的源码，第二次却是undefined。即采用方式1(函数声明)定义函数，可以在该函数代码之上使用它，采用方式2(函数表达式)定义函数则不能在其定义前使用，只能在其定义后使用。
其内部涉及到 执行上下文(Execution context)及 激活对象(Activation object)。想更深了解的请阅读EcmaScript 5文档。
最近发现越来越多的人喜欢使用方式2定义函数，尤其在嵌套函数中。如单纯的定义一个函数个人还是习惯方式1。
论坛回复 /
(12 / 7332)
可以这样简单理解，js解释器在执行js代码的时候分为2个阶段。
首先，加载所有函数声明，初始化var声明的变量。
然后，顺序执行代码。
所以，无论函数在那里声明，都会最先加载，保证在运行时函数是有效的。是不是匿名函数没啥区别。
初始化var声明的变量，只是表明变量存在，变量的赋值在执行时进行。
但是，实际上的执行过程比这个要复杂些，其中还涉及到变量的范围，作用域链等细节。
多谢解答,谢谢
楼主可以做另一个实验，更简单一些的实验：
function func() {
&&& alert(v1);
}
func();
这时会抛出异常，因为从当前context一直找到global都没有这个对象。
而如果：
function func() {
&&& alert(v1);
&&& var v1 = 1;
}
这时候会弹出窗口undefined
这说明js引擎在构造函数context和activation object的时候（称为构建期），会事先检查var关键字并创建reference，只是这个reference的赋值是runtime的
而用function func() {}这种非匿名方式创建的函数，在构建期就会被加入活动对象中。
个人估计，这是为了闭包~
不错，楼主的命题虽小但是包含了许多语言特性。
你这例子前后都不一致，根本说明不了什么东西，在js里面，定义在函数里的局部变量，是在整个函数范围可以访问的，所以是可以在定义前访问的，和函数声明方式没关系
浏览: 797963 次
来自: 北京
LZ 提供的链接地址失效了
LovingBaby 写道function fun() {}f ...
说的很清楚！jQuery作者为了实现简洁调用的苦心！高超的编程 ...
这不能算是任意进制之间的转换，例如二十六进制、十二进制又该如何 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'忽然间茫然之javascript函数和对象 - ITeye问答
大家不要笑话我 前天晚上睡觉时候忽然想到这个问题 javascript对象是由函数构造的 可是我感觉貌似用函数就够了 使用对象就是为了多个继承吗& 我发现自己很多时候用函数就够了& 到底什么时候是必须用函数的呢&
唉 脑子很乱 这样写也不知道大家看的懂我的意思不···
问题补充：谢谢大家啦& 看着大家都回复感觉无比幸福& 继续研究研究 不急结贴 呵呵
问题补充：lqixv 写道看了你的疑惑后，我认为，你不明白的是为什么要使用对象，而不是JavaScript实现对象的方法。
也就是说，你的思想里还没有面向对象设计的思想，而是在用面向过程设计的的思维。这与那种程序语言无关。
要真正解决你的疑惑，你觉得你要学习一些面向对象设计方面的书，去理解面向对象的思想，而不是看其如何实现面向对象的。
感谢好像是的& 我很喜欢我学的第一个语言&& C
问题补充：但是 对象应该是比函数强大的啊& 可惜我没体会到～～
问题补充：lqixv 写道等元旦放假的时候，写篇文章把我的理解写一下。你再看一下吧。
期待中& 一定要写啊！！ 先支持下！！
采纳的答案
引用蔡老师说：“至于Object与Function的区别，感觉最大的还是在于原型”
我的理解是
Object和Function的原型都是挂接在Function.prototype上，挂在同一原型上没有区别。
对象和函数才是有区别的！
var obj = new Object();//对象
obj的原型是挂在Object.prototype上
var fn = new Function("参数","//code")；
fn的原型是挂在Function.prototype上
应该是：
fn 和obj有区别因为原型不同（Object.prototype 与 Function.prototype有区别）
话说是Object与Function的区别，其实真正说的是其实例的区别。
Object与Function本身是没什么区别的，其两者都既是函数又是对象。
Object instanceof Function =& true
Function instanceof Object =& true
我认为两者的区别在于Object.prototype产生的是{}，而Function.prototype产生的是function(){}。所以我赞成你的那句话。
其实质还是在于{}与function(){}不同。主要因为{}不是一个Function，所以也没有prototype。通常可以看成一个简单的数据集合。如:
{} instanceof Object =& true
(function(){}) instanceof Object =& true
{} instanceof Function =& false
(function(){}) instanceof Function =& true
由上可以看出，Object实例{}并不是一个Function。因为Function有个很大的特色就是原型链，所以Object实例并没有继承这个特色。
var a = {};
var b = function(){};
var c = new a(); //Error
var d = new b();
var e = a. //undefined
var f = b. //Object
因此，{}与function(){}的区别在于function(){}可以看做一个Function对象，用来生成新的实例，而{}不能。所以上例中var c = new a();会抛出错误。
引用貌似用右手就可以了，找个老婆就是为了释放右手吗？我发现很多时候使用右手就可以了，到底什么时候是必须用右手的呢
哈哈，经典！
JavaScript中函数(function)也是一种数据类型，跟数字(number)、字符串(string)一样,将一个函数实例化，就会产生一个对象(object)类型，这些都可以通过typeof函数还求的当前变量的数据类型。
function a() {
this.property1 = "circleName";
this.property2 = 2;
function compute (r) {
return 3.14*r*r;
this.getArea = function() {
return compute(this.property2);
var myCircle = new a();
alert(typeof(myCircle.property1));
alert(typeof(myCircle.getArea()));
alert(typeof(myCircle));
alert(typeof(a));
上面代码中四个alert分别显示：
number string object function
感觉说的还是比较浅显易懂的。我们可以把JavaScript中函数理解成java中的类，虽然JavaScript不是面向对象的语言，我们也不经常使用它的基于对象的特性，但是JavaScript中的函数还是和java中的类有许多相似之处的，比如都有成员属性（类如a函数中的property1），成员方法（例如a函数中的getArea）。只是我们在实际编程中函数式编程习惯用的多一些，像这种基于对象的编程用的比较少，让我们忽略它的基于对象特性，其实JavaScript稍加改造，也是可以实现面向对象中继承之类的操作的，这些就超出了几天的讨论范围了。
读大学的时候，我感觉JS是最难的，等明白了，其实也那样的。熟悉了就好
我的理解是在JS中函数和对象的区别很微弱, 为什么用函数来构建对象, 其原因主要在于:
1. 用函数构建的对象, 可以使用new来创建, 因此我们更习惯接受这种方式创建对象.
var a = {}, b = function(){};
var c = new a();//error
var d = new b();
2. 用函数构建的对象, 可以实现私有和公有方法, 这与我们平时认识到的对象特性相符.
var clazz = function(){
var privateMethod = function(){alert('This is a private method');};
this.publicMethod = function(){alert('This is a public method')};
this.invokPrivateMethod = function(){privateMethod();};
var instance = new clazz();
instance.publicMethod();//alert'This is a private method'
instance.invokPrivateMethod();//alert'This is a public method'
instance.privateMethod();//error
3. 通过对Function的pototype进行改造, 可以加入构造函数, 通过反射实现的继承, 与我们平时理解的继承特性几乎一致.
由于涉及代码较多, 这里没有举例, 如果有兴趣可以参考ExtJs的实现. 在ExtJs中, 继承, 也就是扩展时(Extend), 将方法写在构造函数中(Constructor), 全都是公有的, 如果只是写在继承或者扩展里(Extend), 则仅在此对象内部有效, 即全为私有.
4. 另外通过函数可以实现闭包, 也可以实现代理, 使用{}对象中不行.
因此, 如果仅仅是承载数据, 类似于json的话, 直接使用{}对象, 不然都使用function吧, 优点多多.
其实是不同方法的不同表现
对象是由属性构成的 不是函数
函数方法只是作用在这些属性上
以上的话和语言无关
另外 js不是面向对象的 是基于对象
深奥，需要睡觉的时候，人静的时候思考。何时该用对象，何时该用函数。。如果，可以替换，可能还是对js不够了解。
面向对象的思想
可能你明白面向对象跟面向过程的区别，就会发现他的好处
上面写错一句话，应改为:
1、对象往往是一些属性与方法（函数）的集合体，二者没有可比性。
你的问题：
1、“但是 对象应该是比函数强大的啊& 可惜我没体会到～～”
答案是：对象并不比函数强大！
2、“感谢好像是的& 我很喜欢我学的第一个语言&& C ”
面向对象设计与语言没有关系，有差异的是面向对象设计的语言与面向过程设计的语言。一句话，就是语言的不同。
以上的原因解释：
1、对象往往是一些属性与方法（函数的集合体），二者没有可比性。
2、你注意没有，你常常会看到这样的词语“面向对象设计”，“面向过程设计”，这两个词语真正的共同点，或说其想表达的中心在于“设计”！而“面向对象”和“面向过程”，只是其实现“设计”的方法的不同。既然其目的是“设计”，那你用什么语言来设计，都是可以的。因此，很多人如果没有建立起面向对象设计的思想，那他即使使用面向对象设计的语言去设计系统，他也只是使用面向过程式的思想去设计系统。那么同样的，一个人如果有很强的面向对象设计的思想，那他完全可以用过程式的语言，甚至用汇编语言，同时用面向对象的思想去设计他的系统。
但要阐述清楚面向对象与面向过程的思想，不是这几句话区分得了的。等元旦放假的时候，写篇文章把我的理解写一下。你再看一下吧。
ECMAScript5标准中的bind方法确实可以让你不再用函数构造对象。
比如
& var a = function(x,y){return this.base*(x+y)}
& var b = a.bind({base: 3})
不要忘记：万物皆对象。那么函数本身也就是对象。函数对象区别于普通对象的唯一差距就是函数式对象可以执行。
看了你的疑惑后，我认为，你不明白的是为什么要使用对象，而不是JavaScript实现对象的方法。
也就是说，你的思想里还没有面向对象设计的思想，而是在用面向过程设计的的思维。这与那种程序语言无关。
要真正解决你的疑惑，你觉得你要学习一些面向对象设计方面的书，去理解面向对象的思想，而不是看其如何实现面向对象的。
引用关键是这个
Function instanceof Object =& true
先判断Function._proto_ == Object.prototype 发现不匹配
于是Function._proto_ == Object.prototype._proto_ //
你说反了
Function instanceof Object的依据不是
Function._proto_ == Object.prototype._proto_
而是
Function.prototype._proto_ == Object._proto_
Object instanceof Function =& true
Function instanceof Object =& true
这个写法曾经困扰我很久
instanceof 是如何判断的呢？
假设 obj =
那么 obj instanceof fn //
最初我一直认为instanceof是这样判断的
obj.constructor ===fn 所以true
后来我发现是这样的！
找到obj的内置原型,用它和构造函数的原型进行比较（obj._proto_==fn.prototype)
如果发现不匹配 就在原型中找上一级原型(fn.prototype._proto_)
如果还找不到 就继续找上一级原型(fn.prototype._proto_._proto_)
原理说了，接下来再看
Object instanceof Function =& true //这个很好理解
Object = new Function("","");//Object是由Function构造出来的
Object._proto_ === Function.prototype //ture&
关键是这个
Function instanceof Object =& true
先判断Function._proto_ == Object.prototype 发现不匹配
于是Function._proto_ == Object.prototype._proto_ //
不知道我有没有表达清楚&_&
哇塞，居然有蔡老师的留言^_^,增加了我学js的动力
我的理解：
1.函数只包含操作，比如要做什么处理，可以写个函数。
2.对象是包含数据的，比如json数据，就是对象的形式。
应该是两个不同的东西吧，如果要把数据以函数的形式写，那估计也别扭。
我的理解：
1.javascript本身是个函数式语言，所以只写函数也ok。
2.javascript也有对象，不说具体，举个例子window本身就是对象。
3.所有的javascript变量可以声明为var xx = zz。这样的形式，可以不放在函数里面，那么它本质上是被定义到了window.xx作为全局属性。所以本质上还是对象。
4.比较重要的一点是，javascript可以采用对象形式。那么你会不会选择用呢？
&&& 如果你只是界面的简单的显示逻辑，那用它不会有什么好处的。
那假如你写过几千行或者上万行的js来表达一个很富有逻辑的代码段。你会使用函数，你要用多少个函数，多少个全局变量来保存多少种信息，你觉得你写出的那成千上百的函数和变量，最后你自己还清楚吗。
&&& 用辩证法角度来看，什么都有好有坏，择其优而用。
首先,从概念上理解吧....
对象---&有属性有执行体(函数);
函数---&可以理解为一个单一的执行过程;
javaScript 个人认为语法相当的灵活.虽然可以通过函数去构造对象,但是完全使用函数有其局限性;
比如说:
你去描述一个人的时候
var person = {};
person.age = 20;
person.sex = "f";
person.fire = function(/***/){};
........
然后你就可以直接调用.....如果你用函数的话也完全可以实现,但是麻烦的很多吧???
把这个认真的看完就明白了：
http://www.iteye.com/topic/155109
看你封装的程度了，方法级别的就函数级别就够了，当你想封装组件级别的面向对象更能体现整体。
javaeye为什么时常不能正常访问呢？到底是为什么？谁能告诉我啊？
面向对象而不是过程~
这个时期，一般都有过，很多人由于工作原因（用不到），没有继续走下去。希望楼主可以继续深入的研究下去。建议你读一下《悟透JavaScript》。可以提高你的JavaScript的段位。
这篇文章读完以后，就是要实践了，在你接触的系统中，如何巧妙的运用JavaScript是就需要你一点点的积累和总结了。希望楼组精益求精。
当程序的复杂度是你倍感苦恼，当你想追求简单时，就可以考虑使用对象了。
蔡老师说：“至于Object与Function的区别，感觉最大的还是在于原型”
我的理解是
Object和Function的原型都是挂接在Function.prototype上，挂在同一原型上没有区别。
对象和函数才是有区别的！
var obj = new Object();//对象
obj的原型是挂在Object.prototype上
var fn = new Function("参数","//code")；
fn的原型是挂在Function.prototype上
应该是：
fn 和obj有区别因为原型不同（Object.prototype 与 Function.prototype有区别）
感觉直接写函数的话，相对于对象少了些对象特有的属性，二用new来声明就可以使用这些属性，还有上面说到的原型，在js里也很重要。
javascript对象是由函数构造的
还有一句话是：
javascript的函数也是由函数构造的
var Object = new Function("","[native]code");//这个是构造过程
另外补充一点：由Function构造函数构造出来的对象可以用new关键字继续创建对象
所以上面创建的对象其实就是：
function Object(){
& //[native]code
}
然后我们new Object就创建出了对象。
最后说下个人理解：
javascript对象和函数 都是由 Function函数构造出来的。
函数主要是完成一些功能，声明一个对象传递参数更方便。声明对象的方法可以区别同名函数。
如果你仅仅是指
function(){}
的定义方法。
那么使用Object定义方式也行的，基本上没区别，不用钻牛角尖。
至于Object与Function的区别，感觉最大的还是在于原型
貌似用右手就可以了，找个老婆就是为了释放右手吗？我发现很多时候使用右手就可以了，到底什么时候是必须用右手的呢
已解决问题
未解决问题