JavaScript 对象是词典
在JAVA中，说到的【对象】指类或结构的实例。对象有不同的属性和方法，具体取决于将它们实例化的模板（即类）。而 JavaScript 对象却不是这样。在 JavaScript 中，对象只是一组名称/值对，就是说，将 JavaScript 对象视为包含字符串关键字的词典。我们可以使用熟悉的“.”（点）运算符或“[]”运算符，来获得和设置对象的属性，这是在处理词典时通常采用的方法。
//第一种方法
var obj =
new Object();
obj.name=
"randy";
//alert(obj.name); //第二种方法 var obj = {};
obj.name=
"zhao";
//alert(obj["name"]); //第三种方法 var obj ={
"name":
"test"};
//alert(obj.name); function func1(str){
alert(str);
//alert(this.name); //name 是我在之后添加的一个属性，但是不能在fun1()方法体中访问,及时this.name 也不行 }
var func2 =
function(str){
alert(
"hello "+str);
}
var func3 =
new Function(
"str",
"alert(str);");
//您可以在运行时构造任意函数。 var func4 ={
"firstname":
"name1",
"lastname":
"zhao",
"display":
function(){
alert(
this.firstname+
":"+
this.lastname);
},
"display2":
function(){
alert(
this.firstname);
}
}
func1.name =
"天苍苍";
//alert(func1.name); JavaScript 中的函数是对象。每个函数对象都有一个名为 call 的方法，它将函数作为第一个参数的方法进行调用。就是说，作为函数第一个参数传递给 call 的任何对象都将在函数调用中成为“this”的值。这一技术对于调用基类构造函数来说非常有用.
绝不要调用包含“this”（却没有所属对象）的函数。否则，将违反全局命名空间，因为在该调用中，“this”将引用全局对象，而这必然会给您的应用程序带来灾难。
function DogConstructor(name) {
this.name = name;
this.respondTo =
function(name) {
if(
this.name == name) {
alert(
"Woof");
}
};
}
在上面的构造函数中，发现每个 Dog 实例也都有它自己的 respondTo 方法副本，这是个浪费；您只需要一个可供各个 Dog 实例共享的 respondTo 实例！通过在 Dog 以外定义 respondTo，可以避免此问题。但是还存在问题：这样会造成很多的全局函数，而且随着"类"的增加，会很严重。所以，可以用下面的方法实现。
function respondTo() {
// respondTo definition }
function Dog(name) {
this.name = name;
// attached this function as a method of the object this.respondTo = respondTo;
}
在使用 JavaScript 的面向对象编程中，原型对象是个核心概念。
在 JavaScript 中对象是作为现有示例（即原型）对象的副本而创建的，该名称就来自于这一概念。
function Dog(){
this.name =
"小黑";
}
Dog.prototype.display =
function(){alert(
this.name);}
Dog.prototype.toString =
function() {
return "name:"+
this.name;}
var dog =
new Dog();
alert(dog);
此原型对象的任何属性和方法都将显示为从原型的构造函数创建的对象的属性和方法。可以说，这些对象从其原型继承了属性和方法。
var buddy = new Dog(“Buddy“);
buddy 所引用的对象将从它的原型继承属性和方法，对象 buddy 的原型来自构造函数（在这里是函数 Dog）的属性。
在 JavaScript 中，每个函数都有名为“prototype”的属性，用于引用原型对象。 此原型对象又有名为“constructor”的属性，它反过来引用函数本身。这是一种循环引用。
正如 Dog 实例继承 Dog.prototype 一样，Dog.prototype 继承 Object.prototype。这使得所有 Dog 实例也继承了 Object.prototype 的方法和属性。每个 JavaScript 对象都继承一个原型链，而所有原型都终止于 Object.prototype。注意，迄今为止您看到的这种继承是活动对象之间的继承。它不同于继承的常见概念，后者是指在声明类时类之间的发生的继承。因此，JavaScript 继承动态性更强。它使用简单算法实现这一点，如下所示：当您尝试访问对象的属性/方法时，JavaScript 将检查该属性/方法是否是在该对象中定义的。如果不是，则检查对象原型。如果还不是，则检查该对象的原型的原型，如此继续，一直检查到 Object.prototype。
function DateTime() { }
DateTime.now =
function() {
return new Date();
};
DateTime.now2 =
new Date();
//alert(DateTime.now()); //alert(DateTime.now2); function makeGreaterThanPredicate(lowerBound) {
return function(numberToCheck) {
return (numberToCheck > lowerBound) ?
true :
false;
};
}
闭包是当内部函数（或 C# 中的内部匿名方法）绑定到它的外部函数的本地变量时所发生的运行时现象。很明显，除非此内部函数以某种方式可被外部函数访问，否则它没有多少意义。该匿名内部函数使用 lowerBound，后者是传递给 makeGreaterThanPredicate 的参数。按照作用域的一般规则，当 makeGreaterThanPredicate 退出时，lowerBound 超出了作用域！但在这里，内部匿名函数仍然携带 lowerBound，甚至在 makeGreaterThanPredicate 退出之后的很长时间内仍然如此。这就是我们所说的闭包：因为内部函数关闭了定义它的环境（即外部函数的参数和本地变量）。
function Person(name, age) {
this.getName =
function() {
return name; };
this.setName =
function(newName) { name = newName; };
this.getAge =
function() {
return age; };
this.setAge =
function(newAge) { age = newAge; };
var occupation;
this.age =age;
this.getOccupation =
function() {
return occupation; };
this.setOccupation =
function(newOcc) { occupation =newOcc; };
}
Person.prototype.display =
function() {
// doesn’t work! alert(
this.name);
//unidefined alert(
this.age);
//ok // this one below works alert(
this.getName());
//ok };
var person =
new Person(
"赵",24);
person.display();
9.模拟命名空间，相当于java 中的package
var com = {};
// nested namespace “Examples” com.randy = {};
com.randy.Pet =
function(name) {
this.name = name;
};
com.randy.Pet.prototype.toString =
function() {
return this.name;
};
var pet =
new com.randy.Pet(
"Yammer");
alert(pet);
本文出自 “” 博客，请务必保留此出处