2016-06-20 16 views
0

Ich bevorzuge es, so wenig doppelten Code wie möglich innerhalb meiner Codebasis zu haben und als solche bin ich ständig auf der Suche nach Möglichkeiten, um es zu reduzieren.Reduzieren von Code-Duplizierung beim Analysieren

Ich bin jedoch ein wenig fest auf den folgenden Fall: Angenommen, ich habe eine Methode, die die Ausgabe von einem Programm in ein Objekt analysiert, um es in einem anderen Programm lesbar zu machen.

Meine aktuelle Vorgehensweise besteht darin, Regex zu verwenden, um die Eingabe zu scannen, um ein neues Objekt für die Ausgabe zu bilden.

Dies erstellt eine lange Liste von if-Anweisungen, die hier und da mit leichten Abweichungen mehr oder weniger gleich aussehen. Gibt es eine sinnvolle Möglichkeit, die Code-Duplizierung hier zu reduzieren, oder muss ich damit leben?

if ((match = block.match(/bssid=([A-Fa-f0-9:]{17})/))) { 
    parsed.bssid = match[1].toLowerCase(); 
} 

if ((match = block.match(/freq=([0-9]+)/))) { 
    parsed.frequency = parseInt(match[1], 10); 
} 

if ((match = block.match(/mode=([^\s]+)/))) { 
    parsed.mode = match[1]; 
} 

if ((match = block.match(/key_mgmt=([^\s]+)/))) { 
    parsed.key_mgmt = match[1].toLowerCase(); 
} 
+1

Für jeden Zustand gibt es eine ganz andere Wirkung, gibt es wirklich keine Duplizierung hier oder eine Art und Weise zu abstrahieren, dass. Sie könnten eine Tabelle erstellen, in der Sie eine Regex und die damit verbundene Aktion speichern, aber Sie würden am Ende mit mehr Code und wahrscheinlich nicht einmal einem klareren für die Sache enden. – cviejo

Antwort

3

ich Ihnen raten möchte etwas wie folgt aus:

var parseConfig = { 
    bssid: { 
     expr: /bssid=([A-Fa-f0-9:]{17})/, 
     handle: match => match[1].toLowerCase() 
    }, 
    frequency: { 
     expr: /freq=([0-9]+)/, 
     handle: match => parseInt(match[1], 10) 
    }, 
    mode: { 
     expr: /mode=([^\s]+)/, 
     handle: match => match[1] 
    }, 
    key_mgmt: { 
     expr: /key_mgmt=([^\s]+)/, 
     handle: match => match[1].toLowerCase() 
    } 
}; 

function parse(block, cfg) { 
    var parsed = {}; 

    Object.keys(cfg).forEach(key => { 
     var item = cfg[key], 
      match = block.match(item.expr); 

     parsed[key] = match ? item.handle(match) : null; 
    }); 

    return parsed; 
} 
+0

Während ich verstehe, dass die meisten Menschen dies als "weniger effizient" und "mehr gewunden" sehen würden, danke ich Ihnen für Ihre Antwort. Beim Parsen von mehr als 40 Einträgen scheint es sich zu lohnen. (für meine OCD) – MSB

+0

Nicht nur für die OCD. Es ist eine Trennung von Bedenken. 'parse' ist jetzt eine reine Funktion, die über Parameter konfigurierbar ist, was die Flexibilität beim Arbeiten mit ihr erhöht (und sie auch testet). Was die "weniger effizienten" betrifft, bezweifle ich es. – Tomalak

Verwandte Themen