请教几个js概念性问题

Question

1)object["xxx"]与object.xxx有什么区别
2)object.prototype.xxx = function(){}与object.xxx = function(){}有什么区别.这两个问题涉及到了js一些比较本质的东西.大犀牛那本书中描述的给我感觉不是很清晰.望大牛解答.谢谢

Answer 1

object["a"] 和 object.a没什么区别
但object["2-1.0"] 和 object.2-1.0差别就大了。
即：用[]访问属性时没有字符限制。第二个问题看其他人咋说吧，我是来蹭分的。

Answer 2

var b="123";
object[b] 和 object.b的区别也挺大恩

Answer 3

谢谢伴水哥给新人机会...
object.prototype.xxx = function(){}实例方法object.xxx = function(){}这个就普通的类方法咯...

Answer 4

1）没有区别，并且javascript里面对象的方法、属性都可以采用这两种方式引用。
比如Math[document.all?'ceil':'floor'](12.3);
javascript里面function也是一种数据类型，
所以任何对象的“方法”都可以看做是“属性”，只是这个“属性”是一个function类型的
2）上代码<script>
function a(){};
a.prototype.f = function(){alert(1111)};
a.f = function(){alert(22222)};
a.bb = 12121;
var s = new a();
a.f();
s.f();
alert(a.bb);
alert(s.bb);
</script>prototype是js实现类的形式。
简单的说，就是所有new的对象，都继承prototype的方法，但是不继承他本身的方法、属性。

Answer 5

object["xxx"]与object.xxx 没有什么区别
object["xxx"]相对来讲比object.xxx更灵活，它可以动态修改属性 而object.xxx就不能
例： document.onclick=function(){.....}  
    
    document["on"+vEvent]=function(){.....}
其它这个vEvent就是个变量，，可能赋值 click .mousedown ...prototype对象原型 只能是函数 或者类才能访问
   例： 编一下类： function Class1(){
                     this.vEvent=function(){alert("vEent")}//添加成员方法
                        Class1.prototype.color="red"  //添加成员属性 
                        Class1.prototype={
                                      width:500,
                                      Height:200
                                  } //当该类被实例化时，prototype对象的成员，会作为实例化对象的成员
                }
                    object.xxx=function(){} //在javascript允许为对象无限制的添加属性和方法
例： document.xxx="123"
    alert(document.xxx) //弹出123

Answer 6

在javascript 中函类 其它就是一个类 函数本身也是一个对象
  
  function xy(){
            xy.color="red" //添加静态成员属性 访问的时候 必须 以类名 xy.color访问
              xy.alert=function(){                    }//添加静态成员方法
             var qq="123" //定义类的私有属性
             function qy(){ .....}  //定义类的私有方法
              this.ww=qy() //调用类的私有方法 
             
       }

Answer 7

object["a"] 和 object.a没什么区别
但object["2-1.0"] 和 object.2-1.0差别就大了。
即：用[]访问属性时没有字符限制。1楼正解
function Obj()
{
this.xxx2=function(){};// 相当于公共属性
}
Obj.prototype.xxx1 = function(){}
xxx1  函数 Obj 的所有实例共享,在内存中只保存一个引用
xxx2   每个Obj 的实例都会保存一个引用

Answer 8

1)object["xxx"]与object.xxx有什么区别
  object["xxx"]中的xxx是字符串，而字符串是可以在代码中操作和改变的，比如说我有一个对象circle,我要遍历它的所有属性并显示出属性值，就可以用如下代码：var circle={x:0,y:0,radius:10};
var props="";
for (var propname in circle)
{
    props+="circle."+propname+":"+circle[propname]+"<br />";
}
document.write(props);  而object.xxx中的xxx是标识符，标识符是只能编程者自己手动写出来的，不能用代码操作，如上面的循环语句你就不把circle[propname]改成circle.propname,要这样改的话代码会理解成为你在访问一个叫circle.propname的属性，而显然这个属性是underfined.2）object.prototype.xxx = function(){}与object.xxx = function(){}
   object.prototype.xxx=function(){}中的xxx是对象本身的方法，每个对象都可以有很多个实例，但是用prototype定义的方法，不会被实例化到每个实例中，它仍然只是在对象中存在，当在实例中查询这个方法时，首先会检查这个实例是不是有xxx这个方法，如果没有，就会向上返回到object查询xxx这个方法，这时显然是可以被查到的，然后xxx被调用。而object.xxx=function(){}中的xxx方法，是会随着实例的建立而建立的，查询的时候在实例中就能直接查询到xxx方法，而不会返回到object这一层来查。通俗点讲，就好像你有三个孩子和一辆车，如果你把这辆车给三个孩子开，每个孩子要车时都需要找到你拿钥匙，那么就是object.prototype.xxx,而如果你给三个孩子重新买三辆车，那就是object.xxx

Answer 9

object["xxx"]与object.xxx有什么区别最大的区别就是动态修改属性object["123"] 一般的情况 不会使用 ，，也用不到啊

Answer 10

5楼的：
所有new的对象，都继承prototype的方法，但是不继承他本身的方法、属性。

Answer 11

所有new的对象，都继承prototype的方法，但是不继承他本身的方法、属性。

Answer 12

没有区别，并且javascript里面对象的方法、属性都可以采用这两种方式引用。

Answer 13

没有区别，并且javascript里面对象的方法、属性都可以采用这两种方式引用。

Answer 14

 本质上没有区别
object.prototype.xxx=function(){}中的xxx是对象本身的方法，每个对象都可以有很多个实例，但是用prototype定义的方法，不会被实例化到每个实例中，它仍然只是在对象中存在，当在实例中查询这个方法时，首先会检查这个实例是不是有xxx这个方法，如果没有，就会向上返回到object查询xxx这个方法，这时显然是可以被查到的，然后xxx被调用。而object.xxx=function(){}中的xxx方法，是会随着实例的建立而建立的，查询的时候在实例中就能直接查询到xxx方法，而不会返回到object这一层来查。

Answer 15

有很大区别
prototype属性作用是 当以构造方式(new 关键字)调用函数时，将以什么为模板创建对象，并将函数的this指向创建的新对象。A.object.prototype.xxx = function(){}
B.object.xxx = function(){}A：无法调用object.xxx() 因为 object不包含xxx， object的prototype成员包含xxx  ，new object();包含xxx
B：可以调用object.xxx() 但var newObj=new object();不包含xxx说白了当new object()时 将会把object.prototype对象复制，将object函数的this指向这个复制的新对象

Answer 16

补充，在已new方式调用object函数时   object本身并没有被复制 

Answer 17

object["xxx"]可以使用变量
object.xxx只能使用常量

Answer 18

A.object.prototype.xxx = function(){}  这个就是普通方法B.object.xxx = function(){} 相当于java或者c#中的static修饰的方法

Answer 19

这涉及到了 原型链和作用域链的问题 涉及到了很多JS的基础知识 理解起来是有点儿费脑壳
今晚陪媳妇儿加班 没啥子时间总结 明天整理下发 先MARK下！

Answer 20

1、有区别。
var obj = {0 : "春香", 1 : "夏香", 2 : "秋香", 3 : "冬香"};
alert("唐伯虎点" + obj[2]) // OK
alert("唐伯虎点" + obj.2) // 错误2、object.prototype.xxx = function(){}与object.xxx = function(){}区别：
后者是说给对象“object”添加方法“xxx”，而前者是说给对象“object”的原型添加方法“xxx”。对于方法“xxx”，后者只能通过唯一的对象“object”调用，前者可通过原型派生出来的所有实例继承调用。

Answer 21

在JavaScript中，每个对象可以看作是多个属性（方法）的集合，引用一个属性（方法）
很简单，即：
对象名.属性（方法）名
除此之外，还可以用方括号的形式来引用：
对象名["属性（方法）名"]
注意，这里的方法名和属性名是一个字符串，而非原先点号后面的标识符，例如：
var arr=new Array();
//为数组添加一个元素
arr["push"]("Leepy");
//获得数组的长度
var len=arr["length"];
//输出数组的长度
alert(len);
上面的代码等价于：
var arr=new Array();
//为数组添加一个元素
arr.push( "Leepy");
//获得数组的长度
var len=arr.length;
//输出数组的长度
alert(len);
这种引用属性（方法）的方式和数组类似，也体现出一个JavaScript对象就是一组属性（方法）的集合这个性质。
这种用法适合不确定具体要引用哪个属性（方法）的场合，例如：一个对象用于表示用户资料，这时一个字符串表示要使用哪个属性，那就可以用这种方式来引用：
<script language="JavaScript" type="text/javascript">
<!--
//定义了一个User 类，包括两个成员age和sex，并指定了初始值。
function User(){
this.age=23;
this.sex="男";
}
//创建user 对象
var user=new User();
//根据下拉列表框显示用户的信息
function show(slt){
if(slt.selectedIndex!=0){
alert(user[slt.value]);
}
}
//-->
</script>
<!--下拉列表框用于选择用户信息-->
<select onchange="show(this)">
<option>请选择需要查看的信息：</option>
<option value="age">年龄</option>
<option value="sex">性别</option>
</select>
在这段代码中，使用一个下拉列表框让用户选择查看哪个信息，每个选项的value就表
示用户对象的属性名称。这时如果不采用方括号的形式，就必须使用如下代码来达到预期效
果：
function show(slt){
if(slt.selectedIndex!=0){
if(slt.value=="age")alert(user.age);
if(slt.value=="sex")alert(user.sex);
}
}
而使用方括号语法，则只需写为：
alert(user[slt.value]);
由此可见，方括号语法更像一种参数语法，可用一个变量来表示引用对象的哪个属性。
如果不采用这种方法，又不想用条件判断，可以使用eval函数：
alert(eval("user."+slt.value));
这里利用eval函数的性质，执行了一段动态生成的代码，并返回了结果。
实际上，在document 的集合对象时，就有类似方括号的用法，比如引用页面
中一个名为“theForm”的表单对象，曾经的用法是：
document.forms["theForm"];
其实也可以写为：
document.forms.theForm;
但这里的forms 对象是一个内部对象，和自定义对象不同的是，它还可以用索引来引用
其中的一个属性。

Answer 22

object["a"] 和 object.a没什么区别
object[a] 和 object["a"]不同
object[a] 和 object.a不同
object[a]的a是一个前面已经赋值的变量或者表达式
object["a"]里面的a是一个字符串常量或者字面值另外，当里头是纯数字的0或自然数的时候，如object["1"] 和object[1] 和 object.1没什么区别
例如一个数组var a=[11111,22222,33333];
那么 a.1,a["1"],a[1],a[1.0],a[0.5*2]都是22222，
但是a["1.0"],a["0.5*2"]是undefined用jsLint检查js文件规范性的时候，如果aaaa["bbbb"]的形式会被提示应改为aaaa.bbbb
当且仅当里面的bbbb是一个可以常量字符串、且是一个可以做变量名的串。

Answer 23

方法属性灵活多变。不过按照教程上说的是：动态原型方式比较好些！属性用动态：this.xxx=yyy;方法用原型：xy.prototype={xxx:function(){...}};这种方式用得比较多也比较常见！

Answer 24

1)object["xxx"]与object.xxx有什么区别第一，前者可以用特殊字符，中文等，但后者只能用是符合规定的标识符。第二，前者可以动态的用代码来访问属性，而后者不行，这个是它们最重要而且是最有意义的区别，如下面的代码，这断代码可以遍历对象obj的所有属性值，我们可以用obj["属性名"]动态的在代码中访问对象的属性，但是不可能用obj."属性名"来访问。也就是说下面的这断代码只能用前者实现，不能用后者实现。
var obj={a:1,b:2};
for(var key in obj){
  alert(obj[key]);
}2)object.prototype.xxx = function(){}与object.xxx = function(){}有什么区别.
这个问题要完全说明白，还真不太容易，我就简单的说一下吧
首先，要有类的概念，在javascript中，一个函数就是一个类，也就是如果定义了一个函数:function f(){} 那么f就可以当成一个类，然后就可以用函数创建对象了，如var x=new f();这句话的意思就是对象x是类f的一个实例.
上面的一断话对于没有学过面向对象的语言的人来说可能很抽象，但由于篇幅，我也只能说这么多，下面我就用对象x和类f来谈谈prototype。我们可以用f.prototype.xxx=function(){}//正确
上面的代码是给类的原型加一个属性，如果不懂啥是原型，你只须理解如果你使用了上面这句代码，那么用f创建的所有的对象都会有xxx这个属性，注意在javascript中属性可以为函数。
f.xxx=function(){}//正确
这句代码可能让人觉得很怪，但如果你见到这种情况，你把f不要当成函数来看，而要当成类来看，这句话的意思是为f这个类增加一个属性，而且这个属性只属于f,也就是说用f创建的对象不能访问这个属性，只能通过f 这个类来访问。也就是说只能这么用:f.xxx();而不能用它的对象x.xxx()来用xxx属性。
但不能用x.prototype.xxx=function(){}//错误，不能这样用
上面的代码有语法错误，因为prototype只能用类来使用，不能用对象来使用。好了，就说这么多吧。

Answer 25

还要补充一点，
x.xxx=function(){}也是正确的，它的意思是说为对象x增加一个属性，而这个操作只会影响x 对象最后说明一下，楼主问的第二个问题的区别就是我刚才说的f.prototype.xxx和f.xxx的区别。而x.xxx和楼主的问题没关，我是怕楼主弄混了，所以补充一下。

Answer 26

object["xxx"]与object.xxx 没有什么区别
object["xxx"]相对来讲比object.xxx更灵活，它可以动态修改属性 而object.xxx就不能

Answer 27

给个传送门给大家
http://blog.csdn.net/llyy112233/archive/2010/11/26/6036268.aspx大家看看嘿嘿