Il problema"

Definire una funzione log(o un altro nome di 3 lettere) che quando viene chiamato registrerà / stamperà / scriverà (qualunque sia il valore predefinito per la lingua in questione) sia l'istruzione (come sorgente) che il primo argomento. In altre parole:

i=777
j=333
log(i) //outputs: "log(i) 777"
log(i+j+1) //outputs: "log(i+j+1) 1111"

Per tutti gli scopi pratici, l'output i: 777sarebbe sufficiente, ma in alcune lingue ci sono librerie di riflessione molto specifiche per questo, e ciò non sarebbe una sfida, quindi l'intera istruzione dovrebbe essere emessa.

Ispirazione

L'ispirazione per questo console.log("i:", i)siamo stati io e un altro programmatore a discutere di quanto sia irritante che spesso (con cattivi debugger), scrivi cose come , dopo abbiamo fatto una soluzione (piuttosto folle) javascript (solo nodo) (che genera i: 777piuttosto che l'intera linea di fonte) che è stato sorprendentemente lungo e mi ha ricordato il codegolfing e mi ha fatto chiedermi quanto sarebbero andate meglio le altre lingue (specialmente il golf di codice).

bonus

-10% : nessuna lettura di file (oltre al compilatore)

PS. Questa è la mia prima "domanda" qui, quindi sentiti libero di sottolineare tutti gli errori che ho fatto.

C (40-10% = 36) (38-10% = 34,2)

Si noti che, in C, una logfunzione può essere definita solo per un tipo specifico. Pertanto, questa log"funzione" accetta solo intargomenti.

#define log(x)printf("log("#x") %d",x)

Una soluzione più generale specifica come stampare l'argomento, oltre all'argomento stesso:

#define lg2(f,x)printf("lg2("#x") "f,x)

che sarebbe usato come eg lg2("%s", "I'm a string");o lg2("%f", 3.1415).

Python (65-10% = 58,5)

Ciò presuppone che il codice sia in un file (produce output dispari se richiamato nell'interprete interattivo):

import traceback as t
def log(x):print t.extract_stack()[-2][3],x

È stato testato su Python 2.7.6.

Esempio:

def foo():
    x = 1
    log(x)
    for i in xrange(10):
        log(x+i+1)
    return x

log(foo())

uscite

log(x) 1
log(x+i+1) 2
log(x+i+1) 3
log(x+i+1) 4
log(x+i+1) 5
log(x+i+1) 6
log(x+i+1) 7
log(x+i+1) 8
log(x+i+1) 9
log(x+i+1) 10
log(x+i+1) 11
log(foo()) 1

C ++ 121 71 67 -10% = 60.3

#include<iostream>
#define log(x)std::cout<<"log("#x") "<<(x)<<"\n"

Usato così:

int main() {
    int i = 777;
    int j = 333;
    log(i);
    log(i+j+1);
}

Uscite:

log(i) 777
log(i+j+1) 1111

Rebol3 - 31.5 (35-10%)

Ecco una semplice implementazione abbreviata da @draegtun che funziona bene per i numeri:

log: func[p][print[{log[}p{]}do p]]

Eseguendolo emette:

>> log: func[p][print[{log[}p{]}do p]]
>> i: 777
>> j: 333
>> log [i]
log[ 777 ] 777
>> log[i + j + 1]
log[ i + j + 1 ] 1111

Può essere molto più flessibile (per visualizzare la forma di tipi non numerici) a 42.3 caratteri (47-10%)

log: func[p][print[{log}mold p mold/only do p]]

Il risultato:

>> log: func[p] [print[{log}mold p mold/only do p]]
>> log [join "4" 4]
log [join "4" 4] "44"  ;; shows a string
>> log [1 + 2]
log [1 + 2] 3 

Javascript (325)

Penso che questa sia la logfunzione che stai cercando:

function log(m){L=(new Error()).stack.match(/(at log \([\s\S]+?at .+?:)\d+:\d+/m)[0].split('\n')[1].match(/:\d+:\d+/)[0];N=L.split(':')[1];C=parseInt(L.split(':')[2]);R=new XMLHttpRequest();R.open('GET',location.href,0);R.onload=function(){console.log(R.response.split('\n')[N-1].substr(C-1).split(';')[0]+' = '+m)};R.send()}

uso

<script>
function log(m){L=(new Error()).stack.match(/(at log \([\s\S]+?at .+?:)\d+:\d+/m)[0].split('\n')[1].match(/:\d+:\d+/)[0];N=L.split(':')[1];C=parseInt(L.split(':')[2]);R=new XMLHttpRequest();R.open('GET',location.href,0);R.onload=function(){console.log(R.response.split('\n')[N-1].substr(C-1).split(';')[0]+' = '+m)};R.send()}

function doSomething() {
  var a = 123; log(a); var b = "Hello, I am TrungDQ!"; log(b);
}
doSomething();
var message = "...or just do it out here";
log(message + "!");
</script>

Produzione

log(a) = 123
log(b) = Hello, I am TrungDQ!
log(message + "!") = ...or just do it out here!

Codice lungo

<script>
function log(msg) {
  // Get the line number and offset of the line where is function is called
  var lineInfo = (new Error()).stack.match(/(at log \([\s\S]+?at .+?:)\d+:\d+/m)[0].split('\n')[1].match(/:\d+:\d+/)[0];
  var lineNum = lineInfo.split(':')[1];
  var charOffset = parseInt(lineInfo.split(':')[2]);

  // Get the file source
  request = new XMLHttpRequest();
  request.open('GET', window.location.href, true);

  request.onload = function() {
    // Get file source code
    var response = request.responseText;
    // Get the `log` line
    var line = response.split('\n')[lineNum - 1];
    // Get the `log` statement
    var logStatement = line.substr(charOffset - 1).split(';')[0];
    // Print it
    console.log(logStatement + ' = ' + msg);
  };
  request.send();
}

function doSomething() {
  var a = 123; log(a); var b = "Hello, I am TrungDQ!"; log(b);
}
doSomething();
</script>

Funziona solo quando lo script viene inserito all'interno del <script>tag che viene inserito nel .htmldocumento perché invia una richiesta location.hrefper ottenere il codice sorgente. JSfiddle, F12 Dev Tool Console, i .jsfile integrati non funzionano, sto cercando di renderlo disponibile ovunque ...

Comunque, questa domanda è interessante.

Scala - (221-10%) = 198.9

Yay macro! Questo è in realtà esattamente il tipo di cose per cui sono.

import language.experimental.macros
def log(p:Any)=macro l
def l(c:reflect.macros.Context)(p:c.Expr[Any])={import c.universe._;reify{println("log("+(c.Expr[String](Literal(Constant(show(p.tree)))).splice)+") "+p.splice)}}

Versione leggibile:

import language.experimental.macros
def log(p: Any) = macro l
def l(c: reflect.macros.Context)(p: c.Expr[Any]) = {
  import c.universe._
  val inputString = show(p.tree)
  val inputStringExpr = c.Expr[String](Literal(Constant(inputString)))
  reify {
    println("log(" + (inputStringExpr.splice) + ") " + p.splice)
  }
}

Esempio:

log(1)
val x = 3
log(x)
val y = 4
log(x+y)

Uscite:

log(1) 1
log(x) 3
log(x.+(y)) 7

Poiché l'aggiunta è un metodo chiamato in Scala, aggiunge quella sintassi dettagliata di nuovo, ma è abbastanza vicina! È anche un po 'più dettagliato in un paio di altri casi.

bash (21-10% = 18.9)

Questo:

alias log=echo;set -v

Quindi usa logcome faresti con echo:

log $((1+1))

o

A=2
B=3
log $((A+B))

Questo metodo farà tutto ciò che è richiesto; come bonus, verranno anche stampate alcune informazioni extra, ma nessuna regola esplicita lo proibisce.

BASH

Gli argomenti non vengono passati usando "(...)" in BASH, quindi lascio che l'output di 'log ()' si adatti a quello stile:

$ log(){ echo "$FUNCNAME $@: $(($@))"; }
$ i=333
$ j=777
$ log i
log i: 333
$ log i+j+1
log i+j+1: 1111

Clojure

(defmacro log[x] `(let [x# ~x] (println "log("'~x")" x#)))

L'omoiconicità ha i suoi vantaggi!

Usare:

(def i 777)
(def j 333)
(log i) ;Prints log( i ) 777
(log (+ i j 1)) ;Prints log( (+ i j 1) ) 1111

Vediamo cosa sta succedendo con macroexpand:

(macroexpand '(log (+ i j 1))) 
;; Prints the following: 
(let* [x__1__auto__ (+ i j 1)] (clojure.core/println "log(" (quote (+ i j 1)) ")" x__1__auto__))

Julia, 51 * 0.9 = 45.9

julia> x=4
4
julia> macro log(x) println("log($x) $(log(eval(x)))") end
julia> @log(x)
log(x) 1.3862943611198906

In alternativa, ma non rispettando le regole

julia> @show log(x)
log(x) => 1.3862943611198906

Tcl, 42,3 (47-10%)

proc log c {puts [dict g [info fr -1] cmd]\ $c}

Uso:

set i 777
set j 333
log $i  ;#outputs: "log $i 777"
log [expr {$i+$j+1}] ;#outputs: "log [expr {$i+$j+1}] 1111"

Modifica : piccolo miglioramento

Lisp comune - 119,7 (133-10%)

(defmacro @(&whole f &rest r)(let((g(gensym)))`(let((,g(multiple-value-list,@r)))(progn(format t"~s~{ ~a~}
"',f,g)(values-list,g)))))

• Chiamata @perché logè la funzione di logaritmo standard e bloccata per impostazione predefinita (almeno su SBCL). Inoltre, @è lungo solo un personaggio.
• Funziona come un progn, prendendo un numero variabile di argomenti, ma stampa sull'output standard. Nelle applicazioni reali, probabilmente avrei signaluna condizione con un'espressione S invece di stampare un output separato da spazio.
• Contrariamente alla soluzione Clojure esistente, alla fine restituiamo il valore dell'espressione registrata, in modo che (@ x) possa essere utilizzato ogni volta che xviene utilizzato.
• Usi di stampa prin1 , che genera una readstringa in grado. Ciò è utile quando si tenta di riprodurre espressioni registrate.
• Gestisce tutti i tipi possibili (vedi risposta C)
• Tiene conto dei valori multipli
• Non produce output diversi (vedi risposta Scala)
• Funziona da un file e da REPL (vedi risposta Pyhton)
• Non richiede il trucco browser / interprete (traceback Python, richiesta Javascript)

Output di esempio:

CL-USER>(@ (+ 3 2))   ; user input
(@ (+ 3 2)) 5         ; printed output
5                     ; result of expression

CL-USER> (@ (values 3 4))  ; input
(@ (VALUES 3 4)) 3 4       ; logging
3                          ; first value
4                          ; second value

CL-USER>(@ (round 3.4))
(@ (ROUND 3.4)) 3 0.4000001
3                          ; rounded value
0.4000001                  ; delta

E infine, se registro quanto sopra defmacro, ho la versione ungolfed:

CL-USER> (@ (defmacro @(&whole f &rest r)(let((g(gensym)))`(let((,g(multiple-value-list,@r)))(progn(format t"~s~{ ~a~}
"',f,g)(values-list,g))))))
STYLE-WARNING: redefining COMMON-LISP-USER::@ in DEFMACRO
(@
 (DEFMACRO @ (&WHOLE F &REST R)
   (LET ((G (GENSYM)))
     `(LET ((,G (MULTIPLE-VALUE-LIST ,@R)))
        (PROGN
         (FORMAT T ,"~s~{ ~a~}
"
                 ',F ,G)
         (VALUES-LIST ,G)))))) @
@ ; actual result

PHP 138

Non puoi ripetere la dichiarazione login PHP senza usare un altro modulo ( APD), quindi ho usato logginvece, posso inviare nuovamente con l' logesempio se necessario. Questo è minore, ma più peccaminoso suppongo sia che questo presupponga che la funzione di registro sia su una linea da sola. Posso aggiornare la mia risposta come dettato dai commenti.

<?php function logg($v){$b=debug_backtrace()[0];$h=fopen($b['file'],"r");for($i=0;$i<$b['line']&&$l=fgets($h);$i++);echo trim($l)." $v";}

esempio di output:

for ($i=1; $i<10; $i++) {   
  $j=$i+1;
  $k=$j+1;
  logg($i+$j+$k);
  echo "\n";
}
/*
logg($i+$j+$k); 6
logg($i+$j+$k); 9
logg($i+$j+$k); 12
logg($i+$j+$k); 15
logg($i+$j+$k); 18
logg($i+$j+$k); 21
logg($i+$j+$k); 24
logg($i+$j+$k); 27
logg($i+$j+$k); 30
*/

JavaScript 55 53

function log(x){console.log('log("'+x+'") '+eval(x))}

Uso:

var i = 777,
    j = 333;
log("i")
log("j")
log("12*4")
log("i*j-4")

Produzione:

log("i") 777
log("j") 333
log("12*4") 48
log("i*j-4") 258737

DEVI usare le virgolette doppie, "altrimenti non funzionerà.