精华内容
下载资源
问答
  • js 匹配对象

    2019-12-13 17:44:10
    场景:有数组arr,需要根据obj对象里面的managerId来排序arr数组的顺序,如果obj里面的managerId在arr数组里面是在第4位,就把arr里面的第四个数据排序到第一个来,代码如下: <script> var arr = [{ ...

    场景:有数组arr,需要根据obj对象里面的managerId来排序arr数组的顺序,如果obj里面的managerId在arr数组里面是在第4位,就把arr里面的第四个数据排序到第一个来,代码如下:

    <script>
        var arr = [{
            managerId: "xiaohong",
            managerName: "小红"
        }, {
            managerId: "xiaobai",
            managerName: "小白"
        }, {
            managerId: "xiaohuang",
            managerName: "小黄"
        }, {
            managerId: "xiaozhang",
            managerName: "小张"
        }, {
            managerId: "xiaolan",
            managerName: "小兰"
        }, {
            managerId: "xiaopan",
            managerName: "小潘"
        }, {
            managerId: "xiaodeng",
            managerName: "小登"
        }, {
            managerId: "xiaoshui",
            managerName: "小水"
        }]
    
        var obj = {
            clientSource: "4",
            createBy: "robot",
            createDate: "2019-12-12 00:00:00",
            managedId: "C654771945891958805",
            managedName: "童乐俊",
            managerId: "xiaobai",
            managerName: "小白",
        }
        var newArr = [];
        var newObj = '';
       // 有两种犯法,第一种:
        // newArr = arr.filter(item => {
        //     if (obj.managerId == item.managerId) {
        //         newObj = item;
        //     }
        //     return item.managerId != obj.managerId;
        // });
        // if (newObj) {
        //     newArr.unshift(newObj)
        // }
        // console.log(newArr)
      // 有两种犯法,第二种:
        var k = 1;
        for (let i = 0; i < arr.length; i++) {
            if (arr[i].managerId == obj.managerId) {
                newArr[0] = arr[i]
            } else {
                newArr[k++] = arr[i]
            }
        }
        console.log(newArr)
    </script>
    

    有更好的建议欢迎留言评论,谢谢~
    本文纯属原创,转载请注明出处

    展开全文
  • javascript 对象数组排序

    万次阅读 2014-01-04 21:55:17
    javascript 对象数组排序 作者: admin 日期: 二月 13, 2011发表评论 (3)查看评论 javascript实现多维数组、对象数组排序,其实用的就是原生的sort()方法,用于对数组的元素进行排序。 其基本的...

    javascript 对象数组排序

    javascript实现多维数组、对象数组排序,其实用的就是原生的sort()方法,用于对数组的元素进行排序。

    其基本的用法就不说了,先看个简单的排序例子:

    1
    2
    3
    //Sort alphabetically and ascending:
    var myarray=[ "Bob" , "Bully" , "Amy" ]
    myarray.sort() //Array now becomes ["Amy", "Bob", "Bully"]

    数组直接调用sort()后,数组按字母顺序对数组中的元素进行排序,说得更精确点,是按照字符编码的顺序进行排序。

    再来看看数字的排序:

    1
    2
    3
    //Sort numerically and ascending:
    var myarray=[25, 8, 7, 41]
    myarray.sort( function (a,b){ return a - b}) //Array now becomes [7, 8, 25, 41]

    sort(fun)接受了个排序规则函数,这个函数将比较2个数字的大小。而我们的对象数组排序,实际上原理也是一样的。

    对于对象数组排序,我们先写一个构造比较函数的函数:

    01
    02
    03
    04
    05
    06
    07
    08
    09
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    //by函数接受一个成员名字符串做为参数
    //并返回一个可以用来对包含该成员的对象数组进行排序的比较函数
    var by = function (name){
         return function (o, p){
             var a, b;
             if ( typeof o === "object" && typeof p === "object" && o && p) {
                 a = o[name];
                 b = p[name];
                 if (a === b) {
                     return 0;
                 }
                 if ( typeof a === typeof b) {
                     return a < b ? -1 : 1;
                 }
                 return typeof a < typeof b ? -1 : 1;
             }
             else {
                 throw ( "error" );
             }
         }
    }

    要排序的数组:

    1
    2
    3
    4
    5
    var employees=[]
    employees[0]={name: "George" , age:32, retiredate: "March 12, 2014" }
    employees[1]={name: "Edward" , age:17, retiredate: "June 2, 2023" }
    employees[2]={name: "Christine" , age:58, retiredate: "December 20, 2036" }
    employees[3]={name: "Sarah" , age:62, retiredate: "April 30, 2020" }

    直接调用函数:

    1
    employees.sort(by( "age" ));

    到这里,对象数组排序就算基本实现了。那如何实现多个键值排序呢?意思就是先是对age排序,如果age相同,再比较name。

    这时,我们可以进一步修改by函数,让其可以接受第二个参数,当主要的键值产生一个匹配的时候,另一个compare方法将被调用以决出高下。

    01
    02
    03
    04
    05
    06
    07
    08
    09
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    //by函数接受一个成员名字符串和一个可选的次要比较函数做为参数
    //并返回一个可以用来包含该成员的对象数组进行排序的比较函数
    //当o[age] 和 p[age] 相等时,次要比较函数被用来决出高下
    var by = function (name,minor){
         return function (o,p){
             var a,b;
             if (o && p && typeof o === 'object' && typeof p === 'object' ){
                 a = o[name];
                 b = p[name];
                 if (a === b){
                     return typeof minor === 'function' ? minor(o,p):0;
                 }
                 if ( typeof a === typeof b){
                     return a <b ? -1:1;
                 }
                 return typeof a < typeof b ? -1 : 1;
             } else {
                 thro( "error" );
             }
         }
    }
     
    employees.sort(by( 'age' ,by( 'name' )));

    好了,现在可以放心使用了。如果看不懂,可直接copy 这个by函数到你的应用里面,直接调用即可。

    展开全文
  • 2.可以先将所有数进行排序,从最大值和最小值开始匹配再根据和目标值的比较移动,知道找到结果,时间复杂度为O(nlog(n)) 知识点:comparable 接口的使用,利用其进行对象的自然排序,相关文章 pub

    题目two num

    题意:给定一个整数数组和一个目标值,要求在数组中找到两个数,使得它们的和相加等于目标值,并且返回两个数的下标

    思路:1.如果使用暴力,时间复杂度为O(n^2)

    2.可以先将所有数进行排序,从最大值和最小值开始匹配再根据和目标值的比较移动,知道找到结果,时间复杂度为O(nlog(n))

    知识点:comparable 接口的使用,利用其进行对象的自然排序,相关文章

    public class Solution { 
            static class Node implements Comparable<Node>{
            	int val,index;
            	public Node(int v,int i){
            		val = v;
            		index = i; 
            	}
            	public int compareTo(Node o){
            		return this.val - o.val;
            	}
            }
            public int[] twoSum(int[] numbers,int target){
            	int[] xy = new int[2];
            	Node[] nodes = new Node[numbers.length];
            	for(int i = 0;i < numbers.length;i++){
            		nodes[i] = new Node(numbers[i],i+1);
            	}
            	Arrays.sort(nodes);
            	int i = 0,j = numbers.length-1;
            	while(i < j){
            		if(nodes[i].val+nodes[j].val == target){
            			break; 
            		}
            		else if(nodes[i].val+nodes[j].val < target)
            			i++;
            		else
            			j--;
            	} 
            	xy[0] = nodes[i].index <= nodes[j].index ? nodes[i].index : nodes[j].index;
            	xy[1] = nodes[i].index > nodes[j].index?nodes[i].index:nodes[j].index;
            	return xy;
            }
        } 


    展开全文
  • Javascript中的数组对象排序

    千次阅读 2018-05-26 14:37:53
    一、普通数组排序  js中用方法sort()为数组排序。sort()方法有一个可选参数,是用来确定元素顺序的函数。如果这个参数被省略,那么数组中的元素将按照ASCII字符顺序进行排序。如: var arr = [&quot;a&...

    一、普通数组排序  

    js中用方法sort()为数组排序。sort()方法有一个可选参数,是用来确定元素顺序的函数。如果这个参数被省略,那么数组中的元素将按照ASCII字符顺序进行排序。如:

    var arr = ["a", "b", "A", "B"];
    arr.sort();
    console.log(arr);//["A", "B", "a", "b"]

    因为字母A、B的ASCII值分别为65、66,而a、b的值分别为97、98,所以上面输出的结果是 ["A", "B", "a", "b"]

    如果数组元素是数字呢,结果会是怎样?

    var arr = [15, 8, 25, 3];
    arr.sort();
    console.log(arr);//[15, 25, 3, 8]

    结果是 [15, 25, 3, 8] 。其实,sort方法会调用每个数组项的toString()方法,得到字符串,然后再对得到的字符串进行排序。虽然数值15比3大,但在进行字符串比较时”15”则排在”3”前面。显然,这种结果不是我们想要的,这时,sort()方法的参数就起到了作用,我们把这个参数叫做比较函数。

    比较函数接收两个参数,如果第一个参数应该位于第二个之前则返回一个负数,如果两个参数相等则返回0,如果第一个参数应该位于第二个之后则返回一个正数。例子:

    var arr = [23, 9, 4, 78, 3];
    var compare = function (x, y) {//比较函数
        if (x < y) {
            return -1;
        } else if (x > y) {
            return 1;
        } else {
            return 0;
        }
    }
    console.log(arr.sort(compare));        

    结果为 [3, 4, 9, 23, 78] ,返回了我们想要的结果。如果要按降序排序,比较函数写成这样即可:

    var compare = function (x, y) {
        if (x < y) {
            return 1;
        } else if (x > y) {
            return -1;
        } else {
            return 0;
        }
    }

    我们并不能用比较函数比较一个不能转化为数字的字符串与数字的顺序:

    var arr = ["b", 5];
    console.log(arr.sort(compare))

    结果是 ["b", 5] 。因为比较函数在比较时,会把先把字符串转化为数字,然后再比较,字符串b不能转化为数字,所以就不能比较大小。然而,当不用比较函数时,会比较ASCII值,所以结果是 [5, "b"]

    二、数组对象排序

    如果数组项是对象,我们需要根据数组项的某个属性对数组进行排序,要怎么办呢?其实和前面的比较函数也差不多:

    var arr = [{name: "zlw", age: 24}, {name: "wlz", age: 25}];
    var compare = function (obj1, obj2) {
        var val1 = obj1.name;
        var val2 = obj2.name;
        if (val1 < val2) {
            return -1;
        } else if (val1 > val2) {
            return 1;
        } else {
            return 0;
        }            
    } 
    console.log(arr.sort(compare));

    输出结果为 [Object { name="wlz", age=25}, Object { name="zlw", age=24}] ,可以看到数组已经按照 name 属性进行了排序。我们可以对上面的比较函数再改造一下:

    var compare = function (prop) {
        return function (obj1, obj2) {
            var val1 = obj1[prop];
            var val2 = obj2[prop];if (val1 < val2) {
                return -1;
            } else if (val1 > val2) {
                return 1;
            } else {
                return 0;
            }            
        } 
    }

    如果想按照 age 进行排序, arr.sort(compare("age")) 即可。

    但是对age属性进行排序时需要注意了,如果age属性的值是数字,那么排序结果会是我们想要的。但很多时候我们从服务器传回来的数据中,属性值通常是字符串。现在我把上面的数组改为:

    var arr = [{name: "zlw", age: "24"}, {name: "wlz", age: "5"}];

    可以看到,我把 age 属性由数字改为了字符串,第二个数组项的 age 值改为了 “5” 。再次调用 arr.sort(compare("age")) 后,结果为:

    [Object { name="zlw", age="24"}, Object { name="wlz", age="5"}]

    我们的期望是5排在24前面,但是结果不是。这是因为当两个数字字符串比较大小时,会比较它们的ASCII值大小,比较规则是:从第一个字符开始,顺次向后直到出现不同的字符为止,然后以第一个不同的字符的ASCII值确定大小。所以”24”与”5”比较大小时,先比较”2“与”5”的ASCII值,显然”2“的ASCII值比”5”小,即确定排序顺序。

    现在,我们需要对比较函数再做一些修改:

    var compare = function (prop) {
        return function (obj1, obj2) {
            var val1 = obj1[prop];
            var val2 = obj2[prop];
            if (!isNaN(Number(val1)) && !isNaN(Number(val2))) {
                val1 = Number(val1);
                val2 = Number(val2);
            }
            if (val1 < val2) {
                return -1;
            } else if (val1 > val2) {
                return 1;
            } else {
                return 0;
            }            
        } 
    }

    在比较函数中,先把比较属性值转化为数字 Number(val1) 再通过 !isNaN(Number(val1)) 判断转化后的值是不是数字(有可能是NaN),转化后的值如果是数字,则比较转换后的值,这样就可以得到我们想要的结果了, 调用 arr.sort(compare("age")) 得到:

    [Object { name="wlz", age="5"}, Object { name="zlw", age="24"}]

    可以看到,确实是按正确的方式排序了。


    Js数组排序函数sort()介绍

    JavaScript实现多维数组、对象数组排序,其实用的就是原生的sort()方法,用于对数组的元素进行排序。
    sort() 方法用于对数组的元素进行排序。语法如下:

    arrayObject.sort(sortby)

    返回值为对数组的引用。请注意,数组在原数组上进行排序,不生成副本。
    如果调用该方法时没有使用参数,将按字母顺序对数组中的元素进行排序,说得更精确点,是按照字符编码的顺序进行排序。要实现这一点,首先应把数组的元素都转换成字符串(如有必要),以便进行比较。
    如果想按照其他标准进行排序,就需要提供比较函数,该函数要比较两个值,然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b,其返回值如下:

    • 若 a 小于 b,在排序后的数组中 a 应该出现在 b 之前,则返回一个小于 0 的值。
    • 若 a 等于 b,则返回 0。
    • 若 a 大于 b,则返回一个大于 0 的值。
    function NumAscSort(a,b)
    {
     return a - b;
    }
    function NumDescSort(a,b)
    {
     return b - a;
    }
    var arr = new Array( 3600, 5010, 10100, 801); 
    arr.sort(NumDescSort);
    alert(arr);
    arr.sort(NumAscSort);
    alert(arr);
    

    sort(fun)接受了个排序规则函数,这个函数将比较2个数字的大小。而我们的对象数组排序,实际上原理也是一样的。
    如果不比较数字的大小,则可以这样:

    var myarray=["Apple", "Banana", "Orange"]
    myarray.sort()

    数组直接调用sort()后,数组按字母顺序对数组中的元素进行排序,说得更精确点,是按照字符编码的顺序进行排序。
    对于对象数组排序,我们先写一个构造比较函数的函数:

    //by函数接受一个成员名字符串做为参数
    //并返回一个可以用来对包含该成员的对象数组进行排序的比较函数
    var by = function(name){
     return function(o, p){
       var a, b;
       if (typeof o === "object" && typeof p === "object" && o && p) {
         a = o[name];
         b = p[name];
         if (a === b) {
           return 0;
         }
         if (typeof a === typeof b) {
           return a < b ? -1 : 1;
         }
         return typeof a < typeof b ? -1 : 1;
       }
       else {
         throw ("error");
       }
     }
    }

    要排序的数组:

    var employees=[]
    employees[0]={name:"George", age:32, retiredate:"March 12, 2014"}
    employees[1]={name:"Edward", age:17, retiredate:"June 2, 2023"}
    employees[2]={name:"Christine", age:58, retiredate:"December 20, 2036"}
    employees[3]={name:"Sarah", age:62, retiredate:"April 30, 2020"}

    直接调用函数:

    employees.sort(by("age"));

    到这里,对象数组排序就算基本实现了。那如何实现多个键值排序呢?意思就是先是对age排序,如果age相同,再比较name
    这时,我们可以进一步修改by函数,让其可以接受第二个参数,当主要的键值产生一个匹配的时候,另一个compare方法将被调用以决出高下。

    //by函数接受一个成员名字符串和一个可选的次要比较函数做为参数
    //并返回一个可以用来包含该成员的对象数组进行排序的比较函数
    //当o[age] 和 p[age] 相等时,次要比较函数被用来决出高下
    var by = function(name,minor){
     return function(o,p){
       var a,b;
       if(o && p && typeof o === 'object' && typeof p ==='object'){
         a = o[name];
         b = p[name];
         if(a === b){
           return typeof minor === 'function' ? minor(o,p):0;
         }
         if(typeof a === typeof b){
           return a < b ? -1:1;
         }
         return typeof a < typeof b ? -1 : 1;
       }else{
         thro("error");
       }
     }
    }
    
    employees.sort(by('age',by('name')));
    展开全文
  • list stream按照对象多个属性进行排序

    千次阅读 2019-11-12 16:24:38
    /** * 如果需要多条件排序,thenComparing(),对于排序完的结果还可以接着操作 *先按照年龄排序,再按照名称排序 */ List collect = personList.stream() .sorted(Comparator.comparing(Person::getAge)....
  • 周末无聊利用swapNode方法写了个排序算法,性能比较一般,超简单的冒泡排序,但是由于使用了swapNode,所以TR以及TD对象后绑定的属性不会丢失,同时解决了checkbox在swapNode后丢失值的问题,支持数字排序,日期排序,利用...
  • ElasticSearch (ES)学习之路(五)ES 复杂搜索( 匹配 过滤 精准 排序 高亮) 在上文中,我们查询小红 其kinbana 语法是这样写的 GET /lei/one/_search?q=name:小丽 前文中,也是做了分析,由于有多个包含‘小丽’...
  • 直接上代码: var list ...*排序后的结果 [ {name: "北京", code: "beijing"}, {name: "西安", code: "xian"}, {name: "上海", code: "shanghai"} , {name: "深圳", code: "shenzhen"} ] */
  • 需求:根据用户输入的关键字(中英文区别,)然后根据关键字进行匹配,根据匹配度高低进行排序  SELECT * FROM gt_poi where  cn_name like CONCAT('%','${cnName}','%' ) or   en_name like CONCAT('%','${...
  • js对象中的key按照a-z排序

    万次阅读 2017-01-14 10:47:22
    <!DOCTYPE html> <html> , maximum-scale=1.0, user-scalable=no" /> <title>js对象中的key按照a-z排序</title>
  • package com.ysj.control; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; import com.alibaba.fastjson.JSON;...
  • 2 Query和QueryParser 2.1 创建查询的两种方法 创建查询 对要搜索的信息创建Query查询对象,Lucene会根据Query查询对象生成最终的查询语法,类似关系数据库Sql语法一样Lucene也有自己的查询语法,比如:“name:...
  • 匹配问题

    千次阅读 2018-09-22 15:17:49
    匹配问题匹配问题中的重要概念GS算法GS算法的几个特性 匹配问题中的重要概念 匹配,假设有男人的集合M和女人的集合W,每个男人向女人W求婚,并且两个人成功组成一对,就叫做匹配。 完美匹配,假设集合M和集合W的...
  • Cursor排序

    千次阅读 2016-06-06 18:41:21
    数据库搜索联系人‘张’搜索出的结果按照关键字匹配先后进行排序,把‘张三’放在‘小张’前面。 而数据库可实现的是按照拼音首字母排序‘小张’排在‘张三’前面。需要对获取的Cursor再进行排序。但由于Cursor无法...
  • 一、需求:读取txt文件内容按成绩排序后输出 二、分析步骤: 创建txt学生信息文件 创建学生类 创建字符缓冲输入流对象 创建ArrayList集合 调用缓冲输入流对象的方法读取数据 把读取到的字符串数据读取到集合中 释放...
  • BZ1_排序1_冒泡排序

    千次阅读 2020-11-25 14:01:00
    算法思想 简单可以理解为 位置匹配 元素, 对于N个元素,需要进行N - 1 轮排序,即for(int i = a.length - 1 ;i>0;i--){...}, 即每轮确定 一个 当前序列 的 最大值元素a[0 ~ i - 1],放到 当前序列的末尾a[i],...
  • [ [:“双方括号”仅可用于提取单一元素,并且用来提取列表或者数据框中的元素,但是,由于列表或者数据框中的元素类别不唯一,因此它返回对象的类型不一定是列表或者数据框 $ :“美元符号”是提取有名字的列表或...
  • 10.MIL中灰度匹配(Pattern)

    千次阅读 2014-03-31 11:57:19
    上节已经提到,图像处理中的匹配包括灰度匹配和几何匹配。灰度匹配主要原理是一对一的像素比对,算法实现是计算两个图像的相关,容易理解,实现容易,但是计算量太大且鲁棒性较差。...分配对象->设置对象->(预处理对象
  • 模板匹配,特征点匹配-全

    千次阅读 2019-07-09 23:46:33
    模板匹配:模板匹配是一种最原始、最基本的模式识别方法,研究某一特定对象物的图案位于图像的什么地方,进而识别对象物,这就是一个匹配问题。它是图像处理中最基本、最常用的匹配方法。模板匹配具有自身的局限性,...
  • opencv+python实现图像匹配----模板匹配、特征点匹配

    万次阅读 多人点赞 2019-02-12 16:30:46
    文章目录模板匹配与特征匹配python的版本及依赖的库的安装opencv+python模板匹配[^1]匹配材料Template Matchingopencv+python特征匹配[^2]匹配材料BFMatching描述特征点--运行结果不精确基于FLANN的匹配器(FLANN ...
  • 图像匹配匹配点筛选

    千次阅读 2019-07-10 17:47:11
    特征点匹配+特征检测方法汇总 转载于:https://www.cnblogs.com/Jessica-jie/p/8622449.html 特征提取与匹配---SURF;SIFT;ORB;FAST;Harris角点 匹配方法 匹配函数 1. OpenCV提供了两种Matching方式: ...
  • Glob Patterns匹配模式使用

    千次阅读 2018-12-29 23:45:08
    前段时间在用workbox时,在做precache时,匹配模式基于的是Glob Pattern模式,于是就看了下相关文档。 下面翻译一下node-glob的使用,原文:https://github.com/isaacs/node-glob#glob-primer Glob 像在shell里面,...
  • 利用jQuery对无序列表排序的原理是:获取到无序列表中的所有列表项,并转成数组形式,使用JavaScript函数对其进行排序后再次输出。其中使用到的jQuery函数有ready()、get()、text()、each()、append()和JavaScript...
  • JS的对象与内置对象详细介绍

    万次阅读 多人点赞 2019-07-06 23:53:50
    JS的对象就是Object,还有独立于宿主环境的ECMAScript实现提供的内置对象:Array,String,Date,Math。。。 首先我们来学习一下JS的对象: Object: JS里有一句话叫万物皆对象(除了基本数据类型)。但是new String(’...
  • 深入理解快速排序算法的稳定性

    万次阅读 2014-04-30 11:30:06
    在初次接触排序算法稳定性这个概念时,我一直认为复杂度为O(n2)的算法是稳定的,复杂度为O(nlogn)的算法是不稳定的。当时是这样理解的,复杂度为O(n2)的算法不可能再坏,而复杂度为O(nlogn)的算法在极端情况下可能会...
  • 通常来说动物的物理年龄与其生理年龄是不匹配的,如果要严格的根据动物的生理年龄排序需要有一个具体的参照(例如人)。下面列出了狗和人以及猫和人的年龄对照表。 狗 1 2 3 ...
  • 机器学习排序之Learning to Rank简单介绍

    万次阅读 多人点赞 2015-01-03 21:50:25
    最近需要完成课程作业——分布式排序学习系统.它是在M/R、Storm或Spark架构上搭建分布式系统,并使用学习排序Pointwise、Pairwise和Listwise三大类算法实现对微软数据集(Microsoft Learning to Rank Datasets)进行...
  • JavaScript 内置对象解读

    千次阅读 2015-10-27 22:51:10
    JavaScript 是面向对象的编程语言 (OOP)。OOP 语言使我们有能力自定义对象和变量类型。(事实上,只是基于对象的,并不完全具备面向对象的语言的三大特性[封装、继承、多态])。面向对象编程 在高级 JavaScript 的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 185,808
精华内容 74,323
关键字:

对象信息匹配排序