（七）js 常用方法

一、数组常用方法：

1、锁定数组的长度(只读模式)

var a = [1,2,3]  //定义一个数组<br>
Object.defineProperty(a,"length",{
   writable:false
})  //将a数组的长度属性设为只读<br>
a.length = 0  //将a的长度改为0<br>
console.log(a.length);  //打印a数组的长度，还是3

2、将数组合并成字符串（返回字符串）[ Array.join() ]

var a = [1,2,3];
var b = a.join("");
console.log(a); //[1, 2, 3],原数组不改变
console.log(b); //"123",变成字符串

 3、返回逆序数组（倒叙排列数组）[ Array..reverse() ]

var a = [1,2,3];
a.reverse();
console.log(a); //直接改变a数组的值 返回的是[3,2,1]

4、Array.sort()方法，返回字符串排序后的数组。如果数组包含undefined，会被排到数组的尾部。如果不带参数的调用sort()，数组元素以字母表顺序排序。

从大到小排列
var a = [2,33,1111,444];  
a.sort()             
console.log(a); //返回的结果是[1111, 2, 33, 444]
从小到大排列
var a = [2,33,1111,444];            
a.sort(function (a,b) {
    return a-b
})             
console.log(a); //[2, 33, 444, 1111]

注意sort是按照字符串排序，如果需要按照数字大小排序，需要自己实现，如：

var arr=[1,4,8,2,11,7,3,5];
arr.sort(function (a,b){ return a-b });//arr = [1,2,3,4,5,7,8,11]

 5、Array.concat(),创建并返回一个新数组

var a = [1,2,3];       
var b = a.concat(4,5);             
var c = a.concat([4,5]);             
console.log(a); //返回的还是[1,2,3]
console.log(b); //返回[1,2,3,4,5] 
console.log(c);  //返回[1,2,3,4,5]
// 复制数组
var a = [1,2,3];          
var b = a.concat();                   
console.log(a); //返回[1,2,3] 
console.log(b); //返回[1,2,3]

6、Array.slice()方法，返回指定数组的片段或者子数组。不会改变原数组

var a = [1,2,3,4,5];<br>
a.slice(0,3); //返回[1,2,3] 第一个参数是截取开始的位置（包括），第二个参数是截取结束的位置（不包括）           
a.slice(3); //返回[4,5]             
a.slice(1,-1); //返回[2,3,4] 负数表示倒数             
console.log(a); //返回[1,2,3,4,5]

 7、Array.splice()方法，用来删除或插入元素，会修改原数组！

数组的起始位置为0
var a = [1,2,3,4,5,6,7,8];             
var b = a.splice(1,2); //第一个参数是截取的起始位置（包括），第二个参数是截取的个数，之后的参数就是添加在元数组的新值             
console.log(a); //返回[1, 4, 5, 6, 7, 8]             
console.log(b); //返回[2, 3]

可以用来解决在数组起始部位加入数据

 this.noticeMessageList.splice(0, 0, { fromUser: 'zhangq1',
            noticeMessage: '此处添加message'})

if (param.type === 'update') {     
        this.users.splice( index,1, user);
      } else if (param.type === 'delete') {
        this.users.splice( index,1);
      }

 8、push()方法与pop()方法：

push()方法在数组的尾部添加一个或者多个元素，并返回数组的新长度。注意的是，改变的是原数组的值，返回的是新数组的长度；pop()方法删除数组的最后一个元素，并返回它的删除值。也是改变原数组，返回的是删除的值。

9、unshift()方法与shift()方法

unshift()方法类似于push()不同的是，他是在数组头部添加，其他都一样
shift()方法则类比pop()方法。

10、toString()和toLocaleString()

toString()方法将每个元素转化为字符串，类似于不传参的join()方法。
toLocaleString()方法是toString()的本地化版本。

 11、forEach()方法，从头至尾遍历数组，为每个元素调用指定的函数，语法：

this.array.forEach(item => {
        ....
 });

或

a.forEach(function (value) {
    sum += value
})  

12、map()方法
和forEach()类似，调用数组的每个元素传递给指定函数，并返回一个数组，所以它和forEach()的区别在于，有一个返回值。不修改原数组，返回的数组长度和原数组相同

var a = [1,2,3,4,5];           
var b = a.map(function (value) {
    return value+1
})             
console.log(b); //返回[2,3,4,5,6]

再如获取对象数组的某个属性集合：

// 使用了 ES6 语法
data.map(item => item.a)

// 兼容的写法
data.map(function (item) {
    return item.a;
});

 13、filter()方法，返回的是调用数组的一个子集。

var a = [1,2,3,4,5];            
var b = a.filter(function (value) {
    return value > 3
})             
console.log(b); //返回[4,5]
注意：如果使用map()方法，返回的是[false, false, false, true, true]

filter()会跳过稀疏数组中缺少的元素，他的返回数组总是稠密的。所以可以用一下方法来压缩稀疏数组的空缺。

var a = [1,2,,,5];             
var b = a.filter(function (value) {
    return true
})              
console.log(b); //返回[1,2,5]

14、find方法：返回数组符合条件的第一个元素：

let userId = this.searchData.userName
            ? this.userList.find(item => {
                return item.userName === this.searchData.userName;
              }).id
            : '';

 15、every()和some()
every()方法是只有数组中所以元素都满足某个条件才会返回true；some()方法是只要有满足条件的值，就返回true。
以every()方法为例

var a = [1,2,3,4,5];
             
a.every(function (value) {
    return value < 10
}) //true             
a.every(function (value) {
    return value % 2 === 0
}) //false

如：去除数组A中包含数组B中的元素

let newArr = A.filter(function (item) {
                    return B.every(function (item1) {
                        return item.SPID != item1.SPID;
                    })
                });

 16、indexOf()和lastIndexOf()

这两个方法都是用来搜索整个数组中具有给定值的元素，返回找到的第一个元素的索引，如果没找到，则返回-1。

区别在于indexOf()从头至尾搜索，而后者则是反向搜索

如：this.fileList.splice(this.fileList.indexOf(file), 1);

17、数组中对象的操作

//根据对象中的某一个属性值获取相应的对象
 ignoreAnswerMessage(row) {
      for (var index in this.noticeMessageList) {
        const indexValue = this.noticeMessageList[index].nmId
        if (indexValue === row.nmId) {
          this.noticeMessageList.splice(index, 1)
          this.newNoticeCount = this.noticeMessageList.length
        }
      }
      Axios.put('http://localhost:60000/noticeMessage/update/' + row.nmId)
      //
    }

18、数组的深拷贝和浅拷贝：js 赋值的两个对象数据会相互影响。数组也属于对象，所以数组也是会相互影响的。如

var a = [333]
var b = a;//将a赋值给b
a[0] = 555;//将a的值改为555
console.log(b) // 打印b也是555

这种属于深拷贝；如果不希望互相影响，可以使用浅拷贝，方法有：

（1）使用concat  ：

this.copyUsers = [];
this.copyUsers = this.copyUsers.concat(this.users); 

（2）循环复制

var shallowCopy = function (obj) {
  // 只拷贝对象
  if (typeof obj !== 'object') return;
  // 根据obj的类型判断是新建一个数组还是一个对象
  var newObj = obj instanceof Array ? [] : {};
  // 遍历obj,并且判断是obj的属性才拷贝
  for (var key in obj) {
    if (obj.hasOwnProperty(key)) {
      newObj[key] = obj[key];
    }
  }
  return newObj;
}

19、 数组去重：

（1）普通数组去重：

 this.ids = Array.from(new Set(this.ids ));

（2）对象数组去重：

unique(arr) {
  const res = new Map();
  return arr.filter((arr) => !res.has(arr.id) && res.set(arr.id, 1))
}

20、数组组合用法：

（1）如先过滤再返回某个字段：如获取用户对象中某角色下不为空的地址列表

 let user= this.addUsers
            .filter(user => user.roleCode=== this.roleCode && user.address)
            .map(user => {
              return user.address;
            });

二、字符串常用方法：

1、trim()头尾去空格：

如

  <el-input v-model.trim="formValidate.leaveCode"  ></el-input>

2、字符串转为字符数组：

let a = new Array(0,1,2,3,4);

三、常用转换方法：

1、json转换：

（1）json对象转为json字符串：JSON.stringify(obj)；

（2）json字符串转json对象：两种方式，JSON.parse和eval。
 eval 是javascript支持的方式，不需要严格的json格式的数据也可以转化；JSON.parse 是浏览器支持的转换方式，必须要标准的json格式才可以转换。建议使用eval方法，JSON.parse方法有时候会出错，转成了字符串而不是对象。

（3）注意：Map对象与json字符串互转比较特殊，中间需要先转化成Object对象：

   Map 转 JSON，需要先将Map转化为Object（对象）：

 _strMapToObj(strMap){
    let obj= Object.create(null);
    for (let[k,v] of strMap) {
      obj[k] = v;
    }
    return obj;
  }
  /**
  *map转换为json
  */
  _mapToJson(map) {
  return JSON.stringify(this._strMapToObj(map));
  }

JSON 转 Map：

_objToStrMap(obj){
  let strMap = new Map();
  for (let k of Object.keys(obj)) {
    strMap.set(k,obj[k]);
  }
  return strMap;
}
 /**
  *json转换为map
  */
 _jsonToMap(jsonStr){
    return this._objToStrMap(JSON.parse(jsonStr));
  }

 this.users= eval(data) || [];

 2、日期格式转换：new Date(date).format(format)

 <el-table-column prop="createTime" label="进入时间" width="150" align="left">
          <template scope="scope">{{ new Date(scope.row.createTime).format('yyyy-MM-dd hh:mm:ss') }}</template>
        </el-table-column>

3、数字转为对应序号的英文字母：

for (var i = 0; i < 26; i++) {
        console.log(String.fromCharCode((65 + i)));
    }

四、正则匹配：

使用方法：

 var reg = /^([1-9]\d*|[0]{1,1})$/;
 if (!reg.test(value)) {
       return false;
 }else{
    return true
}

常用正则表达式：

1、正整数（包括0）：/^([1-9]\d*|[0]{1,1})$/

2、正整数（不包括0）：/^\+?[1-9][0-9]*$/

3、获取小括号内的数据：

var regex1 = /\(([^)]*)\)/; // () 小括号
this.userId = this.label.match(regex1)[1];
this.userName = this.label.replace(/\([^\)]*\)/g, '');

注意这里获取的是匹配后数组的第二项[1]，第一项[0]包含了小括号 

五、对象Object常用方法： 

1、拼接对象Object.assign()

如

 let query = {
        roleId: this.roleId,
        pageSize: this.page.size,
        page: this.page.index
      };
      Object.assign(query, this.searchData);
      this.$api['user/findPageList'](query).then(data => {
        this.page.total = data.totalCount;
        this.tableData = data.dataList;
      });

六、map集合常用方法：es6提供一个对象Map，其功能类似于java中的Map,下面是java中的Map和js中的Map的简单对比：

js中的Map.set()相当于java中的Map.put(),

js中的Map.size相当于java中的Map.size()；//在js中size是属性，在Map中size()是方法。

1、遍历map对象：

  var map = [{  
             key : "百度",  
             value : "李彦宏"  },
            {
             key : "阿里巴巴",  
             value : "马云"  },
        ];  
 
for (var key in map) {  
            console.log(map[key]);  
        }
//输出结果
//Object {key : "百度", value : "李彦宏"}
//Object {key : "阿里巴巴", value : "马云"}

2、遍历map集合：

var m = new Map();
m.set(1, "black");
m.set(2, "red");
m.set("colors", 2);
//方法一：
m.forEach(function (item) {
     console.log(item.toString());
});
 
//方法二：
m.forEach(function (value, key, map) {
    console.log(value)
 })
// 输出:
// black
// red
// 2
//方法三：
for (var [key, value] of m) {
  console.log(key + ' = ' + value);
}
// 输出:
// 1 = black
// 2 = red
// colors  = 2

3、取出集合所有的key：

let list = Object.keys(map);

4、说明：js使用map时，一般不显示定义map对象，也不使用.get和.set方法去操作值，如下面的写法：

let objMap = new Map();
let obj = {"name":"张三","userId":"zhangsan"};
objMap.set('zhangsan',obj);
let obj = objMap.get('zhangsan');

一般直接使用对象的方式，改写如下：

let objMap = {};
let obj = {"name":"张三","userId":"zhangsan"};
objMap['zhangsan'] = obj ;
let obj = objMap['zhangsan'];