目录
1. 函数
1.1. 函数参数
1.2. 变量作用域
1.2.1. 全局作用域
1.2.2. 局部作用域
1.3. 函数返回值
2. 比较操作符
2.1. 相等运算符：==
2.2. 全等运算符：===
2.3. 不相等运算符：!=
2.4. 不全等运算符：!==
2.5. 大于运算符：>
2.6. 大于等于 运算符：>=
2.7. 小于 运算符：<
2.8. 小于等于 运算符：<=
2.9. 逻辑与运算符：&&
2.10. 逻辑或 运算符 ：||
-----------------------黄金分割线----------------------
1. 函数
在 JavaScript 中，我们可以把代码的重复部分抽取出来，放到一个函数（functions）中。
这是一个函数（function）的例子：
function functionName() {
console.log("Hello World");
}
你可以通过函数名称functionName加上后面的小括号来调用这个函数（function），就像这样：
functionName();
每次调用函数时它会打印出消息的“Hello World”到开发的控制台上。所有的大括号之间的代码将在每次函数调用时执行。
1.1. 函数参数
函数的参数parameters在函数中充当占位符(也叫形参)的作用，参数可以为一个或多个。调用一个函数时所传入的参数为实参，实参决定着形参真正的值。简单理解：形参即形式、实参即内容。
这是带有两个参数的函数， param1 和param2：
function testFun(param1, param2) {
console.log(param1, param2);
}
接着我们调用 testFun：
testFun("Hello", "World");
我们传递了两个参数， "Hello" 和 "World"。在函数内部，param1 等于“Hello”，param2等于“World”。请注意，testFun 函数可以多次调用，每次调用时传递的参数会决定形参的实际值。
1.2. 变量作用域
1.2.1. 全局作用域
在 JavaScript 中， 作用域 涉及到变量的作用范围。在函数外定义的变量具有 全局 作用域。这意味着，具有全局作用域的变量可以在代码的任何地方被调用。
这些没有使用var关键字定义的变量，会被自动创建在全局作用域中，形成全局变量。当在代码其他地方无意间定义了一个变量，刚好变量名与全局变量相同，这时会产生意想不到的后果。因此你应该总是使用var关键字来声明你的变量。
1.2.2. 局部作用域
在一个函数内声明的变量，以及该函数的参数都是局部变量，意味着它们只在该函数内可见。
这是在函数 myTest内声明局部变量loc 的最佳例子：
function myTest() {
var loc = "foo";
console.log(loc);
}
myTest(); // "foo"
console.log(loc); // "undefined"
在函数外，loc 是未定义的。
一个程序中有可能具有相同名称的 局部 变量 和 全局 变量。在这种情况下，局部 变量将会优先于 全局 变量。
下面为例：
var someVar = "Hat";
function myFun() {
var someVar = "Head";
return someVar;
}
函数 myFun 将会返回 "Head"，因为 局部变量优先级更高。
1.3. 函数返回值
我们可以把数据通过函数的 参数 来传入函数，也可以使用 return 语句把数据从一个函数中传出来。
例如
function plusThree(num) {
return num + 3;
}
var answer = plusThree(5); // 8
plusThree 带有一个为 num 的 参数 并且返回（returns）一个等于 num + 3 的值。
2. 比较操作符
在 JavaScript 中，有很多 相互比较的操作。所有这些操作符都返回一个 true 或 false值。
2.1. 相等运算符：==
最基本的运算符是相等运算符：==。相等运算符比较两个值，如果它们是同等，返回 true，如果它们不等，返回 false。值得注意的是相等运算符不同于赋值运算符（=），赋值运算符是把等号右边的值赋给左边的变量。
function equalityTest(myVal) {
if (myVal == 10) {
return "Equal";
}
return "Not Equal";
}
如果 myVal 等于 10，相等运算符会返回true，因此大括号里面的代码会被执行，函数将返回 "Equal"。否则，函数返回 "Not Equal"。
在 JavaScript 中，为了让两个不同的 数据类型（例如 数字 和 字符串）的值可以作比较，它必须把一种类型转换为另一种类型。然而一旦这样做，它可以像下面这样来比较：
1 == 1 // true
1 == 2 // false
1 == '1' // true
"3" == 3 // true
2.2. 全等运算符：===
全等（===）是相对于相等操作符（==）的一种操作符。与相等操作符不同的是全等比较严格，它会同时比较元素的值和 数据类型。
举个例子
3 === 3 // true
3 === '3' // false
3 是一个 数字 类型的，而'3' 是一个 字符 类型的，所以3不全等于'3'。
2.3. 不相等运算符：!=
不相等运算符（!=）与相等运算符是相反的。这意味着不相等运算符中，如果“不为真”并且返回 false 的地方，在相等运算符中会返回true，反之亦然。与相等运算符类似，不相等运算符在比较的时候也会转换值的数据类型。
例如
1 != 2 // true
1 != "1" // false
1 != '1' // false
1 != true // false
0 != false // false
2.4. 不全等运算符：!==
不全等运算符（!==）与全等运算符是相反的。这意味着“不全等”并返回 false 的地方，用全等运算会返回 true，反之亦然。全等运算符不会转换值的数据类型。
例如
3 !== 3 // false
3 !== '3' // true
4 !== 3 // true
2.5. 大于运算符：>
使用大于运算符（>）来比较两个数字。如果大于运算符左边的数字大于右边的数字，将会返回 true。否则，它返回 false。
与相等运算符一样，大于运算符在比较的时候，会转换值的数据类型。
例如
5 > 3 // true
7 > '3' // true
2 > 3 // false
'1' > 9 // false
2.6. 大于等于 运算符：>=
使用 大于等于 运算符（>=）来比较两个数字的大小。如果大于等于运算符左边的数字比右边的数字大或者相等，它会返回 true。否则，它会返回 false。
与相等运算符相似，大于等于 运算符在比较的时候会转换值的数据类型。
例如
6 >= 6 // true
7 >= '3' // true
2 >= 3 // false
'7' >= 9 // false
2.7. 小于 运算符：<
使用 小于 运算符（<）比较两个数字的大小。如果小于运算符左边的数字比右边的数字小，它会返回 true。否则，他会返回 false。与相等运算符类似，小于 运算符在做比较的时候会转换值的数据类型。
例如
2 < 5 // true
'3' < 7 // true
5 < 5 // false
3 < 2 // false
'8' < 4 // false
2.8. 小于等于 运算符：<=
使用 小于等于 运算符（<=）比较两个数字的大小。如果在小于等于运算符，左边的数字小于或者等于右边的数字，它会返回 true。如果在小于等于运算符，左边的数字大于或者等于右边的数字，它会返回 false。与相等运算符类型，小于等于 运算符会转换数据类型。
例如
4 <= 5 // true
'7' <= 7 // true
5 <= 5 // true
3 <= 2 // false
'8' <= 4 // false
2.9. 逻辑与运算符：&&
有时你需要在一次判断中做多个操作。当且仅当运算符的左边和右边都是 true，逻辑与 运算符（&&）才会返回 true。
同样的效果可以通过if语句的嵌套来实现：
if (num > 5) {
if (num < 10) {
return "Yes";
}
}
return "No";
只有当 num 的值在6和9之间（包括6和9）才会返回 "Yes"。相同的逻辑可被写为：
if (num > 5 && num < 10) {
return "Yes";
}
return "No";
2.10. 逻辑或 运算符 ：||
如果任何一个操作数是true，逻辑或 运算符 (||) 返回 true。反之，返回 false。
举个例子：
if (num > 10) {
return "No";
}
if (num < 5) {
return "No";
}
return "Yes";
只有当num大于等于5或小于等于10时，函数返回"Yes"。相同的逻辑可以简写成：
if (num > 10 || num < 5) {
return "No";
}
return "Yes";
最后最后最后，重要的事情说三遍,来着是客，如果您觉得好就推荐或评论下，觉得不好希望能得到您的建议，继续改善，您的支持就是对我最大的鼓励.
