js基础

---

js基础：

---

+：

当 + 操作符与 字符串 一起使用的时候，它被称作 连接 操作符。你可以通过和其他字符串连接 来创建一个新的字符串。

eg:

var ourName = "Free Code Camp";
 var ourStr = "Hello, our name is " + ourName + ", how are you?";

+=：

 还可以使用 += 运算符来 连接 字符串到现有字符串的结尾。对于那些非常长的字符串来说，这一操作是非常有用的。

eg:

 var anAdjective = "awesomhan'ce!";
 var ourStr = "Free Code Camp is ";
 ourStr += anAdjective;

注意
当心空格。连接操作不会添加两个字符串外面的空格，所以如果想要加上空格的话，你需要自己在字符串里面添加。

==:
在 JavaScript 中，为了让两个不同的 数据类型（例如 数字 和 字符串）的值可以作比较，它必须把一种类型转换为另一种类型。然而一旦这样做，它可以像下面这样来比较：

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

===:

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

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

3 是一个 数字 类型的，而’3’ 是一个 字符 类型的，所以3不全等于’3’。

!==:

不全等运算符（!==）与全等运算符是相反的。这意味着“不全等”并返回 false 的地方，用全等运算会返回 true，反之亦然。全等运算符不会转换值的数据类型。
例如

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

:
与相等运算符一样，大于运算符在比较的时候，会转换值的数据类型。
例如
5 > 3 // true
7 > ‘3’ // true
2 > 3 // false
‘1’ > 9 // false

关于变量：
变量作用域：
作用域 涉及到变量的作用范围。在函数外定义的变量具有全局 作用域。这意味着，具有全局作用域的变量可以在代码的任何地方被调用。
这些没有使用var关键字定义的变量，会被自动创建在全局作用域中，形成全局变量。当在代码其他地方无意间定义了一个变量，刚好变量名与全局变量相同，这时会产生意想不到的后果。因此你应该总是使用var关键字来声明你的变量。
变量的优先级：
一个程序中有可能具有相同名称的 局部 变量 和全局 变量。在这种情况下，局部 变量将会优先于 全局 变量。

布尔类型：
一种数据类型是布尔（Boolean）。布尔 值要么是true 要么是false。它非常像电路开关，true 是“开”，false 是“关”。这两种状态是互斥的。
注意:
Boolean 值绝不会写作被引号包裹起来的形式。字符串 的"true" 和 “false” 不是 布尔值，在 JavaScript 中也没有特殊含义。

布尔对象：
Boolean对象是一个包装了布尔值的对象.
语法

  new Boolean([value])

参数
value
可选的. Boolean 对象的初始值.
描述
如果Boolean构造函数的参数不是一个布尔值,则该参数会被转换成一个布尔值.如果参数是 0, -0, null, false, NaN, undefined, 或者空字符串 (""),
生成的Boolean对象的值为false. 其他任何值,包括任何对象或者字符串"false", 都会创建一个值为true的Boolean对象.
注意：不要将原始值true false,和值为true false的Boolean对象相混淆.
任何值不为 undefined或者 null的对象, 包括值为false的Boolean对象, 在条件语句中,其值都将作为true来判断.

字符串：
.length:
你可以通过在字符串变量或字符串后面写上 .length 来获得字符串变量字符串 值的长度。
字符串索引：
你可以使用 firstName[0] 来获得第一个位置上的字符。 这被称为基于零 的索引。

 .charAt():

charAt() 方法可返回指定位置的字符。
请注意，JavaScript 并没有一种有别于字符串类型的字符数据类型，所以返回的字符是长度为 1 的字符串。

语法:stringObject.charAt(index)

index:必需。表示字符串中某个位置的数字，即字符在字符串中的下标。
注释：字符串中第一个字符的下标是 0。如果参数 index 不在 0 与 string.length 之间，该方法将返回一个空字符串。
.replace():
replace() 方法使用一个替换值（replacement）替换掉一个匹配模式（pattern）在原字符串中某些或所有的匹配项，并返回替换后的新的字符串。这个替换模式可以是一个字符串或者一个RegExp，替换值可以是一个字符串或者一个函数。
语法:

str.replace(regexp|substr, newSubStr|function)  

字符或字符串转换大小写：

   toLcaleUpperCase():

toLocaleUpperCase 方法：将字符转换为大写

stringVar.tolocaleUpperCase( )

必选的 stringVar 引用是一个 String 对象，值或文字。

 .toUpperCase():

toUpperCase 方法
返回一个字符串，该字符串中的所有字母都被转化为大写字母。

strVariable.toUpperCase( )
"String Literal".toUpperCase( )

说明
toUpperCase 方法对非字母字符不会产生影响。

 .toLocaleLowerCase():

toLocaleLowerCase 方法：将字符转换为小写

stringVar.tolocaleLowerCase( )

必选的 stringVar 引用是一个 String 对象，值或文字。
.toLowerCase():

toLowerCase() 会将调用该方法的字符串值转为小写形式，并返回。
eg:

str=str.toLowerCase();

返回一个字符串，该字符串中的字母被转换为小写字母。

strVariable.toLowerCase( )
"String Literal".toLowerCase( )

说明
toLowerCase 方法对非字母字符不会产生影响。

 .substr():
 substr() 方法返回字符串中从指定位置开始到指定长度的子字符串。
 语法:str.substr(start[, length])
 参数:
      start

     开始提取字符的位置。如果为负值，则被看作 strLength + start，其中 strLength 为字符串的长度（例如，如果 start 为 -3，则被看作 strLength-3）。
length
     可选。提取的字符数。

 .slice():
               提取字符串中的一部分，

str.slice(beginSlice[, endSlice]);

参数
beginSlice
从该索引（以 0 为基数）处开始提取原字符串中的字符。如果值为负数，会被当做 sourceLength + beginSlice 看待，
这里的sourceLength 是字符串的长度 (例如， 如果beginSlice 是 -3 则看作是: sourceLength - 3)
endSlice
可选。在该索引（以 0 为基数）处结束提取字符串。如果省略该参数，slice会一直提取到字符串末尾。如果该参数为负数，
则被看作是 sourceLength + endSlice，这里的 sourceLength 就是字符串的长度(例如，如果 endSlice 是 -3，则是, sourceLength - 3)。

.indexOf():
返回某个指定的字符串值在字符串中首次出现的位置。
语法

 stringObject.indexOf(searchvalue,fromindex)

参数
searchvalue
必需。规定需检索的字符串值。
fromindex
可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。
说明
该方法将从头到尾地检索字符串 stringObject，看它是否含有子串 searchvalue。开始检索的位置在字符串的 fromindex 处或字符串的开头（没有指定 fromindex 时）。
如果找到一个searchvalue，则返回 searchvalue 的第一次出现的位置。stringObject 中的字符位置是从 0 开始的。
注释：indexOf() 方法对大小写敏感。
如果要检索的字符串值没有出现，则该方法返回 -1。

.split():

你可以使用 split 方法按指定分隔符将字符串分割为数组。
你要给 split 方法传递一个参数，这个参数将会作为一个分隔符。
下面的例子展示了 split 方法的使用，按照s 字母进行分割：

 var array = string.split('s');

语法

 str.split([separator][, limit])

参数
separator：
指定用来分割字符串的字符（串）。separator 可以是一个字符串或正则表达式。 如果忽略 separator，则返回整个字符串的数组形式。
如果 separator 是一个空字符串，则 str 将会把原字符串中每个字符的数组形式返回。
limit：
一个整数，限定返回的分割片段数量。split 方法仍然分割每一个匹配的 separator，但是返回的数组只会截取最多 limit 个元素
s作为分隔符分隔成数组之后字符串与字符串之间将不会出现s。

 .charCodeAt():和.fromCharCode():

       charCodeAt(i) 返回在指定的位置的字符的 Unicode 编码。

charAt(i) 返回在指定位置的字符。

字符串的不可变性：
理解字符串的不可变性！当你搞懂不可变性后immutable.js对于你就是小菜一碟了。
在 JavaScript 中，字符串 的值是不可变的，这意味着一旦字符串被创建就不能被改变。
例如，下面的代码：

var myStr = "Bob";
myStr[0] = "J";

 是不会把变量 myStr 的值改变成 "Job" 的，因为变量myStr 是不可变的。注意，这 并不 意味着myStr 永远不能被改变，只是字符串字面量 string literal 的各个字符不能被改变。
 改变myStr中的唯一方法是重新给它赋一个值，就像这样：

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

数组：
使用 数组，我们可以在一个地方存储多个数据。
你以左方括号[开始定义一个数组，以右方括号]结束定义，并把每个条目之间用逗号隔开，就像这样：

```handlebars
var sandwich = ["peanut butter", "jelly", "bread"];
var array = ["John", 23];

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

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

 .push():

一个简单的方法将数据追加到一个数组的末尾是通过 push() 函数。
.push() 接受把一个或多个参数，并把它“推”入到数组的末尾。
var arr = [1,2,3];
arr.push(4);


// 现在arr的值为 [1,2,3,4]


 .pop():

改变数组中数据的另一种方法是用 .pop() 函数。
.pop() 函数用来“抛出”一个数组末尾的值。我们可以把这个“抛出”的值赋给一个变量存储起来。
数组中任何类型的条目（数值，字符串，甚至是数组）可以被“抛出来” 。
举个例子, 对于这段代码

var oneDown = [1, 4, 6].pop();

现在 oneDown 的值为 6 ，数组变成了 [1, 4]。

 .shift()和.unshift():
      .shift()它的工作原理就像 .pop()，但它移除的是第一个元素，而不是最后一个。

你不仅可以 shift（移出）数组中的第一个元素，你也可以 unshift（移入）一个元素到数组的头部。
.unshift() 函数用起来就像 .push() 函数一样, 但不是在数组的末尾添加元素，而是在数组的头部添加元素。

 .concat():

concat() 方法将传入的数组或非数组值与原数组合并,组成一个新的数组并返回.
语法

var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])

参数
valueN
需要与原数组合并的数组或非数组值。

 .reverse():

你可以使用 reverse 方法来翻转数组。

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

结果myArray 变成了 [3, 2, 1]
使用 reverse 来翻转array 数组。并赋值给 newArray.

 .concat():

concat 方法可以用来把两个数组的内容合并到一个数组中。
concat 方法的参数应该是一个数组。参数中的数组会拼接在原数组的后面，并作为一个新数组返回。
eg:

newArray = oldArray.concat(otherArray);

.join():
还可以使用 join 方法来把数组转换成字符串，里面的每一个元素可以用你指定的连接符来连接起来，这个连接符就是你要传入的参数。
与.split():相对应。

.slice():
类似与字符串.slice()方法。

.indexOf():
类似于字符串.indexOf()方法。
可以用来判断数组中是否有这一项。

.splice():
splice() 方法用新元素替换旧元素，以此修改数组的内容。
返回值：由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。
语法

array.splice(start, deleteCount[, item1[, item2[, ...]]])

参数
start​
必需。规定从何处添加/删除元素。该参数是开始插入和（或）删除的数组元素的下标，必须是数字。
从数组的哪一位开始修改内容。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位。
deleteCount
必需。规定应该删除多少元素。必须是数字，但可以是 “0”。
如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。
整数，表示要移除的数组元素的个数。如果 deleteCount 是 0，则不移除元素。这种情况下，至少应添加一个新元素。如果 deleteCount 大于start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。

itemN
要添加进数组的元素。如果不指定，则 splice() 只删除数组元素

 .sort():
      sort() 方法对数组的元素做原地的排序，并返回这个数组。 sort 排序可能是不稳定的。默认按照字符串的Unicode码位点（code point）排序。
           语法
                arr.sort([compareFunction])
           参数
                compareFunction
                可选。用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的诸个字符的Unicode位点进行排序。

如果指明了 compareFunction ，那么数组会按照调用该函数的返回值排序。记 a 和 b 是两个将要被比较的元素：

• 如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前；

• 如果 compareFunction(a, b) 等于 0 ， a 和 b 的相对位置不变。
  备注： ECMAScript 标准并不保证这一行为，而且也不是所有浏览器都会遵守（例如 Mozilla 在 2003 年之前的版本）；

• 如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。

• compareFunction(a, b) 必须总是对相同的输入返回相同的比较结果，否则排序的结果将是不确定的。

  迭代数组的几种方法：
  .map():
  map 方法可以方便的迭代数组，例子：

var timesFour = oldArray.map(function(val){
  return val * 4;
});

map 方法会迭代数组中的每一个元素，并根据回调函数来处理每一个元素，最后返回一个新数组。注意，这个方法不会改变原始数组。
在我们的例子中，回调函数只有一个参数，即数组中元素的值 (val 参数) ，但其实，你的回调函数也可以支持多个参数，譬如：元素的索引index、原始数组arr。
语法

array.map(function(currentValue,index,arr), thisValue)

参数说明
参数
描述

function(currentValue, index,arr)

必须。函数，数组中的每个元素都会执行这个函数
函数参数:
参数
描述

currentValue

必须。当前元素的值

index

可选。当期元素的索引值

arr

可选。当期元素属于的数组对象

thisValue

可选。对象作为该执行回调时使用，传递给函数，用作 “this” 的值。
如果省略了 thisValue ，“this” 的值为 “undefined”

.filter():

使用指定的函数测试所有元素，并创建一个包含所有通过测试的元素的新数组。
语法

var new_arrary = arr.filter(callback[, thisArg])

           参数
                callback
                     用来测试数组的每个元素的函数。调用时使用参数 (element(值), index(索引), array(被遍历数组))。
                     返回true表示保留该元素（通过测试），false则不保留。

callback 被调用时传入三个参数：

• 元素的值
• 元素的索引
• 被遍历的数组

 thisArg

     可选。执行 callback 时的用于 this 的值

          .reduce():

.sort(): 方法将改变原数组;
  

几种数学函数：

 .pow():

pow() 方法可返回 x 的 y 次幂的值。
语法:Math.pow(x,y)
返回值:x 的 y 次幂。
说明:如果结果是虚数或负数，则该方法将返回 NaN。如果由于指数过大而引起浮点溢出，则该方法将返回 Infinity。

 .sqrt():

sqrt() 方法可返回一个数的平方根。
语法:Math.sqrt(x)
返回值:参数 x 的平方根。如果 x 小于 0，则返回 NaN。

 .round():

round() 方法可把一个数字舍入为最接近的整数。
语法:Math.round(x)
返回值:与 x 最接近的整数。
说明:对于 0.5，该方法将进行上舍入。
例如，3.5 将舍入为 4，而 -3.5 将舍入为 -3。

 Math.random():

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

 Math.floor():

Math.floor() 向下取整

eg: 我们先调用 Math.random()，把它的结果乘以20，然后把上一步的结果传给 Math.floor()， 这确保了我们获得了一个在0到19之间的整数。
同理，求任意两个数之间的随机数：

Math.floor(Math.random() * (max - min + 1)) + min;