都是从 0 开始，选 PHP 的优势是什么？

@geelaw 既然都是自己 malloc 了，那操作这块内存的时候大小一定是自己很自信了。实在看不出 vector<uchar> 额定大小再操作 data 比你上面的写法性能低效在哪里，至少肯定不会是比 malloc 低。

话说，刚同事跟我说，现在退款苹果不拿分成了。

@mcone 是的，追溯肯定是有办法追溯的，但是并不是那么简单。首先退款订单是要 CP 自己主动去查询的，其次，退款是可以在充值后很长一段时间的。这个查询周期非常场，加上小号养大号等行为，前面的收益很有可能扩散出去。大部分情况下，我们还是视退款为正常行为。黑产充钱据我们运营下来的数据看，还是黑卡，外币居多。退款的限制还是比较大的。

上面这些不是重点哇，重点是，无论厂商怎么做，玩家正常退款后，厂商还是要自己贴钱买单分成的那部分啊。。。。

人家不是说了吗，
别的渠道给你导个 1000W 量，流水 5000W ，分成 1500W ， cp 得 3500 W 。
腾讯渠道给你导个 1 亿量，流水 5 亿，分成 4.5 亿， cp 得 5000 W 。
虽然帐是这么算没错，但是还是好像哪里不对。

苹果也好不到哪里去，每个用户每年都可以任性退那么几次款，本来是好事。
坑爹的是，用户充值 1 W ，拿了游戏 1 W 的虚拟道具，然后退款，虚拟道具没办法收回不说
你还得倒贴给苹果那 1W 中他该得的 4000 分成。
流氓。

@zoffy 我身边就有非 985 非计算机科班，毕业才开始入行做码农的同事最近入职蚂蚁金服的。他才 27 左右。也不算完全蜜汁自信吧，阿里以前好多高中毕业的。这些大牛现在的技术也一样是大牛，也不是任何一个科班学习几年就能吊打他们的吧。

求教 xshell 怎么让光标在 vim 中编辑状态是块状，插入模式是竖线状？现在很蛋疼的在使用 minttty

@davinci 不是 2 个版本哟，是一个。本意是， head == None 只需要第一次判断一次， head.nex = None 只需要最后递归完后原先的头节点执行一次。中间递归的过程中可以省略这 2 步。所以 reverse 调用的 reverseImpl 。

不过可能有问题吧，没装 py 环境没试 :(

def reverseImpl(head):
if head.next == None:
return head
result = reverseImpl(head.next)
head.next.next = head
return result

def reverse(head):
if head == None:
return head
ret = reverseImpl(head)
head.next = None
return ret

不会 Python ，写成这样是不是对的呀？

@vghdjgh 是的。 Box 也是可以的。
其实这么写挺蛋疼的，必须要用 trait object ，因为闭包的类型是匿名的。用 Map 类似的结构，如果闭包是传入的，那么传入的类型是可以推倒出来的，如果没有传入，就很麻烦了。
其实这个需求很早就有在讨论了，开启 conservative_impl_trait 就可以使用 impl trait 这种方式约束返回类型了。

#![feature(conservative_impl_trait)]

fn sum<F, G>(f: F, g: G) -> Box<(impl Fn(i32) -> i32)>
where F: Fn(i32) -> i32,
G: Fn(i32) -> i32
{
Box::new(move |x: i32| f(x) + g(x))
}

fn main() {
let f1 = |x: i32| x * x;
let f2 = |x: i32| x * 2 + 1;
let a = sum(f1, f2);
println!("{}", a(1i32));
println!("{}", a(2i32));
println!("{}", a(3i32));
}

声明周期标记的有问题， sum 中的 2 个参数都被标记为 ’ static 了，实际传入的壁报声明周期并不是 'static 的。而且返回的 Box 实际上是引用了传入的 2 个参数，实际上返回值这里有个非常绕的问题。正常 move 的 closure 会使用非引用的形式捕获，但是由于你传入的是 2 个 trait object ，所以无论怎样返回的 Box 都有生命周期的依赖。
改写了一下，下面的形式可以通过，总之， Rust 的闭包我是真心感觉蛋疼：

```rust
fn sum<'a, F, G>(f: &'a F, g: &'a G) -> Box<(Fn(i32) -> i32) + 'a>
where F: Fn(i32) -> i32,
G: Fn(i32) -> i32
{
Box::new(move |x: i32| f(x) + g(x))
}

fn main() {
let f1 = |x: i32| x * x;
let f2 = |x: i32| x * 2 + 1;
let a = sum(&f1, &f2);
println!("{}", a(1i32));
println!("{}", a(2i32));
println!("{}", a(3i32));
}
```

同难受呐。 @zwik 求分享去掉边框的版本 ):

到底是要看壁纸还是桌面呀？

根据客户端传过来的一个值来检测，等于一定程度上的信任客户端，就怕这个值被篡改。其实完全可以根据服务器上同一个玩家的 2 次战斗间隔来呀，还要加上战斗力的一些校验。

写入的数据中有指针吗？

每个人的习惯不同，其实最终个人使用频度比较高的都是部分功能。像我使用最多的一般也就是移动，编辑，搜索，窗口分割了。

移动除了 hjkl 等还有很多细分的比如 w,e,b,c-e,c-y,c-d,c-u,gg,G

编辑常用的多是， r,x,d,cw,dw,dd,dy,p,之类的。

搜索，窗口分割都是固定的几个。

其实每个人常用的都是频度比较高的一部分功能。找到你最习惯用的，多用就行了。其他的等要用时再查手册也不迟。像 s, %s, 宏之类的。

配置一般不要去改原生快捷键了，插件也不用装太多。 vim 说来说去，插件一堆，都说自己装了 xx 插件很好用，其实很多插件都或多或少有些细节问题，有时又是兼容问题。经常发生装了 1 个插件，发现有个地方很不顺手，于是再加个类似的插件互补，然后版本更新后，发现又出现兼容性问题。你用起来不爽，慢慢的用的频度也就不那么高了。熟悉原生配置，方便你切换编辑器或 IDE 时更好的过度（一般流行的 IDE 都有插件实现很纯正的 Vim 模式）

总之就是多用，很多很舒服的功能，用上瘾形成惯性后，自然就记住了。比如 C++ 系语言语句要以分号结尾，但有时光标又在嵌套层次很深的括号或参数表达式中，这时候 A 跳到行尾就很方便了。而有些不需要分号的语言则又可以在这些层次很深的部分 直接通过 o, O 开启新行。（有很多 IDE 都有各自类似的功能，但他们的快捷键互不相同，切换使用时还有有些成本的， Vim 系快捷键则比较通用）

个人比较习惯 () 一起连输，这时光标在括号外面，要快速进入括号内只需 esc,i （两手可以几乎同时按） 习惯了其实与按方向键差不多的感觉。{} 也是 esc,i,回车,O 。这个操作比用方向键顺手不少。

其实最好用的还是窗口分割系的快捷键，习惯了分屏，窗口间移动，复制黏贴，看写代码太舒服了。最主要的是，还能在其他 IDE 中享用同样的快捷键，像 IDEA 就能非常方便的用 vim （插件） 快捷键分屏，效率高的爆。

其实最强大的功能还是 IDE + Vim 插件， IDE 往往都有工程的概念（这比 Vim 中的一些项目管理插件要来的靠谱简便的多），可视化的配置，对语义更懂，对重构更友好。看大型项目时，更智能精准的跳转，锁定，搜索，往往要比你用 Vim + 插件的组合更好的让你理清代码脉络。

@Arrowing 是否动态语言与是否应该有这个坑关系不大， Lua 也同样是动态语言。 JS 在这个地方的解决方案的确非常丑。

需要用这么大篇文章来解释这个 this 的坑，也是佩服 JS 这门语言。 Lua 中的环境与 self 语法糖做的事情几乎与 JS 一样，但是就没有这个坑，理解起来简直不用脑。还有与 prototype 对应的元表。 JS 有硬伤啊。

@urmyfaith 更恐怖是的， 2 天之后我们又这么干了一次， 6K RMB 这次是 23 个小时候通过。