《JavaScript高级程序设计》读书笔记

最新推荐文章于 2023-05-03 21:15:14 发布
最新推荐文章于 2023-05-03 21:15:14 发布
阅读量226 收藏
点赞数
分类专栏： JavaScript 文章标签： JavaScript高级程序设计
原文链接：www.baidu.com
版权

面向对象的程序设计

面向对象的语言都有一个标志，那就是它们都有类的概念，但ECMAScript中没有类的概念，ECMA-262中把对象定义为：“无序属性的集合，其属性可以包含基本值、对象或者函数”。
每个对象都是基于引用类型创建的，引用类型可以是原生类型，也可以是开发者定义的类型。

理解对象

最简单的创建自定义对象的方法（创建一个object实例），然后再为它添加属性和方法。

	var person = new Object();
	person.name = "Nicholas";
	person.age = 29;
	person.job = Softeware Engineer";

	person.sayName = function (){
		alert(this.name);
	}

上面例子，通过对象字面量的写法：

var person = {
	name:"Nicholas",
	age:29,
	job:Software Engineer,

	sayName:function(){
		alert(this.name);
	}
}

属性类型

在定义只有内部才用的特性时，描述了属性的各种特征。定义这些特性是为了实现JavaScript引擎用的，因此在JavaScript中不能直接访问它们。为了表示特性时内部值，该规范把他们放在了两对方括号中，例如[[Enumerable]]。
ECMAScript中有两种属性：数据属性和访问器属性。

1.数据属性

数据属性包含一个数据值的位置。在这个位置可以读取和写入值。数据属性有4个描述其行为的特性。

  • [[Configurable]]
  • []

数据属性可以通过Object.defineProperty()方法修改属性的默认特性。

var person = {};
Object.defineProperty(person,"name",{
	writable:false,
	value:"Nicholas"
});
2.访问属性

包含一对getter和setter函数也需要Object.defineProperty()来定义。

定义多个属性

通过Object.defineProperties()方法定义多个属性。

	var book = {};
	Object.defineProperties(book,{
		_year:{
			value:2004
		},
		edition:{
			value:1
		},
		year:{
		 	get:function(){
				return this._year;
			},
			set:function(newValue){
				if(newValue > 2004){
					this._year = newValue;
					this.edition += newValue - 2004;
				}
			}
		}
	});

读取属性的特性

通过Object.getOwnPropertyDescriptor()方法，可以取得给定属性的描述符。
这个方法可以接收两个参数：属性所在的对象和要读取其描述符的属性名称。
返回值是一个对象，如果是访问器属性，这个对象的属性有configurable、enumerable、get和set；如果是数据属性，这个对象的属性有configurable、enumerable、writable和value。

	var book = {};
	Object.defineProperties(book,{
		_year:{
			value:2004
		},
		edition:{
			value:1
		},
		year:{
		 	get:function(){
				return this._year;
			},
			set:function(newValue){
				if(newValue > 2004){
					this._year = newValue;
					this.edition += newValue - 2004;
				}
			}
		}
	});
	var descriptor = Object.getOwnPerpertyDescriptor(book,"_year");
	descriptor.value      //2004
	descriptor.configurable     //false
	typeof descriptor.get 	    //"undefined"
	
	var descriptor2 = Object.getOwnPerpertyDescriptor(book,"year");
	descriptor2.value   //undefined
	descriptor2.enumerable     //false
	typeof descriptor.get 	   //"function"

创建对象

工厂模式

工厂模式抽象了创建具体对象的过程。用函数封装以特定接口创建对象的细节。

function createPerson(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("Nicholas",29,"Software Engineer");
var person2 = createPerson("Greg",27,"Doctor");

工厂模式虽然解决多个相似对象问题，但却没有解决对象识别的问题（即怎样知道一个对象的类型）。

构造函数模型

ECMAScript中构造函数可以用来创建特定类型的对象。像object和Array这样的原生构造函数，在运行时会自动出现在执行环境中。此外可以创建自定义的构造函数，从而定义自定义对象的属性和方法。

function Person(name,age,job){
	this.name = name;
	this.age = age;
	this.job = job;
	this.sayName = function(){
		alert(this.name);
	}
}
var person1 = new Person("Nicholas",29,"Software Engineer");
var person2 = new Person("Greg",27,"Doctor");

此处，两个对象都有一个constructor（构造函数）属性，该属性指向Person。

alert(person1.constructor == Person);     //true
alert(person2.constructor == preson);     //true

对象的constructor属性最初是用来标识对象的类型，还是instanceof操作符要更可靠些。我们在这个例子中创建的所有对象既是Object实例，同时也是Person的实例：

alert(person1 instanceof Object);     //true
alert(person2 instanceof Object);     //true
alert(person1 instanceof Person);     //true
alert(person2 instanceof Person);     //true

创建自定义的构造函数意味着将来可以用它的实例标识为一种特定的类型

将构造函数当做函数

构造函数与其他函数的唯一区别，就在于调用它们的方式不同。任何函数，只要通过new操作符来调用，那它就可以作为构造函数；反之，跟普通函数没什么区别。

//当做构造函数使用
var person = new Person("Nicholas",29,"Software Engineer");
person.sayName();    //"Nicholas"

//作为普通函数调用
Person("Greg",27,"Doctor");      //添加到window
window.sayName();    //"Greg"

//另一个对象的作用域中调用
var o = new Object();
Person.call(o,"kristen",25,"Nurse");
o.sayName();    //"kristen"
构造函数的问题

每个方法都要在每个实例上重新创建一遍，所以，在前面的例子中，person1和person2都有一个名为sayName()的方法，但那两个方法不是一个Function实例。因为，ECMAScript中的函数是对象，因此每定义一个函数，也就是实例化一个对象。

function Person(name,age,job){
	this.name = name;
	this.age = age;
	this.job = job;
	this.sayName = new Function("alert(this.name)");
}

以这种方式创建函数，会导致不同的作用域链和标识符解析，但创建function新实例的机制仍然是相同的。不同实例上的同名函数是不相等的：

alert(person1.sayName == person2.sayName);     //false

然而，创建两个完成同样任务的Function实例的确没有必要；况且有this对象在，根本不用在执行代码前就把函数绑定到特定对象上面，因此，大可通过把函数定义转移到构造函数外部来解决这个问题。

function Person(name,age,job){
	this.name = name;
	this.age = age;
	this.job = job;
	this.sayName = sayName;
}
function sayName(){
	alert(this.name);
}
var person1 = new Person("Nicholas",29,"Software Engineer");
var person2 = new Person("Greg",27,"Doctor");

通过这种代码，person1和person2对象就共享了在全局作用域中定义的一个sayName()函数。这样确实解决了两个函数做同一件事的问题。
这样写法引发的新问题：在全局作用域中定义的函数实际上只能被某个对象调用，这让全局作用域有点名不副实。而更让人无法接受的是：如果对象需要定义很多方法，那么就要定义很多个全局函数，于是我们自定义的引用类型就毫无封装性可言。

原型模式

每个函数都有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();
person2.sayName();    //"Nicholas"

alert(person1.sayName == person2.sayName);    //true
理解原型对象

继承

许多OO（面向对象）语言都支持两种继承方式：接口继承和实现继承。接口继承只继承方法签名，而实现继承则继承实际的方法。
由于函数没有签名，则只支持实现继承，而且主要依靠原型链实现。

原型链

基本思想：利用原型让一个引用类型继承另一个引用类型的属性和方法。
构造函数、原型和实例的关系：
构造函数、原型和实例的关系
让原型对象等于另一个类型的实例=》再层层递进，构成了原型链。
实现原型链的基本模式：

function SuperType(){
	this.property = true;
}
SuperType.prototype.getSuperValue = function(){
	return this.property;
}
function SubType(){
	this.subproperty = false;
}

SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function(){
	return this.subprototype;
};
var instance = new SubType();
alert(instance.getSuperValue());           //true

下图就是上面代码中的逻辑关系：
在这里插入图片描述
上面例子中，调用instance.getSuperValue()会经历的三个搜索步骤：
1）搜索实例；
2）搜索SubType.prototype;
3）搜索SuperType.prototype

1.别忘记默认的原型

前面展示的例子中还少了一环。所有引用类型默认都继承了Obeject，而这个继承也是通过原型链实现的。
展现完整的原型链：
在这里插入图片描述
所有函数的默认原型都是Object的实例，因此默认原型都会包含一个内部指针，指向Object.prototype。这也真是所有自定义类型都会继承toString()、valueOf()等默认方法的根本原因。

2.确定原型和实例的关系

第一种方式，使用instanceof操作符，用这个操作符来测试实例与原型链中出现过的构造函数，结果就会返回true。

alert(instance instanceof Object);       //true
alert(instance instanceof SuperType);    //true
alert(instance instanceof SubType);      //true

由于原型链的关系，我们可以说instance是Object、SuperType或SubType中任何一个类型的实例。
第二种方式，使用isPrototypeOf()方法。同样，因此，只要是原型链中出现过的原型，都可以说是该原型链所派生的实例的原型。

alert(Object.prototype.isPrototypeOf(instance));       //true
alert(SuperType.prototype.isPrototypeOf(instance));    //true
alert(SubType.prototype.isPrototypeOf(instance));      //true
谨慎地定义方法

子类型有时候需要重写超类型中的某个方法，或者需要添加超类型中不存在的某个方法。但是不管怎样，都要在SuperType的实例替换原型之后，再定义这两个方法。

function SuperType(){
	this.property = true;
}
SuperType.prototype.getSuperValue = function(){
	return this.property;
}
function SubType(){
	this.subproperty = false;
}
//继承了SuperType
SubType.prototype = new SuperType();
//添加新方法
SubType.prototype.getSubValue = function(){
	return this.subprototype;
};
//重写超类型中的方法
SubType.prototype.getSuperValue = function(){
	return false;
}

var instance = new SubType();
alert(instance.getSuperValue());           //false

还有一点需要注意，即在通过原型链实现继承时，不能使用对象字面量创建原型方法。因为这样做会重写原型链。

function SuperType(){
	this.property = true;
}
SuperType.prototype.getSuperValue = function(){
	return this.property;
}
function SubType(){
	this.subproperty = false;
}

SubType.prototype = new SuperType();

//使用字面量添加新方法，会导致上一行代码无效
SubType.prototype = {
	getSubValue : function (){
		return this.subproperty;
	},
	someOtherMethod : function (){
		return false;
	}
}
var instance = new SubType();
alert(instance.getSuperValue());           //error!

以上代码展示了刚刚吧SuperType的实例赋值给原型，紧接着又将原型替换成一个对象字面量而导致的问题。由于现在的原型包含的是一个Object的实例，而非SuperType的实例，因此我们设想中的原型链已经被切断。

5.原型链的问题

最主要的问题来自包含引用类型值的原型。包含引用类型值的属性会被所有实例共享；而这也正是为什么要在构造函数中，而不是在原型对象中定义属性的原因。在通过原型来实现继承时，原型实际上回变成另一个类型的实例。于是，原先的实例属性也就顺理成章地变成了现在的原型属性了。

function SuperType(){
	this.color = ["red","blue","green"];
}
function SubType(){
}
SubType.prototype = new SuperType();

var instance1 = new SuperType();
instance1.colors.push("black");
alert(instance1.colors);      //"red,blue,green,black"
var instance2 = new SuperType();
alert(instance2.colors);      //"red,blue,green,black"

SubType的所有实例都会共享这一个colors属性。而我们队instance1.colors的修改能够通过instance2.colors反应出来。
原型链的第二个问题：在创建子类型的实例时们不能向超类型的构造函数中传递参数。实际上，应该说是没有办法在不影响所有对象实例的情况下，给超类型的构造函数中传递参数。
由于以上的问题，实践中很少会单独使用原型链。

借用构造函数

在子类型构造函数的内部调用超类型构造函数。别忘了，函数只不过是在特定环境中执行代码的对象，因此通过使用apply()和call()方法也可以在新创建的对象上执行构造函数。

function SuperType(){
	this.colors = ["red","blue","green"];
}
function SubType(){
	//继承了SuperType
	SuperType.call(this);
}
var instance1 = new SubType();
instance1.colors.push("black");
alert(instance1.colors);          //"red,blue,green,black"

var instance2 = new SubType();
alert(instance2.colors);          //"red,blue,green"

SuperType.call(this);代码“借调”了超类型的构造函数。通过使用call()方法/apply()方法。我们实际上是在（未来将要）新创建的SubType实例的环境下调用了SuperType构造函数。这样一来，就会在新SubType对象上执行SuperType()函数中定义的所有对象初始化代码。结果，SubType的每个实例就都会具有自己的colors属性的副本了。

1.传递参数

对于原型链而言，借用构造函数有一个很大的优势，即可以在子类型构造函数中向超类型构造函数传递参数

function SuperType(name){
	this.name = name;
}
function SubType(){
	//继承了SuperType,同时还传递了参数;
	SuperType.call(this,"Nicholas");

	//实例属性
	this.age = 29;
}
vatr instance = new SubType();
alert(instance.name);            //"Nicholas"
alert(instance.age);             //29
2.借用构造函数的问题

如果仅仅是借用构造函数，那么也将无法避免构造函数模式存在的问题–方法都在构造函数中定义，因此函数复用就无从谈起了。而且，在超类型的原型中定义的方法，对子类型而言也是不可见的，结果所有类型都只能使用构造函数。

组合继承

结合原型链和借用构造函数的技术，使用原型链实现对原型属性和方法的继承，而通过借用构造函数来实现对实例属性的继承。这样，既通过在原型上定义方法实现了函数复用，又能保证每个实例都有它自己的属性。

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.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"
insance1.sayAge();              //29

var instance2 = new SubType("Greg",27);
alert(instance2.colors);        //"red,blue,green"
instance2.sayName();            //"Grey"
instance2.sayAge();             //27

组合继承避免了原型链和借用构造函数的缺陷，融合了它们的优点，成为JavaScript中最常用的继承模式。

原型式继承

函数表达式

定义函数的两种方式：函数声明和函数表达式。
函数声明：

function functionName(arg0,arg1,arg2){
	//函数体
}

即（function关键字 函数名) 的方式，在某些浏览器中，给函数定义了一个非标准的name属性，通过这个属性可以访问到给函数指定的名字。

//只在Firefox、Safari、Chrome和Opera有效
alert(functionName.name);            //"functionName"

函数声明的一个重要特征就是函数声明提升，意思是在执行代码之前会先读取函数声明。这就意味着可以把函数声明放在调用它的语句后面。
sayHi();
function sayHi(){
alert(“Hi!”);
}
函数表达式：
最常见的形式：

var functionName = function(arg0,arg1,arg2){
	//函数体
}

这种形式看起来像是常规的变量赋值语句，即创建一个函数并将它赋值给变量functionName。这种函数叫做匿名函数（因为function关键字后面没有标识符，也叫拉姆达函数）。匿名函数的name属性是空字符串。
函数表达式与其他表达式一样，在使用前必须先赋值。

sayHi();        //错误：函数还不存在
var sayHi = function(){
	alert("Hi!");
};

理解函数提升的关键，就是理解函数声明与函数表达式之间的区别。

//不要这样做！
if(condition){
	function sayHi(){
		alert("Hi!");
	}
} else {
	function sayHi(){
		alert("Yo!");
	}
}

表面上可能此代码没有问题，但实际上，这在ECMAScript中属于无效语法，JS引擎会尝试修正错误，将其转换为合理的状态。但是浏览器修正错误的语法并不一致，大多数浏览器会返回第二个声明，忽略condition；有些会在condition为true的时候，返回第一个声明。
但是如果是使用函数表达式就没有什么问题了。

//可以这样做
var sayHi;
if(condition){
	sayHi = function (){
		alert("Hi!");
	}
} else {
	sayHi = function (){
		alert("Yo!");
	}
}

这个例子不会有意外，不同的函数会根据condition被赋值给sayHi。
能够创建函数再赋值给变量，也就能够把函数作为其他函数的值返回。

function createComparisonFunction(propertyName){
	return function(obj1,obj2){
		var value1 = obj1[propertyName];
		var value2 = obj2[propertyName];
		if(value1 < value2){
			return -1;
		} else if(value1 > value2){
			return 1;
		} else {
			return 0;
		}
	}
}

createComparisonFunction()就返回了一个匿名函数。返回的函数可能会被赋值给一个变量或者以其他方式被调用，把函数当成值来使用的情况下，都可以使用匿名函数。不过这不是匿名函数的唯一途径。

7.1递归

递归函数是在一个函数通过名字调用自身的情况下构成的。

function factorial(num){
	if(num<=1){
		return 1;
	} else {
		return num +factorial(num-1);
	}
}

这是一个经典的递归阶乘函数。在下面的情况中使用此函数，会报错。

var anotherFactorial = factorial;
factorial = null;
alert(anotherFactorial(4));      //出错！

在调用anotherFactorial()时，由于必须执行factorial()（因为函数体内有factorial函数），而factorial已经不再是函数，所以就会导致错误。
在这种情况下，使用arguments.callee(指向正在执行的函数的指针，因此可以用它来实现对函数的递归调用)可以解决这个问题。

function factorial(num){
	if(num<=1){
		return 1;
	} else {
		return num * arguments.callee(num-1);
	}
}

但是，在严格模式下，不能通过脚本访问arguments.callee，访问这个属性会导致错误。不过可以使用命名函数表达式来达成相同的效果。

var factorial = (function f(num){
	if (num <= 1){
		return 1；
	} else {
		return num * f(num-1);
	}
});

这种方式在严格模式和非严格模式下都行得通。

闭包

闭包是指有权访问另一个函数作用域中的变量的函数。
创建闭包的常见方式，就是在一个函数内部创建另一个函数，仍一前面的createComparisonFunction()函数为例 ：

function createComparisonFunction(propertyName){
	return function(object1,object2){
		**var value1 = object[propertyName];
		**var value2 = object[propertyName];
	
		if(value1 < value2){
			return -1;
		} else if(value1 > value2){
			return 1;
		} else{
			return 0;
		}
	}
}
mirror_Mx
关注
专栏目录
JavaScript高级程序设计读书笔记--语言基础
m0_44981797的博客
04-12 1288
1.语法 1.1 标识符 标识符，就是变量、函数、属性或函数参数的名称。标识符按照ECMAScript惯例，采用驼峰命名法，由一或多个下列字符组成： 第一个字符必须是一个字母、下划线（_）或美元符号（$）； 剩下的其他字符可以是字母、下划线、美元符号或数字。 1.2 语句 ECMAScript 中的语句以分号结尾。省略分号就意味着由解析器确定语句在哪结尾。加分号有助于防止因为省略造成的问题，也便于开发者通过删除空行来压缩代码（如果没有结尾的分号，只删除空行，则会导致语法错误），同时加分号也有助于在某些情
JavaScript高级程序设计 阅读笔记（十五） 浏览器中的JavaScript
12-11
Window对象 窗口操作 Window对象对操作浏览器窗口非常有用，开发者可以移动或调整浏览器窗口的大小。可用四种方法实现这些操作： moveBy(dx,dy)：把浏览器窗口相对当前位置水平移动dx个像素，垂直移动dy个像素。...
javascript高级程序设计读书笔记(一)
Marshall's
11-08 1069
上“人机交互”课上时记的一些东西，留下来备忘。上次那个JVM书的读书笔记真的只有一篇了，因为只能在IBM里才能看到，呵呵~~1. isFinit(Number) 判断数字是不是无穷大， isNan(..)判断是不是数字2. parseInt(String, int), 可以解析各种进制的整数3. Nan != NaN, typeof(null) == "object"4. Stirng.charC
javascript高级程序设计读书笔记1
LZJ394112的博客
03-13 125
浮点数虽然精度很高，但在实际计算中的精度可能不如整数。比如0.1+0.2并不等于0.3，而是0.3000000000000004，所以把浮点数的计算结果当做判断条件会产生失误，这是基于IEEE754数据浮点计算的通病，js的数的表示范围也有限制，如果超过Number.MAX_VALUE或小于Number.MIN_VALUE，则数据为（+/-）Infinity,可用函数isInfinity...
<<JavaScript高级程序设计>>读书笔记
TINA_DD的博客
07-30 378
第一章是js的发展历程，就不写了。 第二章：在HTML中使用JavaScript 在HTML页面中插入JavaScript的主要方法: 使用元素的方法有两种: 直接在HTML页面中嵌入JavaScript代码和包含外部JavaScript文件 在HTML页面中嵌入script代码时注意不要再代码的任何地方出现””字符串,通过转义字符可以解决,”<\/script>
Javascript高级程序设计读书笔记1
esabeny的博客
01-26 137
1.小结1 1.JavaScript的基本数据类型包括Undefined, Null, Boolean,Number,String 2.与其他语言不同,ECMScript没有整数和浮点数，Number类型可用于表达所有数值 3.不存在重载，函数没有返回值，返回值为undefined 4.我们不能给基本类型添加属性 5.一个变量向另一个变量复制基本类型的值，会在变量对象上新创建一个新值，然后把该值复制到为新变量分配的位置上 6.当一个变量向另一个变量复制引用类型的值时，同样会将存储在变量对象中的值复制一份放到
javascript 高级程序设计 读书笔记（3）
04-19
《JavaScript高级程序设计》是JavaScript开发者的经典教材，它深入探讨了这门语言的核心概念和技术。这篇读书笔记主要聚焦在第三部分，这部分通常涵盖了更高级的主题，如对象、原型、闭包以及模块化等。结合提供的...
JavaScript高级程序设计 读书笔记之八 Function类及闭包
12-11
JavaScript中的Function类是一种特殊的数据类型，它可以用来动态创建或表示任何开发者定义的函数。通过`new Function()`构造函数，我们可以传递参数列表和函数体来创建一个新的函数。例如，`var sayHi = new ...
JavaScript高级程序设计 读书笔记之十一 内置对象Global
12-11
内置对象 定义：由ECMAScript实现提供的、独立于宿主环境的所有对象，在ECMAScript程序开始执行时出现。 由定义可知开发者不必明确实例化内置对象，它已被实例化了。在ECMAScript-262只定义了两个内置对象，即Global...
《javascript高级程序设计》读书笔记
前端笔记
08-18 877
1. js没有块级作用域 if(true){ var color ="blue"; } alert(color); //"blue" for (var i=0; i<10 i++){ doSomething(i); } alert(i  对于块级作用域的语言来说，for语句初始化变量的表达所定义的变量，只会存在于循环的环境中。而对于JavaScript来说，由for语句创建的变量i即使在
JavaScript高级程序设计（读书笔记）（一）
热门推荐
hc1025808587的专栏
05-23 1万+
JavaScript高级程序设计（JS部分知识汇总）本笔记汇总了作者认为“JavaScript高级程序设计”这本书的前七章知识重点，仅供参考。第一章 JavaScript简介JavaScript发展简史： 1995年，JavaScript诞生 1997年，由欧洲计算机制造协会（ECMA，European Computer Manufactures Association）指定的39号技术委员会制
JavaScript高级程序设计——读书笔记
最新发布
淡水瑜的博客
05-03 1598
想要全面理解和掌握JavaScript，关键在于弄清楚它的本质、历史、局限性。ECMAScriptECMAScript（简称ES）是一种用于编写Web浏览器脚本语言的标准，它定义了JavaScript语言的核心规范。它由Ecma International 标准化组织负责管理和更新。JavaScript是ECMAScript标准的一种实现，其他还有JScript和ActionScript等。ECMAScript的目标是提供一种可以跨平台、可靠、高效、强大的脚本语言。
《javaScript高级程序设计》阅读笔记
kkjy_00的博客
07-24 340
《javaScript高级程序设计》笔记
JavaScript高级程序设计阅读笔记
hiwzg
01-26 144
由于前端越来越受到关注，前两天，我也买到了这本久受褒奖的书。确实是很不错，被它引吸住了。 我承认，自己以前对JavaScript了解得太少。其实，就语言这个层次来讲，JavaScript语言和其他强类型语言：Java等没有优劣之分，只有试用的场合不同，以及语言所具备的语境有所区别，但是有很多部分都差不多。 JavaScript语言很棒，也相对简单一些。我需要做的...
JavaScript 高级程序设计读书笔记
马踏飞燕
08-09 156
第一章Javascript简介 第二章在HTML中使用Javascript 第一章Javascript简介 Javascript是一门专为网页交互而设计的脚本语言，由三部分组成： 1. ECMAScript, 由ECMA-262定义，提供核心语言功能。 2. 文档对象模型（DOM），提供访问和操作网页内容的方法和接口。 3. 浏览器对象模型（BOM），提供与浏...
JavaScript高级程序设计读书笔记
qq_45968958的博客
12-01 191
学习目标： JavaScript高级程序设计 学习内容： 什么是JavaScript JavaScript是一门用来与网页交互的脚本语言，包含以下三个组成部分。 1.ECMAScript：由ECMA-262定义并提供核心功能。 2.文档对象模型（DOM）：提供与网页内容交互的方法和接口。 3.浏览器对象模型（BOM）：提供与浏览器交互的方法和接口。 HTML中的JavaScrip script元素 1.在网页中嵌入JavaScript代码 <script> function sayHi
JavaScript高级程序设计读书笔记：原始值与引用值解析
"javascript读书笔记1，涵盖了ECMAScript变量声明、变量值的存储方式以及原始类型与引用类型的区别。" 在深入理解JavaScript编程时，了解变量的声明与作用至关重要。根据描述，当JavaScript（ECMAScript）的解释器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值