dojo/data/util/sorter.js

  • Provides:

    • dojo.data.util.sorter
  • dojo.data.util.sorter.basicComparator

    • type
      Function
    • parameters:
      • a: (typeof anything)
      • b: (typeof anything)
    • source: [view]
       var r = -1;
       if(a === null){
        a = undefined;
       }
       if(b === null){
        b = undefined;
       }
       if(a == b){
        r = 0;
       }else if(a > b || a == null){
        r = 1;
       }
       return r; //int {-1,0,1}
    • summary
      Basic comparision function that compares if an item is greater or less than another item
    • description
      returns 1 if a > b, -1 if a < b, 0 if equal.
      'null' values (null, undefined) are treated as larger values so that they're pushed to the end of the list.
      And compared to each other, null is equivalent to undefined.
      
      null is a problematic compare, so if null, we set to undefined.
      Makes the check logic simple, compact, and consistent
      And (null == undefined) === true, so the check later against null
      works for undefined and is less bytes.
    • returns
      int {-1,0,1}
  • dojo.data.util.sorter.createSortFunction

    • type
      Function
    • parameters:
      • sortSpec: (typeof attributes array)
        array
        A JS object that array that defines out what attribute names to sort on and whether it should be descenting or asending.
        The objects should be formatted as follows:
        {
        attribute: &quot;attributeName-string&quot; || attribute,
        descending: true|false;   // Default is false.
        }
      • store: (typeof dojo.data.core.Read)
        object
        The datastore object to look up item values from.
    • source: [view]
       var sortFunctions=[];


       function createSortFunction(attr, dir, comp, s){
        //Passing in comp and s (comparator and store), makes this
        //function much faster.
        return function(itemA, itemB){
         var a = s.getValue(itemA, attr);
         var b = s.getValue(itemB, attr);
         return dir * comp(a,b); //int
        };
       }
       var sortAttribute;
       var map = store.comparatorMap;
       var bc = dojo.data.util.sorter.basicComparator;
       for(var i = 0; i < sortSpec.length; i++){
        sortAttribute = sortSpec[i];
        var attr = sortAttribute.attribute;
        if(attr){
         var dir = (sortAttribute.descending) ? -1 : 1;
         var comp = bc;
         if(map){
          if(typeof attr !== "string" && ("toString" in attr)){
            attr = attr.toString();
          }
          comp = map[attr] || bc;
         }
         sortFunctions.push(createSortFunction(attr,
          dir, comp, store));
        }
       }
       return function(rowA, rowB){
        var i=0;
        while(i < sortFunctions.length){
         var ret = sortFunctions[i++](rowA, rowB);
         if(ret !== 0){
          return ret;//int
         }
        }
        return 0; //int
       }; // Function
    • summary
      Helper function to generate the sorting function based off the list of sort attributes.
    • description
      The sort function creation will look for a property on the store called 'comparatorMap'.  If it exists
      it will look in the mapping for comparisons function for the attributes.  If one is found, it will
      use it instead of the basic comparator, which is typically used for strings, ints, booleans, and dates.
      Returns the sorting function for this particular list of attributes and sorting directions.
    • returns
      int
  • dojo.data.util.sorter

    • type
      Object
    • summary
  • dojo.data.util

    • type
      Object
    • summary
  • dojo.data

    • type
      Object
    • summary
  • dojo

    • type
      Object
    • summary