注释

1. //
This is an in-line comment.

2. /*
This is a 
multi-line comment */

七种data types(数据类型)

undefined（未定义）,

null（空）,

boolean（布尔型）,

string（字符串）,

symbol(符号),

number（数字）,

object（对象）。

Variables（变量）

允许计算机以一种动态的形式来存储和操作数据，通过操作指向数据的指针而不是数据本身来避免了内存泄露。

Variable （变量）的名字可以由数字、字母、$ 或者 _组成，但是不能包含空格或者以数字为首。

当 JavaScript 中的变量被声明的时候，程序内部会给它一个初始值 undefined。

当你对一个值为 undefined 的变量进行运算操作的时候，算出来的结果将会是 NaN，NaN的意思是 "Not a Number"。

当你用一个没有 定义 的变量来做字符串连接操作的时候，它会如实的输出"undefined"。

用 驼峰命名法 来书写一个 Javascript 变量

在 驼峰命名法 中，变量名的第一个单词的首写字母小写，后面的单词的第一个字母大写。

举个栗子:

var someVariable;
var anotherVariableName;
var thisVariableNameIsTooLong;

i++;

等效于

i = i + 1;

i--;

等效于

i = i - 1;

用%运算符来取余

5 % 2 = 1

myVar += 5;

myVar -= 5;

myVar *= 5;

myVar /= 5;

用 反斜杠 (\) 来转义引号

var sampleStr = "Alan said, \"Peter is
learning JavaScript\".";

转义序列列表

Code

Output

\'

单引号

\"

双引号

\\

反斜杠符

\n

换行符

\r

回车符

\t

制表符

\b

退格符

\f

换页符

字符串

通过在字符串变量或字符串后面写上 .length 来获得字符串变量 字符串 值的长度。

"Alan Peter".length; // 10

JavaScript中只有字符串类型，没有字符类型。通过[索引] 来获得对应的字符

var firstName = "Charles" 中，你可以使用firstName[0] 来获得第一个位置上的字符。

字符串 的值是 不可变的，这意味着一旦字符串被创建就不能被改变

并不 意味着 myStr 永远不能被改变，只是字符串字面量 string literal 的各个字符不能被改变。

改变 myStr 中的唯一方法是重新给它赋一个值，就像这样：

var myStr = "Bob";
myStr = "Job";

var firstName = "Charles" 中，你可以这样操作firstName[firstName.length
- 1] 来得到字符串的最后的一个字符。

firstName[firstName.length - 3] 操作来获得 var
firstName = "Charles" 字符串中的倒数第三个字符。

数组

可以在一个地方存储多个数据

var sandwich = ["peanut butter",
"jelly", "bread"]。

在数组中包含其他数组，就像这样: [["Bulls",
23], ["White Sox", 45]]。这被称为一个 多维数组。

像操作字符串一样通过数组索引[index]来访问数组中的数据。

数组索引的使用与字符串索引一样，

不同的是，通过字符串的索引得到的是一个字符，通过数组索引得到的是一个条目。

与字符串类似，数组也是 基于零 的索引，因此数组的第一个元素的索引是 0。

var array = [1,2,3];
array[0]; // 等于 1
var data = array[1]; // 等于 2

与字符串的数据不可变不同，数组的数据是可变的，并且可以自由地改变。

var ourArray = [3,2,1];
ourArray[0] = 1; // ourArray等于 [1,2,1]

把多维数组看作成是一个 数组中的数组。

当使用[]去访问数组的时候，第一个[index]访问的是第N个子数组，第二个[index]访问的是第N个子数组的第N个元素

var arr = [
[1,2,3],
[4,5,6],
[7,8,9],
[[10,11,12], 13, 14]
];
arr[0]; // 等于 [1,2,3]
arr[1][2]; // 等于 6
arr[3][0][1]; // 等于 11

.push() 接受一个或多个参数，并把它“推”入到数组的末尾。

var arr = [1,2,3];
arr.push(4);  // 现在arr的值为 [1,2,3,4]

.pop() 函数用来“抛出”一个数组末尾的值。我们可以把这个“抛出”的值赋给一个变量存储起来。

var oneDown = [1, 4, 6].pop();　　//现在 oneDown 的值为 6 ，数组变成了 [1, 4]。

.shift()  它的工作原理就像 .pop()，但它移除的是第一个元素

unshift（移入）一个元素到数组的头部

用起来就像 .push() 函数一样, 但不是在数组的末尾添加元素，而是在数组的头部添加元素。

var myArray = [["John", 23], ["dog",
3]];

myArray.unshift(["Paul", 35]);

函数（function）

我们可以把代码的重复部分抽取出来，放到一个函数（functions）中。

function functionName() {
console.log("Hello World");
}

通过函数名称functionName加上后面的小括号来调用这个函数（function），就像这样：

functionName();

带有两个参数的函数， param1 和 param2：

function testFun(param1, param2) {
console.log(param1, param2);
}

接着我们调用 testFun：

testFun("Hello", "World");

作用域 涉及到变量的作用范围。在函数外定义的变量具有 全局 作用域。这意味着，具有全局作用域的变量可以在代码的任何地方被调用。

函数内声明的变量，以及该函数的参数都是局部变量，意味着它们只在该函数内可见。

一个程序中有可能具有相同名称的 局部 变量 和 全局 变量。在这种情况下，局部 变量将会优先于 全局 变量。

下面为例：

var someVar = "Hat";
function myFun() {
var someVar = "Head";
return someVar;
}

函数 myFun 将会返回 "Head"，因为 局部变量 优先级更高。

用 return 语句把数据从一个函数中传出来，

代码执行到return语句时，函数返回一个结果就结束运行了，return后面的语句不会执行。

function plusThree(num) {
return num + 3;
}
var answer = plusThree(5); // 8

队列（queue）是一个抽象的数据结构，队列中的条目都是有秩序的。新的条目会被加到 队列 的末尾，旧的条目会从 队列 的头部被移出。

写一个函数 queue ，用一个数组arr和一个数字item作为参数。数字item添加到数组的结尾，然后移出数组的第一个元素，最后队列函数应该返回被删除的元素。

function queue(arr, item) {
arr.push(item);
var del=arr.shift();
return del; 
}

布尔（Boolean）。布尔 值要么是true 要么是false。

If 语句

function test (myCondition) {
if (myCondition) {
return "It was true";
}
return "It was false";
}
test(true); // returns "It was true"
test(false); // returns "It was
false"

相互比较的操作

相等运算符：==

相等运算符比较两个值，如果它们是同等，返回 true，如果它们不等，返回false。

1 == 1 // true
1 == 2 // false
1 == '1' // true
"3" == 3 // true

全等（===）是相对于相等操作符（==）的一种操作符。与相等操作符不同的是全等比较严格，它会同时比较元素的值和 数据类型。

3 === 3 // true
3 === '3' // false

不相等运算符（!=）与相等运算符是相反的。

不相等运算符中，如果“不为真”并且返回 false 的地方，在相等运算符中会返回true，反之亦然。

与相等运算符类似，不相等运算符在比较的时候也会转换值的数据类型。

1 != 2 // true
1 != "1" // false
1 != '1' // false
1 != true // false
0 != false // false

不全等运算符（!==）与全等运算符是相反的。

这意味着“不全等”并返回 false 的地方，用全等运算会返回true，反之亦然。

全等运算符不会转换值的数据类型。

3 !== 3 // false
3 !== '3' // true
4 !== 3 // true

大于运算符（>）

5 > 3 // true
7 > '3' // true
2 > 3 // false
'1' > 9 // false

大于等于 运算符（>=）

6 >= 6 // true
7 >= '3' // true
2 >= 3 // false
'7' >= 9 // false

小于 运算符（<）比较两个数字的大小

2 < 5 // true
'3' < 7 // true
5 < 5 // false
3 < 2 // false
'8' < 4 // false

小于等于 运算符（<=）

4 <= 5 // true
'7' <= 7 // true
5 <= 5 // true
3 <= 2 // false
'8' <= 4 // false

逻辑与 运算符（&&）

需要在一次判断中做多个操作。当且仅当运算符的左边和右边都是 true

if (num > 5 && num < 10) {
return "Yes";
}
return "No";

逻辑或 运算符 (||)

如果任何一个操作数是true，逻辑或 运算符 (||) 返回true。反之，返回 false。

if (num > 10 || num < 5) {
return "No";
}
return "Yes";

if/else语句

if (num > 10) {
return "Bigger than 10";
} else {
return "10 or Less";
}

if (num > 15) {
return "Bigger than 15";
} else if (num < 5) {
return "Smaller than 5";
} else {
return "Between 5 and 15";
}

switch语句

function myTest(val) {
　　var answer = "";
　　switch(val){
　　　　case 1:
　　　　　　answer = "alpha";
　　　　　　break;
　　　　case 2:
　　　　　　answer = "beta";
　　　　　　break;
　　　　case 3:
　　　　　　answer = "gamma";
　　　　　　break;

　　　　default:
　　　　　　answer = "stuff";

　　}
　　return answer; 
}

myTest(1);  //返回“alpha”

如果你有多个输入值和输出值一样，可以试试下面的switch语句

switch(val) {
　　case 1:
　　case 2:
　　case 3:
　　　　result = "1, 2, or 3";
　　　　break;
　　case 4:
　　　　result = "4 alone";
}

所有的比较操作符返回的都是一个boolean值，要么是 true 要么是false 。

使用 if/else语句来做比较然后返回true或false已经成为大家的共识:

function isEqual(a,b) {
if (a === b) {
return true;
} else {
return false;
}
}

因为=== 总是返回 true 或 false，所以我们可以直接返回比较的结果：

function isEqual(a,b) {
return a === b;
}

对象 object

对象和数组很相似，数组是通过索引来访问和修改数据，对象是通过属性来访问和修改数据的。

对象适合用来存储结构化数据，就和真实世界的对象一模一样，比如一只猫。

var cat = {
"name": "Whiskers",
"legs": 4,
"tails": 1,
"enemies": ["Water",
"Dogs"],

"More Space": "Spock"
};

访问对象属性，一个是点操作符(.)，一个是中括号操作符([])。

var prop1val = myObj.prop1; // val1

如果你想访问的属性的名称有一个空格，这时你只能使用中括号操作符([])。

提示：属性名称中如果有空格，必须把属性名称用单引号或双引号包裹起来。

myObj['More Space']; // Spock

使用变量来访问属性

var someProp = "propName";
var myObj = {
propName: "Some Value"
}
myObj[someProp]; // "Some Value

像更改属性一样给对象添加属性。

看看我们是如何给ourDog添加 "bark"属性：

ourDog.bark = "bow-wow";　　或者　　ourDog["bark"]
= "bow-wow";

删除对象的属性

delete ourDog.bark;

用.hasOwnProperty(propname)方法来检查对象是否有该属性。如果有返回true，反之返回 false。

var myObj = {
top: "hat",
bottom: "pants"
};
myObj.hasOwnProperty("top"); 　　 // true
myObj.hasOwnProperty("middle"); 　　// false

JavaScript Object Notation 简称 JSON

它使用JavaScript对象的格式来存储数据。JSON是灵活的，因为它允许 数据结构 是 字符串，数字，布尔值，字符串，和 对象 的任意组合。

这里是一个JSON_对象的示例_ 这是一个对象数组：

var ourMusic = [
　　{
　　　　"artist": "Daft
Punk",
　　　　"title":
"Homework",
　　　　"release_year": 1997,
　　　　"formats": [ 
　　　　"CD", 
　　　　"Cassette", 
　　　　"LP" ],
　　　　"gold": true
　　}
];

通过串联起来的点操作符或中括号操作符来访问JSON对象的嵌套属性。

JSON对象可以嵌套对象和数组。

下面是一个嵌套的JSON对象：

var
myStorage = {
　　"car": {
　　　　"inside": {
　　　　"glove box": "maps",
　　　　"passenger seat": "crumbs"
　　　　},
　　　　"outside": {
　　　　　　"trunk": "jack"
　　　　}
　　}
};

var
gloveBoxContents = myStorage.car.inside["glove box"]; // Change this
line

下面是如何访问嵌套数组:

var
ourPets = { 
　　"cats": [
　　　　"Meowzer",
　　　　"Fluffy",
　　　　"Kit-Cat"
　　],
　　"dogs": [
　　　　"Spot",
　　　　"Bowser",
　　　　"Frankie"
　　]
};
ourPets.cats[1];
// "Fluffy"
ourPets.dogs[0];
// "Spot"

for循环

for ([初始化]; [条件判断]; [计数器])

var ourArray = [];
for (var i = 0; i < 5; i++) {
　　ourArray.push(i);
}

最终 ourArray 的值为 [0,1,2,3,4].

while循环

var ourArray = [];
var i = 0;
while(i < 5) {
ourArray.push(i);
i++;
}

Math.random()用来生成一个在0(包括0)到1(不包括1)之间的随机小数，因此Math.random()可能返回0但绝不会返回1。

Math.floor() 向下取整 获得它最近的整数。

随机数是在两个指定的数之间: Math.floor(Math.random()
* (max - min + 1)) + min

Regular expressions 正则表达式

被用来根据某种匹配模式来寻找strings中的某些单词。

var
testString = "Ada Lovelace and Charles Babbage designed the first computer
and the software that would have run on it.";

var
expression = /and/gi;

var
andCount = testString.match(expression).length;　　//2

/ 是这个正则表达式的头部　　and 是想要匹配的模式　　/ 是这个正则表达式的尾部

g 代表着 global(全局)，意味着返回所有的匹配而不仅仅是第一个。

i 代表着忽略大小写，意思是当我们寻找匹配的字符串的时候忽略掉字母的大小写。

特殊选择器中的一种就是数字选择器\d，意思是被用来获取一个字符串的数字。

在JavaScript中, 数字选择器类似于: /\d/g

在选择器后面添加一个加号标记(+)，例如：/\d+/g，它允许这个正则表达式匹配一个或更多数字。

var
testString = "There are 3 cats but 4 dogs.";

var
expression = /\d+/g;

var
digitCount = testString.match(expression);　　//["3",
"4"]

\s 来选择一个字符串中的空白。

空白字符有 " " (空格符)、\r (回车符)、\n (换行符)、\t (制表符) 和 \f (换页符)。

空白正则表达式类似于：/\s+/g

var
testString = "How many spaces are there in this sentence?";

var
expression = /\s+/g;

var
spaceCount = testString.match(expression).length;　　//7

你可以用正则表达式选择器的大写版本 来转化任何匹配。

举个例子：\s 匹配任何空白字符，\S 匹配任何非空白字符。

var
testString = "How many non-space characters are there in this
sentence?";

var
expression = /\S/g;

var
nonSpaceCount = testString.match(expression).length;　　//49

面向对象

使用构造函数来创建对象。

构造函数 通常使用大写字母开头，以便把自己和其他普通函数区别开。

var Car = function() {
  this.wheels = 4;
  this.engines = 1;
  this.seats = 1;
};

在
构造函数 中， this 指向被此 构造函数 创建出来的 对象 。

使用 new 关键字 来对它进行调用，如下：

var myCar = new Car();

记住：要使用 new 关键字 去调用构造函数。因为只有这样，Javascript才知道这是要去构造一个新 对象 ，并且把构造函数中的 this 指向这个新对象。

向 构造函数 中添加 参数

var
Car = function(wheels, seats, engines) {
  this.wheels
= wheels;
  this.seats
= seats;
  this.engines
= engines;
};

var
myCar = new Car(6, 3, 1);

对象拥有自己的特征，称为 属性，对象还有自己的函数，称为 方法 。

使用了 this 指向当前（将要被创建的）对象中的 公有属性 。

我们也可以创建 私有属性 和 私有方法 ，它们两个在对象外部是不可访问的。

使用我们熟悉的var 关键字去创建变量，来替代我们使用 this 创建 属性。

var
Bike = function() {

　　var gear;　　//私有属性
　　this.getGear = function(){
　　　　return gear;
　　};
　　this.setGear = function(change){
　　　　gear=change;
　　};

};

数组 & 字符串
操作

map 方法可以方便的迭代数组

map 方法会迭代数组中的每一个元素，并根据回调函数来处理每一个元素，最后返回一个新数组。注意，这个方法不会改变原始数组。

回调函数只有一个参数，即数组中元素的值 (val 参数) ，但其实，你的回调函数也可以支持多个参数，譬如：元素的索引index、原始数组arr。

//使用 map 方法来为 oldArray 中的每一项增加3，并且在newArray 中保存它们。 oldArray 不应该被改变。

var
oldArray = [1,2,3,4,5];

var
newArray = oldArray.map(function(val){

　　return val+=3;
});　　//[4,5,6,7,8]

reduce 用来迭代一个数组，并且把它累积到一个值中。

使用 reduce 方法时，你要传入一个回调函数，这个回调函数的参数是一个 累加器 （比如例子中的 previousVal) 和当前值 (currentVal）。

reduce 方法有一个可选的第二参数，它可以被用来设置累加器的初始值。如果没有在这定义初始值，那么初始值将变成数组中的第一项，而 currentVal将从数组的第二项开始。

//使用了 reduce 来让数组中的所有值相加：

var
array = [4,5,6,7,8];
var
singleVal = 0;

singleVal
= array.reduce(function(previousVal, currentVal){

return
previousVal + currentVal;
},0);　　　　//30

filter 方法用来迭代一个数组，并且按给出的条件过滤出符合的元素。

filter 方法传入一个回调函数，这个回调函数会携带一个参数，参数为当前迭代的项（我们叫它 val ）。

回调函数返回 true 的项会保留在数组中，返回 false 的项会被过滤出数组。

//使用 filter 来创建一个新数组，新数组的值是 oldArray中值小于6的元素。不许改变原数组 oldArray 。

var
oldArray = [1,2,3,4,5,6,7,8,9,10];

var
newArray = oldArray.filter(function(val){

　　return val<6;
});

sort 方法，按字母顺序或数字顺序对数组中的元素进行排序。

sort方法将改变原数组，返回被排序后的数组。

sort 可以把比较函数作为参数传入。比较函数有返回值，当 a 小于 b，返回一个负数；当 a 大于 b ，返回一个正数；相等时返回0。

如果没有传入比较函数，它将把值全部转成字符串，并按照字母顺序进行排序。

//使用 sort 按照从大到小的顺序排序 array 。

var
array = [1, 12, 21, 2];

array.sort(function(a,b){

　　return b-a;
});　　　　//[21,12,2,1]

reverse 方法来翻转数组。

var myArray = [1, 2, 3];
myArray.reverse();

结果__myArray 变成了 [3, 2, 1]

concat 方法可以用来把两个数组的内容合并到一个数组中。

//将 concatMe 拼接到 oldArray 后面，并且赋值给 newArray。

var
oldArray = [1,2,3];
var newArray
= [];

var
concatMe = [4,5,6];

newArray
= oldArray.concat(concatMe);

split 方法按指定分隔符将字符串分割为数组。

给 split 方法传递一个参数，这个参数将会作为一个分隔符。

var
string = "Split me into an array";
var array =
[];

array
= string.split(" ");　　//["Split",
"me", "into", "an", "array"]

join 方法把数组转换成字符串

里面的每一个元素可以用你指定的连接符来连接起来，这个连接符就是你要传入的参数。

参数可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。

arrayObject.join(separator)　separator 可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。

var
joinMe =
["Split","me","into","an","array"];

var
joinedString = '';

joinedString
= joinMe.join(" ");　　//"Split me into an array"