Javascript 网格柱型

我想为SlickGrid过滤器做自己的过滤功能，它通常是统一的，可以在99%中使用。我在Slickgrid中遗漏了什么-列中使用了哪种类型的数据？也许它一直存在，但在查阅资料后我没有找到。如果存在的话，我会很感激你指引我走向真正的道路。圆滑，编辑类型？但如果专栏不是用来编辑的
在SlickGrid示例中，我们通常使用不允许使用数据类型的过滤器，仅存在一些具有具体字段Id的示例。我们通常使用的数据是字符、日期、布尔值和NUM。 对于nums类型，我希望使用和其他数字操作数符号改进过滤器，对于日期类型也可以这样做。此时，我只能使用字段ID来实现这一点——我可以使用字段ID和类型来指导自己的全局数组，然后从中识别列的类型。但这个解决方案还不清楚——最好是从网格中检测列类型

非常感谢您的帮助和想法

增加：

经过一些搜索发现，我可以使用SlickGrid数据值类型。我是Javascript的新手，所以欢迎提供任何帮助和建议来改进下面的源代码…：-）

以下是我的资料来源：

 function filter( item ) 
  {
     for ( var columnId in colFilt ) 
     {
        if ( columnId !== undefined && colFilt[ columnId ] !== "" ) 
        {
           var c   = grid.getColumns()[ grid.getColumnIndex( columnId ) ];
           var typ = varType( item[ c.field ] );
           if ( typ == "N" || typ == "D" ) 
           {
              var arr = date_num_filter( colFilt[ columnId ] )
              if ( arr.length > 0 )
              {
                 if ( arr.length == 2 )
                 {
                    switch ( arr[ 0 ] )
                    {
                       case "<" : 
                          if ( item[ c.field ] >= arr[ 1 ] )
                              return false;
                          break;
                       case ">" : 
                          if ( item[ c.field ] <= arr[ 1 ] )
                             return false;
                          break;
                       case "<=" :
                          if ( item[ c.field ] > arr[ 1 ] )
                             return false;
                          break;
                       case ">=" :   
                          if ( item[ c.field ] < arr[ 1 ] )
                             return false;
                          break;
                       default :
                          return false;                          
                    }
                 }   
                 else
                 {
                    if ( item[ c.field ] < arr[ 1 ] || item[ c.field ] > arr[ 3 ] ) 
                       return false;
                 }
              }   
              else
              {
                 if ( item[ c.field ] != colFilt[ columnId ] )
                    return false;
              }      
           }
           if ( typ == "C" ) // item[ c.field ].substring 
           {
              if ( item[ c.field ].toLowerCase().indexOf( colFilt[ columnId ] ) == -1 ) // item[ c.field ] != colFilt[ columnId ] && 
                 return false;
           }
        }   
     }
     return true;
  }

  function varType( o ) 
  {
     if ( o.toFixed )
        return "N";
     if ( o.substring )
        return "C";
     if ( o.getMonth )
        return "D";
     if ( o == true || o == false )
        return "L";
     return "U";
  }

  function date_num_filter( cVal )
  {
     var ret_arr = [];
     var p       = -1;
     var n1,n2,n3

     if ( cVal.length == 0 )
        return ret_arr;

     n1 = cVal.indexOf( ".." );
     n2 = cVal.indexOf( "<" );
     n3 = cVal.indexOf( ">" );
     if ( n1 >= 0 || n2 >= 0 || n3 >= 0 )
     {
        p = cVal.indexOf( ".." );
       if ( p >= 0 && cVal.length > 2 )
        {
           if ( p == 0 || p == cVal.length - 2 )
           {
              ret_arr[ 0 ] = ( p == 0 ? "<=" : ">=" );
              ret_arr[ 1 ] = ( p == 0 ? cVal.substr( 2 ) : cVal.substr( 0, p ) );
           }
           else
           {
              ret_arr[ 0 ] = ">=";
              ret_arr[ 1 ] = cVal.substr( 0, p );
              ret_arr[ 2 ] = "<=";
              ret_arr[ 3 ] = cVal.substr( p + 2 );
           }                  
           return ret_arr;
        }

        n1 = cVal.indexOf( "<=" );
        n2 = cVal.indexOf( ">=" );
        if ( n1 == 0 || n2 == 0 )
        {
           if ( cVal.length > 2 );
           {
              ret_arr[ 0 ] = cVal.substr( 0, 2 );
              ret_arr[ 1 ] = cVal.substr( 2 );
              return ret_arr;
           }
        }   
        n1 = cVal.indexOf( "<" );
        n2 = cVal.indexOf( ">" );
        if ( n1 == 0 || n2 == 0 ) 
        {
           if ( cVal.length > 1 );
           {
              ret_arr[ 0 ] = cVal.substr( 0, 1 );
              ret_arr[ 1 ] = cVal.substr( 1 );
              return ret_arr;
           }   
        }
     }   
     return ret_arr;
  }

功能过滤器（项目）
{
for（colFilt中的var columnId）
{
if（columnId！==未定义和&colFilt[columnId]！==“”）
{
var c=grid.getColumns（）[grid.getColumnIndex（columnId）]；
变量类型=变量类型（项目[c.字段]）；
如果（类型==“N”| |类型==“D”）
{
var arr=date\u num\u filter（colFilt[columnId]）
如果（arr.length>0）
{
如果（arr.length==2）
{
交换机（arr[0]）
{
案例“”：
if（项目[c.字段]arr[1]）
返回false；
打破
案例“>=”：
如果（项目[c.字段]arr[3]）
返回false；
}
}   
其他的
{
if（项[c.field]！=colFilt[columnId]）
返回false；
}      
}
if（typ==“C”）//项[C.field]。子字符串
{
if（item[c.field].toLowerCase（）.indexOf（colFilt[columnId]）==-1）//item[c.field]！=colFilt[columnId]&&
返回false；
}
}   
}
返回true；
}
函数变量类型（o）
{
如果（o.toFixed）
返回“N”；
if（o.子串）
返回“C”；
如果（o.getMonth）
返回“D”；
如果（o==true | | o==false）
返回“L”；
返回“U”；
}
函数日期\数值\过滤器（cVal）
{
var ret_arr=[]；
var p=-1；
变量n1、n2、n3
如果（cVal.length==0）
返回ret_arr；
n1=cVal.indexOf（“..”）；
n2=cVal.indexOf（“”）；
如果（n1>=0 | | n2>=0 | | n3>=0）
{
p=cVal.indexOf（“..”）；
如果（p>=0&&cVal.length>2）
{
如果（p==0 | | p==cVal.length-2）
{
ret_arr[0]=（p==0？“=”）；
ret_arr[1]=（p==0？cVal.substr（2）：cVal.substr（0，p））；
}
其他的
{
ret_arr[0]=“>=”；
ret_arr[1]=cVal.substr（0，p）；
ret_arr[2]=“你的英语有点难理解，但我相信你正在尝试使用一些条件进行过滤，比如（>100，！=100100），我在我的项目中使用了两个函数。原则是首先检查第一个字符，如果发现这4个符号中的任何一个（，！，=）然后我们知道它是一个条件过滤器，之后它将获取该条件，直到找到一个空格，这样您就可以捕获任何具有1或2个字符（0）的符号{
//拆分完整筛选器字符串的条件和值
var条件=filterVal.substring（0，idxFilterSpace）；
FilterNodeVal=columnFilters[columnId]。子字符串（idxFilterSpace+1）；
//行值是哪种类型的？在应用条件之前，我们将转换为正确的格式
//然后应用条件比较：String（我们将执行常规indexOf）、number（解析为float，然后比较）
如果（patRegex_no.test（项目[c.字段]）{
if（testCondition（condition，parseFloat（item[c.field]），parseFloat（filterNoCondVal））==false）
返回false；
//剩下的将作为常规字符串格式进行测试
}否则{
if（testCondition（条件，项[c.field].toLowerCase（），filterNoCondVal.toLowerCase（））==false）
返回false；
}
} 
}否则{
if（item[c.field].toLowerCase（）.indexOf（columnFilters[columnId].toLowerCase（））=-1）
返回false；
}
}
}
返回true；
}
/**测试传递到字符串中的筛选条件，因为eval（）函数是性能杀手
*我已经为所有可能的情况创建了一个开关盒。这样，性能就无关紧要了
*@var字符串条件：用于筛选的条件
*@var any value1:要比较的第一个值，类型可以是任何内容（数字、字符串
function myFilter(item) {
    // Regex pattern to validate numbers
    var patRegex_no = /^[$]?[-+]?[0-9.,]*[$%]?$/; // a number negative/positive with decimals with/without $, %

    for (var columnId in columnFilters) {
        if (columnId !== undefined && columnFilters[columnId] !== "") {
            var c = grid.getColumns()[grid.getColumnIndex(columnId)];
            var filterVal = columnFilters[columnId].toLowerCase();
            var filterChar1 = filterVal.substring(0, 1); // grab the 1st Char of the filter field, so we could detect if it's a condition or not

            if(item[c.field] == null)
                return false;

            // First let see if the user supplied a condition (<, <=, >, >=, !=, <>, =, ==)
            // Substring on the 1st Char is enough to find out if it's a condition or not
            // if a condition is supplied, we might have to transform the values (row values & filter value) before comparing
            // for a String (we'll do a regular indexOf), for a number (parse to float then compare), for a date (create a Date Object then compare)
            if( filterChar1 == '<' || filterChar1 == '>' || filterChar1 == '!' || filterChar1 == '=') {
                // We found a Condition filter, find the white space index position of the condition substring (should be index 1 or 2)
                var idxFilterSpace = filterVal.indexOf(" ");

                if( idxFilterSpace > 0 ) {
                    // Split the condition & value of the full filter String
                    var condition = filterVal.substring(0, idxFilterSpace);
                    filterNoCondVal = columnFilters[columnId].substring(idxFilterSpace+1);

                    // Which type are the row values? We'll convert to proper format before applying the condition
                    // Then apply the condition comparison: String (we'll do a regular indexOf), number (parse to float then compare)
                    if( patRegex_no.test(item[c.field]) ) {                             
                        if( testCondition(condition, parseFloat(item[c.field]), parseFloat(filterNoCondVal)) == false ) 
                            return false;
                    // whatever is remain will be tested as a regular String format     
                    }else {                             
                        if ( testCondition(condition, item[c.field].toLowerCase(), filterNoCondVal.toLowerCase()) == false )
                            return false;
                    }
                } 
            }else{
                if (item[c.field].toLowerCase().indexOf(columnFilters[columnId].toLowerCase()) == -1)
                    return false;
            }
        }
    }
    return true;
}

/** Test a filter condition that is passed into String, since eval() function is a performance killer
 * I have created a switch case for all possible conditions. Performance is irrelevent this way 
 * @var String condition: condition to filter with
 * @var any value1: 1st value to compare, the type could be anything (number, String or even Date)
 * @var any value2: 2nd value to compare, the type could be anything (number, String or even Date)
 * @return boolean: a boolean result of the tested condition (true/false)
 */
function testCondition(condition, value1, value2){
    switch(condition) {
        case '<':   return (value1 < value2);
        case '<=':  return (value1 <= value2);
        case '>':   return (value1 > value2);
        case '>=':  return (value1 >= value2);
        case '!=':  
        case '<>':  return (value1 != value2);
        case '=':   
        case '==':  return (value1 == value2);
    }
    return resultCond;
}