Cache < Command 继承
https://www.cnblogs.com/tardis/p/4004438.html 更多继承
- 有时， 我们渴望子类从父类继承来的方法可以做与父类不雷同的事变，这就必要在子类中重写方法。比方， 你有一个类名字叫Email继承于类Message，两个类都有send方法，但是Email类的send方法必要有邮件地点和一系列邮件协议，但是Message中的send方法并不知道这些，与其在Email类中添加send_mail方法，而从父类继承的send方法弃之不消， 不如显式的修改send方法以顺应Email的需求。
- 另一方面， 有时子类发现它所必要的继承自父类的方法已经被改写， 不要惊骇， 我们可以直接获取父类的相应方法， 这必要使用super关键字。
- 当你在方法中调用super， 这就是告诉Ruby，在父类中找到与调用super的这个方法同名的函数，假如找到， 那么Ruby将会使用其父类版本的这个方法。
:: 语法
@cache = Downloader::Cache.new(Config.instance.cache_root + 'Pods')
你可以通过在方法名称前加上类或模块名称和 . 来调用类或模块中的方法。你可以使用类或模块名称和两个冒号 :: 来引用类或模块中的常量。
:: 是一元运算符，允许在类或模块内界说常量、实例方法和类方法，可以从类或模块外的任何地方举行访问。
请记住：在 Ruby 中，类和方法也可以被当作常量。
多行字符串
https://www.runoob.com/ruby/ruby-syntax.html
#!/usr/bin/ruby -w# -*- coding : utf-8 -*- print <<EOF 这是第一种方式创建here document 。 多行字符串。EOF print <<"EOF"; # 与上面雷同 这是第二种方式创建here document 。 多行字符串。EOF print <<`EOC` # 实行命令 echo hi there echo lo thereEOC print <<"foo", <<"bar" # 您可以把它们举行堆叠 I said foo.foo I said bar.bar <<-EOS### Installation Source ```/Executable Path: #{actual_path} ```/EOS返回值
https://www.runoob.com/ruby/ruby-method.html
Ruby 中的每个方法默认都会返回一个值。这个返回的值是最后一个语句的值。比方：
def actual_path $PROGRAM_NAME endRuby语法表明：attr_reader,attr_writer和attr_accessor
表明
变量set 和get
attr_accessor :required alias_method :required?, :required # @return [Boolean] # Indicates if the argument is repeatable (= can appear multiple # times in the command, which is indicated by '...' in the banner) # attr_accessor :repeatableattr_accessor :abc等同于def abcreturn @abcenddef abc=(abc)@abc = abcendruby中的alias和alias_method
new_name 和old_name
（12）alias :new_name  ld_name 可以用来给方法取别名。alias是个关键字，和他类似的尚有一个Module#alias_method方法
https://blog.csdn.net/raosheng1993/article/details/45458821 的第12点
if 语法
https://haicoder.net/ruby/ruby-else.html 这内里有全部的if语法记载
message = verbose_prefix + message if config.verbose? puts_indented message if config.verbose?假如 if 语句条件为真，则会实行相对应的代码
#!/usr/bin/ruby -w# -*- coding : utf-8 -*-puts "HaiCoder(www.haicoder.net)"$debug=1print "debug\n" if $debug步伐运行后，控制台输出如下：
由于 debug 变量为 1，以是我们这里输出了 debug。
Ruby if修饰符总结
在 Ruby 中，if 修饰词组表现当 if 右边之条件成立时才实行 if 左边的式子。即假如 conditional 为真，则实行 code。
:语法
冒号:
https://www.jianshu.com/p/28d7f3a17b29
# spec.authors = { "#{data[:author_name]}" => "#{data[:author_email]}" } def pod(set, mode = :normal) if mode == :name_and_version puts_indented "#{set.name} #{set.versions.first.version}" else当我说{ :bla => 1, :bloop => 2 }时，:到底是做什么的？我在某个地方读到过关于它是怎样类似于一个字符串，但不知怎的是一个符号.
:foo是一个名为"foo"的符号.符号有一个明显的特点，即任何两个定名雷同的符号都是雷同的:
"foo".equal? "foo" # false:foo.equal? :foo # true这使得比较两个符号的速率非常快(由于只涉及指针比较，而不是像比较字符串中的全部字符那样)，而且不会有大量雷同符号的副本.
别的，与字符串差异，符号是不可变的.
unless 用法
help! 'A Podfile path is required.' unless @pathhttps://haicoder.net/ruby/ruby-unless.html
在 Ruby 中，unless 语句和 if 语句作用相反，即假如 conditional 为假，则实行 code。假如 conditional 为真，则实行 else 子句中指定的 code。
Ruby unless语句详解
语法
unless conditional [then] code[else code ]endinclude ProjectDirectory 用法
unless repl_command == '\n' def execute_repl_command(repl_command) unless repl_command == '\n' repl_commands = repl_command.split subcommand = repl_commands.shift.capitalize arguments = repl_commands subcommand_class = Pod::Command::IPC.const_get(subcommand) subcommand_class.new(CLAide::ARGV.new(arguments)).run signal_end_of_output end endconcat(super)
def self.options [ ['--template-url=URL', 'The URL of the git repo containing a compatible template'], ].concat(super) end private用法
ensure 关键字
当一个方法竣事工作时我们大概必要举行清算工作.大概一个打开的文件必要关闭,缓冲区的数据应清空等等.假如对于每一个方法这里永久只有一个退出点,我们可以问心无愧地将我们的清算代码放在一个地方并知道它会被实行;但一个方法可能从多个地方返回,大概由于非常我们的清算代码被不测跳过.
使用 ensure 语句
有时间，无论是否抛出非常，您必要包管一些处理处罚在代码块竣事时完成。比方，您可能在进入时打开了一个文件，当您退出块时，您必要确保关闭文件。
ensure 子句做的就是这个。ensure 放在最后一个 rescue 子句后，并包罗一个块停止时总是实行的代码块。它与块是否正常退出、是否抛出并处理处罚非常、是否因一个未捕获的非常而停止，这些都不要紧，ensure 块始终都会运行。
https://www.runoob.com/ruby/ruby-exceptions.html
yield if block_given?
from_path = config.podfile_path.dirname if config.podfile_path if pathname from_path = config.podfile_path.dirname if config.podfile_path from_path ||= Pathname.pwd path = begin Pathname(pathname).relative_path_from(from_path) rescue pathname end "`#{path}`" elsehttps://juejin.cn/post/6844903683524673550 讲了block的回调
private
https://blog.csdn.net/qq284489030/article/details/88369791
总结一下
public方法可以被界说它的类和子类访问，并可以被类和子类的实例对象调用；
protected方法可以被界说它的类和子类访问，不能被类和子类的实例对象调用，但可以被该类和子类的实例对象(全部)访问；
private方法可以被界说它的类和子类访问，不能被类和子类的实例对象调用，且实例对象只能访问自己的private方法。
问号
def repo_update?(default: false) if @repo_update.nil? default else @repo_update end end def initialize(argv) @repo_update = argv.flag?('repo-update') super end在Ruby中有很多方法是以?和!号末了的
“？”被用于标示谓词，即返回Boolean直的方法，如Array.empty?(判断数组中元素是否为空)
“！”出现在方法名尾部的感叹号表明使用该方法是必要多加警惕。很多Ruby的焦点类都界说了
成对的方法，它们具有同样的名称，只是末了相差一个“！”,通常环境下，不带感叹号的方法返
调用该方法的一个拷贝，二带感叹号的方法则是一个可变方法，该方法会修改原来的对象，如Array
类中的sort和sort!
ruby中的方法可以以问号和叹号末了,问号通常用于谓语方法，这种方法返回一个布尔值。比方array和hash类都界说了一个empty?方法，这个方法用于测试数据结构中有没有元素。
假如方法以叹号末了，这意味着我们在使用这个方法的时间要警惕，比如大多数焦点的ruby类库方法都提供两个同名的方法，一个以叹号末了，一个没有，
区别在于，假如使用没有叹号末了的方法，你在调用它的时间会得到当前对象的一个拷贝而不会修改原始对象，而假如使用带有叹号的方法，你在调用它的时间会直接修改当前对象的值。
叹号 !
2.以感叹号末了的方法。一样平常表现这是伤害的，大概会修改吸收者对象的方法。
def insert_sort! (0...self.length).to_a.each do |j| key = self[j] i = j - 1; while i >= 0 and self > key self[i+1] = self i = i-1 end self[i+1] = key end self end`运行上述代码之后，会对传入的数据举行排序，修改了（吸收者）对象。
Ruby焦点类都界说了成对的方法，它们有同样的名字，相互的差异在于此中一个以感叹号末了，而另一个没有，通常环境下，不带感叹号的方法返回调用该方法的对象的一个修改过的拷贝，而带感叹号的方法则是一个可变的方法，该方法会修改原对象。
3.以等号末了的方法。一样平常被赋值的方法以等号末了。
def validate!
def validate!
<<
``` section << " (branch `#{@branch}`)" if @branch```方法传参 (关键字参数)
7.3.4 关键字参数
https://www.kancloud.cn/imxieke/ruby-base/107294
关键字参数是 Ruby 2.0 中的新特性。
在现在为止先容过的方法界说中，我们都必要界说调用方法时的参数个数以及调用次序。而使用关键字参数，就可以将参数名与参数值成对地传给方法内部使用。
使用关键字参数界说方法的语法如下所示：
def 方法名（参数 1: 参数 1 的值, 参数 2: 参数 2 的值, …) 渴望实行的处理处罚end除了参数名外，使用“参数名 : 值”如许的情势还可以指定参数的默认值。用关键字参数改写盘算立方体外貌积的 area 方法的步伐如下所示：
def area2(x: 0, y: 0, z: 0) xy = x * y yz = y * z zx = z * x (xy + yz + zx ) * 2endp area2(x: 2, y: 3, z: 4) #=> 52p area2(z: 4, y: 3, x: 2) #=> 52 （改变参数的次序）p area2(x: 2, z: 3) #=> 12 （省略y）这个方法有参数 x、y、z，各自的默认值都为 0。调用该方法时，可以像 x: 2 如许，指定一对现实的参数名和值。在用关键字参数界说的方法中，每个参数都指定了默认值，因此可以省略任何一个。而且，由于调用方法时也会把参数名传给方法，以是参数次序可以自由地更改。
不外，假如把未界说的参数名传给方法，步伐就会报错，如下所示：
area2(foo: 0) #=> 错误：unknown keyword: foo（ArgumentError）
为了避免调用方法时因指定了未界说的参数而报错，我们可以使用“** 变量名”的情势来 吸收未界说的参数。下面这个例子的方法中，除了关键字参数 x、y、z 外，还界说了 **arg 参数。参数 arg 会把参数列表以外的关键字参数以散列对象的情势生存。
def meth(x: 0, y: 0, z: 0, **args) [x, y, z, args]endp meth(z: 4, y: 3, x: 2) #=> [2, 3, 4, {}]p meth(x: 2, z: 3, v: 4, w: 5) #=> [2, 0, 3, {:v=>4, :w=>5}]关键字参数与平凡参数的搭配使用
关键字参数可以与平凡参数搭配使用。
def func(a, b: 1, c:2) ┊end上述如许界说时，a 为必须指定的平凡参数，b、c 为关键字参数。调用该方法时，可以像下面如许，首先指定平凡参数，然后是关键字参数。
func(1, b: 2, c: 3)用散列转达参数
调用用关键字参数界说的方法时，可以使用以符号作为键的散列来转达参数。如许一来，步伐就会查抄散列的键与界说的参数名是否同等，并将与散列的键同等的参数名转达给方法。
def area2(x: 0, y: 0, z: 0) xy = x * y yz = y * z zx = z * x (xy + yz + zx ) * 2end args1 = {x: 2, y: 3, z: 4}p area2(args1) #=> 52 args2 = {x: 2, z: 3} #=> 省略yp area2(args2) #=> 12方法调用
branch_name, = Executable.capture_command('git', %w(name-rev --name-only HEAD), :capture => ut, :chdir => source.repo)方法界说
def self.capture_command(executable, command, capture: :merge, env: {}, **kwargs) bin = which!(executable) require 'open3' command = command.map(&:to_s) case capture when :merge then Open3.capture2e(env, [bin, bin], *command, **kwargs) when :both then Open3.capture3(env, [bin, bin], *command, **kwargs) when ut then Open3.capture3(env, [bin, bin], *command, **kwargs).values_at(0, -1) when :err then Open3.capture3(env, [bin, bin], *command, **kwargs).drop(1) when :none then Open3.capture3(env, [bin, bin], *command, **kwargs).last end end箭头 向左, 向右
Ruby语言的非利用符(Nonoperator)和利用符(Operator)
https://www.huoxiaoqiang.com/ruby/rubylang/1516.html
1.<< 和 >>代表左移或右移puts 1<<2 输出结果为：4 代表1的二进制向左移动4位，即x<<y,x*2**y。寻常用不到这种方法2.字符串拼接test = "you"txt = "sb"p test<<txt输出结果为：yousb3.数组添加元素ar = Array.newar<<3p ar输出结果为：[3]**字符串拼接和数组添加元素不能使用>>git!(%W(-C #{dir} pull))
https://www.delftstack.com/zh/howto/ruby/ruby-what-does-w-mean/
array = ["one", "two", "three"]
输出：
["one", "two", "three"]
它有效，但输入引号和逗号必要耗费大量时间和精力。Ruby 为我们提供了更优雅的办理方案。
%w 语法用于创建字符串数组，而不必要在每个元素之间使用逗号或引号。
每个元素都将被视为一个字符串，并应以空格分隔。
array = %w[1 two 3.4 [] {}]
输出：
["1", "two", "3.4", "[]", "{}"]
if path =~ %r{https?://}
@podspecs_paths.each do |path| if path =~ %r{https?://} require 'cocoapods/open-uri' output_path = podspecs_tmp_dir + File.basename(path)=~ 是正则表达式
https://www.runoob.com/ruby/ruby-regular-expressions.html
正则表达式是一种特殊序列的字符，它通过使用有专门语法的模式来匹配或查找字符串聚集。
<<
files << (pathname = Pathname.new(path))
- 1.<< 和 >>代表左移或右移
puts 1<<2
输出结果为：4
代表1的二进制向左移动4位，即x<<y,x2*y。寻常用不到这种方法
- 2.字符串拼接
test = "you"
txt = "sb"
p test<<txt
输出结果为：yousb
- 3.数组添加元素
ar = Array.new
ar<<3
p ar
输出结果为：[3]
**字符串拼接和数组添加元素不能使用>>
reject的用法
].concat(super).reject { |(name, _)| name == '--no-repo-update' }reject和reject!
reject返回不满意代码块的元素数组
reject！删除数组中满意代码块的元素
a=[1,2,3,5]a.reject! {|x| x<4}p a #[5]b = [1,2,3,4,5]c = b.reject {|x| x>4}p cp b[1, 2, 3, 4][1, 2, 3, 4, 5]||= 的符号
@lockfile ||= beginhttps://blog.csdn.net/lihuan974683978/article/details/8686297
a||=123就是 当a存在但是没有赋值时 a＝123extend 关键字
extend:在界说类时使用,把module的实例方法作为当前类的类方法.
module Test def class_type "This class is of type:#{self.class}" endendclass TestClass extend Testendputs TestClass.class_type #=> This class is of type:Classmodule Pod class Command class Repo < Command self.abstract_command = true # @todo should not show a usage banner! # self.summary = 'Manage spec-repositories' self.default_subcommand = 'list' #-----------------------------------------------------------------------# extend Executable executable :git def dir config.repos_dir + @name end end endend=> 箭头函数
=>将键与哈希映射笔墨中的值分开。它不可重载，也没有专门毗连到符号。
哈希图笔墨的情势为{key1 => value1, key2 => value2, ...}，但是当用作函数的最后一个参数时，可以省略花括号。因此，当您看到类似f(:a => 1, :b => 2)的函数调用时，将使用一个参数调用f，这是一个具有键:a和:b以及值1和2的哈希映射。
def pre_download(sandbox) title = " re-downloading: `#{name}` #{description}" UI.titled_section(title, :verbose_prefix => '-> ') do target = sandbox.pod_dir(name) begin download_result = Downloader.download(download_request, target, :can_cache => can_cache) rescue Pod: SLError => e raise Informative, "Failed to load '#{name}' podspec: #{e.message}" rescue => e raise Informative, "Failed to download '#{name}': #{e.message}" end spec = download_result.spec raise Informative, "Unable to find a specification for '#{name}'." unless specdef download_request Downloader::Request.new( :name => name, :params => params, ) end? !
https://wenku.baidu.com/view/387eeb85f624ccbff121dd36a32d7375a417c6db.html
resuce
ruby 非常处理处罚 begin rescue end
begin 代码1rescue 代码2end假如实行 代码1 发生非常 则转至 代码2若正常，则实行完跳出运算符号
https://ke.qq.com/itdoc/ruby/ruby-operator.html
各种运算符
**
将右侧利用数指定为左侧利用数的指数
**=
指数幂并赋值运算符
<=>
组合比较运算符
.eql?
查抄比较利用数相称和范例是否雷同？
equal?
查抄比较对象ID是否相称
//更多请阅读：https://www.yiibai.com/ruby/operators.html
<=>
组合比较运算符。假如第一个利用数便是秒，则返回0，假如第一个利用数大于第二个，则返回1，假如第一个利用数小于第二个则返回-1。
<=>
组合比较运算符。假如第一个利用数便是秒，则返回0，假如第一个利用数大于第二个，则返回1，假如第一个利用数小于第二个则返回-1。
10 便是？
假如吸收方和参数具有雷同的对象标识，则为真。
.join 和.tap 关键词
def self.capture_command!(executable, command, **kwargs) capture_command(executable, command, **kwargs).tap do |result| result = Array(result) status = result.last unless status.success? output = result[0..-2].join raise Informative, "#{executable} #{command.join(' ')}\n\n#{output}".strip end end endjoin方法的界说
>> a=> [42, 8, 17, 7, "foo", "bar"]>> a.join # 没有毗连符=> "428177foobar">> a.join(', ') # 毗连符是一个逗号和空格=> "42, 8, 17, 7, foo, bar"https://ruby-china.org/topics/5348
分享 Rails 本领之 tap & try
当读者碰到：
user = User.newuser.username = "foobar"user.save!他们必须依照全部三行，然后才华认识到它只是在创建一个名为user.
假如是：
user = User.new.tap do |u| u.username = "foobar" u.save!end那么这将立即清晰。读者不必阅读块内的内容即可知道实例user已创建。
正如博主所做的那样，使用点击只是一种方便的方法。在您的示例中，这可能有点矫枉过正，但在您想与用户一起做很多事变的环境下，点击可以说提供了一个更简便的界面。因此，大概在以下示例中可能会更好：
user = User.new.tap do |u| u.build_profile u.process_credit_card u.ship_out_item u.send_email_confirmation u.blahblahyougetmypointend使用上面的方法可以很容易地快速看到全部这些方法都组合在一起，由于它们都引用同一个对象（本例中的用户）。更换方案是：
user = User.newuser.build_profileuser.process_credit_carduser.ship_out_itemuser.send_email_confirmationuser.blahblahyougetmypoint同样，这是有争议的 - 但可以证明第二个版本看起来有点紊乱，而且必要更多的人工剖析才华看到全部方法都在同一个对象上被调用。
gsub
https://blog.csdn.net/sqlxx/article/details/8164554
ruby中带“!"和不带"!"的方法的最大的区别就是带”!"的会改变调用对象自己了。比方说str.gsub(/a/, 'b')，不会改变str自己，只会返回一个新的str。而str.gsub!(/a/, 'b')就会把str自己给改了。
但是gsub和gsub!尚有别的一个差异点就是，gsub不管怎么样都会返回一个新的字符串，而gsub!只有在有字符被更换的环境下才会返回一个新的字符串，假如说没有任何字符被更换，gsub!只会返回nil.
example:
'abc'.gsub(/a/, 'b') #返回'bbc''abc'.gsub!(/a/, 'b') #返回'bbc''abc'.gsub(/d/,'a') #返回'abc''abc'.gsub!(/d/, 'a') #返回nilscan match
https://blog.csdn.net/cz9025/article/details/90202839
用法：
新建文件xx.rb内容为：
module ModuleName def fn p "module cz" endend以获得module名为例：
Dir["xx.rb"].each do |file| name1 = File.read(file).scan(/module (.*)/) p name1 name2 = File.read(file).match(/module (.*)/) p name2 name3 = File.read(file).scan(/hh (.*)/) p name3 name4 = File.read(file).match(/hh (.*)/) p name4end运行结果为：
区别
scan: 查找全部匹配的内容，返回一个数组。 假如未匹配到，返回[]。 返回结果：()匹配到的内容。match: 只匹配第一次，返回为MatchData范例。 假如未匹配到，返回nil。 返回结果：完备匹配部门+（）匹配到的内容。.map(&:to_s)
https://wenku.baidu.com/view/39aae24e26c52cc58bd63186bceb19e8b8f6ecae.html
Hash.key？(obj)方法
https://www.nhooo.com/note/qa55qj.html
在本文中，我们将研究Hash.key？(obj)方法。由于该方法的名称完全差异，因此无法举行假设。让我们阅读其界说并在语法和步伐代码的资助下相识实在现。
方法阐明：
该方法是Public实例方法，属于Hash类，它位于Ruby语言库中。Hash.key？()方法用于查抄键（键值）是否为特定Hash实例的一部门，而且该Hash实例应为平凡的Hash实例。它将搜刮整个哈希，并根据其搜刮结果。让我们来看一下语法，并演示该方法的步伐代码。
假如您正在思量它将返回什么，那么让我告诉您，它将返回一个布尔值。假如在哈希表中找到键，则返回值将为true；假如找不到哈希表实例的一部门，则返回值为false。
语法：
Hash_instance.key?(obj)Argument(s) 必要：
此方法仅使用一个参数，而该参数不外是我们要查抄其存在性的键。
范例1：
=begin Ruby program to demonstrate Hash.key? method=end hsh = {"colors" => "red","letters" => "a", "Fruit" => "Grapes"}puts "Hash.key? implementation:"puts "Enter the Key you want to search: "ky = gets.chompif (hsh.key?(ky)) puts "Key found successfully"else puts "Key not found!"end输出
Hash.key? implementation:Enter the Key you want to search: colorsKey found successfully在上面的代码中，您可以观察到我们在平凡的Hash实例上调用Hash.key？()方法。当它在用户输入的哈希对象中发现键存在时，它返回true。
范例2：
=begin Ruby program to demonstrate Hash.key? method=end hsh = {"colors" => "red","letters" => "a", "Fruit" => "Grapes"}hsh1 = {"cars" => "800","bike" => "pulsar", "phone" => "A50"}hsh2 = {"one"=> hsh, "two" => hsh1}puts "Hash.key? implementation:"puts "Enter the Key you want to search: "ky = gets.chompif (hsh2.key?(ky)) puts "Key found successfully"else puts "Key not found!"end输出结果
Hash.key? implementation:Enter the Key you want to search: colorsKey not found!阐明：
在上面的代码中，您可以验证Hash.key？()方法不实用于作为多个Hash实例聚集的Hash实例。纵然对象是Hash实例的一部门，它也会返回false。 |
