класс Prism::CaseMatchNode

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

Представляет использование оператора case для сопоставления с образцом.

case true
in false
end
^^^^^^^^^

Атрибуты

case_keyword_loc[R]

attr_reader case_keyword_loc: Location

conditions[R]

attr_reader conditions: Массив

consequent[R]

attr_reader consequent: ElseNode?

end_keyword_loc[R]

attr_reader end_keyword_loc: Location

predicate[R]

attr_reader predicate: Node?

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

new(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location) Показать исходный код

# File lib/prism/node.rb, line 2948
def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location)
  @predicate = predicate
  @conditions = conditions
  @consequent = consequent
  @case_keyword_loc = case_keyword_loc
  @end_keyword_loc = end_keyword_loc
  @location = location
end

def initialize: (predicate: Node?, conditions: Массив, consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> void

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

# File lib/prism/node.rb, line 3056
def self.type
  :case_match_node
end

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

def self.type: () -> Symbol

Общедоступные методы экземпляров

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

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

def accept: (visitor: Visitor) -> void

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

# File lib/prism/node.rb, line 3002
def case_keyword
  case_keyword_loc.slice
end

def case_keyword: () -> String

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

# File lib/prism/node.rb, line 2963
def child_nodes
  [predicate, *conditions, consequent]
end

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

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

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

# File lib/prism/node.rb, line 2977
def comment_targets
  [*predicate, *conditions, *consequent, case_keyword_loc, end_keyword_loc]
end

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

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

# File lib/prism/node.rb, line 2968
def compact_child_nodes
  compact = []
  compact << predicate if predicate
  compact.concat(conditions)
  compact << consequent if consequent
  compact
end

def compact_child_nodes: () -> Array

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

# File lib/prism/node.rb, line 2982
def copy(**params)
  CaseMatchNode.new(
    params.fetch(:predicate) { predicate },
    params.fetch(:conditions) { conditions },
    params.fetch(:consequent) { consequent },
    params.fetch(:case_keyword_loc) { case_keyword_loc },
    params.fetch(:end_keyword_loc) { end_keyword_loc },
    params.fetch(:location) { location },
  )
end

def copy: (**params) -> CaseMatchNode

deconstruct()

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

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

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

# File lib/prism/node.rb, line 2997
def deconstruct_keys(keys)
  { predicate: predicate, conditions: conditions, consequent: consequent, case_keyword_loc: case_keyword_loc, end_keyword_loc: end_keyword_loc, location: location }
end

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

# File lib/prism/node.rb, line 3007
def end_keyword
  end_keyword_loc.slice
end

def end_keyword: () -> String

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

# File lib/prism/node.rb, line 3012
def inspect(inspector = NodeInspector.new)
  inspector << inspector.header(self)
  if (predicate = self.predicate).nil?
    inspector << "├── predicate: ∅\n"
  else
    inspector << "├── predicate:\n"
    inspector << predicate.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
  end
  inspector << "├── conditions: #{inspector.list("#{inspector.prefix}│   ", conditions)}"
  if (consequent = self.consequent).nil?
    inspector << "├── consequent: ∅\n"
  else
    inspector << "├── consequent:\n"
    inspector << consequent.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
  end
  inspector << "├── case_keyword_loc: #{inspector.location(case_keyword_loc)}\n"
  inspector << "└── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
  inspector.to_str
end

def inspect(inspector: NodeInspector) -> String

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

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