класс Prism::ConstantPathTargetNode

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

Представляет запись в постоянный путь в контексте, у которого нет явного значения.

Foo::Foo, Bar::Bar = baz
^^^^^^^^  ^^^^^^^^

Атрибуты

child[R]

attr_reader child: Node

delimiter_loc[R]

attr_reader delimiter_loc: Location

parent[R]

attr_reader parent: Node?

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

new(parent, child, delimiter_loc, location) Показать исходный код

# File lib/prism/node.rb, line 4742
def initialize(parent, child, delimiter_loc, location)
  @parent = parent
  @child = child
  @delimiter_loc = delimiter_loc
  @location = location
end

def initialize: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> void

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

# File lib/prism/node.rb, line 4834
def self.type
  :constant_path_target_node
end

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

def self.type: () -> Symbol

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

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

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

def accept: (visitor: Visitor) -> void

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

# File lib/prism/node.rb, line 4755
def child_nodes
  [parent, child]
end

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

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

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

# File lib/prism/node.rb, line 4768
def comment_targets
  [*parent, child, delimiter_loc]
end

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

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

# File lib/prism/node.rb, line 4760
def compact_child_nodes
  compact = []
  compact << parent if parent
  compact << child
  compact
end

def compact_child_nodes: () -> Array

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

# File lib/prism/node.rb, line 4773
def copy(**params)
  ConstantPathTargetNode.new(
    params.fetch(:parent) { parent },
    params.fetch(:child) { child },
    params.fetch(:delimiter_loc) { delimiter_loc },
    params.fetch(:location) { location },
  )
end

def copy: (**params) -> ConstantPathTargetNode

deconstruct()

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

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

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

# File lib/prism/node.rb, line 4786
def deconstruct_keys(keys)
  { parent: parent, child: child, delimiter_loc: delimiter_loc, location: location }
end

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

# File lib/prism/node.rb, line 4791
def delimiter
  delimiter_loc.slice
end

def delimiter: () -> String

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

# File lib/prism/node_ext.rb, line 142
def full_name
  full_name_parts.join("::")
end

Возвращает полное имя этого постоянного пути. Например: «Foo::Bar»

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

# File lib/prism/node_ext.rb, line 137
def full_name_parts
  (parent&.full_name_parts || [:""]).push(child.name)
end

Возвращает список частей полного имени этого постоянного пути. Например: [:Foo, :Bar]

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

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

def inspect(inspector: NodeInspector) -> String

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

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