class Symbol

Ein Symbol-Objekt repräsentiert einen benannten Bezeichner innerhalb des Ruby-Interpreters.

Sie können ein explizites Symbol-Objekt mit

einem Symbol-Literal erstellen.

Für einen gegebenen Namen oder eine gegebene Zeichenkette wird während der gesamten Programmausführung dasselbe Symbol-Objekt erstellt, unabhängig vom Kontext oder der Bedeutung dieses Namens. Wenn also Fred in einem Kontext eine Konstante, in einem anderen eine Methode und in einem dritten eine Klasse ist, ist das Symbol :Fred in allen drei Kontexten dasselbe Objekt.

module One
  class Fred
  end
  $f1 = :Fred
end
module Two
  Fred = 1
  $f2 = :Fred
end
def Fred()
end
$f3 = :Fred
$f1.object_id   #=> 2514190
$f2.object_id   #=> 2514190
$f3.object_id   #=> 2514190

Konstanten-, Methoden- und Variablennamen werden als Symbole zurückgegeben

module One
  Two = 2
  def three; 3 end
  @four = 4
  @@five = 5
  $six = 6
end
seven = 7

One.constants
# => [:Two]
One.instance_methods(true)
# => [:three]
One.instance_variables
# => [:@four]
One.class_variables
# => [:@@five]
global_variables.grep(/six/)
# => [:$six]
local_variables
# => [:seven]

Ein Symbol-Objekt unterscheidet sich von einem String-Objekt darin, dass ein Symbol-Objekt einen Bezeichner repräsentiert, während ein String-Objekt Text oder Daten repräsentiert.

Was gibt es hier

Zuerst, was woanders ist. Klasse Symbol

Erbt von Klasse Object.
Enthält das Modul Comparable.

Hier bietet die Klasse Symbol Methoden, die nützlich sind für

Methoden zum Abfragen

::all_symbols: Gibt ein Array der aktuell in Rubys Symboltabelle befindlichen Symbole zurück.
=~: Gibt den Index des ersten Teilstrings im Symbol zurück, der mit einem gegebenen Regexp oder einem anderen Objekt übereinstimmt; gibt nil zurück, wenn keine Übereinstimmung gefunden wird.
[], slice: Gibt einen Teilstring des Symbols zurück, der durch einen gegebenen Index, Start/Länge oder Bereich oder eine Zeichenkette bestimmt wird.
empty?: Gibt true zurück, wenn self.length null ist; andernfalls false.
encoding: Gibt das Encoding-Objekt zurück, das die Kodierung des Symbols darstellt.
end_with?: Gibt true zurück, wenn das Symbol mit einer der gegebenen Zeichenketten endet.
match: Gibt ein MatchData-Objekt zurück, wenn das Symbol mit einem gegebenen Regexp übereinstimmt; andernfalls nil.
match?: Gibt true zurück, wenn das Symbol mit einem gegebenen Regexp übereinstimmt; andernfalls false.
length, size: Gibt die Anzahl der Zeichen im Symbol zurück.
start_with?: Gibt true zurück, wenn das Symbol mit einer der gegebenen Zeichenketten beginnt.

Methoden zum Vergleichen

<=>: Gibt -1, 0 oder 1 zurück, je nachdem, ob ein gegebenes Symbol kleiner, gleich oder größer als das Symbol ist.
==, ===: Gibt true zurück, wenn ein gegebenes Symbol denselben Inhalt und dieselbe Kodierung hat.
casecmp: Ignoriert Groß-/Kleinschreibung und gibt -1, 0 oder 1 zurück, je nachdem, ob ein gegebenes Symbol kleiner, gleich oder größer als das Symbol ist.
casecmp?: Gibt true zurück, wenn das Symbol nach Unicode-Groß-/Kleinschreibungskonvertierung gleich einem gegebenen Symbol ist; andernfalls false.

Methoden zur Konvertierung

capitalize: Gibt das Symbol mit dem ersten Zeichen in Großbuchstaben und allen anderen Zeichen in Kleinbuchstaben zurück.
downcase: Gibt das Symbol mit allen Zeichen in Kleinbuchstaben zurück.
inspect: Gibt die Zeichenkettenrepräsentation von self als Symbol-Literal zurück.
name: Gibt die eingefrorene Zeichenkette zurück, die dem Symbol entspricht.
succ, next: Gibt das Symbol zurück, das der Nachfolger des Symbols ist.
swapcase: Gibt das Symbol mit allen Großbuchstaben in Kleinbuchstaben und allen Kleinbuchstaben in Großbuchstaben zurück.
to_proc: Gibt ein Proc-Objekt zurück, das auf die Methode mit dem Namen des Symbols reagiert.
to_s, id2name: Gibt die Zeichenkette zurück, die self entspricht.
to_sym, intern: Gibt self zurück.
upcase: Gibt das Symbol mit allen Zeichen in Großbuchstaben zurück.

Öffentliche Klassenmethoden

all_symbols → array_of_symbols

Source

static VALUE
sym_all_symbols(VALUE _)
{
    return rb_sym_all_symbols();
}

Gibt ein Array aller Symbole zurück, die sich derzeit in der Ruby-Symboltabelle befinden.

Symbol.all_symbols.size    # => 9334
Symbol.all_symbols.take(3) # => [:!, :"\"", :"#"]

json_create (o)

Source

# File ext/json/lib/json/add/symbol.rb, line 49
def self.json_create(o)
  o['s'].to_sym
end

Siehe as_json.

Öffentliche Instanzmethoden

self <=> other → -1, 0, 1, or nil

Source

static VALUE
sym_cmp(VALUE sym, VALUE other)
{
    if (!SYMBOL_P(other)) {
        return Qnil;
    }
    return rb_str_cmp_m(rb_sym2str(sym), rb_sym2str(other));
}

Vergleicht self und other unter Verwendung von String#<=>.

Gibt zurück

self.to_s <=> other.to_s, wenn other ein Symbol ist.
nil, andernfalls.

Beispiele

:bar <=> :foo  # => -1
:foo <=> :foo  # => 0
:foo <=> :bar  # => 1
:foo <=> 'bar' # => nil

Die Klasse Symbol schließt das Modul Comparable ein, dessen Methoden Symbol#<=> zum Vergleichen verwenden.

Verwandt: String#<=>.

symbol == object → true oder false

Source

#define sym_equal rb_obj_equal

Gibt true zurück, wenn object dasselbe Objekt wie self ist, andernfalls false.

Auch als === bekannt

===

Alias für: ==

symbol =~ object → integer oder nil

Source

static VALUE
sym_match(VALUE sym, VALUE other)
{
    return rb_str_match(rb_sym2str(sym), other);
}

Entspricht symbol.to_s =~ object, einschließlich möglicher Aktualisierungen globaler Variablen; siehe String#=~.

symbol[index] → string oder nil

symbol[start, length] → string oder nil

symbol[range] → string oder nil

symbol[regexp, capture = 0] → string oder nil

symbol[substring] → string oder nil

Source

static VALUE
sym_aref(int argc, VALUE *argv, VALUE sym)
{
    return rb_str_aref_m(argc, argv, rb_sym2str(sym));
}

Entspricht symbol.to_s[]; siehe String#[].

Auch als slice bekannt

as_json (*)

Source

# File ext/json/lib/json/add/symbol.rb, line 23
def as_json(*)
  {
    JSON.create_id => self.class.name,
    's'            => to_s,
  }
end

Die Methoden Symbol#as_json und Symbol.json_create können verwendet werden, um ein Symbol-Objekt zu serialisieren und zu deserialisieren; siehe Marshal.

Die Methode Symbol#as_json serialisiert self und gibt einen 2-elementigen Hash zurück, der self repräsentiert.

require 'json/add/symbol'
x = :foo.as_json
# => {"json_class"=>"Symbol", "s"=>"foo"}

Die Methode JSON.create deserialisiert einen solchen Hash und gibt ein Symbol-Objekt zurück.

Symbol.json_create(x) # => :foo

capitalize(mapping) → symbol

Source

static VALUE
sym_capitalize(int argc, VALUE *argv, VALUE sym)
{
    return rb_str_intern(rb_str_capitalize(argc, argv, rb_sym2str(sym)));
}

Entspricht sym.to_s.capitalize.to_sym.

Siehe String#capitalize.

casecmp(object) → -1, 0, 1 oder nil

Source

static VALUE
sym_casecmp(VALUE sym, VALUE other)
{
    if (!SYMBOL_P(other)) {
        return Qnil;
    }
    return str_casecmp(rb_sym2str(sym), rb_sym2str(other));
}

Ähnlich wie Symbol#<=>, aber ohne Berücksichtigung der Groß-/Kleinschreibung; entspricht self.to_s.casecmp(object.to_s)

lower = :abc
upper = :ABC
upper.casecmp(lower) # => 0
lower.casecmp(lower) # => 0
lower.casecmp(upper) # => 0

Gibt nil zurück, wenn self und object inkompatible Kodierungen haben oder wenn object kein Symbol ist.

sym = 'äöü'.encode("ISO-8859-1").to_sym
other_sym = 'ÄÖÜ'
sym.casecmp(other_sym) # => nil
:foo.casecmp(2)        # => nil

Im Gegensatz zu Symbol#casecmp? funktioniert die Ignorierung der Groß-/Kleinschreibung nicht für Zeichen außerhalb von ‘A’..‘Z’ und ‘a’..‘z’.

lower = :äöü
upper = :ÄÖÜ
upper.casecmp(lower) # => -1
lower.casecmp(lower) # => 0
lower.casecmp(upper) # => 1

Verwandt: Symbol#casecmp?, String#casecmp.

casecmp?(object) → true, false oder nil

Source

static VALUE
sym_casecmp_p(VALUE sym, VALUE other)
{
    if (!SYMBOL_P(other)) {
        return Qnil;
    }
    return str_casecmp_p(rb_sym2str(sym), rb_sym2str(other));
}

Gibt true zurück, wenn self und object nach Unicode-Groß-/Kleinschreibungskonvertierung gleich sind, andernfalls false.

lower = :abc
upper = :ABC
upper.casecmp?(lower) # => true
lower.casecmp?(lower) # => true
lower.casecmp?(upper) # => true

Gibt nil zurück, wenn self und object inkompatible Kodierungen haben oder wenn object kein Symbol ist.

sym = 'äöü'.encode("ISO-8859-1").to_sym
other_sym = 'ÄÖÜ'
sym.casecmp?(other_sym) # => nil
:foo.casecmp?(2)        # => nil

Im Gegensatz zu Symbol#casecmp funktioniert dies auch für Zeichen außerhalb von ‘A’..‘Z’ und ‘a’..‘z’.

lower = :äöü
upper = :ÄÖÜ
upper.casecmp?(lower) # => true
lower.casecmp?(lower) # => true
lower.casecmp?(upper) # => true

Verwandt: Symbol#casecmp, String#casecmp?.

downcase(mapping) → symbol

Source

static VALUE
sym_downcase(int argc, VALUE *argv, VALUE sym)
{
    return rb_str_intern(rb_str_downcase(argc, argv, rb_sym2str(sym)));
}

Entspricht sym.to_s.downcase.to_sym.

Siehe String#downcase.

Verwandt: Symbol#upcase.

empty? → true oder false

Source

static VALUE
sym_empty(VALUE sym)
{
    return rb_str_empty(rb_sym2str(sym));
}

Gibt true zurück, wenn self :'' ist, andernfalls false.

encoding → encoding

Source

static VALUE
sym_encoding(VALUE sym)
{
    return rb_obj_encoding(rb_sym2str(sym));
}

Entspricht self.to_s.encoding; siehe String#encoding.

end_with?(*strings) → true oder false

Source

static VALUE
sym_end_with(int argc, VALUE *argv, VALUE sym)
{
    return rb_str_end_with(argc, argv, rb_sym2str(sym));
}

Entspricht self.to_s.end_with?; siehe String#end_with?.

id2name

Alias für: to_s

inspect → String

Source

static VALUE
sym_inspect(VALUE sym)
{
    VALUE str = rb_sym2str(sym);
    const char *ptr;
    long len;
    char *dest;

    if (!rb_str_symname_p(str)) {
        str = rb_str_inspect(str);
        len = RSTRING_LEN(str);
        rb_str_resize(str, len + 1);
        dest = RSTRING_PTR(str);
        memmove(dest + 1, dest, len);
    }
    else {
        rb_encoding *enc = STR_ENC_GET(str);
        VALUE orig_str = str;

        len = RSTRING_LEN(orig_str);
        str = rb_enc_str_new(0, len + 1, enc);

        // Get data pointer after allocation
        ptr = RSTRING_PTR(orig_str);
        dest = RSTRING_PTR(str);
        memcpy(dest + 1, ptr, len);

        RB_GC_GUARD(orig_str);
    }
    dest[0] = ':';

    RUBY_ASSERT_BUILTIN_TYPE(str, T_STRING);

    return str;
}

Gibt eine Zeichenkettenrepräsentation von self zurück (einschließlich des führenden Doppelpunkts).

:foo.inspect # => ":foo"

Verwandt: Symbol#to_s, Symbol#name.

intern

Alias für: to_sym

length → integer

Source

static VALUE
sym_length(VALUE sym)
{
    return rb_str_length(rb_sym2str(sym));
}

Entspricht self.to_s.length; siehe String#length.

Auch als size bekannt

match(pattern, offset = 0) → matchdata oder nil

match(pattern, offset = 0) {|matchdata| } → object

Source

static VALUE
sym_match_m(int argc, VALUE *argv, VALUE sym)
{
    return rb_str_match_m(argc, argv, rb_sym2str(sym));
}

Entspricht self.to_s.match, einschließlich möglicher Aktualisierungen globaler Variablen; siehe String#match.

match?(pattern, offset) → true oder false

Source

static VALUE
sym_match_m_p(int argc, VALUE *argv, VALUE sym)
{
    return rb_str_match_m_p(argc, argv, sym);
}

Entspricht sym.to_s.match?; siehe String#match.

name → string

Source

# File symbol.rb, line 26
def name
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_sym2str(self)'
end

Gibt eine eingefrorene Zeichenkettenrepräsentation von self zurück (ohne den führenden Doppelpunkt).

:foo.name         # => "foo"
:foo.name.frozen? # => true

Verwandt: Symbol#to_s, Symbol#inspect.

Alias für: succ

size

Alias für: length

slice

Alias für: []

start_with?(*string_or_regexp) → true oder false

Source

static VALUE
sym_start_with(int argc, VALUE *argv, VALUE sym)
{
    return rb_str_start_with(argc, argv, rb_sym2str(sym));
}

Entspricht self.to_s.start_with?; siehe String#start_with?.

succ

Source

static VALUE
sym_succ(VALUE sym)
{
    return rb_str_intern(rb_str_succ(rb_sym2str(sym)));
}

Entspricht self.to_s.succ.to_sym

:foo.succ # => :fop

Verwandt: String#succ.

Auch als next bekannt

swapcase(mapping) → symbol

Source

static VALUE
sym_swapcase(int argc, VALUE *argv, VALUE sym)
{
    return rb_str_intern(rb_str_swapcase(argc, argv, rb_sym2str(sym)));
}

Entspricht sym.to_s.swapcase.to_sym.

Siehe String#swapcase.

to_json (state = nil, *a)

Source

# File ext/json/lib/json/add/symbol.rb, line 39
def to_json(state = nil, *a)
  state = ::JSON::State.from_state(state)
  if state.strict?
    super
  else
    as_json.to_json(state, *a)
  end
end

Gibt einen JSON-String zurück, der self repräsentiert

require 'json/add/symbol'
puts :foo.to_json

Ausgabe

# {"json_class":"Symbol","s":"foo"}

Ruft die Methode der Superklasse auf

to_proc

Source

VALUE
rb_sym_to_proc(VALUE sym)
{
    enum {SYM_PROC_CACHE_SIZE = 67};

    if (rb_ractor_main_p()) {
        if (!sym_proc_cache) {
            sym_proc_cache = rb_ary_hidden_new(SYM_PROC_CACHE_SIZE);
            rb_ary_store(sym_proc_cache, SYM_PROC_CACHE_SIZE - 1, Qnil);
        }

        ID id = SYM2ID(sym);
        long index = (id % SYM_PROC_CACHE_SIZE);
        VALUE procval = RARRAY_AREF(sym_proc_cache, index);
        if (RTEST(procval)) {
            rb_proc_t *proc;
            GetProcPtr(procval, proc);

            if (proc->block.as.symbol == sym) {
                return procval;
            }
        }

        procval = sym_proc_new(rb_cProc, sym);
        RARRAY_ASET(sym_proc_cache, index, procval);

        return RB_GC_GUARD(procval);
    }
    else {
        return sym_proc_new(rb_cProc, sym);
    }
}

Gibt ein Proc-Objekt zurück, das die Methode mit dem Namen von self auf dem ersten Parameter aufruft und die verbleibenden Parameter an die Methode übergibt.

proc = :to_s.to_proc   # => #<Proc:0x000001afe0e48680(&:to_s) (lambda)>
proc.call(1000)        # => "1000"
proc.call(1000, 16)    # => "3e8"
(1..3).collect(&:to_s) # => ["1", "2", "3"]

to_s → String

Source

# File symbol.rb, line 10
def to_s
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_sym_to_s(self)'
end

Gibt eine Zeichenkettenrepräsentation von self zurück (ohne den führenden Doppelpunkt).

:foo.to_s # => "foo"

Verwandt: Symbol#inspect, Symbol#name.

Auch als id2name bekannt

to_sym → self

Source

# File symbol.rb, line 37
def to_sym
  self
end

Gibt self zurück.

Verwandt: String#to_sym.

Auch als intern bekannt

upcase(mapping) → symbol

Source

static VALUE
sym_upcase(int argc, VALUE *argv, VALUE sym)
{
    return rb_str_intern(rb_str_upcase(argc, argv, rb_sym2str(sym)));
}

Entspricht sym.to_s.upcase.to_sym.

Siehe String#upcase.