JavaScript学习笔记

注释

1. // This is an in-line comment.
2. /* This is a
   multi-line comment */

七种data types(数据类型)

undefined（未定义）,
null（空）,
boolean（布尔型）,
string（字符串）,
number（数字）,
object（对象）,
symbol(符号)[ES6新增]。

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”

来自 https://www.cnblogs.com/jeacy/p/6475088.html