只有当分隔符不用引号括起来时才分割字符串

Question

我需要在JavaScript中编写一个分割函数，它将字符串分割为数组，逗号......但逗号不能用引号括起来（ '和"）。

这里有三个例子，结果（数组）如何应该是：

"peanut, butter, jelly" 
    -> ["peanut", "butter", "jelly"] 

"peanut, 'butter, bread', 'jelly'" 
    -> ["peanut", "butter, bread", "jelly"] 

'peanut, "butter, bread", "jelly"' 
    -> ["peanut", 'butter, bread', "jelly"] 

我不能使用JavaScript的split方法的原因是因为它也分裂时，分隔符用引号括起来。

如何才能做到这一点，也许正则表达式？

---

至于背景下，我将使用这个分裂扩大jQuery的$.expr[':']当您从传递给函数的第三个参数的第三个要素传递的参数。通常，给这个参数的名字叫做meta，它是一个包含关于过滤器的某些信息的数组。

无论如何，这个数组的第三个元素是一个字符串，它包含与过滤器一起传递的参数;并且由于字符串格式的参数，我需要能够正确地分割它们以进行解析。

Answer 1

你所要求的基本上是一个JavaScript CSV解析器。在“Javascript CSV解析器”上进行Google搜索，您将获得许多点击，其中很多都带有完整的脚本。又见Javascript code to parse CSV data

Answer 2

var str = 'text, foo, "haha, dude", bar'; 
var fragments = str.match(/[a-z]+|(['"]).*?\1/g); 

更妙的是（支持逃过串内"或'）：

var str = 'text_123 space, foo, "text, here\", dude", bar, \'one, two\', blob'; 
var fragments = str.match(/[^"', ][^"',]+[^"', ]|(["'])(?:[^\1\\\\]|\\\\.)*\1/g); 

// Result: 
0: text_123 space 
1: foo 
2: "text, here\", dude" 
3: bar 
4: 'one, two' 
5: blob 

Answer 3

如果你能控制输入执行该字符串将用双引号括起来"，并且所有包含字符串的元素将被括在单引号'中，并且没有元素可以包含单引号，则可以分割为, '。如果你无法控制输入，那么使用正则表达式对输入进行排序/过滤/拆分将与使用正则表达式匹配xhtml一样有用（请参阅：RegEx match open tags except XHTML self-contained tags）

Answer 4

那么，我已经有了编写解决方案的手提钻（用于其他方面的通用代码），仅用于踢球。 。 。

function Lexer() { 
    this.setIndex = false; 
    this.useNew = false; 
    for (var i = 0; i < arguments.length; ++i) { 
    var arg = arguments [i]; 
    if (arg === Lexer.USE_NEW) { 
     this.useNew = true; 
    } 
    else if (arg === Lexer.SET_INDEX) { 
     this.setIndex = Lexer.DEFAULT_INDEX; 
    } 
    else if (arg instanceof Lexer.SET_INDEX) { 
     this.setIndex = arg.indexProp; 
    } 
    } 
    this.rules = []; 
    this.errorLexeme = null; 
} 

Lexer.NULL_LEXEME = {}; 

Lexer.ERROR_LEXEME = { 
    toString: function() { 
    return "[object Lexer.ERROR_LEXEME]"; 
    } 
}; 

Lexer.DEFAULT_INDEX = "index"; 

Lexer.USE_NEW = {}; 

Lexer.SET_INDEX = function (indexProp) { 
    if (!(this instanceof arguments.callee)) { 
    return new arguments.callee.apply (this, arguments); 
    } 
    if (indexProp === undefined) { 
    indexProp = Lexer.DEFAULT_INDEX; 
    } 
    this.indexProp = indexProp; 
}; 

(function() { 
    var New = (function() { 
    var fs = []; 
    return function() { 
     var f = fs [arguments.length]; 
     if (f) { 
     return f.apply (this, arguments); 
     } 
     var argStrs = []; 
     for (var i = 0; i < arguments.length; ++i) { 
     argStrs.push ("a[" + i + "]"); 
     } 
     f = new Function ("var a=arguments;return new this(" + argStrs.join() + ");"); 
     if (arguments.length < 100) { 
     fs [arguments.length] = f; 
     } 
     return f.apply (this, arguments); 
    }; 
    })(); 

    var flagMap = [ 
     ["global", "g"] 
    , ["ignoreCase", "i"] 
    , ["multiline", "m"] 
    , ["sticky", "y"] 
    ]; 

    function getFlags (regex) { 
    var flags = ""; 
    for (var i = 0; i < flagMap.length; ++i) { 
     if (regex [flagMap [i] [0]]) { 
     flags += flagMap [i] [1]; 
     } 
    } 
    return flags; 
    } 

    function not (x) { 
    return function (y) { 
     return x !== y; 
    }; 
    } 

    function Rule (regex, lexeme) { 
    if (!regex.global) { 
     var flags = "g" + getFlags (regex); 
     regex = new RegExp (regex.source, flags); 
    } 
    this.regex = regex; 
    this.lexeme = lexeme; 
    } 

    Lexer.prototype = { 
     constructor: Lexer 

    , addRule: function (regex, lexeme) { 
     var rule = new Rule (regex, lexeme); 
     this.rules.push (rule); 
     } 

    , setErrorLexeme: function (lexeme) { 
     this.errorLexeme = lexeme; 
     } 

    , runLexeme: function (lexeme, exec) { 
     if (typeof lexeme !== "function") { 
      return lexeme; 
     } 
     var args = exec.concat (exec.index, exec.input); 
     if (this.useNew) { 
      return New.apply (lexeme, args); 
     } 
     return lexeme.apply (null, args); 
     } 

    , lex: function (str) { 
     var index = 0; 
     var lexemes = []; 
     if (this.setIndex) { 
      lexemes.push = function() { 
      for (var i = 0; i < arguments.length; ++i) { 
       if (arguments [i]) { 
       arguments [i] [this.setIndex] = index; 
       } 
      } 
      return Array.prototype.push.apply (this, arguments); 
      }; 
     } 
     while (index < str.length) { 
      var bestExec = null; 
      var bestRule = null; 
      for (var i = 0; i < this.rules.length; ++i) { 
      var rule = this.rules [i]; 
      rule.regex.lastIndex = index; 
      var exec = rule.regex.exec (str); 
      if (exec) { 
       var doUpdate = !bestExec 
       || (exec.index < bestExec.index) 
       || (exec.index === bestExec.index && exec [0].length > bestExec [0].length) 
       ; 
       if (doUpdate) { 
       bestExec = exec; 
       bestRule = rule; 
       } 
      } 
      } 
      if (!bestExec) { 
      if (this.errorLexeme) { 
       lexemes.push (this.errorLexeme); 
       return lexemes.filter (not (Lexer.NULL_LEXEME)); 
      } 
      ++index; 
      } 
      else { 
      if (this.errorLexeme && index !== bestExec.index) { 
       lexemes.push (this.errorLexeme); 
      } 
      var lexeme = this.runLexeme (bestRule.lexeme, bestExec); 
      lexemes.push (lexeme); 
      } 
      index = bestRule.regex.lastIndex; 
     } 
     return lexemes.filter (not (Lexer.NULL_LEXEME)); 
     } 
    }; 
})(); 

if (!Array.prototype.filter) { 
    Array.prototype.filter = function (fun) { 
    var len = this.length >>> 0; 
    var res = []; 
    var thisp = arguments [1]; 
    for (var i = 0; i < len; ++i) { 
     if (i in this) { 
     var val = this [i]; 
     if (fun.call (thisp, val, i, this)) { 
      res.push (val); 
     } 
     } 
    } 
    return res; 
    }; 
} 

现在使用的代码为您的问题：

function trim (str) { 
    str = str.replace (/^\s+/, ""); 
    str = str.replace (/\s+$/, ""); 
    return str; 
} 

var splitter = new Lexer(); 
splitter.setErrorLexeme (Lexer.ERROR_LEXEME); 
splitter.addRule (/[^,"]*"[^"]*"[^,"]*/g, trim); 
splitter.addRule (/[^,']*'[^']*'[^,']*/g, trim); 
splitter.addRule (/[^,"']+/g, trim); 
splitter.addRule (/,/g, Lexer.NULL_LEXEME); 

var strs = [ 
    "peanut, butter, jelly" 
    , "peanut, 'butter, bread', 'jelly'" 
    , 'peanut, "butter, bread", "jelly"' 
    ]; 

// NOTE: I'm lazy here, so I'm using Array.prototype.map, 
//  which isn't supported in all browsers. 
var splitStrs = strs.map (function (str) { 
    return splitter.lex (str); 
});