класс Prism::PostExecutionNode

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

Представляет использование ключевого слова ‘END`.

END { foo }
^^^^^^^^^^^

Атрибуты

closing_loc[R]

attr_reader closing_loc: Location

keyword_loc[R]

attr_reader keyword_loc: Location

opening_loc[R]

attr_reader opening_loc: Location

statements[R]

attr_reader statements: StatementsNode?

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

new(statements, keyword_loc, opening_loc, closing_loc, location) Показать исходный код

# File lib/prism/node.rb, line 13662
def initialize(statements, keyword_loc, opening_loc, closing_loc, location)
  @statements = statements
  @keyword_loc = keyword_loc
  @opening_loc = opening_loc
  @closing_loc = closing_loc
  @location = location
end

def initialize: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void

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

# File lib/prism/node.rb, line 13765
def self.type
  :post_execution_node
end

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

def self.type: () -> Symbol

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

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

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

def accept: (visitor: Visitor) -> void

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

# File lib/prism/node.rb, line 13676
def child_nodes
  [statements]
end

def child_nodes: () -> Array[nil | Node]

Также алиасируется как: deconstruct

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

# File lib/prism/node.rb, line 13722
def closing
  closing_loc.slice
end

def closing: () -> String

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

# File lib/prism/node.rb, line 13688
def comment_targets
  [*statements, keyword_loc, opening_loc, closing_loc]
end

def comment_targets: () -> Array[Node | Location]

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

# File lib/prism/node.rb, line 13681
def compact_child_nodes
  compact = []
  compact << statements if statements
  compact
end

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

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

# File lib/prism/node.rb, line 13693
def copy(**params)
  PostExecutionNode.new(
    params.fetch(:statements) { statements },
    params.fetch(:keyword_loc) { keyword_loc },
    params.fetch(:opening_loc) { opening_loc },
    params.fetch(:closing_loc) { closing_loc },
    params.fetch(:location) { location },
  )
end

def copy: (**params) -> PostExecutionNode

deconstruct()

def deconstruct: () -> Array[nil | Node]

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

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

# File lib/prism/node.rb, line 13707
def deconstruct_keys(keys)
  { statements: statements, keyword_loc: keyword_loc, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
end

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

# File lib/prism/node.rb, line 13727
def inspect(inspector = NodeInspector.new)
  inspector << inspector.header(self)
  if (statements = self.statements).nil?
    inspector << "├── statements: ∅\n"
  else
    inspector << "├── statements:\n"
    inspector << statements.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
  end
  inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
  inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
  inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
  inspector.to_str
end

def inspect(inspector: NodeInspector) -> String

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

# File lib/prism/node.rb, line 13712
def keyword
  keyword_loc.slice
end

def keyword: () -> String

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

# File lib/prism/node.rb, line 13717
def opening
  opening_loc.slice
end

def opening: () -> String

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

# File lib/prism/node.rb, line 13755
def type
  :post_execution_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.