модуль Kernel
RubyGems добавляет метод gem для активации определённых версий gem и переопределяет метод require в Kernel, чтобы сделать gems доступными, как будто они находятся на $LOAD_PATH. Смотрите документацию этих методов для получения дополнительной информации.
Модуль Kernel включается классом Object, поэтому его методы доступны в каждом объекте Ruby.
Методы экземпляра Kernel документированы в классе Object, а методы модуля — здесь. Эти методы вызываются без получателя и поэтому могут быть вызваны в функциональной форме:
sprintf "%.1f", 1.234 #=> "1.2"
Публичные методы класса
# File lib/uri/common.rb, line 738
def URI(uri)
if uri.is_a?(URI::Generic)
uri
elsif uri = String.try_convert(uri)
URI.parse(uri)
else
raise ArgumentError,
"bad argument (expected URI object or URI string)"
end
end Возвращает uri, преобразованный в объект URI.
static VALUE
rb_f_open(int argc, VALUE *argv)
{
ID to_open = 0;
int redirect = FALSE;
if (argc >= 1) {
CONST_ID(to_open, "to_open");
if (rb_respond_to(argv[0], to_open)) {
redirect = TRUE;
}
else {
VALUE tmp = argv[0];
FilePathValue(tmp);
if (NIL_P(tmp)) {
redirect = TRUE;
}
else {
VALUE cmd = check_pipe_command(tmp);
if (!NIL_P(cmd)) {
argv[0] = cmd;
return rb_io_s_popen(argc, argv, rb_cIO);
}
}
}
}
if (redirect) {
VALUE io = rb_funcallv(argv[0], to_open, argc-1, argv+1);
if (rb_block_given_p()) {
return rb_ensure(rb_yield, io, io_close, io);
}
return io;
}
return rb_io_s_open(argc, argv, rb_cFile);
} Создаёт объект IO, подключённый к заданному потоку, файлу или подпроцессу.
Если path не начинается с символа трубы (|), то он рассматривается как имя файла для открытия с указанным режимом (по умолчанию «r»).
Параметр mode может быть строкой или целым числом. Если это целое число, оно должно быть побитовым или открытых (2) флагов, таких как File::RDWR или File::EXCL. Если это строка, то это либо «fmode», либо «fmode:ext_enc», либо «fmode:ext_enc:int_enc».
См. документацию IO.new для полной документации по mode строковым директивам.
Если файл создаётся, его начальные права доступа можно установить с помощью параметра perm. См. File.new и страницы руководства open(2) и chmod(2) для описания прав доступа.
Если указан блок, он будет вызван с объектом IO в качестве параметра, и IO будет автоматически закрыт по завершении блока. Вызов возвращает значение блока.
Если path начинается с символа трубы ("|"), создаётся подпроцесс, подключённый к вызывающему объекту парой каналов. Возвращаемый объект IO может использоваться для записи в стандартный ввод и чтения из стандартного вывода этого подпроцесса.
Если команда, следующая за символом трубы, является одиночным знаком минус ("|-"), Ruby создаёт вилку, и этот подпроцесс подключается к родителю. Если команда не "-", подпроцесс выполняет команду.
Когда подпроцесс — это Ruby (открытый через "|-"), вызов open возвращает nil. Если блок связан с вызовом open, этот блок будет выполнен дважды — один раз в родительском процессе и один раз в дочернем.
Параметр блока будет объектом IO в родительском процессе и nil в дочернем. Объект IO родителя будет подключён к $stdin и $stdout дочернего процесса. Подпроцесс будет завершён по завершении блока.
Примеры
Чтение из «testfile»:
open("testfile") do |f|
print f.gets
end
Результат:
This is line one
Открытие подпроцесса и чтение его вывода:
cmd = open("|date")
print cmd.gets
cmd.close
Результат:
Wed Apr 9 08:56:31 CDT 2003
Открытие подпроцесса, выполняющего ту же программу Ruby:
f = open("|-", "w+")
if f.nil?
puts "in Child"
exit
else
puts "Got: #{f.gets}"
end
Результат:
Got: in Child
Открытие подпроцесса с использованием блока для получения объекта IO:
open "|-" do |f|
if f then
# parent process
puts "Got: #{f.gets}"
else
# child process
puts "in Child"
end
end
Результат:
Got: in Child
# File lib/pp.rb, line 551
def pp(*objs)
objs.each {|obj|
PP.pp(obj)
}
objs.size <= 1 ? objs.first : objs
end выводит аргументы в красивом формате.
pp возвращает аргумент(ы).
Приватные методы класса
Публичные методы экземпляров
static VALUE
rb_f_array(VALUE obj, VALUE arg)
{
return rb_Array(arg);
} Возвращает arg в виде массива.
Сначала пытается вызвать to_ary у arg, затем to_a. Если arg не отвечает на to_ary или to_a, возвращает массив длиной 1, содержащий arg.
Если to_ary или to_a возвращает что-то кроме массива, генерирует исключение TypeError.
Array(["a", "b"]) #=> ["a", "b"] Array(1..5) #=> [1, 2, 3, 4, 5] Array(key: :value) #=> [[:key, :value]] Array(nil) #=> [] Array(1) #=> [1]
static VALUE
BigDecimal_global_new(int argc, VALUE *argv, VALUE self)
{
ENTER(1);
Real *pv;
VALUE obj;
obj = TypedData_Wrap_Struct(rb_cBigDecimal, &BigDecimal_data_type, 0);
GUARD_OBJ(pv, BigDecimal_new(argc, argv));
if (ToValue(pv)) pv = VpCopy(NULL, pv);
RTYPEDDATA_DATA(obj) = pv;
return pv->obj = obj;
} См. также BigDecimal.new
static VALUE
nucomp_f_complex(int argc, VALUE *argv, VALUE klass)
{
return nucomp_s_convert(argc, argv, rb_cComplex);
} Возвращает x+i*y;
Complex(1, 2) #=> (1+2i)
Complex('1+2i') #=> (1+2i)
Complex(nil) #=> TypeError
Complex(1, nil) #=> TypeError
Синтаксис строковой формы:
string form = extra spaces , complex , extra spaces ;
complex = real part | [ sign ] , imaginary part
| real part , sign , imaginary part
| rational , "@" , rational ;
real part = rational ;
imaginary part = imaginary unit | unsigned rational , imaginary unit ;
rational = [ sign ] , unsigned rational ;
unsigned rational = numerator | numerator , "/" , denominator ;
numerator = integer part | fractional part | integer part , fractional part ;
denominator = digits ;
integer part = digits ;
fractional part = "." , digits , [ ( "e" | "E" ) , [ sign ] , digits ] ;
imaginary unit = "i" | "I" | "j" | "J" ;
sign = "-" | "+" ;
digits = digit , { digit | "_" , digit };
digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
extra spaces = ? \s* ? ; См. String#to_c.
static VALUE rb_f_float(VALUE obj, VALUE arg))
static VALUE
rb_f_hash(VALUE obj, VALUE arg)
{
return rb_Hash(arg);
} Преобразует arg в словарь, вызвав у него метод arg.to_hash. Возвращает пустой словарь, когда arg является nil или [].
Hash([]) #=> {}
Hash(nil) #=> {}
Hash(key: :value) #=> {:key => :value}
Hash([1, 2, 3]) #=> TypeError
static VALUE
rb_f_integer(int argc, VALUE *argv, VALUE obj)
{
VALUE arg = Qnil;
int base = 0;
switch (argc) {
case 2:
base = NUM2INT(argv[1]);
case 1:
arg = argv[0];
break;
default:
/* should cause ArgumentError */
rb_scan_args(argc, argv, "11", NULL, NULL);
}
return rb_convert_to_integer(arg, base);
} Преобразует arg в целое число. Числовые типы преобразуются напрямую (с плавающей точкой, которые усекаются). base (0 или от 2 до 36) — основание для целочисленного представления строки. Если arg является строкой, а base опущен или равен нулю, учитываются префиксы (0, 0b, и 0x). В любом случае, строки должны строго соответствовать числовому представлению. Это поведение отличается от поведения String#to_i. Нестроковые значения преобразуются, сначала пытаясь использовать to_int, затем to_i. Передача nil приводит к TypeError.
Integer(123.999) #=> 123
Integer("0x1a") #=> 26
Integer(Time.new) #=> 1204973019
Integer("0930", 10) #=> 930
Integer("111", 2) #=> 7
Integer(nil) #=> TypeError
static VALUE
path_f_pathname(VALUE self, VALUE str)
{
return rb_class_new_instance(1, &str, rb_cPathname);
} Создает новый объект Pathname из заданной строки, path, и возвращает объект пути.
Для использования этого конструктора, вы должны сначала подключить расширение стандартной библиотеки Pathname.
require 'pathname'
Pathname("/home/zzak")
#=> #<Pathname:/home/zzak>
См. также Pathname.new для получения дополнительной информации.
static VALUE
nurat_f_rational(int argc, VALUE *argv, VALUE klass)
{
return nurat_s_convert(argc, argv, rb_cRational);
} Возвращает x/y или arg как Rational.
Rational(2, 3) #=> (2/3)
Rational(5) #=> (5/1)
Rational(0.5) #=> (1/2)
Rational(0.3) #=> (5404319552844595/18014398509481984)
Rational("2/3") #=> (2/3)
Rational("0.3") #=> (3/10)
Rational("10 cents") #=> ArgumentError
Rational(nil) #=> TypeError
Rational(1, nil) #=> TypeError
Синтаксис строковой формы:
string form = extra spaces , rational , extra spaces ;
rational = [ sign ] , unsigned rational ;
unsigned rational = numerator | numerator , "/" , denominator ;
numerator = integer part | fractional part | integer part , fractional part ;
denominator = digits ;
integer part = digits ;
fractional part = "." , digits , [ ( "e" | "E" ) , [ sign ] , digits ] ;
sign = "-" | "+" ;
digits = digit , { digit | "_" , digit } ;
digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
extra spaces = ? \s* ? ; См. также String#to_r.
static VALUE
rb_f_string(VALUE obj, VALUE arg)
{
return rb_String(arg);
} Возвращает arg как строку.
Сначала пытается вызвать его метод to_str, затем его метод to_s.
String(self) #=> "main" String(self.class) #=> "Object" String(123456) #=> "123456"
static VALUE
rb_f_callee_name(void)
{
ID fname = prev_frame_callee(); /* need *callee* ID */
if (fname) {
return ID2SYM(fname);
}
else {
return Qnil;
}
} Возвращает имя вызываемого метода в текущем контексте как Symbol. Если вызов производится вне метода, возвращает nil.
static VALUE
f_current_dirname(void)
{
VALUE base = rb_current_realfilepath();
if (NIL_P(base)) {
return Qnil;
}
base = rb_file_dirname(base);
return base;
} Возвращает канонизированный абсолютный путь к каталогу файла, из которого вызван этот метод. Это означает, что ссылки на символы в пути будут разрешены. Если __FILE__ равно nil, возвращает nil. Результат эквивалентен File.dirname(File.realpath(__FILE__)).
static VALUE
rb_f_method_name(void)
{
ID fname = prev_frame_func(); /* need *method* ID */
if (fname) {
return ID2SYM(fname);
}
else {
return Qnil;
}
} Возвращает имя метода в месте его определения как Symbol. Если вызов производится вне метода, возвращает nil.
static VALUE
rb_f_backquote(VALUE obj, VALUE str)
{
VALUE port;
VALUE result;
rb_io_t *fptr;
SafeStringValue(str);
rb_last_status_clear();
port = pipe_open_s(str, "r", FMODE_READABLE|DEFAULT_TEXTMODE, NULL);
if (NIL_P(port)) return rb_str_new(0,0);
GetOpenFile(port, fptr);
result = read_all(fptr, remain_size(fptr), Qnil);
rb_io_close(port);
rb_io_fptr_finalize(fptr);
rb_gc_force_recycle(port); /* also guards from premature GC */
return result;
} Возвращает стандартный вывод выполнения cmd в дочернем процессе. Встроенный синтаксис %x{...} использует этот метод. Устанавливает $? в статус процесса.
`date` #=> "Wed Apr 9 08:56:30 CDT 2003\n" `ls testdir`.split[1] #=> "main.rb" `echo oops && exit 99` #=> "oops\n" $?.exitstatus #=> 99
VALUE
rb_f_abort(int argc, const VALUE *argv)
{
rb_check_arity(argc, 0, 1);
if (argc == 0) {
rb_execution_context_t *ec = GET_EC();
VALUE errinfo = ec->errinfo;
if (!NIL_P(errinfo)) {
rb_ec_error_print(ec, errinfo);
}
rb_exit(EXIT_FAILURE);
}
else {
VALUE args[2];
args[1] = args[0] = argv[0];
StringValue(args[0]);
rb_io_puts(1, args, rb_stderr);
args[0] = INT2NUM(EXIT_FAILURE);
rb_exc_raise(rb_class_new_instance(2, args, rb_eSystemExit));
}
UNREACHABLE;
} Немедленно прерывает выполнение, фактически вызывая Kernel.exit(false). Если задан msg, он выводится в STDERR перед завершением.
static VALUE
rb_f_at_exit(void)
{
VALUE proc;
if (!rb_block_given_p()) {
rb_raise(rb_eArgError, "called without a block");
}
proc = rb_block_proc();
rb_set_end_proc(rb_call_end_proc, proc);
return proc;
} Преобразует блок в объект процедуры (и, следовательно, связывает его в момент вызова) и регистрирует его для выполнения при выходе программы. Если зарегистрированы несколько обработчиков, они выполняются в обратном порядке регистрации.
def do_at_exit(str1)
at_exit { print str1 }
end
at_exit { puts "cruel world" }
do_at_exit("goodbye ")
exit
выводит:
goodbye cruel world
static VALUE
rb_f_autoload(VALUE obj, VALUE sym, VALUE file)
{
VALUE klass = rb_class_real(rb_vm_cbase());
if (NIL_P(klass)) {
rb_raise(rb_eTypeError, "Can not set autoload on singleton class");
}
return rb_mod_autoload(klass, sym, file);
} Регистрирует имя_файла для загрузки (используя Kernel::require) в первый раз, когда к модулю (который может быть модулем или символом) обращаются.
autoload(:MyModule, "/usr/local/lib/modules/my_module.rb")
static VALUE
rb_f_autoload_p(VALUE obj, VALUE sym)
{
/* use rb_vm_cbase() as same as rb_f_autoload. */
VALUE klass = rb_vm_cbase();
if (NIL_P(klass)) {
return Qnil;
}
return rb_mod_autoload_p(klass, sym);
} Возвращает имя_файла для загрузки, если имя зарегистрировано как autoload.
autoload(:B, "b") autoload?(:B) #=> "b"
static VALUE
rb_f_binding(VALUE self)
{
return rb_binding_new();
} Возвращает объект связывания, описывающий связывания переменных и методов в точке вызова. Этот объект может быть использован при вызове eval для выполнения вычисляемой команды в этой среде. См. также описание класса Binding.
def get_binding(param)
binding
end
b = get_binding("hello")
eval("param", b) #=> "hello"
static VALUE
rb_f_block_given_p(void)
{
rb_execution_context_t *ec = GET_EC();
rb_control_frame_t *cfp = ec->cfp;
cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
if (cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE) {
return Qtrue;
}
else {
return Qfalse;
}
} Возвращает true если yield бы выполнил блок в текущем контексте. Форма iterator? слегка устарела.
def try
if block_given?
yield
else
"no block"
end
end
try #=> "no block"
try { "hello" } #=> "hello"
try do "hello" end #=> "hello"
static VALUE
rb_callcc(VALUE self)
{
volatile int called;
volatile VALUE val = cont_capture(&called);
if (called) {
return val;
}
else {
return rb_yield(val);
}
} Генерирует объект Continuation, который передаётся в связанный блок. Вам необходимо require
'continuation' перед использованием этого метода. Выполнение cont.call приведёт к возврату callcc (как и проход до конца блока). Значение, возвращаемое callcc, — это значение блока или значение, переданное в cont.call. Дополнительные сведения см. в классе Continuation. Также см. #throw для альтернативного механизма разворачивания стека вызовов.
static VALUE
rb_f_caller(int argc, VALUE *argv)
{
return ec_backtrace_to_ary(GET_EC(), argc, argv, 1, 1, 1);
} Возвращает текущий стек выполнения — массив, содержащий строки в формате file:line или file:line: in `method'.
Необязательный параметр start определяет количество начальных записей стека, которые нужно пропустить сверху стека.
Необязательный второй параметр length может быть использован для ограничения количества возвращаемых записей из стека.
Возвращает nil если start больше размера текущего стека выполнения.
Необязательно можно передать диапазон, который вернёт массив, содержащий записи в указанном диапазоне.
def a(skip) caller(skip) end def b(skip) a(skip) end def c(skip) b(skip) end c(0) #=> ["prog:2:in `a'", "prog:5:in `b'", "prog:8:in `c'", "prog:10:in `<main>'"] c(1) #=> ["prog:5:in `b'", "prog:8:in `c'", "prog:11:in `<main>'"] c(2) #=> ["prog:8:in `c'", "prog:12:in `<main>'"] c(3) #=> ["prog:13:in `<main>'"] c(4) #=> [] c(5) #=> nil
static VALUE
rb_f_caller_locations(int argc, VALUE *argv)
{
return ec_backtrace_to_ary(GET_EC(), argc, argv, 1, 1, 0);
} Возвращает текущий стек выполнения — массив, содержащий объекты расположения трассировки стека.
Дополнительную информацию см. в Thread::Backtrace::Location.
Необязательный параметр start определяет количество начальных записей стека, которые нужно пропустить сверху стека.
Необязательный второй параметр length может быть использован для ограничения количества возвращаемых записей из стека.
Возвращает nil если start больше размера текущего стека выполнения.
Необязательно можно передать диапазон, который вернёт массив, содержащий записи в указанном диапазоне.
static VALUE
rb_f_catch(int argc, VALUE *argv)
{
VALUE tag;
if (argc == 0) {
tag = rb_obj_alloc(rb_cObject);
}
else {
rb_scan_args(argc, argv, "01", &tag);
}
return rb_catch_obj(tag, catch_i, 0);
} catch выполняет свой блок. Если throw не вызывается, блок выполняется обычно, и catch возвращает значение последнего вычисленного выражения.
catch(1) { 123 } # => 123
Если throw(tag2, val) вызывается, Ruby ищет в стеке catch блок, чей tag имеет такое же значение, как tag2. При обнаружении блок прекращает выполнение и возвращает val (или nil если второй аргумент не был передан в throw).
catch(1) { throw(1, 456) } # => 456
catch(1) { throw(1) } # => nil
Когда tag передаётся в качестве первого аргумента, catch передаёт его как параметр блока.
catch(1) {|x| x + 2 } # => 3
Когда tag не указан, catch передаёт новый уникальный объект (как из Object.new) в качестве параметра блока. Этот объект затем может быть использован в качестве аргумента throw, и будет соответствовать правильному catch блоку.
catch do |obj_A|
catch do |obj_B|
throw(obj_B, 123)
puts "This puts is not reached"
end
puts "This puts is displayed"
456
end
# => 456
catch do |obj_A|
catch do |obj_B|
throw(obj_A, 123)
puts "This puts is still not reached"
end
puts "Now this puts is also not reached"
456
end
# => 123
static VALUE
rb_f_chomp(int argc, VALUE *argv)
{
VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("chomp"), argc, argv);
rb_lastline_set(str);
return str;
} Эквивалентно $_ = $_.chomp(string). См. String#chomp. Доступно только при использовании опций командной строки -p/-n.
static VALUE
rb_f_chop(void)
{
VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("chop"), 0, 0);
rb_lastline_set(str);
return str;
} Эквивалентно ($_.dup).chop!, за исключением того, что nil никогда не возвращается. См. String#chop!. Доступно только при использовании опций командной строки -p/-n.
VALUE
rb_f_eval(int argc, const VALUE *argv, VALUE self)
{
VALUE src, scope, vfile, vline;
VALUE file = Qundef;
int line = 1;
rb_scan_args(argc, argv, "13", &src, &scope, &vfile, &vline);
SafeStringValue(src);
if (argc >= 3) {
StringValue(vfile);
}
if (argc >= 4) {
line = NUM2INT(vline);
}
if (!NIL_P(vfile))
file = vfile;
return eval_string(self, src, scope, file, line);
} Вычисляет выражение(я) Ruby в string. Если задан binding, который должен быть объектом Binding, вычисление выполняется в его контексте. Если заданы необязательные параметры filename и lineno, они будут использоваться при сообщении об ошибках синтаксиса.
def get_binding(str)
return binding
end
str = "hello"
eval "str + ' Fred'" #=> "hello Fred"
eval "str + ' Fred'", get_binding("bye") #=> "bye Fred"
VALUE
rb_f_exec(int argc, const VALUE *argv)
{
VALUE execarg_obj, fail_str;
struct rb_execarg *eargp;
#define CHILD_ERRMSG_BUFLEN 80
char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' };
int err;
execarg_obj = rb_execarg_new(argc, argv, TRUE);
eargp = rb_execarg_get(execarg_obj);
before_exec(); /* stop timer thread before redirects */
rb_execarg_parent_start(execarg_obj);
fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
err = exec_async_signal_safe(eargp, errmsg, sizeof(errmsg));
after_exec(); /* restart timer thread */
rb_exec_fail(eargp, err, errmsg);
RB_GC_GUARD(execarg_obj);
rb_syserr_fail_str(err, fail_str);
UNREACHABLE;
} Заменяет текущий процесс, выполняя заданную внешнюю command, которая может иметь один из следующих форматов:
-
exec(commandline) -
строка командной строки, которая передаётся в стандартную оболочку
-
exec(cmdname, arg1, ...) -
имя команды и один или несколько аргументов (без оболочки)
-
exec([cmdname, argv0], arg1, ...) -
имя команды, argv и ноль или более аргументов (без оболочки)
В первом формате строка рассматривается как командная строка, которая подвергается расширению оболочки перед выполнением.
Стандартная оболочка всегда означает "/bin/sh" на системах Unix-подобных, то же, что и ENV["RUBYSHELL"] (или ENV["COMSPEC"] в Windows NT), и подобное.
Если строка из первого формата (exec("command")) следует этим простым правилам:
-
нет метасимволов
-
нет зарезервированных слов оболочки и нет специальных встроенных
-
Ruby вызывает команду напрямую без оболочки
Вы можете принудительно вызвать оболочку, добавив «;» в строку (поскольку «;» — метасимвол).
Обратите внимание, что это поведение наблюдается полученным pid (значение возвращаемое spawn() и IO#pid для IO.popen) — это pid вызванной команды, а не оболочки.
Во втором формате (exec("command1", "arg1",
...)), первый рассматривается как имя команды, а остальные передаются как параметры команды без расширения оболочки.
В третьем формате (exec(["command", "argv0"],
"arg1", ...)), начиная с двухелементного массива в начале команды, первый элемент — это команда, которая должна быть выполнена, а второй аргумент используется как значение argv[0], которое может появиться в списках процессов.
Для выполнения команды используются системные вызовы exec(2), поэтому выполняемая команда может унаследовать часть окружения исходной программы (включая открытые дескрипторы файлов).
Это поведение изменяется заданными env и options параметрами. Подробнее см. ::spawn.
Если команда не выполняется (обычно Errno::ENOENT при её отсутствии), генерируется исключение SystemCallError.
Этот метод изменяет атрибуты процесса в соответствии с заданными options перед системным вызовом exec(2). Подробнее см. ::spawn об указанных options.
Изменённые атрибуты могут сохраняться, когда системный вызов exec(2) завершается неудачно.
Например, жёсткие лимиты ресурсов не восстанавливаются.
Рассмотрите возможность создания дочернего процесса с помощью ::spawn или #system, если это неприемлемо.
exec "echo *" # echoes list of files in current directory # never get here exec "echo", "*" # echoes an asterisk # never get here
VALUE
rb_f_exit(int argc, const VALUE *argv)
{
int istatus;
if (rb_check_arity(argc, 0, 1) == 1) {
istatus = exit_status_code(argv[0]);
}
else {
istatus = EXIT_SUCCESS;
}
rb_exit(istatus);
UNREACHABLE;
} Инициирует завершение скрипта Ruby, выбросив исключение SystemExit. Это исключение может быть перехвачено. Необязательный параметр используется для возврата кода состояния вызывающей среде. true и FALSE значения status означают успех и неудачу соответственно. Интерпретация других целочисленных значений зависит от системы.
begin exit puts "never get here" rescue SystemExit puts "rescued a SystemExit exception" end puts "after begin block"
выводит:
rescued a SystemExit exception after begin block
Непосредственно перед завершением Ruby выполняет все at_exit функции (см. Kernel::at_exit) и выполняет любые финализаторы объектов (см. ObjectSpace.define_finalizer).
at_exit { puts "at_exit function" }
ObjectSpace.define_finalizer("string", proc { puts "in finalizer" })
exit
выводит:
at_exit function in finalizer
static VALUE
rb_f_exit_bang(int argc, VALUE *argv, VALUE obj)
{
int istatus;
if (rb_check_arity(argc, 0, 1) == 1) {
istatus = exit_status_code(argv[0]);
}
else {
istatus = EXIT_FAILURE;
}
_exit(istatus);
UNREACHABLE;
} Немедленно завершает процесс. Обработчики завершения не выполняются. status возвращается подлежащей системе как код завершения.
Process.exit!(true)
static VALUE
rb_f_raise(int argc, VALUE *argv)
{
VALUE err;
VALUE opts[raise_max_opt], *const cause = &opts[raise_opt_cause];
argc = extract_raise_opts(argc, argv, opts);
if (argc == 0) {
if (*cause != Qundef) {
rb_raise(rb_eArgError, "only cause is given with no arguments");
}
err = get_errinfo();
if (!NIL_P(err)) {
argc = 1;
argv = &err;
}
}
rb_raise_jump(rb_make_exception(argc, argv), *cause);
UNREACHABLE;
} Без аргументов, вызывает исключение в $! или вызывает RuntimeError, если $! равно nil. С одним аргументом String, вызывает RuntimeError с указанной строкой в качестве сообщения. В противном случае, первый параметр должен быть именем класса Exception (или объектом, возвращающим объект Exception при получении сообщения exception). Необязательный второй параметр задаёт сообщение, связанное с исключением, а третий параметр — массив с информацией о колбэках. Исключение перехватывается блоком rescue в begin...end блоке.
raise "Failed to create socket" raise ArgumentError, "No parameters", caller
static VALUE
rb_f_fork(VALUE obj)
{
rb_pid_t pid;
switch (pid = rb_fork_ruby(NULL)) {
case 0:
rb_thread_atfork();
if (rb_block_given_p()) {
int status;
rb_protect(rb_yield, Qundef, &status);
ruby_stop(status);
}
return Qnil;
case -1:
rb_sys_fail("fork(2)");
return Qnil;
default:
return PIDT2NUM(pid);
}
} Создаёт дочерний процесс. Если указан блок, этот блок выполняется в дочернем процессе, и дочерний процесс завершается со статусом ноль. В противном случае, вызов fork происходит дважды: один раз в родительском процессе, возвращая идентификатор процесса дочернего процесса, и один раз в дочернем процессе, возвращая nil. Дочерний процесс может завершиться с помощью Kernel.exit!, чтобы избежать выполнения любых at_exit функций. Родительский процесс должен использовать Process.wait для сбора статусов завершения своих дочерних процессов или использовать Process.detach для отмены интереса к их статусам; в противном случае операционная система может накапливать процессы-зомби.
Поток, вызывающий fork, является единственным потоком в созданном дочернем процессе. fork не копирует другие потоки.
Если fork недоступен, Process.respond_to?(:fork) возвращает false.
Обратите внимание, что fork(2) недоступен на некоторых платформах, таких как Windows и NetBSD 4. Поэтому следует использовать spawn() вместо fork().
VALUE
rb_f_sprintf(int argc, const VALUE *argv)
{
return rb_str_format(argc - 1, argv + 1, GETNTHARG(0));
} Возвращает строку, полученную в результате применения строки_формата к любым дополнительным аргументам. Любые символы в строке формата, кроме последовательностей форматирования, копируются в результат.
Синтаксис последовательности форматирования следующий.
%[flags][width][.precision]type
Последовательность форматирования состоит из знака процента, за которым следуют необязательные флаги, ширина и точность, а затем завершается символом типа поля. Тип поля определяет, как соответствующий sprintf аргумент должен быть интерпретирован, в то время как флаги изменяют эту интерпретацию.
Символы типа поля:
Field | Integer Format
------+--------------------------------------------------------------
b | Convert argument as a binary number.
| Negative numbers will be displayed as a two's complement
| prefixed with `..1'.
B | Equivalent to `b', but uses an uppercase 0B for prefix
| in the alternative format by #.
d | Convert argument as a decimal number.
i | Identical to `d'.
o | Convert argument as an octal number.
| Negative numbers will be displayed as a two's complement
| prefixed with `..7'.
u | Identical to `d'.
x | Convert argument as a hexadecimal number.
| Negative numbers will be displayed as a two's complement
| prefixed with `..f' (representing an infinite string of
| leading 'ff's).
X | Equivalent to `x', but uses uppercase letters.
Field | Float Format
------+--------------------------------------------------------------
e | Convert floating point argument into exponential notation
| with one digit before the decimal point as [-]d.dddddde[+-]dd.
| The precision specifies the number of digits after the decimal
| point (defaulting to six).
E | Equivalent to `e', but uses an uppercase E to indicate
| the exponent.
f | Convert floating point argument as [-]ddd.dddddd,
| where the precision specifies the number of digits after
| the decimal point.
g | Convert a floating point number using exponential form
| if the exponent is less than -4 or greater than or
| equal to the precision, or in dd.dddd form otherwise.
| The precision specifies the number of significant digits.
G | Equivalent to `g', but use an uppercase `E' in exponent form.
a | Convert floating point argument as [-]0xh.hhhhp[+-]dd,
| which is consisted from optional sign, "0x", fraction part
| as hexadecimal, "p", and exponential part as decimal.
A | Equivalent to `a', but use uppercase `X' and `P'.
Field | Other Format
------+--------------------------------------------------------------
c | Argument is the numeric code for a single character or
| a single character string itself.
p | The valuing of argument.inspect.
s | Argument is a string to be substituted. If the format
| sequence contains a precision, at most that many characters
| will be copied.
% | A percent sign itself will be displayed. No argument taken. Флаги изменяют поведение форматирования. Символы флагов:
Flag | Applies to | Meaning
---------+---------------+-----------------------------------------
space | bBdiouxX | Leave a space at the start of
| aAeEfgG | non-negative numbers.
| (numeric fmt) | For `o', `x', `X', `b' and `B', use
| | a minus sign with absolute value for
| | negative values.
---------+---------------+-----------------------------------------
(digit)$ | all | Specifies the absolute argument number
| | for this field. Absolute and relative
| | argument numbers cannot be mixed in a
| | sprintf string.
---------+---------------+-----------------------------------------
# | bBoxX | Use an alternative format.
| aAeEfgG | For the conversions `o', increase the precision
| | until the first digit will be `0' if
| | it is not formatted as complements.
| | For the conversions `x', `X', `b' and `B'
| | on non-zero, prefix the result with ``0x'',
| | ``0X'', ``0b'' and ``0B'', respectively.
| | For `a', `A', `e', `E', `f', `g', and 'G',
| | force a decimal point to be added,
| | even if no digits follow.
| | For `g' and 'G', do not remove trailing zeros.
---------+---------------+-----------------------------------------
+ | bBdiouxX | Add a leading plus sign to non-negative
| aAeEfgG | numbers.
| (numeric fmt) | For `o', `x', `X', `b' and `B', use
| | a minus sign with absolute value for
| | negative values.
---------+---------------+-----------------------------------------
- | all | Left-justify the result of this conversion.
---------+---------------+-----------------------------------------
0 (zero) | bBdiouxX | Pad with zeros, not spaces.
| aAeEfgG | For `o', `x', `X', `b' and `B', radix-1
| (numeric fmt) | is used for negative numbers formatted as
| | complements.
---------+---------------+-----------------------------------------
* | all | Use the next argument as the field width.
| | If negative, left-justify the result. If the
| | asterisk is followed by a number and a dollar
| | sign, use the indicated argument as the width. Примеры флагов:
# `+' and space flag specifies the sign of non-negative numbers.
sprintf("%d", 123) #=> "123"
sprintf("%+d", 123) #=> "+123"
sprintf("% d", 123) #=> " 123"
# `#' flag for `o' increases number of digits to show `0'.
# `+' and space flag changes format of negative numbers.
sprintf("%o", 123) #=> "173"
sprintf("%#o", 123) #=> "0173"
sprintf("%+o", -123) #=> "-173"
sprintf("%o", -123) #=> "..7605"
sprintf("%#o", -123) #=> "..7605"
# `#' flag for `x' add a prefix `0x' for non-zero numbers.
# `+' and space flag disables complements for negative numbers.
sprintf("%x", 123) #=> "7b"
sprintf("%#x", 123) #=> "0x7b"
sprintf("%+x", -123) #=> "-7b"
sprintf("%x", -123) #=> "..f85"
sprintf("%#x", -123) #=> "0x..f85"
sprintf("%#x", 0) #=> "0"
# `#' for `X' uses the prefix `0X'.
sprintf("%X", 123) #=> "7B"
sprintf("%#X", 123) #=> "0X7B"
# `#' flag for `b' add a prefix `0b' for non-zero numbers.
# `+' and space flag disables complements for negative numbers.
sprintf("%b", 123) #=> "1111011"
sprintf("%#b", 123) #=> "0b1111011"
sprintf("%+b", -123) #=> "-1111011"
sprintf("%b", -123) #=> "..10000101"
sprintf("%#b", -123) #=> "0b..10000101"
sprintf("%#b", 0) #=> "0"
# `#' for `B' uses the prefix `0B'.
sprintf("%B", 123) #=> "1111011"
sprintf("%#B", 123) #=> "0B1111011"
# `#' for `e' forces to show the decimal point.
sprintf("%.0e", 1) #=> "1e+00"
sprintf("%#.0e", 1) #=> "1.e+00"
# `#' for `f' forces to show the decimal point.
sprintf("%.0f", 1234) #=> "1234"
sprintf("%#.0f", 1234) #=> "1234."
# `#' for `g' forces to show the decimal point.
# It also disables stripping lowest zeros.
sprintf("%g", 123.4) #=> "123.4"
sprintf("%#g", 123.4) #=> "123.400"
sprintf("%g", 123456) #=> "123456"
sprintf("%#g", 123456) #=> "123456."
Ширина поля — это необязательное целое число, за которым необязательно следует точка и точность. Ширина задаёт минимальное количество символов, которые будут записаны в результат для данного поля.
Примеры ширины:
# padding is done by spaces, width=20
# 0 or radix-1. <------------------>
sprintf("%20d", 123) #=> " 123"
sprintf("%+20d", 123) #=> " +123"
sprintf("%020d", 123) #=> "00000000000000000123"
sprintf("%+020d", 123) #=> "+0000000000000000123"
sprintf("% 020d", 123) #=> " 0000000000000000123"
sprintf("%-20d", 123) #=> "123 "
sprintf("%-+20d", 123) #=> "+123 "
sprintf("%- 20d", 123) #=> " 123 "
sprintf("%020x", -123) #=> "..ffffffffffffffff85"
Для числовых полей точность управляет количеством знаков после запятой. Для строковых полей точность определяет максимальное количество символов, которые будут скопированы из строки. (Таким образом, последовательность форматирования %10.10s всегда будет вносить ровно десять символов в результат.)
Примеры точности:
# precision for `d', 'o', 'x' and 'b' is
# minimum number of digits <------>
sprintf("%20.8d", 123) #=> " 00000123"
sprintf("%20.8o", 123) #=> " 00000173"
sprintf("%20.8x", 123) #=> " 0000007b"
sprintf("%20.8b", 123) #=> " 01111011"
sprintf("%20.8d", -123) #=> " -00000123"
sprintf("%20.8o", -123) #=> " ..777605"
sprintf("%20.8x", -123) #=> " ..ffff85"
sprintf("%20.8b", -11) #=> " ..110101"
# "0x" and "0b" for `#x' and `#b' is not counted for
# precision but "0" for `#o' is counted. <------>
sprintf("%#20.8d", 123) #=> " 00000123"
sprintf("%#20.8o", 123) #=> " 00000173"
sprintf("%#20.8x", 123) #=> " 0x0000007b"
sprintf("%#20.8b", 123) #=> " 0b01111011"
sprintf("%#20.8d", -123) #=> " -00000123"
sprintf("%#20.8o", -123) #=> " ..777605"
sprintf("%#20.8x", -123) #=> " 0x..ffff85"
sprintf("%#20.8b", -11) #=> " 0b..110101"
# precision for `e' is number of
# digits after the decimal point <------>
sprintf("%20.8e", 1234.56789) #=> " 1.23456789e+03"
# precision for `f' is number of
# digits after the decimal point <------>
sprintf("%20.8f", 1234.56789) #=> " 1234.56789000"
# precision for `g' is number of
# significant digits <------->
sprintf("%20.8g", 1234.56789) #=> " 1234.5679"
# <------->
sprintf("%20.8g", 123456789) #=> " 1.2345679e+08"
# precision for `s' is
# maximum number of characters <------>
sprintf("%20.8s", "string test") #=> " string t"
Примеры:
sprintf("%d %04x", 123, 123) #=> "123 007b"
sprintf("%08b '%4s'", 123, 123) #=> "01111011 ' 123'"
sprintf("%1$*2$s %2$d %1$s", "hello", 8) #=> " hello 8 hello"
sprintf("%1$*2$s %2$d", "hello", -8) #=> "hello -8"
sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23) #=> "+1.23: 1.23:1.23"
sprintf("%u", -123) #=> "-123"
Для более сложного форматирования Ruby поддерживает ссылку по имени. Стиль %<имя>s использует стиль форматирования, но стиль %{имя} нет.
Примеры:
sprintf("%<foo>d : %<bar>f", { :foo => 1, :bar => 2 })
#=> 1 : 2.000000
sprintf("%{foo}f", { :foo => 1 })
# => "1f"
static VALUE
rb_f_gets(int argc, VALUE *argv, VALUE recv)
{
if (recv == argf) {
return argf_gets(argc, argv, argf);
}
return rb_funcallv(argf, idGets, argc, argv);
} Возвращает (и присваивает $_) следующую строку из списка файлов в ARGV (или $*), или со стандартного ввода, если на командной строке нет файлов. Возвращает nil в конце файла. Необязательный аргумент задаёт разделитель записей. Разделитель включается в содержимое каждой записи. Разделитель nil считывает всё содержимое, а разделитель нулевой длины считывает ввод по абзацам, где абзацы разделены двумя последовательными символами новой строки. Если первый аргумент — целое число, или дан необязательный второй аргумент, возвращаемая строка не будет длиннее заданного значения в байтах. Если в ARGV присутствуют несколько имён файлов, gets(nil) будет считывать содержимое по одному файлу за раз.
ARGV << "testfile" print while gets
выводит:
This is line one This is line two This is line three And so on...
Стиль программирования с использованием $_ в качестве неявного параметра постепенно теряет популярность в сообществе Ruby.
VALUE
rb_f_global_variables(void)
{
VALUE ary = rb_ary_new();
VALUE sym, backref = rb_backref_get();
rb_id_table_foreach(rb_global_tbl, gvar_i, (void *)ary);
if (!NIL_P(backref)) {
char buf[2];
int i, nmatch = rb_match_count(backref);
buf[0] = '$';
for (i = 1; i <= nmatch; ++i) {
if (!rb_match_nth_defined(i, backref)) continue;
if (i < 10) {
/* probably reused, make static ID */
buf[1] = (char)(i + '0');
sym = ID2SYM(rb_intern2(buf, 2));
}
else {
/* dynamic symbol */
sym = rb_str_intern(rb_sprintf("$%d", i));
}
rb_ary_push(ary, sym);
}
}
return ary;
} Возвращает массив имён глобальных переменных.
global_variables.grep /std/ #=> [:$stdin, :$stdout, :$stderr]
static VALUE
rb_f_gsub(int argc, VALUE *argv)
{
VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("gsub"), argc, argv);
rb_lastline_set(str);
return str;
} Эквивалентно $_.gsub..., за исключением того, что $_ будет обновлён при выполнении подстановки. Доступно только при указании опции командной строки -p/-n.
static VALUE
rb_f_block_given_p(void)
{
rb_execution_context_t *ec = GET_EC();
rb_control_frame_t *cfp = ec->cfp;
cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
if (cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE) {
return Qtrue;
}
else {
return Qfalse;
}
} Возвращает true, если yield бы выполнил блок в текущем контексте. Форма iterator? слегка устарела.
def try
if block_given?
yield
else
"no block"
end
end
try #=> "no block"
try { "hello" } #=> "hello"
try do "hello" end #=> "hello"
VALUE
rb_block_lambda(void)
{
return proc_new(rb_cProc, TRUE);
} Эквивалентно Proc.new, за исключением того, что полученные объекты Proc проверяют количество переданных параметров при вызове.
static VALUE
rb_f_load(int argc, VALUE *argv)
{
VALUE fname, wrap, path, orig_fname;
rb_scan_args(argc, argv, "11", &fname, &wrap);
orig_fname = rb_get_path_check_to_string(fname, rb_safe_level());
fname = rb_str_encode_ospath(orig_fname);
RUBY_DTRACE_HOOK(LOAD_ENTRY, RSTRING_PTR(orig_fname));
path = rb_find_file(fname);
if (!path) {
if (!rb_file_load_ok(RSTRING_PTR(fname)))
load_failed(orig_fname);
path = fname;
}
rb_load_internal(path, RTEST(wrap));
RUBY_DTRACE_HOOK(LOAD_RETURN, RSTRING_PTR(orig_fname));
return Qtrue;
} Загружает и выполняет программу Ruby в файле имя_файла. Если имя файла не разрешается в абсолютный путь, файл ищется в каталогах библиотек, перечисленных в $:. Если необязательный параметр wrap равен true, загружаемый скрипт будет выполнен в анонимном модуле, защищая глобальное пространство имён вызывающей программы. В ни при каких обстоятельствах локальные переменные из загружаемого файла не будут переданы в среду загрузки.
static VALUE
rb_f_local_variables(void)
{
struct local_var_list vars;
rb_execution_context_t *ec = GET_EC();
rb_control_frame_t *cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(ec->cfp));
unsigned int i;
local_var_list_init(&vars);
while (cfp) {
if (cfp->iseq) {
for (i = 0; i < cfp->iseq->body->local_table_size; i++) {
local_var_list_add(&vars, cfp->iseq->body->local_table[i]);
}
}
if (!VM_ENV_LOCAL_P(cfp->ep)) {
/* block */
const VALUE *ep = VM_CF_PREV_EP(cfp);
if (vm_collect_local_variables_in_heap(ep, &vars)) {
break;
}
else {
while (cfp->ep != ep) {
cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
}
}
}
else {
break;
}
}
return local_var_list_finish(&vars);
} Возвращает имена текущих локальных переменных.
fred = 1 for i in 1..10 # ... end local_variables #=> [:fred, :i]
static VALUE
rb_f_loop(VALUE self)
{
RETURN_SIZED_ENUMERATOR(self, 0, 0, rb_f_loop_size);
return rb_rescue2(loop_i, (VALUE)0, loop_stop, (VALUE)0, rb_eStopIteration, (VALUE)0);
} Повторяет выполнение блока.
Если блок не указан, возвращается перечислитель.
loop do print "Input: " line = gets break if !line or line =~ /^qQ/ # ... end
StopIteration, поднятый в блоке, прерывает цикл. В этом случае loop возвращает значение «результата», сохранённое в исключении.
enum = Enumerator.new { |y|
y << "one"
y << "two"
:ok
}
result = loop {
puts enum.next
} #=> :ok
static VALUE
rb_f_p(int argc, VALUE *argv, VALUE self)
{
struct rb_f_p_arg arg;
arg.argc = argc;
arg.argv = argv;
return rb_uninterruptible(rb_f_p_internal, (VALUE)&arg);
} Для каждого объекта напрямую выводит объект.inspect с новой строкой в стандартный вывод программы.
S = Struct.new(:name, :state) s = S['dave', 'TX'] p s
выводит:
#<S name="dave", state="TX">
static VALUE
rb_f_print(int argc, const VALUE *argv)
{
rb_io_print(argc, argv, rb_stdout);
return Qnil;
} Выводит каждый объект по очереди в $stdout. Если разделитель полей вывода ($,) не nil, его содержимое будет отображаться между каждым полем. Если разделитель записей вывода ($\) не nil, он будет добавлен в вывод. Если аргументов нет, выводит $_. Объекты, которые не являются строками, будут преобразованы, вызвав их метод to_s.
print "cat", [1,2,3], 99, "\n" $, = ", " $\ = "\n" print "cat", [1,2,3], 99
Результат:
cat12399 cat, 1, 2, 3, 99
static VALUE
rb_f_printf(int argc, VALUE *argv)
{
VALUE out;
if (argc == 0) return Qnil;
if (RB_TYPE_P(argv[0], T_STRING)) {
out = rb_stdout;
}
else {
out = argv[0];
argv++;
argc--;
}
rb_io_write(out, rb_f_sprintf(argc, argv));
return Qnil;
} Эквивалентно:
io.write(sprintf(string, obj, ...))
или
$stdout.write(sprintf(string, obj, ...))
VALUE
rb_block_proc(void)
{
return proc_new(rb_cProc, FALSE);
} Эквивалентно Proc.new.
static VALUE
rb_f_putc(VALUE recv, VALUE ch)
{
if (recv == rb_stdout) {
return rb_io_putc(recv, ch);
}
return rb_funcallv(rb_stdout, rb_intern("putc"), 1, &ch);
} Эквивалентно:
$stdout.putc(int)
Обратитесь к документации для IO#putc за важной информацией о многобайтовых символах.
static VALUE
rb_f_puts(int argc, VALUE *argv, VALUE recv)
{
if (recv == rb_stdout) {
return rb_io_puts(argc, argv, recv);
}
return rb_funcallv(rb_stdout, rb_intern("puts"), argc, argv);
} Эквивалентно
$stdout.puts(obj, ...)
static VALUE
rb_f_raise(int argc, VALUE *argv)
{
VALUE err;
VALUE opts[raise_max_opt], *const cause = &opts[raise_opt_cause];
argc = extract_raise_opts(argc, argv, opts);
if (argc == 0) {
if (*cause != Qundef) {
rb_raise(rb_eArgError, "only cause is given with no arguments");
}
err = get_errinfo();
if (!NIL_P(err)) {
argc = 1;
argv = &err;
}
}
rb_raise_jump(rb_make_exception(argc, argv), *cause);
UNREACHABLE;
} Без аргументов, вызывает исключение в $! или вызывает RuntimeError если $! равно nil. С одним аргументом, вызывает RuntimeError с заданной строкой в качестве сообщения. В противном случае, первый параметр должен быть именем класса Exception (или объектом, возвращающим объект Exception при отправке сообщения exception). Необязательный второй параметр устанавливает сообщение, связанное с исключением, а третий параметр — массив информации о обратном вызове. Исключения перехватываются в блоке rescue блоков begin...end.
raise "Failed to create socket" raise ArgumentError, "No parameters", caller
static VALUE
rb_f_rand(int argc, VALUE *argv, VALUE obj)
{
VALUE vmax;
rb_random_t *rnd = rand_start(&default_rand);
if (rb_check_arity(argc, 0, 1) && !NIL_P(vmax = argv[0])) {
VALUE v = rand_range(Qnil, rnd, vmax);
if (v != Qfalse) return v;
vmax = rb_to_int(vmax);
if (vmax != INT2FIX(0)) {
v = rand_int(Qnil, rnd, vmax, 0);
if (!NIL_P(v)) return v;
}
}
return DBL2NUM(genrand_real(&rnd->mt));
} Если вызывается без аргумента или если max.to_i.abs == 0, rand возвращает псевдослучайное число с плавающей запятой между 0.0 и 1.0, включая 0.0 и не включая 1.0.
rand #=> 0.2725926052826416
Когда max.abs больше или равно 1, rand возвращает псевдослучайное целое число, большее или равное 0 и меньшее max.to_i.abs.
rand(100) #=> 12
Когда max является объектом Range, rand возвращает случайное число, для которого range.member?(number) == true.
Отрицательные или числа с плавающей запятой для max разрешены, но могут дать неожиданные результаты.
rand(-100) # => 87 rand(-0.5) # => 0.8130921818028143 rand(1.9) # equivalent to rand(1), which is always 0
#srand можно использовать для того, чтобы обеспечить воспроизводимость последовательностей случайных чисел при разных запусках программы.
См. также Random#rand.
static VALUE
rb_f_readline(int argc, VALUE *argv, VALUE recv)
{
if (recv == argf) {
return argf_readline(argc, argv, argf);
}
return rb_funcallv(argf, rb_intern("readline"), argc, argv);
} Эквивалентно Kernel::gets, за исключением того, что readline вызывает EOFError в конце файла.
static VALUE
rb_f_readlines(int argc, VALUE *argv, VALUE recv)
{
if (recv == argf) {
return argf_readlines(argc, argv, argf);
}
return rb_funcallv(argf, rb_intern("readlines"), argc, argv);
} Возвращает массив, содержащий строки, возвращаемые вызовом Kernel.gets(sep) до конца файла.
VALUE
rb_f_require_relative(VALUE obj, VALUE fname)
{
VALUE base = rb_current_realfilepath();
if (NIL_P(base)) {
rb_loaderror("cannot infer basepath");
}
base = rb_file_dirname(base);
return rb_require_safe(rb_file_absolute_path(fname, base), rb_safe_level());
} Ruby пытается загрузить библиотеку с именем string относительно пути файла, который её требует. Если путь к файлу не может быть определён, выбрасывается LoadError. Если файл загружается, возвращается true, в противном случае — false.
static VALUE
rb_f_select(int argc, VALUE *argv, VALUE obj)
{
VALUE timeout;
struct select_args args;
struct timeval timerec;
int i;
rb_scan_args(argc, argv, "13", &args.read, &args.write, &args.except, &timeout);
if (NIL_P(timeout)) {
args.timeout = 0;
}
else {
timerec = rb_time_interval(timeout);
args.timeout = &timerec;
}
for (i = 0; i < numberof(args.fdsets); ++i)
rb_fd_init(&args.fdsets[i]);
return rb_ensure(select_call, (VALUE)&args, select_end, (VALUE)&args);
} Вызывает системный вызов select(2). Отслеживает заданные массивы объектов IO, ожидает, пока один или несколько из IO объектов будут готовы к чтению, готовы к записи и соответственно имеют ожидающие исключения, и возвращает массив, содержащий массивы этих объектов IO. Он вернёт nil, если опциональное значение timeout задано и ни один объект IO не готов в течение timeout секунд.
IO.select просматривает буфер объектов IO для проверки возможности чтения. Если буфер IO не пуст, IO.select немедленно сообщает о возможности чтения. Это «просмотр» происходит только для объектов IO. Это не происходит для объектов, подобных IO, таких как OpenSSL::SSL::SSLSocket.
Лучший способ использовать IO.select — вызвать его после неблокирующих методов, таких как read_nonblock, write_nonblock и т. д. Эти методы генерируют исключение, которое расширяется IO::WaitReadable или IO::WaitWritable. Модули сообщают, как вызывающей стороне следует ожидать с помощью IO.select. Если возникает IO::WaitReadable, вызывающая сторона должна дождаться чтения. Если возникает IO::WaitWritable, вызывающая сторона должна дождаться записи.
Таким образом, блокирующее чтение (readpartial) можно эмулировать с помощью read_nonblock и IO.select следующим образом:
begin result = io_like.read_nonblock(maxlen) rescue IO::WaitReadable IO.select([io_like]) retry rescue IO::WaitWritable IO.select(nil, [io_like]) retry end
В особенности, сочетание неблокирующих методов и IO.select предпочтительно для объектов, подобных потокам, таких как OpenSSL::SSL::SSLSocket. У него есть метод to_io для возврата базового объекта IO. IO.select вызывает to_io для получения дескриптора файла для ожидания.
Это означает, что уведомление о возможности чтения, отправленное IO.select, не означает возможность чтения из объекта OpenSSL::SSL::SSLSocket.
Скорее всего, OpenSSL::SSL::SSLSocket буферизует некоторые данные. IO.select не видит буфер. Таким образом, IO.select может заблокироваться, когда OpenSSL::SSL::SSLSocket#readpartial не блокируется.
Однако существуют и более сложные ситуации.
SSL — это протокол, представляющий собой последовательность записей. Запись состоит из нескольких байтов. Таким образом, удалённая сторона SSL отправляет частичную запись, IO.select сообщает о возможности чтения, но OpenSSL::SSL::SSLSocket не может расшифровать байт и OpenSSL::SSL::SSLSocket#readpartial заблокируется.
Также удалённая сторона может запросить переподключение SSL, которое заставляет локальный движок SSL записать некоторые данные. Это означает, что OpenSSL::SSL::SSLSocket#readpartial может вызвать системный вызов write и он может заблокироваться. В такой ситуации OpenSSL::SSL::SSLSocket#read_nonblock генерирует IO::WaitWritable вместо блокировки. Таким образом, вызывающая сторона должна ожидать готовности к записи, как в примере выше.
Сочетание неблокирующих методов и IO.select также полезно для потоков, таких как tty, сокеты-каналы, сокеты, когда несколько процессов читают из потока.
Наконец, разработчики ядра Linux не гарантируют, что возможность чтения select(2) означает возможность чтения последующим read(2), даже для одного процесса. Обратитесь к руководству select(2) в системе GNU/Linux.
Вызов IO.select перед IO#readpartial работает хорошо, как обычно. Однако это не лучший способ использовать IO.select.
Уведомление о возможности записи, полученное от select(2), не показывает, сколько байтов можно записать. Метод IO#write блокируется до тех пор, пока весь заданный строковый объект не будет записан. Таким образом, IO#write(two or more bytes) может заблокироваться после того, как о возможности записи будет сообщено IO.select. Необходимо IO#write_nonblock, чтобы избежать блокировки.
Блокирующая запись (write) может быть эмулирована с помощью write_nonblock и IO.select следующим образом: IO::WaitReadable также следует обрабатывать для переподключения SSL в OpenSSL::SSL::SSLSocket.
while 0 < string.bytesize
begin
written = io_like.write_nonblock(string)
rescue IO::WaitReadable
IO.select([io_like])
retry
rescue IO::WaitWritable
IO.select(nil, [io_like])
retry
end
string = string.byteslice(written..-1)
end
Параметры
- read_array
-
массив объектов
IO, ожидающих готовности к чтению - write_array
-
массив объектов
IO, ожидающих готовности к записи - error_array
-
массив объектов
IO, ожидающих исключений - timeout
-
числовое значение во секундах
Пример
rp, wp = IO.pipe
mesg = "ping "
100.times {
# IO.select follows IO#read. Not the best way to use IO.select.
rs, ws, = IO.select([rp], [wp])
if r = rs[0]
ret = r.read(5)
print ret
case ret
when /ping/
mesg = "pong\n"
when /pong/
mesg = "ping "
end
end
if w = ws[0]
w.write(mesg)
end
}
выводит:
ping pong ping pong ping pong (snipped) ping
static VALUE
set_trace_func(VALUE obj, VALUE trace)
{
rb_remove_event_hook(call_trace_func);
if (NIL_P(trace)) {
return Qnil;
}
if (!rb_obj_is_proc(trace)) {
rb_raise(rb_eTypeError, "trace_func needs to be Proc");
}
rb_add_event_hook(call_trace_func, RUBY_EVENT_ALL, trace);
return trace;
} Устанавливает proc как обработчик для отслеживания или отключает отслеживание, если параметр равен nil.
Примечание: этот метод устарел, используйте TracePoint вместо него.
proc принимает до шести параметров:
-
имя события
-
имя файла
-
номер строки
-
идентификатор объекта
-
связывание
-
имя класса
proc вызывается всякий раз, когда происходит событие.
События:
-
c-call -
вызов C-функции
-
c-return -
возврат из C-функции
-
call -
вызов Ruby-метода
-
class -
начало определения класса или модуля
-
end -
завершение определения класса или модуля
-
line -
выполнение кода в новой строке
-
raise -
выбрасывание исключения
-
return -
возврат из Ruby-метода
Отслеживание отключается в контексте proc.
class Test
def test
a = 1
b = 2
end
end
set_trace_func proc { |event, file, line, id, binding, classname|
printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname
}
t = Test.new
t.test
line prog.rb:11 false
c-call prog.rb:11 new Class
c-call prog.rb:11 initialize Object
c-return prog.rb:11 initialize Object
c-return prog.rb:11 new Class
line prog.rb:12 false
call prog.rb:2 test Test
line prog.rb:3 test Test
line prog.rb:4 test Test
return prog.rb:4 test Test static VALUE
rb_f_sleep(int argc, VALUE *argv)
{
time_t beg, end;
beg = time(0);
if (argc == 0) {
rb_thread_sleep_forever();
}
else {
rb_check_arity(argc, 0, 1);
rb_thread_wait_for(rb_time_interval(argv[0]));
}
end = time(0) - beg;
return INT2FIX(end);
} Приостанавливает текущую нить на duration секунд (что может быть любым числом, включая Float с дробными секундами). Возвращает фактическое количество проспанных секунд (округлённое), которое может быть меньше запрошенного, если другая нить вызовет Thread#run. Вызванный без аргумента, sleep() будет спать вечно.
Time.new #=> 2008-03-08 19:56:19 +0900 sleep 1.2 #=> 1 Time.new #=> 2008-03-08 19:56:20 +0900 sleep 1.9 #=> 2 Time.new #=> 2008-03-08 19:56:22 +0900
static VALUE
rb_f_spawn(int argc, VALUE *argv)
{
rb_pid_t pid;
char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' };
VALUE execarg_obj, fail_str;
struct rb_execarg *eargp;
execarg_obj = rb_execarg_new(argc, argv, TRUE);
eargp = rb_execarg_get(execarg_obj);
fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
pid = rb_execarg_spawn(execarg_obj, errmsg, sizeof(errmsg));
if (pid == -1) {
int err = errno;
rb_exec_fail(eargp, err, errmsg);
RB_GC_GUARD(execarg_obj);
rb_syserr_fail_str(err, fail_str);
}
#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
return PIDT2NUM(pid);
#else
return Qnil;
#endif
} spawn выполняет указанную команду и возвращает её pid.
pid = spawn("tar xf ruby-2.0.0-p195.tar.bz2")
Process.wait pid
pid = spawn(RbConfig.ruby, "-eputs'Hello, world!'")
Process.wait pid
Этот метод похож на #system, но не ожидает завершения команды.
Родительский процесс должен использовать Process.wait для получения статуса завершения своего дочернего процесса или использовать Process.detach для отмены интереса к их статусу; в противном случае операционная система может накапливать процессы-зомби.
spawn имеет ряд опций для указания атрибутов процесса:
env: hash
name => val : set the environment variable
name => nil : unset the environment variable
the keys and the values except for +nil+ must be strings.
command...:
commandline : command line string which is passed to the standard shell
cmdname, arg1, ... : command name and one or more arguments (This form does not use the shell. See below for caveats.)
[cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
options: hash
clearing environment variables:
:unsetenv_others => true : clear environment variables except specified by env
:unsetenv_others => false : don't clear (default)
process group:
:pgroup => true or 0 : make a new process group
:pgroup => pgid : join the specified process group
:pgroup => nil : don't change the process group (default)
create new process group: Windows only
:new_pgroup => true : the new process is the root process of a new process group
:new_pgroup => false : don't create a new process group (default)
resource limit: resourcename is core, cpu, data, etc. See Process.setrlimit.
:rlimit_resourcename => limit
:rlimit_resourcename => [cur_limit, max_limit]
umask:
:umask => int
redirection:
key:
FD : single file descriptor in child process
[FD, FD, ...] : multiple file descriptor in child process
value:
FD : redirect to the file descriptor in parent process
string : redirect to file with open(string, "r" or "w")
[string] : redirect to file with open(string, File::RDONLY)
[string, open_mode] : redirect to file with open(string, open_mode, 0644)
[string, open_mode, perm] : redirect to file with open(string, open_mode, perm)
[:child, FD] : redirect to the redirected file descriptor
:close : close the file descriptor in child process
FD is one of follows
:in : the file descriptor 0 which is the standard input
:out : the file descriptor 1 which is the standard output
:err : the file descriptor 2 which is the standard error
integer : the file descriptor of specified the integer
io : the file descriptor specified as io.fileno
file descriptor inheritance: close non-redirected non-standard fds (3, 4, 5, ...) or not
:close_others => true : don't inherit
current directory:
:chdir => str
The 'cmdname, arg1, ...' form does not use the shell. However,
on different OSes, different things are provided as built-in
commands. An example of this is 'echo', which is a built-in
on Windows, but is a normal program on Linux and Mac OS X.
This means that `Process.spawn 'echo', '%Path%'` will display
the contents of the `%Path%` environment variable on Windows,
but `Process.spawn 'echo', '$PATH'` prints the literal '$PATH'. Если в качестве env передаётся хеш, среда изменяется с помощью env перед exec(2) в дочернем процессе. Если пара в env имеет nil в качестве значения, переменная удаляется.
# set FOO as BAR and unset BAZ.
pid = spawn({"FOO"=>"BAR", "BAZ"=>nil}, command)
Если в качестве options передаётся хеш, он определяет группу процессов, создание новой группы процессов, ограничения ресурсов, текущий каталог, umask и перенаправления для дочернего процесса. Также можно указать очистку переменных среды.
Ключ :unsetenv_others в options указывает на очистку переменных среды, кроме тех, что указаны env.
pid = spawn(command, :unsetenv_others=>true) # no environment variable
pid = spawn({"FOO"=>"BAR"}, command, :unsetenv_others=>true) # FOO only
Ключ :pgroup в options определяет группу процессов. Соответствующее значение должно быть true, нулём, положительным целым числом или nil. true и ноль заставляют процесс стать лидером процесса новой группы процессов. Положительное целое число отличное от нуля заставляет процесс присоединиться к указанной группе процессов. По умолчанию, nil, процесс остаётся в той же группе процессов.
pid = spawn(command, :pgroup=>true) # process leader pid = spawn(command, :pgroup=>10) # belongs to the process group 10
Ключ :new_pgroup в options указывает на передачу флага CREATE_NEW_PROCESS_GROUP в CreateProcessW(), что является API Windows. Эта опция предназначена только для Windows. true означает, что новый процесс является корневым процессом новой группы процессов. Новый процесс имеет отключённую комбинацию клавиш CTRL+C. Этот флаг необходим для Process.kill(:SIGINT,
pid) в дочернем процессе. :new_pgroup по умолчанию имеет значение false.
pid = spawn(command, :new_pgroup=>true) # new process group pid = spawn(command, :new_pgroup=>false) # same process group
Ключ :rlimit_foo указывает на ограничение ресурсов. foo должен быть одним из типов ресурсов, таких как core. Соответствующее значение должно быть целым числом или массивом, содержащим одно или два целых числа: аналогично аргументам cur_limit и max_limit для Process.setrlimit.
cur, max = Process.getrlimit(:CORE) pid = spawn(command, :rlimit_core=>[0,max]) # disable core temporary. pid = spawn(command, :rlimit_core=>max) # enable core dump pid = spawn(command, :rlimit_core=>0) # never dump core.
Ключ :umask в options указывает umask.
pid = spawn(command, :umask=>077)
Ключи :in, :out, :err, целое число, IO и массив определяют перенаправление. Перенаправление сопоставляет дескриптор файла в дочернем процессе.
Например, stderr можно объединить со stdout следующим образом:
pid = spawn(command, :err=>:out) pid = spawn(command, 2=>1) pid = spawn(command, STDERR=>:out) pid = spawn(command, STDERR=>STDOUT)
Ключи хеша определяют дескриптор файла в дочернем процессе, запущенном spawn. :err, 2 и STDERR указывают стандартный поток ошибок (stderr).
Значения хеша определяют дескриптор файла в родительском процессе, вызывающем spawn. :out, 1 и STDOUT указывают стандартный поток вывода (stdout).
В приведенном примере стандартный вывод в дочернем процессе не указан. Поэтому он наследуется от родительского процесса.
Стандартный поток ввода (stdin) может быть указан с помощью :in, 0 и STDIN.
Можно указать имя файла как значение хеша.
pid = spawn(command, :in=>"/dev/null") # read mode pid = spawn(command, :out=>"/dev/null") # write mode pid = spawn(command, :err=>"log") # write mode pid = spawn(command, [:out, :err]=>"/dev/null") # write mode pid = spawn(command, 3=>"/dev/null") # read mode
Для stdout и stderr (и их комбинации) он открывается в режиме записи. В противном случае используется режим чтения.
Для явного указания флагов и разрешений при создании файла используется массив.
pid = spawn(command, :in=>["file"]) # read mode is assumed pid = spawn(command, :in=>["file", "r"]) pid = spawn(command, :out=>["log", "w"]) # 0644 assumed pid = spawn(command, :out=>["log", "w", 0600]) pid = spawn(command, :out=>["log", File::WRONLY|File::EXCL|File::CREAT, 0600])
Массив задаёт имя файла, флаги и разрешения. Флаги могут быть строкой или целым числом. Если флаги отсутствуют или nil, предполагается File::RDONLY. Разрешения должны быть целым числом. Если разрешения отсутствуют или nil, предполагается 0644.
Если в качестве ключа хеша указан массив IOs и целых чисел, все элементы перенаправляются.
# stdout and stderr is redirected to log file. # The file "log" is opened just once. pid = spawn(command, [:out, :err]=>["log", "w"])
Ещё один способ объединения нескольких дескрипторов файлов – [:child, fd]. [:child, fd] означает дескриптор файла в дочернем процессе. Это отличается от fd. Например, :err=>:out означает перенаправление child stderr в родительский stdout. Но :err=>[:child, :out] означает перенаправление child stderr в child stdout. Различия возникают, если stdout перенаправляется в дочернем процессе следующим образом.
# stdout and stderr is redirected to log file. # The file "log" is opened just once. pid = spawn(command, :out=>["log", "w"], :err=>[:child, :out])
[:child, :out] может использоваться для объединения stderr со stdout в IO.popen. В этом случае IO.popen перенаправляет stdout в канал в дочернем процессе, и [:child, :out] ссылается на перенаправленный stdout.
io = IO.popen(["sh", "-c", "echo out; echo err >&2", :err=>[:child, :out]]) p io.read #=> "out\nerr\n"
Ключ :chdir в options указывает текущий каталог.
pid = spawn(command, :chdir=>"/var/tmp")
spawn по умолчанию закрывает все нестандартные неуказанные дескрипторы. «Стандартные» дескрипторы – 0, 1 и 2. Это поведение задаётся опцией :close_others. :close_others не влияет на стандартные дескрипторы, которые закрываются только если :close указан явно.
pid = spawn(command, :close_others=>true) # close 3,4,5,... (default) pid = spawn(command, :close_others=>false) # don't close 3,4,5,...
По умолчанию :close_others имеет значение true для spawn и IO.popen.
Обратите внимание, что дескрипторы файлов, для которых флаг close-on-exec уже установлен, закрываются независимо от опции :close_others.
Таким образом, IO.pipe и spawn могут использоваться как IO.popen.
# similar to r = IO.popen(command) r, w = IO.pipe pid = spawn(command, :out=>w) # r, w is closed in the child process. w.close
:close указывается как значение хеша для закрытия fd индивидуально.
f = open(foo) system(command, f=>:close) # don't inherit f.
Если дескриптор файла нужно унаследовать, можно использовать io=>io.
# valgrind has --log-fd option for log destination.
# log_w=>log_w indicates log_w.fileno inherits to child process.
log_r, log_w = IO.pipe
pid = spawn("valgrind", "--log-fd=#{log_w.fileno}", "echo", "a", log_w=>log_w)
log_w.close
p log_r.read
Также возможно обмен дескрипторами файлов.
pid = spawn(command, :out=>:err, :err=>:out)
Ключи хеша указывают дескрипторы файлов в дочернем процессе. Значения хеша указывают дескрипторы файлов в родительском процессе. Таким образом, вышеуказанное указывает обмен stdout и stderr. Внутри spawn используется дополнительный дескриптор для разрешения такой циклической карты дескрипторов файлов.
См. Kernel.exec для стандартной оболочки.
VALUE
rb_f_sprintf(int argc, const VALUE *argv)
{
return rb_str_format(argc - 1, argv + 1, GETNTHARG(0));
} Возвращает строку, полученную путём применения format_string к дополнительным аргументам. Все символы в строке формата, кроме последовательностей формата, копируются в результат.
Синтаксис последовательности формата следующий.
%[flags][width][.precision]type
Последовательность формата состоит из знака процента, за которым следуют необязательные флаги, ширина и точность, а затем завершается символом типа поля. Тип поля управляет тем, как соответствующий sprintf аргумент интерпретируется, а флаги изменяют эту интерпретацию.
Символы типов полей:
Field | Integer Format
------+--------------------------------------------------------------
b | Convert argument as a binary number.
| Negative numbers will be displayed as a two's complement
| prefixed with `..1'.
B | Equivalent to `b', but uses an uppercase 0B for prefix
| in the alternative format by #.
d | Convert argument as a decimal number.
i | Identical to `d'.
o | Convert argument as an octal number.
| Negative numbers will be displayed as a two's complement
| prefixed with `..7'.
u | Identical to `d'.
x | Convert argument as a hexadecimal number.
| Negative numbers will be displayed as a two's complement
| prefixed with `..f' (representing an infinite string of
| leading 'ff's).
X | Equivalent to `x', but uses uppercase letters.
Field | Float Format
------+--------------------------------------------------------------
e | Convert floating point argument into exponential notation
| with one digit before the decimal point as [-]d.dddddde[+-]dd.
| The precision specifies the number of digits after the decimal
| point (defaulting to six).
E | Equivalent to `e', but uses an uppercase E to indicate
| the exponent.
f | Convert floating point argument as [-]ddd.dddddd,
| where the precision specifies the number of digits after
| the decimal point.
g | Convert a floating point number using exponential form
| if the exponent is less than -4 or greater than or
| equal to the precision, or in dd.dddd form otherwise.
| The precision specifies the number of significant digits.
G | Equivalent to `g', but use an uppercase `E' in exponent form.
a | Convert floating point argument as [-]0xh.hhhhp[+-]dd,
| which is consisted from optional sign, "0x", fraction part
| as hexadecimal, "p", and exponential part as decimal.
A | Equivalent to `a', but use uppercase `X' and `P'.
Field | Other Format
------+--------------------------------------------------------------
c | Argument is the numeric code for a single character or
| a single character string itself.
p | The valuing of argument.inspect.
s | Argument is a string to be substituted. If the format
| sequence contains a precision, at most that many characters
| will be copied.
% | A percent sign itself will be displayed. No argument taken. Флаги изменяют поведение форматов. Символы флагов:
Flag | Applies to | Meaning
---------+---------------+-----------------------------------------
space | bBdiouxX | Leave a space at the start of
| aAeEfgG | non-negative numbers.
| (numeric fmt) | For `o', `x', `X', `b' and `B', use
| | a minus sign with absolute value for
| | negative values.
---------+---------------+-----------------------------------------
(digit)$ | all | Specifies the absolute argument number
| | for this field. Absolute and relative
| | argument numbers cannot be mixed in a
| | sprintf string.
---------+---------------+-----------------------------------------
# | bBoxX | Use an alternative format.
| aAeEfgG | For the conversions `o', increase the precision
| | until the first digit will be `0' if
| | it is not formatted as complements.
| | For the conversions `x', `X', `b' and `B'
| | on non-zero, prefix the result with ``0x'',
| | ``0X'', ``0b'' and ``0B'', respectively.
| | For `a', `A', `e', `E', `f', `g', and 'G',
| | force a decimal point to be added,
| | even if no digits follow.
| | For `g' and 'G', do not remove trailing zeros.
---------+---------------+-----------------------------------------
+ | bBdiouxX | Add a leading plus sign to non-negative
| aAeEfgG | numbers.
| (numeric fmt) | For `o', `x', `X', `b' and `B', use
| | a minus sign with absolute value for
| | negative values.
---------+---------------+-----------------------------------------
- | all | Left-justify the result of this conversion.
---------+---------------+-----------------------------------------
0 (zero) | bBdiouxX | Pad with zeros, not spaces.
| aAeEfgG | For `o', `x', `X', `b' and `B', radix-1
| (numeric fmt) | is used for negative numbers formatted as
| | complements.
---------+---------------+-----------------------------------------
* | all | Use the next argument as the field width.
| | If negative, left-justify the result. If the
| | asterisk is followed by a number and a dollar
| | sign, use the indicated argument as the width. Примеры флагов:
# `+' and space flag specifies the sign of non-negative numbers.
sprintf("%d", 123) #=> "123"
sprintf("%+d", 123) #=> "+123"
sprintf("% d", 123) #=> " 123"
# `#' flag for `o' increases number of digits to show `0'.
# `+' and space flag changes format of negative numbers.
sprintf("%o", 123) #=> "173"
sprintf("%#o", 123) #=> "0173"
sprintf("%+o", -123) #=> "-173"
sprintf("%o", -123) #=> "..7605"
sprintf("%#o", -123) #=> "..7605"
# `#' flag for `x' add a prefix `0x' for non-zero numbers.
# `+' and space flag disables complements for negative numbers.
sprintf("%x", 123) #=> "7b"
sprintf("%#x", 123) #=> "0x7b"
sprintf("%+x", -123) #=> "-7b"
sprintf("%x", -123) #=> "..f85"
sprintf("%#x", -123) #=> "0x..f85"
sprintf("%#x", 0) #=> "0"
# `#' for `X' uses the prefix `0X'.
sprintf("%X", 123) #=> "7B"
sprintf("%#X", 123) #=> "0X7B"
# `#' flag for `b' add a prefix `0b' for non-zero numbers.
# `+' and space flag disables complements for negative numbers.
sprintf("%b", 123) #=> "1111011"
sprintf("%#b", 123) #=> "0b1111011"
sprintf("%+b", -123) #=> "-1111011"
sprintf("%b", -123) #=> "..10000101"
sprintf("%#b", -123) #=> "0b..10000101"
sprintf("%#b", 0) #=> "0"
# `#' for `B' uses the prefix `0B'.
sprintf("%B", 123) #=> "1111011"
sprintf("%#B", 123) #=> "0B1111011"
# `#' for `e' forces to show the decimal point.
sprintf("%.0e", 1) #=> "1e+00"
sprintf("%#.0e", 1) #=> "1.e+00"
# `#' for `f' forces to show the decimal point.
sprintf("%.0f", 1234) #=> "1234"
sprintf("%#.0f", 1234) #=> "1234."
# `#' for `g' forces to show the decimal point.
# It also disables stripping lowest zeros.
sprintf("%g", 123.4) #=> "123.4"
sprintf("%#g", 123.4) #=> "123.400"
sprintf("%g", 123456) #=> "123456"
sprintf("%#g", 123456) #=> "123456."
Ширина поля – необязательное целое число, за которым необязательно следует точка и точность. Ширина определяет минимальное количество символов, которое будет записано в результат для данного поля.
Примеры ширины:
# padding is done by spaces, width=20
# 0 or radix-1. <------------------>
sprintf("%20d", 123) #=> " 123"
sprintf("%+20d", 123) #=> " +123"
sprintf("%020d", 123) #=> "00000000000000000123"
sprintf("%+020d", 123) #=> "+0000000000000000123"
sprintf("% 020d", 123) #=> " 0000000000000000123"
sprintf("%-20d", 123) #=> "123 "
sprintf("%-+20d", 123) #=> "+123 "
sprintf("%- 20d", 123) #=> " 123 "
sprintf("%020x", -123) #=> "..ffffffffffffffff85"
Для числовых полей точность контролирует количество десятичных знаков, отображаемых. Для строковых полей точность определяет максимальное количество символов, которые будут скопированы из строки. (Таким образом, последовательность формата %10.10s всегда будет вносить ровно десять символов в результат.)
Примеры точностей:
# precision for `d', 'o', 'x' and 'b' is
# minimum number of digits <------>
sprintf("%20.8d", 123) #=> " 00000123"
sprintf("%20.8o", 123) #=> " 00000173"
sprintf("%20.8x", 123) #=> " 0000007b"
sprintf("%20.8b", 123) #=> " 01111011"
sprintf("%20.8d", -123) #=> " -00000123"
sprintf("%20.8o", -123) #=> " ..777605"
sprintf("%20.8x", -123) #=> " ..ffff85"
sprintf("%20.8b", -11) #=> " ..110101"
# "0x" and "0b" for `#x' and `#b' is not counted for
# precision but "0" for `#o' is counted. <------>
sprintf("%#20.8d", 123) #=> " 00000123"
sprintf("%#20.8o", 123) #=> " 00000173"
sprintf("%#20.8x", 123) #=> " 0x0000007b"
sprintf("%#20.8b", 123) #=> " 0b01111011"
sprintf("%#20.8d", -123) #=> " -00000123"
sprintf("%#20.8o", -123) #=> " ..777605"
sprintf("%#20.8x", -123) #=> " 0x..ffff85"
sprintf("%#20.8b", -11) #=> " 0b..110101"
# precision for `e' is number of
# digits after the decimal point <------>
sprintf("%20.8e", 1234.56789) #=> " 1.23456789e+03"
# precision for `f' is number of
# digits after the decimal point <------>
sprintf("%20.8f", 1234.56789) #=> " 1234.56789000"
# precision for `g' is number of
# significant digits <------->
sprintf("%20.8g", 1234.56789) #=> " 1234.5679"
# <------->
sprintf("%20.8g", 123456789) #=> " 1.2345679e+08"
# precision for `s' is
# maximum number of characters <------>
sprintf("%20.8s", "string test") #=> " string t"
Примеры:
sprintf("%d %04x", 123, 123) #=> "123 007b"
sprintf("%08b '%4s'", 123, 123) #=> "01111011 ' 123'"
sprintf("%1$*2$s %2$d %1$s", "hello", 8) #=> " hello 8 hello"
sprintf("%1$*2$s %2$d", "hello", -8) #=> "hello -8"
sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23) #=> "+1.23: 1.23:1.23"
sprintf("%u", -123) #=> "-123"
Для более сложной форматировки Ruby поддерживает ссылку по имени. Стиль %<имя>s использует стиль форматирования, а стиль %{имя} — нет.
Примеры:
sprintf("%<foo>d : %<bar>f", { :foo => 1, :bar => 2 })
#=> 1 : 2.000000
sprintf("%{foo}f", { :foo => 1 })
# => "1f"
static VALUE
rb_f_srand(int argc, VALUE *argv, VALUE obj)
{
VALUE seed, old;
rb_random_t *r = &default_rand;
if (rb_check_arity(argc, 0, 1) == 0) {
seed = random_seed();
}
else {
seed = rb_to_int(argv[0]);
}
old = r->seed;
r->seed = rand_init(&r->mt, seed);
return old;
} Инициализирует генератор псевдослучайных чисел системы Random::DEFAULT значением number. Возвращает предыдущее значение семени.
Если number опущено, генератор инициализируется с помощью источника энтропии, предоставляемого операционной системой (если доступно /dev/urandom в системах Unix или криптографический модуль RSA в Windows), который затем объединяется со временем, идентификатором процесса и номером последовательности.
srand может использоваться для обеспечения повторяющихся последовательностей псевдослучайных чисел между различными запусками программы. Установив семенное значение, программы могут быть определёнными во время тестирования.
srand 1234 # => 268519324636777531569100071560086917274 [ rand, rand ] # => [0.1915194503788923, 0.6221087710398319] [ rand(10), rand(1000) ] # => [4, 664] srand 1234 # => 1234 [ rand, rand ] # => [0.1915194503788923, 0.6221087710398319]
static VALUE
rb_f_sub(int argc, VALUE *argv)
{
VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("sub"), argc, argv);
rb_lastline_set(str);
return str;
} Эквивалентно $_.sub(args), за исключением того, что $_ будет обновлено, если произойдёт замена. Доступно только при указании опций командной строки -p/-n.
static VALUE
rb_f_syscall(int argc, VALUE *argv)
{
VALUE arg[8];
#if SIZEOF_VOIDP == 8 && defined(HAVE___SYSCALL) && SIZEOF_INT != 8 /* mainly *BSD */
# define SYSCALL __syscall
# define NUM2SYSCALLID(x) NUM2LONG(x)
# define RETVAL2NUM(x) LONG2NUM(x)
# if SIZEOF_LONG == 8
long num, retval = -1;
# elif SIZEOF_LONG_LONG == 8
long long num, retval = -1;
# else
# error ---->> it is asserted that __syscall takes the first argument and returns retval in 64bit signed integer. <<----
# endif
#elif defined(__linux__)
# define SYSCALL syscall
# define NUM2SYSCALLID(x) NUM2LONG(x)
# define RETVAL2NUM(x) LONG2NUM(x)
/*
* Linux man page says, syscall(2) function prototype is below.
*
* int syscall(int number, ...);
*
* But, it's incorrect. Actual one takes and returned long. (see unistd.h)
*/
long num, retval = -1;
#else
# define SYSCALL syscall
# define NUM2SYSCALLID(x) NUM2INT(x)
# define RETVAL2NUM(x) INT2NUM(x)
int num, retval = -1;
#endif
int i;
if (RTEST(ruby_verbose)) {
rb_warning("We plan to remove a syscall function at future release. DL(Fiddle) provides safer alternative.");
}
if (argc == 0)
rb_raise(rb_eArgError, "too few arguments for syscall");
if (argc > numberof(arg))
rb_raise(rb_eArgError, "too many arguments for syscall");
num = NUM2SYSCALLID(argv[0]); ++argv;
for (i = argc - 1; i--; ) {
VALUE v = rb_check_string_type(argv[i]);
if (!NIL_P(v)) {
SafeStringValue(v);
rb_str_modify(v);
arg[i] = (VALUE)StringValueCStr(v);
}
else {
arg[i] = (VALUE)NUM2LONG(argv[i]);
}
}
switch (argc) {
case 1:
retval = SYSCALL(num);
break;
case 2:
retval = SYSCALL(num, arg[0]);
break;
case 3:
retval = SYSCALL(num, arg[0],arg[1]);
break;
case 4:
retval = SYSCALL(num, arg[0],arg[1],arg[2]);
break;
case 5:
retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3]);
break;
case 6:
retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4]);
break;
case 7:
retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4],arg[5]);
break;
case 8:
retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6]);
break;
}
if (retval == -1)
rb_sys_fail(0);
return RETVAL2NUM(retval);
#undef SYSCALL
#undef NUM2SYSCALLID
#undef RETVAL2NUM
} Вызывает функцию операционной системы, идентифицируемую значением num, и возвращает результат выполнения функции или вызывает исключение SystemCallError, если произошла ошибка.
Аргументы функции могут следовать за значением num. Они должны быть объектами типа String или Integer. Объект типа String передаётся как указатель на последовательность байтов. Объект типа Integer передаётся как целое число, размер разрядности которого совпадает с размером указателя. Может быть передано до девяти параметров.
Функция, идентифицируемая значением num, зависит от операционной системы. В некоторых системах Unix номера функций можно получить из заголовочного файла, называемого syscall.h.
syscall 4, 1, "hello\n", 6 # '4' is write(2) on our box
возвращает:
hello
Вызов syscall на платформе, не имеющей доступа к произвольной системной функции, завершается ошибкой NotImplementedError.
Примечание: syscall в значительной степени небезопасен и непереносим. Не стесняйтесь использовать его на свой страх и риск. Для более безопасного и переносимого программирования предпочтительно использовать библиотеку DL (Fiddle).
static VALUE
rb_f_system(int argc, VALUE *argv)
{
rb_pid_t pid;
int status;
#if defined(SIGCLD) && !defined(SIGCHLD)
# define SIGCHLD SIGCLD
#endif
#ifdef SIGCHLD
RETSIGTYPE (*chfunc)(int);
rb_last_status_clear();
chfunc = signal(SIGCHLD, SIG_DFL);
#endif
pid = rb_spawn_internal(argc, argv, NULL, 0);
#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
if (pid > 0) {
int ret, status;
ret = rb_waitpid(pid, &status, 0);
if (ret == (rb_pid_t)-1)
rb_sys_fail("Another thread waited the process started by system().");
}
#endif
#ifdef SIGCHLD
signal(SIGCHLD, chfunc);
#endif
if (pid < 0) {
return Qnil;
}
status = PST2INT(rb_last_status_get());
if (status == EXIT_SUCCESS) return Qtrue;
return Qfalse;
} Выполняет command… в дочернем процессе. command… может иметь один из следующих форматов.
commandline : command line string which is passed to the standard shell cmdname, arg1, ... : command name and one or more arguments (no shell) [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
system возвращает true, если команда завершилась с кодом возврата 0, false для ненулевого кода возврата. Возвращает nil в случае неудачи при выполнении команды. Статус ошибки доступен в $?. Аргументы обрабатываются так же, как и в случае с Kernel.spawn.
Аргументы в формате хеша, env и options, соответствуют exec и spawn соответственно. Подробности см. в Kernel.spawn.
system("echo *")
system("echo", "*")
возвращает:
config.h main.rb *
См. Kernel.exec для стандартной оболочки.
static VALUE
rb_f_test(int argc, VALUE *argv)
{
int cmd;
if (argc == 0) rb_check_arity(argc, 2, 3);
cmd = NUM2CHR(argv[0]);
if (cmd == 0) {
unknown:
/* unknown command */
if (ISPRINT(cmd)) {
rb_raise(rb_eArgError, "unknown command '%s%c'", cmd == '\'' || cmd == '\\' ? "\\" : "", cmd);
}
else {
rb_raise(rb_eArgError, "unknown command \"\\x%02X\"", cmd);
}
}
if (strchr("bcdefgGkloOprRsSuwWxXz", cmd)) {
CHECK(1);
switch (cmd) {
case 'b':
return rb_file_blockdev_p(0, argv[1]);
case 'c':
return rb_file_chardev_p(0, argv[1]);
case 'd':
return rb_file_directory_p(0, argv[1]);
case 'e':
return rb_file_exist_p(0, argv[1]);
case 'f':
return rb_file_file_p(0, argv[1]);
case 'g':
return rb_file_sgid_p(0, argv[1]);
case 'G':
return rb_file_grpowned_p(0, argv[1]);
case 'k':
return rb_file_sticky_p(0, argv[1]);
case 'l':
return rb_file_symlink_p(0, argv[1]);
case 'o':
return rb_file_owned_p(0, argv[1]);
case 'O':
return rb_file_rowned_p(0, argv[1]);
case 'p':
return rb_file_pipe_p(0, argv[1]);
case 'r':
return rb_file_readable_p(0, argv[1]);
case 'R':
return rb_file_readable_real_p(0, argv[1]);
case 's':
return rb_file_size_p(0, argv[1]);
case 'S':
return rb_file_socket_p(0, argv[1]);
case 'u':
return rb_file_suid_p(0, argv[1]);
case 'w':
return rb_file_writable_p(0, argv[1]);
case 'W':
return rb_file_writable_real_p(0, argv[1]);
case 'x':
return rb_file_executable_p(0, argv[1]);
case 'X':
return rb_file_executable_real_p(0, argv[1]);
case 'z':
return rb_file_zero_p(0, argv[1]);
}
}
if (strchr("MAC", cmd)) {
struct stat st;
VALUE fname = argv[1];
CHECK(1);
if (rb_stat(fname, &st) == -1) {
int e = errno;
FilePathValue(fname);
rb_syserr_fail_path(e, fname);
}
switch (cmd) {
case 'A':
return stat_atime(&st);
case 'M':
return stat_mtime(&st);
case 'C':
return stat_ctime(&st);
}
}
if (cmd == '-') {
CHECK(2);
return rb_file_identical_p(0, argv[1], argv[2]);
}
if (strchr("=<>", cmd)) {
struct stat st1, st2;
struct timespec t1, t2;
CHECK(2);
if (rb_stat(argv[1], &st1) < 0) return Qfalse;
if (rb_stat(argv[2], &st2) < 0) return Qfalse;
t1 = stat_mtimespec(&st1);
t2 = stat_mtimespec(&st2);
switch (cmd) {
case '=':
if (t1.tv_sec == t2.tv_sec && t1.tv_nsec == t2.tv_nsec) return Qtrue;
return Qfalse;
case '>':
if (t1.tv_sec > t2.tv_sec) return Qtrue;
if (t1.tv_sec == t2.tv_sec && t1.tv_nsec > t2.tv_nsec) return Qtrue;
return Qfalse;
case '<':
if (t1.tv_sec < t2.tv_sec) return Qtrue;
if (t1.tv_sec == t2.tv_sec && t1.tv_nsec < t2.tv_nsec) return Qtrue;
return Qfalse;
}
}
goto unknown;
} Использует символ cmd для выполнения различных проверок над file1 (первая таблица ниже) или над file1 и file2 (вторая таблица).
Проверки для одного файла:
Cmd Returns Meaning
"A" | Time | Last access time for file1
"b" | boolean | True if file1 is a block device
"c" | boolean | True if file1 is a character device
"C" | Time | Last change time for file1
"d" | boolean | True if file1 exists and is a directory
"e" | boolean | True if file1 exists
"f" | boolean | True if file1 exists and is a regular file
"g" | boolean | True if file1 has the \CF{setgid} bit
| | set (false under NT)
"G" | boolean | True if file1 exists and has a group
| | ownership equal to the caller's group
"k" | boolean | True if file1 exists and has the sticky bit set
"l" | boolean | True if file1 exists and is a symbolic link
"M" | Time | Last modification time for file1
"o" | boolean | True if file1 exists and is owned by
| | the caller's effective uid
"O" | boolean | True if file1 exists and is owned by
| | the caller's real uid
"p" | boolean | True if file1 exists and is a fifo
"r" | boolean | True if file1 is readable by the effective
| | uid/gid of the caller
"R" | boolean | True if file is readable by the real
| | uid/gid of the caller
"s" | int/nil | If file1 has nonzero size, return the size,
| | otherwise return nil
"S" | boolean | True if file1 exists and is a socket
"u" | boolean | True if file1 has the setuid bit set
"w" | boolean | True if file1 exists and is writable by
| | the effective uid/gid
"W" | boolean | True if file1 exists and is writable by
| | the real uid/gid
"x" | boolean | True if file1 exists and is executable by
| | the effective uid/gid
"X" | boolean | True if file1 exists and is executable by
| | the real uid/gid
"z" | boolean | True if file1 exists and has a zero length Проверки для двух файлов:
"-" | boolean | True if file1 and file2 are identical
"=" | boolean | True if the modification times of file1
| | and file2 are equal
"<" | boolean | True if the modification time of file1
| | is prior to that of file2
">" | boolean | True if the modification time of file1
| | is after that of file2 static VALUE
rb_f_throw(int argc, VALUE *argv)
{
VALUE tag, value;
rb_scan_args(argc, argv, "11", &tag, &value);
rb_throw_obj(tag, value);
UNREACHABLE;
} Передает управление в конец активного catch блока, ожидая метки tag. Возбуждает исключение UncaughtThrowError если для метки tag не существует catch блока. Необязательный второй параметр задаёт возвращаемое значение для catch блока; в противном случае значение по умолчанию равно nil. Примеры см. в Kernel::catch.
VALUE
rb_f_trace_var(int argc, const VALUE *argv)
{
VALUE var, cmd;
struct rb_global_entry *entry;
struct trace_var *trace;
if (rb_scan_args(argc, argv, "11", &var, &cmd) == 1) {
cmd = rb_block_proc();
}
if (NIL_P(cmd)) {
return rb_f_untrace_var(argc, argv);
}
entry = rb_global_entry(rb_to_id(var));
if (OBJ_TAINTED(cmd)) {
rb_raise(rb_eSecurityError, "Insecure: tainted variable trace");
}
trace = ALLOC(struct trace_var);
trace->next = entry->var->trace;
trace->func = rb_trace_eval;
trace->data = cmd;
trace->removed = 0;
entry->var->trace = trace;
return Qnil;
} Управляет отслеживанием присваиваний глобальным переменным. Параметр symbol идентифицирует переменную (как строковое имя или идентификатор символа). cmd (который может быть строкой или объектом Proc) или блок выполняются всякий раз, когда переменная получает новое значение. Блок или объект Proc получают новое значение переменной в качестве параметра. Также см. Kernel::untrace_var.
trace_var :$_, proc {|v| puts "$_ is now '#{v}'" }
$_ = "hello"
$_ = ' there'
возвращает:
$_ is now 'hello' $_ is now ' there'
static VALUE
sig_trap(int argc, VALUE *argv)
{
int sig;
sighandler_t func;
VALUE cmd;
rb_check_arity(argc, 1, 2);
sig = trap_signm(argv[0]);
if (reserved_signal_p(sig)) {
const char *name = signo2signm(sig);
if (name)
rb_raise(rb_eArgError, "can't trap reserved signal: SIG%s", name);
else
rb_raise(rb_eArgError, "can't trap reserved signal: %d", sig);
}
if (argc == 1) {
cmd = rb_block_proc();
func = sighandler;
}
else {
cmd = argv[1];
func = trap_handler(&cmd, sig);
}
if (OBJ_TAINTED(cmd)) {
rb_raise(rb_eSecurityError, "Insecure: tainted signal trap");
}
return trap(sig, func, cmd);
} Устанавливает обработчик сигналов. Первый параметр — имя сигнала (строка, например, “SIGALRM”, “SIGUSR1” и так далее) или номер сигнала. Символы “SIG” можно опустить из имени сигнала. Команда или блок задают код, который будет выполнен при возникновении сигнала. Если команда — строка “IGNORE” или “SIG_IGN”, сигнал будет проигнорирован. Если команда — “DEFAULT” или “SIG_DFL”, будет вызван обработчик по умолчанию Ruby. Если команда — “EXIT”, сценарий завершится сигналом. Если команда — “SYSTEM_DEFAULT”, будет вызван обработчик по умолчанию операционной системы. В противном случае, будет выполнена заданная команда или блок. Специальное имя сигнала “EXIT” или номер сигнала ноль вызывается непосредственно перед завершением программы. trap возвращает предыдущий обработчик для данного сигнала.
Signal.trap(0, proc { puts "Terminating: #{$$}" })
Signal.trap("CLD") { puts "Child died" }
fork && Process.wait
возвращает:
Terminating: 27461 Child died Terminating: 27460
VALUE
rb_f_untrace_var(int argc, const VALUE *argv)
{
VALUE var, cmd;
ID id;
struct rb_global_entry *entry;
struct trace_var *trace;
VALUE data;
rb_scan_args(argc, argv, "11", &var, &cmd);
id = rb_check_id(&var);
if (!id) {
rb_name_error_str(var, "undefined global variable %"PRIsVALUE"", QUOTE(var));
}
if (!rb_id_table_lookup(rb_global_tbl, id, &data)) {
rb_name_error(id, "undefined global variable %"PRIsVALUE"", QUOTE_ID(id));
}
trace = (entry = (struct rb_global_entry *)data)->var->trace;
if (NIL_P(cmd)) {
VALUE ary = rb_ary_new();
while (trace) {
struct trace_var *next = trace->next;
rb_ary_push(ary, (VALUE)trace->data);
trace->removed = 1;
trace = next;
}
if (!entry->var->block_trace) remove_trace(entry->var);
return ary;
}
else {
while (trace) {
if (trace->data == cmd) {
trace->removed = 1;
if (!entry->var->block_trace) remove_trace(entry->var);
return rb_ary_new3(1, cmd);
}
trace = trace->next;
}
}
return Qnil;
} Удаляет отслеживание для указанной команды по заданной глобальной переменной и возвращает nil. Если команда не указана, удаляет всё отслеживание для этой переменной и возвращает массив, содержащий команды, которые были удалены.
static VALUE
rb_warn_m(int argc, VALUE *argv, VALUE exc)
{
VALUE opts, location = Qnil;
if (!NIL_P(ruby_verbose) && argc > 0 &&
(argc = rb_scan_args(argc, argv, "*:", NULL, &opts)) > 0) {
VALUE str = argv[0], uplevel = Qnil;
if (!NIL_P(opts)) {
static ID kwds[1];
if (!kwds[0]) {
CONST_ID(kwds[0], "uplevel");
}
rb_get_kwargs(opts, kwds, 0, 1, &uplevel);
if (uplevel == Qundef) {
uplevel = Qnil;
}
else if (!NIL_P(uplevel)) {
VALUE args[2];
long lev = NUM2LONG(uplevel);
if (lev < 0) {
rb_raise(rb_eArgError, "negative level (%ld)", lev);
}
args[0] = LONG2NUM(lev + 1);
args[1] = INT2FIX(1);
location = rb_vm_thread_backtrace_locations(2, args, GET_THREAD()->self);
if (!NIL_P(location)) {
location = rb_ary_entry(location, 0);
}
}
}
if (argc > 1 || !NIL_P(uplevel) || !end_with_asciichar(str, '\n')) {
VALUE path;
if (NIL_P(uplevel)) {
str = rb_str_tmp_new(0);
}
else if (NIL_P(location) ||
NIL_P(path = rb_funcall(location, rb_intern("path"), 0))) {
str = rb_str_new_cstr("warning: ");
}
else {
str = rb_sprintf("%s:%ld: warning: ",
rb_string_value_ptr(&path),
NUM2LONG(rb_funcall(location, rb_intern("lineno"), 0)));
}
RBASIC_SET_CLASS(str, rb_cWarningBuffer);
rb_io_puts(argc, argv, str);
RBASIC_SET_CLASS(str, rb_cString);
}
if (exc == rb_mWarning) {
rb_must_asciicompat(str);
rb_write_error_str(str);
}
else {
rb_write_warning_str(str);
}
}
return Qnil;
} Если предупреждения отключены (например, с помощью флага -W0 ), ничего не делается. В противном случае, каждое сообщение преобразуется в строку, к строке добавляется символ новой строки, если она на нём не заканчивается, и вызывается Warning.warn со строкой.
warn("warning 1", "warning 2")
<em>produces:</em>
warning 1
warning 2 Приватные методы экземпляра
# File ext/json/lib/json/common.rb, line 438
def JSON(object, *args)
if object.respond_to? :to_str
JSON.parse(object.to_str, args.first)
else
JSON.generate(object, args.first)
end
end Если object является строкой, разобрать строку и вернуть результат разбора как структуру данных Ruby. В противном случае, сгенерировать текстовое представление JSON из объекта Ruby структуры данных и вернуть его.
Аргумент opts передаётся в функцию генерации/разбора соответственно. См. документацию для функций генерации и разбора.
# File lib/uri/common.rb, line 738
def URI(uri)
if uri.is_a?(URI::Generic)
uri
elsif uri = String.try_convert(uri)
URI.parse(uri)
else
raise ArgumentError,
"bad argument (expected URI object or URI string)"
end
end Возвращает uri, преобразованный в объект URI.
# File lib/rubygems/core_ext/kernel_gem.rb, line 43
def gem(gem_name, *requirements) # :doc:
skip_list = (ENV['GEM_SKIP'] || "").split(/:/)
raise Gem::LoadError, "skipping #{gem_name}" if skip_list.include? gem_name
if gem_name.kind_of? Gem::Dependency
unless Gem::Deprecate.skip
warn "#{Gem.location_of_caller.join ':'}:Warning: Kernel.gem no longer "\
"accepts a Gem::Dependency object, please pass the name "\
"and requirements directly"
end
requirements = gem_name.requirement
gem_name = gem_name.name
end
dep = Gem::Dependency.new(gem_name, *requirements)
loaded = Gem.loaded_specs[gem_name]
return false if loaded && dep.matches_spec?(loaded)
spec = dep.to_spec
Gem::LOADED_SPECS_MUTEX.synchronize {
spec.activate
} if spec
end Используйте #gem для активации конкретной версии gem_name.
requirements — список требований к версии, которым должна соответствовать указанная библиотека, чаще всего в формате “= example.version.number”. См. Gem::Requirement для уточнения способов указания требований к версии.
Если вы активируете самую последнюю версию библиотеки, вызов #gem не нужен, #require сделает это автоматически.
#gem возвращает true, если библиотека активирована, в противном случае — false. Если библиотека не найдена, не соответствует требованиям к версии или уже активирована другая версия, будет выброшено исключение.
#gem следует вызывать до любых инструкций require (в противном случае RubyGems может загрузить конфликтующую версию библиотеки).
#gem загружает предварительные версии только при указании предварительных requirements:
gem 'rake', '>= 1.1.a', '< 2'
В старых версиях RubyGems для пропуска активации определённых библиотек можно было использовать переменную среды GEM_SKIP, например, для тестирования изменений, которые ещё не установлены. Теперь RubyGems использует -I и переменную среды RUBYLIB для пропуска активации библиотеки.
Пример:
GEM_SKIP=libA:libB ruby -I../libA -I../libB ./mycode.rb
# File ext/json/lib/json/common.rb, line 416
def j(*objs)
objs.each do |obj|
puts JSON::generate(obj, :allow_nan => true, :max_nesting => false)
end
nil
end Выводит objs в STDOUT в виде строк JSON в краткой форме, то есть в одну строку.
# File ext/json/lib/json/common.rb, line 425
def jj(*objs)
objs.each do |obj|
puts JSON::pretty_generate(obj, :allow_nan => true, :max_nesting => false)
end
nil
end Выводит objs в STDOUT в виде строк JSON в красивом формате с отступами и на нескольких строках.
static VALUE
rb_f_open(int argc, VALUE *argv)
{
ID to_open = 0;
int redirect = FALSE;
if (argc >= 1) {
CONST_ID(to_open, "to_open");
if (rb_respond_to(argv[0], to_open)) {
redirect = TRUE;
}
else {
VALUE tmp = argv[0];
FilePathValue(tmp);
if (NIL_P(tmp)) {
redirect = TRUE;
}
else {
VALUE cmd = check_pipe_command(tmp);
if (!NIL_P(cmd)) {
argv[0] = cmd;
return rb_io_s_popen(argc, argv, rb_cIO);
}
}
}
}
if (redirect) {
VALUE io = rb_funcallv(argv[0], to_open, argc-1, argv+1);
if (rb_block_given_p()) {
return rb_ensure(rb_yield, io, io_close, io);
}
return io;
}
return rb_io_s_open(argc, argv, rb_cFile);
} Создаёт объект IO, связанный с указанным потоком, файлом или подпроцессом.
Если path не начинается с символа '|' (|), считать его именем файла для открытия с указанным режимом (по умолчанию «r»).
mode — это строка или целое число. Если целое число, оно должно быть побитовым объединением флагов open(2), таких как File::RDWR или File::EXCL. Если это строка, она имеет формат «fmode», «fmode:ext_enc» или «fmode:ext_enc:int_enc».
См. документацию IO.new для полного описания директив строки mode.
Если создаётся файл, его начальные права могут быть установлены с помощью параметра perm. См. File.new и страницы руководства open(2) и chmod(2) для описания прав.
Если указан блок, он будет вызван с объектом IO в качестве параметра, а IO будет автоматически закрыт по завершении блока. Вызов возвращает значение блока.
Если path начинается с символа '|' ("|"), создаётся подпроцесс, соединённый с вызывающей стороной парой каналов. Возвращаемый объект IO может использоваться для записи в стандартный ввод и чтения из стандартного вывода этого подпроцесса.
Если команда после символа '|' — одиночный дефис ("|-"), Ruby создаёт вилку, и этот подпроцесс соединяется с родительским. Если команда не "-", подпроцесс выполняет указанную команду.
Если подпроцесс — это Ruby (открыт через "|-"), вызов open возвращает nil. Если с вызовом open связан блок, этот блок выполнится дважды — один раз в родительском процессе, и один раз в дочернем.
Параметр блока будет объектом IO в родительском процессе и nil в дочернем. Объект IO родительского процесса будет соединён со стандартным вводом ($stdin) и стандартным выводом ($stdout) дочернего процесса. Подпроцесс завершится по завершении блока.
Примеры
Чтение из файла “testfile”:
open("testfile") do |f|
print f.gets
end
Вывод:
This is line one
Открытие подпроцесса и чтение его вывода:
cmd = open("|date")
print cmd.gets
cmd.close
Вывод:
Wed Apr 9 08:56:31 CDT 2003
Открытие подпроцесса, выполняющего ту же программу Ruby:
f = open("|-", "w+")
if f.nil?
puts "in Child"
exit
else
puts "Got: #{f.gets}"
end
Вывод:
Got: in Child
Открытие подпроцесса с использованием блока для получения объекта IO:
open "|-" do |f|
if f then
# parent process
puts "Got: #{f.gets}"
else
# child process
puts "in Child"
end
end
Вывод:
Got: in Child
# File lib/pp.rb, line 551
def pp(*objs)
objs.each {|obj|
PP.pp(obj)
}
objs.size <= 1 ? objs.first : objs
end Выводит аргументы в красивой форме.
pp возвращает аргументы.
# File lib/rubygems/core_ext/kernel_require.rb, line 38
def require path
RUBYGEMS_ACTIVATION_MONITOR.enter
path = path.to_path if path.respond_to? :to_path
if spec = Gem.find_unresolved_default_spec(path)
Gem.remove_unresolved_default_spec(spec)
begin
Kernel.send(:gem, spec.name)
rescue Exception
RUBYGEMS_ACTIVATION_MONITOR.exit
raise
end
end
# If there are no unresolved deps, then we can use just try
# normal require handle loading a gem from the rescue below.
if Gem::Specification.unresolved_deps.empty? then
RUBYGEMS_ACTIVATION_MONITOR.exit
return gem_original_require(path)
end
# If +path+ is for a gem that has already been loaded, don't
# bother trying to find it in an unresolved gem, just go straight
# to normal require.
#--
# TODO request access to the C implementation of this to speed up RubyGems
if Gem::Specification.find_active_stub_by_path(path)
RUBYGEMS_ACTIVATION_MONITOR.exit
return gem_original_require(path)
end
# Attempt to find +path+ in any unresolved gems...
found_specs = Gem::Specification.find_in_unresolved path
# If there are no directly unresolved gems, then try and find +path+
# in any gems that are available via the currently unresolved gems.
# For example, given:
#
# a => b => c => d
#
# If a and b are currently active with c being unresolved and d.rb is
# requested, then find_in_unresolved_tree will find d.rb in d because
# it's a dependency of c.
#
if found_specs.empty? then
found_specs = Gem::Specification.find_in_unresolved_tree path
found_specs.each do |found_spec|
found_spec.activate
end
# We found +path+ directly in an unresolved gem. Now we figure out, of
# the possible found specs, which one we should activate.
else
# Check that all the found specs are just different
# versions of the same gem
names = found_specs.map(&:name).uniq
if names.size > 1 then
RUBYGEMS_ACTIVATION_MONITOR.exit
raise Gem::LoadError, "#{path} found in multiple gems: #{names.join ', '}"
end
# Ok, now find a gem that has no conflicts, starting
# at the highest version.
valid = found_specs.find { |s| !s.has_conflicts? }
unless valid then
le = Gem::LoadError.new "unable to find a version of '#{names.first}' to activate"
le.name = names.first
RUBYGEMS_ACTIVATION_MONITOR.exit
raise le
end
valid.activate
end
RUBYGEMS_ACTIVATION_MONITOR.exit
return gem_original_require(path)
rescue LoadError => load_error
RUBYGEMS_ACTIVATION_MONITOR.enter
begin
if load_error.message.start_with?("Could not find") or
(load_error.message.end_with?(path) and Gem.try_activate(path)) then
require_again = true
end
ensure
RUBYGEMS_ACTIVATION_MONITOR.exit
end
return gem_original_require(path) if require_again
raise load_error
end При использовании RubyGems, #require заменяется на собственную реализацию, способную загружать библиотеки по требованию.
Когда вы вызываете require 'x', происходит следующее:
-
Если файл можно загрузить из существующего пути загрузки Ruby, это делается.
-
В противном случае, выполнятся поиск в установленных библиотеках файла, который соответствует. Если он найден в библиотеке 'y', эта библиотека активируется (добавляется в путь загрузки).
Сохранена обычная require функциональность возврата false, если этот файл уже был загружен.
# File lib/scanf.rb, line 772 def scanf(format, &b) #:doc: STDIN.scanf(format ,&b) end
Сканирует стандартный ввод (STDIN) на наличие данных, соответствующих format. См. IO#scanf для деталей.
См. Scanf для деталей по созданию строки формата.
Вам потребуется загрузить 'scanf', чтобы использовать #scanf.
# File ext/psych/lib/psych/y.rb, line 4 def y *objects puts Psych.dump_stream(*objects) end
Псевдоним для Psych.dump_stream, предназначенный для использования с IRB.
Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.
