温馨提示！由于新浪微博认证机制调整，您的新浪微博帐号绑定已过期，请重新绑定！&&|&&
LOFTER精选
网易考拉推荐
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
&head&&title&JavaScript 对象方法 类方法 原型方法的区别;私有属性 公有属性 公有静态属性的区别&/title&&script language="javascript" type="text/javascript" &//定义Person类function Person(name){&& &//私有属性MyTime、ID&& &var MyTime = " ";&& &var ID="773C0D35-298A-EADC250ED61";&&&&& &//公有属性MyName&& &this.MyName =&& &//对象方法(实例化后才能调用) 位置：Person类的内部 语法格式：this.方法名称 = function([参数...]){ 语句行; }&& &this.ShowMyName = function() {&& & & & & & &alert("My name is " + this.MyName + MyTime );&& &}&& &//this.Init();}//类方法(实际是静态方法直接调用) 位置：Person类的外部 语法格式：类名称.方法名称 = function([参数...]){ 语句行; }Person.EnglishandFrench = function() {&& & //访问静态属性 语法格式：类名称.公有静态属性；或者使用语法格式：this.公有静态属性；&& & alert(Person.NAME + " can speak " + this.ENGLISH +" and "+ Person.prototype.FRENCH);}//原型方法(实例化后调用或者直接调用) 位置：Person类的外部 语法格式：类名称.prototype.方法名称 = function([参数...]){ 语句行; }Person.prototype.ChineseandFrech = function() {&& //编写一个原型方法相当扩充了一个对象方法，稍作变化可复制到类的内部成为一个对象方法;&& //访问公有属性 语法格式：this.公有属性; &&& //访问公有静态属性 语法格式：类名称.公有静态属性；&&& alert(this.MyName + " can speak " + Person.CHINESE + " and " + this.FRENCH+", "+ Person.prototype.FRENCH +" do better.");}//只有原型方法执行后内部扩充到Person类的属性才能生效Person.prototype.Init = function() {&& & & //定义公有属性PersonNo&& & & this.PersonNo = "";&& & & //定义公有数组属性 [] 等价于 new Array();它现在是几维数组或是混合数组要根据赋值后才知道&& & & this.ArrInfo = [];&& & & //定义一个json对象属性&& & & this.jsonData = {};}//公有静态属性 位置：Person类的外部Person.NAME="Jack";Person.ENGLISH="in english";Person.CHINESE="in chinese";//原型属性(当作公有静态属性使用 语法格式：类名称.prototype.公有静态属性；不能使用语法格式：this.公有静态属性；)//原型属性(当作公有属性使用 语法格式：类名称.prototype.公有属性； 或者使用语法格式：this.公有属性；)Person.prototype.FRENCH="in french";var p = new Person("Rose");//实例化p.ShowMyName();Person.EnglishandFrench();p.ChineseandFrech();//ChineseandFrech()当作静态方法直接调用，请注意 MyName是对象属性 原型方法内不能调用它//当作静态方法直接调用时内部成员必须都是静态属性，下面这样调用是错误的;Person.prototype.ChineseandFrech();//使用this.Init();这行代码放在定义Person类内部也一样初始化p.Init();p.PersonNo = "A1B2C3";alert(p.PersonNo);p.ArrInfo[0]='123';alert(p.ArrInfo[0]);p.ArrInfo[1]=["111","222","333"];alert(p.ArrInfo[1][2]);p.jsonData = { flash_url : "../swfupload/swfupload.swf",&&custom_settings : {&& & upload_target : "divFileProgressContainer"&& &},&& debug: false };alert(p.jsonData.flash_url+" &"+p.jsonData.custom_settings.upload_target);&/script&&/head&&body&&& & & &&div&E-mail:.cn&/div&&& & & &&div&尽量将方法定义为原型方法，原型方法避免了每次调用构造函数时对属性或方法的构造，节省空间,创建对象快.&/div&&/body&&/html&
阅读(1160)|
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
历史上的今天
loftPermalink:'',
id:'fks_086069',
blogTitle:'JavaScript 对象方法 类方法 原型方法的区别;私有属性 公有属性 公有静态属性的区别',
blogAbstract:'&html&&head&&title&JavaScript 对象方法 类方法 原型方法的区别;私有属性 公有属性 公有静态属性的区别&/title&&script language=\"javascript\" type=\"text/javascript\" &//定义Person类function Person(name){',
blogTag:'',
blogUrl:'blog/static/',
isPublished:1,
istop:false,
modifyTime:0,
publishTime:8,
permalink:'blog/static/',
commentCount:0,
mainCommentCount:0,
recommendCount:2,
bsrk:-100,
publisherId:0,
recomBlogHome:false,
currentRecomBlog:false,
attachmentsFileIds:[],
groupInfo:{},
friendstatus:'none',
followstatus:'unFollow',
pubSucc:'',
visitorProvince:'',
visitorCity:'',
visitorNewUser:false,
postAddInfo:{},
mset:'000',
remindgoodnightblog:false,
isBlackVisitor:false,
isShowYodaoAd:false,
hostIntro:'',
hmcon:'0',
selfRecomBlogCount:'0',
lofter_single:''
{list a as x}
{if x.moveFrom=='wap'}
{elseif x.moveFrom=='iphone'}
{elseif x.moveFrom=='android'}
{elseif x.moveFrom=='mobile'}
${a.selfIntro|escape}{if great260}${suplement}{/if}
{list a as x}
推荐过这篇日志的人：
{list a as x}
{if !!b&&b.length>0}
他们还推荐了：
{list b as y}
转载记录：
{list d as x}
{list a as x}
{list a as x}
{list a as x}
{list a as x}
{if x_index>4}{break}{/if}
${fn2(x.publishTime,'yyyy-MM-dd HH:mm:ss')}
{list a as x}
{if !!(blogDetail.preBlogPermalink)}
{if !!(blogDetail.nextBlogPermalink)}
{list a as x}
{if defined('newslist')&&newslist.length>0}
{list newslist as x}
{if x_index>7}{break}{/if}
{list a as x}
{var first_option =}
{list x.voteDetailList as voteToOption}
{if voteToOption==1}
{if first_option==false},{/if}&&“${b[voteToOption_index]}”&&
{if (x.role!="-1") },“我是${c[x.role]}”&&{/if}
&&&&&&&&${fn1(x.voteTime)}
{if x.userName==''}{/if}
网易公司版权所有&&
{list x.l as y}
{if defined('wl')}
{list wl as x}{/list}23:01 提问
原型的属性里面的方法如何获取到对象？
最近遇到了一个问题，简单地代码如下
function Mp3() {
this.songList = [
songName: 'ProblemsProblems',
singer: 'Frankie'
Mp3.prototype = {
songManger: {
add: function (obj) {
this.songList.push(obj);
var mp3=new Mp3();
mp3.songManger.add({songName:'',singer:''});
困扰我的是，构造函数的原型被替换之后，原型里面有一个属性，这个属性指向一个对象，而这个对象中又有一些方法，在这个代码里面指的add方法。
add方法内使用this获得的是它所存在的对象，也就是songManger，那么问题来了，我如何在add里面获得Mp3的原型（也就是add的爹的爹）？总不能用两次this吧？
因为最后实例化的对象调用的是songManger对象，然后songManger再调用的add放，这样是没办法获取到对象本身的属性（songList）的。
按赞数排序
this是songManger这个json对象，根本不是类的实例对象，干嘛要放里面去。。
你要弄Mp3.prototype.songManger.songList指向mp3的songList，由于对象，地址引用，可以直接修改。不过建议你自己搞清楚js的继承来先，不要乱搞一通
function Mp3() {
Mp3.prototype.songManger.songList=
this.songList = [
songName: 'ProblemsProblems',
singer: 'Frankie'
准确详细的回答，更有利于被提问者采纳，从而获得C币。复制、灌水、广告等回答会被删除，是时候展现真正的技术了！
其他相关推荐原型(prototype)对象中属性的修改问题 - ITeye问答
这是我在使用原型化构造函数时意外遇到的问题。下面是代码：
&script type="text/javascript"&
function Cons(){
//声明构造函数 Cons()
Cons.prototype.info="something";
Cons.prototype.showInfo=function(){
alert(this.info);
Cons.prototype.info="changed!";
//尝试修改原型中的属性
var inst=new Cons();
//建立实例 inst
inst.showInfo();
//修改无效,警告"something"
上面的代码无法修改 Cons() 的原型对象！但是把 Cons.prototype.info="changed!" 这句放在建立实例之后，就有效了：
var inst=new Cons();
//建立实例 inst
Cons.prototype.info="changed!";
//尝试修改原型中的属性
inst.showInfo();
//警告"changed!"
当时我就怀疑是不是在实例化 Cons() 之前,原型对象是无法访问的。不过很奇怪，可以在原型对象中建立新的属性：
&script type="text/javascript"&
function Cons(){
//声明构造函数 Cons()
Cons.prototype.info="something";
Cons.prototype.showInfo=function(){
alert(this.info);
Cons.prototype.newInfo="new!";
//尝试在原型中添加属性
var inst=new Cons();
//建立实例 inst
alert(inst.newInfo);
//有效，警告"new!"
这是怎么回事呢？从这个问题看，大家是如何理解 prototype 创建、访问和销毁等问题的？
问题补充现在发现其实这只是简单的一个执行顺序的问题首先,JS解释器会提前处理函数和变量声明,此时已经创建了 inst 、 Cons 和 Cons.prototype接着开始执行代码,到 Cons.prototype.info="changed" 时为 Cons.prototype 添加了属性 info:"changed"然后遇到 new Cons() 开始执行函数,将函数内部为 prototype 赋的值放入 Cons.prototype 中由于发现 info 重名,所以原来的值被覆盖 info:"something" ,如果将 Cons.prototype.info="changed" 放在后面,则覆盖顺序刚好相反最后,将创建好的对象交给 inst
额，你在构造函数里，把原型链重新赋值了。。。。。。
构造函数覆盖了修改属性的语句ons.prototype.info="changed!";
//尝试修改原型中的属性 。
这是执行顺序的问题，
建立实例inst的时候，把你的changed值改变成something了。
&script type="text/javascript"&&&
function Cons(){& //声明构造函数 Cons()&&
&&& Cons.prototype.info="something";&& //改变成someting，也就是覆盖了changed这个值。
&&& Cons.prototype.showInfo=function(){&&
&&&&&&& alert(this.info);&&
Cons.prototype.info="changed!";& //尝试修改原型中的属性&&
var inst=new Cons();& //建立实例 inst&&
inst.showInfo();& //修改无效,警告"something"&&
&/script&&
function Cons(){& //声明构造函数 Cons()
&&& alert('开始实例化时为'+this.info);//此时为changed
&&& Cons.prototype.info="something";
&&& alert('原型被改变'+this.info);//此时为something
&&& Cons.prototype.showInfo=function(){
&&&&&&& alert(this.info);
&&& }
}
Cons.prototype.info="changed!";& //尝试修改原型中的属性
var inst=new Cons();& //建立实例 inst
inst.showInfo();& //修改无效,警告"something"
//看下面的代码你就知道了
function Cons(){
//声明构造函数 Cons()
[b] alert('开始实例化时为'+this.info);//此时为changed[/b]
Cons.prototype.info="something";
[b]alert('原型被改变'+this.info);//此时为something[/b]
Cons.prototype.showInfo=function(){
alert(this.info);
Cons.prototype.info="changed!";
//尝试修改原型中的属性
var inst=new Cons();
//建立实例 inst
inst.showInfo();
//修改无效,警告"something"
错了，这是因为你
function Cons(){& //声明构造函数 Cons()&&
&&& Cons.prototype.info="something";&&
&&& Cons.prototype.showInfo=function(){&&
&&&&&&& alert(this.info);&&
}
在构造函数中赋值的prototype，所以当你在new之前改变该对象的原型的时候，其实你确实是变了，但当你再new的时候，那么你的构造函数的时候，构造函数里的赋值就再次执行了，也就是说，你在构造函数中再次对你的原型进行了赋值，所以就会反映出你在new之前改变原型的值无效。二。因为原型有个很明显的问题，所有的实例都是共享同一个原型的，所以不管你是在new之前改变原型的值，还是你在new之后改变原型的值，这些改变都会反映到每一个原型对应的实例上。
为啥非要放在构造函数的里边，一般不是放在外边？放里边有什么特别这意思。
prototype 创建、访问和销毁等问题的？
已解决问题
未解决问题一，instanceof：instanceof检测左侧的__proto__原型链上，是否存在右侧的prototype原型. 我在之前的两篇文章[js高手之路]构造函数的基本特性与优缺点[js高手之路]一步步图解javascript的原型(prototype)对象,原型链已经分享过了.function CreateObj(uName) {
this.userName = uN
this.showUserName = function () {
return '100';
CreateObj.prototype.showUserName = function () {
return this.userN
var obj1 = new CreateObj('ghostwu');
var obj2 = new CreateObj('卫庄');
console.log( obj1 instanceof CreateObj ); //true
console.log( obj2 instanceof CreateObj ); //true
console.log( obj1 instanceof Object ); //true
console.log( obj2 instanceof Object ); //true二、isPrototypeOf:如果隐式原型__proto__指向调用isPrototypeOf()方法的对象原型( CreateObj ), 那么这个方法就返回true，如:1
var obj1 = new CreateObj('ghostwu');
var obj2 = new CreateObj('卫庄');
console.log( CreateObj.prototype.isPrototypeOf( obj1 ) ); //true
console.log( CreateObj.prototype.isPrototypeOf( obj2 ) ); //true因为obj1,obj2的隐式原型__proto__指向的都是CreateObj.prototype， 有朋友可能会问CreateObj.prototype上面根本就没有isPrototypeOf这个方法，怎么可以调用呢？是的，没错，但是CreateObj.prototype的隐式原型__proto__指向了Object.prototype, 而isPrototypeOf存在Object.prototype上，所以就能够调用三、Object.getPrototypeOf获取实例的隐式原型(__proto__)的指向，因为obj1,obj2的__proto__都指向CreateObj.prototypevar obj1 = new CreateObj('ghostwu');
var obj2 = new CreateObj('卫庄');
console.log( Object.getPrototypeOf( obj1 ) === CreateObj.prototype ); //true
console.log( Object.getPrototypeOf( obj2 ) === CreateObj.prototype ); //true四，实例访问属性和方法时，遵循就近查找原则实例先在自己身上查找，有，就停止查找，如果没有，就沿着实例的__proto__继续往上查找，有，就停止查找，如果没有就继续沿着原型链一直往上查找，如果所有的原型对象上都没有，那就是undefined.function CreateObj(uName) {
this.userName = uN
CreateObj.prototype.showUserName = function () {
return this.userN
CreateObj.prototype.age = 22;
var obj1 = new CreateObj('ghostwu');
obj1.age = 20;
var obj2 = new CreateObj('卫庄');
console.log( obj1.age ); //20---&来自实例
console.log( obj2.age ); //22---&来自原型对象
delete obj1.
console.log( obj1.age ); //22---&来自原型五，hasOwnProperty判断属性是实例上的还是原型对象上的，如果是实例上的，返回true, 原型上的返回falsefunction CreateObj(uName) {
this.userName = uN
CreateObj.prototype.showUserName = function () {
return this.userN
CreateObj.prototype.age = 22;
var obj1 = new CreateObj('ghostwu');
obj1.age = 20;
var obj2 = new CreateObj('卫庄');
console.log( obj1.age ); //20---&来自实例
console.log( obj1.hasOwnProperty( 'age' ) ); //true
console.log( obj2.age ); //22---&来自原型对象
console.log( obj2.hasOwnProperty( 'age' ) ); //false
delete obj1.
console.log( obj1.age ); //22---&来自原型
console.log( obj1.hasOwnProperty( 'age' ) ); //false六、in操作符判断属性是否在实例或者原型对象上，只要一个满足条件，返回值都是truefunction CreateObj(uName) {
this.userName = uN
CreateObj.prototype.showUserName = function () {
return this.userN
CreateObj.prototype.age = 22;
var obj1 = new CreateObj('ghostwu');
obj1.age = 20;
console.log( 'age' in obj1 ); //true
var obj2 = new CreateObj('卫庄');
console.log( 'age' in obj2 ); //true
delete obj1.
console.log( 'age' in obj1 ); //true
console.log( 'user' in obj1 ); //false
console.log( 'user' in obj2 ); //false七，结合in和hasOwnProperty的用法，可以封装一个函数判断这个属性是否在原型对象上, 返回值为true:在原型对象上, false:不在原型对象上function CreateObj(uName) {
this.userName = uN
CreateObj.prototype.showUserName = function () {
return this.userN
CreateObj.prototype.age = 20;
function hasPrototypeProperty( obj, name ){
return !obj.hasOwnProperty( name ) && ( name in obj );
var obj1 = new CreateObj('ghostwu');
var obj2 = new CreateObj('卫庄');
obj1.age = 10;
console.log( hasPrototypeProperty( obj1, 'age' ) ); //false
console.log( hasPrototypeProperty( obj2, 'age' ) ); //true八、for...in 可以枚举实例和原型对象上的属性和方法，前提是：该属性和方法是可以枚举的function CreateObj(uName) {
this.userName = uN
CreateObj.prototype.showUserName = function () {
return this.userN
CreateObj.prototype.age = 20;
var obj = new CreateObj( 'ghostwu' );
for( var key in obj ){
console.log( key ); //userName,age,showUserName
console.log( Object.prototype );
for( var key in Object.prototype ){
console.log( key );//枚举不了, Object.prototype上的属性和方法默认不可枚举,枚举属性为false
声明：本文内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至： 进行举报，并提供相关证据，工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
标签：至少1个，最多5个
Javascript对象具有“自有属性”（own property），也有一些属性是从继承而来的。为了更好地理解对象自有属性和继承属性下面的示例深入解释了属性的访问和设置细节。
function Obj () {
this.z = 3;//自有属性
//对象会继承原型里的属性
Obj.prototype.x = 1;
Obj.prototype.y = 2;
var o = new Obj();
console.log(o); //o的打印结果如下图，可以看到其自有属性和继承自原型的属性
假设要查询对象o的属性y, 如果o自有属性中不存在y, 那么会继续在o的原型对象中查找属性y。如果原型对象中也没有y，但这个原型对象也有原型，那么继续在这个原型对象的原型上执行查询，直到没找到y或者查找到一个原型是null的对象为止。 对象的原型属性构成了一个“链”。 通过这个“链”可以实现属性的继承。
现在假设给对象o的属性x赋值，如果o中已经有属性x(自有属性，不是继承来的)那么这个赋值操作只改变这个已有属性x的值。如果o中不存在属性x, 那么赋值操作给o添加一个新属性x。 如果之前o继承了自己的原型对象的x属性，那么这个继承的属性就被新创建的同名属性屏蔽了。
console.log(o);
console.log(o.x);// 5
从打印结果可以看到对象创建了一个自有属性x，屏蔽了之前继承来的x值，这个操作只影响o这个单一对象，不会影响对象的原型里的x属性，既不会影响其他继承该原型的对象。
var b = new Obj();
console.log(b);
console.log(b.x);//1
我们再把对象o的x属性delete掉,然后再访问属性“x”
delete o.x;//true
发现访问o.x时 x 再次指向了原型对象中的 x属性。实际上自有属性和继承属性与静态语言的实例属性和类属性很像，因此在编写程序的时候最好不要把实例属性和类属性使用相同的名字，因为相同名字的实例属性会屏蔽掉类属性，但是当你删除实例属性后，再使用相同的名称访问到的将是类属性。
在给对象的属性赋值时，是在原始对象上创建属性或者对已有属性赋值，而不会去修改原型链。在Javascript中，只有查询属性时才会体会到继承的存在，而设置属性则和继承无关，该特性可以让我们可以有选择地覆盖继承的属性。
0 收藏&&|&&3
你可能感兴趣的文章
1 收藏，129
30 收藏，802
38 收藏，2.8k
本作品采用 署名-非商业性使用-禁止演绎 4.0 国际许可协议 进行许可
如果要改变的是原型里的引用类型里的值，就不是赋值而是更改原型了。。这是为什么呢？
如果要改变的是原型里的引用类型里的值，就不是赋值而是更改原型了。。这是为什么呢？
分享到微博？
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。}