класс Prism::ArrayPatternNode

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

Представляет массивный шаблон в сопоставлении с шаблонами.

foo in 1, 2
^^^^^^^^^^^

foo in [1, 2]
^^^^^^^^^^^^^

foo in *1
^^^^^^^^^

foo in Bar[]
^^^^^^^^^^^^

foo in Bar[1, 2, 3]
^^^^^^^^^^^^^^^^^^^

Атрибуты

closing_loc[R]

attr_reader closing_loc: Location?

constant[R]

attr_reader constant: Node?

opening_loc[R]

attr_reader opening_loc: Location?

posts[R]

attr_reader posts: Массив

requireds[R]

attr_reader requireds: Массив

rest[R]

attr_reader rest: Node?

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

new(constant, requireds, rest, posts, opening_loc, closing_loc, location) Показать исходный код

# File lib/prism/node.rb, line 723
def initialize(constant, requireds, rest, posts, opening_loc, closing_loc, location)
  @constant = constant
  @requireds = requireds
  @rest = rest
  @posts = posts
  @opening_loc = opening_loc
  @closing_loc = closing_loc
  @location = location
end

def initialize: (constant: Node?, requireds: Массив, rest: Node?, posts: Массив, opening_loc: Location?, closing_loc: Location?, location: Location) -> void

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

# File lib/prism/node.rb, line 835
def self.type
  :array_pattern_node
end

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

def self.type: () -> Symbol

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

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

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

def accept: (visitor: Visitor) -> void

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

# File lib/prism/node.rb, line 739
def child_nodes
  [constant, *requireds, rest, *posts]
end

def child_nodes: () -> Массив[nil | Узел]

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

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

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

def closing: () -> String?

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

# File lib/prism/node.rb, line 754
def comment_targets
  [*constant, *requireds, *rest, *posts, *opening_loc, *closing_loc]
end

def comment_targets: () -> Массив[Узел | Местоположение]

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

# File lib/prism/node.rb, line 744
def compact_child_nodes
  compact = []
  compact << constant if constant
  compact.concat(requireds)
  compact << rest if rest
  compact.concat(posts)
  compact
end

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

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

# File lib/prism/node.rb, line 759
def copy(**params)
  ArrayPatternNode.new(
    params.fetch(:constant) { constant },
    params.fetch(:requireds) { requireds },
    params.fetch(:rest) { rest },
    params.fetch(:posts) { posts },
    params.fetch(:opening_loc) { opening_loc },
    params.fetch(:closing_loc) { closing_loc },
    params.fetch(:location) { location },
  )
end

def copy: (**params) -> ArrayPatternNode

deconstruct()

def deconstruct: () -> Массив[nil | Узел]

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

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

# File lib/prism/node.rb, line 775
def deconstruct_keys(keys)
  { constant: constant, requireds: requireds, rest: rest, posts: posts, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
end

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

# File lib/prism/node.rb, line 790
def inspect(inspector = NodeInspector.new)
  inspector << inspector.header(self)
  if (constant = self.constant).nil?
    inspector << "├── constant: ∅\n"
  else
    inspector << "├── constant:\n"
    inspector << constant.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
  end
  inspector << "├── requireds: #{inspector.list("#{inspector.prefix}│   ", requireds)}"
  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 << "├── opening_loc: #{inspector.location(opening_loc)}\n"
  inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
  inspector.to_str
end

def inspect(inspector: NodeInspector) -> String

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

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

def opening: () -> String?

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

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