javascript读书笔记

最新推荐文章于 2021-06-20 21:04:04 发布

38度秋裤

最新推荐文章于 2021-06-20 21:04:04 发布

阅读量362

点赞数

本文链接：https://blog.csdn.net/u010452908/article/details/44138923

版权

《悟透javascript》 PDF下载链接

<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
	<!--
	<link rel="stylesheet" type="text/css" href="styles.css">
	-->
    <script type="text/javascript">
    function Person(name)
    {
      this.name = name; //设置对象属性,每个对象各自一份属性数据
    };
    
    Person.prototype.sayHello = function() //给Person 函数的prototype 添加sayHello 方法
    {
       alert("Hello, I'am " + this.name);
    };
    
    // 构造函数的prototype 上定义的方法确实可以通过对象直接调用到,而且代码是共享的,显然
    // 把方法设置到prototype 的写法显得优雅得多,尽管调用形式没有改变,但是逻辑上体现了方法与类的关系
    // 相比前面的写法,更容易理解和组织代码
    var BillGates = new Person("BillGates"); //创建BillGates 对象
    var SteveJobs = new Person("Steve Jobs"); //创建SteveJobs 对象
    
    BillGates.sayHello();
    SteveJobs.sayHello();
    
    // 因为两个对象是共享的prototype 的sayHello
    alert(BillGates.sayHello() == SteveJobs.sayHello());
    </script>
  </head>
  
  <body>
    了解javascript 原型:
    prototype 源自于法语, 软件界标准翻译为"原型", 代表事物的初始状态,也含有模型和样板的意义,javascript 中的
    prototype 概念恰如其分地反映了这个词的含义, 我们不能将其理解为C++ 的prototype 那种预先声明的概念.
    
    javascript 的所有function 类型的对象都有一个prototype 属性,这个prototype 属性本身又是一个 Object类型的对象
    因此我们也可以给这个prototype 对象添加任意的属性和方法, 既然prototype 是对象的原型,那么由该函数构造出来的
    对象应该都会具有原型的特征,事实上,在构造函数的prototype 上定义的所有属性和方法, 都是可以通过其构造的对象直接
    访问和调用的,也可以这么说,prototype 提供了一群同类对象共享属性和方法的机制;
  </body>
</html>

<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>My JSP 'prototype2.jsp' starting page</title>
    
	<meta http-equiv="pragma" content="no-cache">
	<meta http-equiv="cache-control" content="no-cache">
	<meta http-equiv="expires" content="0">    
	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
	<meta http-equiv="description" content="This is my page">
	<!--
	<link rel="stylesheet" type="text/css" href="styles.css">
	-->
    <script type="text/javascript">
    function Person(name) //基类构造函数
    {
       this.name = name;
    };
    
    Person.prototype.sayHello = function() //给基类构造函数的prototype 添加方法
    {
      alert("hello, I am " + this.name);
    };
    
    function Employee(name, salary) //子类构造函数
    {
      Person.call(this, name);
      this.salary = salary;
    };
    
    Employee.prototype = new Person(); //建一个基类的对象作为子类原型的原型
    
    Employee.prototype.showMeMoney = function()
    {
        alert(this.name + " $ " + this.salary);
    
    };
    
    var BillGates = new Person("BillGates");
    var SteveJobs = new Employee("SteveJobs",1234);
    
    BillGates.sayHello();
    SteveJobs.sayHello();
    
    SteveJobs.showMeMoney();
    </script>
  </head>
  
  <body>
    在 javascript中, prototype 不但能让对象共享自己的财富,而且prototype 还有寻根问祖的天性,从而使得先辈们的
    遗产可以代代相传,当从一个对象那里读取属性或调用方法的时候,如果该对象自身不存在这样的属性或方法,就会去自己
    关联的prototype 对象那里寻找,如果prototype没有,又会从prototype 自己关联的前辈prototype 那里去寻找,直到
    找到或追溯过程结束为止;
    
    在javascript 内部,对象的属性和方法追溯机制是通过所谓的prototype 原型链来实现的,当用new 操作符构造对象时候,
    也会同时将构造函数的prototype 对象指派给新创建的对象,成为该对象内置的原型对象,对象内置的原型对象应该是对外
    不可见的,尽管有些浏览器可以让我们访问这个内置原型对象,但是并不建议这样做,内置的原型对象本身也是对象,内置的
    原型对象本身也是对象,也有自己关联的原型对象,这样就形成了所谓的原型链
    
    在原型链的最末端,就是Object 构造函数 prototype属性指向的那一个原型对象,这个原型对象是所有对象的最老祖先,
    这个老祖宗实现了诸如:toString 等所有对象天生就该具有的方法,其它内置构造函数如:function，boolean,string,date
    和RegExp 等的prototype 都是这个老祖宗传承下来的,但是他们各自又定义了自身的属性和方法,从而他们的子孙就表现
    出各自宗族的那些特征;
  </body>
</html>

<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>My JSP 'prototype3.jsp' starting page</title>
    
	<meta http-equiv="pragma" content="no-cache">
	<meta http-equiv="cache-control" content="no-cache">
	<meta http-equiv="expires" content="0">    
	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
	<meta http-equiv="description" content="This is my page">
	<!--
	<link rel="stylesheet" type="text/css" href="styles.css">
	"原型继承"是慈祥而又严厉,原型对象将自己的属性和方法无私地贡献给孩子们使用,也并不强迫孩子们必须遵从
	允许一些顽皮孩子按自己的兴趣和爱好独立行事,从这点上看,原型对象是一位慈祥的母亲,然而,任何一个孩子虽然
	可以我行我素,但却不能对原型对象的既有财产,因为那可能会影响到其它孩子的利益,从这一点上看,原型对象又像
	一位严厉的父亲
	-->
   <script type="text/javascript">
   function Person(name)
   {
     this.name = name;
   };
   
   Person.prototype.company = "Microsoft"; // 原型的属性
   
   Person.prototype.sayHello = function() // 原型的方法
   {
       alert("hello, I am " + this.name + " of " + this.company);   
   };
   
   var BillGates = new Person("Bill Gates");
   BillGates.sayHello(); //由于继承了原型的东西
   
   var SteveJobs = new Person("Steve_Jobs");
   SteveJobs.company = "Apple"; //设置了自己的company 属性,掩盖了原型company 属性
   SteveJobs.sayHello = function() //实现了自己的sayHello 方法,掩盖了原型的sayHello 方法
   {
      alert("Hi, " + this.name + " like " + this.company );
   };
   
    SteveJobs.sayHello();
    BillGates.sayHello();
   </script>
  </head>
  
  <body>
    
  </body>
</html>

<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>My JSP 'prototype4.jsp' starting page</title>
    
	<meta http-equiv="pragma" content="no-cache">
	<meta http-equiv="cache-control" content="no-cache">
	<meta http-equiv="expires" content="0">    
	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
	<meta http-equiv="description" content="This is my page">
	<!--
	<link rel="stylesheet" type="text/css" href="styles.css">
	相比静态对象语言更神奇的是,我们可以随时给原型对象动态添加新的属性和方法,从而动态地扩展
	基类的功能特征,这在静态语言中是很难想象的:
	-->
   <script type="text/javascript">
   function Person(name)
   {
     this.name = name;
   };
   
   Person.prototype.sayHello = function() //建立对象之前定义的方法
   {
      alert("hello, I am " + this.name);
   };
   
   var BillGates = new Person("BillGates"); //建立对象
   BillGates.sayHello();
   
   Person.prototype.Retire = function() //建立对象后再动态扩展原型的方法
   {
      alert("poor" + this.name + ", byebye");
   };
   BillGates.Retire(); //动态扩展的方法即可以被先前建立的对象立即调用
   
   // 如果在javascript 内置的那些如Object 和function 等函数的prototype上添加些新的方法和属性
   // 就能扩展javascript 的功能了
   
   // Microsoftajax.debug.js
   // 给内置String 函数的prototype 扩展了一个trim 方法,于是所有的String 类对象都有了trim 方法
   String.prototype.trim = function String$trim()
   {
       if(arguments.length != 0) throw Error.parameterCount();
       return this.replace(/^\s+|\s+$/g, '');
   };
   </script>
  </head>
  
  <body>
  
  </body>
</html>

myItEye