HoneyHoney

 最近在看ES6，看得自己快吐了。我第一次遇到这么恶心的编程语言。真的，it sucks!

一直在改动

最大的改动还是在ES6。感觉上就是吸收了很多编程语言的优势，试图加入很多东西，比如Symbol，生成器，迭代器这些在之前版本里面都没有的功能，以及对之前一些有缺陷方法的替换方法。比如，Array(3)和Array.of(3)。原始的方法里面根据输入的不同，返回的类型还不一样，完全不符合常理啊！所以有了新方法，那实现一种功能，还有好几种方法，还得记住这些方法有哪些缺陷。一个前端工程师至少有3-5年的沉淀，记住这些演变过程。OMG。无论是Ruby还是数据库系统，都没有这么激进的改动，都是符合一些理论基础的，所以对之前的方法基本很少改动，一般都是在底层上面做性能优化。个人觉得，JavaScript在ES6之前就不是一个成熟完备的语言。

疯狂的继承

单构造函数，或者编写一个类，就有N多种写法（详见高程三），每个写法还有各自的缺陷，以至于最后出了一个关键字class来解决分歧。实际上，javascript的继承关系和其他编程语言就不是一类的。这原型继承稍不留神就要出错，比如实例属性写到prototype上去...

全局变量

你定义的变量都是全局变量，所有作用域都可见，都可以修改。变量越多，你都不知道谁改了你的变量。

没有块级作用域

虽然With和Try...Catch有块级作用域，但是在For循环里面却没有，导致内部定义的局部变量在外部可以访问了，这也是为啥let的出现。

+

如果是数字，那就是加法。否则，就是转换成字符串，再拼接起来。Amazing！

var arr = [1, 2, 3] //undefined
var arr2 = [4, 5, 6]; //undefined
arr + arr2 // '1,2,34,5,6'

伪数组

要求

思路

def listPosition(word)
  # 如果word就只有一个字母，就返回1
  return 1 if word.size == 1
  # 对word按照字母顺序排序
  sorted_chars = word.chars.sort
  # 计算每个字母的顺序
  p word_to_num_by_index = word.chars.map { |e| sorted_chars.index(e) }
  # 去重考虑，比如有N个'A'，计算所有的排列，即n!,再累乘
  p k = sorted_chars.uniq.map { |e| (1..sorted_chars.count(e)).reduce(&:*) }.reduce(&:*)

  # 针对第一个字母，先考虑剩下的字母所有的排列，即(n-1)!, 再乘以该字母在序列word_to_num_by_index中的序号
  # 假如'DBAC'，首字母为'D'，在字母序列word_to_num_by_index中排3，则可能出现以'A','B','C'打头的3种情况
  # 最后还需要处理k来去重
  p counter = (1..(word_to_num_by_index.size-1)).inject(&:*) * word_to_num_by_index[0] / k
  counter + listPosition(word[1..-1])
end

p listPosition('DBAA')
# 针对 'DBAA'，'D'在排序序列中排3，在以'D'打头之前有 3 * (4-1)! / 2 种可能
# 针对 'BAA'，'B'在排序序列中排2，在以'B'打头之前有 2 * (3-1)! / 2 种可能
# 针对 'AA'，'A'在排序序列中排0，在以'A'打头之前有 0 * (2-1)! / 2 种可能
# 针对 'A'，只有一种可能

class A
  attr_reader :x

  def initialize(x)
    @x = x
  end

  def get_binding
    binding
  end
end

a = A.new(1)
b = A.new(2)

eval 'p @x', a.get_binding
eval 'p @x', b.get_binding

class A
  attr_reader :x

  def initialize(x)
    @x = x
  end

  def get_binding
    binding
  end
end

a = A.new(1)
b = A.new(2)

a.instance_eval 'p @x'
b.instance_eval 'p @x'

p a.instance_eval { @x }
p b.instance_eval { @x }

a.instance_eval do
  def speak
    puts 'ya ya ya!'
  end
end

a.speak

b.instance_eval do
  def speak
    puts 'bia bia bia!'
  end
end

b.speak

p a.methods # => [:speak, :x, :get_binding, ...]
p a.class.instance_methods(false) # => [:x, :get_binding]
p a.singleton_class.instance_methods(false) # => [:speak]

class C
  attr_reader :name

  def initialize(name)
    @name = name
  end

  def build(m, &block)
    self.singleton_class.define_method(m) do |v|
      yield v
    end
    self
  end
end

a = C.new('jack').build(:speak) do |word|
  "says #{word}"
end
b = C.new('jane').build(:speak) do |word|
  "yells #{word}"
end

p a.speak('hello')
p b.speak('bye')
  

class B
  attr_reader :name

  def initialize(name)
    @name = name
  end

  def build(m, &block)
    self.singleton_class.define_method(m) do |v|
      instance_exec v, &block
    end
    self
  end
end

a = B.new('jack').build(:speak) do |word|
  "#{name} says #{word}"
end
b = B.new('jane').build(:speak) do |word|
  "#{name} yells #{word}"
end

p a.speak('hello')
p b.speak('bye')
  

module InstanceEach
  def each(&block)
    self.size.times { |i| self[i].instance_eval &block }
    self
  end
end
  
t = Array.new(@cnt) { A.new('') }.extend(InstanceEach)

t.each { puts name }