数组

• 描述：数组可以把一组相关的数据放到一起，并提供方便的访问方式。

• 概念：数组是指一组数据的集合，其中的每个数据被称为元素，在数组中可以存放任意类型的元素。数组是一种将一组数据存储在一个变量名下的优雅写法。长度是可以动态的调整。

创建数组的方法

• new方法创建数组

  • var 数组名 = new Array()

• 利用数组字面量创建数组

  • var 数组名 = ["元素1", "元素2"]

检测数组类型

• instanceof: 检测某个实例是否是某个对象类型

• 语法：
  console.log(arr instanceof Array)

  var arr = [1,2,3]
  console.log(arr instanceof Array)  // true
  

获取数组中的元素

• 索引

  • 通过索引获取数组中的元素，索引表示用来访问数组元素的序号，索引的下标从0开始。可以通过索引对数组中的元素进行获取，设置和修改。

  • 语法：数组名[0]；表示获取数组中第一个元素。

  • 注意：如果索引超出了数组元素的数量，则返回一个undefined。

    var arr = ["a", "b", "c"]
    console.log(arr[0])  // "a"
    console.log(arr[3]) // undefined
    

• 数组遍历

  • 描述：将数组中的元素从头到尾访问一遍。

  • 通过for循环对数组进行遍历，注意数组的索引是从0开始的，所有循环数组也应该是从0开始。

• 数组长度

  • length属性，可以通过length属性获取到数组的长度。

  • 数组名.length；获取数组中元素的数量。

数组元素的方法和属性

• toString()方法：把数组转换成字符串，逗号分隔每一项。

  var arr = [1, 2, 3]
  console.log(arr.toString())  // 1, 2, 3
  

• 通过修改length长度新增数组元素。length属性是可读可写的。

  • 语法：数组名.length = 5；表示数组长度修改成5，如果原本的数据长度是3，则会在原来的数组中新增两个空元素。[1, 2, 3, empty × 2]，如果数组中原本有5个元素，现在将数组的长度修改成了2，则只会保留数组中的前两个元素。并且删除的数据是不可逆的。

• 通过修改索引号，追加数组元素

  • 语法：数组名[索引号] = "元素值"，如果索引号本身在数组中不存在该元素，则表示追加新的元素到该数组中，如果在数组中该索引号有表示的值，则会修改原始值，替换成新的值。

• push(元素)方法，在数组的尾部添加新的元素。

  • 语法：数组.push(元素)，可以同时添加多个元素。返回数组的长度。

• pop()方法，删除数组最后一项，返回删除项。

  • 语法：数组.pop( )，返回删除项

• unshift(元素)方法，在数组头部部添加新的元素。

  • 语法：数组.unshift(元素)，可以同时添加多个元素。

• shift() 方法：删除数组第一项，返回删除项。

  • 语法：数组.shift()，返回删除项

• splice(index, howmany, item1)方法，向指定位置添加/删除元素。返回删除项。

  • 语法：数组.splice(index, howmany)

  • index：必选参数，整数烈性，规定添加/删除项目的位置，使用负数可以从数组结尾处规定位置。

  • howmany：必选参数，要删除的项目数量。如果为0，则不会删除元素。

  • item1...itemx：可选参数，想数组添加新的元素

    // 删除功能
    var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    arr.splice(1, 3)
    console.log(arr)  // [1, 5, 6, 7, 8, 9]
    ​
    // 替换功能
    var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    arr.splice(1, 3, "hello")
    console.log(arr)  // [1, "hello", 5, 6, 7, 8, 9]
    ​
    // 插入功能
    var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    arr.splice(1, 0, "hello")
    console.log(arr)  // [1, "hello", 2, 3, 4, 5, 6, 7, 8, 9]
    

• concat()方法，将两个数组合并成一个新的数组，原数组不受影响。参数位置可以是一个数组字面量，数组变量，零散的值。

  • 语法：数组.concat(参数)

    var arr = [1,2,3]
    var arr2 = arr.concat([4,5,6])
    console.log(arr2)  // [1,2,3,4,5,6]
    

• slice(start, end)方法，从当前数组中截取一个新的数组，不影响原来的数组，返回一个新的数组。

  • 包含start不包含end。

  • 参数区分正负，正数表示下标位置，负数表示从后面往前数第几个位置，参数可以只传递一个，表示从开始位置截取到字符串结尾。

    var arr = [1,2,3,4,5,6]
    var arr2 = arr.slice(2, 4)
    console.log(arr2)  // [2,3,4]
    

• indexOf()方法：查找数据在数组中最先出现的下标。如果没有找到返回-1

• lastIndexOf()方法：查找数据在数组中最后一次出现的下标。如果没有找到返回-1

  var arr = [1,2,3,4,5,6,4,5,6]
  console.log(arr.indexOf(4))  // 3
  console.log(arr.lastIndexOf(4))  // 6
  

• reverse()方法：将数组完全颠倒，第一项变成最后一项，最后一项变成第一项。

  • 语法：数组.reverse()

• sort()方法：默认根据字符编码顺序从小到大排序。

  • 语法：数组.sort()

  • 如果想要根据数值大小进行排序，必须添加sort的比较函数参数。该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有a和b两个参数，根据a和b的关系作为判断条件，返回值根据条件分为三个分支，正数、负数和零。

  • 返回值为负数，a 排在 b的前面

  • 返回值为正数，a 排在 b 的后面

  • 返回值为零，a 和 b 的顺序保持不变。

    var arr [1,2,3,4,5,11,21,31]
    console.log(arr.sort())  // [1,11,2,21,3,31,4,5]
    ​
    console.log(arr.sort(function (a, b) {
     if (a < b) {
     retrun -1;  // a 排在 b 的前面
     } else if (a > b) {
     return 1;  // a 排在 b 的后面
     } else {
     return 0;  // a 和 b 的顺序保持不变
     }
    }))  // [1,2,3,4,5,11,21,31]
    

• join()方法：数组转字符串方法，将数组的所有元素连接到一个字符串中。

  • 语法：数组.join("-"); 通过参数作为连字符将数组中的每一项用连字符连接成一个完整的字符串。返回一个新的值。

    var arr = [1,2,3,4,5];
    var str = arr.join("-");
    console.log(str)  // "1-2-3-4-5"
    

函数

• 描述：函数也叫做功能、方法，函数可以将一段代码一起封装起来，被封装起来的函数具备某一项特殊的功能，内部封装的一段代码作为一个完整的结构体，要执行就都执行，要不执行就都不执行。

• 函数就是封装了一段可被重复调用执行的代码块。函数声明的时候，函数体并不会执行，只有当函数被调用的时候才会执行。

• 语法：

  // 利用function关键字声明
  function 函数名(参数) {
   函数体;
  }
  // 函数表达式（匿名函数）
  var 变量名 = function() {
   函数体;
  }
  // 箭头函数，由等号和大于号代替function关键字
  const 函数名 = (参数) => {
   函数体;
  }
  // 在箭头函数中，如果只有一个参数，则可以省略参数的括号，如果函数体是个单个表达式，而不失大括号中块，则函数将返回这个表达式。
  const square1 = (x) => {return x * x}
  const square2 = x => x * x
  ​```
  
  

函数调用

• 调用方法：函数名()

• 函数调用也叫做函数执行，调用时会将函数内部封装的所有的结构体的代码立即执行。

• 函数内部语句执行的位置，与函数定义的位置无关，与含税调用位置有关。

• 函数可以一次调用，多次执行。

函数的参数

• 函数的参数本质就是变量，可以接受任意类型的数据，导致函数执行结果根据参数的不同，结果也不同。

• 一个反函数可以设置0个或者多个参数，参数之间用逗号分隔。

• 在定义函数的时候，函数名后面的括号中传递的参数称为形参，调用函数的时候，传递的参数称为实参。

• 如果实参的个数大于形参，则只会取到形参个数的部分，不会再继续取

• 如果实参的个数少于形参，则未传递的形参为undefined。

函数的返回值

• 利用函数内部的return关键字设置函数的返回值。

• 作用：

  • 函数内部如果结构体执行到return的关键字，会立即体质后面代码的执行。

  • 可以再return关键字后面添加空格，空格后面任意定义一个数据字面量或者表达式，函数在执行完自身功能后，整体会被return矮化成一个表达式，表达式必须求出一个值，继续可以参与程序，表达式的值就是return后面的数据。如果return 返回多个值的时候，多个值用逗号隔开，则返回最后一个值。

• 如果函数有返回值，自行结果可以当成普通数据参与程序。也可以作为一个普通数据赋值给一个变量，甚至赋值给其他函数的实际参数。

• 注意：如果函数中有return，返回的是return后面的值，如果没有return，返回的是undefined。

函数表达式

• 函数表达式是函数定义的另外一种方式。

• 定义方法：将函数的定义、匿名函数赋值给一个变量。

  var fun = function (参数) {
   函数体;
  };
  

• 函数定义赋值给一个变量，相当于将函数整体矮化成了一个表达式。是一个匿名函数。表示函数没有函数名。

• 调用方法：给变量名加()执行。

箭头函数

• 箭头函数是由等于号和大于号组成的箭头代替function关键字组成的函数。

• 箭头位于参数列表之后，后面跟函数体。

  const fun = (参数) => {
   函数体
  };
  

• 当箭头函数只有一个参数的时候，可以省略掉参数两边的括号不写，并且当函数体内的返回值是一个表达式，而不是一个代码块的时候，可以省略掉大括号。

  const fun1 = (x) => {return x * x}
  // 简略写法
  const fun2 x => x * x
  

函数的数据类型

• 函数是一种单独的数据类型Function。

• 由于函数是一种数据类型，可以参与其他程序，例如可以把函数作为另一个函数的参数，在另一个函数中调用。或者可以把函数可以作为返回值从函数内部返回。

arguments

• arguments实际上是当前函数的一个内置对象，所有函数都内置了一个arguments对象，arguments对象中存储了传递的所有实参。当不确定有多少参数传入时，可以使用arguments对象接收参数。

• arguments是一个伪数组，具有数组的length属性，也是按照索引的方式进行存储的数据。但是没有数组的一些方法，比如pop()、push()等。

  // 创建函数
  function fn() {
   console.log(arguments)
  }
  ​
  // 调用函数
  fn(1,2,3)
  

函数递归

• 函数内部可以通过函数名调用函数自身的方式，就是函数递归现象。

• 递归的次数太多容易出现错误，超出计算机的计算最大能力，栈溢出。

调用栈

• 描述：调用栈就是代码执行的地方。用于追踪函数执行流程的一种机制，当执行环境中调用了多个函数时，通过这种机制能够追踪到哪个函数正在执行，执行的函数体中又调用了那个函数

• 每调用一个函数，解释器就会把这个函数添加到调用栈顶部，并执行该函数。

• 当正在执行的函数有调用了一个新的函数，新的函数也将会加入到调用栈中，一旦这个函数被调用，就会立即执行。

• 当执行完毕后，解释器会将其清出调用栈，并且会继续执行当前环境中剩余的代码。

• 当分配的调用栈的空间被沾满时，将会抛出栈溢出的异常。

  function out() {
   function inner() {
   console.log("inner")
   }
   inner();
   console.log("out");
  }
  out()
  

  ​
  // 1.当调用函数out的时候，会将out()函数放入到调用栈中。
  // 2.当执行到out()函数体内部调用inner函数的时候，会将inner函数放入到调用栈顶部。
  // 3.inner函数执行完之后，调用栈会删除inner函数，并且继续执行剩余的代码。
  // 4.当执行完out函数内剩余的代码时，调用栈会删除out函数。</pre>

作用域

• 描述：变量可以起作用的范围。

• 如果变量定义在一个函数内部，只能在函数内部被访问到，在函数外部不能使用这个变量，函数就是变量定义的作用域。

• 任何一堆花括号{}中的的结构体都属于一个快，在这之中定义的所有变量在代码块外都是不可见的，我们称之为块级作用域。

• 使用let和const声明的变量实际上是在声明它们的块级作用域，在块级作用域之外是不可见的。使用var声明的变量实际上在函数中，如果在一个代码块中是使用let和const声明的变量，则在其他代码块中是不能使用的，并且抛出未定义的异常。而在函数中，在一个代码块中是使用的var声明的变量，在另一个代码块中表示为undefined。

• 局部变量：定义在函数内部的变量，只能在函数作用域内部被访问到，在函数外面是没有定义的。

• 全局变量：从广义上说，也是一种局部变量，定义在全局的变量，作用域范围是全局，在整个js程序任意位置都能被访问到。

• 局部变量退出作用域之后会销毁，全局变量关闭网页或者浏览器才会销毁。

参数和函数的作用域

• 函数的参数本质是一个变量，也有自己的作用域，函数的参数也是属于函数自己内部的局部变量，只能在函数内部被使用，在函数外面没有定义。

• 函数也有自己的作用域，定义在哪个作用域内部，只能在这个作用域范围内被访问，出了作用域就不能被访问。

• 函数定义在另一个函数内部，如果外部函数没有执行时，相当于内部代码没有写。

作用域链

• 只有函数可以制造作用域结构，只要是写代码，就至少有一个作用域，即全局作用域。凡是代码中有函数，那么这个函数就构成另一个作用域。如果函数中含有函数，那么在这个作用域中就又可以单生一个作用域。

• 将这样的所有的作用域列出来，可以有一个结构：函数内部指向函数外的练市结构，就称作作用域链。函数内部可以调用函数外部的变量，函数外部不可以调用函数内部的变量。如果想在函数外调用函数内部的变量，可以使用闭包函数。

遮蔽效应

• 程序在遇到一个变量时，使用时作用域查找顺序是从下往上进行查找，不同层次的函数内部有可能定义相同名字的变量，一个变量在使用时，会优先从自己所在层作用域查找变量，如果当前层没有变量定义，会按照顺序从本层往外依次查找，直到找到第一个变量定义。整个过程总会发生内部变量遮罩外层变量的效果，叫做遮蔽效应。

  var a = 1;
  function out() {
   var a = 2;
   function inner() {
   var a = 3;
   console.log(a)
   }
   inner()
  }
  out()
  

  // 当inner函数被调用时，会先从函数内部寻找变量 a ，如果inner函数内部没有定义变量 a ，则会向外层out函数中进行寻找变量 a ，如果out函数中也没有定义变量 a ，则继续向外层寻找，直到全局变量中。按照从内到外的顺序进行查找。</pre>

var关键字的影响

• 在函数内部定义新的变量，如果不加关键字var，相当于定义全局变量，如果全局也有相同的标识符，会被函数内部的变量影响，局部变量污染全局变量。

  var a = 1;
  function out() {
   a = 2;
   function inner() {
   var a = 3;
   }
   inner()
  }
  out()
  console.log(a)
  

  // 当调用函数out()的时候，函数体中的"a = 2"会改变全局变量 "a = 1" 的值，当执行完out函数的时候，在最终执行console.log(a)的时候，会输出2；</pre>

预解析和声明提升

• JavaScript代码的执行是由浏览器中的js解析器来执行的。js解析器执行js代码的时候，分为两个过程：预解析过程和代码执行过程。

• 预解析过程：

  • 1.把变量的声明提升到当前作用域的最前面，只会提升声明，不会提升赋值。

  • 2.把函数的声明提升到当前作用域的最前面，只会提升声明，不会调用。

  • 3.先提升var，再提成function。

• 执行过程：

  • 在预解析之后，根据新的代码顺序，从上往下按照既定规律执行js代码。

• 变量声明提升

  • 在预解析过程中，所有定义的变量，都会将声明的过程提升到所在的作用域最上面，在将来的代码执行的过程中，按照先后顺序会先执行被提升的声明变量过程。

  • 提升过程中，只提升声明过程，不提升变量赋值，相当于变量定义，但是未赋值，变量内存储undefined值。因此，在js中，在前面调用后定义的变量，不会报错，只会只用undefined值。

    console.log(a)  // undefined
    var a = 1
    

• 函数声明提升

  • 在预解析过程中，所有定义的函数，都会将声明的过程提升到所在的作用域最上面，在将来的代码执行的过程中，按照先后顺序会先执行被提升的函数声明过程。

  • 在预解析之后的代码执行过程中，函数定义过程已经在最开始就会执行，一旦函数定义成功，后续就可以直接调用函数。因此在js中，在前面调用后定义的函数不会报错，而且能正常执行函数内部的代码。

    fun()  // 2
    ​
    function fun() {
     console.log(2)
    }
    

• 提升顺序

  • 预解析过程中，线提升var变量声明，再提成function函数声明。

  • 假设出现变量名和函数名相同，那么后提升的函数名标识符会覆盖先提升的变量名，那么在后续代码中出现的调用标识符时，内部是函数的定义过程，而不是undefined。

  • 如果调用标识符的过程在源代码函数和变量定义后面，相当于函数名覆盖了一次变量名，结果再执行到变量赋值时，又被新值重新覆盖了函数的值，那么在后面再次调用标识符，用的就是变量存的新值。

• 函数表达式的提升

  • 在预解析过程中，函数表达式进行的是变量声明提升，而不是函数声明提升。提升后变量内部存的是一个undefined。在前面进行函数方法调用，数据类型会提示错误。

IIFE自调用函数

• IIFE，叫做及时调用的函数表达式，也叫做自调用函数，表示函数在定义时就立即调用。

• 函数调用方式：函数名或函数表达式的变量名后面加()运算符。

• 函数定义的形式不能实现立即执行自调用，函数使用函数表达式形式可以实现立即执行，原因是因为函数表达式定义过程中，将一个函数矮化成了一个表达式，后面加 () 运算符就可以立即执行。

• 函数矮化成表达式，就可以实现自调用。

• 函数矮化成表达式的方法

  • 可以让函数参与一些运算符，也就是说给函数前面加一些运算符。

  • 数学运算符：+ - ()

  • 逻辑运算符：! 非运算

• IIFE结构可以关住函数的作用域，在结构外面是不能调用函数的。

• IIFE最常用的是 () 运算符，而且函数可以不写函数名，使用匿名函数。

  (function(a) {
   console.log(a);  // 1
  })(1);
  

对象

什么是对象

• JavaScript的对象就是无序属性和方法的集合。

• 属性可以包含基本值、对象或函数。对象就是一组没有顺序的值。我们可以把javascript中的对象当做一对键值对，其中值可以是数据和函数。

• 对象的行为和特征：

  • 特征：在对象中用属性表示

  • 行为：在对象中用方法表示

对象字面量

• 创建一个对象的最简单的方式就是使用对象字面量赋值给变量。类似数组。

• 语法：{}

  var obj = {
  name: "小明",  // 属性
  age: 18,  // 属性
  sayHi: function () {  // 方法
  console.log("你好")
  }
  };
  

• 内部可以存放多条数据，数据与数据之间用逗号分隔，最后一条数据后面不需要添加逗号。

• 每条数据都是由属性名和属性值组成，键值对的写法为{"k": "v"};

• k 代表属性名

• v 代表属性值，可以是任意类型的数据。比如简单类型的数据，数组，函数等。

区分属性和方法

• 属性：对象的描述性特征，一般是名词，相当于定义在对象内部的变量。

• 方法：对象的行为和功能，一般是动词，定义在对象中的函数。

对象数据的调用

• 用对象的变量名加点调用某个属性名，得到属性值。当属性名不存在时会返回一个undefined。

  obj.name  // "小明"
  

• 在对象内用this打点调用属性名，this代替对象。

  var obj = {
   name: "小明",  // 属性
   age: 18,  // 属性
   sayHi: function () {  // 方法
   console.log("你好" + "，" + this.name)
   }
  };
  

• 用对象的变量名后面加[ ]调用，[ ]内部是字符串格式的属性名。

  obj["age"] // 18
  

• 调用方法时，需要在方法名后面加小括号执行。

  obj.sayHi()
  

对象数据的修改

• 更改属性的属性值方法：先调用属性，再等号赋值

  obj.age = 20
  

• 增加新的属性和属性值，使用点语法或者[ ]语法直接添加新的属性，等号赋值。

  obj.height = 183
  obj["height"] = 183
  

• 删除一条属性：直接使用delete关键字，空格后面加属性调用。

  delete obj.height
  

new Object() 创建对象

• Object()构造函数是一种特殊的函数。主要用来在创建对象时初始化对象。即为对象成员变量赋初始值，在创建对象的语句中，总与new运算符一起使用。

• 注意：

  • 构造函数用于创建一类对象，首字母要大写。

  • 构造函数要和 new 一起使用才有意义。

  var obj = new Object();
  obj.name = "小明";
  obj["age"] = 18;
  obj.sayHi = function () {
   console.log("你好");
  };
  

• new 运算符的作用：

  • 1.创建一个空的对象。

  • 2.将this指向新创建的对象。

  • 3.执行构造函数，建立对象和原型的对应关系。使对象能够添加新的属性和方法。

  • 4.返回一个对象。

工厂函数创建对象

• 如果要创建多个类似的对象，可以将 new Object() 过程封装到一个函数中，将来调用封装函数就可以创建一个对象，相当于一个生成对象的函数工厂，用来简化代码。

  function createObj(name, age, sex) {
   // 工厂方法就相当于对 new Object() 的一个封装
   var obi = new Object();
   obj.name = name;
   obj.age = age;
   obj.sex = sex;
   obj.sayHi = function () {
   console.log("你好");
   };
  
   return obj
  }
  

自定义构造函数

• 自定义一个创建具体对象的构造函数，函数内部不需要new一个构造函数的过程，直接使用 this 代替对象进行属性和方法的书写，也不需要return一个返回值。

• 使用时，利用 new 关键字调用自定义的构造函数即可。

• 注意：构造函数的函数名首字母需要大写，区别去其它普通函数名。

  // 自定义构造函数
  function CreateObj (name, age) {
   this.name = name;
   this.age = age;
  }
  // 调用构造函数
  var obj = new CreateObj("张三", 20)
  

对象遍历

• for in 循环专门用来遍历对象，内部会定义一个k变量，k变量在内次循环时会从第一个开始接受属性名，一直接收到最后一个属性名，执行完成后跳出循环。

  // 输出每一项属性名和属性值
  for(var k in obj) {
   console.log(k + "的属性值是：" + obj[k]);
  }
  

简单数据类型和复杂数据类型

• 简单数据类型又叫做值类型，复杂数据类型又叫做引用类型。

• 值类型：简单数据类型，基本数据类型，在存储时，变量中存储的是值本身，因此叫做值类型。

• 引用类型：复杂数据类型在存储时，变量中存储的仅仅是地址（引用），因此叫做引用数据类型。

堆和栈

• 堆栈分配空间区别：

  • 栈：由操作系统自动分配释放，存放函数的参数值，局部变量的值等等。

  • 堆：存储复杂类型（对象），一般由程序员分配释放，如果不释放，由垃圾回收机制回收。

基本数据类型在内存中的存储

变量中如果存储的是简单类型的数据，那么变量中存储的是值本身，如果将变量赋值给另一个变量，是将内部的值复制一份给了另外一个变量，两个变量之间没有关系，一个发生变化，另一个不会同时改变。

• 示例

     // 在内存中开辟了两个内存空间，分别指向 a 和 b 。
     var a = 10;
     var b = a;  // 将 a 存储的数据，复制给了 b
     // 当 a 发生改变的时候，b 不会随着发生改变。
     a = 5
  

​
console.log(a) // 5
console.log(b) // 10
```

复杂类型数据再内存中的存储

如果将复杂类型的数据赋值给了一个变量，复杂类型的数据会在内存空间中创建一个原型，而变量中存储的是指向内存中对象的一个地址，如果将变量赋值给另一个变量，相当于将地址复制了一份给了新变量，两个变量的地址相同，指向的是同一个原型。不论通过那个地址更改了原型，都是在原型上发生的改变，两个变量下次访问时，都会发生变化。

数组和函数存储在变量中时，也是存储的地址。

• 示例

  var obj = {
   name: "zs",
   age: 18
  };  // 在堆里面开辟了一个内存空间，obj在栈中指向的是堆中的内存地址。
  var obj2 = obj;
  

​
obj2.height = 183;
​
console.log(obj); // {name: "张三", age: 18, height: 183}
console.log(obj2) // {name: "张三", age: 18, height: 183}
```

使用MDN学习手册

MDN链接：https://developer.mozilla.org/zh-CN/

Math对象

Math对象具有数学常数和函数的属性和方法，可以直接对Math直接使用。

Math.PI

描述： 表示一个圆的周长与直径的比例

语法：Math.PI

Math.random()

描述：函数返回一个浮点, 伪随机数在范围从0到小于1，也就是说，从0（包括0）往上，但是不包括1。

语法：Math.random()

Math.floor()和Math.ceil()

Math.floor(x)：返回小于或等于一个给定数字的最大整数

语法：Math.floor(x)

Math.ceil(x)：返回大于或等于一个给定数字的最小整数。

语法：Math.ceil(x)

Math.round()

Math.round(x)：返回一个数字四舍五入后最接近的整数。

语法：Math.round(x)

Math.abs()

Math.round(x)：返回指定数字 “x“ 的绝对值

语法：Math.round(x)

Math.max()和Math.min()

Math.max(x)：返回一组数中的最大值。

语法：Math.max(1,2,3)/Math.max(...[1,2,3])

Math.min(x)：返回一组数中的最小值。

语法：Math.min(1,2,3)/Math.min(...[1,2,3])

Math.sin()和Math.cos()

Math.sin(x)：返回一个数值的正弦值。

语法：Math.sin(x)

Math.cos(x)：返回一个数值的余弦值。

语法：Math.cos(x)

Math.pow()和Math.sqrt()

Math.pow(base, exponent)：返回基数（base）的指数（exponent）次幂。

Math.sqrt(x)：返回一个数的平方根

基本包装类型

• 描述：基本类型的一些数据在进行一些特殊操作时，会暂时被包装成一个对象，结束后再被销毁。

  var str = "这是一个字符串"
  // 当调用字符串的方法或者属性的时候，其实是对字符串进行了临时包装。
  // 相当于调用了String()构造函数，var str2 = new String(str)
  // 调用字符串方法的时候，实际是调用的包装对象的方法。
  // 当结束后会被销毁。包装的对象设置为null
  ``
  
  

字符串

字符串是不可变的，由于他的这一特性，在大量拼接字符串的时候会产生效率问题。

• 实例：

  var a = '123'
  a = '456'
  // 当创建变量a的时候，会在内存中开辟一块内存空间，用于存储变量    值"123"。
  // 当变量a重新被赋值的时候，是在内存中有另外开辟了一块新的内存空间，用于存储变量值"456"。
  // 此时内存中的变量值123仍然会存在，直到js引擎进行垃圾回收的时候才会被清除。
  

字符串属性

语法：字符串.length; 表示的是一个字符串中的内部每一个字符的总和。

字符串的方法

charAt(index): 返回指定位置的字符。

indexOf(字符)：返回某个指定的字符串第一次出现的位置。

concat()：用于连接两个或者多个字符串。

• 参数可以是字符串或者字符串变量、多个字符串。

• 返回一个新的字符串，原字符串不会发生改变。

split(分割符)：把一个字符串分割成一个字符串数组。

• 参数部分就是分割符，利用分割符将字符串分隔成多个部分，多个部分作为数组的每一项组成数组。

• 分割符如果是空字符串，相当于将每个字符拆分成数组中的每一项。

toLowerCase()：把字符串中的英文字符串转换成小写

toUpperCase()：把字符串中的英文字符串转换成大写

slice(start, end)：提取字符串的某个部分。并以新的字符串返回被提取的部分。

substr(start, howmany)：在字符串中抽取从start下标开始指定个数的字符。start区分正负数。howmany必须为正数，也可以不传入。不传表示截取到最后。

subsrting(start, end)：提取字符串中介于两个指定下标之间的字符。

• 语法：str.substring(start, end)

• 参数只能是正数。

• 两个参数都是指下标。两个参数的大小不限，在执行方法之前会比较两个参数的大小，小的会被当做开始位置，大的会被当做结束位置，从开始位置截取到结束位置，但不包含结束位置。

• 如果不写第二个参数，表示从开始截取到字符串结尾。