精华内容
下载资源
问答
  • JavaScript高级程序设计 4 JavaScript高级程序设计 4
  • 接上篇:面向对象的程序设计(上) 三、继承 JavaScript主要通过原型链实现继承。 1.原型链 原型链的构建是通过将一个类型的实例赋值给另一个构造函数的原型实现的。这样,子类型就能够访问超类型的所有属性和...

    接上篇:面向对象的程序设计(上)

    三、继承

    JavaScript主要通过原型链实现继承。

    1.原型链

    原型链的构建是通过将一个类型的实例赋值给另一个构造函数的原型实现的。这样,子类型就能够访问超类型的所有属性和方法。

    function SuperType(){
    	this.property = true;
    }
    SuperType.prototype.getSuperValue = function(){
    	return this.prototype;
    };
    function SubType(){
    	this.subproperty = false;
    }
    //继承了SuperType
    SubType.prototype = new SuperType();
    SubType.prototype.getSubValue = function() {
    	return this.subproperty;
    };
    var instance = new SubType();
    alert(instance.getSuperValue());	//true
    下图展示了以上构造函数和原型之间的关系。


    注意:读取模式访问实例属性时的搜索顺序:1)搜索实例;2)搜索子类型原型;3)搜索超类型原型;

    确定原型和实例的关系

    • instanceof操作符
    • isPrototypeOf()方法
    原型链的问题
    • 对象实例共享所有继承的属性和方法;
    • 不能向超类型的构造函数中传递参数;

    2.借用构造函数

    以上问题可通过借用构造函数来解决,即在子类型构造函数的内部调用超类型构造函数

    function SuperType(name){
    	this.name = name;
    }
    function SubType(){
    	//继承了SuperType,同时还传递了参数
    	SuperType.call(this, "Nicholas");
    	//实例属性
    	this.age = 29;
    }
    var instance = new SubType();
    alert(instance.name);	//"Nicholas"
    alert(instance.age);	//29
    3.组合继承

    使用最多的继承模式是组合继承,即使用原型链继承共享的属性和方法,而通过借用构造函数继承实例属性。

    function SuperType(name){
    	this.name = name;
    	this.colors = ["red", "blue", "green"];
    }
    SuperType.prototype.sayName = function(){
    	alert(this.name);
    };
    function SubType(name, age){
    	//继承属性
    	SuperType.call(this, name);
    	this.age = age;
    }
    //继承方法
    SubType.prototype = new SuperType();
    SubType.prototype.constructor = SuberType;
    SubType.prototype.sayAge = function(){
    	alert(this.age);
    };
    var instance1 = new SubType("Nicholas", 29);
    instance1.colors.push("black");
    alert(instance1.colors);	//"red,blue,green,black"
    instance1.sayName();	//"Nicholas"
    instance1.sayAge();	//29
    
    var instance2 = new SubType("Greg", 27);
    alert(instance1.colors);	//"red,blue,green"
    instance1.sayName();	//"Greg"
    instance1.sayAge();	//27

    4.原型式继承

    可以在不必预先定义构造函数的情况下实现继承,本质是执行给定对象的浅复制,而复制得到的副本还可以进一步改造。

    function object(o){
    	function F(){}
    	F.prototype = o;
    	return new F();
    }
    var person = {
    	name: "Nicholas",
    	friends: ["Shelby", "Court", "Van"]
    };
    var antherPerson = object(person);
    //var antherPerson = object.creat(person);	//ES5新增的方法规范原型式继承
    antherPerson.name = "Greg";
    antherPerson.friends.push("Rob");
    alert(person.friends);	//"Shelby, Court, Van,Rob"
    5.寄生式继承

    与原型式继承非常相似,也是基于某个对象或某些信息创建一个对象,然后增强对象,最后返回对象。为了解决组合继承模式由于多次调用超类型构造函数而导致的低效率问题,可以将这个模式与组合模式一起使用。

    6.寄生组合式继承

    集寄生式继承和组合继承的优点与一身,是实现基于类型继承的最有效方式。

    function inheritPrototype(subType, superType){
    	var prototype = Object(superType.prototype);	//创建对象
    	prototype.constructor = subType;		//增强对象
    	subType.prototype = prototype;		//指定对象
    }
    function SuperType(name){
    	this.name = name;
    	this.colors = ["red", "blue", "green"];
    }
    SuperType.prototype.sayName = function(){
    	alert(this.name);
    };
    function SubType(name, age){
    	//继承属性
    	SuperType.call(this, name);
    	this.age = age;
    }
    
    inheritPrototype(SubType, SuperType);
    SubType.prototype.sayAge = function(){
    	alert(this.age);
    };
    



    展开全文
  • JavaScript高级程序设计4.pdf

    千次阅读 2014-04-05 01:45:00
     //添加第4项   var colors=["red","blue","green"]; colors[99]="black"; alert(colors.length); //100 检测数组 一般可以使用if (value instanceof Array) { //对数组的操作 } instanceof...

    虽然执行环境的类型总共只有两种——全局和局部(函数),但还有其他方法延长作用域链,有些语句可以在作用域链的前端临时增加一个变量对象,执行后会被移除try-catch语句的catch块和with语句

    with语句会将指定对象添加到作用域链中,catch会创建一个新的变量对象

    function buildUrl ()

    {

    var qs="?debug=true";

    with (location)

      {

      var url=href + qs;

      }

    return url;

    }

    在此,with语句接受的是location对象,因此其变量对象就包含了location对象的所有属性和方法,而这个变量对象被添加到了作用域链的前端。

    JavaScript没有块级作用域

    if (true)

    {

    var color="blue";

    }

    alert(color);  //"blue"

    if语句的变量声明会将变量添加到当前执行环境(这里是全局执行环境)

    由for语句创建的变量 i 即使在for循环结束后依然存在与循环外部的执行环境中

    1声明变量如果没有使用var,该变量会自动添加到全局环境 

    2查询标识符由当前执行环境开始搜索

    找出那些不再继续使用的变量,然后释放其占用的内存

    常见的是 标记清除 进入环境标记,离开环境清除

    引用计数 是跟踪记录每个值被引用的次数

    对循环引用使用手工消除的方式myObject.element=null;element.someObject=null;

    对数据的值设置null叫做解除引用,适用大多数全局变量和全局变量的属性,局部变量会在他们离开执行环境后被解除引用

    第5章  引用类型

    引用类型的值(对象)是引用类型的一个实例,在ECMAScript中,引用类型是一种数据结构,用于将数据和功能组织在一起

    新对象是使用new操作符后跟一个构造函数来创建的var person = new object();

    Object的实例是存储和传输的理想选择

    创建Object有两种方式:

    第一种是new操作符后跟Object构造函数

    var person = new Object();

    person.name = "Nicholas";

    person.age = 29;

    另一种方式是使用对象字面量表示法,它是对象定义的一种简写形式,目的在于简化创建包含大量属性的对象的过程

    var person =

    {

    name:"Nicholas",

    age:29

    };

    ECMAScript中的表达式上下文指的是能够返回一个值(表达式),左花括号表示一个表达式或者代码块的开始

    对象字面量也是向函数传递大量可选参数的首选方式

    function displayInfo (args)

    {

      var output="";

      if(typeof args.name=="string")

        {

        output +="Name: "+args.name+ "\n";

        }

      if(typeof args.age=="number")

        {

        output +="Age: "+args.age+ "\n"

        }

      alert(output);

    }

    displayInfo({

        name:"Ncholas",

        age:29

        });

    displayInfo({

        name:"Greq"

        });

    一般来说,访问对象的属性都是点表示法,也是很多面向对象语言中通用的语法,在JavaScript中也可以使用方括号表示法来访问对象的属性,将访问的属性以字符串的形式放在方括号中

    alert(person.name)  //"Nicholas"

    alert(person.["name"])  //"Nicholas"

    方括号语法主要优点是可以通过变量来访问属性

    var propertyName="name";

    alert(person[propertyName]);//"Nicholas"

    如果属性名中包含会导致语法错误的字符,或者属性名使用的是关键字或保留字,也可以使用方括号表示法

    person["first name"]="Nicholas";  //由于"first name"包含一个空格,所以不能使用点表示法来访问

    创建数组的基本方式有两种,第一种是使用Array构造函数

    var colors= new Array();

    如果预先知道数组的要保存的项目数量

    var colors= new Array(20); //自动创建length值为20的数组

    也可以向Array构造函数传递数组中应该包含的项

    var colors= new Array("red","blue","green");

    创建数组的第二种基本方式是使用数组字面量表示法 由一些包含数组项的方括号表示,多个数组项之间以逗号隔开

    var colors= ["red","blue","green"];

    var name= [];

    var value= [1,2,]    //在最后一个数组项加逗号会导致创建一个包含2或3项的数组

    在读取和设置数组的值时,要用方括号并提供基于0的数字的索引

    var color= ["red","blue","green"];  //定义

    alert(colors[0]);    //读取

    color[1]="black";    //修改

    color[3]="gray";    //新增

    数组的length是可读写的,通过设置这个属性可以向数组移除或者添加新项

    var colors=["red","blue","green"];

    colors.length=2;

    alert(colors[2]);    //undefined

     

    var colors=["red","blue","green"];

    colors[colors.length]="black";    //添加第3项

    colors[colors.length]="gray";    //添加第4项

     

    var colors=["red","blue","green"];

    colors[99]="black";

    alert(colors.length);    //100

    检测数组

    一般可以使用if (value instanceof Array)

    {

    //对数组的操作

    }

    instanceof操作符的问题在于,它假定单一的全局执行环境,如果网页包含多个框架就有多个不同的执行环境,就有多个不同版本的Array构造函数

    为了解决这个问题ECMAScript5新增了Array.isArray()方法,这个方法能确定某个值到底是不是数组,而不管是在哪个全局执行环境中创建的

    if(Array.isArray(value))

    {

    //对数组的操作

    }

    转换方法

    所有对象都具有toLocaleString()、toString()、valueOf()方法

    var colors=["red","blue","green"];

    alert(colors.toStrings());  //red,blue,green

    alert(colors.valueOf());  //red.blue,green

    alert(colors);  //red,blue,green

     

    var person1=

    {

      toLocaleString:function()

        {

          return "Nikolaos";

        },

      toString:function()

        {

          return"Nicholas";

        }

    };

    var person2=

    {

      toLocaleString:function()

        {

          return"Grigorios";

        },

       toString:function()

        {

          return"Greg";

        }

    };

    var people = [person1,person2];

    alert(people);

    alert(people.toString());

    alert(people.toLocaleString());

    join()方法可以使用不同的分隔符来构建这个字符串

    var colors=["red","blue","green"];

    alert(colors.join(","));  //red,green,blue

    alert(colors.join("||"));  //red||green||blue

    栈是一种LIFO(Last-In-First-Out后进先出)数据结构,栈中项的推入和移除只在栈的顶部发生,ECMAScript为数组提供push()和pop()方法实现类似的功能

    var colors=new Array();

    var count=colors.push("red","green");  //推入两项

    alert(count);  //2

    count=colors.push("black");  //推入另一项

    alert(count);  //3

    var item=colors.pop();

    alert(item);  //"black"

    alert(colors.length);  //2

    -------------------------------------------今天任务没完成,欠债的感觉不好受,还要付出更多的时间才行呐,好惆怅好忧伤-----------------------------------------------------

    转载于:https://www.cnblogs.com/sdgjytu/p/3644906.html

    展开全文
  • 访问器属性有如下4个特性。 [[Configurable]]:表示能否通过delete删除属性从而重新定义属性,能否修改属性的特性,或者能否把属性修改为数据属性。 [[Enumerable]]:表示能否通过for-in循环返回属性。 [...

    一、理解对象

    1.属性类型

    ECMA-262第5版在定义只有内部采用的特性时,描述了属性的各种特征。

    ECMAScript中有两种属性:数据属性和访问器属性。

    1)数据属性

    数据属性有四个描述其行为的特性。

    • [[Configurable]]:表示能否通过delete删除属性从而重新定义属性,能否修改属性的特性,或者能否把属性修改为访问器属性。
    • [[Enumerable]]:表示能否通过for-in循环返回属性。
    • [[Writable]]:表示能否修改属性的值。
    • [[Value]]:包含这个属性的数据值。读取属性的时候,从这个位置读;写入属性的时候,把新值保存在这个位置,默认值为undefined。

    要修改属性默认的特性,必须使用ES5的Object.defineProperty()方法。

    Object.defineProperty():接收三个参数(属性所在的对象、属性的名字和一个描述符对象),其中描述符对象的属性必须为configurable、enumerable、writable和value。

    var person = {};
    Object.defineProperty(person, "name", {
    	writable: false,
    	value: "Nicholas"
    });
    
    alert(person.name);		//"Nicholas"
    person.name = "Greg";
    alert(person.name);		//"Nicholas"
    注意:一旦把属性定义为不可配置的,就不能再把它变回可配置了。
    2)访问器属性

    访问器属性有如下4个特性。

    • [[Configurable]]:表示能否通过delete删除属性从而重新定义属性,能否修改属性的特性,或者能否把属性修改为数据属性。
    • [[Enumerable]]:表示能否通过for-in循环返回属性。
    • [[Get]]:在读取属性时调用的函数。默认值为undefined。
    • [[Set]]:在写入属性时调用的函数。默认值为undefined。

    //访问器属性的定义
    var book = {
    _year:2004,
    edition:1
    };
    Object.defineProperty(book, "year", {
    	get: function(){
    		return this._year;
    },
    set: function(newValue){
    	if (newValue>2004){
    		this._year = newValue;
    		this.edition += newValue - 2004;
    	}
    }
    });
    
    book.year = 2005;
    alert(book.edition);	//2
    //_year前面的下划线是一种常用的记号,表示只能通过对象方法访问的属性。
    2.定义多个属性

    Object.defineProperties()方法可以通过描述符一次定义多个属性。

    var book = {};
    Object.defineProperties(book, {
    	_year: {
    		writable: true,
    		value: 2004
    	},
    
    	edition: {		
    		writable: true,
    		value: 1
    	},
    
    	year: {
    		get: function(){
    			return this,_year;
    		},
    		set: function(newValue){
    			if (newValue>2004){
    				this._year = newValue;
    				this.edition += newValue - 2004;
    			}
    		}
    	}
    });
    3.读取属性的特性

    Object.getOwnPropertyDescriptor()方法可以取得给定属性的描述符。

    接收两个参数:属性所在的对象和要读取其描述符的属性名称。

    var book = {};
    Object.defineProperties(book, {
    	_year: {
    		writable: true,
    		value: 2004
    	},
    
    	edition: {		
    		writable: true,
    		value: 1
    	},
    
    	year: {
    		get: function(){
    			return this,_year;
    		},
    		set: function(newValue){
    			if (newValue>2004){
    				this._year = newValue;
    				this.edition += newValue - 2004;
    			}
    		}
    	}
    });
    //读取数据属性的特性
    var descriptor = Object.getOwnPropertyDescriptor(book, "_year");
    alert(descriptor.value);	//2004
    alert(descriptor.configurable);		//false
    alert(typeof descriptor.get);	//"undefined"
    
    //读取访问器属性的特性
    var descriptor = Object.getOwnPropertyDescriptor(book, "year");
    alert(descriptor.value);	//undefined
    alert(descriptor.enumerable);		//false
    alert(typeof descriptor.get);	//"function"
    二、创建对象
    1.工厂模式

    使用简单的函数创建对象,为对象添加属性和方法,然后返回对象。

    function creatPerson(name, age, job){
    	var o = new Object();
    	o.name = name;
    	o.age = age;
    	o.job = job;
    	o.sayName = function(){
    		alert(this.name);
    	};
    	return o;
    }
    var person1 = createPerson("Nicholals", 29, "Software Engineer");
    var person2 = createPerson("Greg", 27, "Doctor");
    缺点:没有解决对象识别的问题,即怎样知道一个对象的类型。这个模式后来被构造函数模式所取代。
    2.构造函数模式

    可以创建自定义引用类型,可以像创建内置对象实例一样使用new操作符。

    function Person(name, age, job){
    	this.name = name;
    	this.age = age;
    	this.job = job;
    	this.sayName = function(){
    		alert(this.name);
    	};
    }
    var person1 = new Person("Nicholals", 29, "Software Engineer");
    var person2 = new Person("Greg", 27, "Doctor");
    //按照惯例,构造函数始终都应该以一个大写字母开头,而非构造函数则应该以一个小写字母开头。
    将构造函数当做函数

    //当做构造函数使用
    var person = new Person("Nicholals", 29, "Software Engineer");
    person.sayName();	//"Nicholals"
    //作为普通函数调用
    Person("Greg", 27, "Doctor");		//添加到window
    window.sayName();		//"Greg"
    //在另一个对象的作用域中调用
    var o = new Object();
    Person.call(o, "Kristen", 25, "Nurse");
    o.sayName();	//"Kristen"	
    缺点:它的每个成员都无法得到复用,包括函数
    3.原型模式

    使用构造函数的prototype属性来指定那些应该共享的属性和方法。

    1)理解原型对象
    无论什么时候只要创建了一个新函数,就会根据一定的规则为该函数创建一个prototype属性,这个属性指向函数的原型对象。在默认情况下,所有原型对象都会自动获得一个constructor(构造函数)属性,这个属性是一个指向prototype属性所在函数的指针。

    function Person(){
    	Person.prototype.name = "Nicholas";	
    	Person.prototype.age = 29;	
    	Person.prototype.job = "Software Engineer";
    	Person.prototype.sayName = function(){
    		alert(this.name);
    	};
    }
    var person1 = new Person();
    person1.sayName();	//"Nicholas"
    var person2 = new Person();
    person1.sayName();	//"Nicholas"
    alert(person1.sayName == person2.sayName);	//true
    下图展示了以上使用Person构造函数和Person.prototype创建实例的代码的各个对象之间的关系:

    isPrototypeOf()方法:可以确定对象之间是否存在这种关系,即实例指向构造函数的原型对象。

    alert(Person.prototype.isPrototypeOf(person1));	//true
    alert(Person.prototype.isPrototypeOf(person2));	//true
    Object.getPrototypeOf()方法:返回[[Prototype]]的值。

    alert(Object.getPrototypeOf(person1) == Person.prototype);	//true
    alert(Object.getPrototypeOf(person1).name);	//"Nicholas"
    
    注意:在实例中添加一个与实例原型中同名的属性,那么该属性将会屏蔽原型中的那个属性。只有使用delete操作符完全删除实例属性,才可以重新访问原型中的属性。

    hasOwnProperty()方法:可以检测一个属性是存在于实例中(返回true),还是存在于原型中(返回false)。

    2)原型与in操作符

    in操作符会在通过对象能够访问给定属性时返回true。

    因此同时使用hasOwnProperty()方法和in操作符,可确定该属性是存在于对象中还是原型中。

    function hasPrototypeProperty(object, name){
    	return !object.hasOwnProperty(name)&&(name in object);
    }
    在使用for-in循环时,返回的是所有能够通过对象访问的、可枚举的属性。
    Object.keys()方法:接收一个对象作为参数,可返回一个包含所有可枚举属性的字符串数组。

    Object.getOwnPropertyNames()方法:可以获得所有实例属性,无论它是否可枚举。

    3)更简单的原型语法

    function Person(){
    }
    Person.prototype = {
    	name: "Nicholas",
    	age: 29,
    	job: "software Engineer",
    	sayName: function () {
    		alert(this.name);
    	}
    };
    
    上面的原型写法本质上完全重写了默认的prototype对象,因此constructor也就变成了新对象的constructor属性,不再指向Person函数。
    可以使用下面这种方式特意将它设置回适当的值。
    function Person(){
    }
    Person.prototype = {
    	constructor: Person,
    	name: "Nicholas",
    	age: 29,
    	job: "software Engineer",
    	sayName: function () {
    		alert(this.name);
    	}
    };
    但是,以这种方式重设constructor属性会导致它的[[Enumerable]]特性被设置为true,默认情况下,原生的constructor是不可枚举的。

    因此使用Object.defineProperty()可解决上述问题。

    function Person(){
    }
    Person.prototype = {
    	name: "Nicholas",
    	age: 29,
    	job: "software Engineer",
    	sayName: function () {
    		alert(this.name);
    	}
    };
    //重设构造函数,只适用于ES5兼容的浏览器
    Object.defineProperty(Person.prototype, "constructor", {
    	enumerable: false,
    	value: Person
    });
    4)原型的动态性

    实例中的指针仅指向原型,而不指向构造函数,因此重写原型对象时,已创建的实例仍然指向先前的原型对象。
    5)原生对象的原型

    所有原生引用类型(Object、Array、String等)都在其构造函数的原型上定义了方法,比如String.prototype中可以找到substring()方法,当然,你也可以通过原生对象的原型,定义新方法,不过,不推荐这么做。

    6)原型对象的问题

    • 不能为构造函数传递初始化参数
    • 对于包含引用类型值的属性来说,实例不能拥有属于自己的全部属性
    4.组合使用构造函数模式和原型模式

    创建自定义对象的最常见方式,就是组合使用构造函数模式和原型模式。构造函数模式用于定义实例属性,而原型模式用于定义共享的属性和方法。

    function Person(name, age, job){
    	this.name = name;
    	this.age = age;
    	this.job = job;
    	this.friends = ["Shelby", "Court"];
    }
    Person.prototype = {
    	constructor:Person,
    	sayName: function () {
    		alert(this.name);
    	}
    }
    var person1 = new Person("Nicholals", 29, "Software Engineer");
    var person2 = new Person("Greg", 27, "Doctor");
    person1.friends.push("Van");
    alert(person1.friends);	//"Shelby,Count,Van"
    alert(person2.friends);	//"Shelby,Count"
    alert(person1.friends === person2.friends);	//false
    alert(person1.sayName === person2.sayName);	//true
    5.动态原型模式
    function Person(name, age, job){
    	//属性
    	this.name = name;
    	this.age = age;
    	this.job = job;
    	//方法
    	if (typeof this.sayName != "function"){
    		Person.prototype.sayName = function(){
    			alert(this.name);
    		};
    	}
    }
    var friend = new Person("Nicholals", 29, "Software Engineer");friend.sayName();
    6.寄生构造函数模式

    这个模式与工厂构造模式是一模一样的,它可以在特殊的情况下用来为对象创建构造函数。

    7.稳妥构造函数模式

    稳妥构造函数遵循与寄生构造函数类似的模式,但有两点不同:

    • 新创建对象的实例方法不引用this;
    • 不使用new操作符调用构造函数;
    这种模式非常适合在某些安全执行环境下引用。


    展开全文
  • 最近发现JavaScript高级程序设计(第4版)的中文版上市了,回想当初看这本书的第2版、第3版,javascript的知识如泉水汩汩涌出,如饮甘怡般美妙。javascript的图书非常多,这本书最好。现在第4版上市,内心还有点小激动...
    6e877d4277ad054ece85e89d9b3080a0.png

    最近发现JavaScript高级程序设计(第4版)的中文版上市了,回想当初看这本书的第2版、第3版,javascript的知识如泉水汩汩涌出,如饮甘怡般美妙。

    javascript的图书非常多,这本书最好。现在第4版上市,内心还有点小激动,但最终也没有买纸质版。

    不买的原因如下:

    • 有第2版跟第3版实体书
    • 第4版与第3版的差别,被其它javascript书补充了(下面会讨论有什么区别)。
    • 网上下载到了第4版英文电子版(尴尬,盗版可耻)。
    • 这本书太贵(虽然值),太厚(虽然全是干货),房间太小,放不下。

    下面主要讨论第3版与第4版的差异。

    1 内容变化

    13cec17a582a5f272d9295273c2e9b4a.png

    第4版涵盖ECMAScript 2019,不仅新增了5章内容,还对其余章节进行了大幅度的增补和修订。

    其中第4版的目录结构为

    7f1b8e1ae84b987ad2ea5bbdf6b420c0.png

    第3版的目录结构为:

    14770de1e4ebc76e4ea1fb7163324b56.png

    通过目录比对,内容变化还是挺大的。主要集中在进阶内容部分:迭代器与生成器;代理与反射;对象、类与面向对象编程;函数;期约(promise)与异步编程等。

    2 作者变化

    JavaScript高级程序设计 1-3 版的作者都是:Nicholas C. Zakas。其人个博客为:Human Who Codes – The official website of Nicholas C. Zakas。

    65235d925f2ec4b93b6aa6e12a4b9306.png

    Nicholas C. Zakas写了很多本javascript畅销书:https://humanwhocodes.com/books/

    89910a80456b4c9bacfb79a551dda657.png

    2015年时,他发了一条推特,自己不会再更新第4版。

    3410627e3eb9960ad7dc433dec3e2779.png

    所以现在的作者是马特,当然,也是位程序语言专家。

    48c37d3104a9149111c855fbc3cd1cb1.png

    3 封面变化

    这本书的封面主体都是红色,所以大家都称它为js红宝书。

    第1、2版用的是作者Nicholas C. Zakas的头像。

    第3、4版用的都是小孩用望远镜看世界,不过小孩子长大了,从坐在地上变成站立望向远方。

    javascript真的长大了… …

    展开全文
  • JavaScript高级程序设计.part4
  • JavaScript高级程序设计4
  • JavaScript高级程序设计+JavaScript权威指南第4版 带目录 非扫描
  • javascript高级程序设计

    2013-06-06 09:47:47
    javascript高级程序设计相关知识,包括7章内容: 第1章 JavaScript是什么? 第2章 ECMAScript基础 第3章 对象基础 第4章 继承 第5章 浏览器中的JavaScript 第6章 DOM基础 第15章 JavaScript中的XML
  • javascript高级程序设计+JavaScript权威指南高清第4版pdf
  • JavaScript chapter 4 理解基本类型和引用类型的值 理解执行环境 理解垃圾收集 4.1 基本类型和引用类型的值 JavaScript中有两种不同类型的值:基本类型值和引用类型值 基本数据类型是按值访问,引用类型的值是...
  • JavaScript高级程序设计

    2017-12-31 23:05:07
    就在这时,Wrox的《Professional JavaScript for Web Developers》走进了我们的视野,中文名是《JAVASCRIPT高级程序设计》, , JavaScript是目前Web客户端开发的主要编程语言,也是Ajax的核心技术之一。本书从最早期...
  • javascript高级程序设计.part4.rar第四部分
  • 前言最近Promise被翻译成期约,大家好像有所讨论?今日早读文章由360@李松峰授权...正文从这开始~~本文内容来自于李松峰老师翻译的《JavaScript高级程序设计》第 4 版第 11 章 - 期约与异步函数,本文只是第 11 章部...
  • JavaScript高级程序设计(第2版)》在上一版基础上进行了大幅度更新和修订,融入了近几年来JavaScript应用发展的最新成果,几乎涵盖了所有需要理解的重要概念和最新的JavaScript应用成果。从颇具深度的JavaScript...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,364
精华内容 545
关键字:

javascript高级程序设计4

java 订阅