Приложение 1 - Значения
Руководство пользователя REBOL/Core
Основное содержание
Отправьте нам отзыв
Содержание:
1. Числовые значения
1.1 Десятичные
1.2 Целое число
2. Серии значений
2.1 Двоичный
2.2 Блок
2.3 Электронная почта
2.4 Файл
2.5 Хэш
2.6 Изображение
2.7 Проблема
2.8 Список
2.9 Парен
2.10 Путь
2.11 Строка
2.12 Тег
2.13 URL
3. Другие значения
3.1 Символ
3.2 Дата
3.3 Логика
3.4 Деньги
3.5 None
3.6 Пара
3.7 Уточнение
3.8 Время
3.9 Кортеж
3.10 Слова
1. Числовые значения
1.1 Десятичный
1.1.1 Концепция
Тип данных decimal! основан на 64-битных стандартных числах с плавающей запятой IEEE. Они отличаются от целых чисел десятичной точкой (точка или запятая разрешены для международного использования, см. Примечания ниже).
1.1.2 Формат
Десятичные значения представляют собой последовательность числовых цифр, за которыми следует десятичная точка, которая может быть точкой (.) или запятой (,), за которой следует несколько цифр. Знак плюс (+) или минус (-) непосредственно перед первой цифрой обозначает знак числа. Начальные нули перед десятичной точкой игнорируются. Лишние пробелы, запятые и точки не допускаются.
1.23
123.
123.0
0.321
0.123
1234.5678
Вместо точки можно использовать запятую для обозначения десятичной точки (что является стандартом во многих странах):
1,23
0,321
1234,5678
Используйте одинарные кавычки (`) для разделения цифр в длинных десятичных дробях. Одиночные кавычки могут появляться в любом месте после первой цифры числа, но не перед первой цифрой.
100'234'562.3782
100'234'562,3782
Не используйте запятые или точки для разделения цифр в десятичном значении.
Научная нотация может использоваться для указания степени числа, добавляя к числу букву E или e, за которой следует последовательность цифр. Показатель степени может быть положительным или отрицательным числом.
1.23E10
1.2e007
123.45e-42
56,72E300
-0,34e-12
0.0001e-001
Десятичные числа варьируются от 2,2250738585072e-308 до 1,7976931348623e + 308 и могут содержать до 15 цифр точности.
1.1.3 Создание
Используйте функцию to-decimal (в-десятичное) для преобразования типов данных string! (строка!),
integer! (целое!), block! (блок!), или decimal! (десятичное) в десятичное число:
probe to-decimal "123.45"
123.45
probe to-decimal 123
123
probe to-decimal [-123 45]
-1.23E+47
probe to-decimal [123 -45]
1.23E-43
probe to-decimal -123.8
-123.8
probe to-decimal 12.3
12.3
Если в выражении объединены десятичное и целое число, целое число преобразуется в десятичное число:
probe 1.2 + 2
3.2
probe 2 + 1.2
3.2
probe 1.01 > 1
true
probe 1 > 1.01
false
1.1.4 Связанные
Используйте фенкцию decimal? (десятичное?) чтобы определить, является ли значение типа данных decimal! (десятичное!).
print decimal? 0.123
true
Используйте функции form, print и mold с целочисленным аргументом, чтобы распечатать десятичное значение в его простейшей форме:
- целое число. Если его можно представить как единое целое.
- десятичная дробь без экспоненты. Если он не слишком большой или слишком маленький.
- научная нотация. Если он слишком большой или маленький.
Например,
probe mold 123.4
123.4
probe form 2222222222222222
2.22222222222222E+15
print 1.00001E+5
100001
Одиночные кавычки (`) и ведущий знак плюс (+) не отображаются в десятичном выводе:
print +1'100'200.222'112
1100200.222112
1.2 Целое число
1.2.1 Концепция
Тип данных integer! включает 32-битные положительные и отрицательные числа и ноль. В отличие от десятичных чисел, целые числа не содержат десятичной точки.
1.2.2 Формат
Целочисленные значения состоят из последовательности цифр. Знак плюс (+) или минус (-) непосредственно перед первой цифрой обозначает знак. Между знаком и первой цифрой не может быть пробела. Начальные нули игнорируются.
0 1234 +1234 -1234 00012 -0123
Не используйте запятые или точки в целых числах. Если запятая или точка находятся внутри целого числа, это интерпретируется как десятичное значение. Однако вы можете использовать одиночные кавычки (`) для разделения цифр в длинных целых числах. Одиночные кавычки могут появляться в любом месте после первой цифры числа, но не перед первой цифрой.
2'147'483'647
Целые числа охватывают диапазон от -2147483648 до 2147483647.
1.2.3 Создание
Используйте функцию to-integer (в-целое) для преобразования string! (строка!), logic! (логическле!), decimal! (десятичное!), или integer! (целое!) типов данных к целому числу:
probe to-integer "123"
123
probe to-integer false
0
probe to-integer true
1
probe to-integer 123.4
123
probe to-integer 123.8
123
probe to-integer -123.8
-123
Если в выражении объединены десятичное и целое число, целое число преобразуется в десятичное:
probe 1.2 + 2
3.2
probe 2 + 1.2
3.2
probe 1.01 > 1
true
probe 0 < .001
true
1.2.4 Связанные
Используйте integer? чтобы определить, является ли значение целым числом - тип данных integer!.
probe integer? -1234
true
Используйте функции form, print и mold с целочисленным аргументом, чтобы вывести целочисленное значение в виде строки:
probe mold 123
123
probe form 123
123
print 123
123
Целые числа, которые находятся вне диапазона или не могут быть представлены в 32-битном формате, помечаются как ошибка.
2. Значения серий
2.1 Двоичный
2.1.1 Концепция
Двоичные значения содержат двоичные данные любого произвольного типа. Может быть сохранена любая последовательность байтов, например изображение, аудио, исполняемый файл, сжатые данные и зашифрованные данные. Исходным форматом двоичных данных может быть base-2 (двоичный), base-16 (шестнадцатеричный) и base-64. Базой по умолчанию для двоичных данных в REBOL является base-16.
2.1.2 Формат
Двоичные строки записываются в виде знака числа (#), за которым следует строка, заключенная в фигурные скобки. Символы в строке кодируются в одном из нескольких форматов, определяемых необязательным числом перед знаком числа. Base-16 - это формат по умолчанию.
#{3A18427F 899AEFD8} ; default base-16
2#{10010110110010101001011011001011} ; base-2
64#{LmNvbSA8yw9CB0aGvXmgUkVCu2Uz934b} ; base-64
Внутри строки разрешены пробелы, табуляции и новые строки. Двоичные данные могут занимать несколько строк.
probe #{
3A
18
92
56
}
#{3A189256}
Строки, в которых отсутствует правильное количество символов для создания правильного двоичного результата, дополняются справа.
2.1.3 Создание
Функция to-binary (в-двоичное) преобразует данные в тип данных binary! (двоичные) в базе по умолчанию, установленной в system/options/binary-base:
probe to-binary "123"
#{313233}
probe to-binary "today is the day..."
#{746F64617920697320746865206461792E2E2E}
Чтобы преобразовать целое число в его двоичное значение, передайте его в блоке:
probe to-binary [1]
#{01}
probe to-binary [11]
#{0B}
Преобразование серии целых чисел в двоичное возвращает преобразование битов для каждого целого числа, объединенного в одно двоичное значение:
probe to-binary [1 1 1 1]
#{01010101}
2.1.4 Связанные
Использовать binary? (двоичный?), чтобы определить является ли значение binary! (двоичное!) типом данных.
probe binary? #{616263}
true
Двоичные значения - это тип серии:
probe series? #{616263}
true
probe length? #{616263} ; три шестнадцатеричных значения в этом двоичном формате
3
Тесно связано с работой с типом данных binary! функции enbase и debase. Функция enbase преобразует строки в их представления base-2, base-16 или base-64 как строки. Функция debase преобразует enbased строку в двоичное значение базы, указанной в system/options/binary-base.
2.2 Блок
2.2.1 Концепция
Блоки - это группы значений и слов. Блоки используются везде, от самого сценария до блоков данных и кода, представленных в сценарии.
Значения блоков обозначаются открывающими и закрывающими квадратными скобками ([ ]) с любым количеством данных, содержащихся между ними.
[123 data "hi"] ; блок с данными
[] ; пустой блок
Блоки могут содержать записи информации:
woodsmen: [
"Paul" "Bunyan" paul@bunyan.dom
"Grizzly" "Adams" grizzly@adams.dom
"Davy" "Crocket" davy@crocket.dom
]
Блоки могут содержать код:
[print "this is a segment of code"]
Блоки также являются типом серий, и поэтому все, что можно сделать с серией, можно сделать с помощью значения блока.
Блоки можно искать:
probe copy/part (find woodsmen "Grizzly") 3
[
"Grizzly" "Adams" grizzly@adams.dom]
Блоки можно модифицировать:
append woodsmen [
"John" "Muir" john@muir.dom
]
probe woodsmen
[
"Paul" "Bunyan" paul@bunyan.dom
"Grizzly" "Adams" grizzly@adams.dom
"Davy" "Crocket" davy@crocket.dom
"John" "Muir" john@muir.dom
]
Блоки можно оценивать:
blk: [print "data in a block"]
do blk
data in a block
Блоки могут содержать любое количество любых блоков:
blks: [
[print "block one"]
[print "block two"]
[print "block three"]
]
foreach blk blks [do blk]
block one
block two
block three
2.2.2 Формат
Блоки могут содержать любое количество значений или вообще не содержать значений. Они могут занимать несколько строк и включать в себя значения любого типа, включая другие блоки.
Пустой блок:
[ ]
Блок целых чисел:
[24 37 108]
Заголовок REBOL:
REBOL [
Title: "Test Script"
Date: 31-Dec-1998
Author: "Ima User"
]
Блок условия и оценки функции:/p>
while [time < 10:00] [
print time
time: time + 0:10
]
Слова в блоке определять не нужно:
blk: [undefined words in a block]
probe value? pick blk 1
false
Блоки допускают любое количество строк, пробелов или табуляции. Строки и пробелы можно размещать в любом месте блока, если они не разделяют одно значение.
2.2.3 Создание
Функция to-block (в-блок) преобразует данные в тип данных block!:
probe to-block luke@rebol.com
[luke@rebol.com]
probe to-block {123 10:30 "string" luke@rebol.com}
[123 10:30 "string" luke@rebol.com]
2.2.4 Связанные
Использовать block? чтобы определить, является ли значение типом данных block!.
probe block? [123 10:30]
true
Поскольку блоки являются подмножеством псевдотипа series! (серия!), использовать series? чтобы проверить это:
probe series? [123 10:30]
true
Использование form для значения блока создаёт строку из содержимого, содержащегося в блоке:
probe form [123 10:30]
123 10:30
Использование mold для значения блока создаёт строку из значения блока и его содержимого, что позволяет перезагрузить его как значение блока REBOL:
probe mold [123 10:30]
[123 10:30]
Тесно связанные типы данных - это hash! (хэш!) и list! (список!). Они используются почти так же, как значения блоков, но имеют особые возможности. Значения списков предназначены для более быстрой обработки изменений списков, чем значения блоков, а значения хэшей предназначены для обработки поиска и индексации данных по хешам. Это полезно при работе с большими наборами данных.
2.3 Электронная почта
2.3.1 Концепция
Адрес электронной почты - это тип данных. Тип данных email! позволяет легко выражать адреса электронной почты:
send luke@rebol.com {some message}
emails: [
john@keats.dom
lord@byron.dom
edger@guest.dom
alfred@tennyson.dom
]
mesg: {poetry reading at 8:00pm!}
foreach email emails [send email mesg]
Электронная почта тоже входит в тип данных series!, поэтому те же правила, которые применяются к сериям, применяются к электронным письмам:
probe head change/part jane@doe.dom "john" 4
john@doe.dom
2.3.2 Формат
Стандартный формат адреса электронной почты - это имя, за которым следует знак (@), за которым следует домен. Адрес электронной почты может быть любой длины, но не должен включать какие-либо запрещенные символы, такие как квадратные скобки, кавычки, фигурные скобки, пробелы, символы новой строки и т.д..
Следующее типы данных email! имеют допустимые форматы:
info@rebol.com
123@number-mail.org
my-name.here@an.example-domain.com
В адресах электронной почты сохраняются прописные и строчные буквы.
2.3.3 Доступ
Уточнения можно использовать со значением электронной почты, чтобы получить имя пользователя или домен. Уточнения:
- /user - получить имя пользователя.
- /host - получить домен.
Вот как работают эти уточнения:
email: luke@rebol.com
probe email/user
luke
probe email/host
rebol.com
2.3.4 Создание
Функция to-email (в-электронную-почту) преобразует данные в тип данных email!:
probe to-email "info@rebol.com"
info@rebol.com
probe to-email [info rebol.com]
info@rebol.com
probe to-email [info rebol com]
info@rebol.com
probe to-email [user some long domain name out there dom]
user@some.long.domain.name.out.there.dom
2.3.5 Связанные
Использовать email? чтобы определить, является ли значение типом данных email!.
probe email? luke@rebol.com
true
Поскольку электронные письма - это подмножество псевдотипа series!, использовать series? чтобы определить, является ли значение серией:
probe series? luke@rebol.com
true
probe pick luke@rebol.com 5
#"@"
2.4 Файл
2.4.1 Концепция
Тип данных file! может быть именем файла, именем каталога или путем к каталогу.
%file.txt
%directory/
%directory/path/to/some/file.txt
Значения файлов являются подмножеством серий, поэтому ими можно управлять как сериями:
probe find %dir/path1/path2/file.txt "path2"
%path2/file.txt
f: %dir/path/file.txt
probe head remove/part (find f "path/") (length? "path/")
%dir/file.txt
2.4.2 Формат
Файлы обозначаются знаком процента (%), за которым следует последовательность символов:
load %image.jpg
prog: load %examples.r
save %this-file.txt "This file has few words."
files: load %../programs/
Необычные символы в именах файлов должны быть закодированы с помощью % и шестнадцатеричного числа, что является соглашением в Интернете. Имя файла с пробелом (шестнадцатеричное 20) будет выглядеть так:
probe %cool%20movie%20clip.mpg
%cool%20movie%20clip.mpg
print %cool%20movie%20clip.mpg
cool movie clip.mpg
Другой формат - заключить имя файла в кавычки:
probe %"cool movie clip.mpg"
%cool%20movie%20clip.mpg
print %"cool movie clip.mpg"
cool movie clip.mpg
Стандартным символом для разделения каталогов в пути является косая черта (/), а не обратная косая черта (\). Однако язык REBOL автоматически преобразует обратную косую черту в именах файлов в прямую косую черту:
probe %\some\path\to\some\where\movieclip.mpg
%/some/path/to/some/where/movieclip.mpg
2.4.3 Создание
Функция to-file (в-файл) преобразует данные в тип данных file!:
probe to-file "testfile"
%testfile
При передаче блока элементы в блоке объединяются в путь к файлу с последним элементом, используемым в качестве имени файла:
probe to-file [some path to a file the-file.txt]
%some/path/to/a/file/the-file.txt
2.4.4 Связанные
Используйте file? чтобы определить, является ли значение типом данных file!.
probe file? %rebol.r
true
Поскольку файлы являются частью псевдотипа series!, использовать series? чтобы проверить это:
probe series? %rebol.r
true
2.5 Хеш
2.5.1 Концепция
Хеш - это блок, специально организованный для ускорения поиска данных. Когда поиск выполняется по хэш-блоку, поиск выполняется с использованием хеш-таблицы для поиска. Для больших блоков это может ускорить поиск в сотни раз.
2.5.2 Формат
Блоки хеширования должны быть созданы с использованием make или to-hash. У них нет лексического формата.
2.5.3 Создание
Используйте make для инициализации хеш-блока:
hsh: make hash! 10 ; выделение места для 10 элементов
Функция to-hash (в-хеш) преобразует данные в тип данных hash!.
Преобразовать блок:
blk: [1 "one" 2 "two" 3 "three" 4 "four"]
probe hash: to-hash blk
make hash! [1 "one" 2 "two" 3 "three" 4 "four"]
print select hash 2
two
Преобразуйте различные значения:
probe to-hash luke@rebol.com
probe to-hash 123.5
probe to-hash {123 10:30 "string" luke@rebol.com}
2.5.4 Связанные
Использовать hash? чтобы проверить тип данных.
hsh: to-hash [1 "one" 2 "two" 3 "three" 4 "four"]
probe hash? Hsh
true
Поскольку хеши - это подмножество псевдотипа series!, использовать series? чтобы проверить это:
probe series? hsh
true
При формировании хеш-значения создается строка из содержимого, содержащегося в хеш-значении:
probe form hsh
"1 one 2 two 3 three 4 four"
Формирование хеш-значения создает строку самого хеш-значения и его содержимого, что позволяет перезагрузить его как хеш-значение REBOL:
probe mold hsh
make hash! [1 "one" 2 "two" 3 "three" 4 "four"]
2.6 Изображение
2.6.1 Концепция
Тип данных image! (изображение!)- это серия, содержащая изображения RGB. Этот тип данных используется с REBOL/View.
Поддерживаемые форматы изображений: GIF, JPEG и BMP. Загруженным изображением можно управлять как серией.
2.6.2 Формат
Изображения обычно загружаются из файла. Однако они также могут быть выражены в исходном коде путем создания изображения. Предоставленный блок включает размер изображения и его данные RGB.
image: make image! [192x144 #{
B34533B44634B44634B54735B7473
84836B84836B84836BA4837BA4837
BC4837BC4837BC4837BC4837BC483 ...
}
2.6.3 Создание
Пустые изображения могут быть созданы с помощью make или to-image::
empty-img: make image! 300x300
empty-img: to-image 150x300
Размер изображения указан.
Изображения также могут быть сделаны из снимков лица. Это также делается с помощью make или to-image::
face-shot: make image! face
face-shot: to-image face
Используйте load для загрузки файла изображения. Если формат изображения не поддерживается, загрузить его не удастся.
Загрузка изображения:
img: load %bay.jpg
2.6.4 Связанные
Использовать image? чтобы определить, является ли значение типом данных image!:
probe image? img
Изображения - это часть псевдотипа series!:
probe series? img
Используйте уточнение /size, чтобы вернуть размер изображения в пикселях в виде парного значения::
probe img/size
Значения пикселей изображения получаются с помощью pick и изменяются с помощью poke. Значение, возвращаемое командой pick, является значением кортежа RGB. Значение, замененное на poke, также должно быть значением кортежа.
Выбор конкретных пикселей:
probe pick img 1
probe pick img 1500
Меняем конкретные пиксели:
poke img 1 255.255.255
probe pick img 1
poke img 1500 0.0.0
probe pick img 1500
2.7 Номер
2.7.1 Концепция
Issue! представляет собой последовательность символов, используемых для упорядочивания символов или идентификаторов таких вещей, как номера телефонов, номера моделей, серийные номера и номера кредитных карт.
Значения номера представляют собой подмножество серий, поэтому ими можно управлять как сериями:
probe copy/part find #888-555-1212 "555" 3
#555
2.7.2 Формат
Номер начинаются с цифрового знака (#) и продолжаются до тех пор, пока не будет достигнут первый ограничивающий символ (например, пробел).
#707-467-8000
#A-0987654321-CD-09876
#1234-5678-4321-8765
#MG82/32-7
Значения, содержащие символы-разделители, следует записывать в виде строк, а не вопросов.
2.7.3 Создание
Функция to-issue преобразует данные в тип данных issue!:
probe to-issue "1234-56-7890"
#1234-56-7890
2.7.4 Связанные
Использовате issue? чтобы определить, является ли значение типом данных issue!.
probe issue? #1234-56-7890
true
Поскольку номер являются подмножеством псевдотипа сериала, используйте series? чтобы проверить это:
probe series? #1234-56-7890
true
Функция form возвращает проблему в виде строки без знака числа (#):
probe form #1234-56-7890
1234-56-7890
Функция mold возвращает проблему в виде строки, которую REBOL может прочитать как значение проблемы:
probe mold #1234-56-7890
#1234-56-7890
Фнкция print выводит вопрос на стандартный вывод после выполнения reform на нем:
print #1234-56-7890
1234-56-7890
2.8 Список
2.8.1 Концепция
Списки представляют собой блоки связанных списков, которые позволяют быстрее и эффективнее вставлять и удалять их значения. Их можно использовать в случаях, когда выполняется большое количество операций вставки или удаления больших блоков.
2.8.2 Формат
Блоки списка должны быть созданы с помощью make или to-list. У них нет лексического формата.
Значения списков не являются прямой заменой блоков. Между блоками и списками есть несколько отличий:
- При вставке в список ссылка на него изменяется сразу после точки вставки.
- Удаление элемента, на который в настоящее время имеется ссылка в списке, приводит к сбросу ссылки в конец списка.
Следующие примеры показывают разницу в поведении между вставкой в список и в блок.
Инициализация блока и списка:
blk: [1 2 3]
lst: to-list [1 2 3]
Вставка в блок и список:
insert blk 0
insert lst 0
Смотрим на слово после блока и список после вставки. Обратите внимание, что blk указывает на голову, как и до вставки 0, но lst указывает сразу после точки вставки:
print blk
0 1 2 3
print lst
1 2 3
print head lst
0 1 2 3
Следующие примеры показывают разницу в поведении между удалением элемента из списка и блока.
Инициализация блока и списка:
blk: [1 2 3]
lst: to-list [1 2 3]
Удаление из блока и списка:
remove blk
remove lst
Смотрим на слово после удаления значения. Обратите внимание, что теперь lst указывает на конец серии:
print blk
2 3
print tail? lst
true
print head lst
2 3
Если вы не хотите, чтобы слово было в конце после удаления значения, сделайте шаг вперед и удалите значение за текущим индексом. Следующие примеры демонстрируют это.
Инициализация списка:
lst: to-list [1 2 3]
Шаг вперед и удаление значения за текущим индексом:
remove back (lst: next lst)
Глядя на слово после удаления значения:
probe lst
make list! [2 3]
2.8.3 Создание
Используйте make для инициализации значения списка:
lst: make list! 10 ; allocating space for 10 elements
Функция to-list преобразует данные в тип данных list!:
Преобразовать блок:
blk: [1 "one" 2 "two" 3 "three" 4 "four"]
probe to-list blk
2.8.4 Связанные
Используйте list? чтобы определить, является ли значение типом данных list!.
lst: to-list [1 "one" 2 "two" 3 "three" 4 "four"]
probe list? Lst
true
Поскольку списки - это подмножество типа данных series!, используйте series? чтобы проверить, является ли список серией:
probe series? lst
true
Использование form для значения списка создает строку из содержимого, содержащегося в списке:
probe form lst
"1 one 2 two 3 three 4 four"
Использование mold для значения списка создает строку самого значения списка и его содержимого, что позволяет перезагрузить его как значение списка REBOL:
probe mold lst
make list! [1 "one" 2 "two" 3 "three" 4 "four"]
2.9 Скобки
2.9.1 Концепция
Тип данных paren! - это блок, который немедленно оценивается. Он идентичен блоку во всех отношениях, за исключением того, что он оценивается, когда он встречается, и его результат возвращается.
При использовании в вычисляемом выражении paren! позволяет контролировать порядок оценки:
print 1 + (2 * 3)
7
print 1 + 2 * 3
9
Значение paren! можно получить доступ и изменить так же, как и любой блок. Однако когда речь идет о paren! необходимо соблюдать осторожность, чтобы предотвратить оценку if. Если вы храните парен в переменной, вам нужно будет использовать форму получения слова (:слово), чтобы предотвратить ее оценку.
Скобки - это тип серии, поэтому все, что можно сделать с серией, можно сделать с помощью парных значений.
paren: first [(1 + 2 * 3 / 4)]
print type? :paren
paren!
print length :paren
7
print first :paren
1
print last :paren
4
insert :paren [10 + 5 *]
probe :paren
(10 + 5 * 1 + 2 * 3 / 4)
print paren
12.75
2.9.2 Формат
Скобки обозначаются открывающими и закрывающими круглыми скобками. Они могут занимать несколько строк и содержать любые данные, включая другие скобки значения.
2.9.3 Создание
Функция make может быть использована для выделения PAREN значения:
paren: make paren! 10
insert :paren 10
insert :paren `+
insert :paren 20
print :paren
20 + 10
print paren
30
Функция to-paren преобразует данные в тип данных paren!:
probe to-paren "123 456"
(123 456)
probe to-paren [123 456]
(123 456)
2.9.4 Связанные
Используйте paren? чтобы проверить тип данных.
blk: [(3 + 3)]
probe pick blk 1
(3 + 3)
probe paren? pick blk 1
true
Поскольку скобки - это подмножество псевдотипа series!, использовать series? чтобы проверить это:
probe series? pick blk 1
true
Использование form в парном значении создает строку из содержимого, содержащегося в парном значении:
probe form pick blk 1
3 + 3
2.10 Путь
2.10.1 Концепция
Пути - это набор слов и значений, обозначенных косой чертой (/). Пути используются для навигации или поиска чего-либо. Слова и значения пути называются уточнениями, и они объединяются, чтобы обеспечить средства навигации по значению или функции.
Пути можно использовать для блоков, файлов, строк, списков, хэшей, функций и объектов. Как работает путь, зависит от используемого типа данных.
Пути можно использовать для выбора значений из блоков, выбора символов из строк, доступа к переменным в объектах, уточнения работы функции:
USA/CA/Ukiah/size (block selection)
names/12 (string position)
account/balance (object function)
match/any (function option)
Пример ниже показывает простоту использования пути для доступа к мини-базе данных, созданной из нескольких блоков:
towns: [
Hopland [
phone #555-1234
web http://www.hopland.ca.gov
]
Ukiah [
phone #555-4321
web http://www.ukiah.com
email info@ukiah.com
]
]
print towns/ukiah/web
http://www.ukiah.com
Резюме конструкций пути:
|
Действие
|
Типовые слова
|
Типовое испытание
|
Преобразование
|
|---|
|
path/word:
|
set-path!
|
set-path?
|
to-set-path
|
|
path/word
|
path!
|
path?
|
to-path
|
|
'path/word
|
lit-path!
|
lit-path?
|
to-lit-path
|
Примеры путей:
Оцените функцию объекта:
obj: make object! [
hello: func [] [print "hello! hello!"]
]
obj/hello
hello! hello!
Оцените слово объекта:
obj: make object! [
text: "do you believe in magic?"
]
probe obj/text
do you believe in magic?
Доработки функций:
hello: func [/again] [
print either again ["hello again!"]["hello"]
]
hello/again
hello again!
Выберите из блоков или нескольких блоков:
USA: [
CA [
Ukiah [
population 15050
elevation [610 feet]
]
Willits [
population 5073
elevation [1350 feet]
]
]
]
print USA/CA/Ukiah/population
15050
print form USA/CA/Willits/elevation
1350 feet
Выберите элементы из серий и встроенных серий по их числовому положению:
string-series: "abcdefg"
block-series: ["John" 21 "Jake" 32 "Jackson" 43 "Joe" 52]
block-with-sub-series: [ "abc" [4 5 6 [7 8 9]]]
probe string-series/4
#"d"
probe block-series/3
Jake
probe block-series/6
43
probe block-with-sub-series/1/2
#"b"
probe block-with-sub-series/2/2
5
probe block-with-sub-series/2/4/2
8
Слова, представленные как пути, являются символическими и поэтому не оцениваются. Это необходимо для обеспечения наиболее интуитивно понятной формы ссылок на объекты. Чтобы использовать ссылку на слово, требуется явная ссылка на значение слова:
city: 'Ukiah
probe USA/CA/:city
[
population 15050
elevation "610 feet"
]
Пути в блоках, хэшах или объектах оцениваются путем сопоставления слова на верхнем уровне пути и проверки слова как block!, hash! или object! значение. Затем ищется следующее слово в пути как слово, выраженное в блоке, хэше или объекте, и выполняется неявный выбор. Возвращается значение, следующее за совпавшим словом. Когда возвращаемое значение является блоком, хешем или объектом, путь может быть расширен:
Получение значения, связанного с CA в USA:
probe USA/CA
[
Ukiah [
population 15050
elevation "610 feet"
]
Willits [
population 9935
elevation "1350 feet"
]
]
Получение значения, связанного с Willits в USA/CA:
probe USA/CA/Willits
[
population 9935
elevation "1350 feet"
]
Получение значения, связанного с population в USA/CA/Willits:
probe USA/CA/Willits/population
9935
Когда слово используется в пути, которого нет в данной точке структуры, возникает ошибка:
probe USA/CA/Mendocino
** Script Error: Invalid path value: Mendocino.
** Where: probe USA/CA/Mendocino
Пути можно использовать для изменения значений в блоках и объектах:
USA/CA/Willits/elevation: "1 foot, after the earthquake"
probe USA/CA/Willits
[
population 9935
elevation "1 foot, after the earthquake"
]
obj/text: "yes, I do believe in magic."
probe obj
make object! [
text: "yes, I do believe in magic."
]
Блоки, хэши, функции и объекты могут быть смешаны в путях.
Выбор из элементов в блоке внутри объекта:
obj: make object! [
USA: [
CA [
population "too many"
]
]
]
probe obj/USA/CA/population
too many
Использование уточнений функций внутри объекта:
obj: make object! [
hello: func [/again] [
print either again [
"hello again"
] [
"oh, hello"
]
]
]
obj/hello/again
hello again
Пути - это тип серии, поэтому все, что можно сделать с серией, можно сделать с помощью значений пути:
root: [sub1 [sub2 [
word "a word at the end of the path"
num 55
] ] ]
path: 'root/sub1/sub2/word
probe :path
root/sub1/sub2/word
В предыдущем примере обозначение :path использовалось для получения самого path, а не его значения:
probe path
a word at the end of the path
Смотрим на длину пути:
probe length? :path
4
Поиск слова в пути:
probe find :path 'sub2
sub2/word
Изменение слова в пути:
change find :path 'word 'num
probe :path
root/sub1/sub2/num
probe path
55
2.10.2 Формат
Пути выражаются относительно корневого слова с помощью ряда уточнений, каждое из которых разделено косой чертой (/). Эти уточнения могут быть словами или значениями. Их конкретная интерпретация зависит от типа данных корневого значения.
Слова, представленные как уточнения в путях, являются символическими и не оцениваются. Это необходимо для обеспечения наиболее интуитивно понятной формы ссылок на объекты. Чтобы использовать ссылку на слово, требуется явная ссылка на значение слова:
root/:word
В этом примере используется значение переменной, а не её имя.
2.10.3 Создание
Вы можете создать пустой путь заданного размера с помощью make:
path: make path! 10
insert :path `test
insert tail :path `this
print :path
test/this
Функция to-path преобразует данные в тип данных path!:
probe to-path [root sub]
root/sub
probe to-path "root sub"
root/sub
Функция to-set-word преобразует другие значения в тип данных set-word.
probe to-set-path "root sub"
root/sub:
Функция to-lit-word преобразует другие значения в тип данных lit-word.
probe to-lit-path "root sub"
'root/sub
2.10.4 Связанные
Использовать path?, set-path?, и lit-path? для определения типа данных значения.
probe path? second [1 two "3"]
false
blk: [sub1 [sub2 [word 1]]]
blk2: [blk/sub1/sub2/word: 2]
if set-path? (pick blk2 1) [print "it is set"]
it is set
probe lit-path? first ['root/sub]
true
Поскольку пути - это подмножество псевдотипа series!, использовать series? чтобы проверить это:
probe series? pick [root/sub] 1
true
Использование form в значении пути создает строку из пути:
probe form pick [root/sub] 1
root/sub
Использование mold для значения пути создает строку самого значения пути, что позволяет перезагрузить ее как значение пути REBOL:
probe mold pick [root/sub] 1
root/sub
2.11 Строка
2.11.1 Концепция
Строки - это набор символов. Все операции, выполняемые над значениями серий, могут выполняться над строками.
2.11.2 Формат
Строковые значения записываются как последовательность символов, заключенных в двойные кавычки " " или фигурные скобки {}. Строки, заключенные в двойные кавычки, ограничиваются одной строкой и не должны содержать непечатаемых символов.
"This is a short string of characters."
Строки, заключенные в фигурные скобки, используются для больших разделов текста, занимающих несколько строк. Все символы строки, включая пробелы, табуляторы, кавычки и символы новой строки, являются частью строки.
{This is a long string of text that will
not easily fit on a single line of source.
These are often used for documentation
purposes.}
Фигурные скобки подсчитываются в строке, поэтому строка может включать другие фигурные скобки, если количество закрывающих фигурных скобок совпадает с количеством открывающих фигурных скобок.
{
This is another long string of text that would
never fit on a single line. This string also
includes braces { a few layers deep { and is
valid because there are as many closing braces }
as there are open braces } in the string.
}
Вы можете включать в строки специальные символы и операции, добавляя к ним знак вставки (^). К специальным символам относятся:
|
Сочитание
|
Определение
|
|---|
|
^"
|
Вставляет двойную кавычку (").
|
|
^}
|
Вставляет закрывающую скобку (}).
|
|
^^
|
Вставляет курсор (^).
|
|
^/
|
Начинает новую строку.
|
|
^(line)
|
Начинает новую строку.
|
|
^-
|
Вставляет табуляцию.
|
|
^(tab)
|
Вставляет табуляцию.
|
|
^(page)
|
Начинает новую страницу.
|
|
^(back)
|
Удаляет один символ слева от места вставки.
|
|
^(null)
|
Вставляет нулевой символ.
|
|
^(escape)
|
Вставляет escape-символ.
|
|
^(letter)
|
Вставляет указанную букву (A-Z).
|
|
^(xx)
|
Вставляет символ ASCII в виде шестнадцатеричного числа (xx). его формат допускает расширение в символы Юникода в будущем.
|
2.11.3 Создание
Используйте make, чтобы создать заранее выделенное пространство для пустой строки:
make string! 40'000 ; space for 40k characters
Функция to-string преобразует данные других типов в тип данных string!:
probe to-string 29-2-2000
"29-Feb-2000"
probe to-string 123456.789
"123456.789"
probe to-string #888-555-2341
"888-555-2341"
Преобразование блока данных в строку с to-string имеет эффект rejoin (повторное соединение), но без оценки содержимого блока:
probe to-string [123 456]
"123456"
probe to-string [225.225.225.0 none true 'word]
"225.225.225.0nonetrueword"
2.11.4 Связанные
Использовать string? или series? чтобы определить, является ли значение типом данных string!:
print string? "123"
true
print series? "123"
true
Функции form и mold тесно связаны со строками, поскольку они создают строки из других типов данных. Функция form создает удобочитаемую версию указанного типа данных, в то время как mold создает читаемую версию REBOL.
probe form "111 222 333"
"111 222 333"
probe mold "111 222 333"
{"111 222 333"}
2.12 Тег
2.12.1 Концепция
Теги используются в HTML и других языках разметки, чтобы указать, как следует обрабатывать текстовые поля. Например, тег <HTML> в начале файла указывает, что он должен быть проанализирован в соответствии с правилами языка гипертекстовой разметки. Тег с косой чертой (/), например </HTML>, указывает на закрытие тега.
Теги являются подмножеством серий, поэтому ими можно управлять как таковые:
a-tag: <img src="mypic.jpg">
probe a-tag
<img src="mypic.jpg">
append a-tag { alt="My Picture!"}
probe a-tag
<img src="mypic.jpg" alt="My Picture!">
2.12.2 Формат
Допустимые теги начинаются с открытой угловой скобки (<) и заканчиваются закрывающей скобкой (>). Например:
<a href="index.html">
<img src="mypic.jpg" width="150" height="200">
2.12.3 Создание
Функция to-tag преобразует данные в тип данных tag!:
probe to-tag "title"
<title>
Используйте build-tag для создания тегов, включая их атрибуты. Функция build-tag принимает один аргумент - блок. В этом блоке первое слово используется как имя тега, а остальные слова обрабатываются как пары значений атрибутов:
probe build-tag [a href http://www.rebol.com/]
<a href="http://www.rebol.com/">
probe build-tag [
img src %mypic.jpg width 150 alt "My Picture!"
]
<img src="mypic.jpg" width="150" alt="My Picture!">
2.12.4 Связанные
Использовать tag? чтобы определить, является ли значение типом данных tag!.
probe tag? <a href="http://www.rebol.com/">
true
Поскольку теги являются подмножеством псевдотипа серии, используйте series? чтобы проверить это:
probe series? <a href="http://www.rebol.com/">
true
Функция form возвращает тег в виде строки:
probe form <a href="http://www.rebol.com/">
{<a href="http://www.rebol.com/">}
Функция mold возвращает тег в виде строки:
probe mold <a href="http://www.rebol.com/">
{<a href="http://www.rebol.com/">}
Функция print печатает метки на стандартный вывод после выполнения reform на нем:
print <a href="http://www.rebol.com/">
<a href="http://www.rebol.com/">
2.13 URL
2.13.1 Концепция
URL - это аббревиатура от Uniform Resource Locator, интернет-стандарта, используемого для доступа к таким ресурсам, как веб-страницы, изображения, файлы и электронная почта по сети. Наиболее известная схема URL-адресов используется для таких веб-сайтов, как http://www.REBOL.com..
Значения URL-адресов являются подмножеством серий, поэтому ими можно управлять как сериями:
url: http://www.rebol.com/reboldoc.html
probe to-file find/reverse (tail url) "rebol"
%reboldoc.html
2.13.2 Формат
Первая часть URL-адреса указывает его протокол связи, называемый схемой. Язык поддерживает несколько схем, в том числе: веб - страниц (HTTP:), передача файлов (FTP:), группы новостей (NNTP:), электронная почта (MAILTO:), файлы (FILE:), finger (FINGER:), Whois (WHOIS:), сетевое время (DAYTIME:), почтовое отделение (POP:), управление передачей (TCP:) и служба доменных имен (DNS:). За этими именами схем следуют символы, зависящие от используемой схемы.
http://host.dom/path/file
ftp://host.dom/path/file
nntp://news.some-isp.net/some.news.group
mailto:name@domain
file://host/path/file
finger://user@host.dom
whois://rebol@rs.internic.net
daytime://everest.cclabs.missouri.edu
pop://user:passwd@host.dom/
tcp://host.dom:21
dns://host.dom
Некоторые поля необязательны. Например, за хостом может следовать номер порта, если он отличается от значения по умолчанию. URL-адрес FTP предоставляет пароль по умолчанию, если он не указан:
ftp://user:password@host.dom/path/file
Символы в URL-адресе должны соответствовать Интернет-стандартам. Запрещенные символы должны быть закодированы в шестнадцатеричном формате, перед ними должен стоять escape-символ %:
probe http://www.somesite.dom/odd%28dir%29/odd%7Bfile%7D.txt
http://www.somesite.dom/odd%28dir%29/odd%7Bfile%7D.txt
print http://www.somesite.dom/odd%28dir%29/odd%7Bfile%7D.txt
http://www.somesite.dom/odd(dir)/odd{file}.txt
2.13.3 Создание
Функция to-url преобразует блоки в тип данных url!, первый элемент в блоке - это схема, второй элемент - это домен (с указанием именем пользователя, порт или без), остальные элементы - это путь и файл:
probe to-url [http www.rebol.com reboldoc.html]
http://www.rebol.com/reboldoc.html
probe to-url [http www.rebol.com %examples "websend.r"]
http://www.rebol.com/examples/websend.r
probe to-url [http usr:pass@host.com:80 "(path)" %index.html]
http://usr:pass@host.com:80/%28path%29/index.html
2.13.4 Связанные
Слово типа данных - url!.
Использовать url? чтобы проверить тип данных..
probe url? ftp://ftp.rebol.com/
true
Поскольку URL-адреса являются подмножеством псевдотипа серии, используйте series? чтобы проверить это:
probe series? http://www.rebol.com/
true
3. Прочие типы
3.1 Символ
3.1.1 Концепция
Символы - это не строки; это отдельные значения, из которых строятся строки. Символ может быть печатным, непечатаемым или управляющим.
3.1.2 Формат
Char! значение записывается в виде знака числа (#), за которым следует строка, заключенная в двойные кавычки. Знак числа необходим, чтобы отличить символ от строки:
#"R" ; символ "R"
"R" ; строка с буквой "R"
Символы могут включать escape-последовательности, которые начинаются с символа вставки (^) и сопровождаются одним или несколькими символами кодировки. Эта кодировка может включать символы от #"^A" до #"^Z" для элемента control A для control #"^Z" (верхний и нижний регистры одинаковы) (...или сочетание славиш от Ctrl+A до Ctrl+Z) :
#"^A" #"^Z"
Кроме того, если внутри символа используются скобки, они указывают специальное значение. Например, null можно записать как:
"^@"
"^(null)"
"^(00)"
Последняя строка записывается в шестнадцатеричном формате (основание 16). Квадратные скобки вокруг значения позволяют в будущем расширить его до 16-битных символов Юникода.
Ниже приводится таблица управляющих символов, которые можно использовать в REBOL.
|
Запись
|
Определение
|
|---|
|
#"(null)" or #"@"
|
null (ноль)
|
|
#"(line)", #"/" or, #"."
|
конец линии
|
|
#"(tab)" or #"-"
|
горизонтальная табуляция
|
|
#"(page)"
|
новая страница (и извлечение страницы)
|
|
#"(esc)"
|
esc
|
|
#"(back)"
|
backspace
|
|
#"(del)"
|
delete
|
|
#"^"
|
символ каретки
|
|
#"^""
|
кавычка
|
|
#"(00)" to #"(FF)"
|
шестнадцатеричные формы символов
|
3.1.3 Создание
Символы могут быть преобразованы в другие типы данных и обратно с помощью функции to-char:
probe to-char "a"
#"a"
probe to-char "z"
#"z"
Символы соответствуют стандарту ASCII и могут быть созданы путем указания числового эквивалента символа:
probe to-char 65
#"A"
probe to-char 52
#"4"
probe to-char 52.3
#"4"
Другой способ получения символа - получить первый символ из строки:
probe first "ABC"
#"A"
Хотя символы в строках не чувствительны к регистру, сравнение между отдельными символами чувствительно к регистру:
probe "a" = "A"
true
probe #"a" = #"A"
false
Однако при использовании во многих типах функций сравнение не чувствительно к регистру, если вы не укажете этот параметр. Примеры:
select [#"A" 1] #"a"
1
select/case [#"A" 1] #"a"
none
find "abcde" #"B"
"bcde"
find/case "abcde" #"B"
none
switch #"A" [#"a" [print true]]
true
3.1.4 Связанные
Используйте char? чтобы определить, является ли значение типом данных char!.
probe char? "a"
false
probe char? #"a"
true
Используйте функцию form для печати символа без знака числа:
probe form #"A"
"A"
Используйте команду mold on, чтобы напечатать символ со знаком числа и двойными кавычками (и escape-последовательностями для тех символов, которые этого требуют):
probe mold #"A"
{#"A"}
3.2 Дата
3.2.1 Концепция
Во всем мире даты записываются в самых разных форматах. Однако в большинстве стран используется формат "день-месяц-год". Одно из немногих исключений - США, где обычно используется формат месяц-день-год. Например, дата, записанная в цифровом формате как 01.02.1999, неоднозначна. Месяц можно интерпретировать как февраль или январь. В некоторых странах используется тире (-), в некоторых - косая черта (/), а в других в качестве разделителя используется точка (.). Наконец, компьютерщики часто предпочитают даты в формате «год-месяц-день» (ISO), чтобы их можно было легко отсортировать.
3.2.2 Формат
Язык REBOL гибкий, позволяющий типы данных date! быть выраженой в различных форматах. Например, первый день марта может быть выражен в любом из следующих форматов:
probe 1/3/1999
1-Mar-1999
probe 1+++1999
1-Mar-1999
probe 1999+++1 ;ISO format
1-Mar-1999
Год может охватывать от 9999 до 1. Високосные дни (29 февраля) могут быть записаны только для високосных лет:
probe 29-2-2000
29-Feb-2000
Поля дат можно разделять косой чертой (/) или тире (-). Даты могут быть записаны в формате год-месяц-день или день-месяц-год:
probe 1999-10-5
5-Oct-1999
probe 1999/10/5
5-Oct-1999
probe 5-10-1999
5-Oct-1999
probe 5/10/1999
5-Oct-1999
Поскольку международные форматы даты, которые широко не используются в США, также можно использовать название месяца или аббревиатуру месяца:
probe 5/Oct/1999
5-Oct-1999
probe 5-October-1999
5-Oct-1999
probe 1999/oct/5
5-Oct-1999
Когда год является последним полем, его можно записать как четырехзначное или двузначное число:
probe 5/oct/99
5-Oct-1999
probe 5/oct/1999
5-Oct-1999
Однако желательно указывать год полностью. В противном случае возникнут проблемы с операциями сравнения дат и сортировки. В то время как две цифры могут использоваться для обозначения года, интерпретация двухзначного года относится к текущему году и действительна только в течение 50 лет в будущем или в прошлом:
probe 28-2-66 ; refers to 1966
28-Feb-1966
probe 12-Mar-20 ; refers to 2020
12-Mar-2020
probe 11+++45 ; refers to 2045, not 1945
11-Mar-2045
Рекомендуется использовать год из четырех цифр, чтобы избежать потенциальных проблем.
Чтобы представить даты в первом веке (что делается редко, потому что григорианского календаря не существовало), используйте ведущие нули для обозначения века (как в 9-4-0029).
Даты также могут включать необязательное поле времени и необязательный часовой пояс. Время отделяется от даты косой чертой (/). Часовой пояс добавляется с помощью плюса (+) или минуса (-), пробелы не допускаются. Часовые пояса записываются как сдвиг во времени (плюс или минус) от GMT. Разрешение часового пояса до получаса. Если временной сдвиг является целым числом, предполагается, что это часы:
probe 4/Apr/2000/6:00+8:00
4-Apr-2000/6:00+8:00
probe 1999-10-2/2:00-4:00
2-Oct-1999/2:00-4:00
probe 1/1/1990/12:20:25-6
1-Jan-1990/12:20:25
В дате не должно быть пробелов. Например:
10 - 5 - 99
будет интерпретироваться как выражение вычитания, а не как дата.
3.2.3 Доступ
Уточнения можно использовать со значением даты, чтобы получить любое из его определенных полей:
|
Уточнение
|
Описание
|
|---|
|
/day
|
Получает день.
|
|
/month
|
Получает месяц.
|
|
/year
|
Получает год.
|
|
/julian
|
Получает день года.
|
|
/weekday
|
Получает день недели (1-7 / пн-вс).
|
|
/time
|
Получает время (если есть).
|
|
/hour
|
Получает час времени (если есть)
|
|
/minute
|
Получает минуты времени (если есть).
|
|
/second
|
Получает секунды времени (если есть).
|
|
/zone
|
Получает часовой пояс (если есть).
|
Вот как работают эти уточнения:
some-date: 29-Feb-2000
probe some-date/day
29
probe some-date/month
2
probe some-date/year
2000
days: ["Mon" "Tue" "Wed" "Thu" "Fri" "Sat" "Sun"]
probe pick days some-date/weekday
Tue
Когда время присутствует, можно использовать уточнения, связанные со временем b>/hour, /minute и /second, используются с уточнением /time, что изолирует отрезок времени значения даты для их работы по:
lost-time: 29-Feb-2000/11:33:22.14-8:00
probe lost-time/time
11:33:22.14
probe lost-time/time/hour
11
probe lost-time/time/minute
33
probe lost-time/time/second
22.14
probe lost-time/zone
-8:00
3.2.4 Создание
Используйте функцию to-date для преобразования значений в date!: :
probe to-date "5-10-1999"
5-Oct-1999
probe to-date "5 10 1999 10:30"
5-Oct-1999/10:30
probe to-date [1999 10 5]
5-Oct-1999
probe to-date [5 10 1999 10:30 -8:00]
5-Oct-1999/10:30-8:00
[!Примечание! При преобразовании в date!, год должен быть указан в виде четырех цифр.
Преобразования можно применять к различным математическим операциям над датами:
probe 5-Oct-1999 + 1
6-Oct-1999
probe 5-10-1999 - 10
25-Sep-1999
probe 5-Oct-1999/23:00 + 5:00
6-Oct-1999/4:00
3.2.5 Связанные
Используйте date?чтобы определить является ли у значения тип данных date!.
probe date? 5/1/1999
true
Связанная функция to-idate возвращает стандартную строку даты в Интернете. Формат даты в Интернете - день, дата, месяц, год, время (в 24-часовом формате) и смещение часового пояса от GMT.
probe to-idate now
Fri, 30 Jun 2000 14:42:26 -0700
Now возвращает текущую дату и время в полном формате, включая смещение часового пояса:
probe now
30-Jun-2000/14:42:26-7:00
3.3 Логика
3.3.1 Концепция
Тип данных logic! состоит из двух состояний, представляющих true (истину) и false (ложь). Они часто возвращаются из таких сравнений, как:
age: 100
probe age = 100
true
time: 10:31:00
probe time < 10:30
false
str: "this is a string"
probe (length? str) > 10
true
Тип данных logic! чаще всего используется в качестве параметров условных функций, таких как if, while и until:
if age = 100 [print "Centennial human"]
Centennial human
while [time > 6:30] [
send person "Wake up!"
wait [0:10]
]
Дополнение к логическому значению получается из функции not :
there: place = "Ukiah"
if not there [...]
3.3.2 Формат
Обычно логические значения извлекаются из оценки выражений сравнения. Однако, слова могут быть установлены на логическое значение и используются для слова on и off:
print-me: false
print either print-me ["turned on"]["turned off"]
turned off
print-me: true
print either print-me ["turned on"]["turned off"]
turned on
Значение false не соответствует числу ноль или значению none. Однако в условных выражениях false и none имеют такой же эффект:
print-me: none
print either print-me ["turned on"]["turned off"]
turned off
Практически любое значение, присвоенное слову, имеет тот же эффект, что и true:
print-me: "just a string"
print either print-me ["turned on"]["turned off"]
turned on
print-me: 11-11-1999
print either print-me ["turned on"]["turned off"]
turned on
Следующие слова предопределены для хранения логических значений:
true
on ;чтото истенное
yes ;чтото истенное
false
off ;чтото ложное
no ;чтото ложное
Таким образом, вместо true и false , когда это имеет смысл, можно использовать слова on (вкл) и off (выкл) или yes (да) и no (нет):
print-me: yes
print either print-me ["turned on"]["turned off"]
turned on
print-me: no
print either print-me ["turned on"]["turned off"]
turned off
print-me: on
print either print-me ["turned on"]["turned off"]
turned on
print-me: off
print either print-me ["turned on"]["turned off"]
turned off
3.3.3 Создание
Функция to-logic преобразует integer! (целое число) или none! (нечего) значение к типу данных logic!:
probe to-logic 0
false
probe to-logic 200
true
probe to-logic none
false
probe to-logic []
true
probe to-logic "a"
true
probe to-logic none
false
3.3.4 Связанные
Используйте logic? чтобы определить, является ли значение типо данных logic!.
probe logic? 1
false
probe logic? on
true
probe logic? false
true
Используйте функции form, print и mold для вывода логического значения:
probe form true
true
probe mold false
false
print true
true
3.4 Деньги
3.4.1 Концепция
Существует множество международных символов для денежных купюр. Некоторые символы используются перед суммой, а некоторые - после. В качестве стандарта для представления международных денежных значений язык REBOL использует денежный формат США, но допускает включение определенных номиналов.
3.4.2 Формат
Тип данных money! использует стандартные числа с плавающей запятой IEEE, допускающие до 15 знаков точности, включая центы.
Язык ограничивает длину до 64 символов. Значения, которые находятся вне диапазона или не могут быть представлены 64 символами, помечаются как ошибка.
Денежные значения имеют префикс с необязательным обозначением валюты, за которым следует знак доллара ($). Знак «плюс» (+) или «минус» (-) может стоять непосредственно перед первым символом (обозначением валюты или знаком доллара) для обозначения знака.
$123
-$123
$123.45
US$12
US$12.34
-US$12.34
$12,34
-$12,34
DEM$12,34
Чтобы разбить длинные числа на читаемые сегменты, можно поставить одинарную кавычку (`) в любом месте между двумя цифрами в пределах суммы, но не перед суммой.
probe $1'234.56
$1234.56
probe $1'234'567,89
$1234567.89
Не используйте запятые и точки для разделения больших сумм, поскольку оба эти символа представляют собой десятичные точки.
Тип данных money! - это гибридный тип данных. Концептуально деньги скалярны - это сумма денег. Однако, поскольку обозначение валюты хранится в виде строки, тип данных money! состоит из двух элементов:
- string! - Строка обозначения валюты, которая может содержать максимум 3 символа.
- decimal! - Сумма денег.
Чтобы продемонстрировать это, следующие деньги указаны с префиксом USD:
my-money: USD$12345.67
Вот два компонента:
probe first my-money
USD
probe second my-money
12345.67
probe pick my-money 3 ; only two components
none
Если обозначение валюты не используется, строка обозначения валюты пуста:
my-money: $12345.67
probe first my-money
""
probe second my-money
12345.67
В обозначении валюты могут быть указаны различные международные валюты, например:
my-money: DKM$12'345,67
probe first my-money
DKM
probe second my-money
12345.67
3.4.3 Создание
Используйте функцию to-money, чтобы конвертировать деньги из string!, integer!, decimal! или зblock!.
probe to-money 123
$123.00
probe to-money "123"
$123.00
probe to-money 12.34
$12.34
probe to-money [DEM 12.34]
DEM$12.34
probe to-money [USA 12 34]
USA$12.34
Деньги можно складывать, вычитать и сравнивать с другими деньгами той же валюты. Ошибка возникает, если для таких операций используется другая валюта (автоматические преобразования в настоящее время не предусмотрены).
probe $100 + $10
$110.00
probe $100 - $50
$50.00
probe equal? DEM$100.11 DEM$100.11
true
MДеньги можно умножать и делить на целые и десятичные дроби. Деньги также можно разделить на деньги, получив целое или десятичное число.
probe $100 + 11
$111.00
probe $100 / 4
$25.00
probe $100 * 5
$500.00
probe $100 - 20.50
$79.50
probe 10 + $1.20
$11.20
probe 10 - $0.25
$9.75
probe $10 / .50
$20.00
probe 10 * $0.75
$7.50
3.4.4 Связанные
Используйте money? чтобы определить, является ли тип данных money!.
probe money? USD$12.34
true
Используйте функции form, print и mold с аргументом типа money! для печати денежного значения с обозначением валюты и знаком доллара ($) в виде десятичного числа с двумя цифрами десятичной точности.
probe form USD$12.34
USD$12.34
probe mold USD$12.34
USD$12.34
print USD$12.34
USD$12.34
3.5 None
3.5.1 Концепция
Тип данных none! содержит одно значение, которое ничего не содержит или не представляет.
Концепция none отличается от пустого блока, пустой строки или нулевого символа. Это реальная значение, олицетворяющее "нечего".
Значение none! может быть возвращено из различных функций, в первую очередь из тех, которые связаны с рядами (например, pick и find).
В REBOL слово none определяется как тип данных none! и содержит значение none!. Слово none не эквивалентно нулю или false. Однако none не интерпретируется многими функциями как false.
Значение none! имеет множество применений, таких как возвращаемое значение из функций ряда, таких как pick, find и select:
if (pick series 30) = none [...]
В базах данных none может быть заполнителем для пропущенных значений:
email-database: [
"Bobby" bob@rebol.com 40
"Linda" none 23
"Sara" sara@rebol.net 33
]
Его также можно использовать как логическое значение:
secure none
3.5.2 Формат
Слово none предопределено для хранения значения none.
Хотя none не эквивалентен нулю или false, он действителен в условных выражениях и имеет тот же эффект, что и false:
probe find "abcd" "e"
none
if find "abcd" "e" [print "found"]
3.5.3 Создание
Функция to-none всегда возвращает none.
3.5.4 Связанные
Иcпользуйте none? чтобы определить, является ли значение типом данных none!.
print none? 1
false
print none? find [1 2 3] 4
true
Функции form, print и mold выводят значение none при передаче аргумента none.
probe form none
none
probe mold none
none
print none
none
3.6 Пара
3.6.1 Концепция
Тип данных pair! используется для обозначения пространственных координат, например положения на дисплее. Они используются как для позиций, так и для размеров. Пары используются в основном в REBOL/View.
3.6.2 Формат
Пара указывается как целые числа, разделенные символом x.
100x50
1024x800
-50x200
3.6.3 Создание
Используйте to-pair для преобразования блочных или строковых значений в тип данных pair!:
p: to-pair "640x480"
probe p
640x480
p: to-pair [800 600]
probe p
800x600
3.6.4 Связанные
Используйте pair? чтобы определить, является ли значение типом данных pair!:
probe pair? 400x200
true
probe pair? pair
true
Пары можно использовать с большинством целочисленных математических операторов:
100x200 + 10x20
10x20 * 2x4
100x30 / 10x3
100x100 * 3
10x10 + 3
Пары можно просмотреть по их индивидуальным координатам:
pair: 640x480
probe first pair
640
probe second pair
480
Все значения пар поддерживают уточнения /x и /y. Эти уточнения позволяют просматривать и изменять координаты отдельных пар.
Просмотр индивидуальных координат:
probe pair/x
640
probe pair/y
480
Изменение индивидуальных координат:
pair/x: 800
pair/y: 600
probe pair
800x600
3.7 Уточнение
3.7.1 Концепция
Уточнения - это модификаторы, похожие на прилагательные, используемые в естественных (человеческих) языках. Уточнение указывает на вариант использования или расширение значения функции, объекта, имени файла, URL-адреса или пути. Уточнения всегда имеют символическое значение.
Доработки используются для функций:
block: [1 2]
append/only block [3 4]
объектов:
print system/version
файлов:
dir: %docs/core
print read dir/file.txt
urls:
site: http://www.rebol.com
print read site/index.html
3.7.2 Формат
Уточнения состоят из косой черты, за которой следует допустимое слово REBOL (определение см. В разделе слов ниже). Примеры:
/only
/test1
/save-it
Уточнения обычно присоединяются к другим словам, например, в случае:
port: open/binary file
Но уточнения также могут быть написаны отдельно, как это делается при указании уточнений функции:
save-data: function [file data /limit /reload] ...
3.7.3 Создание
Уточнения можно создавать буквально в исходном коде:
/test
или может состоять из слова to-refinement:
probe to-refinement "test"
/test
3.7.4 Связанные
Чтобы проверить уточнение, используйте функцию refinement?:
probe refinement? /test
true
probe refinement? 'word
false
3.8 Время
3.8.1 Концепция
Язык REBOL поддерживает стандартное выражение времени в часах, минутах, секундах и подсекундах. Допускается как положительное, так и отрицательное время.
Тип данных time! использует относительное, а не абсолютное время. Например, 10:30 - это 10 часов 30 минут, а не 10:30 AM или PM (до_полудня или после_полудня).
3.8.2 Формат
Время выражается в виде набора целых чисел, разделенных двоеточием (:) .. Часы и минуты являются обязательными, но секунды - необязательными. Внутри каждого поля ведущие нули игнорируются:
10:30
0:00
18:59
23:59:50
8:6:20
8:6:2
Поля минут и секунд могут содержать значения больше 60. Значения больше 60 преобразуются автоматически. Например, 0:120:00 совпадает с 2:00.
probe 00:120:00
2:00
Подсекунды указываются с использованием десятичной дроби в поле секунд. В качестве десятичной точки используйте точку или запятую. Поля часов и минут становятся необязательными, если присутствует десятичная дробь. Подсекунды кодируются с точностью до наносекунды или одной миллиардной секунды:
probe 32:59:29.5
32:59:29.5
probe 1:10,25
0:01:10.25
probe 0:0.000000001
0:00:00.000000001
probe 0:325.2
0:05:25.2
После времени можно указывать AM или PM, но пробелы не допускаются. PM добавляет к времени 12 часов:
probe 10:20PM
22:20
probe 3:32:20AM
3:32:20
Время выводится в стандартном формате часов, минут, секунд и подсекунд, независимо от того, как они введены:
probe 0:87363.21
24:16:03.21
3.8.3 Доступ
Значения времени имеют три уточнения, которые можно использовать для возврата конкретной информации о значении:
|
Уточнение
|
Описание
|
|---|
|
/hour
|
Получает значение часа.
|
|
/minute
|
Получает значение минуты.
|
|
/second
|
Получает значение секунды.
|
Вот как использовать уточнения значения времени:
lapsed-time: 91:32:12.14
probe lapsed-time/hour
91
probe lapsed-time/minute
32
probe lapsed-time/second
12.14
Время с часовыми поясами можно использовать только с дdate!.
3.8.4 Создание
Время можно преобразовать с помощью функции to-time:
probe to-time "10:30"
10:30
probe to-time [10 30]
10:30
probe to-time [0 10 30]
0:10:30
probe to-time [10 30 20.5]
10:30:20.5
В предыдущих примерах значения не оцениваются. Чтобы оценить значения как математические выражения, используйте функцию уменьшения:
probe to-time reduce [10 30 + 5]
10:35
В различных математических операциях, связанных со значениями времени, значения времени, целые или десятичные числа преобразуются, как показано ниже:
probe 10:30 + 1
10:30:01
probe 10:00 - 10
9:59:50
probe 0:00 - 10
-0:00:10
probe 5:10 * 3
15:30
probe 0:0:0.000000001 * 1'500'600
0:00:00.0015006
probe 8:40:20 / 4
2:10:05
probe 8:40:20 / 2:20:05
3
probe 8:40:20 // 4:20
0:00:20
3.8.5 Связанные
Используете time? чтобы определить, является ли значение типом данных time!:
probe time? 10:30
true
probe time? 10.30
false
Используйте функцию now с уточнением /time, чтобы вернуть текущую местную дату и время:
print now/time
14:42:15
Используйте функцию wait, чтобы дождаться продолжительности, порта или того и другого.
Если значение - это тип данных time!, wait (ждать) делает задержку в течение этого периода времени. Если значением является date!/time!, wait ожидает, пока не истечет указанная дата и время. Если значение integer! (целое!) или decimal! (десятичный!), функция ждет указанное количество секунд. Если значением является port (порт), функция будет ожидать события от этого порта. Если блок указан, он будет ждать, пока не произойдет какое-либо время или порты. Он возвращает порт, который вызвал завершение ожидания, или возвращает none, если истекло время ожидания. Например,
probe now/time
14:42:16
wait 0:00:10
probe now/time
14:42:26
3.9 Кортеж
3.9.1 Концепция
Обычно номера версий, адреса в Интернете и значения цветов RGB представляют как последовательность из трех или четырех целых чисел. Эти типы чисел называются tuple!(кортежами!) и представлены как набор целых чисел, разделенных точками.
1.3.0 2.1.120 1.0.2.32 ; версия
199.4.80.250 255.255.255.0 ; сетевой адрес и маска
0.80.255 200.200.60 ; RGB цвета
3.9.2 Формат
Каждое целочисленное поле типа данных tuple! может находиться в диапазоне от 0 до 255. Отрицательные целые числа вызывают ошибку.
В кортеже можно указать от трех до десяти целых чисел. В случае, когда задано только два целых числа, должно быть не менее двух точек, в противном случае значение рассматривается как десятичное.
probe 1.2 ; is decimal
1.2
probe type? 1.2
decimal!
probe 1.2.3 ; is tuple
1.2.3
probe 1.2. ; is tuple
1.2.0
probe type? 1.2.
tuple!
3.9.3 Создание
Используйте функцию to-tuple для преобразования данных в тип данных tuple!:
probe to-tuple "12.34.56"
12.34.56
probe to-tuple [12 34 56]
12.34.56
3.9.4 Связанные
Используйте tuple? чтобы определить, является ли значение типом данных tuple!.
probe tuple? 1.2.3.4
true
Используйте функцию form для печати кортежа в виде строки:
probe form 1.2.3.4
1.2.3.4
Используйте функцию mold, чтобы преобразовать кортеж в строку, которую можно будет прочитать обратно в REBOL как кортеж:
probe mold 1.2.3.4
1.2.3.4
Используйте функцию print, чтобы распечатать кортеж на стандартный вывод после использования функции reform:
print 1.2.3.4
1.2.3.4
3.10 Слова
3.10.1 Концепция
Слова - это символы, используемые REBOL. Слово может быть или не быть переменной, в зависимости от того, как оно используется. Слова часто используются непосредственно как символы.
REBOL не имеет ключевых слов, нет ограничений на то, какие слова используются или как они используются. Например, вы можете определить свою собственную функцию с именем print и использовать ее вместо предопределенной функции для печати значений.
В зависимости от требуемой операции существует четыре различных формата использования слов.
|
Действие
|
Создание
|
Проверка
|
ПРеобразование
|
|---|
|
word:
|
set-word!
|
set-word?
|
to-set-word
|
|
:word
|
get-word!
|
get-word?
|
to-get-word
|
|
word
|
word!
|
word?
|
to-word
|
|
'word
|
lit-word!
|
lit-word?
|
to-lit-word
|
3.10.2 Формат
Слова состоят из букв, цифр и любых из следующих символов:
? ! . ' + - * & | = _ ~
Слово не может начинаться с числа, а также существуют некоторые ограничения на слова, которые можно интерпретировать как числа. Например, -1 и +1 - это числа, а не слова.
Конец слова отмечается пробелом, новой строкой или одним из следующих символов:
[ ] ( ) { } " : ; /
Таким образом, квадратные скобки блока не являются частью слова:
[test]
В словах нельзя использовать следующие символы:
@ # $ % ^ ,
Слова могут быть любой длины, но не могут выходить за пределы конца строки.
this-is-a-very-long-word-used-as-an-example
Примеры слов:
Copy print test
number? time? date!
image-files l'image
++ -- == +-
***** *new-line*
left&right left|right
В языке REBOL регистр не учитывается. Слова следующие за словами:
blue
Blue
BLUE
все относятся к одному и тому же слову. Регистр слова сохраняется при печати.
Слова можно использовать повторно. Значение слова зависит от его контекста, поэтому слова можно повторно использовать в разных контекстах. Вы можете повторно использовать любое слово, даже заранее определенные слова REBOL. Например, слово REBOL if может использоваться в вашем коде иначе, чем оно используется интерпретатором REBOL.
3.10.3 Создание
Функция to-word преобразует значения в тип данных word!.
probe to-word "test"
test
Функция to-set-word преобразует значения в тип данныхset-word!.
probe make set-word! "test"
test:
Функция to-get-word преобразует значения в тип данных get-word!.
probe to-get-word "test"
:test
Функция to-lit-word преобразует значения в световое тип данных lit-word!.
probe to-lit-word "test"
'test
3.10.4 Связанные
Используйте word?, set-word?, get-word? и lit-word? чтобы проверить тип данных.
probe word? second [1 two "3"]
true
if set-word? first [word: 10] [print "it is set"]
it is set
probe get-word? second [pr: :print]
true
probe lit-word? first ['foo bar]
true
| 