класс StringScanner

Родитель:: Объект

StringScanner обеспечивает лексический анализ строки. Вот пример его использования:

s = StringScanner.new('This is an example string')
s.eos?               # -> false

p s.scan(/\w+/)      # -> "This"
p s.scan(/\w+/)      # -> nil
p s.scan(/\s+/)      # -> " "
p s.scan(/\s+/)      # -> nil
p s.scan(/\w+/)      # -> "is"
s.eos?               # -> false

p s.scan(/\s+/)      # -> " "
p s.scan(/\w+/)      # -> "an"
p s.scan(/\s+/)      # -> " "
p s.scan(/\w+/)      # -> "example"
p s.scan(/\s+/)      # -> " "
p s.scan(/\w+/)      # -> "string"
s.eos?               # -> true

p s.scan(/\s+/)      # -> nil
p s.scan(/\w+/)      # -> nil

Анализ строки подразумевает запоминание позиции указателя сканирования, которая представляет собой просто индекс. Цель сканирования — перемещаться вперед понемногу, поэтому соответствия ищутся после указателя сканирования; обычно сразу после него.

Рассмотрим строку «test string», вот соответствующие позиции указателя сканирования:

  t e s t   s t r i n g
0 1 2 ...             1
                      0

При сканировании шаблона (регулярного выражения), соответствие должно происходить после символа, следующего за указателем сканирования. Если вы используете scan_until, то соответствие может произойти где угодно после указателя сканирования. В обоих случаях указатель сканирования перемещается немного за последний символ соответствия, готовый снова начать сканирование с следующего символа. Это демонстрируется на примере выше.

Методы Категории

Помимо простых сканеров, есть и другие методы. Вы можете предвидеть содержимое строки, не фактически сканируя его. Вы можете получить доступ к последнему совпадению. Вы можете изменить анализируемую строку, сбросить или завершить сканер, узнать или изменить позицию указателя сканирования, перейти вперед и так далее.

Перемещение указателя сканирования

Предварительный просмотр

Определение текущей позиции

Установка текущей позиции

Данные соответствия

Разное

Существуют псевдонимы для нескольких методов.

Методы публичного класса

must_C_version Показать исходный код

static VALUE
strscan_s_mustc(VALUE self)
{
    return self;
}

Этот метод определён для обратной совместимости.

new(string, dup = false) Показать исходный код

static VALUE
strscan_initialize(int argc, VALUE *argv, VALUE self)
{
    struct strscanner *p;
    VALUE str, need_dup;

    p = check_strscan(self);
    rb_scan_args(argc, argv, "11", &str, &need_dup);
    StringValue(str);
    p->str = str;

    return self;
}

Создаёт новый объект StringScanner для сканирования заданной string. dup аргумент устарел и сейчас не используется.

Открытые методы экземпляра

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

static VALUE
strscan_concat(VALUE self, VALUE str)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    StringValue(str);
    rb_str_append(p->str, str);
    return self;
}

Добавляет str к сканируемой строке. Этот метод не влияет на указатель сканирования.

s = StringScanner.new("Fri Dec 12 1975 14:39")
s.scan(/Fri /)
s << " +1000 GMT"
s.string            # -> "Fri Dec 12 1975 14:39 +1000 GMT"
s.scan(/Dec/)       # -> "Dec"

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

static VALUE
strscan_aref(VALUE self, VALUE idx)
{
    const char *name;
    struct strscanner *p;
    long i;

    GET_SCANNER(self, p);
    if (! MATCHED_P(p))        return Qnil;

    switch (TYPE(idx)) {
        case T_SYMBOL:
            idx = rb_sym2str(idx);
            /* fall through */
        case T_STRING:
            RSTRING_GETMEM(idx, name, i);
            i = name_to_backref_number(&(p->regs), p->regex, name, name + i, rb_enc_get(idx));
            break;
        default:
            i = NUM2LONG(idx);
    }

    if (i < 0)
        i += p->regs.num_regs;
    if (i < 0)                 return Qnil;
    if (i >= p->regs.num_regs) return Qnil;
    if (p->regs.beg[i] == -1)  return Qnil;

    return extract_range(p, p->prev + p->regs.beg[i],
                            p->prev + p->regs.end[i]);
}

Возвращает n-ю подгруппу в последнем совпадении.

s = StringScanner.new("Fri Dec 12 1975 14:39")
s.scan(/(\w+) (\w+) (\d+) /)       # -> "Fri Dec 12 "
s[0]                               # -> "Fri Dec 12 "
s[1]                               # -> "Fri"
s[2]                               # -> "Dec"
s[3]                               # -> "12"
s.post_match                       # -> "1975 14:39"
s.pre_match                        # -> ""

s.reset
s.scan(/(?<wday>\w+) (?<month>\w+) (?<day>\d+) /)       # -> "Fri Dec 12 "
s[0]                               # -> "Fri Dec 12 "
s[1]                               # -> "Fri"
s[2]                               # -> "Dec"
s[3]                               # -> "12"
s[:wday]                           # -> "Fri"
s[:month]                          # -> "Dec"
s[:day]                            # -> "12"
s.post_match                       # -> "1975 14:39"
s.pre_match                        # -> ""

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

static VALUE
strscan_bol_p(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    if (CURPTR(p) > S_PEND(p)) return Qnil;
    if (p->curr == 0) return Qtrue;
    return (*(CURPTR(p) - 1) == '\n') ? Qtrue : Qfalse;
}

Возвращает true если указатель сканирования находится в начале строки.

s = StringScanner.new("test\ntest\n")
s.bol?           # => true
s.scan(/te/)
s.bol?           # => false
s.scan(/st\n/)
s.bol?           # => true
s.terminate
s.bol?           # => true

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

static VALUE
strscan_get_charpos(VALUE self)
{
    struct strscanner *p;
    VALUE substr;

    GET_SCANNER(self, p);

    substr = rb_funcall(p->str, id_byteslice, 2, INT2FIX(0), INT2NUM(p->curr));

    return rb_str_length(substr);
}

Возвращает позицию символа указателя сканирования. В позиции «сброс» это значение равно нулю. В позиции «завершено» (т. е. строка исчерпана), это значение равно размеру строки.

Короче говоря, это индекс, основанный на 0, в строке.

s = StringScanner.new("abcädeföghi")
s.charpos           # -> 0
s.scan_until(/ä/)   # -> "abcä"
s.pos               # -> 5
s.charpos           # -> 4

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

static VALUE
strscan_check(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 0, 1, 1);
}

Возвращает значение, которое вернул бы scan, не перемещая указатель сканирования. Однако регистр соответствия изменяется.

s = StringScanner.new("Fri Dec 12 1975 14:39")
s.check /Fri/               # -> "Fri"
s.pos                       # -> 0
s.matched                   # -> "Fri"
s.check /12/                # -> nil
s.matched                   # -> nil

Мнемоника: он «проверяет», вернет ли scan значение.

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

static VALUE
strscan_check_until(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 0, 1, 0);
}

Возвращает значение, которое вернул бы scan_until, не перемещая указатель сканирования. Однако регистр соответствия изменяется.

s = StringScanner.new("Fri Dec 12 1975 14:39")
s.check_until /12/          # -> "Fri Dec 12"
s.pos                       # -> 0
s.matched                   # -> 12

Мнемоника: он «проверяет», вернет ли scan_until значение.

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

static VALUE
strscan_clear(VALUE self)
{
    rb_warning("StringScanner#clear is obsolete; use #terminate instead");
    return strscan_terminate(self);
}

Эквивалентно terminate. Этот метод устарел; используйте terminate вместо него.

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

static VALUE
strscan_concat(VALUE self, VALUE str)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    StringValue(str);
    rb_str_append(p->str, str);
    return self;
}

Добавляет str к сканируемой строке. Этот метод не влияет на указатель сканирования.

s = StringScanner.new("Fri Dec 12 1975 14:39")
s.scan(/Fri /)
s << " +1000 GMT"
s.string            # -> "Fri Dec 12 1975 14:39 +1000 GMT"
s.scan(/Dec/)       # -> "Dec"

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

static VALUE
strscan_empty_p(VALUE self)
{
    rb_warning("StringScanner#empty? is obsolete; use #eos? instead");
    return strscan_eos_p(self);
}

Эквивалентно eos?. Этот метод устарел, используйте eos? вместо него.

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

static VALUE
strscan_eos_p(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    return EOS_P(p) ? Qtrue : Qfalse;
}

Возвращает true если указатель сканирования находится в конце строки.

s = StringScanner.new('test string')
p s.eos?          # => false
s.scan(/test/)
p s.eos?          # => false
s.terminate
p s.eos?          # => true

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

static VALUE
strscan_exist_p(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 0, 0, 0);
}

Заглядывает вперед, чтобы проверить, существует ли pattern где-либо в строке, не перемещая указатель сканирования. Это определяет, вернет ли scan_until значение.

s = StringScanner.new('test string')
s.exist? /s/            # -> 3
s.scan /test/           # -> "test"
s.exist? /s/            # -> 2
s.exist? /e/            # -> nil

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

static VALUE
strscan_get_byte(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    CLEAR_MATCH_STATUS(p);
    if (EOS_P(p))
        return Qnil;

    p->prev = p->curr;
    p->curr++;
    MATCHED(p);
    adjust_registers_to_matched(p);
    return extract_range(p, p->prev + p->regs.beg[0],
                            p->prev + p->regs.end[0]);
}

Сканирует один байт и возвращает его. Этот метод не чувствителен к многобайтовым символам. См. также: getch.

s = StringScanner.new('ab')
s.get_byte         # => "a"
s.get_byte         # => "b"
s.get_byte         # => nil

$KCODE = 'EUC'
s = StringScanner.new("\244\242")
s.get_byte         # => "\244"
s.get_byte         # => "\242"
s.get_byte         # => nil

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

static VALUE
strscan_getbyte(VALUE self)
{
    rb_warning("StringScanner#getbyte is obsolete; use #get_byte instead");
    return strscan_get_byte(self);
}

Эквивалентно get_byte. Этот метод устарел; используйте get_byte вместо него.

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

static VALUE
strscan_getch(VALUE self)
{
    struct strscanner *p;
    long len;

    GET_SCANNER(self, p);
    CLEAR_MATCH_STATUS(p);
    if (EOS_P(p))
        return Qnil;

    len = rb_enc_mbclen(CURPTR(p), S_PEND(p), rb_enc_get(p->str));
    if (p->curr + len > S_LEN(p)) {
        len = S_LEN(p) - p->curr;
    }
    p->prev = p->curr;
    p->curr += len;
    MATCHED(p);
    adjust_registers_to_matched(p);
    return extract_range(p, p->prev + p->regs.beg[0],
                            p->prev + p->regs.end[0]);
}

Сканирует один символ и возвращает его. Этот метод чувствителен к многобайтовым символам.

s = StringScanner.new("ab")
s.getch           # => "a"
s.getch           # => "b"
s.getch           # => nil

$KCODE = 'EUC'
s = StringScanner.new("\244\242")
s.getch           # => "\244\242"   # Japanese hira-kana "A" in EUC-JP
s.getch           # => nil

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

static VALUE
strscan_inspect(VALUE self)
{
    struct strscanner *p;
    VALUE a, b;

    p = check_strscan(self);
    if (NIL_P(p->str)) {
        a = rb_sprintf("#<%"PRIsVALUE" (uninitialized)>", rb_obj_class(self));
        return infect(a, p);
    }
    if (EOS_P(p)) {
        a = rb_sprintf("#<%"PRIsVALUE" fin>", rb_obj_class(self));
        return infect(a, p);
    }
    if (p->curr == 0) {
        b = inspect2(p);
        a = rb_sprintf("#<%"PRIsVALUE" %ld/%ld @ %"PRIsVALUE">",
                       rb_obj_class(self),
                       p->curr, S_LEN(p),
                       b);
        return infect(a, p);
    }
    a = inspect1(p);
    b = inspect2(p);
    a = rb_sprintf("#<%"PRIsVALUE" %ld/%ld %"PRIsVALUE" @ %"PRIsVALUE">",
                   rb_obj_class(self),
                   p->curr, S_LEN(p),
                   a, b);
    return infect(a, p);
}

Возвращает строку, представляющую объект StringScanner, показывающую:

текущую позицию
размер строки
символы, окружающие указатель сканирования

s = ::new(“Fri Dec 12 1975 14:39”) s.inspect # -> '#<StringScanner 0/21 @ “Fri D…”>' s.scan_until /12/ # -> “Fri Dec 12” s.inspect # -> '#<StringScanner 10/21 “…ec 12” @ “ 1975…”>'

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

static VALUE
strscan_match_p(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 0, 0, 1);
}

Проверяет, соответствует ли данный pattern текущему указателю сканирования. Возвращает длину совпадения или nil. Указатель сканирования не перемещается.

s = StringScanner.new('test string')
p s.match?(/\w+/)   # -> 4
p s.match?(/\w+/)   # -> 4
p s.match?(/\s+/)   # -> nil

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

static VALUE
strscan_matched(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    if (! MATCHED_P(p)) return Qnil;
    return extract_range(p, p->prev + p->regs.beg[0],
                            p->prev + p->regs.end[0]);
}

Возвращает последнюю найденную подстроку.

s = StringScanner.new('test string')
s.match?(/\w+/)     # -> 4
s.matched           # -> "test"

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

static VALUE
strscan_matched_p(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    return MATCHED_P(p) ? Qtrue : Qfalse;
}

Возвращает true если последнее совпадение было успешным.

s = StringScanner.new('test string')
s.match?(/\w+/)     # => 4
s.matched?          # => true
s.match?(/\d+/)     # => nil
s.matched?          # => false

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

static VALUE
strscan_matched_size(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    if (! MATCHED_P(p)) return Qnil;
    return INT2NUM(p->regs.end[0] - p->regs.beg[0]);
}

Возвращает размер последнего совпадения (см. matched) или nil если не было недавнего совпадения.

s = StringScanner.new('test string')
s.check /\w+/           # -> "test"
s.matched_size          # -> 4
s.check /\d+/           # -> nil
s.matched_size          # -> nil

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

static VALUE
strscan_peek(VALUE self, VALUE vlen)
{
    struct strscanner *p;
    long len;

    GET_SCANNER(self, p);

    len = NUM2LONG(vlen);
    if (EOS_P(p))
        return infect(str_new(p, "", 0), p);

    if (p->curr + len > S_LEN(p))
        len = S_LEN(p) - p->curr;
    return extract_beg_len(p, p->curr, len);
}

Извлекает строку, соответствующую string[pos,len], не перемещая указатель сканирования.

s = StringScanner.new('test string')
s.peek(7)          # => "test st"
s.peek(7)          # => "test st"

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

static VALUE
strscan_peep(VALUE self, VALUE vlen)
{
    rb_warning("StringScanner#peep is obsolete; use #peek instead");
    return strscan_peek(self, vlen);
}

Эквивалентно peek. Этот метод устарел; используйте peek вместо него.

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

static VALUE
strscan_get_pos(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    return INT2FIX(p->curr);
}

Возвращает байтовую позицию указателя сканирования. В позиции «сброс» это значение равно нулю. В позиции «завершено» (т. е. строка исчерпана), это значение равно размеру строки в байтах.

Короче говоря, это индекс, основанный на 0, в байтах строки.

s = StringScanner.new('test string')
s.pos               # -> 0
s.scan_until /str/  # -> "test str"
s.pos               # -> 8
s.terminate         # -> #<StringScanner fin>
s.pos               # -> 11

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

static VALUE
strscan_set_pos(VALUE self, VALUE v)
{
    struct strscanner *p;
    long i;

    GET_SCANNER(self, p);
    i = NUM2INT(v);
    if (i < 0) i += S_LEN(p);
    if (i < 0) rb_raise(rb_eRangeError, "index out of range");
    if (i > S_LEN(p)) rb_raise(rb_eRangeError, "index out of range");
    p->curr = i;
    return INT2NUM(i);
}

Установить позицию указателя сканирования байтов.

s = StringScanner.new('test string')
s.pos = 7            # -> 7
s.rest               # -> "ring"

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

static VALUE
strscan_get_pos(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    return INT2FIX(p->curr);
}

Возвращает позицию указателя сканирования в байтах. В позиции «сброс» это значение равно нулю. В позиции «завершение» (т.е. строка исчерпана) это значение равно размеру строки в байтах.

Короче говоря, это индекс (с нуля) байта в строке.

s = StringScanner.new('test string')
s.pos               # -> 0
s.scan_until /str/  # -> "test str"
s.pos               # -> 8
s.terminate         # -> #<StringScanner fin>
s.pos               # -> 11

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

static VALUE
strscan_set_pos(VALUE self, VALUE v)
{
    struct strscanner *p;
    long i;

    GET_SCANNER(self, p);
    i = NUM2INT(v);
    if (i < 0) i += S_LEN(p);
    if (i < 0) rb_raise(rb_eRangeError, "index out of range");
    if (i > S_LEN(p)) rb_raise(rb_eRangeError, "index out of range");
    p->curr = i;
    return INT2NUM(i);
}

Установить позицию указателя сканирования в байтах.

s = StringScanner.new('test string')
s.pos = 7            # -> 7
s.rest               # -> "ring"

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

static VALUE
strscan_post_match(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    if (! MATCHED_P(p)) return Qnil;
    return extract_range(p, p->prev + p->regs.end[0], S_LEN(p));
}

Возвращает после-совпадение (в смысле регулярных выражений) последнего сканирования.

s = StringScanner.new('test string')
s.scan(/\w+/)           # -> "test"
s.scan(/\s+/)           # -> " "
s.pre_match             # -> "test"
s.post_match            # -> "string"

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

static VALUE
strscan_pre_match(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    if (! MATCHED_P(p)) return Qnil;
    return extract_range(p, 0, p->prev + p->regs.beg[0]);
}

Возвращает перед-совпадение (в смысле регулярных выражений) последнего сканирования.

s = StringScanner.new('test string')
s.scan(/\w+/)           # -> "test"
s.scan(/\s+/)           # -> " "
s.pre_match             # -> "test"
s.post_match            # -> "string"

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

static VALUE
strscan_reset(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    p->curr = 0;
    CLEAR_MATCH_STATUS(p);
    return self;
}

Сбрасывает указатель сканирования (индекс 0) и очищает данные сопоставления.

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

static VALUE
strscan_rest(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    if (EOS_P(p)) {
        return infect(str_new(p, "", 0), p);
    }
    return extract_range(p, p->curr, S_LEN(p));
}

Возвращает «остаток» строки (т.е. всё после указателя сканирования). Если данных больше нет (eos? = true), возвращает "".

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

static VALUE
strscan_rest_p(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    return EOS_P(p) ? Qfalse : Qtrue;
}

Возвращает true, если в строке есть дополнительные данные. См. eos?. Этот метод устарел; используйте вместо него eos?.

s = StringScanner.new('test string')
s.eos?              # These two
s.rest?             # are opposites.

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

static VALUE
strscan_rest_size(VALUE self)
{
    struct strscanner *p;
    long i;

    GET_SCANNER(self, p);
    if (EOS_P(p)) {
        return INT2FIX(0);
    }
    i = S_LEN(p) - p->curr;
    return INT2FIX(i);
}

s.rest_size эквивалентно s.rest.size.

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

static VALUE
strscan_restsize(VALUE self)
{
    rb_warning("StringScanner#restsize is obsolete; use #rest_size instead");
    return strscan_rest_size(self);
}

s.restsize эквивалентно s.rest_size. Этот метод устарел; используйте вместо него rest_size.

scan(pattern) → String Показать исходный код

static VALUE
strscan_scan(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 1, 1, 1);
}

Пытается сопоставить pattern в текущей позиции. Если совпадение найдено, сканер продвигает «указатель сканирования» и возвращает соответствующую строку. В противном случае сканер возвращает nil.

s = StringScanner.new('test string')
p s.scan(/\w+/)   # -> "test"
p s.scan(/\w+/)   # -> nil
p s.scan(/\s+/)   # -> " "
p s.scan(/\w+/)   # -> "string"
p s.scan(/./)     # -> nil

scan_full(pattern, advance_pointer_p, return_string_p) Показать исходный код

static VALUE
strscan_scan_full(VALUE self, VALUE re, VALUE s, VALUE f)
{
    return strscan_do_scan(self, re, RTEST(s), RTEST(f), 1);
}

Проверяет, соответствует ли заданный pattern с текущего указателя сканирования. Продвигает указатель сканирования, если advance_pointer_p равно true. Возвращает сопоставленную строку, если return_string_p равно true. Регистр сопоставления затронут.

«полный» означает «#scan со всеми параметрами».

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

static VALUE
strscan_scan_until(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 1, 1, 0);
}

Сканирует строку до тех пор, пока не будет найдено совпадение с pattern. Возвращает подстроку до и включая конец совпадения, продвигая указатель сканирования до этого местоположения. Если совпадения нет, возвращается nil.

s = StringScanner.new("Fri Dec 12 1975 14:39")
s.scan_until(/1/)        # -> "Fri Dec 1"
s.pre_match              # -> "Fri Dec "
s.scan_until(/XYZ/)      # -> nil

search_full(pattern, advance_pointer_p, return_string_p) Показать исходный код

static VALUE
strscan_search_full(VALUE self, VALUE re, VALUE s, VALUE f)
{
    return strscan_do_scan(self, re, RTEST(s), RTEST(f), 0);
}

Сканирует строку до тех пор, пока не будет найдено совпадение с pattern. Продвигает указатель сканирования, если advance_pointer_p, иначе нет. Возвращает сопоставленную строку, если return_string_p равно true, иначе возвращает количество сдвинутых байтов. Этот метод влияет на регистр сопоставлений.

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

static VALUE
strscan_skip(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 1, 0, 1);
}

Пытается пропустить заданное pattern, начиная с указателя сканирования. Если совпадение найдено, указатель сканирования продвинут до конца совпадения, и возвращается длина совпадения. В противном случае возвращается nil.

Аналогично scan, но без возврата сопоставленной строки.

s = StringScanner.new('test string')
p s.skip(/\w+/)   # -> 4
p s.skip(/\w+/)   # -> nil
p s.skip(/\s+/)   # -> 1
p s.skip(/\w+/)   # -> 6
p s.skip(/./)     # -> nil

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

static VALUE
strscan_skip_until(VALUE self, VALUE re)
{
    return strscan_do_scan(self, re, 1, 0, 0);
}

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

Предварительно проверяет соответствие с pattern, и продвигает указатель сканирования до конца совпадения. Возвращает количество перемещённых символов, или nil если совпадение не удалось.

Аналогично scan_until, но без возврата промежуточной строки.

s = StringScanner.new("Fri Dec 12 1975 14:39")
s.skip_until /12/           # -> 10
s                           #

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

static VALUE
strscan_get_string(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    return p->str;
}

Возвращает сканируемую строку.

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

static VALUE
strscan_set_string(VALUE self, VALUE str)
{
    struct strscanner *p = check_strscan(self);

    StringValue(str);
    p->str = str;
    p->curr = 0;
    CLEAR_MATCH_STATUS(p);
    return str;
}

Изменяет сканируемую строку на str и сбрасывает сканер. Возвращает str.

terminate Показать исходный код

clear

static VALUE
strscan_terminate(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    p->curr = S_LEN(p);
    CLEAR_MATCH_STATUS(p);
    return self;
}

Установить указатель сканирования в конец строки и очистить данные совпадения.

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

static VALUE
strscan_unscan(VALUE self)
{
    struct strscanner *p;

    GET_SCANNER(self, p);
    if (! MATCHED_P(p))
        rb_raise(ScanError, "unscan failed: previous match record not exist");
    p->curr = p->prev;
    CLEAR_MATCH_STATUS(p);
    return self;
}

Установить указатель сканирования в предыдущую позицию. Запоминается только одна предыдущая позиция, и она меняется при каждом сканировании.

s = StringScanner.new('test string')
s.scan(/\w+/)        # => "test"
s.unscan
s.scan(/../)         # => "te"
s.scan(/\d/)         # => nil
s.unscan             # ScanError: unscan failed: previous match record not exist

Методы частного экземпляра

dup Показать исходный код

clone

static VALUE
strscan_init_copy(VALUE vself, VALUE vorig)
{
    struct strscanner *self, *orig;

    self = check_strscan(vself);
    orig = check_strscan(vorig);
    if (self != orig) {
        self->flags = orig->flags;
        self->str = orig->str;
        self->prev = orig->prev;
        self->curr = orig->curr;
        if (rb_reg_region_copy(&self->regs, &orig->regs))
            rb_memerror();
        RB_GC_GUARD(vorig);
    }

    return vself;
}

Создаёт копию объекта StringScanner.

Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.