ในรหัสของฉันฉันแบ่งสตริงตาม_และคว้ารายการที่สองในอาร์เรย์

var element = $(this).attr('class');
var field = element.split('_')[1];

ใช้เวลาและให้ฉันด้วยgood_luck luckใช้งานได้ดี!

good_luck_buddyแต่ตอนนี้ผมมีชั้นเรียนที่มีลักษณะเหมือน ฉันจะทำให้ javascript ของฉันเพิกเฉยต่อวินาที_และให้ฉันได้luck_buddyอย่างไร

ฉันพบสิ่งนี้var field = element.split(new char [] {'_'}, 2);ในคำตอบของ ac # stackoverflow แต่ไม่ได้ผล ฉันลองมันที่ jsFiddle ...

ใช้วงเล็บที่จับภาพ :

"good_luck_buddy".split(/_(.+)/)[1]
"luck_buddy"

พวกเขาถูกกำหนดเป็น

หากseparatorมีวงเล็บที่จับได้ผลลัพธ์ที่ตรงกันจะถูกส่งกลับในอาร์เรย์

ดังนั้นในกรณีนี้เราต้องการแยกที่_.+(เช่นตัวแยกแบ่งเป็นสตริงย่อยที่ขึ้นต้นด้วย_) แต่ให้ผลลัพธ์มีส่วนหนึ่งของตัวแยกของเรา (เช่นทุกอย่างหลังจาก_)

ในตัวอย่างนี้คั่นเรา (จับคู่_(.+)) เป็น_luck_buddyและกลุ่มที่ถูกจับ (ภายในคั่น) lucky_buddyเป็น หากไม่มีวงเล็บจับluck_buddy(การจับคู่.+) จะไม่ถูกรวมไว้ในอาร์เรย์ผลลัพธ์เนื่องจากเป็นกรณีที่ง่ายsplitที่ตัวคั่นไม่รวมอยู่ในผลลัพธ์

คุณต้องการนิพจน์และอาร์เรย์ปกติอะไร

myString = myString.substring(myString.indexOf('_')+1)

var myString= "hello_there_how_are_you"
myString = myString.substring(myString.indexOf('_')+1)
console.log(myString)

ฉันหลีกเลี่ยง RegExp ที่ค่าใช้จ่ายทั้งหมด นี่คืออีกสิ่งที่คุณสามารถทำได้:

"good_luck_buddy".split('_').slice(1).join('_')

แทนที่อินสแตนซ์แรกด้วยตัวยึดตำแหน่งที่ไม่ซ้ำกันแล้วแยกออกจากที่นั่น

"good_luck_buddy".replace(/\_/,'&').split('&')

["good","luck_buddy"]

สิ่งนี้มีประโยชน์มากขึ้นเมื่อต้องการแยกทั้งสองด้าน

คุณสามารถใช้นิพจน์ทั่วไปเช่น:

var arr = element.split(/_(.*)/)

ทุกวันนี้String.prototype.splitอนุญาตให้คุณ จำกัด จำนวนการแบ่งได้อย่างแน่นอน

str.split([separator[, limit]])

...

จำกัดตัวเลือก

จำนวนเต็มที่ไม่เป็นลบ จำกัด จำนวนของการแยก ถ้ามีให้แยกสตริงที่เกิดขึ้นแต่ละครั้งของตัวคั่นที่ระบุ แต่หยุดเมื่อรายการ จำกัด ได้ถูกวางไว้ในอาร์เรย์ ข้อความที่เหลือจะไม่รวมอยู่ในอาร์เรย์เลย

อาร์เรย์อาจมีรายการน้อยกว่าขีด จำกัด ถ้าถึงจุดสิ้นสุดของสตริงก่อนถึงขีด จำกัด หากขีด จำกัด คือ 0 จะไม่มีการแยก

ข้อแม้

มันอาจไม่ทำงานอย่างที่คุณคาดหวัง ฉันหวังว่ามันจะไม่สนใจส่วนที่เหลือของตัวคั่น แต่เมื่อถึงขีด จำกัด มันจะแยกสตริงที่เหลืออีกครั้งโดยแยกส่วนหลังจากแยกจากผลลัพธ์ที่ส่งคืน

let str = 'A_B_C_D_E'
const limit_2 = str.split('_', 2)
limit_2
(2) ["A", "B"]
const limit_3 = str.split('_', 3)
limit_3
(3) ["A", "B", "C"]

ฉันหวังว่า:

let str = 'A_B_C_D_E'
const limit_2 = str.split('_', 2)
limit_2
(2) ["A", "B_C_D_E"]
const limit_3 = str.split('_', 3)
limit_3
(3) ["A", "B", "C_D_E"]

วิธีนี้ใช้ได้ผลสำหรับฉัน

var str = "good_luck_buddy";
var index = str.indexOf('_');
var arr = [str.slice(0, index), str.slice(index + 1)];

//arr[0] = "good"
//arr[1] = "luck_buddy"

หรือ

var str = "good_luck_buddy";
var index = str.indexOf('_');
var [first, second] = [str.slice(0, index), str.slice(index + 1)];

//first = "good"
//second = "luck_buddy"

String.splitน่าเสียดายที่Javascript ไม่มีวิธี จำกัด จำนวนการแบ่งที่แท้จริง มันมีอาร์กิวเมนต์ที่สองที่ระบุจำนวนของการแยกรายการจริงที่ส่งคืนซึ่งไม่มีประโยชน์ในกรณีของคุณ วิธีแก้ปัญหาคือการแยกสตริงเปลี่ยนรายการแรกออกจากนั้นเข้าร่วมรายการที่เหลืออีกครั้ง ::

var element = $(this).attr('class');
var parts = element.split('_');

parts.shift(); // removes the first item from the array
var field = parts.join('_');

ฉันต้องการสตริงสองส่วนดังนั้น regex lookbehind ช่วยฉันด้วยสิ่งนี้

const full_name = 'Maria do Bairro';
const [first_name, last_name] = full_name.split(/(?<=^[^ ]+) /);
console.log(first_name);
console.log(last_name);

ด้วยความช่วยเหลือของการทำลายล้างมันสามารถอ่านได้ง่ายขึ้น:

let [first, ...rest] = "good_luck_buddy".split('_')
rest = rest.join('_')

ทางออกที่เร็วที่สุด?

ฉันใช้การวัดประสิทธิภาพและวิธีแก้ปัญหานี้ชนะอย่างมหาศาล: ¹

str.slice(str.indexOf(delim) + delim.length)

// as function
function gobbleStart(str, delim) {
    return str.slice(str.indexOf(delim) + delim.length);
}

// as polyfill
String.prototype.gobbleStart = function(delim) {
    return this.slice(this.indexOf(delim) + delim.length);
};

การเปรียบเทียบประสิทธิภาพกับโซลูชันอื่น ๆ

คู่แข่งเพียงอย่างใกล้ชิดเป็นบรรทัดเดียวกันของรหัสยกเว้นใช้แทนsubstrslice

โซลูชันอื่น ๆ ที่ฉันพยายามเกี่ยวข้องsplitหรือRegExpได้รับผลกระทบอย่างมากและมีขนาดประมาณ 2 คำสั่งที่ช้าลง การใช้joinกับผลลัพธ์ของsplitหลักสูตรเพิ่มการลงโทษประสิทธิภาพเพิ่มเติม

ทำไมพวกเขาถึงช้าลง เมื่อใดก็ตามที่วัตถุหรืออาร์เรย์ใหม่จะต้องมีการสร้าง JS ต้องขอหน่วยความจำจากระบบปฏิบัติการ กระบวนการนี้ช้ามาก

ต่อไปนี้เป็นแนวทางทั่วไปบางประการในกรณีที่คุณกำลังไล่ตามมาตรฐาน:

• การจัดสรรหน่วยความจำแบบไดนามิกใหม่สำหรับวัตถุ{}หรืออาร์เรย์[](เช่นเดียวกับที่splitสร้าง) จะมีค่าใช้จ่ายจำนวนมากในประสิทธิภาพ
• RegExp การค้นหามีความซับซ้อนและช้ากว่าการค้นหาสตริง
• หากคุณมีอาร์เรย์อยู่แล้วการทำลายอาร์เรย์จะเร็วพอ ๆ กับการทำดัชนีอย่างชัดเจนและดูดีมาก

การลบที่นอกเหนือจากอินสแตนซ์แรก

ต่อไปนี้เป็นโซลูชันที่จะแบ่งส่วนและรวมอินสแตนซ์ที่ n มันไม่เร็วนัก แต่สำหรับคำถามของ OP gobble(element, '_', 1)นั้นยังคงเร็วกว่า 2x RegExpหรือมากกว่าและมีsplitวิธีแก้ไขมากกว่า:

/*
`gobble`, given a positive, non-zero `limit`, deletes
characters from the beginning of `haystack` until `needle` has
been encountered and deleted `limit` times or no more instances
of `needle` exist; then it returns what remains. If `limit` is
zero or negative, delete from the beginning only until `-(limit)`
occurrences or less of `needle` remain.
*/
function gobble(haystack, needle, limit = 0) {
  let remain = limit;
  if (limit <= 0) { // set remain to count of delim - num to leave
    let i = 0;
    while (i < haystack.length) {
      const found = haystack.indexOf(needle, i);
      if (found === -1) {
        break;
      }
      remain++;
      i = found + needle.length;
    }
  }

  let i = 0;
  while (remain > 0) {
    const found = haystack.indexOf(needle, i);
    if (found === -1) {
      break;
    }
    remain--;
    i = found + needle.length;
  }
  return haystack.slice(i);
}

ด้วยคำจำกัดความข้างต้นgobble('path/to/file.txt', '/')จะให้ชื่อของไฟล์และgobble('prefix_category_item', '_', 1)จะลบคำนำหน้าเหมือนคำตอบแรกในคำตอบนี้

1. การทดสอบรันใน Chrome 70.0.3538.110 บน macOSX 10.14

โซลูชันของ Mark F นั้นยอดเยี่ยม แต่เบราว์เซอร์รุ่นเก่าไม่รองรับ โซลูชันของ Kennebec นั้นยอดเยี่ยมและรองรับเบราว์เซอร์รุ่นเก่า แต่ไม่รองรับ regex

ดังนั้นหากคุณกำลังมองหาโซลูชันที่แยกสตริงของคุณเพียงครั้งเดียวเบราว์เซอร์รุ่นเก่าและรองรับ regex นี่คือโซลูชันของฉัน:

String.prototype.splitOnce = function(regex)
{
    var match = this.match(regex);
    if(match)
    {
        var match_i = this.indexOf(match[0]);
        
        return [this.substring(0, match_i),
        this.substring(match_i + match[0].length)];
    }
    else
    { return [this, ""]; }
}

var str = "something/////another thing///again";

alert(str.splitOnce(/\/+/)[1]);

สำหรับผู้เริ่มต้นเช่นฉันที่ไม่คุ้นเคยกับ Expression วิธีแก้ปัญหานี้ใช้งานได้:

   var field = "Good_Luck_Buddy";
   var newString = field.slice( field.indexOf("_")+1 );

slice () วิธีการแยกส่วนหนึ่งของสตริงและส่งกลับสตริงใหม่และวิธีการ indexOf () ส่งกลับตำแหน่งของการเกิดขึ้นครั้งแรกที่พบค่าที่ระบุในสตริง

ใช้replace()วิธีการสตริงกับregex :

var result = "good_luck_buddy".replace(/.*?_/, "");
console.log(result);

regex นี้ตรงกับ 0 ตัวอักษรขึ้นไปก่อนตัวแรก_และ_ตัวมันเอง การแข่งขันจะถูกแทนที่ด้วยสตริงว่าง

สิ่งนี้ใช้ได้กับฉันใน Chrome + FF:

"foo=bar=beer".split(/^[^=]+=/)[1] // "bar=beer"
"foo==".split(/^[^=]+=/)[1] // "="
"foo=".split(/^[^=]+=/)[1] // ""
"foo".split(/^[^=]+=/)[1] // undefined

หากคุณต้องการกุญแจลองใช้สิ่งนี้:

"foo=bar=beer".split(/^([^=]+)=/) // Array [ "", "foo", "bar=beer" ]
"foo==".split(/^([^=]+)=/) // [ "", "foo", "=" ]
"foo=".split(/^([^=]+)=/) // [ "", "foo", "" ]
"foo".split(/^([^=]+)=/) // [ "foo" ]

//[0] = ignored (holds the string when there's no =, empty otherwise)
//[1] = hold the key (if any)
//[2] = hold the value (if any)

นี่คือ RegExp อันเดียวที่ใช้กลอุบาย

'good_luck_buddy' . split(/^.*?_/)[1] 

ก่อนอื่นบังคับให้การแข่งขันเริ่มต้นจากจุดเริ่มต้นด้วย '^' จากนั้นจะจับคู่อักขระจำนวนใด ๆ ที่ไม่ใช่ '_' หรืออีกนัยหนึ่งคืออักขระทั้งหมดก่อนหน้า '_' ตัวแรก

The '?' หมายถึงตัวอักษรจำนวนน้อยที่สุดที่ทำให้การจับคู่รูปแบบทั้งหมดตรงกันโดยใช้ '. *?' เพราะตามด้วย '_' ซึ่งจะรวมอยู่ในการแข่งขันเป็นอักขระตัวสุดท้าย

ดังนั้นการแยกนี้ () ใช้ส่วนการจับคู่เช่น 'splitter' และลบออกจากผลลัพธ์ ดังนั้นจึงลบทุกอย่างจนถึงและรวม '_' แรกและให้ส่วนที่เหลือเป็นองค์ประกอบที่สองของผลลัพธ์ องค์ประกอบแรกคือ "" แทนส่วนก่อนหน้าส่วนที่ตรงกัน มันคือ "" เพราะการแข่งขันเริ่มต้นตั้งแต่ต้น

มี RegExps อื่น ๆ ที่ทำงานได้ดีเช่นเดียวกับ /_(.*)/ ที่ Chandu ให้ไว้ในคำตอบก่อนหน้านี้

/^.*?_/ มีประโยชน์ที่คุณสามารถเข้าใจในสิ่งที่มันทำโดยไม่ต้องรู้เกี่ยวกับบทบาทพิเศษในการจับกลุ่มที่เล่นด้วยการแทนที่ ()