StringIO

class StringIO

父类：DataIncluded模块：Enumerable，IO :: generic_readable，IO :: generic_writable

字符串对象上的伪I / O。

常用来模拟$stdio或$stderr

例子

require 'stringio'

io = StringIO.new
io.puts "Hello World"
io.string #=> "Hello World\n"

公共类方法

new(string="", mode) 显示源

使用字符串和模式创建新的StringIO实例。

static VALUE
strio_initialize(int argc, VALUE *argv, VALUE self)
{
    struct StringIO *ptr = check_strio(self

    if (!ptr) {
        DATA_PTR(self) = ptr = strio_alloc(
    }
    rb_call_super(0, 0
    return strio_init(argc, argv, ptr, self
}

open(string="", mode) {|strio| ...} 显示源

相当于:: new，除非用块调用它时，它将产生新实例并关闭它，并返回块返回的结果。

static VALUE
strio_s_open(int argc, VALUE *argv, VALUE klass)
{
    VALUE obj = rb_class_new_instance(argc, argv, klass
    if (!rb_block_given_p()) return obj;
    return rb_ensure(rb_yield, obj, strio_finalize, obj
}

公共实例方法

binmode() 显示源

static VALUE
strio_binmode(VALUE self)
{
    struct StringIO *ptr = StringIO(self
    rb_encoding *enc = rb_ascii8bit_encoding(

    ptr->enc = enc;
    if (WRITABLE(self)) {
        rb_enc_associate(ptr->string, enc
    }
    return self;
}

bytes() 显示源

对于each_byte，这是一个不推荐的别名。

static VALUE
strio_bytes(VALUE self)
{
    rb_warn("StringIO#bytes is deprecated; use #each_byte instead"
    if (!rb_block_given_p())
        return rb_enumeratorize(self, ID2SYM(rb_intern("each_byte")), 0, 0
    return strio_each_byte(self
}

chars() 显示源

这是一个不推荐的别名each_char。

static VALUE
strio_chars(VALUE self)
{
    rb_warn("StringIO#chars is deprecated; use #each_char instead"
    if (!rb_block_given_p())
        return rb_enumeratorize(self, ID2SYM(rb_intern("each_char")), 0, 0
    return strio_each_char(self
}

close → nil 显示源

关闭strio。该strio为任何进一步的数据操作不可用; 一IOError，如果这样的尝试升高。

static VALUE
strio_close(VALUE self)
{
    StringIO(self
    RBASIC(self)->flags &= ~STRIO_READWRITE;
    return Qnil;
}

close_read → nil 显示源

关闭StringIO的读取结束。IOError如果strio不可读，将会引发。

static VALUE
strio_close_read(VALUE self)
{
    struct StringIO *ptr = StringIO(self
    if (!(ptr->flags & FMODE_READABLE)) {
        rb_raise(rb_eIOError, "closing non-duplex IO for reading"
    }
    RBASIC(self)->flags &= ~STRIO_READABLE;
    return Qnil;
}

close_write → nil 显示源

关闭StringIO的写入结束。IOError如果strio不可写，将会引发。

static VALUE
strio_close_write(VALUE self)
{
    struct StringIO *ptr = StringIO(self
    if (!(ptr->flags & FMODE_WRITABLE)) {
        rb_raise(rb_eIOError, "closing non-duplex IO for writing"
    }
    RBASIC(self)->flags &= ~STRIO_WRITABLE;
    return Qnil;
}

closed? → true or false 显示源

true如果strio完全关闭，false则返回，否则返回。

static VALUE
strio_closed(VALUE self)
{
    StringIO(self
    if (!CLOSED(self)) return Qfalse;
    return Qtrue;
}

closed_read? → true or false 显示源

true如果strio不可读则返回，false否则返回。

static VALUE
strio_closed_read(VALUE self)
{
    StringIO(self
    if (READABLE(self)) return Qfalse;
    return Qtrue;
}

closed_write? → true or false 显示源

true如果strio不可写false则返回，否则返回。

static VALUE
strio_closed_write(VALUE self)
{
    StringIO(self
    if (WRITABLE(self)) return Qfalse;
    return Qtrue;
}

codepoints() 显示源

这是一个不推荐的别名each_codepoint。

static VALUE
strio_codepoints(VALUE self)
{
    rb_warn("StringIO#codepoints is deprecated; use #each_codepoint instead"
    if (!rb_block_given_p())
        return rb_enumeratorize(self, ID2SYM(rb_intern("each_codepoint")), 0, 0
    return strio_each_codepoint(self
}

each(sep=$/) {|line| block } → strio 显示源

each(limit) {|line| block } → strio

each(sep, limit) {|line| block } → strio

each(...) → anEnumerator

each_line(sep=$/) {|line| block } → strio

each_line(limit) {|line| block } → strio

each_line(sep,limit) {|line| block } → strio

each_line(...) → anEnumerator

See IO#each.

static VALUE
strio_each(int argc, VALUE *argv, VALUE self)
{
    VALUE line;
    struct getline_arg arg;

    StringIO(self
    RETURN_ENUMERATOR(self, argc, argv

    if (prepare_getline_args(&arg, argc, argv)->limit == 0) {
        rb_raise(rb_eArgError, "invalid limit: 0 for each_line"
    }

    while (!NIL_P(line = strio_getline(&arg, readable(self)))) {
        rb_yield(line
    }
    return self;
}

each_byte {|byte| block } → strio 显示源

each_byte → anEnumerator

See IO#each_byte.

static VALUE
strio_each_byte(VALUE self)
{
    struct StringIO *ptr = readable(self

    RETURN_ENUMERATOR(self, 0, 0

    while (ptr->pos < RSTRING_LEN(ptr->string)) {
        char c = RSTRING_PTR(ptr->string)[ptr->pos++];
        rb_yield(CHR2FIX(c)
    }
    return self;
}

each_char {|char| block } → strio 显示源

each_char → anEnumerator

See IO#each_char.

static VALUE
strio_each_char(VALUE self)
{
    VALUE c;

    RETURN_ENUMERATOR(self, 0, 0

    while (!NIL_P(c = strio_getc(self))) {
        rb_yield(c
    }
    return self;
}

each_codepoint {|c| block } → strio 显示源

each_codepoint → anEnumerator

See IO#each_codepoint.

static VALUE
strio_each_codepoint(VALUE self)
{
    struct StringIO *ptr;
    rb_encoding *enc;
    unsigned int c;
    int n;

    RETURN_ENUMERATOR(self, 0, 0

    ptr = readable(self
    enc = get_enc(ptr
    for (;;) {
        if (ptr->pos >= RSTRING_LEN(ptr->string)) {
            return self;
        }

        c = rb_enc_codepoint_len(RSTRING_PTR(ptr->string)+ptr->pos,
                                 RSTRING_END(ptr->string), &n, enc
        rb_yield(UINT2NUM(c)
        ptr->pos += n;
    }
    return self;
}

each_line(sep=$/) {|line| block } → strio 显示源

each_line(limit) {|line| block } → strio

each_line(sep,limit) {|line| block } → strio

each_line(...) → anEnumerator

See IO#each.

static VALUE
strio_each(int argc, VALUE *argv, VALUE self)
{
    VALUE line;
    struct getline_arg arg;

    StringIO(self
    RETURN_ENUMERATOR(self, argc, argv

    if (prepare_getline_args(&arg, argc, argv)->limit == 0) {
        rb_raise(rb_eArgError, "invalid limit: 0 for each_line"
    }

    while (!NIL_P(line = strio_getline(&arg, readable(self)))) {
        rb_yield(line
    }
    return self;
}

eof → true or false 显示源

eof? → true or false

如果strio位于文件末尾，则返回true 。弦必须打开阅读或IOError将被提出。

static VALUE
strio_eof(VALUE self)
{
    struct StringIO *ptr = readable(self
    if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
    return Qtrue;
}

eof? → true or false 显示源

如果strio位于文件末尾，则返回true 。弦必须打开阅读或IOError将被提出。

static VALUE
strio_eof(VALUE self)
{
    struct StringIO *ptr = readable(self
    if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
    return Qtrue;
}

external_encoding → encoding 显示源

返回表示文件编码的Encoding对象。如果strio是写模式并且没有指定编码，则返回nil。

static VALUE
strio_external_encoding(VALUE self)
{
    struct StringIO *ptr = StringIO(self
    return rb_enc_from_encoding(get_enc(ptr)
}

fcntl(*args) 显示源

引发NotImplementedError。

static VALUE
strio_unimpl(int argc, VALUE *argv, VALUE self)
{
    StringIO(self
    rb_notimplement(

    UNREACHABLE;
}

fileno() 显示源

退货nil。只是为了与IO兼容。

static VALUE
strio_nil(VALUE self)
{
    StringIO(self
    return Qnil;
}

flush() 显示源

返回strio本身。只是为了与IO兼容。

static VALUE
strio_self(VALUE self)
{
    StringIO(self
    return self;
}

fsync() 显示源

返回0.仅用于与IO的兼容性。

static VALUE
strio_0(VALUE self)
{
    StringIO(self
    return INT2FIX(0
}

getbyte → fixnum or nil 显示源

请参阅IO＃getbyte。

static VALUE
strio_getbyte(VALUE self)
{
    struct StringIO *ptr = readable(self
    int c;
    if (ptr->pos >= RSTRING_LEN(ptr->string)) {
        return Qnil;
    }
    c = RSTRING_PTR(ptr->string)[ptr->pos++];
    return CHR2FIX(c
}

getc → string or nil 显示源

见IO＃getc。

static VALUE
strio_getc(VALUE self)
{
    struct StringIO *ptr = readable(self
    rb_encoding *enc = get_enc(ptr
    VALUE str = ptr->string;
    long pos = ptr->pos;
    int len;
    char *p;

    if (pos >= RSTRING_LEN(str)) {
        return Qnil;
    }
    p = RSTRING_PTR(str)+pos;
    len = rb_enc_mbclen(p, RSTRING_END(str), enc
    ptr->pos += len;
    return enc_subseq(str, pos, len, enc
}

gets(sep=$/) → string or nil 显示源

gets(limit) → string or nil

gets(sep, limit) → string or nil

见IO＃获取。

static VALUE
strio_gets(int argc, VALUE *argv, VALUE self)
{
    struct getline_arg arg;
    VALUE str;

    if (prepare_getline_args(&arg, argc, argv)->limit == 0) {
        return rb_str_new(0, 0
    }

    str = strio_getline(&arg, readable(self)
    rb_lastline_set(str
    return str;
}

internal_encoding → encoding 显示源

如果指定了转换，则返回内部字符串的编码。否则返回零。

static VALUE
strio_internal_encoding(VALUE self)
{
     return Qnil;
}

isatty() 显示源

退货false。只是为了与IO兼容。

static VALUE
strio_false(VALUE self)
{
    StringIO(self
    return Qfalse;
}

length → integer 显示源

返回缓冲区字符串的大小。

static VALUE
strio_size(VALUE self)
{
    VALUE string = StringIO(self)->string;
    if (NIL_P(string)) {
        rb_raise(rb_eIOError, "not opened"
    }
    return ULONG2NUM(RSTRING_LEN(string)
}

lineno → integer 显示源

返回strio中的当前行号。弦必须打开阅读。lineno统计gets被调用的次数，而不是所遇到的换行符的数量。如果gets使用换行符以外的分隔符调用这两个值，它们将会有所不同。另请参阅$.变量。

static VALUE
strio_get_lineno(VALUE self)
{
    return LONG2NUM(StringIO(self)->lineno
}

lineno = integer → integer 显示源

手动将当前行号设置为给定值。$.仅在下次阅读时更新。

static VALUE
strio_set_lineno(VALUE self, VALUE lineno)
{
    StringIO(self)->lineno = NUM2LONG(lineno
    return lineno;
}

lines(*args) 显示源

这是一个不推荐的别名each_line。

static VALUE
strio_lines(int argc, VALUE *argv, VALUE self)
{
    rb_warn("StringIO#lines is deprecated; use #each_line instead"
    if (!rb_block_given_p())
        return rb_enumeratorize(self, ID2SYM(rb_intern("each_line")), argc, argv
    return strio_each(argc, argv, self
}

pid() 显示源

返回nil。只是为了与IO兼容。

static VALUE
strio_nil(VALUE self)
{
    StringIO(self
    return Qnil;
}

pos → integer 显示源

tell → integer

返回strio的当前偏移量（以字节为单位）。

static VALUE
strio_get_pos(VALUE self)
{
    return LONG2NUM(StringIO(self)->pos
}

pos = integer → integer 显示源

在strio中寻找给定的位置（以字节为单位）。

static VALUE
strio_set_pos(VALUE self, VALUE pos)
{
    struct StringIO *ptr = StringIO(self
    long p = NUM2LONG(pos
    if (p < 0) {
        error_inval(0
    }
    ptr->pos = p;
    return pos;
}

putc(obj) → obj 显示源

见IO＃putc。

static VALUE
strio_putc(VALUE self, VALUE ch)
{
    struct StringIO *ptr = writable(self
    VALUE str;

    check_modifiable(ptr
    if (RB_TYPE_P(ch, T_STRING)) {
        str = rb_str_substr(ch, 0, 1
    }
    else {
        char c = NUM2CHR(ch
        str = rb_str_new(&c, 1
    }
    strio_write(self, str
    return ch;
}

读取（[length，outbuf]）→string，outbuf或nil显示源文件

请参阅IO＃读取。

static VALUE
strio_read(int argc, VALUE *argv, VALUE self)
{
    struct StringIO *ptr = readable(self
    VALUE str = Qnil;
    long len;
    int binary = 0;

    rb_check_arity(argc, 0, 2
    switch (argc) {
      case 2:
        str = argv[1];
        if (!NIL_P(str)) {
            StringValue(str
            rb_str_modify(str
        }
      case 1:
        if (!NIL_P(argv[0])) {
            len = NUM2LONG(argv[0]
            if (len < 0) {
                rb_raise(rb_eArgError, "negative length %ld given", len
            }
            if (len > 0 && ptr->pos >= RSTRING_LEN(ptr->string)) {
                if (!NIL_P(str)) rb_str_resize(str, 0
                return Qnil;
            }
            binary = 1;
            break;
        }
        /* fall through */
      case 0:
        len = RSTRING_LEN(ptr->string
        if (len <= ptr->pos) {
            if (NIL_P(str)) {
                str = rb_str_new(0, 0
            }
            else {
                rb_str_resize(str, 0
            }
            return str;
        }
        else {
            len -= ptr->pos;
        }
        break;
    }
    if (NIL_P(str)) {
        str = strio_substr(ptr, ptr->pos, len
        if (binary) rb_enc_associate(str, rb_ascii8bit_encoding()
    }
    else {
        long rest = RSTRING_LEN(ptr->string) - ptr->pos;
        if (len > rest) len = rest;
        rb_str_resize(str, len
        MEMCPY(RSTRING_PTR(str), RSTRING_PTR(ptr->string) + ptr->pos, char, len
        if (binary)
            rb_enc_associate(str, rb_ascii8bit_encoding()
        else
            rb_enc_copy(str, ptr->string
    }
    ptr->pos += RSTRING_LEN(str
    return str;
}

readlines(sep=$/) → array 显示源

readlines(limit) → array

readlines(sep,limit) → array

请参阅IO＃readlines。

static VALUE
strio_readlines(int argc, VALUE *argv, VALUE self)
{
    VALUE ary, line;
    struct getline_arg arg;

    StringIO(self
    ary = rb_ary_new(
    if (prepare_getline_args(&arg, argc, argv)->limit == 0) {
        rb_raise(rb_eArgError, "invalid limit: 0 for readlines"
    }

    while (!NIL_P(line = strio_getline(&arg, readable(self)))) {
        rb_ary_push(ary, line
    }
    return ary;
}

reopen(other_StrIO) → strio 显示源

reopen(string, mode) → strio

用给定的other_StrIO或字符串和模式重新初始化strio（请参见StringIO＃new）。

static VALUE
strio_reopen(int argc, VALUE *argv, VALUE self)
{
    rb_io_taint_check(self
    if (argc == 1 && !RB_TYPE_P(*argv, T_STRING)) {
        return strio_copy(self, *argv
    }
    return strio_init(argc, argv, StringIO(self), self
}

rewind → 0 显示源

将strio定位到输入的开头，重置lineno为零。

static VALUE
strio_rewind(VALUE self)
{
    struct StringIO *ptr = StringIO(self
    ptr->pos = 0;
    ptr->lineno = 0;
    return INT2FIX(0
}

seek(amount, whence=SEEK_SET) → 0 显示源

根据whence的值寻找流中给定的偏移量（请参阅IO＃seek）。

static VALUE
strio_seek(int argc, VALUE *argv, VALUE self)
{
    VALUE whence;
    struct StringIO *ptr = StringIO(self
    long amount, offset;

    rb_scan_args(argc, argv, "11", NULL, &whence
    amount = NUM2LONG(argv[0]
    if (CLOSED(self)) {
        rb_raise(rb_eIOError, "closed stream"
    }
    switch (NIL_P(whence) ? 0 : NUM2LONG(whence)) {
      case 0:
        offset = 0;
        break;
      case 1:
        offset = ptr->pos;
        break;
      case 2:
        offset = RSTRING_LEN(ptr->string
        break;
      default:
        error_inval("invalid whence"
    }
    if (amount > LONG_MAX - offset || amount + offset < 0) {
        error_inval(0
    }
    ptr->pos = amount + offset;
    return INT2FIX(0
}

set_encoding(ext_enc, [int_enc, opt]) → strio 显示源

将StringIO的编码指定为ext_enc。如果ext_enc为零，则使用默认的外部编码。第二个参数int_enc和可选的hash opt参数被忽略; 它们是为了与IO兼容的。

static VALUE
strio_set_encoding(int argc, VALUE *argv, VALUE self)
{
    rb_encoding* enc;
    struct StringIO *ptr = StringIO(self
    VALUE ext_enc, int_enc, opt;

    argc = rb_scan_args(argc, argv, "11:", &ext_enc, &int_enc, &opt

    if (NIL_P(ext_enc)) {
        enc = rb_default_external_encoding(
    }
    else {
        enc = rb_to_encoding(ext_enc
    }
    ptr->enc = enc;
    if (WRITABLE(self)) {
        rb_enc_associate(ptr->string, enc
    }

    return self;
}

size → integer 显示源

返回缓冲区字符串的大小。

static VALUE
strio_size(VALUE self)
{
    VALUE string = StringIO(self)->string;
    if (NIL_P(string)) {
        rb_raise(rb_eIOError, "not opened"
    }
    return ULONG2NUM(RSTRING_LEN(string)
}

string → string 显示源

返回底层String对象，IO的主题。

static VALUE
strio_get_string(VALUE self)
{
    return StringIO(self)->string;
}

string = string → string 显示源

更改基础字符串对象的基础，即IO的主题。

static VALUE
strio_set_string(VALUE self, VALUE string)
{
    struct StringIO *ptr = StringIO(self

    rb_io_taint_check(self
    ptr->flags &= ~FMODE_READWRITE;
    StringValue(string
    ptr->flags = OBJ_FROZEN(string) ? FMODE_READABLE : FMODE_READWRITE;
    ptr->pos = 0;
    ptr->lineno = 0;
    return ptr->string = string;
}

sync → true 显示源

true总是返回。

static VALUE
strio_get_sync(VALUE self)
{
    StringIO(self
    return Qtrue;
}

sync=(p1)显示源

不变地返回参数。只是为了与IO兼容。

static VALUE
strio_first(VALUE self, VALUE arg)
{
    StringIO(self
    return arg;
}

pos → integer 显示源

tell → integer

返回strio的当前偏移量（以字节为单位）。

static VALUE
strio_get_pos(VALUE self)
{
    return LONG2NUM(StringIO(self)->pos
}

truncate(integer) → 0 显示源

将缓冲区字符串截断为最多整数个字节。该strio必须写打开。

static VALUE
strio_truncate(VALUE self, VALUE len)
{
    VALUE string = writable(self)->string;
    long l = NUM2LONG(len
    long plen = RSTRING_LEN(string
    if (l < 0) {
        error_inval("negative length"
    }
    rb_str_resize(string, l
    if (plen < l) {
        MEMZERO(RSTRING_PTR(string) + plen, char, l - plen
    }
    return len;
}

tty?() 显示源

返回false。只是为了与IO兼容。

static VALUE
strio_false(VALUE self)
{
    StringIO(self
    return Qfalse;
}

ungetbyte(fixnum) → nil 显示源

请参阅IO＃ungetbyte

static VALUE
strio_ungetbyte(VALUE self, VALUE c)
{
    struct StringIO *ptr = readable(self
    char buf[1], *cp = buf;
    long cl = 1;

    check_modifiable(ptr
    if (NIL_P(c)) return Qnil;
    if (FIXNUM_P(c)) {
        buf[0] = (char)FIX2INT(c
        return strio_unget_bytes(ptr, buf, 1
    }
    else {
        SafeStringValue(c
        cp = RSTRING_PTR(c
        cl = RSTRING_LEN(c
        if (cl == 0) return Qnil;
        strio_unget_bytes(ptr, cp, cl
        RB_GC_GUARD(c
        return Qnil;
    }
}

ungetc(string) → nil 显示源

将一个字符（作为参数传递）推回到strio，以便后续的缓冲读取将返回它。对于多次推送没有限制，包括推回缓冲区字符串的开头。

static VALUE
strio_ungetc(VALUE self, VALUE c)
{
    struct StringIO *ptr = readable(self
    rb_encoding *enc, *enc2;

    check_modifiable(ptr
    if (NIL_P(c)) return Qnil;
    if (RB_INTEGER_TYPE_P(c)) {
        int len, cc = NUM2INT(c
        char buf[16];

        enc = rb_enc_get(ptr->string
        len = rb_enc_codelen(cc, enc
        if (len <= 0) rb_enc_uint_chr(cc, enc
        rb_enc_mbcput(cc, buf, enc
        return strio_unget_bytes(ptr, buf, len
    }
    else {
        SafeStringValue(c
        enc = rb_enc_get(ptr->string
        enc2 = rb_enc_get(c
        if (enc != enc2 && enc != rb_ascii8bit_encoding()) {
            c = rb_str_conv_enc(c, enc2, enc
        }
        strio_unget_bytes(ptr, RSTRING_PTR(c), RSTRING_LEN(c)
        RB_GC_GUARD(c
        return Qnil;
    }
}

write(string) → integer显示源

syswrite(string) → integer

将给定的字符串追加到strio的基础缓冲区字符串中。该流必须打开才能写入。如果参数不是字符串，它将被转换为使用的字符串to_s。返回写入的字节数。请参阅IO＃写入。

static VALUE
strio_write(VALUE self, VALUE str)
{
    struct StringIO *ptr = writable(self
    long len, olen;
    rb_encoding *enc, *enc2;
    rb_encoding *const ascii8bit = rb_ascii8bit_encoding(

    if (!RB_TYPE_P(str, T_STRING))
        str = rb_obj_as_string(str
    enc = get_enc(ptr
    enc2 = rb_enc_get(str
    if (enc != enc2 && enc != ascii8bit) {
        str = rb_str_conv_enc(str, enc2, enc
    }
    len = RSTRING_LEN(str
    if (len == 0) return INT2FIX(0
    check_modifiable(ptr
    olen = RSTRING_LEN(ptr->string
    if (ptr->flags & FMODE_APPEND) {
        ptr->pos = olen;
    }
    if (ptr->pos == olen) {
        if (enc == ascii8bit || enc2 == ascii8bit) {
            rb_enc_str_buf_cat(ptr->string, RSTRING_PTR(str), len, enc
            OBJ_INFECT(ptr->string, str
        }
        else {
            rb_str_buf_append(ptr->string, str
        }
    }
    else {
        strio_extend(ptr, ptr->pos, len
        memmove(RSTRING_PTR(ptr->string)+ptr->pos, RSTRING_PTR(str), len
        OBJ_INFECT(ptr->string, str
    }
    OBJ_INFECT(ptr->string, self
    RB_GC_GUARD(str
    ptr->pos += len;
    return LONG2NUM(len
}