• Java

long t = System.nanoTime();
foo();
t = System.nanoTime() - t;
System.out.println(t + "ns");

• Clojure

(time (foo))

• C++

auto start = std::chrono::steady_clock::now();
foo();
auto end = std::chrono::steady_clock::now();
auto t = std::chrono::duration_cast<std::chrono::nanoseconds>(end-start).count();

• C#

var stopwatch = new Stopwatch();
stopwatch.Start();
foo();
stopwatch.Stop();
var t = stopwatch.ElapsedMilliseconds;

• D

StopWatch sw;
sw.start;
foo;
auto t = sw.peek.nsecs; 
writeln(t);

• Dart

var t = Stopwatch();
t.start();
foo();
t.stop();
print(t.elapsedMicroseconds * 1000);

• Elixir

def main(function) do
  function
  |> :timer.tc()
  |> elem(0)
  |> Kernel.*(1_000)
end

• Erlang

timer:tc(Fun).

• Fortran

integer, parameter :: i8 = selected_int_kind(15)
integer (kind=i8) :: count, count_rate, count_2
x = 1.2
call system_clock (count, count_rate)
call foo
call system_clock (count_2)
if (count_rate == 10**9) then
  print *,"The call to foo used ", (count_2-count), "Nanoseconds"
else
  print *,"The call to foo used ", (count_2-count)/real(count_rate)*1e9, "Nanoseconds"
end if

• Go

t1 := time.Now()
foo()
t := time.Since(t1)
ns := t.Nanoseconds()
fmt.Printf("%dns\n", ns)

• Go

t1 := time.Now()
foo()
t := time.Since(t1)
ns := int64(t / time.Nanosecond)
fmt.Printf("%dns\n", ns)

• JS

console.time('foo');
foo();
console.timeEnd('foo');

• Lisp

(time (foo))

• PHP

$start = hrtime(true);
foo();
$end = hrtime(true);
$t = $end - $start;
echo $t;

• Pascal

var
  t1, t: QWord;
begin
  t1 := GetTickCount64;
  foo;
  t := (GetTickCount64 - t1) * 1000000;
  writeln(t);
end.

• Perl

sub foo {};
my $start = Benchmark->new;
foo;
my $t = timediff(Benchmark->new, $start)->[0] * 10**9; 

• Python

t1 = time.perf_counter_ns()
foo()
t2 = time.perf_counter_ns()
print('Nanoseconds:', t2 - t1)

• Ruby

t1 = Time.now
foo
p (Time.now - t1)*1000000

• Rust

let start = Instant::now();
foo();
let duration = start.elapsed();
println!("{}", duration);