快速入门

JavaScript的引入

引入JS有两种方式,无论哪一种最好放置在页面底部,因为我们的代码是从上至下解析的,写在底部可以避免当js出错时影响页面结构和样式的问题出现。

  • 方式一
<html>
<head>
</head>
<body>
...
</body>
<script>
alert('Hello, world!');
</script>
</html>

<script>...</script>包含的代码就是JavaScript代码,可以在页面中多次编写<script> js代码... </script>,浏览器按照顺序依次执行。

  • 方式二

把JavaScript代码放到一个单独的js文件中。

<html>
<head>
<script src="js/all.js"></script>
</head>
<body>
...
</body>
</html>

优势:更利于维护代码,并且多个页面可以各自引用同一份js文件。可以在同一个页面中引入多个js文件。

基本语法

JavaScript的每个语句以分号结束,语句块用{...}包含。JavaScript并不强制要求在每个语句的结尾加分号,浏览器中负责执行JavaScript代码的引擎会自动在每个语句的结尾补上分号。但是让JavaScript引擎自动加分号在某些情况下会改变程序的语义,可能会导致运行结果与期望不一致。所以在平时编码中最好不要省略结束分号。

例如:

//完整的赋值语句
var name = 'Tom';
//判断语句块:符合条件,执行语句块内容。
if (2 > 1) {
x = 1;
y = 2;
z = 3;
}
//{...}代码块还可以嵌套使用,形成层级结构
if (2 > 1) {
x = 1;
y = 2;
z = 3;
if (x < y) {
z = 4;
}
if (x > y) {
z = 5;
}
}

注意:

  • 花括号{...}内的语句具有缩进,通常是2个空格。缩进不是JavaScript语法要求必须的,但缩进有助于我们理解代码的层次,所以编写代码时要遵守缩进规则。很多文本编辑器具有“自动缩进”的功能,可以帮助整理代码;
  • JavaScript本身对嵌套的层级没有限制,但是过多的嵌套无疑会大大增加看懂代码的难度。遇到这种情况,需要把部分代码抽出来,作为函数来调用,这样可以减少代码的复杂度。

注释

  • 以//开头直到行末的字符被视为行注释,注释是给开发人员看到,JavaScript引擎会自动忽略:

    // 这是一行注释
    alert('hello'); // 这也是注释
  • 块注释是用/*...*/把多行字符包裹起来,把一大“块”视为一个注释:

    /* 从这里开始是块注释
    仍然是注释
    仍然是注释
    注释结束 */

数据类型和变量

一、JavaScript中数据类型包括基本数据类型引用数据类型

基本数据类型:number、string、boolean、undefined、null

  • number
    JavaScript不区分整数和浮点数,统一用Number表示,以下都是合法的Number类型:
123; // 整数123
0.456; // 浮点数0.456
1.2345e3; // 科学计数法表示1.2345x1000,等同于1234.5
-99; // 负数
NaN; // NaN表示Not a Number,是特殊的number当无法计算结果时用NaN表示
Infinity; // Infinity表示无限大,当数值超过了JavaScript的Number所能表示的最大值时,就表示为Infinity

number可以直接做四则运算,规则和数学一致。

  • string
    字符串是以单引号’或双引号”括起来的任意文本,比如’abc’,”xyz”等等。请注意,’’或””本身只是一种表示方式,不是字符串的一部分,因此,字符串’abc’只有a,b,c这3个字符。

  • boolean
    布尔值和布尔代数的表示完全一致,一个布尔值只有true、false两种值,要么是true,要么是false,可以直接用true、false表示布尔值,也可以通过布尔运算计算出来:

    true; // 这是一个true值
    false; // 这是一个false值
    2 > 1; // 这是一个true值
    2 >= 3; // 这是一个false值
  • undefined
    表示“未定义”,undefined仅仅在判断函数参数是否传递的情况下有用。

  • null
    表示一个“空”的值,它和0以及空字符串’’不同,0是一个数值,’’表示长度为0的字符串,而null表示“空”。

引用数据类型:Function、Object、Array

二、变量
变量在JavaScript中就是用一个变量名表示,变量名是大小写英文、数字、$和_的组合,且不能用数字开头。变量名也不能是JavaScript的关键字,如if、while等。也不要用英文申明一个变量用var语句,比如:

var a; // 申明了变量a,此时a的值为undefined
var $b = 1; // 申明了变量$b,同时给$b赋值,此时$b的值为1
var s_007 = '007'; // s_007是一个字符串
var Answer = true; // Answer是一个布尔值true
var t = null; // t的值是null

字符串

字符串常见的操作如下:

var s = 'Hello, world!';
document.write(s.length); // 13 获取字符串长度

要获取字符串某个指定位置的字符,使用类似Array的下标操作,索引号从0开始:

var s = 'Hello, world!';
document.write(s[0]); // 'H'
document.write(s[6]); // ' '
document.write(s[7]); // 'w'
document.write(s[12]); // '!'
document.write(s[13]); // undefined 超出范围的索引不会报错,但一律返回undefined

需要特别注意的是,字符串是不可变的,如果对字符串的某个索引赋值,不会有任何错误,但是,也没有任何效果:

var s = 'Test';
s[0] = 'X';
alert(s); // s仍然为'Test'

JavaScript为字符串提供了一些常用方法,注意,调用这些方法本身不会改变原有字符串的内容,而是返回一个新字符串。

  • toUpperCase()把一个字符串全部变为大写
  • toLowerCase()把一个字符串全部变为小写
  • indexOf()会搜索指定字符串出现的位置
  • substring()返回指定索引区间的子串
    举例:
    var str1 = 'Hello';
    var str2 = 'Hello, world';
    str1.toUpperCase(); // 返回'HELLO'
    str1.toLowerCase(); // 返回'hello'
    str2.indexOf('world'); // 返回7
    str2.indexOf('World'); // 没有找到指定的子串,返回-1
    str2.substring(0, 5); // 从索引0开始到5(不包括5),返回'hello'
    str2.substring(7); // 从索引7开始到结束,返回'world'

数组

数组是一组按顺序排列的集合,集合的每个值称为元素。JavaScript的数组可以包括任意数据类型。例如:

[1, 2, 3.14, 'Hello', null, true];

上述数组包含6个元素。数组用[]表示,元素之间用,分隔。

另一种创建数组的方法是通过Array()函数实现:

var arr = new Array(1, 2, 3); // 创建了数组[1, 2, 3]

然而,出于代码的可读性考虑,强烈建议直接使用[]。

数组的元素可以通过索引来访问。请注意,索引的起始值为0:

var arr = [1, 2, 3.14, 'Hello', null, true];
document.write(arr[0]); // 返回索引为0的元素,即1
document.write(arr[5]); // 返回索引为5的元素,即true
document.write(arr[6]); // 索引超出了范围,返回undefined

要取得Array的长度,直接访问length属性:

var arr = [1, 2, 3.14, 'Hello', null, true];
document.write(arr.length); // 6

请注意,直接给Array的length赋一个新的值会导致Array大小的变化:

var arr = [1, 2, 3];
arr.length; // 3
arr.length = 6;
document.write(arr); // arr变为[1, 2, 3, undefined, undefined, undefined]
arr.length = 2;
document.write(arr); // arr变为[1, 2]

Array可以通过索引把对应的元素修改为新的值,因此,对Array的索引进行赋值会直接修改这个Array:

var arr = ['A', 'B', 'C'];
arr[1] = 99;
document.write(arr); // arr现在变为['A', 99, 'C']

请注意,如果通过索引赋值时,索引超过了范围,同样会引起Array大小的变化:

var arr = [1, 2, 3];
arr[5] = 'x';
document.write(arr); // arr变为[1, 2, 3, undefined, undefined, 'x']

大多数其他编程语言不允许直接改变数组的大小,越界访问索引会报错。然而,JavaScript的Array却不会有任何错误。在编写代码时,不建议直接修改Array的大小,访问索引时要确保索引不会越界。

数组中的一些方法:

  • indexOf

与String类似,Array也可以通过indexOf()来搜索一个指定的元素的位置:

var arr = [10, '30', 'xyz'];
document.write(arr.indexOf(10)); // 元素10的索引为0
document.write(arr.indexOf(30)); // 元素30没有找到,返回-1
document.write(arr.indexOf('30')); // 元素'30'的索引为1

注意了,数字30和字符串’30’是不同的元素。

  • slice

slice()就是对应String的substring()版本,它截取Array的部分元素,然后返回一个新的Array:

var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
document.write(arr.slice(0, 3)); // 从索引0开始,到索引3结束,但不包括索引3: ['A', 'B', 'C']
document.write(arr.slice(3)); // 从索引3开始到结束: ['D', 'E', 'F', 'G']

注意到slice()的起止参数包括开始索引,不包括结束索引。

如果不给slice()传递任何参数,它就会从头到尾截取所有元素。利用这一点,我们可以很容易地复制一个Array:

var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
var aCopy = arr.slice();
document.write(aCopy); // ['A', 'B', 'C', 'D', 'E', 'F', 'G']
document.write(aCopy === arr); // false

  • push和pop

push()向Array的末尾添加若干元素,pop()则把Array的最后一个元素删除掉:

var arr = [1, 2];
arr.push('A', 'B'); // 返回Array新的长度: 4
document.write(arr); // [1, 2, 'A', 'B']
arr.pop(); // pop()返回'B'
document.write(arr); // [1, 2, 'A']
arr.pop(); arr.pop(); arr.pop(); // 连续pop 3次
document.write(arr); // []
arr.pop(); // 空数组继续pop不会报错,而是返回undefined
document.write(arr); // []

  • unshift和shift

如果要往Array的头部添加若干元素,使用unshift()方法,shift()方法则把Array的第一个元素删掉:

var arr = [1, 2];
arr.unshift('A', 'B'); // 返回Array新的长度: 4
document.write(arr); // ['A', 'B', 1, 2]
arr.shift(); // 'A'
document.write(arr); // ['B', 1, 2]
arr.shift(); arr.shift(); arr.shift(); // 连续shift 3次
document.write(arr); // []
arr.shift(); // 空数组继续shift不会报错,而是返回undefined
document.write(arr); // []

  • sort

sort()可以对当前Array进行排序,它会直接修改当前Array的元素位置,直接调用时,按照默认顺序排序:

var arr = ['B', 'C', 'A'];
arr.sort();
document.write(arr); // ['A', 'B', 'C']

  • reverse

reverse()把整个Array的元素反转:

var arr = ['one', 'two', 'three'];
arr.reverse();
document.write(arr); // ['three', 'two', 'one']

  • splice

splice()方法是修改Array的“万能方法”,它可以从指定的索引开始删除若干元素,然后再从该位置添加若干元素:

var arr = ['Microsoft', 'Apple', 'Yahoo', 'AOL', 'Excite', 'Oracle'];
// 从索引2开始删除3个元素,然后再添加两个元素:
arr.splice(2, 3, 'Google', 'Facebook'); // 返回删除的元素 ['Yahoo', 'AOL', 'Excite']
document.write(arr); // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']
// 只删除,不添加:
arr.splice(2, 2); // ['Google', 'Facebook']
document.write(arr); // ['Microsoft', 'Apple', 'Oracle']
// 只添加,不删除:
arr.splice(2, 0, 'Google', 'Facebook'); // 返回[],因为没有删除任何元素
document.write(arr); // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']

  • concat

concat()方法把当前的Array和另一个Array连接起来,并返回一个新的Array:

var arr = ['A', 'B', 'C'];
var added = arr.concat([1, 2, 3]);
document.write(added); // ['A', 'B', 'C', 1, 2, 3]
document.write(arr); // ['A', 'B', 'C']

请注意,concat()方法并没有修改当前Array,而是返回了一个新的Array。

实际上,concat()方法可以接收任意个元素和Array,并且自动把Array拆开,然后全部添加到新的Array里:

var arr = ['A', 'B', 'C'];
arr.concat(1, 2, [3, 4]); // ['A', 'B', 'C', 1, 2, 3, 4]

  • join

join()方法是一个非常实用的方法,它把当前Array的每个元素都用指定的字符串连接起来,然后返回连接后的字符串:

var arr = ['A', 'B', 'C', 1, 2, 3];
arr.join('-'); // 'A-B-C-1-2-3'

如果Array的元素不是字符串,将自动转换为字符串后再连接。

多维数组

如果数组的某个元素又是一个Array,则可以形成多维数组,例如:

var arr = [[1, 2, 3], [400, 500, 600], '-'];

上述Array包含3个元素,其中头两个元素本身也是Array。

对象

JavaScript的对象是一种无序的集合数据类型,它由若干键值对组成。

JavaScript的对象用于描述现实世界中的某个对象。例如,为了描述“小明”这个淘气的小朋友,我们可以用若干键值对来描述他:

var xiaoming = {
name: '小明',
birth: 1990,
school: 'No.1 Middle School', //对象的静态特征写成属性
smile:function(){ //对象的动态行为写成函数(方法)
alert('小明笑了!')
}
};

JavaScript用一个{...}表示一个对象,键值对以键名: 键值形式申明,每个键值对用,隔开。注意,最后一个键值对不需要在末尾加逗号,如果加了,浏览器(如低版本的IE)将报错。

上述对象申明了一个name属性,值是’小明’,birth属性,值是1990,以及其他一些属性。最后,把这个对象赋值给变量xiaoming后,就可以通过变量xiaoming来获取小明的属性了:

xiaoming.name; // '小明'
xiaoming.birth; // 1990

访问属性是通过.操作符完成的,但这要求属性名必须是一个有效的变量名。如果属性名包含特殊字符,就必须用''括起来:

var xiaohong = {
name: '小红',
'middle-school': 'No.1 Middle School'
};

xiaohong的属性名middle-school不是一个有效的变量,就需要用''括起来。访问这个属性也无法使用.操作符,必须用['键名']来访问:

xiaohong['middle-school']; // 'No.1 Middle School'
xiaohong['name']; // '小红'
xiaohong.name; // '小红'

也可以用xiaohong[‘name’]来访问xiaohong的name属性,不过xiaohong.name的写法更简洁。我们在编写JavaScript代码的时候,属性名尽量使用标准的变量名,这样就可以直接通过object.prop的形式访问一个属性了。

实际上JavaScript对象的所有属性都是字符串,不过属性对应的值可以是任意数据类型。

如果访问一个不存在的属性会返回什么呢?JavaScript规定,访问不存在的属性不报错,而是返回undefined:

var xiaoming = {
name: '小明'
};
xiaoming.age; // undefined

由于JavaScript的对象是动态类型,你可以自由地给一个对象添加或删除属性:

var xiaoming = {
name: '小明'
};
xiaoming.age; // undefined
xiaoming.age = 18; // 新增一个age属性
document.write(xiaoming.age); // 18
delete xiaoming.age; // 删除age属性
document.write(xiaoming.age); // undefined
delete xiaoming['name']; // 删除name属性
document.write(xiaoming.name); // undefined
delete xiaoming.school; // 删除一个不存在的school属性也不会报错

如果我们要检测xiaoming是否拥有某一属性,可以用in操作符:

var xiaoming = {
name: '小明',
birth: 1990,
school: 'No.1 Middle School'
};
'name' in xiaoming; // true
'grade' in xiaoming; // false

不过要小心,如果in判断一个属性存在,这个属性不一定是xiaoming的,它可能是xiaoming继承得到的:

'toString' in xiaoming; // true

因为toString定义在object对象中,而所有对象最终都会在原型链上指向object,所以xiaoming也拥有toString属性。

要判断一个属性是否是xiaoming自身拥有的,而不是继承得到的,可以用hasOwnProperty()方法:

var xiaoming = {
name: '小明'
};
xiaoming.hasOwnProperty('name'); // true
xiaoming.hasOwnProperty('toString'); // false

条件判断

JavaScript使用if () { ... } else { ... }来进行条件判断。例如,根据年龄显示不同内容,可以用if语句实现如下:

var age = 20;
if (age >= 18) { // 如果age >= 18为true,则执行if语句块
alert('adult');
} else { // 否则执行else语句块
alert('teenager');
}

多行条件判断

如果还要更细致地判断条件,可以使用多个if…else…的组合:

var age = 3;
if (age >= 18) {
alert('adult');
} else if (age >= 6) {
alert('teenager');
} else {
alert('kid');
}

上述多个if…else…的组合实际上相当于两层if…else…:

var age = 3;
if (age >= 18) {
alert('adult');
} else {
if (age >= 6) {
alert('teenager');
} else {
alert('kid');
}
}

但是我们通常把else if连写在一起,来增加可读性。

请注意,if…else…语句的执行特点是二选一,在多个if…else…语句中,如果某个条件成立,则后续就不再继续判断了。

switch语句

switch适合做等值判断,在已知几种情况的条件下使用。

举例:显示今天是星期几。请注意 Sunday=0, Monday=1, Tuesday=2, 等等:

var day=new Date().getDay();
switch (day)
{
case 0:
x="Today it's Sunday";
break;
case 1:
x="Today it's Monday";
break;
case 2:
x="Today it's Tuesday";
break;
case 3:
x="Today it's Wednesday";
break;
case 4:
x="Today it's Thursday";
break;
case 5:
x="Today it's Friday";
break;
case 6:
x="Today it's Saturday";
break;
}

请使用 default 关键词来规定匹配不存在时做的事情:
var day=new Date().getDay();
switch (day)
{
case 6:
x=”Today it’s Saturday”;
break;
case 0:
x=”Today it’s Sunday”;
break;
default:
x=”Looking forward to the Weekend”;
}

循环

要计算1+2+3,我们可以直接写表达式:

1 + 2 + 3; // 6

要计算1+2+3+…+10,勉强也能写出来。

但是,要计算1+2+3+…+10000,直接写表达式就不可能了。

为了让计算机能计算成千上万次的重复运算,我们就需要循环语句。

for循环

JavaScript的循环有两种,一种是for循环,通过初始条件、结束条件和递增条件来循环执行语句块:

var x = 0;
var i;
for (i=1; i<=10000; i++) {
x = x + i;
}
document.write(x); // 输出50005000

让我们来分析一下for循环的控制条件:

i=1 这是初始条件,将变量i置为1;
i<=10000 这是判断条件,满足时就继续循环,不满足就退出循环;
i++ 这是每次循环后的递增条件,由于每次循环后变量i都会加1,因此它终将在若干次循环后不满足判断条件i<=10000而退出循环。

for循环最常用的地方是利用索引来遍历数组:

var arr = ['Apple', 'Google', 'Microsoft'];
var i, x;
for (i=0; i<arr.length; i++) {
x = arr[i];
alert(x);
}

for循环的3个条件都是可以省略的,如果没有退出循环的判断条件,就必须使用break语句退出循环,否则就是死循环:

var x = 0;
for (;;) { // 将无限循环下去
if (x > 100) {
break; // 通过if判断来退出循环
}
x++;
}

for … in循环

for循环的一个变体是for … in循环,它可以把一个对象的所有属性依次循环出来:

var obj = {
name: 'Jack',
age: 20,
city: 'Beijing'
};
for (var key in obj) {
alert(key); // 'name', 'age', 'city'
}

要过滤掉对象继承的属性,用hasOwnProperty()来实现:

var obj = {
name: 'Jack',
age: 20,
city: 'Beijing'
};
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
alert(key); // 'name', 'age', 'city'
}
}

由于Array也是对象,而它的每个元素的索引被视为对象的属性,因此,for … in循环可以直接循环出Array的索引:

var arr = ['A', 'B', 'C'];
for (var i in arr) {
alert(i); // '0', '1', '2'
alert(arr[i]); // 'A', 'B', 'C'
}

请注意,for … in对Array的循环得到的是String而不是Number。

while

for循环在已知循环的初始和结束条件时非常有用。而上述忽略了条件的for循环容易让人看不清循环的逻辑,此时用while循环更佳。

while循环只有一个判断条件,条件满足,就不断循环,条件不满足时则退出循环。比如我们要计算100以内所有奇数之和,可以用while循环实现:

var x = 0;
var n = 99;
while (n > 0) {
x = x + n;
n = n - 2;
}
console.log(x); // 2500

在循环内部变量n不断自减,直到变为-1时,不再满足while条件,循环退出。

do … while

最后一种循环是do { ... } while()循环,它和while循环的唯一区别在于,不是在每次循环开始的时候判断条件,而是在每次循环完成的时候判断条件:

var n = 0;
do {
n = n + 1;
} while (n < 100);
console.log(n); // 100

用do { … } while()循环要小心,循环体会至少执行1次,而for和while循环则可能一次都不执行。

小结

循环是让计算机做重复任务的有效的方法,有些时候,如果代码写得有问题,会让程序陷入“死循环”,也就是永远循环下去。JavaScript的死循环会让浏览器无法正常显示或执行当前页面的逻辑,有的浏览器会直接挂掉,有的浏览器会在一段时间后提示你强行终止JavaScript的执行,因此,要特别注意死循环的问题。

在编写循环代码时,务必小心编写初始条件和判断条件,尤其是边界值。特别注意i < 100i <= 100是不同的判断逻辑。