คอฟฟี่เบรค#89. 10 ปลั๊กอิน IntelliJ IDEA ที่ดีที่สุดเพื่อเพิ่มประสิทธิภาพการทำงานของคุณ การจัดการข้อยกเว้นใน Java Streams โดยใช้อินเทอร์เฟซการทำงาน

10 ปลั๊กอิน IntelliJ IDEA ที่ดีที่สุดที่จะเพิ่มประสิทธิภาพการทำงานของคุณ

ที่มา: Hackernoon ฉันเพิ่งถามนักพัฒนาที่ใช้ IntelliJ IDEA ปลั๊กอินใดที่พวกเขาชอบที่สุดสำหรับ IDE นี้ จากคำตอบที่รวบรวมมา เราได้รับรายการส่วนขยายยอดนิยม 10 รายการ

1. วากาไทม์

WakaTimeช่วยให้คุณเห็นตัวชี้วัด การวิเคราะห์ และติดตามเวลาที่ใช้ในการเขียนโปรแกรม ด้วยเครื่องมือนี้ คุณจะรู้ได้อย่างแน่ชัดว่าคุณใช้เวลาในการเขียนโค้ดไปเท่าใด เนื่องจากปลั๊กอินจะติดตามโดยอัตโนมัติเมื่อคุณเริ่มและหยุดพิมพ์ พร้อมด้วยตัววัดโดยละเอียดสำหรับโปรเจ็กต์ ไฟล์ สาขา คอมมิต/PR คุณสมบัติ และอื่นๆ อีกมากมาย

2.ขนาดขั้นบันได

ปลั๊กอินนี้ช่วยในการแก้ไขปัญหาที่เกี่ยวข้องกับหนี้ทางเทคนิค การบำรุงรักษา และการปรับโครงสร้างโค้ดใหม่ Stepsize ช่วยให้คุณ:

• ทำบุ๊กมาร์กในโค้ด
• ติดตามหนี้ทางเทคนิคโดยตรงจากบรรณาธิการ
• สร้างสิ่งที่ต้องทำ
• จัดลำดับความสำคัญของปัญหาทางเทคนิคระหว่างการวางแผนการวิ่ง
• ทำงานร่วมกับเพื่อนร่วมทีมในระหว่างการบำรุงรักษาโค้ดและการปรับโครงสร้างใหม่

3. ผู้สนับสนุนหลัก X

Key Promoter Xช่วยให้คุณเรียนรู้ความหมายของทางลัดและปุ่มต่างๆ ใน ​​IntelliJ IDEA เมื่อคุณวางเมาส์ไว้เหนือปุ่มภายใน IDE Key Promoter X จะแสดงแป้นพิมพ์ลัดที่คุณสามารถใช้แทนการคลิกเมาส์ได้

4. ZIO สำหรับ IntelliJ

ZIOจะให้คำแนะนำ การปรับโครงสร้างใหม่และการปรับปรุงอื่นๆ สำหรับระบบนิเวศ Scala ZIO แก่คุณ ปลั๊กอินขยายไลบรารี ZIO ด้วยฟังก์ชันต่างๆ เช่น:

• การปรับโครงสร้างใหม่และข้อเสนอแนะ
• รองรับมาโคร zio (เช่น @accessible)
• การทดสอบการทำงานในตัว

5.โปรโตบุฟ

ปลั๊กอินภาษา Protobufสำหรับ IDE ที่ใช้ IntelliJ ให้การสนับสนุนภาษา Protobuf Protobuf ช่วยในการเน้นไวยากรณ์ การนำเข้าไฟล์จากไลบรารีและ SDK การนำทาง การพับโค้ด การวิเคราะห์ความหมาย และการจัดทำเอกสารอย่างรวดเร็ว

6.โซนาร์ลินท์

SonarLintช่วยให้คุณสามารถแก้ไขปัญหาโค้ดได้ก่อนที่จะเกิดขึ้น ในฐานะเครื่องตรวจตัวสะกด SonarLint จะเน้นข้อผิดพลาดและช่องโหว่ด้านความปลอดภัยในขณะที่คุณเขียนโค้ด พร้อมด้วยคำแนะนำที่ชัดเจนเกี่ยวกับวิธีการแก้ไข เพื่อให้คุณสามารถแก้ไขได้ก่อนที่จะคอมมิตโค้ด SonarLint ใน VS Code รองรับการวิเคราะห์โค้ดใน Java, JavaScript, TypeScript, Python, HTML และ PHP

7. อีสลินท์

ESLintรองรับการแสดงคำเตือน eslint เป็นการตรวจสอบ IntelliJ ช่วยดำเนินการแก้ไขอย่างรวดเร็วสำหรับกฎหลายข้อ รองรับกฎ eslint แบบกำหนดเอง และคำอธิบายประกอบการกำหนดค่า eslint และการเสร็จสิ้น

8. สวยกว่า

ส่วนขยายPrettierช่วยให้โค้ดของคุณดูดีขึ้นและสอดคล้องกันมากขึ้น ช่วยให้มั่นใจถึงสไตล์ที่สอดคล้องกันโดยการวิเคราะห์โค้ดของคุณและเขียนใหม่ตามกฎและความยาวบรรทัดสูงสุด

9.ควอกก้า

Quokka.jsเป็นเครื่องมือเพิ่มประสิทธิภาพการทำงานของนักพัฒนาสำหรับการสร้างต้นแบบอย่างรวดเร็วของ JavaScript/TypeScript ใน IDE จะอัปเดตตัววัดเวลาดำเนินการถัดจากโค้ดในขณะที่คุณพิมพ์ ซึ่งจะช่วยเร่งความเร็วในการสร้างต้นแบบ การฝึกอบรม และการทดสอบ JavaScript/TypeScript ได้อย่างมาก

10. เอซจัมป์

AceJumpช่วยให้คุณเลื่อนเคอร์เซอร์ไปยังตำแหน่งใด ๆ ที่เห็นในตัวแก้ไขได้อย่างรวดเร็ว เพียงกด “CRTL+;” ป้อนอักขระ จากนั้นป้อนอักขระที่เกี่ยวข้องสำหรับ Ace Jump หากไม่พบการแข่งขันบนหน้าจอ AceJump จะเลื่อนไปยังการแข่งขันถัดไปที่สามารถค้นหาได้

การจัดการข้อยกเว้นใน Java Streams โดยใช้อินเทอร์เฟซการทำงาน

ที่มา: Dev.to ฉันเพิ่งดูโค้ดบางส่วนและเจอสิ่งนี้:

subject.getIdentities().forEach(i -> {
  try {
    caseService.updateDocument(i.getCase());
  } catch (Exception e) {
    log.error(e);
  }
});

เนื่องจากฉันเป็นแฟนตัวยงของสำนวนแลมบ์ดาและชอบความกะทัดรัด โค้ดด้านบนจึงดูกระชับเล็กน้อยและทำให้สับสนเล็กน้อยสำหรับฉัน หากต้องการล้างข้อมูล คุณควรใช้อินเทอร์เฟซที่ใช้งานได้ เราต้องการอะไรสำหรับสิ่งนี้? เรารู้ว่าforEachคาดหวังข้อมูลจากผู้บริโภค หากเราสามารถรวมตรรกะการจัดการข้อยกเว้นของเราไว้ใน Consumer ได้ เราก็สามารถใช้ตรรกะใน forEach ได้ ตรรกะหลักภายใน forEach คือบรรทัดต่อไปนี้:

//try catch removed
// i is an Identity and updateDocument returns a UpdateResponse
i -> caseService.updateDocument(i.getCase());

เรารู้ประเภทอินพุตและส่งคืน และเราสามารถสร้างอินเทอร์เฟซการทำงานที่มีเมธอดส่งข้อยกเว้นได้

@FunctionalInterface
public interface ThrowingFunction<Identity, UpdateResponse> {
  UpdateResponse apply(Identity i) throws Exception;
}

เราสามารถทำให้โค้ดสะดวกยิ่งขึ้นโดยใช้ข้อมูลทั่วไป

@FunctionalInterface
public interface ThrowingFunction<T, R> {
  R apply(T t) throws Exception;
}

เมื่อสร้างอินเทอร์เฟซแล้ว ตรรกะดั้งเดิมสามารถพิมพ์ได้:

ThrowingFunction<Identity, UpdateResponse> tf = i -> caseService.updateDocument(i.getCase());

ตอนนี้เรามีอินเทอร์เฟซที่ใช้งานได้สำหรับตรรกะของเราแล้ว เราก็สามารถส่งมันเป็นพารามิเตอร์ไปยังเมธอดที่จัดการข้อยกเว้นและส่งกลับ Consumer ที่เราสามารถใช้ได้ใน forEach

private static <T, R> Consumer<T> wrap(ThrowingFunction<T, R> f) {
  return t -> {
    try  {
      f.apply(t);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  };
}

มันดูแปลกนิดหน่อย แต่โดยพื้นฐานแล้ววิธีการ wrap จะใช้ ThrowingFunction เป็นอินพุตและจัดการการทำงานของฟังก์ชันหรือจับและโยนข้อยกเว้นใน Consumer ตอนนี้เราสามารถรวมตรรกะที่ใช้แล้วลงใน forEach ที่อาจทำให้เกิดข้อยกเว้นได้ มีลักษณะดังนี้:

// target type the original logic
ThrowingFunction<Identity, UpdateResponse> tf = i -> caseService.updateDocument(i.getCase()):

// pass logic to the wrapmethod
// which will execute the function or throw a RunTimeException.
Consumer<Identity> p = wrap(tf);

// use Consumer in foreach
subject.getIdentities().forEach(p);

หรือหากคุณต้องการหนึ่งบรรทัด:

subject.getIdentities().forEach(wrap(i -> caseService.updateDocument(i.getCase())));

ยอมรับว่าดีกว่านี้มาก! คุณสามารถใช้สิ่งนี้เพื่อจัดการกับอินเทอร์เฟซการทำงานประเภทต่างๆ ตัวอย่างเช่นการ ดำเนินการ Map รับเฉพาะ Functionเป็นอินพุต แทนที่จะใช้เมธอด wrapper ที่ส่งคืน Consumer คุณสามารถมีเมธอดที่ส่งคืนฟังก์ชันได้ นี่เป็นเพียงวิธีหนึ่งในการจัดการข้อยกเว้นในเธรด ฉันควรจะพูดถึงว่ามีห้องสมุดที่ทำสิ่งนี้เพื่อคุณ คุณยังสามารถใช้ monad เพื่อจัดการกับความสำเร็จหรือความล้มเหลวได้ แต่นั่นอยู่นอกเหนือขอบเขตของโพสต์นี้