класс Prism::ParametersNode

Родитель:: Prism::Node

Представляет список параметров метода, блока или определения лямбда-функции.

def a(b, c, d)
      ^^^^^^^
end

Атрибуты

block[R]

attr_reader block: BlockParameterNode?

keyword_rest[R]

attr_reader keyword_rest: Node?

keywords[R]

attr_reader keywords: Массив

optionals[R]

attr_reader optionals: Массив

posts[R]

attr_reader posts: Массив

requireds[R]

attr_reader requireds: Массив

rest[R]

attr_reader rest: Node?

Публичные методы класса

new(requireds, optionals, rest, posts, keywords, keyword_rest, block, location) Показать исходный код

# File lib/prism/node.rb, line 13187
def initialize(requireds, optionals, rest, posts, keywords, keyword_rest, block, location)
  @requireds = requireds
  @optionals = optionals
  @rest = rest
  @posts = posts
  @keywords = keywords
  @keyword_rest = keyword_rest
  @block = block
  @location = location
end

def initialize: (requireds: Массив, optionals: Массив, rest: Node?, posts: Массив, keywords: Массив, keyword_rest: Node?, block: BlockParameterNode?, location: Location) -> void

type() Показать исходный код

# File lib/prism/node.rb, line 13300
def self.type
  :parameters_node
end

Аналогично type, этот метод возвращает символ, который вы можете использовать для разделения по типу узла, без необходимости выполнения длинной цепочки ===. Обратите внимание, что, как и type, он по-прежнему будет медленнее, чем использование == для одного класса, но должен быть быстрее в операторе case или сравнении массивов.

def self.type: () -> Symbol

Публичные методы экземпляра

accept(visitor) Показать исходный код

# File lib/prism/node.rb, line 13199
def accept(visitor)
  visitor.visit_parameters_node(self)
end

def accept: (visitor: Visitor) -> void

child_nodes() Показать исходный код

# File lib/prism/node.rb, line 13204
def child_nodes
  [*requireds, *optionals, rest, *posts, *keywords, keyword_rest, block]
end

def child_nodes: () -> Массив[null | Node]

Также алиас: deconstruct

comment_targets() Показать исходный код

# File lib/prism/node.rb, line 13222
def comment_targets
  [*requireds, *optionals, *rest, *posts, *keywords, *keyword_rest, *block]
end

def comment_targets: () -> Массив[Node | Location]

compact_child_nodes() Показать исходный код

# File lib/prism/node.rb, line 13209
def compact_child_nodes
  compact = []
  compact.concat(requireds)
  compact.concat(optionals)
  compact << rest if rest
  compact.concat(posts)
  compact.concat(keywords)
  compact << keyword_rest if keyword_rest
  compact << block if block
  compact
end

def compact_child_nodes: () -> Массив

copy(**params) Показать исходный код

# File lib/prism/node.rb, line 13227
def copy(**params)
  ParametersNode.new(
    params.fetch(:requireds) { requireds },
    params.fetch(:optionals) { optionals },
    params.fetch(:rest) { rest },
    params.fetch(:posts) { posts },
    params.fetch(:keywords) { keywords },
    params.fetch(:keyword_rest) { keyword_rest },
    params.fetch(:block) { block },
    params.fetch(:location) { location },
  )
end

def copy: (**params) -> ParametersNode

deconstruct()

def deconstruct: () -> Массив[null | Node]

Псевдоним для: child_nodes

deconstruct_keys(keys) Показать исходный код

# File lib/prism/node.rb, line 13244
def deconstruct_keys(keys)
  { requireds: requireds, optionals: optionals, rest: rest, posts: posts, keywords: keywords, keyword_rest: keyword_rest, block: block, location: location }
end

inspect(inspector = NodeInspector.new) Показать исходный код

# File lib/prism/node.rb, line 13249
def inspect(inspector = NodeInspector.new)
  inspector << inspector.header(self)
  inspector << "├── requireds: #{inspector.list("#{inspector.prefix}│   ", requireds)}"
  inspector << "├── optionals: #{inspector.list("#{inspector.prefix}│   ", optionals)}"
  if (rest = self.rest).nil?
    inspector << "├── rest: ∅\n"
  else
    inspector << "├── rest:\n"
    inspector << rest.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
  end
  inspector << "├── posts: #{inspector.list("#{inspector.prefix}│   ", posts)}"
  inspector << "├── keywords: #{inspector.list("#{inspector.prefix}│   ", keywords)}"
  if (keyword_rest = self.keyword_rest).nil?
    inspector << "├── keyword_rest: ∅\n"
  else
    inspector << "├── keyword_rest:\n"
    inspector << keyword_rest.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
  end
  if (block = self.block).nil?
    inspector << "└── block: ∅\n"
  else
    inspector << "└── block:\n"
    inspector << block.inspect(inspector.child_inspector("    ")).delete_prefix(inspector.prefix)
  end
  inspector.to_str
end

def inspect(inspector: NodeInspector) -> String

signature() Показать исходный код

# File lib/prism/node_ext.rb, line 149
def signature
  names = []

  requireds.each do |param|
    names << (param.is_a?(MultiTargetNode) ? [:req] : [:req, param.name])
  end

  optionals.each { |param| names << [:opt, param.name] }
  names << [:rest, rest.name || :*] if rest

  posts.each do |param|
    names << (param.is_a?(MultiTargetNode) ? [:req] : [:req, param.name])
  end

  # Regardless of the order in which the keywords were defined, the required
  # keywords always come first followed by the optional keywords.
  keyopt = []
  keywords.each do |param|
    if param.is_a?(OptionalKeywordParameterNode)
      keyopt << param
    else
      names << [:keyreq, param.name]
    end
  end

  keyopt.each { |param| names << [:key, param.name] }

  case keyword_rest
  when ForwardingParameterNode
    names.concat([[:rest, :*], [:keyrest, :**], [:block, :&]])
  when KeywordRestParameterNode
    names << [:keyrest, keyword_rest.name || :**]
  when NoKeywordsParameterNode
    names << [:nokey]
  end

  names << [:block, block.name || :&] if block
  names
end

Отражает метод Method#parameters.

type() Показать исходный код

# File lib/prism/node.rb, line 13290
def type
  :parameters_node
end

Иногда вам нужно проверить экземпляр узла по списку классов, чтобы узнать, какое поведение выполнить. Обычно это делается с помощью вызова `[cls1, cls2].include?(node.class)` или размещения узла в операторе case и выполнения `case node; when cls1; when cls2; end`. Оба этих подхода относительно медленные из-за постоянных поисков, вызовов методов и/или выделений массивов.

Вместо этого вы можете вызвать type, который вернёт вам символ, который вы можете использовать для сравнения. Это быстрее, чем другие подходы, потому что он использует одно целочисленное сравнение, но также потому, что если вы работаете с CRuby, вы можете воспользоваться тем, что операторы case со всеми символами в качестве ключей будут использовать таблицу переходов.

def type: () -> Symbol

Ruby Core © 1993–2022 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.