JS创建对象篇
来源：博客园


JS创建对象篇

Object构造函数创建

 var person = new Object();
 person.name = "Tom";
 person.age = 10;
 person.sayName = function(){
 alert(this.name);
 }


对象字面量

var person = { 
name : "Tom",
age : 10,
sayName : function(){
alert(this.name);
}

这两种创建对象的方式都比较简便，可以用来创建单个对象。但是如果使用一个接口创建多个对象时会产生大量的重复代码。

工厂模式

function createPerson(name,age)
{ var o = new Object();
o.name =
o.age =
o.sayName = function(){
alert(this.name);
return
 }
 var person1 = createPerson("Tom",10);
 var person2 = createPerson("Jack",9);

工厂模式抽象了创建具体对象的过程这样我们就可以传入参数创建多个对象了。但是没有解决对象的识别问题

构造函数模式

function Person(name,age)
{
this.name =
this.age =
this.sayName = function(){
alert(this.name);
}
 }
 var person1 = new Person("Tom",10);
 var person2 = new Person("Jack",9);
 
 console.log(person1.constructor == Person);
 
 console.log(person1 instanceOf Object);
 console.log(person2 instanceOf Person);
 

构造函数和普通函数的区别只是调用的方式有所差别，任何函数，只要new操作符来调用的话都作为构造函数（this的绑定规则），但是构造函数模式也存在问题：每个方法都要在每个实例上重新创建一遍。
console.log(person1.sayName == person2.sayName);


原型模式

我们创建的每一个函数都有一个prototype属性，这个属性是一个指针，指向一个对象
function Person(){}
Person.prototype.name = "Tom";
Person.prototype.age = 10;
Person.prototype.sayName = function(){
alert(this.name);
}
var person1 = new Person();
person1.sayName();
var person2 = new Person();
person2.sayName();
console.log(person1.sayName == person2.sayName);

跟构造函数模式不同，添加在prototype中的所有属性和方法都是共享的，也就是说person1和person2访问的都是同一组属性和同一个方法每当代码读取某个属性（eg:alert(person1.job)）的时候，都会执行一次搜索，目标是具有给定名字的属性，首先从对象实例本身开始，如果找到该属性则返回该属性的值，如果没有找到，则继续在原型链上向上查找，直到找到该属性停止，如果查找到原型链顶部，但是仍然没有找到指定的属性，就会返回对某个属性赋值（修改）（eg:person1.job="teacher")的时候，如果job存在于person1中，便会修改该属性的值。如果不在该person1中，则向原型链上查找但是这时候需要分析：

如果在原型链上找到了job，并且没有被标记为（writable:false），那么会在person1上添加一个名为job的新属性并设置它的值，这就是屏蔽属性。





如果在原型链上找到了job，但是它被标记为（writable:false），那么无法修改已有属性或是在person1上创建属性屏蔽，并且在严格模式下运行的话，代码会抛出一个错误，在非严格模式下，忽略该条语句。





如果在原型链上找到了job并且他是一个setter，那么一定会调用这个setter，job不会添加到person1上，也不会重新定义job这个setter。如果查找到原型链顶部，但是仍然没有找到指定的属性，那么这条语句（person1.job="teacher"),便会在person1中添加一个新的属性并设置它的值。
更简单的原型语法









function Person(){}
Person.prototype = {
name : "Tom",
age : 10,
sayName : function(){
alert(this.name);
}
};

这里我们重写了原型对象，但是constructor属性不在指向Person了（指向Object）
var person3 = new Person();
 console.log(person3.constructor == Person);
 console.log(person3.constructor == Object);

所以如果constructor属性的值很重要，那就要特意设置它的值
function Person(){}
Person.prototype = {
name : "Tom",
age : 10,
sayName : function(){
alert(this.name);
}
};
Object.defineProperty(Person.prototype,"constructor",
 {
enumerable:false,
value:Person
 });
 


构造函数模式和原型模式的组合

构造函数模式用来定义实例属性（非共享），原型模式用来定义共享的属性或方法（共享）
function Person(name,age)
{
this.name =
this.age =
this.frieds = ["Jack","Sam"];

 }
 Person.prototype = {
 sayName : function(){
alert(this.name);
}
 }
 Object.defineProperty(Person.prototype,"constructor",
 {
enumerable:false,
value:Person
 });


寄生构造函数模式

如果在前面的集中模式都不适用的情况下，可以使用寄生构造函数模式。
function Person(name,age)
{ var o = new Object(); 
o.name =
o.age =
o.sayName = function(){
alert(this.name);
return 
 }
 var person1 = new Person("Tom",10);


除了调用是用new操作符之外，跟工厂模式一模一样，建议可以使用其他模式的情况，不要使用这种模式

稳妥构造函数模式

稳妥，指的是没有公共属性，而且其他方法也不引用this的对象
function Person(name,age)
{ var o = new Object(); 
 
 
o.sayName = function(){
alert(name);
return 
 }
 var person1 = new Person("Tom",10);


免责声明：本站部分内容、图片、文字、视频等来自于互联网，仅供大家学习与交流。相关内容如涉嫌侵犯您的知识产权或其他合法权益，请向本站发送有效通知，我们会及时处理。反馈邮箱&&&&。
学生服务号
在线咨询，奖学金返现，名师点评，等你来互动Web前端开发和JS面向对象编程分享 - 抛砖引玉 - ITeye技术网站
博客分类：
Web前端开发和JS面向对象编程分享
一、前端开发的重要性
1. Web2.0、AJAX、JSON、用户体验
2. HTML5、微网、移动互联网
3. 前端MVC框架：Backbone.js
4. 服务器端Javascript：Node.js
5. Node.js + Jquery Mobile + HTML5 、CSS3 + MongDB
二、工欲善其事，必先利其器
1. Firefox插件
集HTML、CSS查看和编辑、Javascript调试、网络状况监视器于一体。
用来评估网页的性能，并获得如何改进性能和网页载入速度的建议。Page Speed能自动为用户优化图像，提供可以发布在网页上的压缩图片，它也能识别JS和CSS载入问题，帮助开发者减少浏览者等待网页展示的时间。
对网站的页面进行分析，并告诉你为了提高网站性能，如何基于某些规则而进行优化。并为每一个规则产生一个整体报告，如果页面可以进行优化，则会列出具体的修改意见。
Yslow-23条规则:
/link?url=g066BL1gqe6RnzN-bJoCjrbLeDrEjRQh_u8x3haH5NuhDtsrzt8ZvjgOfnMsOBuibky8Oqt1H9gUwdsK7TrwH_
可以模拟各种http请求，并详细设置请求参数，比如http header，parameter等。
是一款仿搜狗浏览器的Firefox双核扩展，能够自动切换到IE内核！
2. 前端工具
（3）、、浏览器（按调出）
设置兼容模式，IE标准可以多IE各版本测试
（4） 响应式设计视图
Firefox浏览器--工具--Web开发者--响应式设计视图
（5）文本编辑器
a). Notepad++
b). Sublime Text 2
备注：你还在用如“UltraEdit、EditPlus”等文本编辑器吗？你Out了！
（6）截图工具
三、Javascript面向对象编程
1. 使用外部、
2. 延迟加载脚本
（1）脚本置于最底部
（2）defer属性（在上添加）
//defer作用：文档加载完毕后再执行脚本【但是：只有浏览器支持】
&script type="text/javascript" defer="defer" src="js/jquery.js"&&/script&
JS和压缩工具：
4.headjs：能使并发下载（但是顺序执行）
&script src="/js/head.min.js"&&/script&
head.load(["file1.js", "file2.js"]);
/site/api/v1.00.html
5.自调用匿名函数（块级作用域）
(function(){
//使用匿名函数封闭每一个页面中的代码
通过定义一个匿名函数，创建了一个“私有”的命名空间，该命名空间的变量和方法，不会破坏全局的命名空间。
6.JS命名空间和模块化
（）模块化
（2）JS命名空间
比如文件：
approvalList.js &br&
审批列表页面对于的
(function(){
// 审批列表
var approvalList = {
add : function(){
this.showList();
showList : function(){
showList : function(){
// 如何调用
approvalList.add();
approvalList.showList ();
approvalList.im.showList ();
（3）使用扩展对象方法
比如文件：
approvalList.js &br&
审批列表页面对于的
(function(){
// 审批列表
var approvalList = approvalList
approvalList .prototype.add = funtion(){
// 如何调用
approvalList.add();
7. 前端解耦
（1）使用绑定事件和单独、文件解耦
（2）使用“前端框架”解耦
四、Javascript注意点
1. 函数参数传递：使用对象形式
function1({name:gxw,age:28});
var args1 = {name:gxw,age:28};
function1(args1);
备注：输出参数的个数
2. 避免多字符串用号连接
（）例如下列情况就会出现错误
var str3="3.14";
document.write(str3 - 1);
// 如果是减法他回自动将字符串转成数字
document.write(str3 + 1);
// 加法会当成字符串的拼接操作
（2）使用用方法进行连接字符串
var arr = [];
arr.push(aaa);
arr.push(bbb);
document.write(arr.join());
3. 定义对象用，定义数组用
4.存储常用的值
多次使用同一个值时，可以将其存储在局部变量中提高访问速度
5. 使用“，”进行判断
==用于一般比较 在比较的时候可以转换数据类型
===用于严格比较 严格比较，只要类型不匹配就返回
6. Javascript 中的、、、和空字符串对象
alert(typeof(false) === 'boolean');
alert(typeof(0) === 'number');
alert(typeof("") === 'string');
alert(typeof(null) === 'object');
alert(typeof undefined === 'undefined');
alert(typeof({})==="object");
alert(typeof([])==="object");
（2）== 比较
alert(false == undefined);//flase
alert(false == null);//flase
alert(false == {});//flase
alert(false == []);//flase
alert(false == 0); //true
alert(false == "");//true
alert(null == undefined);//true
（3）=== 比较
alert(false === undefined);//flase
alert(false === null);//flase
alert(false === 0); //false
alert(false === "");//flase
alert(false === {});//flase
alert(false === []);//flase
alert(null === undefined);//flase
（4）在语句中
if(false){}
if(undefined){}
if(null){}
a).true都可以用来替换，而可以用来替换
b).if(!oTest){
//do something
// undefined 、、、、
7. eval的使用
//eval 他是把一个字符串解析成一个方法并且调用
var str = "var show = function(){alert(100)}()";
eval(str);
//数据库会返回一个字符串长得像数组
var a = "[1,2]";
var array = eval(a);
for (var i = 0; i & array. i++) {
alert(array[i])
8. 学会使用链式调用
* 从一个实例引出立案时调用的需求
(function(){
//创建一个
function Cat(name){
this.name =
this.run = function(){
document.write(name+ " start run");
this.sing = function(){
document.write(name+ " start sing");
var c = new Cat("abc");
c.run().sing();
9. 禁止在函数内不使用申明变量
function outerFun(){
a =0;// 没有使用申明，就是全局变量了
10. 谨慎使用闭包
（）闭包会使函数中的变量保存在内存中
由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在中可能导致内存泄露。解决方法是，在退出函数之前，将不使用的局部变量全部删除。（）闭包会在父函数外部改变父函数内部变量的值
如果你把父函数当作对象（）使用，把闭包当作它的公用方法（），把内部变量当作它的私有属性（），这时一定要小心，不要随便改变父函数内部变量的值。
五、Jquery注意点
1. 总是使用去寻找元素
$('div#content')
$('#content')
2. 在前面使用
$('input.on')
3. 更好的利用链
$(#id1).css().click();
4. 限制直接对多次操作
组合成字符串，一次性操作
5. 事件委托（冒泡事件）的两面性
（）多个元素使用同一事件，在父元素上绑定事件
（）只有一个元素使用事件，阻止事件冒泡（）
event.stopPropagation(); // 事件停止冒泡到，即不让事件再向上传递到，但是此事件的默认行为仍然被执行，如点击一个链接，调用了，链接仍然会被打开。
event.preventDefault(); // 取消了事件的默认行为，如点击一个链接，链接不会被打开，但是此事件仍然会传递给更上一层的先辈元素。
// 相当于同时调用了和，事件的默认行为不会被执行，事件也不会冒泡向上传递。
六、Javascript调试
2.console.log() （内置对象）
3.Firebug 的调试功能
浏览: 125073 次
来自: 南京
这篇文章不错，值得借鉴参考！
如果集群有独立的zookeeper集群，那么配置zookeep ...
大家有没有遇到“修改文件$HOME/.hiverc文件”这个啊 ...
文章不错，有待进步！创建你自己的 JavaScript 对象|创建你自己的 JavaScript 对象
创建你自己的 JavaScript 对象
对象有助于组织信息。
本例向您展示如何创建 JavaScript 对象的实例 (instance)。
本例向您展示如何创建 JavaScript 对象的模板 (template)。
JavaScript 对象
在本教程前面的章节，我们已经学习到 JavaScript 拥有若干内置的对象，比如 String、Date、Array 等等。除了这些对象，你还可以创建自己的对象。
对象仅仅是一种特殊的数据类型而已，并拥有一系列的属性和方法。
让我们用一个例子来理解：一个人就是一个对象。属性是和对象有关的值。人的属性包括其名字、身高、体重、年纪、肤色、眼睛的颜色等等。所有的人都有这些属性，但是每个人的属性的值却各不相同。对象也拥有方法。方法是可施加于对象上的行为。人的方法可能是吃、睡、工作、玩等等。
访问对象的属性的方法：
对象名.属性名
通过简单地向属性赋值，你就可以向对象添加属性。假定存在 personObj 这个对象 － 你可以添加诸如 firstname、lastname、age 以及 eyecolor 等属性。
personObj.firstname=&John&
personObj.lastname=&Doe&
personObj.age=30
personObj.eyecolor=&blue&
document.write(personObj.firstname)
上面的代码生成以下的输出：
对象可包含方法。
使用下面的语法来调用方法:
对象名.方法名()
注意：位于括号之间的用于方法的参数是可以省略的。
调用名为 sleep 的 personObj 对象的方法：
personObj.sleep()
创建你自己的对象
有多种不同的办法来创建对象：
1. 创建对象的实例
下列代码创建了一个对象的实例，并向其添加了四个属性：
personObj=new Object()
personObj.firstname=&John&
personObj.lastname=&Doe&
personObj.age=50
personObj.eyecolor=&blue&
向 personObj 添加方法也很简单。下列代码向 personObj 添加了名为 eat() 的方法：
personObj.eat=eat
2. 创建对象的模版
模版定义了对象的结构。
function person(firstname,lastname,age,eyecolor)
this.firstname=firstname
this.lastname=lastname
this.age=age
this.eyecolor=eyecolor
注意：模版仅仅是一个函数。你需要在函数内部向 this.propertiName 分配内容。
一旦拥有模版，你就可以创建新的实例，就像这样：
myFather=new person(&John&,&Doe&,50,&blue&)
myMother=new person(&Sally&,&Rally&,48,&green&)
同样可以向 person 对象添加某些方法。并且同样需要在模版内进行操作：
function person(firstname,lastname,age,eyecolor)
this.firstname=firstname
this.lastname=lastname
this.age=age
this.eyecolor=eyecolor
this.newlastname=newlastname
注意：方法只是依附于对象的函数而已。然后，我们需要编写 newlastname() 函数：
function newlastname(new_lastname)
this.lastname=new_lastname
Newlastname() 函数定义 person 的新的 lastname，并将之分配给 person。通过使用 “this.”，JavaScript 即可得知你指的 person 是谁。因此，现在你可以这样写：myMother.newlastname(&Doe&)。
如需更多有关 JavaScript 对象的知识，请阅读 JavaScript 高级教程中的相关内容：
本节简要介绍了面向对象技术的术语、面向对象语言的要求以及对象的构成。
本节讲解了如何声明和实例化对象，如何引用和废除对象，以及绑定的概念。
本节介绍了 ECMAScript 的三种类型：本地对象、内置对象和宿主对象，并提供了指向相关参考手册的链接。
本节讲解了 ECMAScript 作用域以及 this 关键字。
本节详细讲解了创建 ECMAScript 对象或类的各种方式。
本节讲解了如何通过创建新方法或重定义已有方法来修改对象。为什么在node.js中，如何这个对象申报工作，申报一个静态变量？-javascript,node.js-CodeGo.net
为什么在node.js中，如何这个对象申报工作，申报一个静态变量？
我看到这样的代码：
var myNet = require ("net");
和在函数：
function foo (x,y) {
var myNewNet = new myNet();
myNewNet.createServer(x,y);
为什么上面的代码创建一个新的对象？什么是背后的看台？
还有一个问题，我如何创建一个静态无功的Node.js的，例如有是唯一性的ID号。
我和这个选项的静态变量：
var id =0;
并把它放在全局范围内，那是正确的？
本文地址 ：CodeGo.net/6350575/
-------------------------------------------------------------------------------------------------------------------------
1.该require基本上就像是一个导入;它需要一个外部库，使得它在你的代码中。
如果你在寻找一个外部模块，你会发现，这只是正常的Node.js的js代码。它有EXPORT有一GLOBAL关键字Node.js的你，使全局GLOBAL.IP_ADDRESS = "..."由于@Raynos说，这是一个好主意，这样做 CodeGo.net，所以另一个选择是导出一个常量，从一个模块，这样你就可以创建一个模块，并做exports.STATIC_CONSTANT = "";然后，一旦你导入模块，你可以做
var mod = require('mymodule');
mod.STATIC_CONSTANT;
编辑，回答你行var myNet = require("net")myNet是无论net模块出口。必须导出函数，所以var newNet = new myNet()创建对象的一个新实例。从那里myNewNet.createServer()只是调用刚才创建的对象。
本文标题 ：为什么在node.js中，如何这个对象申报工作，申报一个静态变量？
本文地址 ：CodeGo.net/6350575/
Copyright (C) 2014 CodeGo.net}