javascript私有的简单介绍
js公有,私有,静态属性和方法的区别
html
站在用户的角度思考问题,与客户深入沟通,找到龙南网站设计与龙南网站推广的解决方案,凭借多年的经验,让设计与互联网技术结合,创造个性化、用户体验好的作品,建站类型包括:成都做网站、成都网站建设、企业官网、英文网站、手机端网站、网站推广、申请域名、虚拟空间、企业邮箱。业务覆盖龙南地区。
head
titleJavaScript 对象方法 类方法 原型方法的区别;私有属性 公有属性 公有静态属性的区别/title
script language="javascript" type="text/javascript"
//定义Person类
function Person(name){
//私有属性MyTime、ID
var MyTime = " 2010-12-12";
var ID="773C0D35-298A-4660-B803-9EADC250ED61";
//公有属性MyName
this.MyName = name;
//对象方法(实例化后才能调用) 位置: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
divE-mail:zhengzizhi@yahoo.com.cn/div
div尽量将方法定义为原型方法,原型方法避免了每次调用构造函数时对属性或方法的构造,节省空间,创建对象快./div
/body
/html
JavaScript 中有可能模拟出类的私有变量吗
作者:寸志
链接:
来源:知乎
著作权归作者所有,转载请联系作者获得授权。
在JavaScript中谈私有属性和私有方法就是扯淡,"private"还杵在保留字的位置上,不知道什么时候提上来实现真正的私有。那今天咱就来讨论下如何以JS当前的特性来实现私有成员。
闭包
(比较枯燥,可以跳过本单元)JavaScript实现私有属性必须依赖闭包特性(可以先通过该链接补习)。下面也稍微补习下,看下面的例子:
var uniqueId;
uniqueId = (function() {
var index;
index = 0;
return function(prefix) {
return prefix + "_" + index++;
};
})();
//c_0
console.log(uniqueId("c"));
//c_1
console.log(uniqueId("c"));
通常所说的或所看到的闭包就是这样子——(function(){})(),但这不是它的全部或者是本质。在定义uniqueId这个函数的时候,我们使用了匿名函数表达式(请注意(function(){})是函数表达式)定义了一个函数且立即执行,把function(prefix){/*some code*/}作为返回值赋值给了quniqueId,此时这个function(prefix){/*some code*/}已经生成了函数实例,在函数实例生成的过程中:
【1】通俗的讲将index这个外部函数定义的变量记住了(为什么要记住?没记住你让我怎么给你计算prefix+"_"+index的值嘛!);
【2】再次我们没法通过什么this.index或者someObj.index引用到index,改变其值了,(function(){})()这个一执行完,局部变量index在外面怎么调得到嘛;
【3】怎么调得到,只能靠function(prefix){/*some code*/},因为我们还能通过它间接的取得或改变index值。这就是闭包了。
比较学术的解释:
【1】JS是词法作用域(就是程序看上去啥样就啥样)的,使用一个叫做[[scope]]的内部属性来标识每个执行上下文的作用域(我可以读写哪些变量啊,调用哪些哪些函数啊);每个函数执行时都由该[scope]作用域加上活动对象来构成真实的执行上下文;
【2】而这个执行上下文[[scope]]属性是在函数生成时就指定的了,不严格的讲为生成该函数时的执行上下文;
【3】于是function(prefix){/*some code*/}生成时其内部的[[scope]]属性引用了(function(){})()执行上下文的scope链;该scope链即包含了该函数的[[scope]]和活动对象,且活动对象包含了index的定义引用;
【4】GC的回收规则,没人用我我就是垃圾!因此uniqueId引用了function(prefix){/*some code*/}函数实例,而该函数实例的[[scope]]引用了(function(){})()执行期的scope链,其包含活动对象,即有index的引用;ok,index还有人引用它,它不是垃圾,因此闭包形成了,我们可以通过uniqueId函数间接的读取或者修改index。
总结:其实学术解释和通俗解释一个意思,不过闭包其实是相对的,并不是我们不能修改index,只是需要间接的方法(是不是有点私有属性和私有方法的感觉)。
私有属性和私有方法
相对来说,构造单例对象的私有属性和方法都比较简单。
var aira;
aira = (function () {
var __getName, __name;
//private variable
__name = "HTC mobile";
//private method
__getName = function () {
return __name;
};
aira = {
init: function () {
//change private variable inner
__name = "aira";
},
hello: function () {
//execute private method inner
console.log("hello,my name is " + (__getName()));
}
};
return aira;
})();
aira.init();
//hello,my name is aira
aira.hello();
使用双下划线"__"表示私有;aira手机有一个私有属性__name和私有方法__getName;我们可以在init中修改__name,在hello中调用__getName,且在闭包外面无法直接调用和修改这两个成员。我们做到了,这就是单例对象的私有属性和私有方法。
但是更确切的说,其实aira能够有私有属性和方法仅仅是因为它有私有的一个闭包,即init和hello成员的[[scope]]都引用了闭包的活动对象。
然而,一个构造函数(类)的私有属性和方法就么这么简单了。
var Phone, aira;
//wrap by function
Phone = function (name) {
var phone;
phone = (function () {
var __getName, __name;
__name = name;
__getName = function () {
return __name;
};
phone = {
init: function (number) {
__name += "#" + number;
},
hello: function () {
console.log("hello,my name is " + (__getName()));
}
};
return phone;
})();
return phone;
};
aira1 = Phone("aira");
aira1.init(1);
//hello,my name is aira#1
aira1.hello();
aira2 = Phone("aira");
aira2.init(2);
//hello,my name is aira#2
aira2.hello();
我们先来简单的将单例对象的构造包裹一个函数,实现产生不同的对象。我们可以说Phone是一个类,因为它可以产生不同的对象,有类似的功能。同样aira1和aira2都有自己闭包,于是都有自己的私有属性和方法。
我想对自己说,别逗了你,这样就行啦?!JS中类的概念就是构造函数。
var Phone, aira1, aira2;
Phone = function (name) {
var __getName, __name;
__name = name;
__getName = function () {
return __name;
};
this.init = function (number) {
__name += "#" + number;
};
this.hello = function () {
console.log("hello,my name is " + (__getName()));
};
};
aira1 = new Phone("aira");
aira1.init(1);
//hello,my name is aira#1
aira1.hello();
aira2 = new Phone("aira");
aira2.init(1);
//hello,my name is aira#2
aira2.hello();
Phone构造函数其实就是闭包的功能,每个Phone实例的init和hello都能引用其构造期间的形成的私有的__name和__getName。
真的,我已经无力回天了,每个实例必须由闭包产生私有属性和方法,因此只能在该闭包中定义公共方法暴露出来(比如说init和hello),这就意味着每次构造一个实例我们都必须生成init和hello的函数实例,这是多么的低效,因为JS有原型。
var Phone, aira;
Phone = function (name) {
var __getName, __name;
__name = name;
__getName = function () {
return __name;
};
};
Phone.prototype.init = function (number) {
__name += "#" + number;
};
Phone.prototype.hello = function () {
console.log("hello,my name is " + (__getName()));
};
aira = new Phone("aira");
上面的代码是错误的(在init中的__name是全局的,hello中的__getName方法因为不存在,所以会报错),这就是问题所在,能够引用私有属性和变量的公共方法必须在闭包中定义,然后暴露出来,然而原型方法并不能在闭包中定义。
曲线救国:
再来确定下什么是私有属性和私有方法,即每个类实例都拥有且只能在类内访问的变量和函数。也就是说变量和方法只能由类的方法来调用。说到这里,我们或许可以尝试下,不让类外的方法调用类的私有方法。
var inner, outer;
outer = function () {
inner();
};
inner = function () {
console.log(arguments.callee.caller);
};
/*
function(){
inner();
}
*/
outer();
从arguments的callee中可获得当前的执行函数inner,而inner的动态属性caller指向了调用inner的外层函数outer,由此看来我们可以使用arguments.callee.caller来确定函数的执行环境,实现私有方法和属性。
var Phone, aira1, aira2;
Function.prototype.__public = function (klass) {
this.klass = klass;
return this;
};
Function.prototype.__private = function () {
var that;
that = this;
return function () {
if (this.constructor === arguments.callee.caller.klass) {
return that.apply(this, arguments);
} else {
throw new Error("" + that + " is a private method!");
}
};
};
Phone = function (name) {
var __name;
__name = name;
this.__getName = (function () {
return __name;
}).__private();
this.__setName = (function (name) {
__name = name;
}).__private();
};
Phone.prototype.init = (function (number) {
this.__setName(this.__getName() + "#" + number);
}).__public(Phone);
Phone.prototype.hello = (function () {
console.log("hello,my name is " + (this.__getName()));
}).__public(Phone);
aira1 = new Phone("aira");
aira1.init(1);
//hello,my name is aira#1
aira1.hello();
aira2 = new Phone("aira");
aira2.init(1);
//hello,my name is aira#2
aira2.hello();
//hello,my name is aira#1
aira1.hello();
try {
aira1.__getName();
} catch (e) {
/*
Error Object
message:"function () {return __name;} is a private method!"
*/
console.log(e);
}
【1】请原谅我给Function原型上添加了两个方法__public和__private以此来实现私有方法的调用环境检测;
【2】其次,我无法给私有属性添加检测,所以私有属性直接不可见,使用私有的get,set方法访问;
【3】本身在aira1外部调用时我们还是能看到__getName和__setName方法,只是不能调用而已;
【4】唯一好的一点是原型方法(公共方法)终于可以从构造函数闭包中解放出来。
私有约定
var Phone, aira1, aira2;
Phone = function (name) {
//"__" private variable
this.__name = name;
};
Phone.prototype.init = function (number) {
this.__name += "#" + number;
};
Phone.prototype.hello = function () {
console.log("hello,my name is " + (this.__getName()));
};
//"__" private method
Phone.prototype.__getName = function () {
return this.__name;
};
aira1 = new Phone("aira");
aira1.init(1);
//hello,my name is aira#1
aira1.hello();
aira2 = new Phone("aira");
aira2.init(2);
//hello,my name is aira#2
aira2.hello();
以双下划线“__”表示私有,用最近看到的一代码注释来解释:“神奇,勿动”。
这是私有方法么?
var Phone, aira1, aira2;
Phone = (function () {
var __getName, __name;
__getName = function () {
return __name;
};
Phone = function (name) {
__name = name;
};
Phone.prototype.init = function (number) {
__name += "#" + number;
};
Phone.prototype.hello = function () {
console.log("hello,my name is " + (__getName()));
};
return Phone;
})();
aira1 = new Phone("aira");
aira1.init(1);
//hello,my name is aira#1 right!
aira1.hello();
aira2 = new Phone("aira");
aira2.init(2);
//hello,my name is aira#2 right!
aira2.hello();
//hello,my name is aira#2 wrong!
aira1.hello();
试图用闭包包住构造函数,形成闭包,但是得到的结果是__name和__getName其实都是类的私有属性,而不是实例的。aira1和aira2共用了__name和__getName。
javascript:什么叫做私有静态变量呢?
这个私有 是对 外面访问而言的。
例如 你可以调用 testObject1.test1()
但是 你不可以使用 testObject1.privateStaticVariable 来调用这个变量。外面是访问不了这个变量的,只有类中的 test 1 2 3这3个函数能够访问和修改。
javascript 私有保护类型
this.getData=function(){var data=Data;return data}
哦,是了,是我搞错了。
因为你操作的是一个数组对象,所以,不能简单的用=号来复制数组,这样只会是对原数组的引用。
所以,你要用一种方法来复制数组。
用遍历法虽然显得比较笨,但也是效果最好的,不会造成其它问题的方法。
所以,修改如下:
this.getData=function(){
var data = [];
for(var i=0;iData.length;i++){
data[i] = Data[i];
}
return data;
}
刚刚打错一个字母,已修改
在Javascript中,访问私有成员的成员方法是否可以写在类的原型中?
在
Javascript
中,访问私有成员的成员方法可以写在类的原型中
有一个Person类,拥有name这一私有属性。
//
Javascript
code:
var
Person
=
(function
()
{
var
name;
var
P
=
function
(theName)
{
name
=
theName;
this.getName
=
function
()
{
return
name;
};
};
P.
prototype
.setName
=
function
(newName)
{
name
=
newName;
};
return
P;
}());
在以上代码中name变成了静态私有变量而不是成员私有变量。
虽然可以创建静态字典,但是代码的可读性会降低。
javascript 私有,特权方法
你脚本的位置放错了,你执行那段脚本时,html代码还没解析完,dom也没生成好。所以报错。
这样写,或者在onload后再调用。
body
form name="js" method="post"
/form
/body
script
function user(){
var form=document.getElementsByTagName("form")[0];
this.name=function(){
return form.getAttribute("name");
};
}
var user=new user();
alert(user.name());
/script
新闻名称:javascript私有的简单介绍
新闻来源:http://myzitong.com/article/dsesiho.html