2.1 JavaScript的特点

JavaScript程序设计语言有如下几个特点：

• 解释型语言
• 类似于C和Java的语法结构
• 动态语言
• 基于原型的面向对象
• 字面量的表现能力
• 函数式编程

解释型语言直接运行环境中执行代码。解释型语言的劣势在于，其运行速度通常都会慢于编译型语言。解释型语言由于使用了JIT（Just In Time）这种能够运行中进行编译的技术，使得运行速度得以改善。

从代码角度看，动态语言的变量和函数是不指定返回值类型。

【评】摘抄一下，解释型语言和动态语言的含义，具体理解应该要看一下代码，其他的没有什么重点直接忽略。

2.3 变量的基础

2.3.1 变量的使用方法

变量的作用是给某一个值或是对象标注名称。

使用关键字var就可以对变量声明。

【评】在C语言中有各种各样的关键字去定义变量，但是JavaScript只有关键字var，毕竟它是弱数据类型。

var hzh;        // 声明变量hzh
var HZH;        // 声明变量HZH
var huangzihan; // 声明变量huangzihan
var Huangzihan; // 声明变量Huangzihan
var HuangZihan; // 声明变量HuangZihan

通过赋值运算符（=）可以给变量赋值，即在运算符的左侧书写变量，而在右侧书写要赋的值。

var hzh = "黄子涵是帅哥！";        // 将字符串"黄子涵是帅哥！"赋值给变量hzh
var HZH = "黄子涵是靓仔！";        // 将字符串"黄子涵是靓仔！"赋值给变量HZH
var huangzihan = "黄子涵真厉害！"; // 将字符串"黄子涵真厉害！"赋值给变量huangzihan
var Huangzihan = "黄子涵真聪明！"; // 将字符串"黄子涵真聪明！"赋值给变量Huangzihan
var HuangZihan = "黄子涵真棒！";   // 将字符串"黄子涵真棒！"赋值给变量HuangZihan

被声明但未进行任何赋值的变量，其值为undefined。读取这类变量的值不会引起运行时错误。需要注意的是，在大部分情况下，读取undefined值都是产生错误的根源。

var huangzihan; 
console.log(huangzihan);

如果要读取没有被声明的变量（即作为右值使用该变量），就会引发ReferenceError异常；如果将其作为左值使用，即作为赋值对象使用，则不会发生错误。

console.log(huangzihan);

2.3.2 省略var

【评】自己都是不要省略，无语！

2.3.3 常量

如果要声明一个常量，需要使用const关键字而不是var。可以作为常量名使用的字符和变量的是相同，不过习惯上常量名都以大写字母表示。

const HZH = 1;
const HUANGZIHAN = 2;
console.log(HZH);
console.log(HUANGZIHAN);

如果在声明时没有对常量进行赋值的话，它的值就是undefined，对其的处理方式和变量相同。

const HZH;
const HUANGZIHAN;
console.log(HZH);
console.log(HUANGZIHAN);

2.4 函数基础

2.4.1 函数的定义

函数是由一连串的子程序（语句的集合）所组成的，可以被外部程序调用。向函数传递参数之后，函数可以返回一定的值。

console.log("1");
function hzh() {       // 声明函数
    console.log("2");
}
console.log("3");      // 调用函数
hzh();

2.4.2 函数的声明与调用

可以通过函数声明语句来定义一个函数。函数声明语句以关键字function开始，其后跟有函数名、参数列表和函数体。其语法如下所示：

// 函数名为sum，参数名为a和b
// 函数声明中所写的参数称为形参（形式参数）
function huangzihan (a,b) {
    return Number(a) + Number(b);
}

// 函数sum的调用
// 调用函数时，传递给函数的参数称为实参（实际参数）
console.log(huangzihan(3,4));

函数声明时不必指定形参的类型。任何类型的值都可以作为实参传递，因而开发者在设计函数时需要考虑接收错误类型的值的情况。此外，形参的数量和实参的数量可以不一致。所以，在JavaScript中不存在函数重载。

2.4.3 匿名函数

匿名函数的语法形式在function后跟可以省略的函数名、参数列表以及函数体。其语法如下所示：

函数声明语句和匿名函数表达式在语法上几乎一模一样，唯一的区别仅仅是能否省略函数名称。不过，因为匿名函数表达式是一种表达式而非语句，所以也可以在表达式内使用。另外由于它是表达式因此也会有返回值。匿名函数的返回值是一个 Function 对象的引用。把它简单理解为返回一个函数也没有问题。

// 赋值表达式右侧的就是匿名函数表达式。
var hzh = function (a, b) {
    return Number(a) + Number(b)
}

// hzh的前面是var，所以它是一个变量名
// 以function开始的匿名函数表达式将返回一个函数
// 那么我们来测试变量hzh是不是接收到一个函数

console.log("判断函数hzh是不是接收的是函数：" + typeof hzh);

// 上面那段代码的含义是，将Function对象的一个引用赋值给变量hzh
// 现在我们来调用变量hzh所引用的函数

console.log("调用变量hzh：" + hzh(3, 4));

2.4.4 函数是一种对象

avaScript 的函数是一种对象，不过并不是说所有的对象都是函数。函数是一种包含了可执行代码，并能够被其他代码调用的特殊的对象。

2.5 对象的基础

2.5.1 对象的定义

Java 中的对象可以认为是类的一种实例化结果，而 JavaScript中并没有类这样的语言构造。JavaScript 中的对象是一个名称与值配对的集合。这种名称与值的配对被称为属性。这样一来，JavaScript 对象可以定义为属性的集合。

面上看，JavaScript 对象和 Java 的映射（java.util.Map）非常相似。实际上，JavaScript 对象可以用作管理键值对的关联数组 [ 又称映射（Map）或字典（Dictionary）]。JavaScript 对象还有着 Java 映射所没有的两个特点。

• 其一是 JavaScript 对象的属性值可以由函数指定。
• 其二是 JavaScript 具备一种称为原型链的构造。通过这一构造，JavaScript 对象实现了类似于类的继承的能力。

简单说来，将对象理解为一种实体即可，程序可以通过它来进行数据处理。

2.5.2 对象字面量表达式与对象的使用

可以通过对象字面量表达式来生成一个对象。对象字面量表达式由大括号{}括起，内部有属性名和属性值。

属性名可以是标识符、字符串值或是数值。属性值则可以是任意的值或对象。

var hzh1 = { hzh :2, huangzihan:1 }       // 属性名是标识符
var hzh2 = { "hzh" :2, "huangzihan":1 }   // 属性名是字符串值
var hzh3 = { 'hzh' :2, 'huangzihan':1 }   // 属性名是字符串值
var hzh4 = { 1:2, 2:1 }                   // 属性名是数值
var hzh5 = { 
    hzh:2, 
    huangzihan:1, 
    enable:true, 
    color:{ r:255, g:255, b:255 }
} //各种类型的属性值
console.log("输出它们的值：");
console.log("hzh1 = " + hzh1);
console.log("hzh2 = " + hzh2);
console.log("hzh3 = " + hzh3);
console.log("hzh4 = " + hzh4);
console.log("hzh5 = " + hzh5);
console.log("*******************************************");
// 对对象字面量表达式求值所得到的结果，是所生成对象的一个引用。
console.log("检查它们的数据类型：");
console.log("hzh1的数据类型：" + (typeof hzh1));
console.log("hzh2的数据类型：" + (typeof hzh2));
console.log("hzh3的数据类型：" + (typeof hzh3));
console.log("hzh4的数据类型：" + (typeof hzh4));
console.log("hzh5的数据类型：" + (typeof hzh5));

2.5.3 属性访问

可以通过点运算符（.）访问对象引用中的属性。只要在点运算符之后书写属性名，就能够读取相应的属性值。

var hzh = { huangzihan:3 };
// 显示对象hzh的属性huangzihan的值
console.log("hzh.huangzihan：" + hzh.huangzihan); 

// 如果属性的值是一个对象，可以通过多次点运算来读取其属性
var hzh2 = { huangzihan: { x:3, y:4 }};
console.log("hzh2.huangzihan.x：" + hzh2.huangzihan.x);
console.log("hzh2.huangzihan.y：" + hzh2.huangzihan.y);

// 在赋值表达式的左侧书写属性访问表达式的话，就可以将相应的值赋给该属性。
hzh.huangzihan = 2333; // 这将覆盖已有的属性值
console.log("hzh.huangzihan：" + hzh.huangzihan);

// 如果赋值给尚不存在的属性名，则将新建该属性并对其赋值。
hzh.huangchunqin = 5;
console.log("hzh.huangchunqin：" + hzh.huangchunqin);

2.5.4 属性访问（括号方式）

// 除了点运算符外，还可以使用中括号运算符 [] 来访问属性。
// []内是需要访问的属性名的字符串值
var hzh = { huangzihan : 3}
console.log("hzh['huangzihan']：" + hzh['huangzihan']);

// [] 里可以是字符字面量，也可以是值为字符串的变量
var HZH = 'huangzihan';
console.log("hzh[HZH]：" + hzh[HZH]);

// 括号运算符也能用于赋值表达式的左侧。
hzh['5'] = 5;
console.log("hzh['5']：" + hzh['5']);

2.5.5 方法

// 函数sum的声明
function sum(a, b) {
    return Number(a) + Number(b);
}

// 可以把任意类型的值、对象或者函数赋值给对象的属性。
// 将函数赋值给对象hzh的属性fn
// 对象属性的函数也可称为一种方法。
var hzh = { 
    fn : null,
    fn2 : null 
};
hzh.fn = function(a, b) { return Number(a) + Number(b); };
hzh.fn2 = sum;
console.log("**********hzh.fn***********");
console.log("hzh.fn：" + hzh.fn);
console.log("hzh.fn(3, 4)：" + hzh.fn(3, 4));
console.log("**********hzh.fn2***********");
console.log("hzh.fn2：" + hzh.fn2);
console.log("hzh.fn2(3, 4)：" + hzh.fn2(3, 4));

2.5.6 new表达式

// new表达式的作用是生产一个对象
var hzh = new Object();
console.log("变量hzh的类型：" + typeof hzh);

// 通过typeof运算符来判别obj的类型，得到的结果object
// 在new之后写函数名的话，就会把该函数作为构造函数来进行调用

2.5.7 类与实例

虽然在 JavaScript 中没有类的概念，但将 new 之后所写的标识符（函数名）看作是类名， 也并没有什么概念上的问题。

2.5.8 对类的功能的整理

类的属性是一个类自身的属性，例如，String 类的属性是 String 类的对象自身的属性。如果是函数的话，则可以像 String.fromCharCode(0x41) 这样来使用。如果用更加直观一些的说法来讲，这就相当于 Java 或 C++ 中的 static 方法。

prototype 对象的属性和实例属性，都是以对象实例的形式来进行访问的。以 String 类为例，可以以 str.trim() 或是 str.length的方式，来使用引用了 String 对象（对象实例）的变量 str。

prototype 对象的属性与实例属性之间的不同点在于是否进行了继承。例如，String 对象的 trim 方法，其实是 String.prototype 对象的属性。这种以实例来继承属性的方式被称为原型继承。

2.5.9 对象与类型

Java 中对象分为类与接口等不同类型。在 JavaScript 中不存在这样的类型区分。不过如果把对象的行为方式定义为其类型的话，JavaScript 的对象也可说是有类型的，只不过并不是 Java 那样的严格的类型。

在 Java 中，需要事先进行严格的类型定义（通常以层级方式进行管理），然后将对象置于类型层级中进行分类。然而在 JavaScript 中，则是根据不同对象的不同行为方式，在事实上对其类型做出了分类。在 Java 中，由于语法规则的需要，强制使用了基于类型层级的编程风格。与此相对，在 JavaScript 中虽然也能够定义（类似于）类（的实体），并以类型层级的方式对对象进行分类，但这仅仅是可供选择的一种风格，没有作强制性的要求。

2.6 数组的基础

数组是一种用于表达有顺序关系的值的集合的语言结构。在 JavaScript 中，数组并非是一种内建类型。相对地，JavaScript 支持 Array 类，所以数组能够以 Array 类的实例的形式实现。不过，由于有数组字面量的表达方式，所以在一般情况下，只需将其作为内建类型使用即可。

// 数组字面量的书写方式为，在方括号内列出所需的值。
// 通过数组字面量就能够生成数组。
var hzh = [1, 100, 7];

// 数组内的各个值被称作元素。每一个元素都可以通过索引（下标）来快速读取。
// 索引是从零开始的整数。
//对于上面的数组，可以像下面的代码这样，通过在方括号中书写索引值 1 来读取其第 2 个元素。

console.log("hzh[0]：" + hzh[0]); //读取索引值为1的元素
console.log("hzh[0]：" + hzh[1]); //读取索引值为2的元素
console.log("hzh[0]：" + hzh[2]); //读取索引值为3的元素

console.log("**************************************************");
// 在括号中不仅可以直接写某个数值，还可以写具有某一特定值的变量或表达式。
var huangzihan = 0;
console.log("hzh[huangzihan]：" + hzh[huangzihan]);      // 与hzh[0]含义相同
console.log("hzh[huangzihan + 1]：" + hzh[huangzihan + 1]);  // 与hzh[1]含义相同
console.log("hzh[huangzihan + 2]：" + hzh[huangzihan + 2]);  // 与hzh[2]含义相同

console.log("**************************************************");
// JavaScript 的数组支持同时包含不同类型的元素。
var hzhArr = [1, 'huangzihan', null, undefined, {}, [1, 2, 3]];
console.log("hzhArr[0]：" + hzhArr[0]);
console.log("hzhArr[1]：" + hzhArr[1]);
console.log("hzhArr[2]：" + hzhArr[2]);
console.log("hzhArr[3]：" + hzhArr[3]);
console.log("hzhArr[4]：" + hzhArr[4]);
console.log("hzhArr[5]：" + hzhArr[5]);