for (var i = 0; i < 10; i++) {
        print(i);
    }

里面的var i，放外面比较好一点。至于for 里面的i++和++i ,可参考楼上 @口味虾 的解答。

下面是 ++ 和 -- 的前缀实现形式:

 T& T::operator++(){                    
    ++*this;                                
    return *this;                           
}

下面是 ++ 和 -- 的后缀实现形式:

 T T::operator++(int){
    T old(*this);
    ++*this;
    return old;
}

我们来分析一下自增自减的后缀形式所多花费的开销:

 T old(*this);

这 一句产生一个类型为T的临时对象 old, 并用原值*this进行初始化.当函数return的时候,又再次创建一个临时对象,并用old的值进行初始,之后,局部变量old被销毁.并用临时创建 的变量对赋值符左边的变量进行赋值(如果有的话).赋值后,临时变量再次被销毁.

而前缀形式的自增自减呢?首先函数内没有创建临时变量,故这方面的开销就节省了.其次,返回的是一个引用,故也节省了这时候创建销毁临时对象的开销.

因此后缀式的自增自减,所多花费的开销是两次临时变量的创建,以及两次临时变量的销毁.如果自增自减的对象不是内建的数据类型,而一个类类型[当然,你首 先得重载自增自减操作符:) ], 那么这个开销可能会比较大.因为变成了两次构造函数以及两次析构函数的调用.

所以在调用代码的时候,要 优先使用前缀形式,除非确实需要后缀形式返回原值.

前者是加完的值返回，后者是返回值再加

++i和i++对于i来说本质没区别，所以楼主也不要纠结了。你在循环中使用的是i的值，所以两种形式都是等价的。在这里扯不清楚i++ ++i的，估计都是深受《c语言程序设计》这本书的影响，a = ++i; a = i++ 这两种形式，区别在a的值。

另外，说到循环的参数，据说用参数递减循环比递增性能上有改善，我看到有些类库中用的都是递减，然后在网上看到人家改善mySql时，第一条就是把里面的所有递增循环改成递减，但我没有亲自测试过，仅提供参考。

单独使用i++或者++i表示递增的话是没有区别的，看你书写习惯，但是在有上下文的情况下是有区别的，一般用++i比较多

i++是先返回值再自增，++i是先自增再返回值。
嗯。举个例子

 //i++的例子
function fn(){
    var i = 0;
    return function innerFn(){
        alert(i++;)
    }
}
var test = fn();
test();//0,i++先返回0，再自增
test();//1,上一次调用i自增了1，所以此时返回1,再自增
//++i的例子
function fn(){
    var i = 0;
    return function innerFn(){
        alert(++i;)
    }
}
var test = fn();
test();//1,先自增再返回值
test();//2

TZ, 我帮你试了
首先这是第一段测试代码:

 #include <stdio.h>
int main(){
  int k = 0, i;
  for (i = 0; i < 10; ++i) k += i;
  printf("%d\n", k);
  return 0;
}

这段代码生成的汇编代码是:(放在文件try1.s里)

 .file   "try.c"
    .def    ___main;    .scl    2;  .type   32; .endef
    .section .rdata,"dr"
LC0:
    .ascii "%d\12\0"
    .text
    .globl  _main
    .def    _main;  .scl    2;  .type   32; .endef
_main:
LFB6:
    .cfi_startproc
    pushl   %ebp
    .cfi_def_cfa_offset 8
    .cfi_offset 5, -8
    movl    %esp, %ebp
    .cfi_def_cfa_register 5
    andl    $-16, %esp
    subl    $32, %esp
    call    ___main
    movl    $0, 28(%esp)
    movl    $0, 24(%esp)
    jmp L2
L3:
    movl    24(%esp), %eax
    addl    %eax, 28(%esp)
    incl    24(%esp)
L2:
    cmpl    $9, 24(%esp)
    jle L3
    movl    28(%esp), %eax
    movl    %eax, 4(%esp)
    movl    $LC0, (%esp)
    call    _printf
    movl    $0, %eax
    leave
    .cfi_restore 5
    .cfi_def_cfa 4, 4
    ret
    .cfi_endproc
LFE6:
    .def    _printf;    .scl    2;  .type   32; .endef

然后我又照着你的意思改了下测试代码,变成后缀式:

 #include <stdio.h>
int main(){
  int k = 0, i;
  for (i = 0; i < 10; i++) k += i;
  printf("%d\n", k);
  return 0;
}

然后生成了新的汇编代码:(放在文件try.s里面)

 .file   "try.c"
    .def    ___main;    .scl    2;  .type   32; .endef
    .section .rdata,"dr"
LC0:
    .ascii "%d\12\0"
    .text
    .globl  _main
    .def    _main;  .scl    2;  .type   32; .endef
_main:
LFB6:
    .cfi_startproc
    pushl   %ebp
    .cfi_def_cfa_offset 8
    .cfi_offset 5, -8
    movl    %esp, %ebp
    .cfi_def_cfa_register 5
    andl    $-16, %esp
    subl    $32, %esp
    call    ___main
    movl    $0, 28(%esp)
    movl    $0, 24(%esp)
    jmp L2
L3:
    movl    24(%esp), %eax
    addl    %eax, 28(%esp)
    incl    24(%esp)
L2:
    cmpl    $9, 24(%esp)
    jle L3
    movl    28(%esp), %eax
    movl    %eax, 4(%esp)
    movl    $LC0, (%esp)
    call    _printf
    movl    $0, %eax
    leave
    .cfi_restore 5
    .cfi_def_cfa 4, 4
    ret
    .cfi_endproc
LFE6:
    .def    _printf;    .scl    2;  .type   32; .endef

为了方便对比,我索性帮你对比了:

没有任何输出就是说两者汇编代码完全一样的意思, 解答TZ的疑问了吗:-)?

楼上各种说不一样的, 我就静静地看着你们装逼. 别的编译器我不说, 你用gcc编译器会对你写的代码进行优化的, 你自己也可以通过-O1 -O2 -O3来控制, 你们先来一发测试再说.
talk is cheap, show u the code.
int main(void)
{
int num = 0;
for (int i = 0; i < 5; ++ i)
{
num = num + 1;
}

 return 0;

}
用 gcc -O3 test.c -o test 然后改为后加再编译为test2, 自己用diff去比较去;
编译为汇编代码也是一样的...

测试1:

 i = 4;
a = i++;
console.log(i); //输出5
console.log(a); //输出4

测试2:

 i = 4;
a = ++i;
console.log(i); //输出5
console.log(a); //输出5

测试3:

 i = 4;
i = i++; //i++的运算结果是4,此时i的值是5,但因为把结果4又赋值给了i,所以最终i为4.
console.log(i); //输出4

在之前的C语言里面两个会有分别，i++会返回一个临时变量，性能会稍差一些，特别是在i为迭代器的时候，构造这个临时对象的成本比较高，所以之前的写法都是++i，而不是i++，后来编译器对此作了优化，两种写法对于基本类型来说性能是一样的，所以有人认为i++的可读性更好，更利于理解，所以推荐i++，但是对于迭代器，编译器没法优化，所以还是++it这样的写法。
在javascript里面，两者就没啥分别了，建议用i++吧，更利于理解

你问的应该不是语义的区别，那么就谈关于效率吧：

首先回答你的问题， 在JavaScript这类高级编程语言和任何拥有现代编译器的语言中，效率没有区别！

在面向对象的编程语言中，前自增和后自增的区别在于后者需要拷贝返回值，多一次拷贝构造函数调用。
因为返回的对象是自增之前的，已经不是当前变量了，显然要把它存起来再返回。举例来讲：

 Obj operator++(Obj& rhs, int i){
    Obj ret = rhs;
    rhs.x ++;
    return ret;
}

在 rhs.x 自增之前需要保存一份原有对象作为 ret ，用来返回。如果是前自增，便不需要保存这一份。所以C++中仍然有面试官上来就问前自增后自增的区别！fuck it！讲编程习惯的可以不必理他，编译器会帮你优化，而你能做的最好的事就是提高可读性，显然后自增更好。

C++中自增运算符的重载可以参考： http://harttle.github.io/2015/06/25/operator-overload.html

然而，你的for循环里并未对它取值，多数编译器都会把它优化掉，不再拷贝一份（即使是C++）。对于像JavaScript这类语言更不需要考虑这个问题！更常见的效率损失在于不合理的网络请求、不需要的DOM操作、页面重绘和回流。

var i = 1

i++
alert(i)
和
++i
alert(i)
2个alert有什么区别………

单独使用没有任何区别
区别体现在取值时