谁才是世界上最好的编程语言？

众所周知，谁才是世界上最好的编程语言
这一直是程序员争论不休的焦点
今天就来吐槽一下那些编程语言……

原文：微信公众号米来的岁岁年

Java 篇

都是泛型惹的祸

众所周知，Java 的 List 转数组只提供了 Object[] toArray 和 T[] toArray(T[])，非常不方便，因此我们来自行实现 T[] toArray()：
图片说明
居然不能 new 泛型数组，那就……

这不就结了吗！开车！

Exception in thread "main" java.lang.ClassCastException: class [Ljava.lang.Object; cannot be cast to class [Ljava.lang.String;

Python 篇

感谢同事不杀之恩

众所周知，python 标准库提供了方便的 json 工具包，只需要 import json 然后 json.dumps 即可将对象转换为 json 字符串：

import json


if __name__ == '__main__':
    print(json.dumps({"abc": 123}))

作为编程多年的程序员，一眼就看出这个简单的程序不过是把 dict 转换为 json 字符串，最终输出字符串 {"abc": 123}。
图片说明
让我们来执行一下这个简单的 json 转换程序：

啥玩意儿？让我看看 json.dumps 源码……

谁 tm 在项目根目录写的 json.py ……

安能辨我是 True False

if __name__ == '__main__':
    print(a)
    if a:
        print('A is True')
    else:
        print('A is False')

很简单的代码:

如果 a 是 True，打印 True\nA is True

如果 a 是 False，打印 False\nA is False

这回铁定错不了，起飞！
图片说明
运行结果：

是 False 但又不完全是 False？

难道是编译器有问题？

难道是内存条坏掉了？

难道是电脑要重启一下？

我是谁？我在哪……
图片说明
看了一个下午没看出问题所在。

没办法了，祭出调试大法：
图片说明

众所众知，Py2和Py3是两个特别相似的语言

python2：
图片说明
python3:

python2:

python3：

python2：

python3:

python2：

import xyz
from a import b
from c import d

python3：

ModuleNotFoundError: No module named 'xyz'
ModuleNotFoundError: No module named 'a'
ImportError: cannot import name 'd' from 'c'

图片说明

Go 篇

你到底是不是 nil

众所周知，Golang 是一个喜欢标新立异的语言，比如它的变量名在类型的前面，比如它的“空指针”既不是 null 也不是 None，而是 nil：

type User struct {
  Name string
}

func (u *User) GetUserName() string {
  return u.Name
}
func (u *User) SayHello() string {
  return "Hello!"
}
func main() {
  user := NewUser()
  print(user == nil)
  print("\n========\n")
  print(user.SayHello())
  print("\n========\n")
  print(user.GetUserName())
}
func NewUser() *User {
  return nil
}

调用 NewUser() 获取到一个空指针，很明显： user 是空指针，因此第 13 行打印 True；
作为多年的面向对象编程程序员，肯定知道第 15 行会空指针异常；
抛出异常后，后面的代码都不会再执行。
图片说明
运行！

12 != 12

func main() {
  var a int64 = 12
  if a != GetValue() {
    print("No\n")
  } else {
    print("Yes\n")
  }
}

func GetValue() interface{} {
  return 12
}

拿这个考验我开发工程师？哪个开发工程师经不起这样的考验？
图片说明
12 和 12 明摆着是相等的，会打印 Yes。

然而，即使是最简单的问题，作为一个经验丰富的软件工程师，也能从各个方面考虑周全，揣摩出题人的意图，确保万无一失：这里如果 a 和 GetValue 返回的浮点类型，由于计算器对浮点数保存的精度问题，导致代码上相同的两个浮点数不一样能 == 相等。
但这里两者都是整数，就不存在这个问题。
图片说明
运行：

我是 int32，但又不是 int32

类似 C 语言的 typedef，Golang 可以通过如 type ID int32 的方式定义 int32 的"别名"为 ID 类型，这样我们在定义一个业务含义是 id 的整数时，就可以直接声明为 ID 类型，而不是含义不明确的 int32，可以说是非常地银杏：

type ID int32

func main() {
  print(GetValue().(int32))
}

func GetValue() interface{} {
  var res ID = 1
  return res
}

既然 ID 和 int32 是一个类型，那么强转为 int32 后再输出，自然也是没有什么问题：
图片说明

JSON 走一遭，我已不是原来的我

众所众知，Go 也和 python 一样在标准库就提供了 json，比隔离 Java 不知道好到哪里去，~~虽然还得先把字符串强转为 byte[]，虽然还得 if 判断一下 err 是否为 null，虽然还得先 var 定义一个空对象……~~
图片说明
啊，总之就是非常地优雅，非常地好用。我给大伙示范一下：

func main() {
  var m map[string]interface{}
  err := json.Unmarshal([]byte(`{"abc": 123}`), &m)
  if err != nil {
    print(err)
    return
  }
  print(m["abc"] == 123)
}

大伙都看到了，不需要引入额外的依赖，都是标准库自带的包，不像隔壁做个 json 转换都要引入额外依赖。
最重要的是不想某个依赖还时不时暴出个 bug 来，Golang 的 json 包从来没有 bug，原来是 123，转换完了还是 123：
图片说明

谢谢你，泰罗

const NAME = "name"
const SEVEN = "seven"
const TALO = "talo"

type User struct {
  name string
}

func main() {
  m := map[string]string{NAME: SEVEN}
  u := User{name: SEVEN}
  ChangeName(m)
  ChangeUserName(u)
  print(m[NAME] + "\n" + u.name)
}

func ChangeName(m map[string]string)  {
  m[NAME] = TALO
}

func ChangeUserName(u User)  {
  u.name = TALO
}

这个代码很有意思：
学 C 语言的时候我们就知道，在 main 函数中将一个变量传递给子函数时，传递过去的其实是这个变量的值，在子函数里面会分配一个新的存储单元去存储，因此在子函数中去修改这个变量的值是不会改变 main 函数中那个变量的值的。
因此为了实现在被调用函数中修改参数的值，我们需要通过传地址或者说传引用的方式来实现。
ChangeName 和 ChangeUserName 都修改了原对象的值，因此应该是输出 2 个 talo。
图片说明
当然，正所谓吃一堑长一智，吸取前面过于武断的教训，考虑到 Golang 素来喜欢标新立异，又想起它的语法中好像有类似取地址的 & 和指针符号 *，这里没有 & 符号，可能传的是副本，也就是说也可能是两个都没能修改，也就是输出 2 个 seven。
图片说明
正的、反的都押上了，这次错不了，运行！

运行结果：

优雅

众所众知，Go 的 map 比隔壁某某垃圾语言的 map 简洁得多，比如：

package main

import "fmt"
import "time"

func main() {
   m := map[string]int{
      "a": 1,
      "b": 2,
   }
   for i := 0; i<100; i++ {
      v := i
      go func() {
         m["a"] = v
      }()
   }
   time.Sleep(time.Second * 3)
   fmt.Printf("%v", m)
}

创建、初始化以及赋值都非常的方便，运行一下：
图片说明
map 居然不能异步写，没关系，我们的业务需求是运行失败，失败时忽略即可，于是加上优雅的异常处理：

package main

import "fmt"
import "time"

func main() {
   m := map[string]int{
      "a": 1,
      "b": 2,
   }
   for i := 0; i<100; i++ {
      v := i
      go func() {

         defer func() {
            err := recover()
            if err != nil {
            }
         }()

         m["a"] = v
      }()
   }
   time.Sleep(time.Second * 3)
   fmt.Printf("%v", m)
}

虽然……也不是特别优雅，但至少解决了问题，类似一般语言的 try-catch，有异常就忽略掉，再次运行：
图片说明

大道至简，简陋的简

众所周知，Golang 的语法非常简洁，不像隔壁的垃圾语言那样繁琐，它的设计理念就是大道至简，非常地简洁，比如你要判断一个列表是不是包含一个元素：
图片说明

毕竟是数组，没有 List 操作也正常，我们还是来判断 Map 里面是否包含某个元素吧：

唉，算了，不就是遍历个 map 然后判断吗，我自己写一个总行了吧：

俗话说，不耻下问……

唉，虽然语法怪了点，但是只要记住了就好了，那现在就可以愉快地遍历数组了：
图片说明