Ho una funzione, parseQuery, che analizza una query SQL in una rappresentazione astratta di quella query.
Sto per scrivere una funzione che accetta una rappresentazione astratta di una query e restituisce una stringa di query SQL.
Come dovrei chiamare la seconda funzione?
Risposte:
Penso che il verbo che vuoi sia "componi".
L'opposto di parse è serializzare
Nella terminologia del compilatore, l'opposto è "unparse". In particolare, l'analisi trasforma un flusso di token in alberi di sintassi astratti, mentre la non analisi trasforma alberi di sintassi astratti in un flusso di token.
Comporre? Quando si analizza una query, la si suddivide nelle sue parti costituenti (token, ecc.), Il contrario comporterebbe la composizione delle parti in una query di stringa.
A complemento della denominazione esistente, composeQuery sembra la migliore.
Ma nel caso generale, l'opposto di parse è ɹɐsɹɐd
Penso che "serializzare" sia probabilmente la parola che vuoi. Significa produrre una rappresentazione testuale di dati che possono essere esportati (e importati) dal programma.
Sicuramente rendering.
generare o emettere, possibilmente.
Solo per aggiungere alcune cose.
Sicuramente analizzare è una parola a doppio senso.
È possibile analizzare un abstract in una query.
È possibile analizzare una query in un abstract.
La domanda dovrebbe essere: come si chiama l'ultima parte del metodo, e poiché in questo caso stai analizzando un abstract per creare una query, la chiameresti parseAbstract .
Per rispondere alla domanda, l'analisi non ha alcun contrario.
Fai la tua scelta
Ognuno di essi ha connotazioni leggermente diverse.
Forse prettyPrintQuery ?
Un compilatore tradizionale ha due parti: un parser e un generatore di codice.
Quindi potresti chiamarlo "Genera". Ovviamente, qui è un po 'diverso perché il compilatore non sta scrivendo il codice sorgente. (a meno che non sia un precompilatore).
Forse Format (). o ToSQL () nella tua istanza?
deanalisi ()? Sto solo scherzando, andrei con toQueryString ()
appiattire?
L'oggetto query analizzato rappresenta forse una gerarchia di condizioni, che si sta "appiattendo" nuovamente in una stringa 1 dimensione.
Ma dato che stai passando da oggetto a stringa, usa semplicemente toString o toSQL () o qualcosa del genere. Inoltre, se l'hai progettata bene e stai usando l'app giusta, puoi rinominarla in un secondo momento e semplicemente inserire elementi nei commenti su ciò che fa.
Direi serializzare e deserializzare, invece di analizzare e ...
Vorrei scegliere ToString (), poiché di solito è possibile eseguirne il nesting a catena (funzioni opposte, che consentono di passare da Class1 a Class2 e viceversa)
DateTime.Parse( DateTime.Parse( myDate.ToString() ).ToString() );
Serialize () sembra una buona scelta, ma ha già un contrario in Deserialize ().
Nel tuo scenario specifico, come altri hanno sottolineato, ToSql () è un'altra buona scelta.
Userei render
> a = 'html': { 'head': {'title': 'My Page'}, 'body': { 'h1': 'Hello World', 'p': 'This is a Paragraph' } }
> b = render(a)
> console.log(b)
<html>
<head>
<title>My Page</title>
</head>
<body>
<h1>Hello World</h1>
<p>This is a Paragraph</p>
</body>
</html>
Che è IMHO, il contrario di parse ()
> c = parse(b)
{ 'html': {
'head': {
'title': 'My Page'
}
'body': {
'h1': 'Hello World',
'p': 'This is a Paragraph'
}
}
Di solito uso "analisi" come metodo di conversione e, pertanto, non riesco a trovare una parola opposta per "convertire". (non puoi "deconvertire" qualcosa, in quanto "non convertito" è un tipo di conversione stesso).
pensando in questo modo, la soluzione migliore (per me) è avere due metodi di "analisi" che ricevono argomenti diversi. Esempio (Java):
public class FooBarParser{
public Foo parse(Bar bar);
public Bar parse(Foo foo);
}
Deparse
Deparse deve analizzare, come:
L'analisi / deparsing non è un cambiamento di struttura, ma una conversione. Conversione precisa tra testo equivalente e formati dell'albero di sintassi astratto, mantenendo tutte le relazioni e la struttura.
"Componi" significa cambiamento di struttura, quindi non è del tutto corretto. Suggerisce la combinazione da parti indipendenti separate (di solito per la prima volta). Proprio come "decomporre" suggerisce la divisione in parti indipendenti. Cambiano forma, non solo formato.
Una rapida ricerca mostra il termine utilizzato in: