用逗号分割字符串，但使用Javascript忽略双引号中的逗号

我想把

[a，b，c，“d，e，f”，g，h]

转换成6个元素的数组：a，b，c，“d，e，f”，g，h。我正试图通过Javascript实现这一点。这就是我到目前为止所做的：

str = str.split(/,+|"[^"]+"/g); 

但是现在它把双引号中的所有内容都分开了，这是不正确的

编辑：好吧，对不起，我把这个问题说得很糟糕。我得到的是一个字符串而不是数组

var str = 'a, b, c, "d, e, f", g, h';

---

我想使用类似于“split”函数的函数将其转换为数组。

假设字符串看起来真的像

”[a，b，c，“d，e，f”，g，h]

，我相信这将是

eval（）的一个可接受的用例。

：

---

编辑：正如Rocket指出的那样，

严格

模式删除了

eval

将变量注入局部范围的功能，这意味着您需要执行以下操作：

var myArr = eval(myString);

---

我知道有点长，但我的看法是：

var sample="[a, b, c, \"d, e, f\", g, h]";

var inQuotes = false, items = [], currentItem = '';

for(var i = 0; i < sample.length; i++) {
  if (sample[i] == '"') { 
    inQuotes = !inQuotes; 

    if (!inQuotes) {
      if (currentItem.length) items.push(currentItem);
      currentItem = '';
    }

    continue; 
  }

  if ((/^[\"\[\]\,\s]$/gi).test(sample[i]) && !inQuotes) {
    if (currentItem.length) items.push(currentItem);
    currentItem = '';
    continue;
  }

  currentItem += sample[i];
}

if (currentItem.length) items.push(currentItem);

console.log(items);

var-sample=“[a，b，c，\'d，e，f\”，g，h]”；
var inQuotes=false，items=[]，currentItem=''；
对于（变量i=0；i

---

作为旁注，它在开始和结束时都可以使用大括号，也可以不使用大括号

var str = 'a, b, c, "d, e, f", g, h';
var arr = str.match(/(".*?"|[^",\s]+)(?=\s*,|\s*$)/g);

/*将匹配：

    (
        ".*?"       double quotes + anything but double quotes + double quotes
        |           OR
        [^",\s]+    1 or more characters excl. double quotes, comma or spaces of any kind
    )
    (?=             FOLLOWED BY
        \s*,        0 or more empty spaces and a comma
        |           OR
        \s*$        0 or more empty spaces and nothing else (end of string)
    )
    
*/
arr = arr || [];
// this will prevent JS from throwing an error in
// the below loop when there are no matches
for (var i = 0; i < arr.length; i++) console.log('arr['+i+'] =',arr[i]);

(
“*？”双引号+除双引号外的任何内容+双引号
|或
[^”，\s]+1个或多个字符，不包括双引号、逗号或任何类型的空格
)
（？=后跟
\s*、0个或多个空格和一个逗号
|或
\s*$0或更多空空格，没有其他内容（字符串结尾）
)
*/
arr=arr | |[]；
//这将防止JS在中抛出错误
//如果没有匹配项，则执行以下循环
对于（var i=0；i

这对我来说很好。（我使用了分号，因此警报消息将显示将数组转换为字符串时添加的逗号与实际捕获值之间的差异。）

REGEX

/("[^"]*")|[^;]+/

---

我在这方面也遇到过类似的问题，但我没有找到好的.net解决方案，所以我自己动手做了。注意：这也是用来回复的

但在这里似乎更适用（但在那里很有用）

在我的应用程序中，我正在解析一个csv，所以我的拆分凭证是“，”。我想这种方法只适用于具有单个字符拆分参数的情况

因此，我编写了一个忽略双引号中逗号的函数，它通过将输入字符串转换为字符数组并逐字符解析来实现

public static string[] Splitter_IgnoreQuotes(string stringToSplit)
    {   
        char[] CharsOfData = stringToSplit.ToCharArray();
        //enter your expected array size here or alloc.
        string[] dataArray = new string[37];
        int arrayIndex = 0;
        bool DoubleQuotesJustSeen = false;          
        foreach (char theChar in CharsOfData)
        {
            //did we just see double quotes, and no command? dont split then. you could make ',' a variable for your split parameters I'm working with a csv.
            if ((theChar != ',' || DoubleQuotesJustSeen) && theChar != '"')
            {
                dataArray[arrayIndex] = dataArray[arrayIndex] + theChar;
            }
            else if (theChar == '"')
            {
                if (DoubleQuotesJustSeen)
                {
                    DoubleQuotesJustSeen = false;
                }
                else
                {
                    DoubleQuotesJustSeen = true;
                }
            }
            else if (theChar == ',' && !DoubleQuotesJustSeen)
            {
                arrayIndex++;
            }
        }
        return dataArray;
    }

---

对于我的应用程序来说，这个函数也会忽略任何输入中的（“”），因为这些都是不需要的，并且出现在我的输入中。

下面是一个JavaScript函数来实现这一点：

function splitCSVButIgnoreCommasInDoublequotes(str) {  
    //split the str first  
    //then merge the elments between two double quotes  
    var delimiter = ',';  
    var quotes = '"';  
    var elements = str.split(delimiter);  
    var newElements = [];  
    for (var i = 0; i < elements.length; ++i) {  
        if (elements[i].indexOf(quotes) >= 0) {//the left double quotes is found  
            var indexOfRightQuotes = -1;  
            var tmp = elements[i];  
            //find the right double quotes  
            for (var j = i + 1; j < elements.length; ++j) {  
                if (elements[j].indexOf(quotes) >= 0) {  
                    indexOfRightQuotes = j; 
                    break;
                }  
            }  
            //found the right double quotes  
            //merge all the elements between double quotes  
            if (-1 != indexOfRightQuotes) {   
                for (var j = i + 1; j <= indexOfRightQuotes; ++j) {  
                    tmp = tmp + delimiter + elements[j];  
                }  
                newElements.push(tmp);  
                i = indexOfRightQuotes;  
            }  
            else { //right double quotes is not found  
                newElements.push(elements[i]);  
            }  
        }  
        else {//no left double quotes is found  
            newElements.push(elements[i]);  
        }  
    }  

    return newElements;  
}  

函数splitCSVButIgnoreCommasInDoublequotes（str）{
//先拆分str
//然后在两个双引号之间合并元素
变量分隔符='，'；
变量引号=“”；
var元素=str.split（分隔符）；
var newElements=[]；
对于（var i=0；i=0{//则找到左双引号
var indexOfRightQuotes=-1；
var tmp=元素[i]；
//找到正确的双引号
对于（var j=i+1；j=0{
indexOfRightQuotes=j；
打破
}  
}  
//找到正确的双引号
//在双引号之间合并所有元素
如果（-1！=indexOfRightQuotes）{
对于（var j=i+1；j类似堆栈的东西应该可以做到这一点

var str=“a，b，c，blah\'d，=，f\'blah，\'g，h，”；
var getAttributes=function（str）{
var结果=[]；
var strBuf=''；
var start=0；
var标记=假；
对于（变量i=0；iif（start这里有一个非正则表达式，假设双引号成对出现：


函数splitCsv（str）{
返回str.split（'，'）。reduce（（累计，当前）=>{
if（累计不一致）{
累计总长度[累计总长度-1]+='，'+当前
}否则{
累计推力（当前）
}
如果（当前拆分（“”）。长度%2==0）{
累计isConcatting=！累计isConcatting
}
返回累计；
}，{soFar:[]，isConcatting:false}）。soFar
}
log（splitCsv（'asdf，“a，d”，fdsa'），'should'be'，['asdf'，'a，d'，'fdsa']））
log（splitCsv（'，asdf，，fds'，），'应该是'，[''，'asdf'，''，''，'fds'，''）
log（splitCsv（'asdf，'a，，'d，'fdsa'），'should'，['asdf'，'a，，'d'，'fdsa']）

如果输入字符串的格式为stringTocompare，则该代码有效。
在上运行代码以查看fiddlejs设置的输出。
请参考屏幕截图。
您可以对其下面的代码使用拆分函数，并根据需要调整代码。
如果您不想在拆分后加逗号，请从代码中删除粗体或带in**的单词，attach=attach**+，“**+实际字符串[t+1]

var stringTocompare='"Manufacturer","12345","6001","00",,"Calfe,eto,lin","Calfe,edin","4","20","10","07/01/2018","01/01/2006",,,,,,,,"03/31/2004"';

console.log(stringTocompare);

var actualString=stringTocompare.split(',');
console.log("Before");
for(var i=0;i<actualString.length;i++){
console.log(actualString[i]);
}
//var actualString=stringTocompare.split(/,(?=(?:(?:[^"]*"){2})*[^"]*$)/);
for(var i=0;i<actualString.length;i++){
var flag=0;
var x=actualString[i];
if(x!==null)
{
if(x[0]=='"' && x[x.length-1]!=='"'){
   var p=0;
   var t=i;
   var b=i;
   for(var k=i;k<actualString.length;k++){
   var y=actualString[k];
        if(y[y.length-1]!=='"'){        
        p++;
        }
        if(y[y.length-1]=='"'){

                flag=1;
        }
        if(flag==1)
        break;
   }
   var attach=actualString[t];
for(var s=p;s>0;s--){

  attach=attach+","+actualString[t+1];
  t++;
}
actualString[i]=attach;
actualString.splice(b+1,p);
}
}


}
console.log("After");
for(var i=0;i<actualString.length;i++){
console.log(actualString[i]);
}




  [1]: https://i.stack.imgur.com/3FcxM.png

var stringTocompare=“‘制造商’、‘12345’、‘6001’、‘00’、‘Calfe，eto，lin’、‘Calfe，edin’、‘4’、‘20’、‘10’、‘2018年1月7日’、‘2006年1月1日’、‘2004年3月31日’；
console.log（stringTocompare）；
var actualString=stringTocompare。
function splitCSVButIgnoreCommasInDoublequotes(str) {  
    //split the str first  
    //then merge the elments between two double quotes  
    var delimiter = ',';  
    var quotes = '"';  
    var elements = str.split(delimiter);  
    var newElements = [];  
    for (var i = 0; i < elements.length; ++i) {  
        if (elements[i].indexOf(quotes) >= 0) {//the left double quotes is found  
            var indexOfRightQuotes = -1;  
            var tmp = elements[i];  
            //find the right double quotes  
            for (var j = i + 1; j < elements.length; ++j) {  
                if (elements[j].indexOf(quotes) >= 0) {  
                    indexOfRightQuotes = j; 
                    break;
                }  
            }  
            //found the right double quotes  
            //merge all the elements between double quotes  
            if (-1 != indexOfRightQuotes) {   
                for (var j = i + 1; j <= indexOfRightQuotes; ++j) {  
                    tmp = tmp + delimiter + elements[j];  
                }  
                newElements.push(tmp);  
                i = indexOfRightQuotes;  
            }  
            else { //right double quotes is not found  
                newElements.push(elements[i]);  
            }  
        }  
        else {//no left double quotes is found  
            newElements.push(elements[i]);  
        }  
    }  

    return newElements;  
}  

var str = "a,b,c,blah\"d,=,f\"blah,\"g,h,";
var getAttributes = function(str){
  var result = [];
  var strBuf = '';
  var start = 0 ;
  var marker = false;
  for (var i = 0; i< str.length; i++){

    if (str[i] === '"'){
      marker = !marker;
    }
    if (str[i] === ',' && !marker){
      result.push(str.substr(start, i - start));
      start = i+1;
    }
  }
  if (start <= str.length){
    result.push(str.substr(start, i - start));
  }
  return result;
};

console.log(getAttributes(str));

var stringTocompare='"Manufacturer","12345","6001","00",,"Calfe,eto,lin","Calfe,edin","4","20","10","07/01/2018","01/01/2006",,,,,,,,"03/31/2004"';

console.log(stringTocompare);

var actualString=stringTocompare.split(',');
console.log("Before");
for(var i=0;i<actualString.length;i++){
console.log(actualString[i]);
}
//var actualString=stringTocompare.split(/,(?=(?:(?:[^"]*"){2})*[^"]*$)/);
for(var i=0;i<actualString.length;i++){
var flag=0;
var x=actualString[i];
if(x!==null)
{
if(x[0]=='"' && x[x.length-1]!=='"'){
   var p=0;
   var t=i;
   var b=i;
   for(var k=i;k<actualString.length;k++){
   var y=actualString[k];
        if(y[y.length-1]!=='"'){        
        p++;
        }
        if(y[y.length-1]=='"'){

                flag=1;
        }
        if(flag==1)
        break;
   }
   var attach=actualString[t];
for(var s=p;s>0;s--){

  attach=attach+","+actualString[t+1];
  t++;
}
actualString[i]=attach;
actualString.splice(b+1,p);
}
}


}
console.log("After");
for(var i=0;i<actualString.length;i++){
console.log(actualString[i]);
}




  [1]: https://i.stack.imgur.com/3FcxM.png

const input_line = '"2C95699FFC68","201 S BOULEVARDRICHMOND, VA 23220","8299600062754882","2018-09-23"'

let my_split = input_line.split(/,(?=(?:(?:[^"]*"){2})*[^"]*$)/)[4]

Output: 
my_split[0]: "2C95699FFC68", 
my_split[1]: "201 S BOULEVARDRICHMOND, VA 23220", 
my_split[2]: "8299600062754882", 
my_split[3]: "2018-09-23"

function parseCSVLine(str){
    if(str.indexOf("\"")>-1){
        var aInputSplit = str.split(",");
        var aOutput = [];
        var iMatch = 0;
        //var adding = 0;
        for(var i=0;i<aInputSplit.length;i++){
            if(aInputSplit[i].indexOf("\"")>-1){
                var sWithCommas = aInputSplit[i];
                for(var z=i;z<aInputSplit.length;z++){
                    if(z !== i && aInputSplit[z].indexOf("\"") === -1){
                        sWithCommas+= ","+aInputSplit[z];
                    }else if(z !== i && aInputSplit[z].indexOf("\"") > -1){
                        sWithCommas+= ","+aInputSplit[z];
                        sWithCommas.replace(new RegExp("\"", 'g'), "");
                        aOutput.push(sWithCommas);
                        i=z;
                        z=aInputSplit.length+1;
                        iMatch++;
                    }
                    if(z === aInputSplit.length-1){
                        if(iMatch === 0){
                            aOutput.push(aInputSplit[z]);
                        }                  
                        iMatch = 0;
                    }
                }
            }else{
                aOutput.push(aInputSplit[i]);
            }
        }
        return aOutput
    }else{
        return str.split(",")
    }
}

public parseCSV(content:string):any[string]{
        return content.split("\n").map(ar=>ar.split(/,(?=(?:(?:[^"]*"){2})*[^"]*$)/).map(refi=>refi.replace(/[\x00-\x08\x0E-\x1F\x7F-\uFFFF]/g, "").trim()));
    }

var str='"abc",jkl,1000,qwerty6000';

parseCSV(str);

[
"abc","jkl","1000","qwerty6000"
]

function split_except_within(text, split_char, encapsulator_char, escape_char) {
    var start = 0
    var encapsulated = false
    var fields = []
    for (var c = 0; c < text.length; c++) {
        var char = text[c]
        if (char === split_char && ! encapsulated) {
            fields.push(text.substring(start, c))
            start = c+1
        }
        if (char === encapsulator_char && (c === 0 || text[c-1] !== escape_char) )             
            encapsulated = ! encapsulated
    }
    fields.push(text.substring(start))
    return fields
}

const csvSplit = (line) => {
    let splitLine = [];

    var quotesplit = line.split('"');
    var lastindex = quotesplit.length - 1;
    // split evens removing outside quotes, push odds
    quotesplit.forEach((val, index) => {
        if (index % 2 === 0) {
            var firstchar = (index == 0) ? 0 : 1;
            var trimmed = (index == lastindex) 
                ? val.substring(firstchar)
                : val.slice(firstchar, -1);
            trimmed.split(",").forEach(v => splitLine.push(v));
        } else {
            splitLine.push(val);
        }
    });
    return splitLine;
}