js篇：运算符、函数、作用域、数组

运算符

也成操作符，可以通过运算符对一个或多个值进行运算得到运算结果

算术运算符

对非Number类型值进行运算时，会将这些值转化为Number类型在进行运算

注：

1. 字符串之间的加法是简单的拼凑在一起，任何值和字符串一起加法运算都会转化为字符串再进行简单的拼凑
2. 任何值和NaN进行运算返回值都会是NaN.
3. 定义字符串换行后要加上+，不然只能识别第一行
   
   
   

赋值运算符

=，+=，-+，*=。/=，%=

自增自减

分前后加减两种,两种都会使原变量自增或自减1并赋值给本身，但不同的是
a++返回的值是原变量的值,但此时a的值已经自增1了
++a返回的是变量自增后的值

逻辑运算符

！非，&&与，||或

• ！非: 就是对一个bool值进行取反操作。true变false,false变true
• &&与:
  运算规则：
  1、两个值只要有一个false就是false，有两个true才是true
  2、短路：如果第一个是false，不会看第二个他就会直接返回false 3、如果两边都是true,则返回后边的
  4、如果两边里面有false，则会返回靠前的
• ||或:
  运算规则：
  1、两个值只要有一个true就是true，有两个false才是false
  2、短路：如果第一个是true，不会看第二个他就会直接返回true 3、如果两边都是true,则返回第一个值的
  4、如果两个都是false,都会直接返回后边的值

关系运算符

可以比较两个数的大小，如果关系成立就会返回true，否则false；
分为>,>=,<,<=,==,!=

1. 非数值进行比较，会先转化为Number再比较
2. 当符号两侧都是字符串不会转化再计算，而会分别计算字符串中字符的Unicode编码
3. 比较字符编码时是一位一位进行比较的，当第一位相等时，就进行下一位与其比较
4. 当比较两个字符串类型的数字时，是根据Unicode编码比较的，会得到不可以预料的结果，所以一定要对其转型
5. 比较中文没啥意义
   (默认true为1)
6. 任何值和NaN作比较都是false，它不和任何值相等，包括他本身
7. Undefined衍生自null，所以两者比较是true
8. ===表全等，比较值跟数据类型，有一个不一样都会返回false
   ！==表不全等
   
   
   

条件运算符：三元的运算符

语法：条件表达式？语句1：语句2；

1. 如果条件表达式的求值结果是非bool值，会自动转化再返回值
2. 执行流程：首先对表达式求值，如果该值为true，则会执行语句1，并返回执行结果；否则，就会执行语句2，并返回执行结果。
3. 可以嵌套使用，但不推荐。
   
   
   

运算符的优先级

函数

复杂的数据类型

定义语法

（1）声明式：可以先调用再定义

function 函数名（形参）{
函数执行语句
}

（2）赋值式：必须先定义再调用

var 函数名=function（形参）{
函数执行语句
}

注：形参只能在函数内使用

调用语法

函数名（实参）

js的预解析机制

• 就是在代码执行之前，先对本文件script的代码进行通读和解释，然后再执行代码。

• 如果先调用赋值式函数会显示not a function，赋值式相当于在文件的最开始先定义了变量，但未赋值。直到函数被调用时，计算机仍不知道仍不知道变量是什么类型的数据。

• 而声明式函数一开始就会被提上到文件最前面但并不会被调用。

• 在函数内部定义的函数预解析时也只会提上到函数内部的最上面，并不能跳出函数

• 变量名与函数名重名问题

  声明式函数一开始就被提上了最上方，当下面有变量名与他重叠的变量被赋值后，调用函数也会显示not a function

• 变量名可以跨js文件引用，但预解析处理时函数只能提升到本js文件的最上面

return关键字用法

1. 看需求在函数的最后加上，调用函数后最后算出的取值会传回给函数（后端）。
2. return后面的语句将不再执行，会直接跳出整个函数。

作用域

全局作用域

1. 全局作用域是最大的作用域，一直存在，页面关闭时才会销毁
2. 当页面打开时，浏览器会自动生成一个全局作用域window
   
   
   

局部作用域

js中，只有函数能生成一个局部作用域，每一个函数都构成一个局部作用域

访问规则——就近原则

首先会在自己作用域内查找，没有的话会依次向上一级寻找，如果全局作用域内都没有就会报not defined。

赋值规则——就近原则

首先会在自己作用域内寻找变量并赋值，如果没有再依次向上一级寻找，如果全局变量都没有，那么这个变量会自动定义为一个全局变量，并给他赋值。

数组

数据的集合，复杂的数据类型

创建数组

1. 字面量方式

   var 数组名=[变量，变量，变量]
   

2. 构造函数方式

   var 数组名=new Array(变量，变量，变量)
   

   如果只输入一个数字n，表示创建一个空数组，其中占了n个单位的内存
   
   
   

基本操作

• length

  1. 获取数组长度

     数组名.length
     

  2. 清空数组长度

     数组名.length=0
     

• 获取数组

  1. 获取单个数组元素

     数组名[下标]//从0开始索引
     

  2. 数组的枚举/遍历

     for（var i=0;i<数组名.length;i++){
                        console.log(数组名[i])
     }
     

  3. 数组的赋值①

     for（var i=0;i<数组名.length;i++){
               数组1[i]=数组2[i]
     }
     

• 增加，删除元素

  1. 在末尾追加:push

     特别地，打印push的返回值是数组的长度

     数组名.push(元素值)
     

  2. 在末尾删除:pop

     数组名.pop(元素值)
     

  3. 在前面追加:unshift

     数组名.unshift(元素值)
     

  4. 在前面删除:shift

     数组名.shift(元素值)
     

  5. 在任意位置添加:splice

     也可以不删除原本的元 素直接加，将第二个参数设置为0即可。

     数组名.splice(下标位置,删除位数，"元素值","元素值")
     

  6. 在任意位置删除

     数组名.splice(下标位置,删除位数)
     

• 关于顺序

  1. 倒叙:reverce

     数组名.reverce()
     

  2. 排序:sort

     数组名.sort(function(a,b){//要求必须传两个形参
                 return a-b//从小到大
                 return b-a//从大到小
                             }
     )
     

• 修改数组元素

  数组名[下标]="元素值"
  

不影响原数组的常用操作

1. 两个数组拼接:concat

   var 新数组名=数组名.concat(数组名)

   • 可以利用concat赋值方法②

     var 数组名1=数组名2.concat()
     

   • 可以利用concat添加元素

     var 新数组名=数组名.concat(元素值,[元素值，元素值,...])
     

2. 数组转字符串:join

   数组名.join("连接符")
   

3. 截取数组:slice

   注：

   • 包前不包后
   • 只传一个值代表从那个下标开始到结尾
   • 不传值代表从头到尾复制——赋值方法③
   • 可以传负值，代表从后面开始数

   var 数组名1=数组名2.slice(开始下标，结束下标)         
   

4. 检查数组元素存在性

   • indexOf：从前往后找，只能检查到在前面的。

     返回-1代表找不到，如果存在会返回元素所在位置的下标

     var 变量=数组名.indexOf(元素值)
     

   • lastindexOf:从后往前找，只能检查到在后面的

   
   
   

利用回调函数的常用操作

1. 遍历forEach

      数组名.forEach(function(item,index,arr)){
            console.log(item,index,arr)
        })
        //item:打印每一个数组元素
        //index:打印下标
        //arr:打印整个数组
        //三个形参根据自己意愿加
   

2. 映射map

   函数返回值是什么，就表示把新数组映射成什么

   var 新数组名=数组名.map(function(item){
              return item
   })
   

3. 过滤filter

   根据返回值，如果返回值有true则将数据返回到新数组中，如果false就会过滤掉

   var 新数组=数组.filter(function(item){
          return 式子//当数组成员是对象时，筛选对象某一成                     员的格式是：item.成员名
   })
   

4. find

   根据返回值，如果返回值true则将数据传回新数组中，但只能找到成立的第一个成员并返回，但filter能将所有符合的都返回

   var 新数组=数组.find(function(item){
          return 式子//当数组成员是对象时，筛选对象某一成                     员的格式是：item.成员名
   })
   

5. 每一个every

   如果数组每一项都成立，就会返回true

   var 新数组=数组.every(function(item){
          return 式子
   })
   

6. some

   只要一个符合条件就返回true

   var 新数组=数组.some(function(item){
          return 式子
   })
   

7. 叠加reduce

   基于初始值实现累加、累成、字符串串在一起

   var 新数组=数组.some(function(prev，item){
          return prev+item  //prev表示上一次的结果
   }，0)  //给一个初始值，还可以是1、“”、...
   

数组排序

1. 冒泡排序：两两对比,交换变量

   for(var j=0;j<arr.length-1;j++){
          for(var i=0;i<arr.length-1-j;i++){
                    if(arr[i]>arr[i+1]){
                                        var temp=arr[i]
                                        arr[i]=arr[i+1]
                                        arr[i+1]=temp
                                        }
                                            }
   }
   

2. 选择排序法:假设第0个为最小，遍历比较，选择最小变量的索引与之交换

   for(var j=0;j<arr.length-1;j++){
               var minIndex=j
               for(var i=j+1;i<arr.length;i++){
                        if(arr[i]<arr[minIndex]){
                        minIndex=i
                                                 }
                                               }
               var temp=arr[j]
               arr[j]=arr[minIndex]
               arr[minIndex]=temp
   }
   

   
   
   

数组去重

1. 利用for循环和if语句

   for（var i=0；i<arr.length;i++){
               if(arr2.indexOf(arr[i])===-1){
               arr2.push(arr[i])
               }
   }
   

2. 利用对象，把数组的成员值赋值给对象的成员名，当成员名重合时回覆盖住前面的。

   var obj={}
   for(var i=0;i<arr.length;i++){
                  obj[arr[i]]=""
   }//赋值给对象
   var arr2=[]
   for(var i in obj){
   arr2.push(i-0)//将对象成员赋值给数组
   }
   

3. 利用new set 不可重复性

   var set1=new St(arr)//数组转set
   var arr1=Array,from(set1)//set转数组