Hướng dẫn javascript split but keep delimiter - javascript tách nhưng giữ dấu phân cách

Tôi đã sửa đổi câu trả lời của Jichi và đặt nó vào một hàm cũng hỗ trợ nhiều chữ cái.

String.prototype.splitAndKeep = function(separator, method='seperate'){
    var str = this;
    if(method == 'seperate'){
        str = str.split(new RegExp(`(${separator})`, 'g'));
    }else if(method == 'infront'){
        str = str.split(new RegExp(`(?=${separator})`, 'g'));
    }else if(method == 'behind'){
        str = str.split(new RegExp(`(.*?${separator})`, 'g'));
        str = str.filter(function(el){return el !== "";});
    }
    return str;
};

Câu trả lời của Jichi Phương pháp thứ 3 sẽ không hoạt động trong hàm này, vì vậy tôi đã lấy phương thức thứ 4 và loại bỏ các khoảng trống để có kết quả tương tự.

Chỉnh sửa: Phương thức thứ hai ngoại trừ một mảng để chia Char1 hoặc char2

String.prototype.splitAndKeep = function(separator, method='seperate'){
    var str = this;
    function splitAndKeep(str, separator, method='seperate'){
        if(method == 'seperate'){
            str = str.split(new RegExp(`(${separator})`, 'g'));
        }else if(method == 'infront'){
            str = str.split(new RegExp(`(?=${separator})`, 'g'));
        }else if(method == 'behind'){
            str = str.split(new RegExp(`(.*?${separator})`, 'g'));
            str = str.filter(function(el){return el !== "";});
        }
        return str;
    }
    if(Array.isArray(separator)){
        var parts = splitAndKeep(str, separator[0], method);
        for(var i = 1; i < separator.length; i++){
            var partsTemp = parts;
            parts = [];
            for(var p = 0; p < partsTemp.length; p++){
                parts = parts.concat(splitAndKeep(partsTemp[p], separator[i], method));
            }
        }
        return parts;
    }else{
        return splitAndKeep(str, separator, method);
    }
};

usage:

str = "first1-second2-third3-last";

str.splitAndKeep(["1", "2", "3"]) == ["first", "1", "-second", "2", "-third", "3", "-last"];

str.splitAndKeep("-") == ["first1", "-", "second2", "-", "third3", "-", "last"];

Ảnh: Nguồn hình ảnh/hình ảnh Getty

.split()

String.prototype.split() là một phương pháp nguyên mẫu tích hợp rất hữu ích để thao tác các chuỗi trong JavaScript. Nó có hai tham số chính, thứ nhất thường được gọi là phân tách trong khi nó có tham số thứ hai và tùy chọn, được gọi là giới hạn. .split() tìm kiếm một chuỗi cho bộ phân cách, có thể là một chuỗi, một số (vì nó sẽ được ép vào một chuỗi) hoặc một biểu thức chính quy, sau đó trả về một mảng với các phần tử bao gồm các phần của chuỗi (AKA trước và sau mỗi trường hợp của dấu phân cách. Nếu dấu phân cách là một chuỗi trống (""), nó sẽ trả về một mảng với mỗi ký tự riêng lẻ dưới dạng chuỗi. Giới hạn là một số lần được chỉ định mà bộ phân cách nên được khớp. Nếu bị bỏ qua, trận đấu sẽ được thực hiện càng nhiều lần càng tốt. Đây là bản demo của .split():separator while it’s second and optional parameter, is called the limit. .split() searches a string for the separator, which can be a string, a number (as it will be coerced to a string) or a regular expression, then returns an array with elements consisting of parts of the string (aka substrings) that were present before and after each instance of the separator. If the separator is an empty string ("") it will return an array with each individual character as a string. The limit is a specified number of times that the separator should be matched. If omitted, the match will be performed as many times as possible. Here is a demo of .split():

Phân định

Delimiter là một chuỗi của một hoặc nhiều ký tự chỉ định bắt đầu và kết thúc của hai phần riêng biệt của văn bản. Một ví dụ điển hình về ứng dụng của dấu phân cách là trong các tệp CSV, trong đó DELIMITER là dấu phẩy (,) (do đó tên các giá trị phân tách bằng dấu phẩy).delimiter is a sequence of one or more characters that specifies the start and end of two separate parts of text. A good example of the application of delimiter is in CSV files, where the delimiter is a comma (,) (hence the name Comma Separated Values).

.Split () và phân định

Cho đến nay, chúng tôi đã xác định .split() và phân định. Bạn có thể đã thực hiện kết nối giữa hai; Bộ phân cách có thể được coi là dấu phân cách cho mảng kết quả mà .split() tạo ra. Nhưng điều gì sẽ xảy ra nếu chúng ta muốn .split() và giữ dấu phân cách? Nếu bạn nhận thấy trong ví dụ trên, dấu phân cách bị mất. Có cách nào để giữ nó không? Tại sao có có!

Enter: Người tìm kiếm "

Cho dù bạn là một kỹ sư dày dạn hoặc nhà phát triển người mới bắt đầu, các biểu thức thường xuyên có thể khá đáng sợ do cú pháp rất ngắn gọn và phức tạp của họ. Đối với cách tiếp cận mà tôi sắp tiết lộ, tôi sẽ giải thích các bit tôi đã sử dụng để thực hiện việc giữ các dấu phân cách. Vì vậy, không có thêm ADO, đây là giải pháp:

Đó là gì?

Ở đây, phân tách của chúng tôi là một biểu thức chính quy. Một biểu thức chính quy (thường được rút ngắn thành regexp) khớp với một mẫu cụ thể trong một chuỗi. Ví dụ: RegEXP

String.prototype.splitAndKeep = function(separator, method='seperate'){
    var str = this;
    function splitAndKeep(str, separator, method='seperate'){
        if(method == 'seperate'){
            str = str.split(new RegExp(`(${separator})`, 'g'));
        }else if(method == 'infront'){
            str = str.split(new RegExp(`(?=${separator})`, 'g'));
        }else if(method == 'behind'){
            str = str.split(new RegExp(`(.*?${separator})`, 'g'));
            str = str.filter(function(el){return el !== "";});
        }
        return str;
    }
    if(Array.isArray(separator)){
        var parts = splitAndKeep(str, separator[0], method);
        for(var i = 1; i < separator.length; i++){
            var partsTemp = parts;
            parts = [];
            for(var p = 0; p < partsTemp.length; p++){
                parts = parts.concat(splitAndKeep(partsTemp[p], separator[i], method));
            }
        }
        return parts;
    }else{
        return splitAndKeep(str, separator, method);
    }
};

0 sẽ phù hợp với sự xuất hiện của các chữ cái "AR" trong từ "thanh" hoặc "thông minh".regular expression. A regular expression (often shortened to RegExp) matches a specific pattern within a string. For example, the RegExp

String.prototype.splitAndKeep = function(separator, method='seperate'){
    var str = this;
    function splitAndKeep(str, separator, method='seperate'){
        if(method == 'seperate'){
            str = str.split(new RegExp(`(${separator})`, 'g'));
        }else if(method == 'infront'){
            str = str.split(new RegExp(`(?=${separator})`, 'g'));
        }else if(method == 'behind'){
            str = str.split(new RegExp(`(.*?${separator})`, 'g'));
            str = str.filter(function(el){return el !== "";});
        }
        return str;
    }
    if(Array.isArray(separator)){
        var parts = splitAndKeep(str, separator[0], method);
        for(var i = 1; i < separator.length; i++){
            var partsTemp = parts;
            parts = [];
            for(var p = 0; p < partsTemp.length; p++){
                parts = parts.concat(splitAndKeep(partsTemp[p], separator[i], method));
            }
        }
        return parts;
    }else{
        return splitAndKeep(str, separator, method);
    }
};

0 would match occurrences of the letters "ar" in the word "bar" or "smart".

Các thành phần của regexp này là gì?

RegEXP này có 4 phần chính:

• Một cái nhìn tích cực

  String.prototype.splitAndKeep = function(separator, method='seperate'){
      var str = this;
      function splitAndKeep(str, separator, method='seperate'){
          if(method == 'seperate'){
              str = str.split(new RegExp(`(${separator})`, 'g'));
          }else if(method == 'infront'){
              str = str.split(new RegExp(`(?=${separator})`, 'g'));
          }else if(method == 'behind'){
              str = str.split(new RegExp(`(.*?${separator})`, 'g'));
              str = str.filter(function(el){return el !== "";});
          }
          return str;
      }
      if(Array.isArray(separator)){
          var parts = splitAndKeep(str, separator[0], method);
          for(var i = 1; i < separator.length; i++){
              var partsTemp = parts;
              parts = [];
              for(var p = 0; p < partsTemp.length; p++){
                  parts = parts.concat(splitAndKeep(partsTemp[p], separator[i], method));
              }
          }
          return parts;
      }else{
          return splitAndKeep(str, separator, method);
      }
  };
  

  1
• Một sự thay thế

  String.prototype.splitAndKeep = function(separator, method='seperate'){
      var str = this;
      function splitAndKeep(str, separator, method='seperate'){
          if(method == 'seperate'){
              str = str.split(new RegExp(`(${separator})`, 'g'));
          }else if(method == 'infront'){
              str = str.split(new RegExp(`(?=${separator})`, 'g'));
          }else if(method == 'behind'){
              str = str.split(new RegExp(`(.*?${separator})`, 'g'));
              str = str.filter(function(el){return el !== "";});
          }
          return str;
      }
      if(Array.isArray(separator)){
          var parts = splitAndKeep(str, separator[0], method);
          for(var i = 1; i < separator.length; i++){
              var partsTemp = parts;
              parts = [];
              for(var p = 0; p < partsTemp.length; p++){
                  parts = parts.concat(splitAndKeep(partsTemp[p], separator[i], method));
              }
          }
          return parts;
      }else{
          return splitAndKeep(str, separator, method);
      }
  };
  

  2
• Một cái nhìn tích cực

  String.prototype.splitAndKeep = function(separator, method='seperate'){
      var str = this;
      function splitAndKeep(str, separator, method='seperate'){
          if(method == 'seperate'){
              str = str.split(new RegExp(`(${separator})`, 'g'));
          }else if(method == 'infront'){
              str = str.split(new RegExp(`(?=${separator})`, 'g'));
          }else if(method == 'behind'){
              str = str.split(new RegExp(`(.*?${separator})`, 'g'));
              str = str.filter(function(el){return el !== "";});
          }
          return str;
      }
      if(Array.isArray(separator)){
          var parts = splitAndKeep(str, separator[0], method);
          for(var i = 1; i < separator.length; i++){
              var partsTemp = parts;
              parts = [];
              for(var p = 0; p < partsTemp.length; p++){
                  parts = parts.concat(splitAndKeep(partsTemp[p], separator[i], method));
              }
          }
          return parts;
      }else{
          return splitAndKeep(str, separator, method);
      }
  };
  

  3
• Cờ toàn cầu

  String.prototype.splitAndKeep = function(separator, method='seperate'){
      var str = this;
      function splitAndKeep(str, separator, method='seperate'){
          if(method == 'seperate'){
              str = str.split(new RegExp(`(${separator})`, 'g'));
          }else if(method == 'infront'){
              str = str.split(new RegExp(`(?=${separator})`, 'g'));
          }else if(method == 'behind'){
              str = str.split(new RegExp(`(.*?${separator})`, 'g'));
              str = str.filter(function(el){return el !== "";});
          }
          return str;
      }
      if(Array.isArray(separator)){
          var parts = splitAndKeep(str, separator[0], method);
          for(var i = 1; i < separator.length; i++){
              var partsTemp = parts;
              parts = [];
              for(var p = 0; p < partsTemp.length; p++){
                  parts = parts.concat(splitAndKeep(partsTemp[p], separator[i], method));
              }
          }
          return parts;
      }else{
          return splitAndKeep(str, separator, method);
      }
  };
  

  4

Những cái nhìn của người Viking là gì?

Lookaround là một loại phù hợp đặc biệt sẽ phù hợp với bất kỳ ký tự được cung cấp nào trong bộ ký tự

String.prototype.splitAndKeep = function(separator, method='seperate'){
    var str = this;
    function splitAndKeep(str, separator, method='seperate'){
        if(method == 'seperate'){
            str = str.split(new RegExp(`(${separator})`, 'g'));
        }else if(method == 'infront'){
            str = str.split(new RegExp(`(?=${separator})`, 'g'));
        }else if(method == 'behind'){
            str = str.split(new RegExp(`(.*?${separator})`, 'g'));
            str = str.filter(function(el){return el !== "";});
        }
        return str;
    }
    if(Array.isArray(separator)){
        var parts = splitAndKeep(str, separator[0], method);
        for(var i = 1; i < separator.length; i++){
            var partsTemp = parts;
            parts = [];
            for(var p = 0; p < partsTemp.length; p++){
                parts = parts.concat(splitAndKeep(partsTemp[p], separator[i], method));
            }
        }
        return parts;
    }else{
        return splitAndKeep(str, separator, method);
    }
};

5, nếu nó "nhìn về phía trước" hoặc "nhìn đằng sau" ở một số điểm của chuỗi. Có thể nói rằng các trông có hiệu lực, phù hợp với điểm mà có thể tìm thấy các nhân vật trong khi nhìn về phía trước hoặc phía sau, vì vậy bản thân các nhân vật không được khớp. Loại phù hợp có độ dài bằng không này trong các biểu thức chính quy được gọi là khẳng định.not matched. This kind of zero-length matching in regular expressions is called an assertion.

Làm thế nào tất cả điều này phù hợp với nhau?

.split() sẽ chia tay bởi mỗi lần xuất hiện của dấu phân cách. Dấu tách của chúng tôi là một regex với hai cái nhìn với sự xen kẽ ở giữa. Các tín hiệu xen kẽ cho regexp để phù hợp với tìm kiếm nếu tìm thấy. Cái nhìn tích cực sẽ phù hợp với điểm nhìn về phía trước sẽ phù hợp với các nhân vật trong bộ nhân vật, trong khi cái nhìn tích cực phía sau sẽ phù hợp với điểm nhìn phía sau sẽ khớp với các nhân vật trong bộ của nó. Vì chúng tôi không trực tiếp khớp với các nhân vật mà chúng tôi muốn chia tách, .split() không tiêu thụ các ký tự và chúng tôi thấy chúng trong mảng kết quả của chúng tôi. Cờ toàn cầu đảm bảo rằng RegEXP tìm thấy các khớp trong toàn bộ chuỗi. Bây giờ, thời gian TTS đến D-D-D-Demo! Hãy bắt đầu với một chuỗi mẫu:

Nếu chúng ta chỉ đơn giản là làm một .split(), chúng ta sẽ nhận được:

Nhưng nếu chúng ta thực hiện thủ thuật nhỏ của mình:

Sự kết luận

.split() là một công cụ thao tác chuỗi mạnh mẽ mà chúng tôi có theo ý của chúng tôi, nhưng nó cũng có thể phá hủy. Tách sẽ loại bỏ các dấu phân cách khỏi mảng được trả về, có thể cung cấp cho chúng ta đầu ra khác với chuỗi ban đầu. Lookaround cho phép chúng ta phẫu thuật hơn các chuỗi mà không cần phải làm quá nhiều để giải thích cho các phân định bị mất trong quá trình này.