Pausa caffè #89. 10 migliori plugin IntelliJ IDEA per aumentare la tua produttività. Gestione delle eccezioni in Java Streams utilizzando l'interfaccia funzionale

10 migliori plugin IntelliJ IDEA che aumenteranno la tua produttività

Fonte: Hackernoon Di recente ho chiesto agli sviluppatori che utilizzano IntelliJ IDEA quali plugin preferiscono per questo IDE? Sulla base delle risposte raccolte è stata ottenuta una lista delle 10 estensioni più popolari.

1. WakaTime

WakaTime ti consente di visualizzare metriche, analisi e tenere traccia del tempo impiegato nella programmazione. Con esso, saprai esattamente quanto tempo dedichi alla codifica poiché il plug-in tiene traccia automaticamente quando inizi e smetti di digitare, con metriche dettagliate per progetti, file, ramo, commit/PR, funzionalità e altro.

2.Grandezza

Questo plugin aiuta a risolvere problemi relativi al debito tecnico, alla manutenzione e al refactoring del codice. Stepsize ti consente di:

• creare segnalibri nel codice;
• tenere traccia del debito tecnico direttamente dall'editor;
• creare TODO;
• dare priorità alle questioni tecniche durante la pianificazione dello sprint;
• Collabora con i compagni di squadra durante la manutenzione del codice e il refactoring.

3. Promotore chiave X

Key Promoter X ti aiuta a apprendere il significato delle scorciatoie e dei pulsanti in IntelliJ IDEA. Quando passi il mouse su un pulsante all'interno dell'IDE, Key Promoter X ti mostra una scorciatoia da tastiera che puoi utilizzare invece di fare clic con il mouse.

4. ZIO per IntelliJ

ZIO ti fornirà suggerimenti, refactoring e altri miglioramenti per l'ecosistema Scala ZIO. Il plugin estende la libreria ZIO con funzioni come:

• refactoring e suggerimenti;
• supporto per le macro zio (ad esempio @accessible);
• esecuzione di prova integrata.

5.Protobuff

Il plug-in Protobuf Language per IDE basati su IntelliJ fornisce il supporto per il linguaggio Protobuf. Protobuf aiuta con l'evidenziazione della sintassi, l'importazione di file dalla libreria e dall'SDK, la navigazione, la piegatura del codice, l'analisi semantica e la documentazione rapida.

6.SonarLint

SonarLint ti consente di risolvere i problemi del codice prima che si verifichino. Come correttore ortografico, SonarLint evidenzia errori e vulnerabilità della sicurezza mentre scrivi il codice, con istruzioni chiare su come risolverli, in modo da poterli correggere prima che il codice venga inserito. SonarLint in VS Code supporta l'analisi del codice in Java, JavaScript, TypeScript, Python, HTML e PHP.

7. ESLint

ESLint supporta la visualizzazione degli avvisi di eslint come ispezioni IntelliJ, aiuta a eseguire correzioni rapide per più regole, supporta regole di eslint personalizzate e annotazione e completamento della configurazione di eslint.

8. Più carino

L' estensione Prettier aiuta il tuo codice ad avere un aspetto migliore e a essere più coerente. Garantisce uno stile coerente analizzando il codice e riscrivendolo secondo le sue regole e la lunghezza massima della riga.

9.Quokka

Quokka.js è uno strumento di produttività degli sviluppatori per la prototipazione rapida JavaScript/TypeScript. Nell'IDE, aggiorna la metrica del tempo di esecuzione accanto al codice durante la digitazione. Ciò accelera notevolmente la prototipazione, l'addestramento e il test di JavaScript/TypeScript.

10. Salto dell'asso

AceJump ti consente di spostare rapidamente il cursore in qualsiasi posizione visibile nell'editor. Premi semplicemente "CRTL+;", inserisci un carattere, quindi inserisci il carattere corrispondente per Ace Jump. Se sullo schermo non viene trovata alcuna corrispondenza, AceJump passerà alla corrispondenza successiva che riesce a trovare.

Gestione delle eccezioni in Java Streams utilizzando l'interfaccia funzionale

Fonte: Dev.to Recentemente stavo esaminando del codice e mi sono imbattuto in qualcosa del genere:

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

Dato che sono un grande fan delle espressioni lambda e amo la brevità, il codice sopra mi sembra un po' conciso e un po' confuso. Per cancellarlo, dovresti usare le interfacce funzionali. Di cosa abbiamo bisogno per questo? Sappiamo che forEach si aspetta l'input del consumatore. Se potessimo racchiudere la nostra logica di gestione delle eccezioni in un Consumer, allora potremmo utilizzare la logica in forEach. La logica principale all'interno di forEach è la seguente riga:

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

Conosciamo il tipo di input e di ritorno e possiamo creare un'interfaccia funzionale il cui metodo genera un'eccezione.

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

Possiamo rendere il codice ancora più conveniente utilizzando i generici.

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

Una volta creata l'interfaccia, la logica originale può essere tipizzata:

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

Ora che abbiamo un'interfaccia funzionale per la nostra logica, possiamo passarla come parametro a un metodo che gestisce l'eccezione e restituisce un Consumer che possiamo utilizzare in 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);
    }
  };
}

Sembra un po' strano, ma essenzialmente il metodo wrap accetta una ThrowingFunction come input e gestisce l'esecuzione della funzione o cattura e genera eccezioni nel Consumer. Ora possiamo racchiudere qualsiasi logica utilizzata in forEach che potrebbe generare un'eccezione. Sembra qualcosa del genere:

// 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);

Oppure se preferisci una riga:

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

D'accordo che questo è molto meglio! Potresti implementare qualcosa di simile per gestire diversi tipi di interfacce funzionali. Ad esempio, l' operazione Map accetta solo una Function come input . Invece di un metodo wrapper che restituisce un Consumer, potresti avere un metodo che restituisce una funzione. Questo è solo un modo per gestire le eccezioni nei thread. Dovrei dire che ci sono biblioteche che fanno questo per te. Puoi anche utilizzare una monade per gestire successi o fallimenti, ma questo va oltre lo scopo di questo post.