ruby基础

• hash定义：

hash = {
  name:"frank",
  "age"=>18
}

hash[:name]   // "frank"
hash["age"]    // 18

• hash api 总结：

hash = {name:"frank", "age"=>18}
hash.length
hash.keys // [:name,:age]
hash.values
hash.delete :name
hash.delete_if {|x| x == :name}
hash.has_key? :name

• String api 总结：

a = "hello"
a.replace : 仅改变value，不会改变索引
a.sub("e",E) // 替换匹配到的第一个字符
a.gusb  // 替换匹配到的所有字符
a.reverse
a.start_with? "h" // true 
a.include? "e" // true
a.freeze // 不允许修改了，否则抛出异常，但允许重新给a赋值
a.split "" // 返回数组
b = a.dup // 深拷贝

• Symbol(符号)是String的补充，可以看做字符串来使用，但是Symbol和String在本质上还是不同的，在Ruby中Symbol经常用来作为Hash的key和一些变化不频繁的字符串来使用。Symbol的值是唯一的

a = :hello
a.object_id  // 1000
a = :hello
a.object_id // 1000

a = "hello"
a.object_id  // 1000
a = "hello"
a.object_id  // 1006

• 以 ! 结尾的方法：

1. 会改变变量自身
2. 这只是一个约束
3. 在 Rails 中 ! 的方法也被用来抛出异常
4. 变量的地址不变

a = "hello"
b = a.capitalize
// b: "Hello", a: "hello"

a = "hello"
a.capitalize!
// a: "Hello"

• nil代表空，不代表未定义，ruby中仅仅nil 和 false代表假，其他都为真

a = nil
a.nil? //true

• ``的作用是用来直接运行shell命令的，比如 ls`
• 数组常识：

a,b = [1,2,3] // a = 1,b = 2
a, *b = [1,2,3] // a = 1,b = [2,3]，类似js的 ...args

• 数组常用 api :

a = [1,2,3]
b = [1]
// 不会改变自身
a.first
a.last
c = a + b
c - a
b * 3

// 会改变自身
a.push
a.shift
a.pop
a.unshift
a << 3
a.concat [1,2]

a.index 2
a.max

b = ["a","b","c"]
b.join " "
b.clear
b.find {|x| x=="a"}
b.map/collect {|x| x.upcase}
a.uniq //去重
a.flatten
a.sort
a.count/length
a.delete_if {|x| x=="a"}
a.each {|x| p x}

• hash是无序的，数组是有序的
• Method:

// 默认值
def hello name="world"
  p "hello #{name}"
end
hello //因为p方法返回nil，所以hello返回nil

• Block类似于一个方法；也可以理解为一个参数，其他方法调用时可以传这个参数；也可以理解为回调函数，该回调的参数是|x|。代码块可以使用do/end来定义，也可以使用{}
• 自定义Block：yield为调用外部代码块的关键字

def hi name
  yield name
end
//此时参数必须加括号
hi('world') {|x| p "hello #{x}"}

代码块可以接收参数，yield用来传递参数
def hi
  yield "hello", "world"
end
hi {|x,y| p "#{x},#{y}"}

• 显示声明 &block，用来说明该方法接收一个代码块

def hello name, &block
  block.call(name)
end
hello("frank") {|x| p "#{x}"}

• 关键字block_given?：用来判断当前方法是否有代码块传递进来

def hi 
  if block_given?
    yield
  else
    p "no block"
  end
end

• proc相当于定义一个方法变量，可以把方法当做参数传递

hi本身不会被调用，hi.call时才会被调用，因此hi可以作为一个函数变量来当做其他方法的参数
hi = proc {|x| "hello #{x}"}
hi.call("world")
等同于
hi = Proc.new {|x| "hello #{x}"}
hi.call("world")

• lambda和proc很相似，参数必须传
• ->定义代码块，类似lambda，参数必传

hello = -> (name) { "hello #{name}" }
hello.call("world")

• unless(如果没有)相当于if的反向断言，目的是为了省略条件判断中的!

a = 1
if a>=1
  "ok"
end
or
unless a<1
  'ok'
end
or
p "ok" unless a<1

• Block实践代码

class Array
  def find
    each do |value|
      return value if yield value
    end
  end
end
[1,2,3].find { |value| value == 2 }  // 2

• raise用于主动抛出异常

def hello name
  raise name
end

hello  // argument error
hello "x" // error :"x"

• 捕获异常

def hello 
  raise
end
// 知道错误情况下
begin
  hello
rescue RuntimeError
  puts "got it"
end
// 不知道情况下
begin hello
  rescue => e
    puts "catch exception with name: #{e.class}"
  else
    ...
  ensure
    # 无论有没有异常都执行
end

• 变量类型

局部变量： a = "x",b = 1
常量： Name = "ricky"
全局变量：$hello = "hello"
实例变量：@a = "a"
类变量：@@b = "b"

• 布尔表达式：

&&  => and
||  => or
!   => not

优先级比 = 等
a = nil
b = a || 1
// b: nil

• send执行一个方法

def hi
  p "hello"
end

send :hi

• respond_to?判断是否有...方法

a = [1,2,3]
a.respond_to? :length // true, 判断是否有length方法

• $LOAD_PATH
• 文件名要和内容的类或模块名一致： user_session.rb => class UserSession