Espressione regolare che Corrisponde ad una Dichiarazione di un Metodo Java

StackOverflow https://stackoverflow.com/questions/68633

  •  09-06-2019
  •  | 
  •  

Domanda

Ho bisogno di una espressione regolare che corrisponde ad un metodo java dichiarazione.Sono venuto con uno che corrisponde ad una dichiarazione di metodo, ma richiede l'apertura staffa di supporto del metodo di essere sulla stessa riga della dichiarazione.Se hai un suggerimento per migliorare la mia regex o semplicemente avere uno migliore, quindi si prega di inviare una risposta.

Qui è il mio regex: "\w+ +\w+ *\(.*\) *\{"

Per coloro che non sanno cosa sia un metodo java mi sembra fornire una base uno:

int foo()
{

}

Ci sono diverse parti opzionali per metodi in java che può essere aggiunto come bene, ma queste sono le uniche parti che un metodo è garantito.

Aggiornamento:Il mio attuale Regex è "\w+ +\w+ *\([^\)]*\) *\{" per evitare che la situazione che Mike e adkom descritto.

È stato utile?

Soluzione

Avete considerato la corrispondenza effettiva possibili parole chiave?ad esempio:

(?:(?:public)|(?:private)|(?:static)|(?:protected)\s+)*

Potrebbe essere un po ' più probabile che corrispondono correttamente, anche se si potrebbe anche fare la regex più difficile da leggere...

Altri suggerimenti

(public|protected|private|static|\s) +[\w\<\>\[\]]+\s+(\w+) *\([^\)]*\) *(\{?|[^;])

Penso che il sopra regexp può corrispondere a quasi tutte le possibili combinazioni di Java dichiarazioni di metodo, anche quelli tra i farmaci generici e le matrici sono di ritorno argomenti, che la regexp fornito dall'autore originale non corrispondono.

Dopo guardando attraverso le altre risposte, ecco cosa mi è venuto fuori:

#permission
   ^[ \t]*(?:(?:public|protected|private)\s+)?
#keywords
   (?:(static|final|native|synchronized|abstract|threadsafe|transient|{#insert zJRgx123GenericsNotInGroup})\s+){0,}
#return type
   #If return type is "return" then it's actually a 'return funcName();' line. Ignore.
   (?!return)
   \b([\w.]+)\b(?:|{#insert zJRgx123GenericsNotInGroup})((?:\[\]){0,})\s+
#function name
   \b\w+\b\s*
#parameters
   \(
      #one
         \s*(?:\b([\w.]+)\b(?:|{#insert zJRgx123GenericsNotInGroup})((?:\[\]){0,})(\.\.\.)?\s+(\w+)\b(?![>\[])
      #two and up
         \(\s*(?:,\s+\b([\w.]+)\b(?:|{#insert zJRgx123GenericsNotInGroup})((?:\[\]){0,})(\.\.\.)?\s+(\w+)\b(?![>\[])\s*){0,})?\s*
   \)
#post parameters
   (?:\s*throws [\w.]+(\s*,\s*[\w.]+))?
#close-curly (concrete) or semi-colon (abstract)
   \s*(?:\{|;)[ \t]*$

Dove {#insert zJRgx123GenericsNotInGroup} uguale

`(?:<[?\w\[\] ,.&]+>)|(?:<[^<]*<[?\w\[\] ,.&]+>[^>]*>)|(?:<[^<]*<[^<]*<[?\w\[\] ,.&]+>[^>]*>[^>]*>)`

Limitazioni:

  • OGNI parametro può avere dei puntini di sospensione:"..." (Java consente solo l'ultimo)
  • Tre livelli di nidificazione generici in più:(<...<...<...>...>...> va bene, <...<...<...<...>...>...>...> bad).La sintassi all'interno generics può essere molto falso, e sembrano ancora bene a questa regex.
  • Non richiede spazi tra i tipi e loro (opzionale) apertura generici '<'
  • Riconosce classi interne, ma non impedisce a due punti uno accanto all'altro, come Classe....InnerClass

Di seguito è il raw PhraseExpress codice (auto-descrizione, sulla linea 1, del corpo sulla linea 2).Chiamata {#insert zJRgxJavaFuncSigThrSemicOrOpnCrly}, e si ottiene questo:

^[ \t]*(?:(?:public|protected|private)\s+)?(?:(static|final|native|synchronized|abstract|threadsafe|transient|(?:<[?\w\[\] ,&]+>)|(?:<[^<]*<[?\w\[\] ,&]+>[^>]*>)|(?:<[^<]*<[^<]*<[?\w\[\] ,&]+>[^>]*>[^>]*>))\s+){0,}(?!return)\b([\w.]+)\b(?:|(?:<[?\w\[\] ,&]+>)|(?:<[^<]*<[?\w\[\] ,&]+>[^>]*>)|(?:<[^<]*<[^<]*<[?\w\[\] ,&]+>[^>]*>[^>]*>))((?:\[\]){0,})\s+\b\w+\b\s*\(\s*(?:\b([\w.]+)\b(?:|(?:<[?\w\[\] ,&]+>)|(?:<[^<]*<[?\w\[\] ,&]+>[^>]*>)|(?:<[^<]*<[^<]*<[?\w\[\] ,&]+>[^>]*>[^>]*>))((?:\[\]){0,})(\.\.\.)?\s+(\w+)\b(?![>\[])\s*(?:,\s+\b([\w.]+)\b(?:|(?:<[?\w\[\] ,&]+>)|(?:<[^<]*<[?\w\[\] ,&]+>[^>]*>)|(?:<[^<]*<[^<]*<[?\w\[\] ,&]+>[^>]*>[^>]*>))((?:\[\]){0,})(\.\.\.)?\s+(\w+)\b(?![>\[])\s*){0,})?\s*\)(?:\s*throws [\w.]+(\s*,\s*[\w.]+))?\s*(?:\{|;)[ \t]*$

Codice grezzo:

zJRgx123GenericsNotInGroup -- To precede return-type    (?:<[?\w\[\] ,.&]+>)|(?:<[^<]*<[?\w\[\] ,.&]+>[^>]*>)|(?:<[^<]*<[^<]*<[?\w\[\] ,.&]+>[^>]*>[^>]*>)  zJRgx123GenericsNotInGroup
zJRgx0OrMoreParams  \s*(?:{#insert zJRgxParamTypeName}\s*(?:,\s+{#insert zJRgxParamTypeName}\s*){0,})?\s*   zJRgx0OrMoreParams
zJRgxJavaFuncNmThrClsPrn_M_fnm -- Needs zvFOBJ_NAME (?<=\s)\b{#insert zvFOBJ_NAME}{#insert zzJRgxPostFuncNmThrClsPrn}   zJRgxJavaFuncNmThrClsPrn_M_fnm
zJRgxJavaFuncSigThrSemicOrOpnCrly -(**)-    {#insert zzJRgxJavaFuncSigPreFuncName}\w+{#insert zzJRgxJavaFuncSigPostFuncName}    zJRgxJavaFuncSigThrSemicOrOpnCrly
zJRgxJavaFuncSigThrSemicOrOpnCrly_M_fnm -- Needs zvFOBJ_NAME    {#insert zzJRgxJavaFuncSigPreFuncName}{#insert zvFOBJ_NAME}{#insert zzJRgxJavaFuncSigPostFuncName}  zJRgxJavaFuncSigThrSemicOrOpnCrly_M_fnm
zJRgxOptKeywordsBtwScopeAndRetType  (?:(static|final|native|synchronized|abstract|threadsafe|transient|{#insert zJRgx123GenericsNotInGroup})\s+){0,}    zJRgxOptKeywordsBtwScopeAndRetType
zJRgxOptionalPubProtPriv    (?:(?:public|protected|private)\s+)?    zJRgxOptionalPubProtPriv
zJRgxParamTypeName -(**)- Ends w/ '\b(?![>\[])' to NOT find <? 'extends XClass'> or ...[]>  (*Original: zJRgxParamTypeName, Needed by: zJRgxParamTypeName[4FQPTV,ForDel[NmsOnly,Types]]*){#insert zJRgxTypeW0123GenericsArry}(\.\.\.)?\s+(\w+)\b(?![>\[])   zJRgxParamTypeName
zJRgxTypeW0123GenericsArry -- Grp1=Type, Grp2='[]', if any  \b([\w.]+)\b(?:|{#insert zJRgx123GenericsNotInGroup})((?:\[\]){0,}) zJRgxTypeW0123GenericsArry
zvTTL_PRMS_stL1c    {#insert zCutL1c}{#SETPHRASE -description zvTTL_PRMS -content {#INSERTCLIPBOARD} -autotext zvTTL_PRMS -folder ctvv_folder}  zvTTL_PRMS_stL1c
zvTTL_PRMS_stL1cSvRstrCB    {#insert zvCB_CONTENTS_stCB}{#insert zvTTL_PRMS_stL1c}{#insert zSetCBToCB_CONTENTS} zvTTL_PRMS_stL1cSvRstrCB
zvTTL_PRMS_stPrompt {#SETPHRASE -description zvTTL_PRMS -content {#INPUT -head How many parameters? -single} -autotext zvTTL_PRMS -folder ctvv_folder}  zvTTL_PRMS_stPrompt
zzJRgxJavaFuncNmThrClsPrn_M_fnmTtlp -- Needs zvFOBJ_NAME, zvTTL_PRMS    (?<=[ \t])\b{#insert zvFOBJ_NAME}\b\s*\(\s*{#insert {#COND -if {#insert zvTTL_PRMS} = 0 -then z1slp -else zzParamsGT0_M_ttlp}}\)    zzJRgxJavaFuncNmThrClsPrn_M_fnmTtlp
zzJRgxJavaFuncSigPostFuncName   {#insert zzJRgxPostFuncNmThrClsPrn}(?:\s*throws \b(?:[\w.]+)\b(\s*,\s*\b(?:[\w.]+)\b))?\s*(?:\{|;)[ \t]*$   zzJRgxJavaFuncSigPostFuncName
zzJRgxJavaFuncSigPreFuncName    (*If a type has generics, there may be no spaces between it and the first open '<', also requires generics with three nestings at the most (<...<...<...>...>...> okay, <...<...<...<...>...>...>...> not)*)^[ \t]*{#insert zJRgxOptionalPubProtPriv}{#insert zJRgxOptKeywordsBtwScopeAndRetType}(*To prevent 'return funcName();' from being recognized:*)(?!return){#insert zJRgxTypeW0123GenericsArry}\s+\b  zzJRgxJavaFuncSigPreFuncName
zzJRgxPostFuncNmThrClsPrn   \b\s*\({#insert zJRgx0OrMoreParams}\)   zzJRgxPostFuncNmThrClsPrn
zzParamsGT0_M_ttlp -- Needs zvTTL_PRMS  {#insert zJRgxParamTypeName}\s*{#insert {#COND -if {#insert zvTTL_PRMS} = 1 -then z1slp -else zzParamsGT1_M_ttlp}}  zzParamsGT0_M_ttlp
zzParamsGT1_M_ttlp  {#LOOP ,\s+{#insert zJRgxParamTypeName}\s* -count {#CALC {#insert zvTTL_PRMS} - 1 -round 0 -thousands none}}    zzParamsGT1_M_ttlp

Ho anche bisogno di una espressione regolare e si avvicinò con questa soluzione:

"((public|private|protected|static|final|native|synchronized|abstract|transient)+\\s)+[\\$_\\w\\<\\>\\[\\]]*\\s+[\\$_\\w]+\\([^\\)]*\\)?\\s*\\{?[^\\}]*\\}?"

Questo grammatica e Georgios Gousios risposta sono stati utili a costruire la regex.

Sono abbastanza sicuro di Java motore regex è golosa per impostazione predefinita, il che significa che "\w+ +\w+ *\(.*\) *\{" non sarà mai soddisfatta dal .* all'interno delle parentesi si mangia di tutto, dopo la parentesi di apertura.Vi consigliamo di sostituire il .* con [^)], in questo modo, verranno selezionati tutti i non-chiusura-parentesi di caratteri.

NOTA: Mike Stone corretto me nei commenti, e dal momento che la maggior parte delle persone in realtà non aprire i commenti (io so io, e spesso non si accorgono di loro):

Avido, non significa che non sarà mai soddisfatta...ma si mangia la parentesi se ci sono più dopo una parentesi per soddisfare il resto della regex...così, per esempio "public void foo(int arg) { if (test) { System.exit(0);} }" non corrispondono correttamente...

Mi si avvicinò con questa:

\b\w*\s*\w*\(.*?\)\s*\{[\x21-\x7E\s]*\}

L'ho testato contro una funzione PHP, ma dovrebbe funzionare lo stesso, questo è il frammento di codice che ho usato:

function getProfilePic($url)
 {
    if(@open_image($url) !== FALSE)
     {
        @imagepng($image, 'images/profiles/' . $_SESSION['id'] . '.png');
        @imagedestroy($image);
        return TRUE;
     }
    else 
     {
        return FALSE;
     }
 }

ULTERIORI INFORMAZIONI:

Options: case insensitive

Assert position at a word boundary «\b»
Match a single character that is a “word character” (letters, digits, etc.) «\w*»
   Between zero and unlimited times, as many times as possible, giving back as needed (greedy) «*»
Match a single character that is a “whitespace character” (spaces, tabs, line breaks, etc.) «\s*»
   Between zero and unlimited times, as many times as possible, giving back as needed (greedy) «*»
Match a single character that is a “word character” (letters, digits, etc.) «\w*»
   Between zero and unlimited times, as many times as possible, giving back as needed (greedy) «*»
Match the character “(” literally «\(»
Match any single character that is not a line break character «.*?»
   Between zero and unlimited times, as few times as possible, expanding as needed (lazy) «*?»
Match the character “)” literally «\)»
Match a single character that is a “whitespace character” (spaces, tabs, line breaks, etc.) «\s*»
   Between zero and unlimited times, as many times as possible, giving back as needed (greedy) «*»
Match the character “{” literally «\{»
Match a single character present in the list below «[\x21-\x7E\s]*»
   Between zero and unlimited times, as many times as possible, giving back as needed (greedy) «*»
   A character in the range between ASCII character 0x21 (33 decimal) and ASCII character 0x7E (126 decimal) «\x21-\x7E»
   A whitespace character (spaces, tabs, line breaks, etc.) «\s»
Match the character “}” literally «\}»


Created with RegexBuddy

Un suggerimento:

Se avete intenzione di scrivere le espressioni regolari in Perl, si prega di utilizzare il "xms" opzioni in modo che si può lasciare spazi e documentare le regex.Per esempio, è possibile scrivere un'espressione regolare come:

 m{\w+ \s+      #return type
   \w+ \s*      #function name
   [(] [^)]* [)] #params
   \s* [{]           #open paren
  }xms

Una delle opzioni (penso x) consente l' # commenti all'interno di un'espressione regolare.Anche utilizzare \s al posto di una " ".\s sta per eventuali "vuoti" di carattere.Così le schede anche match, che è ciò che si vorrebbe.In Perl non è necessario utilizzare / /, è possibile utilizzare { } o < > o | |.

Non so se altre lingue hanno questa capacità.Se lo fanno, si prega di utilizzare loro.

(public|private|static|protected|abstract|native|synchronized) +([a-zA-Z0-9<>._?, ]+) +([a-zA-Z0-9_]+) *\\([a-zA-Z0-9<>\\[\\]._?, \n]*\\) *([a-zA-Z0-9_ ,\n]*) *\\{

La Regex sopra di rilevare tutti i possibili java definizioni di metodo.Testato su un sacco di file di codice sorgente.Per includere i costruttori utilizzare il seguente espressione regolare :

(public|private|static|protected|abstract|native|synchronized) +([a-zA-Z0-9<>._?, ]*) +([a-zA-Z0-9_]+) *\\([a-zA-Z0-9<>\\[\\]._?, \n]*\\) *([a-zA-Z0-9_ ,\n]*) *\\{

Questo prenderà il nome di metodo e non tutta la linea.

(?<=public static void )\w+|(?<=private static void )\w+|(?<=protected static void )\w+|(?<=public void )\w+|(?<=private void )\w+|(?<=protected void )\w+|(?<=public final void)\w+|(?<=private final void)\w+|(?<=protected final void)\w+|(?<=private void )\w+|(?<=protected void )\w+|(?<=public static final void )\w+|(?<=private static final void )\w+|(?<=public final static void )\w+|(?<=protected final static void )\\w+|(?<=private final static void )\w+|(?<=protected final static void )\w+|(?<=void )\w+|(?<=private static )\w+

Ho costruito un vim regex per fare questo per ctrlp/funky basato su Georgios Gousios risposta.

    let regex = '\v^\s+'                " preamble
    let regex .= '%(<\w+>\s+){0,3}'     " visibility, static, final
    let regex .= '%(\w|[<>[\]])+\s+'    " return type
    let regex .= '\w+\s*'               " method name
    let regex .= '\([^\)]*\)'           " method parameters
    let regex .= '%(\w|\s|\{)+$'        " postamble

Credo che questo aspetto in Java:

^\s+(?:<\w+>\s+){0,3}(?:[\w\<\>\[\]])+\s+\w+\s*\([^\)]*\)(?:\w|\s|\{)+$

Questo è per un uso più specifico caso, ma è così molto più semplice credo che vale la pena condividere.Ho fatto questo per la ricerca di 'public static void" metodi cioèGiocare le azioni del controller, e l'ho fatto da Windows/Cygwin riga di comando, l'uso di grep;vedere: https://stackoverflow.com/a/7167115/34806

cat Foobar.java | grep -Pzo '(?s)public static void.*?\)\s+{'

Le ultime due voci dalla mia uscita sono come segue:

public static void activeWorkEventStations (String type,
            String symbol,
            String section,
            String day,
            String priority,
            @As("yyyy-MM-dd") Date scheduleDepartureDate) {
public static void getActiveScheduleChangeLogs(String type,
            String symbol,
            String section,
            String day,
            String priority,
            @As("yyyy-MM-dd") Date scheduleDepartureDate) {

Ho trovato seba229's risposta utile, cattura la maggior parte degli scenari, ma non la segue,

public <T> T name(final Class<T> x, final T y)

Questa espressione regolare è di catturare anche.

((public|private|protected|static|final|native|synchronized|abstract|transient)+\s)+[\$_\w\<\>\w\s\[\]]*\s+[\$_\w]+\([^\)]*\)?\s*

Spero che questo aiuta.

(public|private|static|protected) ([A-Za-z0-9<>.]+) ([A-Za-z0-9]+)\(

Inoltre, ecco una sostituzione sequenza è possibile utilizzare in IntelliJ

$1 $2 $3(

Io uso questo:

$1 $2 aaa$3(

quando la conversione di file Java di Kotlin per evitare che le funzioni che iniziano con "ottenere" da settare nelle variabili.Non funziona con "default" livello di accesso, ma io non uso molto di me.

Come di git 2.19.0, il built-in regexp per Java ora sembra funzionare bene, in modo da fornire il proprio potrebbe non essere necessaria.

"!^[ \t]*(catch|do|for|if|instanceof|new|return|switch|throw|while)\n"
"^[ \t]*(([A-Za-z_][A-Za-z_0-9]*[ \t]+)+[A-Za-z_][A-Za-z_0-9]*[ \t]*\\([^;]*)$"

(La prima riga sembra essere per filtrare le righe che ricordano le dichiarazioni di metodo, ma non lo sono.)

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top