javascript对象(Objects):
JavaScript 对象是词典,对象只是一组名称/值对,就是说,将 JavaScript 对象视为包含字符串关键字的词典,只接受字符串关键字。我们可以使用熟悉的“.”(点)运算符或“[]”运算符,来获得和设置对象的属性。JavaScript 对象不必预先声明属性,如果没有该名称的属性,该属性将被直接添加到对象,记住JavaScript对象是词典。
var myObject = new Object();
myObject.creatorTime = new Date();
alert(myObject.creatorTime);
var myObject = {}; // equivalent to new Object()
myObject[“creatorTime”] = new Date();
alert(myObject[“creatorTime”]);
var myObject = { “creatorTime”: new Date() };
alert(myObject.creatorTime);
JavaScript 函数:(Functions)
JavaScript 函数和对象差别很模糊,JavaScript 函数实际上是具有与它关联的可执行代码的对象。
function func(x) {
alert(x);
}
func("test");
var func = function(x) {
alert(x);
};
func("test");
var func = new Function(“x”, “alert(x);”);
func(“test”);
可以说函数是对象,您可以像对其他任何 JavaScript 对象一样,在函数中设置或添加属性
function sayHi(x) {
alert(“Hi, “ + x + “!”);
}
sayHi.text = “Hello World!”;
sayHi[“text2”] = “Hello World... again.”;
alert(sayHi[“text”]); // displays “Hello World!”
alert(sayHi.text2); // displays “Hello World... again.”
作为对象,函数还可以赋给变量、作为参数传递给其他函数、作为其他函数的值返回,并可以作为对象的属性或数组的元素进行存储等等
var obj = { “toString” : function() { return “This is an object.”; } };
alert(obj);//This is an object
var arr = [];
arr[0] = function(x) { return x * x; };
arr[1] = arr[0](2);
arr[2] = arr[0](arr[1]);
alert(arr[2]); //16
向对象添加方法:
var myDog = {
"name" : "Alan",
"bark" : function() { alert("Alan liu!"); },
"displayFullName" : function() {
alert(this.name + " is a good man!");
},
"chaseMrPostman" : function() {
return "haha";
}
};
myDog.displayFullName(); // alan is a good man
myDog.bark(); //Alan liu!
alert(myDog.chaseMrPostman())//haha
this和with:(this & this)
通过不同对象调用“this”时,它的值也会更改以便指向相应的对象
function displayQuote() {
alert(this.memorableQuote);
}
var williamShakespeare = {
"memorableQuote": "It is williamShakespeare.",
"sayIt" : displayQuote
};
var markTwain = {
"memorableQuote": "It is markTwain.",
"sayIt" : displayQuote
};
var oscarWilde = {
"memorableQuote": "It is oscarWilde." ,
"sayIt" : displayQuote
};
williamShakespeare.sayIt();
markTwain.sayIt();
displayQuote.call(oscarWilde);
表示的是将函数作为对象的方法进行调用的另一种方式。请记住,JavaScript 中的函数是对象。每个函数对象都有一个名为 call 的方法,它将函数作为第一个参数的方法进行调用。就是说,作为函数第一个参数传递给 call 的任何对象都将在函数调用中成为“this”的值。这一技术对于调用基类构造函数来说非常有用
有一点需要记住,绝不要调用包含“this”(却没有所属对象)的函数。否则,将违反全局命名空间,因为在该调用中,“this”将引用全局对象,而这必然会给您的应用程序带来灾难。例如,下面的脚本将更改 JavaScript 的全局函数 isNaN 的行为。一定不要这样做!
function displayQuote() {
alert("NaN is NaN: " + isNaN('qw'));
}
displayQuote();
function x() {
this.isNaN = function() {
return "not anymore!";
};
}
x();
alert("NaN is NaN: " + isNaN('qw'));
with 语句 为一个或一组语句指定默认对象。
用法:with (<对象>) <语句>;
with 语句通常用来缩短特定情形下必须写的代码量。在下面的例子中,请注意 Math 的重复使用:
x = Math.cos(3 *
Math.PI) + Math.sin(Math.LN10);
y = Math.tan(14 * Math.E);
当使用 with
语句时,代码变得更短且更易读:
with (Math) {
x = cos(3 * PI) + sin(LN10);
y = tan(14 * E);
}
JavaScript 构造函数(Constructor):
Functions which are used to initialize objects are called constructors.
JavaScript 中,本来就没有类。与访问类最近似的方法是定义构造函数:
function MyConstructor(name) {
this.name = name;
this.respondTo = function(name) {
if(this.name == name) {
alert(“Woof”);
}
};
}
var spot = new MyConstructor(“Spot”);//“new”运算符执行的操作很简单。首先,它创建一个新的空对象。然后执行紧随其后的函数调用,将新的空对象设置为该函数中“this”的值。这个语句的作用和下面两句一样:var spot = {}; DogConstructor.call(spot, “Spot”);
spot.respondTo(“Rover”);
spot.respondTo(“Spot”); // Woof
原型(Prototype):
Objects contain a hidden link property. This link points to the
prototype member of the constructor of the object
使用 JavaScript 的面向对象编程中,原型对象是个核心概念。在 JavaScript 中对象是作为现有示例(即原型)对象的副本而创建的,该名称就来自于这一概念。此原型对象的任何属性和方法都将显示为从原型的构造函数创建的对象的属性和方法。可以说,这些对象从其原型继承了属性和方法。
在 JavaScript 中,每个函数都有名为“prototype”的属性,用于引用原型对象。此原型对象又有名为“constructor”的属性,它反过来引用函数本身,这是一种循环引用。
下面几行代码结果可以体现出他们之间的对应关系:
var spot = new MyConstructor("Spot");
alert(MyConstructor.prototype.isPrototypeOf(spot)); //true
alert(spot.constructor == MyConstructor.prototype.constructor);//truealert(spot.constructor == MyConstructor);//true
alert(spot.hasOwnProperty("constructor"));//false
alert(MyConstructor.prototype.hasOwnProperty("constructor"));//true
hasOwnProperty 和 isPrototypeOf 方法的调用,它们不是来自 MyConstructor.prototype。实际上,在 MyConstructor.prototype 和 MyConstructor实例中还可以调用其他方法,比如 toString、toLocaleString 和 valueOf,但它们都不来自 MyConstructor.prototype。就像java 中的 Object 充当所有类的最终基类一样,JavaScript 中的 Object.prototype 是所有原型的最终基础原型。(Object.prototype 的原型是 null。)
看下面代码的运行结果,可以得出以下结论:
- 继承原型对象的对象上可以立即呈现对原型所做的更改,即使是在创建这些对象之后。
- 如果在对象中定义了属性/方法 X,则该对象的原型中将隐藏同名的属性/方法。例如,通过在Mobile.prototype 中定义 toString 方法,可以改写 Object.prototype 的 toString 方法。
- 更改只沿一个方向传递,即从原型到它的派生对象,但不能沿相反方向传递
- 您需要绑定到类而不是实例的属性或方法,也就是静态属性和方法,可用通过构造函数中设置静态方法和属性,直接将它们添加到类中,这些静态属性和方法实例不可调用。
function Mobile() { }
var rover = new Mobile();
var spot = new Mobile();
Mobile.prototype.getBrand= function() {
return "moto";
};
Mobile.prototype.color= "red";
Mobile.price='2001'
alert(Mobile.price);//2001
alert(rover.price);//undefined
alert(rover.getBrand());//moto
alert(rover.color);//red
spot.getBrand = function() {
return "nokia";
};
spot.color= "black";
alert(spot.getBrand()); //nokia
alert(spot.color); //"black"
alert(rover.getBrand());//moto
alert(rover.color);//red
闭包:(Closure)
Functions can be defined inside of other functions. The inner function has
access to the vars and parameters of the outer function. If a reference to an
inner function survives (for example, as a callback function), the outer
function's vars also survive.
JavaScript 的更高级功能之一是它支持闭包,闭包是当内部函数绑定到它的外部函数的本地变量时所发生的运行时现象。
定义一个筛选大于**的数字函数
function filter(pred, arr) {
var len = arr.length;
var filtered = []; // shorter version of new Array();
for(var i = 0; i < len; i++) {
var val = arr[i];
if(pred(val)) {
filtered.push(val);
}
}
return filtered;
}
var someRandomNumbers = [12, 32, 1, 3, 2, 2, 234, 236, 632,7, 8];
function makeGreaterThanPredicate(lowerBound) {
return function(numberToCheck) {
return (numberToCheck > lowerBound) ? true : false;
};
}
var greaterThan10 = makeGreaterThanPredicate(10);
var greaterThan100 = makeGreaterThanPredicate(100);
alert(filter(greaterThan10, someRandomNumbers));
alert(filter(greaterThan100, someRandomNumbers));
通过观察函数 makeGreaterThanPredicate 返回的内部匿名函数,可以发现,该匿名内部函数使用 lowerBound,后者是传递给 makeGreaterThanPredicate
的参数。按照作用域的一般规则,当 makeGreaterThanPredicate 退出时,lowerBound 超出了作用域!但在这里,内部匿名函数仍然携带
lowerBound,甚至在 makeGreaterThanPredicate
退出之后的很长时间内仍然如此。这就是我们所说的闭包:因为内部函数关闭了定义它的环境(即外部函数的参数和本地变量)。
在 JavaScript 中,闭包最有趣的用途之一是模拟类的私有变量
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 sex;
this.sex= function() { return sex; };
this.sex= function(newsex) { sex= sex; };
}
var ray = new Person(“Alan”, 31);
alert(ray.name);//undefined
ray.setSex('male');
alert(ray.getSex());//male
alert(ray.getName());//Alan
alert(ray.getAge());//31
ray.setName(“YoungerAlan”);
ray.setAge(25);
alert(ray.getName() + “ is now “ + ray.getAge() + “ years old.”);//Younger Alan is now 25
Person.prototype.testMethod = function() {
alert(this.name);undefined
alert(this.getName());//Younger Alan
};
ray.testMethod()
继承(Inheritance):
JavaScript 非常灵活,可以有很多从类继承的方式,下边提供一类,JavaScript是使用的原型来做继承的,而不是经典的面向对象式的继承自父类
function Pet(name) {
this.getName = function() { return name; };
this.setName = function(newName) { name = newName; };
}
Pet.prototype.toString = function() {
return "This pet’s name is: " + this.getName();
};
var parrotty = new Pet("Beike");
alert(parrotty);//Beike
function Dog(name, age){
Pet.call(this, name);
this.getAge = function() { return age};
this.setAge = function(newAge) { age= newage};
}
Dog.prototype = new Pet();
Dog.prototype.constructor = Dog;
Dog.prototype.toString = function() {
return "This dog's name is: " + this.getName() + ", and it's Age is: " + this.getAge();
};
var dog = new Dog(Heibie,3);
alert(dog);//This dog's name is:Heibei,and it'is Age is 3
alert(dog instanceof Dog);//true
alert(dog instanceof Pet);//ture
alert(dog instanceof Object);//true
命名空间(Namespace):
JavaScript 没有任何特定语言功能来支持命名空间,但很容易使用对象来模拟命名空间。如果要创建一个 JavaScript
库,则可以将它们包装在命名空间内,而不需要定义全局函数和类
var csdn= {};
csdn.alan = {};
csdn.alan .Pet = function(name) { // code };
csdn.alan .Pet.prototype.toString = function() { // code };
var pet = new csdn.alan .Pet("ALAN");
Or : var alias= csdn.alans;var pet = new alias .Pet("ALAN");
更多学习:http://www.crockford.com/javascript/
分享到:
相关推荐
当今 JavaScript 大行其道,各种应用...要掌握好 JavaScript,首先一点是必须摒弃一些其他高级语言如 Java、C# 等类式面向对象思维的干扰,全面地从函数式语言的角度理解 JavaScript 原型式面向对象的特点。把握好这一
_filesjavascript如何避免内存泄露 - - JavaEye技术网站_filesprototype_js深入研究_files从 prototype_js 深入学习 javascript 的面向对象特性 - - AJAX - JavaEye论坛_files带参数的闭包函数的巧妙应用 - ...
要掌握好JavaScript,首先一点是必须摒弃一些其他高级语言如Java、C#等类式面向对象思维的干扰,全面地从函数式语言的角度理解JavaScript原型式面向对象的特点。当今JavaScript大行其道,各种应用对其依赖日深。web...
深入理解Python的高级特性,如迭代器、生成器、装饰器等。 学习Python的标准库,了解常用的模块和函数。 Web开发: 学习Web开发的基础知识,包括HTTP协议、HTML、CSS和JavaScript。 学习至少一个Python Web框架,如...
- 理解面向对象编程的概念,掌握类、对象、继承、多态等相关知识。 - 学习异常处理、输入输出流、集合框架等Java核心库的使用。 2. Web开发阶段: - 学习HTML、CSS和JavaScript等前端技术,掌握网页布局和交互...
JavaScript核心 JavaScript语言基础(数据类型、函数、对象、闭包)、Java DOM编程、事件模型、JavaScript面向对象编程。 深入理解JavaScript语言原理;熟练的使用JavaScript对HTML DOM进行编程;熟练掌握...
JavaScript面向对象及原型 Dom选择器以及内容文本操作 Dom样式操作 Dom属性及创建标签 Dom提交表单及其他 Dom事件操作 Dom事件操作补充 Dom绑定时间的另外一种方式 JavaScript 词法分析解析 前端学习方法分享 ...
*第六阶段:JDBC深入理解高级特性:包括数据库连接池,存储过程,触发器,CRM思想; *第七阶段:HTML语言学习,包括HTML标签,表单标签以及CSS,这是Web应用开发的基础; *第八阶段:JavaScript脚本语言,包括...
深入剖析ASP.NET组件设计]一书第三章关于ASP.NET运行原理讲述的补白 asp.net 运行机制初探(httpModule加载) 利用反射来查看对象中的私有变量 关于反射中创建类型实例的两种方法 ASP.Net应用程序的多进程模型 NET委托...
使之提供更加高效和友好的用户接口,越来越多的企业和开发人员选择使用富客户端技术构建商业应用,本课程主要是介绍了解最流行的富客户端框架jquery - easyUI API及熟悉掌握其高级特性,并结合SSH2框架与Maven实现...
6.10 理解PHP面向对象新的高级功能 6.10.1 使用Per-Class常量 6.10.2 实现静态方法 6.10.3 检查类的类型和类型提示 6.10.4 克隆对象 6.10.5 使用抽象类 6.10.6 使用__call()重载方法 6.10.7 使用__autoload()方法 ...
6.10 理解PHP面向对象新的高级功能 6.10.1 使用Per-Class常量 6.10.2 实现静态方法 6.10.3 检查类的类型和类型提示 6.10.4 克隆对象 6.10.5 使用抽象类 6.10.6 使用__call()重载方法 6.10.7 使用__autoload()...
6.10 理解PHP面向对象新的高级功能 6.10.1 使用Per-Class常量 6.10.2 实现静态方法 6.10.3 检查类的类型和类型提示 6.10.4 克隆对象 6.10.5 使用抽象类 6.10.6 使用__call()重载方法 6.10.7 使用__autoload()...
阅读本书唯一的前提条件,是具备对Java编程或类似面向对象语言(比如说C#)的基本理解,不需要拥有为移动设备开发软件的经验。实际上,如果你确实有这方面的经验,反倒应该忘记它们。Android是如此与众不同,因此...