精华内容
下载资源
问答
  • 插入,删除,添加元素 因为数组是紧密结构 时间长 数组的元素可以重复,无法让元素唯一性 数组有关联关系,可以根据自身前后找到上下数据 数组可以知道当前遍历到什么地方了 对象数据类型: key:value 键值对 ...

    Set和Map

    数组数据类型:
      数组无名有值
      根据下标记录数据  按照顺序记录
      如果需要找到某个数据,必须遍历整个数组,查找数据  时间长
      插入,删除,添加元素 因为数组是紧密结构  时间长
      数组的元素可以重复,无法让元素唯一性
      数组有关联关系,可以根据自身前后找到上下数据
      数组可以知道当前遍历到什么地方了
    
    对象数据类型:
      key:value  键值对  必须有名有值
      可以直接根据键名获取到值,不需要遍历   速度快
      键名是唯一,如果有相同键名会覆盖,但是值仍然不是唯一
      如果查找值   仍然需要遍历整个对象查找    时间长
      插入,删除,添加元素,对象本身是一个松散型结构,因此插入等操作没有关联关系,速度非常快
      因为松散结构,不具备上下数据
      对象是没有长度,所以无法知道现在遍历到第几个,是不是最后一个,是不是开始
    
    Set
    	1.Set是一个不能有重复元素的集合,重复添加无效
    	2.列表容器,没有下标,没有顺序,各数据之间没有关联
    	3.新建set:let  a=new Set()
    		a.add(value)
    			添加元素
    		a.delete(value)
    			删除元素
    		a.has(value)
    			判断是否是成员,快速查找,不需要遍历
    		a.clear()
    			清除所有数据
    	4.数组去重
    		let arr=[1,2,3,1,2,3,1,2,3];
    		let sets=new Set(arr);
    		arr=Array.from(sets);
    		console.log(arr);
    			Array.from()方法从一个类似数组或可迭代对象中创建一个新的数组实例
    	5.遍历set
    		由于没有下标,所以for循环跟for in都不行,可以使用for of和forEach
    		for(let value of a){
            	console.log(value);
        		}
    		a.forEach(function(key,value,s){
            console.log(key,value,a);
        		})
    	6.弱引用列表类型  只能添加对象类型数据
    		let b=new WeakSet();
    
    
    Map
    	1.Map类型是有长度的键值对数据类型
    	2.新建Map:let b=new Map();
    		b.set(key,value)
    			添加元素
    		b.get(key)
    			获取元素,可以根据键查找属性值
    		b.size
    			获取map的成员数
    		b.has(value)
    			判断是否是成员,只能判断是否有键名,不能判断是否有这个值
    		b.clear()
    			清除所有数据
    	3.遍历
    		(1)遍历对象(map里所有元素):
    		for(let obj of b){
        		console.log(obj);
    			}
    		(2)遍历属性名:
    		for(let str of b.keys()){
        		console.log(str);
    			}
    		(3)遍历值:
    		for(let value of b.values()){
            	console.log(value);
       			}
    		(4)返回所有成员的遍历器:
    		for(let item of b.entries()){
            	console.log(item);
        		}
    		(5)forEach遍历map
    		b.forEach((v,k,list)=>{console.log(v,k,list)})
    
    		b.forEach(function(prop,value){
       			 console.log(prop,value);
    			 });
    	4.弱引用键值对类型
    		let b=new WeakMap();
    
    展开全文
  • 一个后台系统中, 管理员要配置自定义字段后台要生成id和title,其他角色要使用自定义字段的表单, 添加数据, 但是每个要填写的对象的id 和title都是无法固定的,因此页面显示的title 和id都需要自定义数字和map对象来...
  • 1.定义一个vue空数组与一个... mapData:{},//自定义字段提交保存数据map  dbData:[  {}  ],//数据库查询出来的自定义字段  mapKey:'age',  mapValue:29,  arrayIndex:0,  arrayValue:'中国',  }; } 2..


    1.定义一个vue空数组与一个vue 空Map对象:

    data: function() {
      return{
        arrayData:[],//自定义字段中下拉框的数组
        mapData:{},//自定义字段提交保存数据的map
        dbData:[
          {}
        ],//数据库查询出来的自定义字段
    
        mapKey:'age',
        mapValue:29,
        arrayIndex:0,
        arrayValue:'中国',
      };
    }
    

    2.赋值对象:


    Map 赋值: Vue.set(this.mapData,this.mapkey,this.mapValue);
    Array 赋值: Vue.set(this.arrayData,this.arrayIndex,this.arrayValue);

    展开全文
  • 数组的访问与遍历: 访问通过访问索引下标arr[0],遍历有for、forEach、map等方法,从效率上讲,for是最快的。二维数组,又叫矩阵。二维数组的初始化,不要用fill完成const arr =(new Array(7)).fill([]),否则填充...

    概念

    • 数组的创建: 有两种方式,const arr = [1, 2, 3, 4]const arr = new Array()
    • 数组的访问与遍历: 访问通过访问索引下标arr[0],遍历有for、forEach、map等方法,从效率上讲,for是最快的。
    • 二维数组,又叫矩阵。二维数组的初始化,不要用fill完成const arr =(new Array(7)).fill([]),否则填充的是同一个数组的引用。而应该使用for来初始化。
    const len = arr.length
    for(let i=0;i<len;i++) {
        // 将数组的每一个坑位初始化为数组
        arr[i] = []
    }
    

    数组API: concat、some、join、sort、push(添加到尾部)、pop(删除尾部)、unshift(添加到头部)、shift(删除头部)、slice(返回一个截取的新数组)、splice(修改原有数组)

    splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。
    示例:

    const months = ['Jan', 'March', 'April', 'June'];
    
    // 在index 1位置插入
    months.splice(1, 0, 'Feb');
    console.log(months);        //["Jan", "Feb", "March", "April", "June"]
    
    // 在index 4位置替换
    months.splice(4, 1, 'May');
    console.log(months);        // ["Jan", "Feb", "March", "April", "May"]
    
    // 在index 2位删除一个元素
    months.splice(2, 1);
    console.log(months);        // ["Jan", "Feb", "April", "May"]
    
    // 在倒数第二2位 删除一个元素
    months.splice(-2, 1);
    console.log(months);        // ["Jan", "Feb", "May"]
    

    slice() 方法返回一个新的数组对象,这一对象是一个由 begin 和 end 决定的原数组的浅拷贝(包括 begin,不包括end)。原始数组不会被改变。
    示例:

    const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];
    
    console.log(animals.slice(2));      // ["camel", "duck", "elephant"]
    
    //从index 2位开始,到index 4结束(不包括4)返回
    console.log(animals.slice(2, 4));   // ["camel", "duck"]
    
    console.log(animals.slice(1, 5));   // ["bison", "camel", "duck", "elephant"]
    

    reduce

    reduce() 方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行),将其结果汇总为单个返回值。

    arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])

    • reducer的callback函数接收4个参数:
    1. Accumulator (acc) (累计器)
    2. Current Value (cur) (当前值)
    3. Current Index (idx) (当前索引)
    4. Source Array (src) (源数组)
      reducer 函数的返回值分配给累计器,该返回值在数组的每个迭代中被记住,并最后成为最终的单个结果值。

    回调函数第一次执行时,accumulator 和currentValue的取值有两种情况:

    • 如果调用reduce()时提供了initialValue,accumulator取值为initialValue,currentValue取数组中的第一个值;
    • 如果没有提供 initialValue,那么accumulator取数组中的第一个值,currentValue取数组中的第二个值
    //一、数组求和
    //0+1+2+3
    var total0 = [0, 1, 2, 3].reduce((acc, cur) => acc + cur)
    console.log(total0) //6
    
    //10+0+1+2+3
    var total1 = [0, 1, 2, 3].reduce((acc, cur) => acc + cur, 10)
    console.log(total1) //16
    
    var total2 = [{ x: 1 }, { x: 2 }, { x: 3 }].reduce((acc, cur) => acc + cur.x, 0)
    console.log(total2) //6
    
    var total3 = [{ x: 1 }, { x: 2 }, { x: 3 }].map(e => e.x).reduce((acc, cur) => acc + cur, 0)
    console.log(total3) //6
    
    //二、二维数组转一维数组
    var flattened = [[0, 1], [2, 3], [4, 5]].reduce(( acc, cur ) => acc.concat(cur),[]);
    console.log(flattened) //[0,1,2,3,4,5]
    

    去重

    Set

    const unique = arr => Array.from(new Set(arr))
    或
    const unique = arr => [...new Set(arr)]
    

    filter + indexOf

    const unique = arr => arr.filter((e,i)=> arr.indexOf(e) === i)
    

    Object

    const unique = arr => {
      const container = {}
      return arr.filter((e,i)=> container.hasOwnProperty(e)?false:(container[e] = true))
    }
    

    reduce

    let arr = [1, 2, 1, 2, 3, 5, 4, 5, 3, 4, 4, 4, 4]
    let result = arr.sort().reduce((acc, cur) => {
      if (acc.indexOf(cur) === -1) {
        acc.push(cur)
      }
      return acc
    }, [])
    或者
    let result2 = arr.sort().reduce((acc, cur) => {
      if (acc.length === 0 || acc[acc.length - 1] !== cur) {
        acc.push(cur)
      }
      return acc
    }, [])
    console.log(result) //[1,2,3,4,5]
    

    去除重复的值(全部去掉):

    const filterNonUnique = arr => arr.filter(i => 
      arr.indexOf(i) === arr.lastIndexOf(i)
    )
    

    扁平化

    function flat(arr) {
      if (!Array.isArray(arr)) return []
      let result = []
      for (let i = 0; i < arr.length; i++) {
        if (Array.isArray(arr[i])){
          result = result.concat(flat(arr[i]))
        }else{
          result.push(arr[i])
        }
      }
      return result
    }
    
    console.log(flat([1, 3, 'a', [4, 6, 'b', [7, 9]]]))
    //[1,3,'a',4,6,'b',7,9]
    
    或者
    function flatten(arr) {
      return arr.reduce((acc,cur)=>{
         Array.isArray(cur)?acc.concat(flatten(cur)):acc.concat(cur)
      },[])
    }
    

    双指针

    主要是利用两个或多个不同位置的指针,通过速度和方向的变换解决问题。注意这种技巧经常在排序数组中使用。

    变换奇偶数位置

    输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于数组的后半部分

    步骤:

    1. 设置两个指针,一个less一个more,
    2. 如果当前less位置的元素为偶数,那么和more位置的元素交换位置,more--,
    3. 接着继续判断交换过来的元素是否是偶数,如果继续是偶数,那么继续和more位置的元素交换,一直循环到less>=more,复杂度为O(N)
    function reOrderArr(arr) {
      if (!Array.isArray(arr)) {
        return null
      }
      let less = 0
      let more = arr.length - 1
      while(less < more){
        while (arr[less]%2==0){
          swap(arr, less, more)
          more-- //交换后more位置已经是偶像了,那么往左边前进
        }
        less++
      }
      return arr
    }
    
    function swap(arr, i, j) {
      const temp = arr[i]
      arr[i] = arr[j]
      arr[j] = temp
    }
    
    console.log(reOrderArr([2,2,1,7,5,4,6,5,8,9,0])) 
    //9,5,1,7,6,5,4,8,2,0,2
    

    进阶版:输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于数组的后半部分,
    并保证奇数和奇数,偶数和偶数之间的相对位置不变

    步骤:

    只要前面的数为偶数,当前的数为奇数,那么就一直交换位置到最前面的奇数后面,这个指针为less,
    时间复杂度为O(N),不过一直从后往前交换,交换次数较多,但是这种方法没有使用额外空间。

    function reOrderArr(arr) {
      if (!Array.isArray(arr)) {
        return null
      }
      let left = 0
      for(let i = 0; i < arr.length; i++){
        if( arr[i]%2 == 1){
          let cur = i //遇到奇数,就逐个交换到最左边奇数的后面
          while(cur > left){
            swap(arr, cur, --cur)
          }
          left++ //交换完后奇数下标右移
        }
      }
      return  arr
    }
    
    function swap(arr, i, j) {
      const temp = arr[i]
      arr[i] = arr[j]
      arr[j] = temp
    }
    
    console.log(reOrderArr([2,2,1,7,5,4,6,5,8,9,0]))
    //1,7,5,5,9,2,2,4,6,8,0
    

    和为S的两个数字

    输入一个递增排序的数组和一个数字S,在数组中查找两个数,使得他们的和正好是S,如果有多对数字的和等于S,输出两个数的乘积最小的。

    步骤:

    数组是有序的,可以使用使用大小指针求解,不断逼近结果,最后取得最终值。

    function findTwoNumber(arr, sum) {
      if (!Array.isArray(arr)) {
        return null
      }
      let left = 0
      let right = arr.length - 1
      while (left < right) {
        const s = arr[left] + arr[right]
        if (s > sum) {
          right--
        } else if (s < sum) {
          left++
        } else {
          return [arr[left], arr[right]]
        }
      }
      return []
    }
    

    和为S的连续正整数序列

    输入一个正数S,打印出所有和为S的连续正数序列。
    例如:输入15,有序1+2+3+4+5 = 4+5+6 = 7+8 = 15 所以打印出3个连续序列1-5,5-6和7-8。

    步骤:

    1. 创建一个容器container,用于表示当前的子序列,初始元素为1,2
    2. 记录子序列的开头元素left和末尾元素right
    3. right向右移动子序列末尾增加一个数 left向右移动子序列开头减少一个数
    4. 当子序列的和大于目标值,left向右移动,子序列的和小于目标值,right向右移动
    function findSerialNumber(s) {
      if (s <= 0) return []
      let result = []
      let left = 1, right = 2
      let container = [left, right]
      while (left < right) {
        let sum = sumArr(container)
        if (sum === s) {
          let targetArr = Object.assign([], container)
          result.push(targetArr)
          container.shift(left)
          left++
        } else if (sum < s) {
          right++
          container.push(right)
        } else {
          container.shift(left)
          left++
        }
      }
      return result
    }
    
    function sumArr(arr) {
      return arr.reduce(function(prev, curr, idx, arr) {
        return prev + curr
      })
    }
    
    console.log(findSerialNumber(15))
    // [ [ 1, 2, 3, 4, 5 ], [ 4, 5, 6 ], [ 7, 8 ] ]
    

    N数之和问题

    非常常见的问题,基本上都是一个套路,主要考虑如何比暴利法降低时间复杂度,而且也会用到上面的双指针技巧

    两数之和

    给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的那两个整数,并返回他们的数组下标。

    给定 nums = [2, 7, 11, 15], target = 9
    因为 nums[0] + nums[1] = 2 + 7 = 9, 所以返回 [0, 1]
    function sumTwo(arr, target) {
      if (!Array.isArray(arr)) return []
      const map = new Map()
      for (let i = 0; i < arr.length; i++) {
        let value = target - arr[i]
        if (map[value] != undefined) {
          return [map[value], i]
        } else {
          map[arr[i]] = i
        }
    
      }
      return []
    }
    
    console.log(sumTwo([2, 7, 11, 15], 9))
    //[0,1]
    

    三数之和

    给定一个包含 n 个整数的数组nums,判断 nums 中是否存在三个元素a,b,c ,使得 a + b + c = 0 ?找出所有满足条件且不重复的三元组。

    注意:答案中不可以包含重复的三元组。

    例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4],
    满足要求的三元组集合为:[[-1, 0, 1], [-1, -1, 2]]

    步骤:

    1. 为了方便去重,我们首先将数组排序
    2. 对数组进行遍历,取当前遍历的数nums[i]为一个基准数,遍历数后面的数组为寻找数组
    3. 在寻找数组中设定两个起点,最左侧的left(i+1)和最右侧的right(length-1)
    4. 判断nums[i] + nums[left] + nums[right]是否等于0,如果等于0,加入结果,并分别将left和right移动一位
    5. 如果结果大于0,将right向左移动一位,向结果逼近
    6. 如果结果小于0,将left向右移动一位,向结果逼近
    function sumThree(arr) {
      if (!Array.isArray(arr)) return []
    
      //由小到大排序
      arr.sort((a, b) => a - b)
    
      let result = []
      for (let i = 0; i < arr.length; i++) {
        let left = i + 1
        let right = arr.length - 1
    
        while (left < right) {
          const sum = arr[i] + arr[left] + arr[right]
          if (sum === 0) {
            result.push([arr[i], arr[left], arr[right]])
            break
          } else if (sum < 0) {
            left++
          } else {
            right--
          }
        }
      }
      return result
    }
    
    console.log(sumThree([-1, 0, 1, 2, -1, -4]))
    //[ [ -1, -1, 2 ], [ -1, 0, 1 ] ]
    

    四数之和

    给定一个包含 n 个整数的数组nums,判断 nums 中是否存在四个元素a,b,c,d ,使得 a + b + c + d = 0 ?找出所有满足条件且不重复的四元组。

    给定数组 nums = [1, 0, -1, 0, -2, 2],和 target = 0。
    满足要求的四元组集合为: [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

    可以像三数之和那样,我们可以通过大小指针来逼近结果,从而达到降低一层时间复杂度的效果。
    不管是几数之和,我们都用这种方法来进行优化。

    function sumFour(arr) {
      if (!Array.isArray(arr)) return []
    
      //由小到大排序
      arr.sort((a, b) => a - b)
    
      let result = []
      for (let i = 0; i < arr.length; i++) {
    
        for (let j = i + 1; j < arr.length; j++) {
          let left = j + 1
          let right = arr.length - 1
    
          while (left < right) {
            const sum = arr[i] + arr[j] + arr[left] + arr[right]
            if (sum === 0) {
              result.push([arr[i], arr[j], arr[left], arr[right]])
              break
            } else if (sum < 0) {
              left++
            } else {
              right--
            }
          }
        }
    
      }
      return result
    }
    
    console.log(sumFour([1, 0, -1, 0, -2, 2]))
    //[ [ -2, -1, 1, 2 ], [ -2, 0, 0, 2 ], [ -1, 0, 0, 1 ] ]
    

    二维数组

    构建乘积数组

    给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]A[i-1]A[i+1]A[n-1]。不能使用除法。

    步骤:

    1. B[i]的值是A数组所有元素的乘积再除以A[i],但是题目中给定不能用除法,我们换一个思路,将B[i]的每个值列出来
    2. B[i]的值可以看作下图的矩阵中每行的乘积
    3. 可以将B数组分为上下两个三角,先计算下三角,然后把上三角乘进去

    4347fc8d3dff81fb1adf8e005262cf99.png
    function multiply(arr) {
      if (!Array.isArray(arr) || !arr.length) return []
    
      let result = []
      for (let j = 0; j < arr.length; j++) {
    
        let temp = arr[j]
        arr[j] = 1
    
        result[j] = 1
        for (let i = 0; i < arr.length; i++) {
          result[j] = result[j] * arr[i]
        }
        arr[j] = temp
      }
      return result
    }
    
    console.log(multiply([1, 2, 3, 4, 5, 6, 7, 8]))
    
    //[40320,20160,13440,10080,8064,6720,5760,5040]
    
    

    数据统计

    出现次数超数组一半的数字

    数组中有一个数字出现的次数超过数组长度的一半,请找出这个数字。例如输入一个长度为9的数组[1,2,3,2,2,2,5,4,2]
    由于数字2在数组中出现了5次,超过数组长度的一半,因此输出2。如果不存在则输出0。

    function counterGreaterThanHalf(arr) {
      if (!Array.isArray(arr) || !arr.length) return 0
    
      const half = arr.length / 2
      const map = new Map()
      for (let i = 0; i < arr.length; i++) {
        if (!map[arr[i]]) {
          map[arr[i]] = 1
        } else {
          map[arr[i]] = map[arr[i]] + 1
        }
      }
    
      let target = 0
      Object.keys(map).forEach(k => {
        if (map[k] > half) {
          target = k
          return k
        }
      })
      return target
    }
    
    console.log(counterGreaterThanHalf([1, 2, 3, 2, 2, 2, 5, 4, 2]))
    

    连接子数组的最大和

    输入一个整型数组,数组里有正数也有负数。数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值,要求时间复杂度为O(n)

    例如:[6,-3,-2,7,-15,1,2,2],连续子向量的最大和为8(从第0个开始,到第3个为止)

    步骤:

    1. 记录一个当前连续子数组最大值 max 默认值为数组第一项
    2. 记录一个当前连续子数组累加值 sum 默认值为数组第一项
    3. 从数组第二个数开始,若 sum<0 则当前的sum不再对后面的累加有贡献,sum = 当前数
    4. 若 sum>0 则sum = sum + 当前数
    5. 比较 sum 和 max ,max = 两者最大值
    function findGreatestSubArr(arr) {
      if (!Array.isArray(arr) || !arr.length) return []
    
      let max = arr[0]
      let sum = arr[0]
    
      for (let i = 1; i < arr.length; i++){
        if (sum < 0) {
          sum = arr[i];
        } else {
          sum = sum + arr[i];
        }
        if (sum > max) {
          max = sum;
        }
      }
      return max
    }
    
    console.log(findGreatestSubArr([6, -3, -2, 7, -15, 1, 2, 2]))
    //8
    

    扑克牌顺子

    扑克牌中随机抽5张牌,判断是不是一个顺子,即这5张牌是不是连续的。
    2-10为数字本身,A为1,J为11…大小王可以看成任何数字,可以把它当作0处理

    步骤:

    1. 字符串映射成数字
    2. 数组从小到大排序
    3. 判断数组末位比首位大4,则是连接的,否则不连续
    function IsContinuous(arr) {
      if (!Array.isArray(arr) || !arr.length) return []
    
      let result = false
      for (let i = 0; i < arr.length; i++) {
        if (arr[i] === 'A') arr[i] = 1
        else if (arr[i] === 'J') arr[i] = 11
        else if (arr[i] === 'Q') arr[i] = 12
        else if (arr[i] === 'K') arr[i] = 13
        else if (Number.isInteger(arr[i])) arr[i] = arr[i]
        else arr[i] = 0
      }
    
      arr.sort((a, b) => a - b)
    
      if(arr[arr.length - 1] - arr[0] == 4){
        result = true
      }
      return result
    }
    
    console.log(IsContinuous(['Q', 3, 'A', 2, 5]))
    

    首个只出现一次的字符

    在一个字符串(0<=字符串长度<=10000,全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回-1(需要区分大小写)

    思路1:

    1. 用一个map存储每个字符出现的字数
    2. 第一次循环存储次数,第二次循环找到第一个出现一次的字符。
      时间复杂度O(n)、空间复杂度O(n)

    思路二:

    1. 使用js的array提供的indexOf和lastIndexOf方法
    2. 遍历字符串,比较每个字符第一次和最后一次出现的位置是否相同。
      indexOf的时间复杂度为O(n),所以整体的时间复杂度为O(n2),空间复杂度为0
    function findFirstOnlyOneLetter(str) {
      if (!str) return -1
      const map = new Map()
      const arr = str.split('')
      for (let i = 0; i < arr.length; i++) {
        if (map[arr[i]]) {
          map[arr[i]] = map[arr[i]] + 1
        } else {
          map[arr[i]] = 1
        }
      }
      for (let i = 0; i < arr.length; i++) {
        if (map[arr[i]] === 1)
          return i
      }
      return -1
    }
    
    console.log(findFirstOnlyOneLetter('ggsafDZFaesrewa'))
    //4
    
    function findFirstOnlyOneLetter(str) {
      if (!str) return -1
    
      const arr = str.split('')
      for (let i = 0; i < arr.length; i++) {
        const indexOf = arr.indexOf(arr[i])
        const lastIndexOf = arr.lastIndexOf(arr[i])
        if (indexOf === lastIndexOf) {
          return i
        }
      }
      return -1
    }
    
    console.log(findFirstOnlyOneLetter('ggsafDZFaesrewa'))
    //4
    展开全文
  • -- forEach : 用来循环 collection : 用来指定循环的数据的类型 可以填的值有:array,list,map, item : 循环中为每个循环的数据指定一个别名; index : 循环中循环的下标; open : 开始; close : 结束; s.
    //dao层接口
    public interface AdjustMapper{
        int dels(Integer[] ids)
    }
    
    

    mapper.xml文件

    <!--批量删除-->
    <!-- forEach : 用来循环 collection : 用来指定循环的数据的类型 可以填的值有:array,list,map,
             item : 循环中为每个循环的数据指定一个别名; index : 循环中循环的下标; open : 开始; close : 结束; separator : 数组中元素之间的分隔符 -->
    <delete id ="dels" parameterType="int[]">
        delete from adjust where id in
        <foreach collection="array" item="id" open="(" separator="," close=")">
            #{id}
        </foreach>
    </delete>

    controller层

     @RequestMapping("/dels")
        @ResponseBody
        public ResultObj dels(Integer[] ids) {
            try {
                adjustService.dels(ids);
                return ResultObj.DELETE_SUCCESS;
            } catch (Exception e) {
                e.printStackTrace();
                return ResultObj.DELETE_ERROR;
            }
        }

     

    展开全文
  • 一个后台系统中, 管理员要配置自定义字段后台要生成id和title,其他角色要使用自定义字段的表单, 添加数据, 但是每个要填写的对象的id 和title都是无法固定的,因此页面显示的title 和id都需要自定义数字和map对象来...
  • 几个常用的数据结构: ...数组是一个紧密型结构,如果要删除,添加,插入都需要重新排列每个元素,会涉及到时间复杂度; 数组中的元素都是有关系的,可以从找到这个元素向上或者向下找到关联位置的元素 ...
  • Pop:删除数组中的最后一个元素。 如果目标数组构建完成,就停止读取更多元素。 题目数据保证目标数组严格递增,并且只包含 1 到 n 之间的数字。 请返回构建目标数组所用的操作序列。 题目数据保证答案是唯一的。 ...
  • 方法,list 查询的所有数据,listSplit18 过滤后获得的数据 public void get18List(List<Map<String, Object>> list, List<List<Map<String,Object>>> listSplit18, int num){ // ...
  • ```bash var arr1=[{id:1},{id:2},{id:3},{id:4},{id:5}] ...var set=arr2.map(item=>item.id) console.log(set) var resArr=arr1.filter(item=>!set.includes(item.id)) console.log(resArr) ```
  • // 快速删除的方式:涉及到两个方法: map filter // 1.0 得到我的频道数据中所有元素的 id 集合 var ids = myChannel.map(item => { return item.id }) console.log(ids) // [0, 1, 3] // 2.0 遍历所遥频道数数组:...
  • js数据结构——数组

    2020-09-05 16:33:07
    数组数组的含义与特点、为什么要用数组什么是数组数组的特点为什么要用数组数组的声明与初始化最广泛的...数组删除末尾删除使用pop方法开头删除使用shift删除任意位置删除和增加splice删除元素delete运算符删除元素...
  • 删除数组元素 let arr = ['a', 'b', 'c'] // 删除'c' arr = arr.filter(i => { return i != 'c' }) $set 有些情况下,仅仅通过“=”号来赋值,无法触发数据的实时更新,这个时候用$set就可以。 this.$set(obj, ...
  • 一、单元(cell)数组类型 ...用class()查看元素的数据类型 元胞数组的合并 删除某个单元 reshape函数的使用 二、map容器类型 容器:container 一个map容器是map类的一个对象,里面有多个键值对,keys/value...
  • unique_set := make(map[int] bool, len(list)) for _, x := range list { unique_set[x] = true } result := make([]int, len(unique_set)) i := 0 for x := range unique_set { result[i] = x i++ } ...
  • 首页来个简单的,javascript提供了数据结构的对象,Array,只有添加方法,却不可以针对元素下表来进行元素的删除。上代码吧。 [code="java"]Array.prototype.del=function(n) { //n表示第几项,从0开始...
  • 这篇文章主要是通过一个问题实现过程,选择合适的数据结构,结合之前介绍过的基于二分搜索树实现的映射(Map)和最小堆两种数据结构,可以将问题实现过程的时间复杂度降低。1. 问题描述给定一个非空的整数数组,返回...
  • 先说需求 在一个表单中有两个下拉框,都是访问同一个接口拿到树结构的List数据后动态绑定的到各自的下拉框,区别在于A...思路:从数据结构来分析这是个包含了所有根节点和子节点数据的treeList数组对象。B下拉...
  • 将已经添加的图片的图片ID合为一个数组,然后全部图片的数据使用filter过滤 let arr=this.pictrueList.map(ee=>ee.picture_id) this.companyVideoList=res.data.filter(ee=>!arr.includes(ee.id)) 这样就...
  • 常用数组方法

    2019-11-14 15:59:46
    常用数组方法 1.删除数组的重复项 ...6 用数据填充数组 7 数组合并 8 求两个数组的交集 9 从数组删除虚值 10 从数组中获取随机值 11 反转数组 12 lastIndexOf() 方法 13 对数组中的所有值求和 ...
  • 数组 总结

    2019-08-18 20:41:53
    改变原数组的方法 删除类型 push pop shift unift splice sort 类数组 变为数组 获取多个元素 类数组 函数形参集合 arguments ... (2)可遍历(iterable)的对象(包括ES6 新增的数据结构Set 和Map) ...
  • var ids = checkedBoxs.map(function(){ return this.value; }) $.ligerDialog.confirm("确认要删除吗?","删除用户",function(r){ if(r){ alert("删除:"+ids.get()); // 发送请求 window.location...
  • return Object.assign({}, ...props.map(prop => ({[prop]: o[prop]}))); } //删除列 function omit(o, props) { return Object.keys(o) .filter((key) => props.indexOf(key) < 0) .reduce((newObj,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,066
精华内容 426
关键字:

数组map删除数据