manager 0.0.0 → 0.1.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/CHART.html +1270 -0
- data/MANUAL.html +1252 -0
- data/bin/manager +43 -0
- data/examples/array/CHART.html +1376 -0
- data/examples/array/MANUAL.html +1126 -0
- data/examples/array/spec +3438 -0
- data/lib/manager.rb +528 -0
- data/lib/manager/annotation +96 -0
- data/lib/manager/input +189 -0
- data/lib/manager/js +257 -0
- data/lib/manager/refine_module +142 -0
- data/lib/manager/refine_object_mapping +143 -0
- data/lib/manager/refine_test +97 -0
- data/lib/manager/render +1228 -0
- data/lib/manager/spell_check +49 -0
- data/lib/manager/test +404 -0
- data/lib/manager/test_helper +9 -0
- data/license +9 -0
- data/manager.gemspec +21 -0
- data/spec/alternatives_implemented.png +0 -0
- data/spec/alternatives_unimplemented.png +0 -0
- data/spec/annotations.png +0 -0
- data/spec/benchmark_test.png +0 -0
- data/spec/citation.png +0 -0
- data/spec/code_block.png +0 -0
- data/spec/context_module.png +0 -0
- data/spec/documentation +1289 -0
- data/spec/external_link.png +0 -0
- data/spec/image.png +0 -0
- data/spec/list.png +0 -0
- data/spec/long.png +0 -0
- data/spec/main_and_object.png +0 -0
- data/spec/markup.png +0 -0
- data/spec/module_diagram.png +0 -0
- data/spec/navigation.png +0 -0
- data/spec/nested_section_headers.png +0 -0
- data/spec/ruby.png +0 -0
- data/spec/setup_teardown.png +0 -0
- data/spec/short.png +0 -0
- data/spec/signature.png +0 -0
- data/spec/spec +76 -0
- data/spec/spec_example.png +0 -0
- data/spec/table.png +0 -0
- data/spec/test_header.png +0 -0
- data/spec/test_non_unit_spec +184 -0
- data/spec/test_program +71 -0
- data/spec/test_unit_spec +790 -0
- data/spec/tutorial_1.png +0 -0
- data/spec/tutorial_2.png +0 -0
- data/spec/tutorial_3.png +0 -0
- data/spec/tutorial_4.png +0 -0
- data/spec/tutorial_5.png +0 -0
- data/spec/tutorial_6.png +0 -0
- data/spec/tutorial_7.png +0 -0
- data/spec/tutorial_8.png +0 -0
- data/spec/unambiguous_links.png +0 -0
- data/spec/unit_test_failure.png +0 -0
- data/spec/unit_test_raise.png +0 -0
- data/spec/unit_test_receiver.png +0 -0
- data/spec/unit_test_succeed.png +0 -0
- data/spec/unit_test_success.png +0 -0
- data/spec/unit_test_throw.png +0 -0
- data/spec/valid_heading.png +0 -0
- data/spec/with_expr.png +0 -0
- data/spec/without_expr.png +0 -0
- data/theme/2016a.css +670 -0
- data/theme/coderay_github.css +132 -0
- metadata +140 -11
|
@@ -0,0 +1,1126 @@
|
|
|
1
|
+
<html><head><meta charset="UTF-8" /><style>/*Author:sawa.The default design */*{box-sizing:border-box;-webkit-user-select:text;-khtml-user-select:text;-moz-user-select:text;-ms-user-select:text;user-select:text;}body,table{font-family:sans-serif;font-size:12px;}body{margin:0;display:flex;flex-wrap:nowrap;align-items:stretch;flex-direction:row;height:100%;text-align:justify;text-rendering:optimizelegibility;color:hsl(100,0%,30%);background-color:hsl(0,0%,100%);word-break:normal;}#top,#top-title{display:flex;flex-wrap:wrap;align-items:center;justify-content:center;font-size:18px;}#top *{-webkit-touch-callout:none;-webkit-user-select:none;-khtml-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;}#top,#user #top-title{padding:2;background-color:hsl(0,0%,97%);color:hsl(0,0%,30%);}#dev #top-title{margin:1em;color:white;}#user #top-title,#dev #top{border-bottom:solid 6px hsl(211,85%,29%);}#top >span{margin-left:5;margin-right:5;display:inline-flex;flex-direction:row;flex-wrap:wrap;align-items:center;justify-content:center;white-space:pre;padding-top:4;padding-bottom:4;}.separator{font-size:18px;color:hsl(60,5%,72%);margin-left:0.5em;margin-right:0.5em;}#left{padding:0 20 24 40;flex-basis:480px;flex-shrink:0;display:flex;flex-wrap:nowrap;align-items:stretch;flex-direction:column;border-right:solid 1px hsl(60,5%,68%);background-color:#4F6B89;color:hsl(0,0%,100%);}#left .tablewrapper{max-height:32%;overflow-y:auto;border-top:solid 1px hsl(60,5%,85%);border-bottom:solid 1px hsl(60,5%,85%);}#left table{margin:0;width:100%;background-color:hsl(0,0%,100%);}#gemspec td:nth-child(1){white-space:nowrap;}#gemspec td:nth-child(2){word-break:break-all;}#files td:nth-child(3),#files td:nth-child(4){white-space:nowrap;}#files td:nth-child(4){text-align:right;}#right{display:flex;flex-wrap:nowrap;align-items:stretch;flex-direction:column;overflow:hidden;flex-grow:1;}#main{flex-basis:0;flex-grow:1;display:flex;flex-wrap:nowrap;align-items:stretch;flex-direction:column;overflow-y:auto;}#user #main{padding-top:12;padding-bottom:12;padding-right:240;padding-left:240;}#dev #main{padding-top:12;padding-bottom:12;padding-right:40;padding-left:20;}#main:before{position:fixed;margin-top:20px;margin-left:-20px;content:"\25B8";/*blacktriangleright */}#user #main:before{top:234;}#dev #main:before{top:300;}[onclick]:not([folded]){cursor:pointer;}[onclick][folded="true"]{cursor:s-resize;}[onclick][folded="false"]{cursor:n-resize;}table{border-collapse:collapse;margin-top:1em;margin-bottom:1em;}tr{border-color:hsl(60,27%,78%);border-style:solid;}#left tr:first-of-type{border-left-width:1px;border-right-width:1px;border-top-width:0;border-bottom-width:1px;}#left tr:last-of-type{border-left-width:1px;border-right-width:1px;border-top-width:1px;border-bottom-width:0;}#main tr,#left tr:not(:last-of-type):not(:first-of-type){border-left-width:1px;border-right-width:1px;border-top-width:1px;border-bottom-width:1px;}td{padding-left:3px;padding-right:3px;border-style:solid;border-color:hsl(60,27%,78%);border-width:1px;}figure{text-align:center;margin-left:0;margin-right:0;}figcaption{text-align:center;margin:2;}input{vertical-align:middle;}h1,h2,h3,h4{display:flex;flex-direction:row;align-items:center;white-space:pre-wrap;word-break:break-word;font-weight:normal;/*color:hsl(180,93%,6%);*/}h1{color:hsl(9,30%,15%);}h2{font-size:163%;margin-left:1em;margin-right:0.5em;color:hsl(9,30%,15%);}h3{font-size:140%;margin-left:1em;margin-right:0.5em;padding-left:1em;border-bottom:solid 1px hsl(0,0%,80%);color:hsl(9,30%,15%);}h4{font-size:120%;margin-left:1em;margin-right:0.5em;padding-left:2em;border-bottom:solid 1px hsl(0,0%,80%);font-style:oblique;color:hsl(9,30%,15%);}h5{font-size:110%;margin-left:1em;margin-right:0.5em;padding-left:3em;border-bottom:solid 1px hsl(0,0%,80%);color:hsl(9,30%,15%);}h6{font-size:100%;margin-left:1em;margin-right:0.5em;padding-left:4em;border-bottom:solid 1px hsl(0,0%,80%);color:hsl(9,30%,15%);}.module-header{/*Margin among `h2.module-header`does not collapse because of extra embedding level `.margin`.Hence margin needs to be set to half of other `h2`.*/margin-top:0.415em;margin-bottom:0.415em;}.feature:not(:first-child)[onclick]:hover{background-color:hsl(90,10%,97%);}.feature-name{font-size:110%;font-weight:bold;font-family:sans-serif;}[folded="true"]>h1,[folded="true"]>h2,[folded="true"]>h3,[folded="true"]>h4,[folded="true"]>h5,[folded="true"]>h6{box-shadow:inset 0px -21px 46px -26px hsla(0,0%,0%,0.2);}.feature-contents{padding-left:1em;}.head{font-weight:bold;font-family:sans-serif;font-size:15px;}.user-item,.dev-item{margin-top:1;margin-bottom:1;padding-left:0.5em;padding-right:0.5em;border-radius:5px;}#dev .user-item{background-color:hsl(180,20%,86%);padding-top:0.1px;padding-bottom:0.1px;}.diagram{text-align:left;margin:0.75em 2em;}.mixins{display:inline-block;margin:2 1;background-color:#c2ccd5;border:solid 1px #246a7d;color:#246a7d;padding:1 4;border-radius:2px;font-size:10.5px;}.mixins >div{width:100%;text-align:center;line-height:2.55ex;}.mixins >.baseline ~div{float:left;clear:both;}.p,li{font-family:serif;font-size:17px;}.p{margin-top:1em;margin-bottom:1em;}.CodeRay,table,figure{margin-top:1.33em;margin-bottom:1.33em;margin-left:2em;margin-right:2em;}.dev-text,table{font-family:sans-serif;font-size:13px;}.CodeRay{overflow-x:auto;}.CodeRay,code{font-size:12px;}.inline{padding:3px 4px;line-height:2.5ex;border-radius:0.4ex;white-space:pre-wrap;font-size:12px;background-color:hsl(50,35%,89%);color:hsl(0,0%,40%);word-break:break-all;}li{margin-top:5;margin-bottom:5;}.indent{padding-left:2.3em;}.hang-indent{margin-right:-2.3em;}.statistics{font-size:12px;}#current{color:black;font-weight:bold;}.navigation{display:inline-flex;flex-direction:row;align-items:center;}.mode.tag,.arrow.tag,.missing_doc.tag,.navigation .bad_doc.tag,.agenda.tag,.log.tag,.missing_test.tag,.bad_test.tag,.untestable.tag,.bug.tag,.success.tag,.benchmark.tag{display:inline-flex;flex-direction:row;align-items:center;justify-content:center;white-space:pre;height:18px;margin:2 0;padding-left:5.5;padding-right:5.5;font-family:sans-serif;font-size:10px;font-weight:500;border-radius:9px;}.unimplemented.tag,.protected.tag,.private.tag,.public.tag,.constant.tag,.singleton.tag,.instance.tag,.undocumented.tag,.hidden.tag,.misplaced.tag,.moved.tag{display:inline-flex;flex-direction:row;align-items:center;justify-content:center;white-space:pre;height:18px;margin:2 0;padding-left:5.5;padding-right:5.5;font-family:sans-serif;font-size:10px;font-weight:500;border-radius:2px;}.tag.mode,.tag.arrow{color:hsl(9,69%,16%);vertical-align:middle;line-height:100%;font-size:12px;}.constant{color:#DB7551;}.constant.tag{background-color:#DB7551;color:white;}.singleton{color:#68894F;}.singleton.tag{background-color:#68894F;color:white;}.instance{color:#4F6589;}.instance.tag{background-color:#4F6589;color:white;}.public{color:#090705;}.public.tag{background-color:#CCBBA7;border:solid 1px;}.private{color:#090705;}.private.tag{background-color:#9B7C59;border:solid 1px;}.protected{color:#D6AF86;}.protected.tag{background-color:#47160D;border:solid 1px;}.hidden,.moved{color:gray;}.hidden.tag,.moved.tag{background-color:white;color:#878787;border:solid 1px;}.agenda{color:#878787;}.agenda.tag{background-color:#878787;color:white;}.log{color:#878787;}.log.tag{background-color:white;color:#878787;border:solid 1px;}.undocumented,.misplaced,.missing_doc,.bad_doc,.missing_test,.bad_test{color:#F79833;}.navigation .bad_doc{font-weight:inherit;text-decoration:inherit;}.anchor .bad_doc{font-weight:bold;border-bottom:dotted 2px;}.undocumented.tag,.misplaced.tag,.missing_doc.tag,.navigation .bad_doc.tag,.missing_test.tag,.bad_test.tag{background-color:#F79833;color:white;}.untestable{color:hsl(54,43%,38%);}.untestable.tag{background-color:hsl(54,43%,38%);color:white;}.unimplemented,.bug{color:hsl(0,80%,50%);}.unimplemented.tag,.bug.tag{background-color:hsl(0,80%,50%);color:white;}.success{color:#00a15a;}.success.tag{background-color:#00a15a;color:white;}.backtrace col:nth-child(1){width:100%;}.backtrace td:nth-child(2)>code{white-space:nowrap;}.benchmark{color:hsl(263,43%,38%);}.benchmark.tag{background-color:hsl(263,43%,38%);color:white;}.barcharts{border-collapse:separate;border-spacing:3 0;}.barcharts col:nth-child(2){width:100%;}.barcharts td:nth-child(1)>code{float:right;font-size:73%;white-space:nowrap;}.barcharts td:nth-child(2){padding:3 0;background-color:hsl(250,7%,92%);}caption{margin:4;}.barchart{display:flex;flex-wrap:nowrap;align-items:stretch;flex-direction:row;height:21px;}.barchart .fill{padding:0 6;background-color:hsl(240,40%,50%);min-width:1;color:hsl(0,0%,63%);font-family:sans-serif;font-size:75%;text-align:right;white-space:nowrap;overflow:visible;line-height:21px;}.barchart .minedge{background-color:hsl(0,50%,50%);border-style:solid;border-left-width:0;border-right-width:0;border-top-width:5px;border-bottom-width:5px;border-color:hsl(240,40%,50%);width:1px;}.barchart .maxedge{background-color:hsl(0,50%,50%);border-style:solid;border-left-width:0;border-right-width:0;border-top-width:5px;border-bottom-width:5px;border-color:hsl(250,7%,92%);width:1px;}.barchart .min{background-color:hsl(0,50%,50%);border-style:solid;border-left-width:0;border-right-width:0;border-top-width:10px;border-bottom-width:10px;border-color:hsl(240,40%,50%);}.barchart .max{background-color:hsl(0,50%,50%);border-style:solid;border-left-width:0;border-right-width:0;border-top-width:10px;border-bottom-width:10px;border-color:hsl(250,7%,92%);}.verification{color:hsl(180,61%,50%);}.gray{color:darkgray;}.right{float:right;}.clear{clear:both;}/*Terminal decorations*/.italic{font-style:italic;}.bold{font-weight:bold;}.underline{text-decoration:underline;}.black{color:#000000;}.red{color:#c75646;}.green{color:#8eb33b;}.yellow{color:#d0b03c;}.blue{color:#72b3cc;}.magenta{color:#c8a0d1;}.cyan{color:#218693;}.white{color:#b0b0b0;}.bg-black{background-color:#5d5d5d;}.bg-red{background-color:#e09690;}.bg-green{background-color:#cdee69;}.bg-yellow{background-color:#ffe337;}.bg-blue{background-color:#9cd9f0;}.bg-magenta{background-color:#fbb1f9;}.bg-cyan{background-color:#77dfd8;}.bg-white{background-color:#f7f7f7;}</style><style>.CodeRay {background-color:#FFF;border:1px solid #CCC;font-family:Monaco,"Courier New","DejaVu Sans Mono","Bitstream Vera Sans Mono",monospace;color:#000;padding:1em 0px 1em 1em;}.CodeRay pre {margin:0px;}div.CodeRay {}span.CodeRay {white-space:pre;border:0px;padding:2px }table.CodeRay {border-collapse:collapse;width:100%;padding:2px }table.CodeRay td {padding:1em 0.5em;vertical-align:top;}.CodeRay .line-numbers,.CodeRay .no {background-color:#ECECEC;color:#AAA;text-align:right;}.CodeRay .line-numbers a {color:#AAA;}.CodeRay .line-numbers tt {font-weight:bold }.CodeRay .line-numbers .highlighted {color:red }.CodeRay .line {display:block;float:left;width:100%;}.CodeRay span.line-numbers {padding:0px 4px }.CodeRay .code {width:100%}ol.CodeRay {font-size:10pt }ol.CodeRay li {white-space:pre }.CodeRay .code pre {overflow:auto }.CodeRay .debug {color:white !important;background:blue !important;}.CodeRay .annotation {color:#007 }.CodeRay .attribute-name {color:#f08 }.CodeRay .attribute-value {color:#700 }.CodeRay .binary {color:#509;font-weight:bold }.CodeRay .comment {color:#998;font-style:italic;}.CodeRay .char {color:#04D }.CodeRay .char .content {color:#04D }.CodeRay .char .delimiter {color:#039 }.CodeRay .class {color:#458;font-weight:bold }.CodeRay .complex {color:#A08;font-weight:bold }.CodeRay .constant {color:teal;}.CodeRay .color {color:#0A0 }.CodeRay .class-variable {color:#369 }.CodeRay .decorator {color:#B0B;}.CodeRay .definition {color:#099;font-weight:bold }.CodeRay .directive {color:#088;font-weight:bold }.CodeRay .delimiter {color:black }.CodeRay .doc {color:#970 }.CodeRay .doctype {color:#34b }.CodeRay .doc-string {color:#D42;font-weight:bold }.CodeRay .escape {color:#666;font-weight:bold }.CodeRay .entity {color:#800;font-weight:bold }.CodeRay .error {color:#F00;background-color:#FAA }.CodeRay .exception {color:#C00;font-weight:bold }.CodeRay .filename {color:#099;}.CodeRay .function {color:#900;font-weight:bold }.CodeRay .global-variable {color:teal;font-weight:bold }.CodeRay .hex {color:#058;font-weight:bold }.CodeRay .integer {color:#099;}.CodeRay .include {color:#B44;font-weight:bold }.CodeRay .inline {color:black }.CodeRay .inline .inline {background:#ccc }.CodeRay .inline .inline .inline {background:#bbb }.CodeRay .inline .inline-delimiter {color:#D14;}.CodeRay .inline-delimiter {color:#D14;}.CodeRay .important {color:#f00;}.CodeRay .interpreted {color:#B2B;font-weight:bold }.CodeRay .instance-variable {color:teal }.CodeRay .label {color:#970;font-weight:bold }.CodeRay .local-variable {color:#963 }.CodeRay .octal {color:#40E;font-weight:bold }.CodeRay .operator {}.CodeRay .predefined-constant {font-weight:bold }.CodeRay .predefined {color:#369;font-weight:bold }.CodeRay .preprocessor {color:#579;}.CodeRay .pseudo-class {color:#00C;font-weight:bold }.CodeRay .predefined-type {color:#074;font-weight:bold }.CodeRay .reserved,.keyword {color:#000;font-weight:bold }.CodeRay .key {color:#808;}.CodeRay .key .delimiter {color:#606;}.CodeRay .key .char {color:#80f;}.CodeRay .value {color:#088;}.CodeRay .regexp {background-color:#fff0ff }.CodeRay .regexp .content {color:#808 }.CodeRay .regexp .delimiter {color:#404 }.CodeRay .regexp .modifier {color:#C2C }.CodeRay .regexp .function {color:#404;font-weight:bold }.CodeRay .string {color:#D20;}.CodeRay .string .string {}.CodeRay .string .string .string {background-color:#ffd0d0 }.CodeRay .string .content {color:#D14;}.CodeRay .string .char {color:#D14;}.CodeRay .string .delimiter {color:#D14;}.CodeRay .shell {color:#D14 }.CodeRay .shell .content {}.CodeRay .shell .delimiter {color:#D14 }.CodeRay .symbol {color:#990073 }.CodeRay .symbol .content {color:#A60 }.CodeRay .symbol .delimiter {color:#630 }.CodeRay .tag {color:#070 }.CodeRay .tag-special {color:#D70;font-weight:bold }.CodeRay .type {color:#339;font-weight:bold }.CodeRay .variable {color:#036 }.CodeRay .insert {background:#afa;}.CodeRay .delete {background:#faa;}.CodeRay .change {color:#aaf;background:#007;}.CodeRay .head {color:#f8f;background:#505 }.CodeRay .insert .insert {color:#080;font-weight:bold }.CodeRay .delete .delete {color:#800;font-weight:bold }.CodeRay .change .change {color:#66f;}.CodeRay .head .head {color:#f4f;}</style><title>Array User's Manual</title></head><body id="user"><div id="right"><div id="top"><span class="navigation"><span class="tag mode" onclick="displayMode(true, true)">Modules</span><span class="tag mode" onclick="displayMode(false, true)">Features</span><span class="tag mode" onclick="displayMode(false, false)">Full</span></span><span class="separator">│</span><span class="navigation"><span class="tag private" onclick="toggleFeatures(this, 'private', 'user-feature-navigation1')">private</span> <span class="private" id="tagsum-private">1</span> <span class="tag public" onclick="toggleFeatures(this, 'public', 'user-feature-navigation1')">public</span> <span class="public" id="tagsum-public">97</span> <span id="user-feature-navigation1" data-tags="unimplemented protected private public"><span class="tag arrow" onclick="navigateTag(this.parentNode, -1)">◂</span><span class="tag arrow" onclick="navigateTag(this.parentNode, 1)">▸</span> <span class="statistics"><span class="current">1</span>/<span class="sum"></span>+<span class="excluded"></span></span> </span></span> <span class="navigation"><span class="tag singleton" onclick="toggleFeatures(this, 'singleton', 'user-feature-navigation2')">Singleton method</span> <span class="singleton" id="tagsum-singleton">3</span> <span class="tag instance" onclick="toggleFeatures(this, 'instance', 'user-feature-navigation2')">Instance method</span> <span class="instance" id="tagsum-instance">93</span> <span id="user-feature-navigation2" data-tags="constant singleton instance"><span class="tag arrow" onclick="navigateTag(this.parentNode, -1)">◂</span><span class="tag arrow" onclick="navigateTag(this.parentNode, 1)">▸</span> <span class="statistics"><span class="current">1</span>/<span class="sum"></span>+<span class="excluded"></span></span> </span></span></div><div id="top-title">“Array” User's Manual</div><div id="main" onmouseover="this.focus()" onmouseout="this.blur()" tabindex="0"><div class="module"><div class="feature"><div></div><div class="feature-contents"><div class="user-item"><div class="p">Arrays are ordered, integer-indexed collections of any object.</div><div class="p"><code class="inline">Array</code> indexing starts at <code class="inline">0</code>, as in C or Java. A negative index is assumed to be relative to the end of the array---that is, an index of <code class="inline">-1</code> indicates the last element of the array, <code class="inline">-2</code> is the next to last element in the array, and so on.</div></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature2">1. Creating Arrays</h2><div class="feature-contents"><div class="user-item"><div class="p">A new array can be created by using the literal constructor <code class="inline">[]</code>. Arrays can contain different types of objects. For example, the array below contains an <code class="inline">Integer</code>, a <code class="inline">String</code> and a <code class="inline">Float</code>:</div><div class="CodeRay">
|
|
2
|
+
<div class="code"><pre>ary = [<span class="integer">1</span>, <span class="string"><span class="delimiter">"</span><span class="content">two</span><span class="delimiter">"</span></span>, <span class="float">3.0</span>] <span class="comment">#=> [1, "two", 3.0]</span>
|
|
3
|
+
</pre></div>
|
|
4
|
+
</div>
|
|
5
|
+
<div class="p">An array can also be created by explicitly calling <code class="inline">::new</code> with zero, one (the initial size of the <code class="inline">Array</code>), or two arguments (the initial size and a default object).</div><div class="CodeRay">
|
|
6
|
+
<div class="code"><pre>ary = <span class="constant">Array</span>.new <span class="comment">#=> []</span>
|
|
7
|
+
<span class="constant">Array</span>.new(<span class="integer">3</span>) <span class="comment">#=> [nil, nil, nil]</span>
|
|
8
|
+
<span class="constant">Array</span>.new(<span class="integer">3</span>, <span class="predefined-constant">true</span>) <span class="comment">#=> [true, true, true]</span>
|
|
9
|
+
</pre></div>
|
|
10
|
+
</div>
|
|
11
|
+
<div class="p">Note that the second argument populates the array with references to the same object. Therefore, it is only recommended in cases when you need to instantiate arrays with natively immutable objects such as symbols, numbers, <code class="inline">true</code>, or <code class="inline">false</code>.</div><div class="p">To create an array with separate objects, a block can be passed instead. This method is safe to use with mutable objects such as hashes, strings, or other arrays:</div><div class="CodeRay">
|
|
12
|
+
<div class="code"><pre><span class="constant">Array</span>.new(<span class="integer">4</span>){<span class="constant">Hash</span>.new} <span class="comment">#=> [{}, {}, {}, {}]</span>
|
|
13
|
+
</pre></div>
|
|
14
|
+
</div>
|
|
15
|
+
<div class="p">This is also a quick way to build up multi-dimensional arrays:</div><div class="CodeRay">
|
|
16
|
+
<div class="code"><pre>empty_table = <span class="constant">Array</span>.new(<span class="integer">3</span>){<span class="constant">Array</span>.new(<span class="integer">3</span>)}
|
|
17
|
+
<span class="comment">#=> [[nil, nil, nil], [nil, nil, nil], [nil, nil, nil]]</span>
|
|
18
|
+
</pre></div>
|
|
19
|
+
</div>
|
|
20
|
+
<div class="p">An array can also be created by using the <code class="inline">Array()</code> method, provided by <code class="inline">Kernel</code>, which tries to call <code class="inline">to_ary</code>, then <code class="inline">to_a</code> on its argument.</div><div class="CodeRay">
|
|
21
|
+
<div class="code"><pre>Array({<span class="symbol">:a</span> => <span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="symbol">:b</span> => <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>}) <span class="comment">#=> [[:a, "a"], [:b, "b"]]</span>
|
|
22
|
+
</pre></div>
|
|
23
|
+
</div>
|
|
24
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature3">2. Example Usage</h2><div class="feature-contents"><div class="user-item"><div class="p">In addition to the methods it mixes in through the <code class="inline">Enumerable</code> module, the <code class="inline">Array</code> class has proprietary methods for accessing, searching and otherwise manipulating arrays.</div><div class="p">Some of the more common ones are illustrated below.</div></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature4">3. Accessing Elements</h2><div class="feature-contents"><div class="user-item"><div class="p">Elements in an array can be retrieved using the <code class="inline">#[]</code> method. It can take a single integer argument (a numeric index), a pair of arguments (start and length), or a range. Negative indices start counting from the end, with <code class="inline">-1</code> being the last element.</div><div class="CodeRay">
|
|
25
|
+
<div class="code"><pre>arr = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">4</span>, <span class="integer">5</span>, <span class="integer">6</span>]
|
|
26
|
+
arr[<span class="integer">2</span>] <span class="comment">#=> 3</span>
|
|
27
|
+
arr[<span class="integer">100</span>] <span class="comment">#=> nil</span>
|
|
28
|
+
arr[<span class="integer">-3</span>] <span class="comment">#=> 4</span>
|
|
29
|
+
arr[<span class="integer">2</span>, <span class="integer">3</span>] <span class="comment">#=> [3, 4, 5]</span>
|
|
30
|
+
arr[<span class="integer">1</span>..<span class="integer">4</span>] <span class="comment">#=> [2, 3, 4, 5]</span>
|
|
31
|
+
arr[<span class="integer">1</span>..<span class="integer">-3</span>] <span class="comment">#=> [2, 3, 4]</span>
|
|
32
|
+
</pre></div>
|
|
33
|
+
</div>
|
|
34
|
+
<div class="p">Another way to access a particular array element is by using the at method</div><div class="CodeRay">
|
|
35
|
+
<div class="code"><pre>arr.at(<span class="integer">0</span>) <span class="comment">#=> 1</span>
|
|
36
|
+
</pre></div>
|
|
37
|
+
</div>
|
|
38
|
+
<div class="p">The slice method works in an identical manner to <code class="inline">#[]</code>.</div><div class="p">To raise an error for indices outside of the array bounds or else to provide a default value when that happens, you can use <code class="inline">fetch</code>.</div><div class="CodeRay">
|
|
39
|
+
<div class="code"><pre>arr = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">e</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">f</span><span class="delimiter">"</span></span>]
|
|
40
|
+
arr.fetch(<span class="integer">100</span>) <span class="comment">#=> IndexError: index 100 outside of array bounds: -6...6</span>
|
|
41
|
+
arr.fetch(<span class="integer">100</span>, <span class="string"><span class="delimiter">"</span><span class="content">oops</span><span class="delimiter">"</span></span>) <span class="comment">#=> "oops"</span>
|
|
42
|
+
</pre></div>
|
|
43
|
+
</div>
|
|
44
|
+
<div class="p">The special methods <code class="inline">first</code> and <code class="inline">last</code> will return the first and last elements of an array, respectively.</div><div class="CodeRay">
|
|
45
|
+
<div class="code"><pre>arr.first <span class="comment">#=> 1</span>
|
|
46
|
+
arr.last <span class="comment">#=> 6</span>
|
|
47
|
+
</pre></div>
|
|
48
|
+
</div>
|
|
49
|
+
<div class="p">To return the first n elements of an array, use take</div><div class="CodeRay">
|
|
50
|
+
<div class="code"><pre>arr.take(<span class="integer">3</span>) <span class="comment">#=> [1, 2, 3]</span>
|
|
51
|
+
</pre></div>
|
|
52
|
+
</div>
|
|
53
|
+
<div class="p"><code class="inline">drop</code> does the opposite of <code class="inline">take</code>, by returning the elements after n elements have been dropped:</div><div class="CodeRay">
|
|
54
|
+
<div class="code"><pre>arr.drop(<span class="integer">3</span>) <span class="comment">#=> [4, 5, 6]</span>
|
|
55
|
+
</pre></div>
|
|
56
|
+
</div>
|
|
57
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature5">4. Obtaining Information about an Array</h2><div class="feature-contents"><div class="user-item"><div class="p">Arrays keep track of their own length at all times. To query an array about the number of elements it contains, use <code class="inline">length</code>, <code class="inline">count</code>, or <code class="inline">size</code>.</div><div class="CodeRay">
|
|
58
|
+
<div class="code"><pre>browsers = [<span class="string"><span class="delimiter">"</span><span class="content">Chrome</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">Firefox</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">Safari</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">Opera</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">IE</span><span class="delimiter">"</span></span>]
|
|
59
|
+
browsers.length <span class="comment">#=> 5</span>
|
|
60
|
+
browsers.count <span class="comment">#=> 5</span>
|
|
61
|
+
</pre></div>
|
|
62
|
+
</div>
|
|
63
|
+
<div class="p">To check whether an array contains any elements at all</div><div class="CodeRay">
|
|
64
|
+
<div class="code"><pre>browsers.empty? <span class="comment">#=> false</span>
|
|
65
|
+
</pre></div>
|
|
66
|
+
</div>
|
|
67
|
+
<div class="p">To check whether a particular item is included in the array</div><div class="CodeRay">
|
|
68
|
+
<div class="code"><pre>browsers.include?(<span class="string"><span class="delimiter">"</span><span class="content">Konqueror</span><span class="delimiter">"</span></span>) <span class="comment">#=> false</span>
|
|
69
|
+
</pre></div>
|
|
70
|
+
</div>
|
|
71
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature6">5. Adding Items to Arrays</h2><div class="feature-contents"><div class="user-item"><div class="p">Items can be added to the end of an array by using either <code class="inline">push</code> or <code class="inline"><<</code></div><div class="CodeRay">
|
|
72
|
+
<div class="code"><pre>arr = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">4</span>]
|
|
73
|
+
arr.push(<span class="integer">5</span>) <span class="comment">#=> [1, 2, 3, 4, 5]</span>
|
|
74
|
+
arr << <span class="integer">6</span> <span class="comment">#=> [1, 2, 3, 4, 5, 6]</span>
|
|
75
|
+
</pre></div>
|
|
76
|
+
</div>
|
|
77
|
+
<div class="p"><code class="inline">unshift</code> will add a new item to the beginning of an array.</div><div class="CodeRay">
|
|
78
|
+
<div class="code"><pre>arr.unshift(<span class="integer">0</span>) <span class="comment">#=> [0, 1, 2, 3, 4, 5, 6]</span>
|
|
79
|
+
</pre></div>
|
|
80
|
+
</div>
|
|
81
|
+
<div class="p">With <code class="inline">insert</code>, you can add a new element to an array at any position.</div><div class="CodeRay">
|
|
82
|
+
<div class="code"><pre>arr.insert(<span class="integer">3</span>, <span class="string"><span class="delimiter">"</span><span class="content">apple</span><span class="delimiter">"</span></span>) <span class="comment">#=> [0, 1, 2, "apple", 3, 4, 5, 6]</span>
|
|
83
|
+
</pre></div>
|
|
84
|
+
</div>
|
|
85
|
+
<div class="p">Using the <code class="inline">insert</code> method, you can also insert multiple values at once:</div><div class="CodeRay">
|
|
86
|
+
<div class="code"><pre>arr.insert(<span class="integer">3</span>, <span class="string"><span class="delimiter">"</span><span class="content">orange</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">pear</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">grapefruit</span><span class="delimiter">"</span></span>)
|
|
87
|
+
<span class="comment">#=> [0, 1, 2, "orange", "pear", "grapefruit", "apple", 3, 4, 5, 6]</span>
|
|
88
|
+
</pre></div>
|
|
89
|
+
</div>
|
|
90
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature7">6. Removing Items from an Array</h2><div class="feature-contents"><div class="user-item"><div class="p">The method <code class="inline">pop</code> removes the last element in an array and returns it:</div><div class="CodeRay">
|
|
91
|
+
<div class="code"><pre>arr = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">4</span>, <span class="integer">5</span>, <span class="integer">6</span>]
|
|
92
|
+
arr.pop <span class="comment">#=> 6</span>
|
|
93
|
+
arr <span class="comment">#=> [1, 2, 3, 4, 5]</span>
|
|
94
|
+
</pre></div>
|
|
95
|
+
</div>
|
|
96
|
+
<div class="p">To retrieve and at the same time remove the first item, use <code class="inline">shift</code>:</div><div class="CodeRay">
|
|
97
|
+
<div class="code"><pre>arr.shift <span class="comment">#=> 1</span>
|
|
98
|
+
arr <span class="comment">#=> [2, 3, 4, 5]</span>
|
|
99
|
+
</pre></div>
|
|
100
|
+
</div>
|
|
101
|
+
<div class="p">To delete an element at a particular index:</div><div class="CodeRay">
|
|
102
|
+
<div class="code"><pre>arr.delete_at(<span class="integer">2</span>) <span class="comment">#=> 4</span>
|
|
103
|
+
arr <span class="comment">#=> [2, 3, 5]</span>
|
|
104
|
+
</pre></div>
|
|
105
|
+
</div>
|
|
106
|
+
<div class="p">To delete a particular element anywhere in an array, use <code class="inline">delete</code>:</div><div class="CodeRay">
|
|
107
|
+
<div class="code"><pre>arr = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">2</span>, <span class="integer">3</span>]
|
|
108
|
+
arr.delete(<span class="integer">2</span>) <span class="comment">#=> 2</span>
|
|
109
|
+
arr <span class="comment">#=> [1,3]</span>
|
|
110
|
+
</pre></div>
|
|
111
|
+
</div>
|
|
112
|
+
<div class="p">A useful method if you need to remove <code class="inline">nil</code> values from an array is <code class="inline">compact</code>:</div><div class="CodeRay">
|
|
113
|
+
<div class="code"><pre>arr = [<span class="string"><span class="delimiter">"</span><span class="content">foo</span><span class="delimiter">"</span></span>, <span class="integer">0</span>, <span class="predefined-constant">nil</span>, <span class="string"><span class="delimiter">"</span><span class="content">bar</span><span class="delimiter">"</span></span>, <span class="integer">7</span>, <span class="string"><span class="delimiter">"</span><span class="content">baz</span><span class="delimiter">"</span></span>, <span class="predefined-constant">nil</span>]
|
|
114
|
+
arr.compact <span class="comment">#=> ["foo", 0, "bar", 7, "baz"]</span>
|
|
115
|
+
arr <span class="comment">#=> ["foo", 0, nil, "bar", 7, "baz", nil]</span>
|
|
116
|
+
arr.compact! <span class="comment">#=> ["foo", 0, "bar", 7, "baz"]</span>
|
|
117
|
+
arr <span class="comment">#=> ["foo", 0, "bar", 7, "baz"]</span>
|
|
118
|
+
</pre></div>
|
|
119
|
+
</div>
|
|
120
|
+
<div class="p">Another common need is to remove duplicate elements from an array.</div><div class="p">It has the non-destructive <code class="inline">uniq</code>, and destructive method <code class="inline">uniq!</code></div><div class="CodeRay">
|
|
121
|
+
<div class="code"><pre>arr = [<span class="integer">2</span>, <span class="integer">5</span>, <span class="integer">6</span>, <span class="integer">556</span>, <span class="integer">6</span>, <span class="integer">6</span>, <span class="integer">8</span>, <span class="integer">9</span>, <span class="integer">0</span>, <span class="integer">123</span>, <span class="integer">556</span>]
|
|
122
|
+
arr.uniq <span class="comment">#=> [2, 5, 6, 556, 8, 9, 0, 123]</span>
|
|
123
|
+
</pre></div>
|
|
124
|
+
</div>
|
|
125
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature8">7. Iterating over Arrays</h2><div class="feature-contents"><div class="user-item"><div class="p">Like all classes that include the <code class="inline">Enumerable</code> module, <code class="inline">Array</code> has an each method, which defines what elements should be iterated over and how. In case of <code class="inline">Array</code>’s <code class="inline">each</code>, all elements in the <code class="inline">Array</code> instance are yielded to the supplied block in sequence.</div><div class="p">Note that this operation leaves the array unchanged.</div><div class="CodeRay">
|
|
126
|
+
<div class="code"><pre>arr = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">4</span>, <span class="integer">5</span>]
|
|
127
|
+
arr.each{|a| print a -= <span class="integer">10</span>, <span class="string"><span class="delimiter">"</span><span class="content"> </span><span class="delimiter">"</span></span>}
|
|
128
|
+
<span class="comment"># prints: -9 -8 -7 -6 -5</span>
|
|
129
|
+
<span class="comment">#=> [1, 2, 3, 4, 5]</span>
|
|
130
|
+
</pre></div>
|
|
131
|
+
</div>
|
|
132
|
+
<div class="p">Another sometimes useful iterator is <code class="inline">reverse_each</code> which will iterate over the elements in the array in reverse order.</div><div class="CodeRay">
|
|
133
|
+
<div class="code"><pre>words = <span class="string"><span class="delimiter">%w[</span><span class="content">first second third fourth fifth sixth</span><span class="delimiter">]</span></span>
|
|
134
|
+
str = <span class="string"><span class="delimiter">"</span><span class="delimiter">"</span></span>
|
|
135
|
+
words.reverse_each{|word| str += <span class="string"><span class="delimiter">"</span><span class="char">\#</span><span class="char">\{</span><span class="content">word</span><span class="char">\}</span><span class="content"> </span><span class="delimiter">"</span></span>}
|
|
136
|
+
p str <span class="comment">#=> "sixth fifth fourth third second first "</span>
|
|
137
|
+
</pre></div>
|
|
138
|
+
</div>
|
|
139
|
+
<div class="p">The <code class="inline">map</code> method can be used to create a new array based on the original array, but with the values modified by the supplied block:</div><div class="CodeRay">
|
|
140
|
+
<div class="code"><pre>arr.map{|a| <span class="integer">2</span>*a} <span class="comment">#=> [2, 4, 6, 8, 10]</span>
|
|
141
|
+
arr <span class="comment">#=> [1, 2, 3, 4, 5]</span>
|
|
142
|
+
arr.map!{|a| a**<span class="integer">2</span>} <span class="comment">#=> [1, 4, 9, 16, 25]</span>
|
|
143
|
+
arr <span class="comment">#=> [1, 4, 9, 16, 25]</span>
|
|
144
|
+
</pre></div>
|
|
145
|
+
</div>
|
|
146
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature9">8. Selecting Items from an Array</h2><div class="feature-contents"><div class="user-item"><div class="p">Elements can be selected from an array according to criteria defined in a block. The selection can happen in a destructive or a non-destructive manner. While the destructive operations will modify the array they were called on, the non-destructive methods usually return a new array with the selected elements, but leave the original array unchanged.</div></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h3 id="feature10">8.1. Non-destructive Selection</h3><div class="feature-contents"><div class="user-item"><div class="CodeRay">
|
|
147
|
+
<div class="code"><pre>arr = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">4</span>, <span class="integer">5</span>, <span class="integer">6</span>]
|
|
148
|
+
arr.select{|a| a > <span class="integer">3</span>} <span class="comment">#=> [4, 5, 6]</span>
|
|
149
|
+
arr.reject{|a| a < <span class="integer">3</span>} <span class="comment">#=> [3, 4, 5, 6]</span>
|
|
150
|
+
arr.drop_while{|a| a < <span class="integer">4</span>} <span class="comment">#=> [4, 5, 6]</span>
|
|
151
|
+
arr <span class="comment">#=> [1, 2, 3, 4, 5, 6]</span>
|
|
152
|
+
</pre></div>
|
|
153
|
+
</div>
|
|
154
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h3 id="feature11">8.2. Destructive Selection</h3><div class="feature-contents"><div class="user-item"><div class="p"><code class="inline">select!</code> and <code class="inline">reject!</code> are the corresponding destructive methods to <code class="inline">select</code> and <code class="inline">reject</code></div><div class="p">Similar to <code class="inline">select</code> vs. <code class="inline">reject</code>, <code class="inline">delete_if</code> and <code class="inline">keep_if</code> have the exact opposite result when supplied with the same block:</div><div class="CodeRay">
|
|
155
|
+
<div class="code"><pre>arr.delete_if{|a| a < <span class="integer">4</span>} <span class="comment">#=> [4, 5, 6]</span>
|
|
156
|
+
arr <span class="comment">#=> [4, 5, 6]</span>
|
|
157
|
+
arr = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">4</span>, <span class="integer">5</span>, <span class="integer">6</span>]
|
|
158
|
+
arr.keep_if{|a| a < <span class="integer">4</span>} <span class="comment">#=> [1, 2, 3]</span>
|
|
159
|
+
arr <span class="comment">#=> [1, 2, 3]</span>
|
|
160
|
+
</pre></div>
|
|
161
|
+
</div>
|
|
162
|
+
</div></div></div></div><div class="module"><div class="feature" onclick="toggleModuleContents(this)"><h1 class="module-header" id="feature12"><span class="anchor" id="public1"><span class="tag public">public</span></span> class <span class="feature-name">Array</span></h1><div class="feature-contents"></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature13"><span class="anchor" id="public2"><span class="tag public">public</span></span> <span class="anchor" id="singleton1"><span class="tag singleton">1</span></span> Array.<span class="feature-name">[]</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(*args)</code> → Array<div class="p">Returns a new array populated with the given objects.</div><div class="CodeRay">
|
|
163
|
+
<div class="code"><pre><span class="constant">Array</span>.[](<span class="integer">1</span>, <span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="regexp"><span class="delimiter">/</span><span class="content">^A</span><span class="delimiter">/</span></span>) <span class="comment"># => [1, "a", /^A/]</span>
|
|
164
|
+
<span class="constant">Array</span>[<span class="integer">1</span>, <span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="regexp"><span class="delimiter">/</span><span class="content">^A</span><span class="delimiter">/</span></span>] <span class="comment"># => [1, "a", /^A/]</span>
|
|
165
|
+
[<span class="integer">1</span>, <span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="regexp"><span class="delimiter">/</span><span class="content">^A</span><span class="delimiter">/</span></span>] <span class="comment"># => [1, "a", /^A/]</span>
|
|
166
|
+
</pre></div>
|
|
167
|
+
</div>
|
|
168
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature14"><span class="anchor" id="public3"><span class="tag public">public</span></span> <span class="anchor" id="singleton2"><span class="tag singleton">2</span></span> Array.<span class="feature-name">new</span></h2><div class="feature-contents"><div class="user-item"><div class="p">Returns a new array.</div><span class="head">Usage</span> <code class="inline">(size = 0, obj = nil)</code> → Array<div class="p">If no arguments are sent, the new array will be empty. When a <code class="inline">size</code> and an optional <code class="inline">obj</code> are sent, an array is created with <code class="inline">size</code> copies of <code class="inline">obj</code>. Take notice that all elements will reference the same object <code class="inline">obj</code>.</div><span class="head">Usage</span> <code class="inline">(array)</code> → Array<div class="p">Creates a copy of the array passed as a parameter (the array is generated by calling <code class="inline">#to_ary</code> on the parameter).</div><div class="CodeRay">
|
|
169
|
+
<div class="code"><pre>first_array = [<span class="string"><span class="delimiter">"</span><span class="content">Matz</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">Guido</span><span class="delimiter">"</span></span>]
|
|
170
|
+
second_array = <span class="constant">Array</span>.new(first_array) <span class="comment">#=> ["Matz", "Guido"]</span>
|
|
171
|
+
first_array.equal? second_array <span class="comment">#=> false</span>
|
|
172
|
+
</pre></div>
|
|
173
|
+
</div>
|
|
174
|
+
<span class="head">Usage</span> <code class="inline">(size){|index| block}</code> → Array<div class="p">An array of the given <code class="inline">size</code> is created. Each element in this array is created by passing the element’s index to the given block and storing the return value.</div><div class="CodeRay">
|
|
175
|
+
<div class="code"><pre><span class="constant">Array</span>.new(<span class="integer">3</span>){|index| index ** <span class="integer">2</span>}
|
|
176
|
+
<span class="comment"># => [0, 1, 4]</span>
|
|
177
|
+
</pre></div>
|
|
178
|
+
</div>
|
|
179
|
+
</div><div class="user-item"><div class="p">Common gotchas</div><div class="p">When sending the second parameter, the same object will be used as the value for all the array elements:</div><div class="CodeRay">
|
|
180
|
+
<div class="code"><pre>a = <span class="constant">Array</span>.new(<span class="integer">2</span>, <span class="constant">Hash</span>.new)
|
|
181
|
+
<span class="comment"># => [{}, {}]</span>
|
|
182
|
+
a[<span class="integer">0</span>][<span class="string"><span class="delimiter">"</span><span class="content">cat</span><span class="delimiter">"</span></span>] = <span class="string"><span class="delimiter">"</span><span class="content">feline</span><span class="delimiter">"</span></span>
|
|
183
|
+
a <span class="comment"># => [{"cat"=>"feline"}, {"cat"=>"feline"}]</span>
|
|
184
|
+
a[<span class="integer">1</span>][<span class="string"><span class="delimiter">"</span><span class="content">cat</span><span class="delimiter">"</span></span>] = <span class="string"><span class="delimiter">"</span><span class="content">Felix</span><span class="delimiter">"</span></span>
|
|
185
|
+
a <span class="comment"># => [{"cat"=>"Felix"}, {"cat"=>"Felix"}]</span>
|
|
186
|
+
</pre></div>
|
|
187
|
+
</div>
|
|
188
|
+
<div class="p">Since all the <code class="inline">Array</code> elements store the same hash, changes to one of them will affect them all.</div><div class="p">If multiple copies are what you want, you should use the block version which uses the result of that block each time an element of the array needs to be initialized:</div><div class="CodeRay">
|
|
189
|
+
<div class="code"><pre>a = <span class="constant">Array</span>.new(<span class="integer">2</span>){<span class="constant">Hash</span>.new}
|
|
190
|
+
a[<span class="integer">0</span>][<span class="string"><span class="delimiter">"</span><span class="content">cat</span><span class="delimiter">"</span></span>] = <span class="string"><span class="delimiter">"</span><span class="content">feline</span><span class="delimiter">"</span></span>
|
|
191
|
+
a <span class="comment"># => [{"cat"=>"feline"}, {}]</span>
|
|
192
|
+
</pre></div>
|
|
193
|
+
</div>
|
|
194
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature15"><span class="anchor" id="public4"><span class="tag public">public</span></span> <span class="anchor" id="singleton3"><span class="tag singleton">3</span></span> Array.<span class="feature-name">try_convert</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(obj)</code> → Array | <code class="inline">nil</code><div class="p">Tries to convert <code class="inline">obj</code> into an array, using <code class="inline">to_ary</code> method. Returns the converted array or <code class="inline">nil</code> if obj cannot be converted for any reason. This method can be used to check if an argument is an array.</div><div class="CodeRay">
|
|
195
|
+
<div class="code"><pre><span class="constant">Array</span>.try_convert([<span class="integer">1</span>]) <span class="comment">#=> [1]</span>
|
|
196
|
+
<span class="constant">Array</span>.try_convert(<span class="string"><span class="delimiter">"</span><span class="content">1</span><span class="delimiter">"</span></span>) <span class="comment">#=> nil</span>
|
|
197
|
+
<span class="keyword">if</span> tmp = <span class="constant">Array</span>.try_convert(arg)
|
|
198
|
+
<span class="comment"># the argument is an array</span>
|
|
199
|
+
<span class="keyword">elsif</span> tmp = <span class="constant">String</span>.try_convert(arg)
|
|
200
|
+
<span class="comment"># the argument is a string</span>
|
|
201
|
+
<span class="keyword">end</span>
|
|
202
|
+
</pre></div>
|
|
203
|
+
</div>
|
|
204
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature16"><span class="anchor" id="public5"><span class="tag public">public</span></span> <span class="anchor" id="instance1"><span class="tag instance">1</span></span> Array#<span class="feature-name">&</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">[#uniq]</code>.</div><span class="head">Usage</span> <code class="inline">(other_ary)</code> → Array<div class="p">Set Intersection — Returns a new array containing elements common to the two arrays, excluding any duplicates. The order is preserved from the original array.</div><div class="p">It compares elements using their <code class="inline">hash</code> and <code class="inline">eql?</code> methods for efficiency.</div><div class="CodeRay">
|
|
205
|
+
<div class="code"><pre>[<span class="integer">1</span>, <span class="integer">1</span>, <span class="integer">3</span>, <span class="integer">5</span>] & [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>] <span class="comment">#=> [1, 3]</span>
|
|
206
|
+
[<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">z</span><span class="delimiter">"</span></span>] & [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>] <span class="comment">#=> ["a", "b"]</span>
|
|
207
|
+
</pre></div>
|
|
208
|
+
</div>
|
|
209
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature17"><span class="anchor" id="public6"><span class="tag public">public</span></span> <span class="anchor" id="instance2"><span class="tag instance">2</span></span> Array#<span class="feature-name">*</span></h2><div class="feature-contents"><div class="user-item"><div class="p">Repetition</div><span class="head">Usage</span> <code class="inline">(str)</code> → String<div class="p">Equivalent to <code class="inline">self.join(str).</code></div><span class="head">Usage</span> <code class="inline">(int)</code> → Array<div class="p">Returns a new array built by concatenating the <code class="inline">int</code> copies of <code class="inline">self</code>.</div><div class="CodeRay">
|
|
210
|
+
<div class="code"><pre>[<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>] * <span class="integer">3</span> <span class="comment">#=> [1, 2, 3, 1, 2, 3, 1, 2, 3]</span>
|
|
211
|
+
[<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>] * <span class="string"><span class="delimiter">"</span><span class="content">,</span><span class="delimiter">"</span></span> <span class="comment">#=> "1,2,3"</span>
|
|
212
|
+
</pre></div>
|
|
213
|
+
</div>
|
|
214
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature18"><span class="anchor" id="public7"><span class="tag public">public</span></span> <span class="anchor" id="instance3"><span class="tag instance">3</span></span> Array#<span class="feature-name">+</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#concat</code>.</div><span class="head">Usage</span> <code class="inline">(other_ary)</code> → Array<div class="p">Concatenation — Returns a new array built by concatenating the two arrays together to produce a third array.</div><div class="CodeRay">
|
|
215
|
+
<div class="code"><pre>[<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>] + [<span class="integer">4</span>, <span class="integer">5</span>] <span class="comment">#=> [1, 2, 3, 4, 5]</span>
|
|
216
|
+
a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
217
|
+
c = a + [<span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">e</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">f</span><span class="delimiter">"</span></span>]
|
|
218
|
+
c <span class="comment">#=> ["a", "b", "c", "d", "e", "f"]</span>
|
|
219
|
+
a <span class="comment">#=> ["a", "b", "c"]</span>
|
|
220
|
+
</pre></div>
|
|
221
|
+
</div>
|
|
222
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature19"><span class="anchor" id="public8"><span class="tag public">public</span></span> <span class="anchor" id="instance4"><span class="tag instance">4</span></span> Array#<span class="feature-name">-</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(other_ary)</code> → Array<div class="p">Array Difference</div><div class="p">Returns a new array that is a copy of the original array, removing any items that also appear in <code class="inline">other_ary</code>. The order is preserved from the original array.</div><div class="p">It compares elements using their <code class="inline">hash</code> and <code class="inline">eql?</code> methods for efficiency.</div><div class="CodeRay">
|
|
223
|
+
<div class="code"><pre>[<span class="integer">1</span>, <span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">3</span>, <span class="integer">4</span>, <span class="integer">5</span>] - [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">4</span>] <span class="comment">#=> [3, 3, 5]</span>
|
|
224
|
+
</pre></div>
|
|
225
|
+
</div>
|
|
226
|
+
<div class="p">If you need set-like behavior, see the library class <code class="inline">Set</code>.</div></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature20"><span class="anchor" id="public9"><span class="tag public">public</span></span> <span class="anchor" id="instance5"><span class="tag instance">5</span></span> Array#<span class="feature-name"><<</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(obj)</code> → Array<div class="p">Append—Pushes the given object on to the end of this array. This expression returns the array itself, so several appends may be chained together.</div><div class="CodeRay">
|
|
227
|
+
<div class="code"><pre>[<span class="integer">1</span>, <span class="integer">2</span>] << <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span> << <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span> << [<span class="integer">3</span>, <span class="integer">4</span>]
|
|
228
|
+
<span class="comment">#=> [1, 2, "c", "d", [3, 4]]</span>
|
|
229
|
+
</pre></div>
|
|
230
|
+
</div>
|
|
231
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature21"><span class="anchor" id="public10"><span class="tag public">public</span></span> <span class="anchor" id="instance6"><span class="tag instance">6</span></span> Array#<span class="feature-name"><=></span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(other_ary)</code> → <code class="inline">-1</code> | <code class="inline">0</code> | <code class="inline">1</code> | <code class="inline">nil</code><div class="p">Comparison — Returns an integer (<code class="inline">-1</code>, <code class="inline">0</code>, or <code class="inline">+1</code>) if this array is less than, equal to, or greater than <code class="inline">other_ary</code>.</div><div class="p"><code class="inline">nil</code> is returned if the two values are incomparable.</div><div class="p">Each object in each array is compared (using the <code class="inline"><=></code> operator).</div><div class="p">Arrays are compared in an element-wise manner; the first two elements that are not equal will determine the return value for the whole comparison.</div><div class="p">If all the values are equal, then the return is based on a comparison of the array lengths. Thus, two arrays are equal according to <code class="inline">Array#<=></code> if, and only if, they have the same length and the value of each element is equal to the value of the corresponding element in the other array.</div><div class="CodeRay">
|
|
232
|
+
<div class="code"><pre>[<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>] <=> [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>] <span class="comment">#=> -1</span>
|
|
233
|
+
[<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">4</span>, <span class="integer">5</span>, <span class="integer">6</span>] <=> [<span class="integer">1</span>, <span class="integer">2</span>] <span class="comment">#=> +1</span>
|
|
234
|
+
</pre></div>
|
|
235
|
+
</div>
|
|
236
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature22"><span class="anchor" id="public11"><span class="tag public">public</span></span> <span class="anchor" id="instance7"><span class="tag instance">7</span></span> Array#<span class="feature-name">==</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(other_ary)</code> → <code class="inline">true</code> | <code class="inline">false</code><div class="p">Equality — Two arrays are equal if they contain the same number of elements and if each element is equal to (according to <code class="inline">Object#==</code>) the corresponding element in <code class="inline">other_ary</code>.</div><div class="CodeRay">
|
|
237
|
+
<div class="code"><pre>[<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>] == [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="integer">7</span>] <span class="comment">#=> false</span>
|
|
238
|
+
[<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="integer">7</span>] == [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="integer">7</span>] <span class="comment">#=> true</span>
|
|
239
|
+
[<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="integer">7</span>] == [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">f</span><span class="delimiter">"</span></span>] <span class="comment">#=> false</span>
|
|
240
|
+
</pre></div>
|
|
241
|
+
</div>
|
|
242
|
+
</div></div></div><div class="feature"><h2 id="feature23"><span class="anchor" id="public12"><span class="tag public">public</span></span> <span class="anchor" id="instance8"><span class="tag instance">8</span></span> Array#<span class="feature-name">===</span></h2><div class="feature-contents"></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature24"><span class="anchor" id="public13"><span class="tag public">public</span></span> <span class="anchor" id="instance9"><span class="tag instance">9</span></span> Array#<span class="feature-name">[]</span> (alias: <span class="feature-name">slice</span>)</h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(index)</code> → Object | <code class="inline">nil</code><span class="head">Usage</span> <code class="inline">(start, length)</code> → Array | <code class="inline">nil</code><span class="head">Usage</span> <code class="inline">(range)</code> → Array | <code class="inline">nil</code><div class="p">Element Reference — Returns the element at <code class="inline">index</code>, or returns a subarray starting at the <code class="inline">start</code> index and continuing for <code class="inline">length</code> elements, or returns a subarray specified by <code class="inline">range</code> of indices.</div><div class="p">Negative indices count backward from the end of the array (<code class="inline">-1</code> is the last element). For <code class="inline">start</code> and <code class="inline">range</code> cases, the starting index is just before an element. Additionally, an empty array is returned when the starting index for an element range is at the end of the array.</div><div class="p">Returns <code class="inline">nil</code> if the index (or starting index) are out of range.</div><div class="CodeRay">
|
|
243
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">e</span><span class="delimiter">"</span></span>]
|
|
244
|
+
a[<span class="integer">2</span>] + a[<span class="integer">0</span>] + a[<span class="integer">1</span>] <span class="comment">#=> "cab"</span>
|
|
245
|
+
a[<span class="integer">6</span>] <span class="comment">#=> nil</span>
|
|
246
|
+
a[<span class="integer">1</span>, <span class="integer">2</span>] <span class="comment">#=> ["b", "c"]</span>
|
|
247
|
+
a[<span class="integer">1</span>..<span class="integer">3</span>] <span class="comment">#=> ["b", "c", "d"]</span>
|
|
248
|
+
a[<span class="integer">4</span>..<span class="integer">7</span>] <span class="comment">#=> ["e"]</span>
|
|
249
|
+
a[<span class="integer">6</span>..<span class="integer">10</span>] <span class="comment">#=> nil</span>
|
|
250
|
+
a[<span class="integer">-3</span>, <span class="integer">3</span>] <span class="comment">#=> ["c", "d", "e"]</span>
|
|
251
|
+
<span class="comment"># special cases</span>
|
|
252
|
+
a[<span class="integer">5</span>] <span class="comment">#=> nil</span>
|
|
253
|
+
a[<span class="integer">6</span>, <span class="integer">1</span>] <span class="comment">#=> nil</span>
|
|
254
|
+
a[<span class="integer">5</span>, <span class="integer">1</span>] <span class="comment">#=> []</span>
|
|
255
|
+
a[<span class="integer">5</span>..<span class="integer">10</span>] <span class="comment">#=> []</span>
|
|
256
|
+
</pre></div>
|
|
257
|
+
</div>
|
|
258
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature25"><span class="anchor" id="public14"><span class="tag public">public</span></span> <span class="anchor" id="instance10"><span class="tag instance">10</span></span> Array#<span class="feature-name">[]=</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#push</code>, and <code class="inline">#unshift</code>.</div><span class="head">Usage</span> <code class="inline">(index, obj)</code> → Object<span class="head">Usage</span> <code class="inline">((start, length), obj)</code> → Object<span class="head">Usage</span> <code class="inline">(range, obj)</code> → Object<div class="p">Element Assignment — Sets the element at <code class="inline">index</code>, or replaces a subarray from the <code class="inline">start</code> index for <code class="inline">length</code> elements, or replaces a subarray specified by the <code class="inline">range</code> of indices.</div><div class="p">If indices are greater than the current capacity of the array, the array grows automatically. Elements are inserted into the array at <code class="inline">start</code> if <code class="inline">length</code> is zero.</div><div class="p">Negative indices will count backward from the end of the array. For <code class="inline">start</code> and <code class="inline">range</code> cases, the starting index is just before an element.</div><div class="p">An <code class="inline">IndexError</code> is raised if a negative index points past the beginning of the array.</div><div class="CodeRay">
|
|
259
|
+
<div class="code"><pre>a = <span class="constant">Array</span>.new
|
|
260
|
+
a[<span class="integer">4</span>] = <span class="string"><span class="delimiter">"</span><span class="content">4</span><span class="delimiter">"</span></span>; <span class="comment">#=> [nil, nil, nil, nil, "4"]</span>
|
|
261
|
+
a[<span class="integer">0</span>, <span class="integer">3</span>] = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>] <span class="comment">#=> ["a", "b", "c", nil, "4"]</span>
|
|
262
|
+
a[<span class="integer">1</span>..<span class="integer">2</span>] = [<span class="integer">1</span>, <span class="integer">2</span>] <span class="comment">#=> ["a", 1, 2, nil, "4"]</span>
|
|
263
|
+
a[<span class="integer">0</span>, <span class="integer">2</span>] = <span class="string"><span class="delimiter">"</span><span class="content">?</span><span class="delimiter">"</span></span> <span class="comment">#=> ["?", 2, nil, "4"]</span>
|
|
264
|
+
a[<span class="integer">0</span>..<span class="integer">2</span>] = <span class="string"><span class="delimiter">"</span><span class="content">A</span><span class="delimiter">"</span></span> <span class="comment">#=> ["A", "4"]</span>
|
|
265
|
+
a[<span class="integer">-1</span>] = <span class="string"><span class="delimiter">"</span><span class="content">Z</span><span class="delimiter">"</span></span> <span class="comment">#=> ["A", "Z"]</span>
|
|
266
|
+
a[<span class="integer">1</span>..<span class="integer">-1</span>] = <span class="predefined-constant">nil</span> <span class="comment">#=> ["A", nil]</span>
|
|
267
|
+
a[<span class="integer">1</span>..<span class="integer">-1</span>] = [] <span class="comment">#=> ["A"]</span>
|
|
268
|
+
a[<span class="integer">0</span>, <span class="integer">0</span>] = [<span class="integer">1</span>, <span class="integer">2</span>] <span class="comment">#=> [1, 2, "A"]</span>
|
|
269
|
+
a[<span class="integer">3</span>, <span class="integer">0</span>] = <span class="string"><span class="delimiter">"</span><span class="content">B</span><span class="delimiter">"</span></span> <span class="comment">#=> [1, 2, "A", "B"]</span>
|
|
270
|
+
</pre></div>
|
|
271
|
+
</div>
|
|
272
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature26"><span class="anchor" id="public15"><span class="tag public">public</span></span> <span class="anchor" id="instance11"><span class="tag instance">11</span></span> Array#<span class="feature-name">assoc</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#rassoc</code>.</div><span class="head">Usage</span> <code class="inline">(obj)</code> → Array | <code class="inline">nil</code><div class="p">Searches through an array whose elements are also arrays comparing <code class="inline">obj</code> with the first element of each contained array using <code class="inline">obj.==</code>.</div><div class="p">Returns the first contained array that matches (that is, the first associated array), or <code class="inline">nil</code> if no match is found.</div><div class="CodeRay">
|
|
273
|
+
<div class="code"><pre>s1 = [<span class="string"><span class="delimiter">"</span><span class="content">colors</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">red</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">blue</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">green</span><span class="delimiter">"</span></span>]
|
|
274
|
+
s2 = [<span class="string"><span class="delimiter">"</span><span class="content">letters</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
275
|
+
s3 = <span class="string"><span class="delimiter">"</span><span class="content">foo</span><span class="delimiter">"</span></span>
|
|
276
|
+
a = [s1, s2, s3]
|
|
277
|
+
a.assoc(<span class="string"><span class="delimiter">"</span><span class="content">letters</span><span class="delimiter">"</span></span>) <span class="comment">#=> ["letters", "a", "b", "c"]</span>
|
|
278
|
+
a.assoc(<span class="string"><span class="delimiter">"</span><span class="content">foo</span><span class="delimiter">"</span></span>) <span class="comment">#=> nil</span>
|
|
279
|
+
</pre></div>
|
|
280
|
+
</div>
|
|
281
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature27"><span class="anchor" id="public16"><span class="tag public">public</span></span> <span class="anchor" id="instance12"><span class="tag instance">12</span></span> Array#<span class="feature-name">at</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#[]</code>.</div><span class="head">Usage</span> <code class="inline">(index)</code> → Object | <code class="inline">nil</code><div class="p">Returns the element at <code class="inline">index</code>. A negative index counts from the end of <code class="inline">self</code>. Returns <code class="inline">nil</code> if the index is out of range.</div><div class="CodeRay">
|
|
282
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">e</span><span class="delimiter">"</span></span>]
|
|
283
|
+
a.at(<span class="integer">0</span>) <span class="comment">#=> "a"</span>
|
|
284
|
+
a.at(<span class="integer">-1</span>) <span class="comment">#=> "e"</span>
|
|
285
|
+
</pre></div>
|
|
286
|
+
</div>
|
|
287
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature28"><span class="anchor" id="public17"><span class="tag public">public</span></span> <span class="anchor" id="instance13"><span class="tag instance">13</span></span> Array#<span class="feature-name">bsearch</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">{|x| block}</code> → Object<div class="p">By using binary search, finds a value from this array which meets the given condition in <code class="inline">O(log n)</code> where <code class="inline">n</code> is the size of the array.</div><div class="p">You can use this method in two use cases: a find-minimum mode and a find-any mode. In either case, the elements of the array must be monotone (or sorted) with respect to the block.</div><div class="p">In find-minimum mode (this is a good choice for typical use case), the block must return <code class="inline">true</code> or <code class="inline">false</code>, and there must be an index <code class="inline">i</code> (<code class="inline">0 <= i <= ary.size</code>) so that:</div><ul><li>the block returns <code class="inline">false</code> for any element whose index is less than <code class="inline">i</code>, and</li><li>the block returns <code class="inline">true</code> for any element whose index is greater than or equal to i.</li></ul><div class="p">This method returns the <code class="inline">i</code>-th element. If <code class="inline">i</code> is equal to <code class="inline">ary.size</code>, it returns <code class="inline">nil</code>.</div><div class="CodeRay">
|
|
288
|
+
<div class="code"><pre>ary = [<span class="integer">0</span>, <span class="integer">4</span>, <span class="integer">7</span>, <span class="integer">10</span>, <span class="integer">12</span>]
|
|
289
|
+
ary.bsearch{|x| x >= <span class="integer">4</span>} <span class="comment">#=> 4</span>
|
|
290
|
+
ary.bsearch{|x| x >= <span class="integer">6</span>} <span class="comment">#=> 7</span>
|
|
291
|
+
ary.bsearch{|x| x >= <span class="integer">-1</span>} <span class="comment">#=> 0</span>
|
|
292
|
+
ary.bsearch{|x| x >= <span class="integer">100</span>} <span class="comment">#=> nil</span>
|
|
293
|
+
</pre></div>
|
|
294
|
+
</div>
|
|
295
|
+
<div class="p">In find-any mode (this behaves like libc’s <code class="inline">bsearch(3)</code>), the block must return a number, and there must be two indices <code class="inline">i</code> and <code class="inline">j</code> (<code class="inline">0</code> <= <code class="inline">i</code> <= <code class="inline">j</code> <= <code class="inline">ary.size</code>) so that:</div><ul><li>the block returns a positive number for ary if 0 <= k < i,</li><li>the block returns zero for ary if <code class="inline">i</code> <= <code class="inline">k</code> < <code class="inline">j</code>, and</li><li>the block returns a negative number for ary if <code class="inline">j</code> <= <code class="inline">k</code> < <code class="inline">ary.size</code>.</li></ul><div class="p">Under this condition, this method returns any element whose index is within <code class="inline">i…j</code>. If <code class="inline">i</code> is equal to <code class="inline">j</code> (i.e., there is no element that satisfies the block), this method returns <code class="inline">nil</code>.</div><div class="CodeRay">
|
|
296
|
+
<div class="code"><pre>ary = [<span class="integer">0</span>, <span class="integer">4</span>, <span class="integer">7</span>, <span class="integer">10</span>, <span class="integer">12</span>]
|
|
297
|
+
<span class="comment"># try to find v such that 4 <= v < 8</span>
|
|
298
|
+
ary.bsearch{|x| <span class="integer">1</span> - x / <span class="integer">4</span>} <span class="comment">#=> 4 or 7</span>
|
|
299
|
+
<span class="comment"># try to find v such that 8 <= v < 10</span>
|
|
300
|
+
ary.bsearch{|x| <span class="integer">4</span> - x / <span class="integer">2</span>} <span class="comment">#=> nil</span>
|
|
301
|
+
</pre></div>
|
|
302
|
+
</div>
|
|
303
|
+
<div class="p">You must not mix the two modes at a time; the block must always return either <code class="inline">true</code>/<code class="inline">false</code>, or always return a number. It is undefined which value is actually picked up at each iteration.</div></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature29"><span class="anchor" id="public18"><span class="tag public">public</span></span> <span class="anchor" id="instance14"><span class="tag instance">14</span></span> Array#<span class="feature-name">clear</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Array<div class="p">Removes all elements from <code class="inline">self</code>.</div><div class="CodeRay">
|
|
304
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">e</span><span class="delimiter">"</span></span>]
|
|
305
|
+
a.clear <span class="comment">#=> []</span>
|
|
306
|
+
</pre></div>
|
|
307
|
+
</div>
|
|
308
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature30"><span class="anchor" id="public19"><span class="tag public">public</span></span> <span class="anchor" id="instance15"><span class="tag instance">15</span></span> Array#<span class="feature-name">collect</span> (alias: <span class="feature-name">map</span>)</h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">Enumerable#collect</code>.</div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Array<div class="p">Invokes the given block once for each element of <code class="inline">self</code>.</div><div class="p">Creates a new array containing the values returned by the block.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="CodeRay">
|
|
309
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>]
|
|
310
|
+
a.collect{|x| x + <span class="string"><span class="delimiter">"</span><span class="content">!</span><span class="delimiter">"</span></span>} <span class="comment">#=> ["a!", "b!", "c!", "d!"]</span>
|
|
311
|
+
a.map.with_index{|x, i| x * i} <span class="comment">#=> ["", "b", "cc", "ddd"]</span>
|
|
312
|
+
a <span class="comment">#=> ["a", "b", "c", "d"]</span>
|
|
313
|
+
</pre></div>
|
|
314
|
+
</div>
|
|
315
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature31"><span class="anchor" id="public20"><span class="tag public">public</span></span> <span class="anchor" id="instance16"><span class="tag instance">16</span></span> Array#<span class="feature-name">collect!</span> (alias: <span class="feature-name">map!</span>)</h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">Enumerable#collect</code>.</div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Array<div class="p">Invokes the given block once for each element of self, replacing the element with the value returned by the block.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="CodeRay">
|
|
316
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>]
|
|
317
|
+
a.map!{|x| x + <span class="string"><span class="delimiter">"</span><span class="content">!</span><span class="delimiter">"</span></span>}
|
|
318
|
+
a <span class="comment">#=> ["a!", "b!", "c!", "d!"]</span>
|
|
319
|
+
a.collect!.with_index{|x, i| x[<span class="integer">0</span>...i]}
|
|
320
|
+
a <span class="comment">#=> ["", "b", "c!", "d!"]</span>
|
|
321
|
+
</pre></div>
|
|
322
|
+
</div>
|
|
323
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature32"><span class="anchor" id="public21"><span class="tag public">public</span></span> <span class="anchor" id="instance17"><span class="tag instance">17</span></span> Array#<span class="feature-name">combination</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(n){|c| block}</code> → Array<div class="p">When invoked with a block, yields all combinations of length <code class="inline">n</code> of elements from the array and then returns the array itself.</div><div class="p">The implementation makes no guarantees about the order in which the combinations are yielded.</div><span class="head">Usage</span> <code class="inline">(n)</code> → Enumerator<div class="p">Examples:</div><div class="CodeRay">
|
|
324
|
+
<div class="code"><pre>a = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">4</span>]
|
|
325
|
+
a.combination(<span class="integer">1</span>).to_a <span class="comment">#=> [[1],[2],[3],[4]]</span>
|
|
326
|
+
a.combination(<span class="integer">2</span>).to_a <span class="comment">#=> [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]</span>
|
|
327
|
+
a.combination(<span class="integer">3</span>).to_a <span class="comment">#=> [[1,2,3],[1,2,4],[1,3,4],[2,3,4]]</span>
|
|
328
|
+
a.combination(<span class="integer">4</span>).to_a <span class="comment">#=> [[1,2,3,4]]</span>
|
|
329
|
+
a.combination(<span class="integer">0</span>).to_a <span class="comment">#=> [[]] # one combination of length 0</span>
|
|
330
|
+
a.combination(<span class="integer">5</span>).to_a <span class="comment">#=> [] # no combinations of length 5</span>
|
|
331
|
+
</pre></div>
|
|
332
|
+
</div>
|
|
333
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature33"><span class="anchor" id="public22"><span class="tag public">public</span></span> <span class="anchor" id="instance18"><span class="tag instance">18</span></span> Array#<span class="feature-name">compact</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Array<div class="p">Returns a copy of <code class="inline">self</code> with all <code class="inline">nil</code> elements removed.</div><div class="CodeRay">
|
|
334
|
+
<div class="code"><pre>[<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="predefined-constant">nil</span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="predefined-constant">nil</span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="predefined-constant">nil</span>].compact
|
|
335
|
+
<span class="comment">#=> ["a", "b", "c"]</span>
|
|
336
|
+
</pre></div>
|
|
337
|
+
</div>
|
|
338
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature34"><span class="anchor" id="public23"><span class="tag public">public</span></span> <span class="anchor" id="instance19"><span class="tag instance">19</span></span> Array#<span class="feature-name">compact!</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Array | <code class="inline">nil</code><div class="p">Removes <code class="inline">nil</code> elements from the array.</div><div class="p">Returns <code class="inline">nil</code> if no changes were made, otherwise returns the array.</div><div class="CodeRay">
|
|
339
|
+
<div class="code"><pre>[<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="predefined-constant">nil</span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="predefined-constant">nil</span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>].compact! <span class="comment">#=> ["a", "b", "c"]</span>
|
|
340
|
+
[<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>].compact! <span class="comment">#=> nil</span>
|
|
341
|
+
</pre></div>
|
|
342
|
+
</div>
|
|
343
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature35"><span class="anchor" id="public24"><span class="tag public">public</span></span> <span class="anchor" id="instance20"><span class="tag instance">20</span></span> Array#<span class="feature-name">concat</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">Array#+</code>.</div><span class="head">Usage</span> <code class="inline">(other_ary)</code> → Array<div class="p">Appends the elements of <code class="inline">other_ary</code> to <code class="inline">self</code>.</div><div class="CodeRay">
|
|
344
|
+
<div class="code"><pre>[<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>].concat([<span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>]) <span class="comment">#=> ["a", "b", "c", "d"]</span>
|
|
345
|
+
a = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>]
|
|
346
|
+
a.concat([<span class="integer">4</span>, <span class="integer">5</span>])
|
|
347
|
+
a <span class="comment">#=> [1, 2, 3, 4, 5]</span>
|
|
348
|
+
</pre></div>
|
|
349
|
+
</div>
|
|
350
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature36"><span class="anchor" id="public25"><span class="tag public">public</span></span> <span class="anchor" id="instance21"><span class="tag instance">21</span></span> Array#<span class="feature-name">count</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(count)</code> → Integer<div class="p">Returns the number of elements.</div><span class="head">Usage</span> <code class="inline">(obj)</code> → Integer<div class="p">Counts the number of elements which equal <code class="inline">obj</code> using <code class="inline">==</code>.</div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Integer<div class="p">Counts the number of elements for which the block returns a true value.</div><div class="CodeRay">
|
|
351
|
+
<div class="code"><pre>ary = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">4</span>, <span class="integer">2</span>]
|
|
352
|
+
ary.count <span class="comment">#=> 4</span>
|
|
353
|
+
ary.count(<span class="integer">2</span>) <span class="comment">#=> 2</span>
|
|
354
|
+
ary.count{|x| (x % <span class="integer">2</span>).zero?} <span class="comment">#=> 3</span>
|
|
355
|
+
</pre></div>
|
|
356
|
+
</div>
|
|
357
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature37"><span class="anchor" id="public26"><span class="tag public">public</span></span> <span class="anchor" id="instance22"><span class="tag instance">22</span></span> Array#<span class="feature-name">cycle</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(n=nil){|obj| block}</code> → NilClass<div class="p">Calls the given block for each element <code class="inline">n</code> times or forever if <code class="inline">nil</code> is given.</div><div class="p">Does nothing if a non-positive number is given or the array is empty.</div><div class="p">Returns <code class="inline">nil</code> if the loop has finished without getting interrupted.</div><span class="head">Usage</span> <code class="inline">(n=nil)</code> → Enumerator<div class="CodeRay">
|
|
358
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
359
|
+
a.cycle{|x| puts x} <span class="comment"># print, a, b, c, a, b, c,.. forever.</span>
|
|
360
|
+
a.cycle(<span class="integer">2</span>){|x| puts x} <span class="comment"># print, a, b, c, a, b, c.</span>
|
|
361
|
+
</pre></div>
|
|
362
|
+
</div>
|
|
363
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature38"><span class="anchor" id="public27"><span class="tag public">public</span></span> <span class="anchor" id="instance23"><span class="tag instance">23</span></span> Array#<span class="feature-name">delete</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(obj)</code> → Object | <code class="inline">nil</code><div class="p">Deletes all items from <code class="inline">self</code> that are equal to <code class="inline">obj</code>.</div><div class="p">Returns the last deleted item, or <code class="inline">nil</code> if no matching item is found.</div><span class="head">Usage</span> <code class="inline">(obj){block}</code> → Object<div class="p">The result of the block is returned if the item is not found. (To remove <code class="inline">nil</code> elements and get an informative return value, use <code class="inline">#compact!</code>)</div><div class="CodeRay">
|
|
364
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
365
|
+
a.delete(<span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>) <span class="comment">#=> "b"</span>
|
|
366
|
+
a <span class="comment">#=> ["a", "c"]</span>
|
|
367
|
+
a.delete(<span class="string"><span class="delimiter">"</span><span class="content">z</span><span class="delimiter">"</span></span>) <span class="comment">#=> nil</span>
|
|
368
|
+
a.delete(<span class="string"><span class="delimiter">"</span><span class="content">z</span><span class="delimiter">"</span></span>){<span class="string"><span class="delimiter">"</span><span class="content">not found</span><span class="delimiter">"</span></span>} <span class="comment">#=> "not found"</span>
|
|
369
|
+
</pre></div>
|
|
370
|
+
</div>
|
|
371
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature39"><span class="anchor" id="public28"><span class="tag public">public</span></span> <span class="anchor" id="instance24"><span class="tag instance">24</span></span> Array#<span class="feature-name">delete_at</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#slice!</code></div><span class="head">Usage</span> <code class="inline">(index)</code> → Object | <code class="inline">nil</code><div class="p">Deletes the element at the specified <code class="inline">index</code>, returning that element, or <code class="inline">nil</code> if the index is out of range.</div><div class="CodeRay">
|
|
372
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">ant</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">bat</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">cat</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">dog</span><span class="delimiter">"</span></span>]
|
|
373
|
+
a.delete_at(<span class="integer">2</span>) <span class="comment">#=> "cat"</span>
|
|
374
|
+
a <span class="comment">#=> ["ant", "bat", "dog"]</span>
|
|
375
|
+
a.delete_at(<span class="integer">99</span>) <span class="comment">#=> nil</span>
|
|
376
|
+
</pre></div>
|
|
377
|
+
</div>
|
|
378
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature40"><span class="anchor" id="public29"><span class="tag public">public</span></span> <span class="anchor" id="instance25"><span class="tag instance">25</span></span> Array#<span class="feature-name">delete_if</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#reject!</code></div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Array<div class="p">Deletes every element of <code class="inline">self</code> for which block evaluates to <code class="inline">true</code>.</div><div class="p">The array is changed instantly every time the block is called, not after the iteration is over.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="CodeRay">
|
|
379
|
+
<div class="code"><pre>scores = [<span class="integer">97</span>, <span class="integer">42</span>, <span class="integer">75</span>]
|
|
380
|
+
scores.delete_if{|score| score < <span class="integer">80</span>} <span class="comment">#=> [97]</span>
|
|
381
|
+
</pre></div>
|
|
382
|
+
</div>
|
|
383
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature41"><span class="anchor" id="public30"><span class="tag public">public</span></span> <span class="anchor" id="instance26"><span class="tag instance">26</span></span> Array#<span class="feature-name">drop</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#take</code></div><span class="head">Usage</span> <code class="inline">(n)</code> → Array<div class="p">Drops first <code class="inline">n</code> elements from <code class="inline">ary</code> and returns the rest of the elements in an array.</div><div class="p">If a negative number is given, raises an <code class="inline">ArgumentError</code>.</div><div class="CodeRay">
|
|
384
|
+
<div class="code"><pre>a = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">4</span>, <span class="integer">5</span>, <span class="integer">0</span>]
|
|
385
|
+
a.drop(<span class="integer">3</span>) <span class="comment">#=> [4, 5, 0]</span>
|
|
386
|
+
</pre></div>
|
|
387
|
+
</div>
|
|
388
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature42"><span class="anchor" id="public31"><span class="tag public">public</span></span> <span class="anchor" id="instance27"><span class="tag instance">27</span></span> Array#<span class="feature-name">drop_while</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#take_while</code></div><span class="head">Usage</span> <code class="inline">{|arr| block}</code> → Array<div class="p">Drops elements up to, but not including, the first element for which the block returns <code class="inline">nil</code> or <code class="inline">false</code> and returns an array containing the remaining elements.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="CodeRay">
|
|
389
|
+
<div class="code"><pre>a = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">4</span>, <span class="integer">5</span>, <span class="integer">0</span>]
|
|
390
|
+
a.drop_while{|i| i < <span class="integer">3</span>} <span class="comment">#=> [3, 4, 5, 0]</span>
|
|
391
|
+
</pre></div>
|
|
392
|
+
</div>
|
|
393
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature43"><span class="anchor" id="public32"><span class="tag public">public</span></span> <span class="anchor" id="instance28"><span class="tag instance">28</span></span> Array#<span class="feature-name">each</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Array<div class="p">Calls the given block once for each element in <code class="inline">self</code>, passing that element as a parameter.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="CodeRay">
|
|
394
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
395
|
+
a.each{|x| print x, <span class="string"><span class="delimiter">"</span><span class="content"> -- </span><span class="delimiter">"</span></span>}
|
|
396
|
+
</pre></div>
|
|
397
|
+
</div>
|
|
398
|
+
<div class="p">produces:</div><div class="CodeRay">
|
|
399
|
+
<div class="code"><pre>a -- b -- c --
|
|
400
|
+
</pre></div>
|
|
401
|
+
</div>
|
|
402
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature44"><span class="anchor" id="public33"><span class="tag public">public</span></span> <span class="anchor" id="instance29"><span class="tag instance">29</span></span> Array#<span class="feature-name">each_index</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">{|index| block}</code> → Array<div class="p">Same as <code class="inline">#each</code>, but passes the index of the element instead of the element itself.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="CodeRay">
|
|
403
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
404
|
+
a.each_index{|x| print x, <span class="string"><span class="delimiter">"</span><span class="content"> -- </span><span class="delimiter">"</span></span>}
|
|
405
|
+
</pre></div>
|
|
406
|
+
</div>
|
|
407
|
+
<div class="p">produces:</div><div class="CodeRay">
|
|
408
|
+
<div class="code"><pre><span class="integer">0</span> -- <span class="integer">1</span> -- <span class="integer">2</span> --
|
|
409
|
+
</pre></div>
|
|
410
|
+
</div>
|
|
411
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature45"><span class="anchor" id="public34"><span class="tag public">public</span></span> <span class="anchor" id="instance30"><span class="tag instance">30</span></span> Array#<span class="feature-name">empty?</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → <code class="inline">true</code> | <code class="inline">false</code><div class="p">Returns <code class="inline">true</code> if <code class="inline">self</code> contains no elements.</div><div class="CodeRay">
|
|
412
|
+
<div class="code"><pre>[].empty? <span class="comment">#=> true</span>
|
|
413
|
+
</pre></div>
|
|
414
|
+
</div>
|
|
415
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature46"><span class="anchor" id="public35"><span class="tag public">public</span></span> <span class="anchor" id="instance31"><span class="tag instance">31</span></span> Array#<span class="feature-name">eql?</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(other)</code> → <code class="inline">true</code> | <code class="inline">false</code><div class="p">Returns <code class="inline">true</code> if <code class="inline">self</code> and other are the same object, or are both arrays with the same content (according to <code class="inline">Object#eql?</code>).</div></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature47"><span class="anchor" id="public36"><span class="tag public">public</span></span> <span class="anchor" id="instance32"><span class="tag instance">32</span></span> Array#<span class="feature-name">fetch</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(index)</code> → Object<div class="p">Tries to return the element at position <code class="inline">index</code>, but throws an <code class="inline">IndexError</code> exception if the referenced <code class="inline">index</code> lies outside of the array bounds.</div><span class="head">Usage</span> <code class="inline">(index, default)</code> → Object<div class="p">This error is prevented by the <code class="inline">default</code>, which will act as a default value.</div><span class="head">Usage</span> <code class="inline">(index){|index| block}</code> → Object<div class="p">It will only be executed when an invalid index is referenced. Negative values of index count from the end of the array.</div><div class="CodeRay">
|
|
416
|
+
<div class="code"><pre>a = [<span class="integer">11</span>, <span class="integer">22</span>, <span class="integer">33</span>, <span class="integer">44</span>]
|
|
417
|
+
a.fetch(<span class="integer">1</span>) <span class="comment">#=> 22</span>
|
|
418
|
+
a.fetch(<span class="integer">-1</span>) <span class="comment">#=> 44</span>
|
|
419
|
+
a.fetch(<span class="integer">4</span>, <span class="string"><span class="delimiter">"</span><span class="content">cat</span><span class="delimiter">"</span></span>) <span class="comment">#=> "cat"</span>
|
|
420
|
+
a.fetch(<span class="integer">100</span>){|i| puts <span class="string"><span class="delimiter">"</span><span class="char">\#</span><span class="char">\{</span><span class="content">i</span><span class="char">\}</span><span class="content"> is out of bounds</span><span class="delimiter">"</span></span>}
|
|
421
|
+
<span class="comment">#=> "100 is out of bounds"</span>
|
|
422
|
+
</pre></div>
|
|
423
|
+
</div>
|
|
424
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature48"><span class="anchor" id="public37"><span class="tag public">public</span></span> <span class="anchor" id="instance33"><span class="tag instance">33</span></span> Array#<span class="feature-name">fill</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(obj)</code> → Array<span class="head">Usage</span> <code class="inline">(obj, start [, length])</code> → Array<span class="head">Usage</span> <code class="inline">(obj, range)</code> → Array<div class="p">Sets the selected elements of <code class="inline">self</code> (which may be the entire array) to <code class="inline">obj</code>.</div><div class="p">A <code class="inline">start</code> of <code class="inline">nil</code> is equivalent to zero.</div><div class="p">A <code class="inline">length</code> of <code class="inline">nil</code> is equivalent to the length of the array.</div><div class="p">Negative values of <code class="inline">start</code> count from the end of the array, where <code class="inline">-1</code> is the last element.</div><span class="head">Usage</span> <code class="inline">{|index| block}</code> → Array<span class="head">Usage</span> <code class="inline">(start [, length]){|index| block}</code> → Array<span class="head">Usage</span> <code class="inline">(range){|index| block}</code> → Array<div class="p">Fills the array with the value of the given block, which is passed the absolute index of each element to be filled.</div><div class="CodeRay">
|
|
425
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>]
|
|
426
|
+
a.fill(<span class="string"><span class="delimiter">"</span><span class="content">x</span><span class="delimiter">"</span></span>) <span class="comment">#=> ["x", "x", "x", "x"]</span>
|
|
427
|
+
a.fill(<span class="string"><span class="delimiter">"</span><span class="content">z</span><span class="delimiter">"</span></span>, <span class="integer">2</span>, <span class="integer">2</span>) <span class="comment">#=> ["x", "x", "z", "z"]</span>
|
|
428
|
+
a.fill(<span class="string"><span class="delimiter">"</span><span class="content">y</span><span class="delimiter">"</span></span>, <span class="integer">0</span>..<span class="integer">1</span>) <span class="comment">#=> ["y", "y", "z", "z"]</span>
|
|
429
|
+
a.fill{|i| i*i} <span class="comment">#=> [0, 1, 4, 9]</span>
|
|
430
|
+
a.fill(<span class="integer">-2</span>){|i| i*i*i} <span class="comment">#=> [0, 1, 8, 27]</span>
|
|
431
|
+
</pre></div>
|
|
432
|
+
</div>
|
|
433
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature49"><span class="anchor" id="public38"><span class="tag public">public</span></span> <span class="anchor" id="instance34"><span class="tag instance">34</span></span> Array#<span class="feature-name">find_index</span> (alias: <span class="feature-name">index</span>)</h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#rindex</code>.</div><span class="head">Usage</span> <code class="inline">(obj)</code> → Integer | <code class="inline">nil</code><div class="p">Returns the index of the first object in <code class="inline">ary</code> such that the object is <code class="inline">==</code> to <code class="inline">obj</code>. Returns <code class="inline">nil</code> if no match is found.</div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Integer | <code class="inline">nil</code><div class="p">Returns the index of the first object for which the block returns <code class="inline">true</code>. Returns <code class="inline">nil</code> if no match is found.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="CodeRay">
|
|
434
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
435
|
+
a.index(<span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>) <span class="comment">#=> 1</span>
|
|
436
|
+
a.index(<span class="string"><span class="delimiter">"</span><span class="content">z</span><span class="delimiter">"</span></span>) <span class="comment">#=> nil</span>
|
|
437
|
+
a.index{|x| x == <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>} <span class="comment">#=> 1</span>
|
|
438
|
+
</pre></div>
|
|
439
|
+
</div>
|
|
440
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature50"><span class="anchor" id="public39"><span class="tag public">public</span></span> <span class="anchor" id="instance35"><span class="tag instance">35</span></span> Array#<span class="feature-name">first</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#last</code> for the opposite effect.</div><span class="head">Usage</span> <code class="inline">first</code> → Object | <code class="inline">nil</code><div class="p">Returns the first element of the array. If the array is empty, returns <code class="inline">nil</code>.</div><span class="head">Usage</span> <code class="inline">(n)</code> → Array<div class="p">Returns the first <code class="inline">n</code> elements of the array. If the array is empty, returns an empty array.</div><div class="CodeRay">
|
|
441
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">q</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">r</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">s</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">t</span><span class="delimiter">"</span></span>]
|
|
442
|
+
a.first <span class="comment">#=> "q"</span>
|
|
443
|
+
a.first(<span class="integer">2</span>) <span class="comment">#=> ["q", "r"]</span>
|
|
444
|
+
</pre></div>
|
|
445
|
+
</div>
|
|
446
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature51"><span class="anchor" id="public40"><span class="tag public">public</span></span> <span class="anchor" id="instance36"><span class="tag instance">36</span></span> Array#<span class="feature-name">flatten</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Array<div class="p">Returns a new array that is a one-dimensional flattening of <code class="inline">self</code> (recursively). That is, for every element that is an array, extract its elements into the new array.</div><span class="head">Usage</span> <code class="inline">(level)</code> → Array<div class="p">The optional <code class="inline">level</code> argument determines the level of recursion to flatten.</div><div class="CodeRay">
|
|
447
|
+
<div class="code"><pre>s = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>] <span class="comment">#=> [1, 2, 3]</span>
|
|
448
|
+
t = [<span class="integer">4</span>, <span class="integer">5</span>, <span class="integer">6</span>, [<span class="integer">7</span>, <span class="integer">8</span>]] <span class="comment">#=> [4, 5, 6, [7, 8]]</span>
|
|
449
|
+
a = [s, t, <span class="integer">9</span>, <span class="integer">10</span>] <span class="comment">#=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]</span>
|
|
450
|
+
a.flatten <span class="comment">#=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]</span>
|
|
451
|
+
a = [<span class="integer">1</span>, <span class="integer">2</span>, [<span class="integer">3</span>, [<span class="integer">4</span>, <span class="integer">5</span>]]]
|
|
452
|
+
a.flatten(<span class="integer">1</span>) <span class="comment">#=> [1, 2, 3, [4, 5]]</span>
|
|
453
|
+
</pre></div>
|
|
454
|
+
</div>
|
|
455
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature52"><span class="anchor" id="public41"><span class="tag public">public</span></span> <span class="anchor" id="instance37"><span class="tag instance">37</span></span> Array#<span class="feature-name">flatten!</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Array | <code class="inline">nil</code><div class="p">Flattens <code class="inline">self</code> in place. Returns <code class="inline">nil</code> if no modifications were made (i.e., the array contains no subarrays.</div><span class="head">Usage</span> <code class="inline">(level)</code> → Array | <code class="inline">nil</code><div class="p">The optional <code class="inline">level</code> argument determines the level of recursion to flatten.</div><div class="CodeRay">
|
|
456
|
+
<div class="code"><pre>a = [<span class="integer">1</span>, <span class="integer">2</span>, [<span class="integer">3</span>, [<span class="integer">4</span>, <span class="integer">5</span>]]]
|
|
457
|
+
a.flatten! <span class="comment">#=> [1, 2, 3, 4, 5]</span>
|
|
458
|
+
a.flatten! <span class="comment">#=> nil</span>
|
|
459
|
+
a <span class="comment">#=> [1, 2, 3, 4, 5]</span>
|
|
460
|
+
a = [<span class="integer">1</span>, <span class="integer">2</span>, [<span class="integer">3</span>, [<span class="integer">4</span>, <span class="integer">5</span>]]]
|
|
461
|
+
a.flatten!(<span class="integer">1</span>) <span class="comment">#=> [1, 2, 3, [4, 5]]</span>
|
|
462
|
+
</pre></div>
|
|
463
|
+
</div>
|
|
464
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature53"><span class="anchor" id="public42"><span class="tag public">public</span></span> <span class="anchor" id="instance38"><span class="tag instance">38</span></span> Array#<span class="feature-name">frozen?</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">Object#frozen?</code></div><span class="head">Usage</span> <code class="inline"></code> → <code class="inline">true</code> | <code class="inline">false</code><div class="p">Returns <code class="inline">true</code> if this array is frozen (or temporarily frozen while being sorted).</div></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature54"><span class="anchor" id="public43"><span class="tag public">public</span></span> <span class="anchor" id="instance39"><span class="tag instance">39</span></span> Array#<span class="feature-name">hash</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Fixnum<div class="p">Computes a hash-code for this array. Two arrays with the same content will have the same hash code (and will compare using <code class="inline">eql?</code>).</div></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature55"><span class="anchor" id="public44"><span class="tag public">public</span></span> <span class="anchor" id="instance40"><span class="tag instance">40</span></span> Array#<span class="feature-name">include?</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(object)</code> → <code class="inline">true</code> | <code class="inline">false</code><div class="p">Returns <code class="inline">true</code> if the given object is present in <code class="inline">self</code> (that is, if any element <code class="inline">==</code> <code class="inline">object</code>), otherwise returns <code class="inline">false</code>.</div><div class="CodeRay">
|
|
465
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
466
|
+
a.include?(<span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>) <span class="comment">#=> true</span>
|
|
467
|
+
a.include?(<span class="string"><span class="delimiter">"</span><span class="content">z</span><span class="delimiter">"</span></span>) <span class="comment">#=> false</span>
|
|
468
|
+
</pre></div>
|
|
469
|
+
</div>
|
|
470
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature56"><span class="anchor" id="public45"><span class="tag public">public</span></span> <span class="anchor" id="instance41"><span class="tag instance">41</span></span> Array#<span class="feature-name">index</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#rindex</code>.</div><span class="head">Usage</span> <code class="inline">(obj)</code> → Integer | <code class="inline">nil</code><div class="p">Returns the index of the first object in <code class="inline">self</code> such that the object is <code class="inline">==</code> to <code class="inline">obj</code>.</div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Integer | <code class="inline">nil</code><div class="p">Returns the index of the first object for which the block returns <code class="inline">true</code>. Returns <code class="inline">nil</code> if no match is found.</div><span class="head">Usage</span> <code class="inline">index</code> → Enumerator<div class="CodeRay">
|
|
471
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
472
|
+
a.index(<span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>) <span class="comment">#=> 1</span>
|
|
473
|
+
a.index(<span class="string"><span class="delimiter">"</span><span class="content">z</span><span class="delimiter">"</span></span>) <span class="comment">#=> nil</span>
|
|
474
|
+
a.index{|x| x == <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>} <span class="comment">#=> 1</span>
|
|
475
|
+
</pre></div>
|
|
476
|
+
</div>
|
|
477
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature57"><span class="anchor" id="private1"><span class="tag private">private</span></span> <span class="anchor" id="instance42"><span class="tag instance">42</span></span> Array#<span class="feature-name">initialize_copy</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(other_ary)</code> → Array<div class="p">Replaces the contents of <code class="inline">self</code> with the contents of <code class="inline">other_ary</code>, truncating or expanding if necessary.</div><div class="CodeRay">
|
|
478
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">e</span><span class="delimiter">"</span></span>]
|
|
479
|
+
a.replace([<span class="string"><span class="delimiter">"</span><span class="content">x</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">y</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">z</span><span class="delimiter">"</span></span>]) <span class="comment">#=> ["x", "y", "z"]</span>
|
|
480
|
+
a <span class="comment">#=> ["x", "y", "z"]</span>
|
|
481
|
+
</pre></div>
|
|
482
|
+
</div>
|
|
483
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature58"><span class="anchor" id="public46"><span class="tag public">public</span></span> <span class="anchor" id="instance43"><span class="tag instance">43</span></span> Array#<span class="feature-name">insert</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(index, obj...)</code> → Array<div class="p">Inserts the given values before the element with the given index.</div><div class="p">Negative indices count backwards from the end of the array, where <code class="inline">-1</code> is the last element.</div><div class="CodeRay">
|
|
484
|
+
<div class="code"><pre>a = <span class="string"><span class="delimiter">%w{</span><span class="content">a b c d</span><span class="delimiter">}</span></span>
|
|
485
|
+
a.insert(<span class="integer">2</span>, <span class="integer">99</span>) <span class="comment">#=> ["a", "b", 99, "c", "d"]</span>
|
|
486
|
+
a.insert(<span class="integer">-2</span>, <span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>) <span class="comment">#=> ["a", "b", 99, "c", 1, 2, 3, "d"]</span>
|
|
487
|
+
</pre></div>
|
|
488
|
+
</div>
|
|
489
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature59"><span class="anchor" id="public47"><span class="tag public">public</span></span> <span class="anchor" id="instance44"><span class="tag instance">44</span></span> Array#<span class="feature-name">inspect</span> (alias: <span class="feature-name">to_s</span>)</h2><div class="feature-contents"><div class="user-item"><div class="p">Also aliased as: <code class="inline">to_s</code></div><span class="head">Usage</span> <code class="inline"></code> → String<div class="p">Creates a string representation of <code class="inline">self</code>.</div><div class="CodeRay">
|
|
490
|
+
<div class="code"><pre>[<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>].to_s <span class="comment">#=> "[\"a\", \"b\", \"c\"]"</span>
|
|
491
|
+
</pre></div>
|
|
492
|
+
</div>
|
|
493
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature60"><span class="anchor" id="public48"><span class="tag public">public</span></span> <span class="anchor" id="instance45"><span class="tag instance">45</span></span> Array#<span class="feature-name">join</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(separator=$,)</code> → String<div class="p">Returns a string created by converting each element of the array to a string, separated by the given <code class="inline">separator</code>. If the <code class="inline">separator</code> is <code class="inline">nil</code>, it uses current <code class="inline">$,</code>. If both the <code class="inline">separator</code> and <code class="inline">$,</code> are <code class="inline">nil</code>, it uses empty string.</div><div class="CodeRay">
|
|
494
|
+
<div class="code"><pre>[<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>].join <span class="comment">#=> "abc"</span>
|
|
495
|
+
[<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>].join(<span class="string"><span class="delimiter">"</span><span class="content">-</span><span class="delimiter">"</span></span>) <span class="comment">#=> "a-b-c"</span>
|
|
496
|
+
</pre></div>
|
|
497
|
+
</div>
|
|
498
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature61"><span class="anchor" id="public49"><span class="tag public">public</span></span> <span class="anchor" id="instance46"><span class="tag instance">46</span></span> Array#<span class="feature-name">keep_if</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#select!</code></div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Array<div class="p">Deletes every element of self for which the given block evaluates to <code class="inline">false</code>.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="CodeRay">
|
|
499
|
+
<div class="code"><pre>a = <span class="string"><span class="delimiter">%w{</span><span class="content">a b c d e f</span><span class="delimiter">}</span></span>
|
|
500
|
+
a.keep_if{|v| v =~ <span class="regexp"><span class="delimiter">/</span><span class="content">[aeiou]</span><span class="delimiter">/</span></span>} <span class="comment">#=> ["a", "e"]</span>
|
|
501
|
+
</pre></div>
|
|
502
|
+
</div>
|
|
503
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature62"><span class="anchor" id="public50"><span class="tag public">public</span></span> <span class="anchor" id="instance47"><span class="tag instance">47</span></span> Array#<span class="feature-name">last</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#first</code> for the opposite effect.</div><span class="head">Usage</span> <code class="inline"></code> → Object | <code class="inline">nil</code><div class="p">Returns the last element of <code class="inline">self</code>. If the array is empty, returns <code class="inline">nil</code>.</div><span class="head">Usage</span> <code class="inline">(n)</code> → Array<div class="p">Returns the last element(s) of <code class="inline">self</code>.</div><div class="CodeRay">
|
|
504
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">w</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">x</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">y</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">z</span><span class="delimiter">"</span></span>]
|
|
505
|
+
a.last <span class="comment">#=> "z"</span>
|
|
506
|
+
a.last(<span class="integer">2</span>) <span class="comment">#=> ["y", "z"]</span>
|
|
507
|
+
</pre></div>
|
|
508
|
+
</div>
|
|
509
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature63"><span class="anchor" id="public51"><span class="tag public">public</span></span> <span class="anchor" id="instance48"><span class="tag instance">48</span></span> Array#<span class="feature-name">length</span> (alias: <span class="feature-name">size</span>)</h2><div class="feature-contents"><div class="user-item"><div class="p">Also aliased as: <code class="inline">size</code></div><span class="head">Usage</span> <code class="inline"></code> → Integer<div class="p">Returns the number of elements in <code class="inline">self</code>. May be zero.</div><div class="CodeRay">
|
|
510
|
+
<div class="code"><pre>[<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">4</span>, <span class="integer">5</span>].length <span class="comment">#=> 5</span>
|
|
511
|
+
[].length <span class="comment">#=> 0</span>
|
|
512
|
+
</pre></div>
|
|
513
|
+
</div>
|
|
514
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature64"><span class="anchor" id="public52"><span class="tag public">public</span></span> <span class="anchor" id="instance49"><span class="tag instance">49</span></span> Array#<span class="feature-name">map</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">Enumerable#collect</code>.</div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Array<div class="p">Invokes the given block once for each element of <code class="inline">self</code>.</div><div class="p">Creates a new array containing the values returned by the block.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="CodeRay">
|
|
515
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>]
|
|
516
|
+
a.collect{|x| x + <span class="string"><span class="delimiter">"</span><span class="content">!</span><span class="delimiter">"</span></span>} <span class="comment">#=> ["a!", "b!", "c!", "d!"]</span>
|
|
517
|
+
a.map.with_index{|x, i| x * i} <span class="comment">#=> ["", "b", "cc", "ddd"]</span>
|
|
518
|
+
a <span class="comment">#=> ["a", "b", "c", "d"]</span>
|
|
519
|
+
</pre></div>
|
|
520
|
+
</div>
|
|
521
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature65"><span class="anchor" id="public53"><span class="tag public">public</span></span> <span class="anchor" id="instance50"><span class="tag instance">50</span></span> Array#<span class="feature-name">map!</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">Enumerable#collect</code>.</div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Array<div class="p">Invokes the given block once for each element of <code class="inline">self</code>, replacing the element with the value returned by the block.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="CodeRay">
|
|
522
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>]
|
|
523
|
+
a.map!{|x| x + <span class="string"><span class="delimiter">"</span><span class="content">!</span><span class="delimiter">"</span></span>}
|
|
524
|
+
a <span class="comment">#=> ["a!", "b!", "c!", "d!"]</span>
|
|
525
|
+
a.collect!.with_index{|x, i| x[<span class="integer">0</span>...i]}
|
|
526
|
+
a <span class="comment">#=> ["", "b", "c!", "d!"]</span>
|
|
527
|
+
</pre></div>
|
|
528
|
+
</div>
|
|
529
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature66"><span class="anchor" id="public54"><span class="tag public">public</span></span> <span class="anchor" id="instance51"><span class="tag instance">51</span></span> Array#<span class="feature-name">pack</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">String#unpack</code>.</div><span class="head">Usage</span> <code class="inline">(aTemplateString)</code> → String<div class="p">Packs the contents of <code class="inline">self</code> into a binary sequence according to the directives in <code class="inline">aTemplateString</code> (see the table below) Directives <code class="inline">A</code>, <code class="inline">a</code>, and <code class="inline">Z</code> may be followed by a count, which gives the width of the resulting field. The remaining directives also may take a count, indicating the number of array elements to convert. If the count is an asterisk (<code class="inline">*</code>), all remaining array elements will be converted. Any of the directives <code class="inline">sSiIlL</code> may be followed by an underscore (<code class="inline">_</code>) or exclamation mark (<code class="inline">!</code>) to use the underlying platform’s native size for the specified type; otherwise, they use a platform-independent size. Spaces are ignored in the template string.</div><div class="CodeRay">
|
|
530
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
531
|
+
n = [<span class="integer">65</span>, <span class="integer">66</span>, <span class="integer">67</span>]
|
|
532
|
+
a.pack(<span class="string"><span class="delimiter">"</span><span class="content">A3A3A3</span><span class="delimiter">"</span></span>) <span class="comment">#=> "a b c "</span>
|
|
533
|
+
a.pack(<span class="string"><span class="delimiter">"</span><span class="content">a3a3a3</span><span class="delimiter">"</span></span>) <span class="comment">#=> "a\000\000b\000\000c\000\000"</span>
|
|
534
|
+
n.pack(<span class="string"><span class="delimiter">"</span><span class="content">ccc</span><span class="delimiter">"</span></span>) <span class="comment">#=> "ABC"</span>
|
|
535
|
+
</pre></div>
|
|
536
|
+
</div>
|
|
537
|
+
<div class="p">Directives for pack.</div><div class="CodeRay">
|
|
538
|
+
<div class="code"><pre><span class="constant">Integer</span> | <span class="constant">Array</span> |
|
|
539
|
+
<span class="constant">Directive</span> | <span class="constant">Element</span> | <span class="constant">Meaning</span>
|
|
540
|
+
---------------------------------------------------------------------------
|
|
541
|
+
<span class="constant">C</span> | <span class="constant">Integer</span> | <span class="integer">8</span>-bit unsigned (unsigned char)
|
|
542
|
+
<span class="constant">S</span> | <span class="constant">Integer</span> | <span class="integer">16</span>-bit unsigned, native endian (uint16_t)
|
|
543
|
+
<span class="constant">L</span> | <span class="constant">Integer</span> | <span class="integer">32</span>-bit unsigned, native endian (uint32_t)
|
|
544
|
+
<span class="constant">Q</span> | <span class="constant">Integer</span> | <span class="integer">64</span>-bit unsigned, native endian (uint64_t)
|
|
545
|
+
| |
|
|
546
|
+
c | <span class="constant">Integer</span> | <span class="integer">8</span>-bit signed (signed char)
|
|
547
|
+
s | <span class="constant">Integer</span> | <span class="integer">16</span>-bit signed, native endian (int16_t)
|
|
548
|
+
l | <span class="constant">Integer</span> | <span class="integer">32</span>-bit signed, native endian (int32_t)
|
|
549
|
+
q | <span class="constant">Integer</span> | <span class="integer">64</span>-bit signed, native endian (int64_t)
|
|
550
|
+
| |
|
|
551
|
+
<span class="constant">S_</span>, S! | <span class="constant">Integer</span> | unsigned short, native endian
|
|
552
|
+
<span class="constant">I</span>, <span class="constant">I_</span>, I! | <span class="constant">Integer</span> | unsigned int, native endian
|
|
553
|
+
<span class="constant">L_</span>, L! | <span class="constant">Integer</span> | unsigned long, native endian
|
|
554
|
+
<span class="constant">Q_</span>, Q! | <span class="constant">Integer</span> | unsigned long long, native endian (<span class="constant">ArgumentError</span>
|
|
555
|
+
| | <span class="keyword">if</span> the platform has no long long type.)
|
|
556
|
+
| | (<span class="constant">Q_</span> <span class="keyword">and</span> Q! is available since <span class="constant">Ruby</span> <span class="float">2.1</span>.)
|
|
557
|
+
| |
|
|
558
|
+
s_, s! | <span class="constant">Integer</span> | signed short, native endian
|
|
559
|
+
i, i_, i! | <span class="constant">Integer</span> | signed int, native endian
|
|
560
|
+
l_, l! | <span class="constant">Integer</span> | signed long, native endian
|
|
561
|
+
q_, q! | <span class="constant">Integer</span> | signed long long, native endian (<span class="constant">ArgumentError</span>
|
|
562
|
+
| | <span class="keyword">if</span> the platform has no long long type.)
|
|
563
|
+
| | (q_ <span class="keyword">and</span> q! is available since <span class="constant">Ruby</span> <span class="float">2.1</span>.)
|
|
564
|
+
| |
|
|
565
|
+
<span class="constant">S</span>> <span class="constant">L</span>> <span class="constant">Q</span>> | <span class="constant">Integer</span> | same as the directives without <span class="string"><span class="delimiter">"</span><span class="content">></span><span class="delimiter">"</span></span> except
|
|
566
|
+
s> l> q> | | big endian
|
|
567
|
+
S!> I!> | | (available since <span class="constant">Ruby</span> <span class="float">1.9</span>.<span class="error">3</span>)
|
|
568
|
+
L!> Q!> | | <span class="string"><span class="delimiter">"</span><span class="content">S></span><span class="delimiter">"</span></span> is same as <span class="string"><span class="delimiter">"</span><span class="content">n</span><span class="delimiter">"</span></span>
|
|
569
|
+
s!> i!> | | <span class="string"><span class="delimiter">"</span><span class="content">L></span><span class="delimiter">"</span></span> is same as <span class="string"><span class="delimiter">"</span><span class="content">N</span><span class="delimiter">"</span></span>
|
|
570
|
+
l!> q!> | |
|
|
571
|
+
| |
|
|
572
|
+
<span class="constant">S</span>< <span class="constant">L</span>< <span class="constant">Q</span>< | <span class="constant">Integer</span> | same as the directives without <span class="string"><span class="delimiter">"</span><span class="content"><</span><span class="delimiter">"</span></span> except
|
|
573
|
+
s< l< q< | | little endian
|
|
574
|
+
S!< I!< | | (available since <span class="constant">Ruby</span> <span class="float">1.9</span>.<span class="error">3</span>)
|
|
575
|
+
L!< Q!< | | <span class="string"><span class="delimiter">"</span><span class="content">S<</span><span class="delimiter">"</span></span> is same as <span class="string"><span class="delimiter">"</span><span class="content">v</span><span class="delimiter">"</span></span>
|
|
576
|
+
s!< i!< | | <span class="string"><span class="delimiter">"</span><span class="content">L<</span><span class="delimiter">"</span></span> is same as <span class="string"><span class="delimiter">"</span><span class="content">V</span><span class="delimiter">"</span></span>
|
|
577
|
+
l!< q!< | |
|
|
578
|
+
| |
|
|
579
|
+
n | <span class="constant">Integer</span> | <span class="integer">16</span>-bit unsigned, network (big-endian) byte order
|
|
580
|
+
<span class="constant">N</span> | <span class="constant">Integer</span> | <span class="integer">32</span>-bit unsigned, network (big-endian) byte order
|
|
581
|
+
v | <span class="constant">Integer</span> | <span class="integer">16</span>-bit unsigned, <span class="constant">VAX</span> (little-endian) byte order
|
|
582
|
+
<span class="constant">V</span> | <span class="constant">Integer</span> | <span class="integer">32</span>-bit unsigned, <span class="constant">VAX</span> (little-endian) byte order
|
|
583
|
+
| |
|
|
584
|
+
<span class="constant">U</span> | <span class="constant">Integer</span> | <span class="constant">UTF</span>-<span class="integer">8</span> character
|
|
585
|
+
w | <span class="constant">Integer</span> | <span class="constant">BER</span>-compressed integer
|
|
586
|
+
|
|
587
|
+
<span class="constant">Float</span> | |
|
|
588
|
+
<span class="constant">Directive</span> | | <span class="constant">Meaning</span>
|
|
589
|
+
---------------------------------------------------------------------------
|
|
590
|
+
<span class="constant">D</span>, d | <span class="constant">Float</span> | double-precision, native format
|
|
591
|
+
<span class="constant">F</span>, f | <span class="constant">Float</span> | single-precision, native format
|
|
592
|
+
<span class="constant">E</span> | <span class="constant">Float</span> | double-precision, little-endian byte order
|
|
593
|
+
e | <span class="constant">Float</span> | single-precision, little-endian byte order
|
|
594
|
+
<span class="constant">G</span> | <span class="constant">Float</span> | double-precision, network (big-endian) byte order
|
|
595
|
+
g | <span class="constant">Float</span> | single-precision, network (big-endian) byte order
|
|
596
|
+
|
|
597
|
+
<span class="constant">String</span> | |
|
|
598
|
+
<span class="constant">Directive</span> | | <span class="constant">Meaning</span>
|
|
599
|
+
---------------------------------------------------------------------------
|
|
600
|
+
<span class="constant">A</span> | <span class="constant">String</span> | arbitrary binary string (space padded, count is width)
|
|
601
|
+
a | <span class="constant">String</span> | arbitrary binary string (null padded, count is width)
|
|
602
|
+
<span class="constant">Z</span> | <span class="constant">String</span> | same as <span class="shell"><span class="delimiter">`</span><span class="delimiter">`</span></span>a<span class="string"><span class="delimiter">'</span><span class="delimiter">'</span></span>, except that null is added with *
|
|
603
|
+
<span class="constant">B</span> | <span class="constant">String</span> | bit string (<span class="constant">MSB</span> first)
|
|
604
|
+
b | <span class="constant">String</span> | bit string (<span class="constant">LSB</span> first)
|
|
605
|
+
<span class="constant">H</span> | <span class="constant">String</span> | hex string (high nibble first)
|
|
606
|
+
h | <span class="constant">String</span> | hex string (low nibble first)
|
|
607
|
+
u | <span class="constant">String</span> | <span class="constant">UU</span>-encoded string
|
|
608
|
+
<span class="constant">M</span> | <span class="constant">String</span> | quoted printable, <span class="constant">MIME</span> encoding (see <span class="constant">RFC2045</span>)
|
|
609
|
+
m | <span class="constant">String</span> | base64 encoded string (see <span class="constant">RFC</span> <span class="integer">2045</span>, count is width)
|
|
610
|
+
| | (<span class="keyword">if</span> count is <span class="integer">0</span>, no line feed are added, see <span class="constant">RFC</span> <span class="integer">4648</span>)
|
|
611
|
+
<span class="constant">P</span> | <span class="constant">String</span> | pointer to a structure (fixed-length string)
|
|
612
|
+
p | <span class="constant">String</span> | pointer to a null-terminated string
|
|
613
|
+
|
|
614
|
+
<span class="constant">Misc</span>. | |
|
|
615
|
+
<span class="constant">Directive</span> | | <span class="constant">Meaning</span>
|
|
616
|
+
---------------------------------------------------------------------------
|
|
617
|
+
<span class="error">@</span> | --- | moves to absolute position
|
|
618
|
+
<span class="constant">X</span> | --- | back up a byte
|
|
619
|
+
x | --- | null byte
|
|
620
|
+
</pre></div>
|
|
621
|
+
</div>
|
|
622
|
+
<table><tr><td style="text-align:center;">Integer Directive</td><td style="text-align:center;">Array Element</td><td style="text-align:center;">Meaning</td></tr><tr><td style="text-align:left;">C</td><td style="text-align:left;">Integer</td><td>8-bit unsigned (unsigned char)</td></tr><tr><td style="text-align:left;">S</td><td style="text-align:left;">Integer</td><td>16-bit unsigned, native endian (uint16_t)</td></tr><tr><td style="text-align:left;">L</td><td style="text-align:left;">Integer</td><td>32-bit unsigned, native endian (uint32_t)</td></tr><tr><td style="text-align:left;">Q</td><td style="text-align:left;">Integer</td><td>64-bit unsigned, native endian (uint64_t)</td></tr><tr><td style="text-align:left;">c</td><td style="text-align:left;">Integer</td><td>8-bit signed (signed char)</td></tr><tr><td style="text-align:left;">s</td><td style="text-align:left;">Integer</td><td>16-bit signed, native endian (int16_t)</td></tr><tr><td style="text-align:left;">l</td><td style="text-align:left;">Integer</td><td>32-bit signed, native endian (int32_t)</td></tr><tr><td style="text-align:left;">q</td><td style="text-align:left;">Integer</td><td>64-bit signed, native endian (int64_t)</td></tr><tr><td style="text-align:left;">S_, S!</td><td style="text-align:left;">Integer</td><td>unsigned short, native endian</td></tr><tr><td style="text-align:left;">I, I_, I!</td><td style="text-align:left;">Integer</td><td>unsigned int, native endian</td></tr><tr><td style="text-align:left;">L_, L!</td><td style="text-align:left;">Integer</td><td>unsigned long, native endian</td></tr><tr><td style="text-align:left;">Q_, Q!</td><td style="text-align:left;">Integer</td><td>unsigned long long, native endian (ArgumentError
|
|
623
|
+
if the platform has no long long type. Q_ and Q! are available since Ruby 2.1.)</td></tr><tr><td style="text-align:left;">s_, s!</td><td style="text-align:left;">Integer</td><td>signed short, native endian</td></tr><tr><td style="text-align:left;">i, i_, i!</td><td style="text-align:left;">Integer</td><td>signed int, native endian</td></tr><tr><td style="text-align:left;">l_, l!</td><td style="text-align:left;">Integer</td><td>signed long, native endian</td></tr><tr><td style="text-align:left;">q_, q!</td><td style="text-align:left;">Integer</td><td>signed long long, native endian (ArgumentError
|
|
624
|
+
if the platform has no long long type. q_ and q! are available since Ruby 2.1.)</td></tr><tr><td style="text-align:left;">S> L> Q></td><td style="text-align:left;">Integer</td><td>same as the directives without ">" except</td></tr><tr><td style="text-align:left;">s> l> q></td><td></td><td>big endian</td></tr></table></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature67"><span class="anchor" id="public55"><span class="tag public">public</span></span> <span class="anchor" id="instance52"><span class="tag instance">52</span></span> Array#<span class="feature-name">permutation</span></h2><div class="feature-contents"><div class="user-item"><div class="p">The implementation makes no guarantees about the order in which the permutations are yielded.</div><span class="head">Usage</span> <code class="inline">(n){|p| block}</code> → Array<div class="p">Yields all permutations of length <code class="inline">n</code> of the elements of the array, then return the array itself.</div><span class="head">Usage</span> <code class="inline">{|p| block}</code> → Array<div class="p">Yields all permutations of all elements.</div><span class="head">Usage</span> <code class="inline">(n)</code> → Enumerator<span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="p">Examples:</div><div class="CodeRay">
|
|
625
|
+
<div class="code"><pre>a = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>]
|
|
626
|
+
a.permutation.to_a <span class="comment">#=> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]</span>
|
|
627
|
+
a.permutation(<span class="integer">1</span>).to_a <span class="comment">#=> [[1],[2],[3]]</span>
|
|
628
|
+
a.permutation(<span class="integer">2</span>).to_a <span class="comment">#=> [[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]]</span>
|
|
629
|
+
a.permutation(<span class="integer">3</span>).to_a <span class="comment">#=> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]</span>
|
|
630
|
+
a.permutation(<span class="integer">0</span>).to_a <span class="comment">#=> [[]] # one permutation of length 0</span>
|
|
631
|
+
a.permutation(<span class="integer">4</span>).to_a <span class="comment">#=> [] # no permutations of length 4</span>
|
|
632
|
+
</pre></div>
|
|
633
|
+
</div>
|
|
634
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature68"><span class="anchor" id="public56"><span class="tag public">public</span></span> <span class="anchor" id="instance53"><span class="tag instance">53</span></span> Array#<span class="feature-name">pop</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#push</code> for the opposite effect.</div><span class="head">Usage</span> <code class="inline"></code> → Object | <code class="inline">nil</code><div class="p">Removes the last element from <code class="inline">self</code> and returns it, or <code class="inline">nil</code> if the array is empty.</div><span class="head">Usage</span> <code class="inline">(n)</code> → Array<div class="p">Returns an array of the last <code class="inline">n</code> elements (or less) just like <code class="inline">array.slice!(-n, n)</code> does.</div><div class="CodeRay">
|
|
635
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>]
|
|
636
|
+
a.pop <span class="comment">#=> "d"</span>
|
|
637
|
+
a.pop(<span class="integer">2</span>) <span class="comment">#=> ["b", "c"]</span>
|
|
638
|
+
a <span class="comment">#=> ["a"]</span>
|
|
639
|
+
</pre></div>
|
|
640
|
+
</div>
|
|
641
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature69"><span class="anchor" id="public57"><span class="tag public">public</span></span> <span class="anchor" id="instance54"><span class="tag instance">54</span></span> Array#<span class="feature-name">product</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(other_ary, ...)</code> → Array<div class="p">Returns an array of all combinations of elements from all arrays.</div><div class="p">The length of the returned array is the product of the length of <code class="inline">self</code> and the argument arrays.</div><span class="head">Usage</span> <code class="inline">(other_ary, ...){|p| block}</code> → Array<div class="p">Product will yield all combinations and return <code class="inline">self</code>.</div><div class="CodeRay">
|
|
642
|
+
<div class="code"><pre>[<span class="integer">1</span>,<span class="integer">2</span>,<span class="integer">3</span>].product([<span class="integer">4</span>,<span class="integer">5</span>]) <span class="comment">#=> [[1,4],[1,5],[2,4],[2,5],[3,4],[3,5]]</span>
|
|
643
|
+
[<span class="integer">1</span>,<span class="integer">2</span>].product([<span class="integer">1</span>,<span class="integer">2</span>]) <span class="comment">#=> [[1,1],[1,2],[2,1],[2,2]]</span>
|
|
644
|
+
[<span class="integer">1</span>,<span class="integer">2</span>].product([<span class="integer">3</span>,<span class="integer">4</span>],[<span class="integer">5</span>,<span class="integer">6</span>]) <span class="comment">#=> [[1,3,5],[1,3,6],[1,4,5],[1,4,6],</span>
|
|
645
|
+
<span class="comment"># [2,3,5],[2,3,6],[2,4,5],[2,4,6]]</span>
|
|
646
|
+
[<span class="integer">1</span>,<span class="integer">2</span>].product() <span class="comment">#=> [[1],[2]]</span>
|
|
647
|
+
[<span class="integer">1</span>,<span class="integer">2</span>].product([]) <span class="comment">#=> []</span>
|
|
648
|
+
</pre></div>
|
|
649
|
+
</div>
|
|
650
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature70"><span class="anchor" id="public58"><span class="tag public">public</span></span> <span class="anchor" id="instance55"><span class="tag instance">55</span></span> Array#<span class="feature-name">push</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#pop</code> for the opposite effect.</div><span class="head">Usage</span> <code class="inline">(obj, ...)</code> → Array<div class="p">Append — Pushes the given object(s) on to the end of this array. This expression returns the array itself, so several appends may be chained together.</div><div class="CodeRay">
|
|
651
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
652
|
+
a.push(<span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">e</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">f</span><span class="delimiter">"</span></span>)
|
|
653
|
+
<span class="comment">#=> ["a", "b", "c", "d", "e", "f"]</span>
|
|
654
|
+
[<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>,].push(<span class="integer">4</span>).push(<span class="integer">5</span>)
|
|
655
|
+
<span class="comment">#=> [1, 2, 3, 4, 5]</span>
|
|
656
|
+
</pre></div>
|
|
657
|
+
</div>
|
|
658
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature71"><span class="anchor" id="public59"><span class="tag public">public</span></span> <span class="anchor" id="instance56"><span class="tag instance">56</span></span> Array#<span class="feature-name">rassoc</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">delete_if</code>.</div><span class="head">Usage</span> <code class="inline">(obj)</code> → Array | <code class="inline">nil</code><div class="p">Searches through the array whose elements are also arrays.</div><div class="p">Compares <code class="inline">obj</code> with the second element of each contained array using <code class="inline">obj.==</code>.</div><div class="p">Returns the first contained array that matches <code class="inline">obj</code>.</div><div class="CodeRay">
|
|
659
|
+
<div class="code"><pre>a = [[<span class="integer">1</span>, <span class="string"><span class="delimiter">"</span><span class="content">one</span><span class="delimiter">"</span></span>], [<span class="integer">2</span>, <span class="string"><span class="delimiter">"</span><span class="content">two</span><span class="delimiter">"</span></span>], [<span class="integer">3</span>, <span class="string"><span class="delimiter">"</span><span class="content">three</span><span class="delimiter">"</span></span>], [<span class="string"><span class="delimiter">"</span><span class="content">ii</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">two</span><span class="delimiter">"</span></span>]]
|
|
660
|
+
a.rassoc(<span class="string"><span class="delimiter">"</span><span class="content">two</span><span class="delimiter">"</span></span>) <span class="comment">#=> [2, "two"]</span>
|
|
661
|
+
a.rassoc(<span class="string"><span class="delimiter">"</span><span class="content">four</span><span class="delimiter">"</span></span>) <span class="comment">#=> nil</span>
|
|
662
|
+
</pre></div>
|
|
663
|
+
</div>
|
|
664
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature72"><span class="anchor" id="public60"><span class="tag public">public</span></span> <span class="anchor" id="instance57"><span class="tag instance">57</span></span> Array#<span class="feature-name">reject</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#delete_if</code></div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Array<div class="p">Returns a new array containing the items in <code class="inline">self</code> for which the given block is not true.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature73"><span class="anchor" id="public61"><span class="tag public">public</span></span> <span class="anchor" id="instance58"><span class="tag instance">58</span></span> Array#<span class="feature-name">reject!</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">Enumerable#reject</code> and <code class="inline">#delete_if</code>.</div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Array<div class="p">Equivalent to <code class="inline">#delete_if</code>, deleting elements from <code class="inline">self</code> for which the block evaluates to <code class="inline">true</code>, but returns <code class="inline">nil</code> if no changes were made.</div><div class="p">The array is changed instantly every time the block is called, not after the iteration is over.</div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → NilClass<span class="head">Usage</span> <code class="inline"></code> → Enumerator</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature74"><span class="anchor" id="public62"><span class="tag public">public</span></span> <span class="anchor" id="instance59"><span class="tag instance">59</span></span> Array#<span class="feature-name">repeated_combination</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(n){|c| block}</code> → Array<div class="p">When invoked with a block, yields all repeated combinations of length <code class="inline">n</code> of elements from the array and then returns the array itself.</div><div class="p">The implementation makes no guarantees about the order in which the repeated combinations are yielded.</div><span class="head">Usage</span> <code class="inline">(n)</code> → Enumerator<div class="p">If no block is given, an <code class="inline">Enumerator</code> is returned instead.</div><div class="p">Examples:</div><div class="CodeRay">
|
|
665
|
+
<div class="code"><pre>a = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>]
|
|
666
|
+
a.repeated_combination(<span class="integer">1</span>).to_a <span class="comment">#=> [[1], [2], [3]]</span>
|
|
667
|
+
a.repeated_combination(<span class="integer">2</span>).to_a <span class="comment">#=> [[1,1],[1,2],[1,3],[2,2],[2,3],[3,3]]</span>
|
|
668
|
+
a.repeated_combination(<span class="integer">3</span>).to_a <span class="comment">#=> [[1,1,1],[1,1,2],[1,1,3],[1,2,2],[1,2,3],</span>
|
|
669
|
+
<span class="comment"># [1,3,3],[2,2,2],[2,2,3],[2,3,3],[3,3,3]]</span>
|
|
670
|
+
a.repeated_combination(<span class="integer">4</span>).to_a <span class="comment">#=> [[1,1,1,1],[1,1,1,2],[1,1,1,3],[1,1,2,2],[1,1,2,3],</span>
|
|
671
|
+
<span class="comment"># [1,1,3,3],[1,2,2,2],[1,2,2,3],[1,2,3,3],[1,3,3,3],</span>
|
|
672
|
+
<span class="comment"># [2,2,2,2],[2,2,2,3],[2,2,3,3],[2,3,3,3],[3,3,3,3]]</span>
|
|
673
|
+
a.repeated_combination(<span class="integer">0</span>).to_a <span class="comment">#=> [[]] # one combination of length 0</span>
|
|
674
|
+
</pre></div>
|
|
675
|
+
</div>
|
|
676
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature75"><span class="anchor" id="public63"><span class="tag public">public</span></span> <span class="anchor" id="instance60"><span class="tag instance">60</span></span> Array#<span class="feature-name">repeated_permutation</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(n){|p| block}</code> → Array<div class="p">When invoked with a block, yield all repeated permutations of length <code class="inline">n</code> of the elements of the array, then return the array itself.</div><div class="p">The implementation makes no guarantees about the order in which the repeated permutations are yielded.</div><span class="head">Usage</span> <code class="inline">(n)</code> → Enumerator<div class="p">Examples:</div><div class="CodeRay">
|
|
677
|
+
<div class="code"><pre>a = [<span class="integer">1</span>, <span class="integer">2</span>]
|
|
678
|
+
a.repeated_permutation(<span class="integer">1</span>).to_a <span class="comment">#=> [[1], [2]]</span>
|
|
679
|
+
a.repeated_permutation(<span class="integer">2</span>).to_a <span class="comment">#=> [[1,1],[1,2],[2,1],[2,2]]</span>
|
|
680
|
+
a.repeated_permutation(<span class="integer">3</span>).to_a <span class="comment">#=> [[1,1,1],[1,1,2],[1,2,1],[1,2,2],</span>
|
|
681
|
+
<span class="comment"># [2,1,1],[2,1,2],[2,2,1],[2,2,2]]</span>
|
|
682
|
+
a.repeated_permutation(<span class="integer">0</span>).to_a <span class="comment">#=> [[]] # one permutation of length 0</span>
|
|
683
|
+
</pre></div>
|
|
684
|
+
</div>
|
|
685
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature76"><span class="anchor" id="public64"><span class="tag public">public</span></span> <span class="anchor" id="instance61"><span class="tag instance">61</span></span> Array#<span class="feature-name">replace</span> (alias: <span class="feature-name">initialize_copy</span>)</h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(other_ary)</code> → Array<div class="p">Replaces the contents of <code class="inline">self</code> with the contents of <code class="inline">other_ary</code>, truncating or expanding if necessary.</div><div class="CodeRay">
|
|
686
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">e</span><span class="delimiter">"</span></span>]
|
|
687
|
+
a.replace([<span class="string"><span class="delimiter">"</span><span class="content">x</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">y</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">z</span><span class="delimiter">"</span></span>]) <span class="comment">#=> ["x", "y", "z"]</span>
|
|
688
|
+
a <span class="comment">#=> ["x", "y", "z"]</span>
|
|
689
|
+
</pre></div>
|
|
690
|
+
</div>
|
|
691
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature77"><span class="anchor" id="public65"><span class="tag public">public</span></span> <span class="anchor" id="instance62"><span class="tag instance">62</span></span> Array#<span class="feature-name">reverse</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Array<div class="p">Returns a new array containing <code class="inline">self</code>‘s elements in reverse order.</div><div class="CodeRay">
|
|
692
|
+
<div class="code"><pre>[<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>].reverse <span class="comment">#=> ["c", "b", "a"]</span>
|
|
693
|
+
[<span class="integer">1</span>].reverse <span class="comment">#=> [1]</span>
|
|
694
|
+
</pre></div>
|
|
695
|
+
</div>
|
|
696
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature78"><span class="anchor" id="public66"><span class="tag public">public</span></span> <span class="anchor" id="instance63"><span class="tag instance">63</span></span> Array#<span class="feature-name">reverse!</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Array<div class="p">Reverses <code class="inline">self</code> in place.</div><div class="CodeRay">
|
|
697
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
698
|
+
a.reverse! <span class="comment">#=> ["c", "b", "a"]</span>
|
|
699
|
+
a <span class="comment">#=> ["c", "b", "a"]</span>
|
|
700
|
+
</pre></div>
|
|
701
|
+
</div>
|
|
702
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature79"><span class="anchor" id="public67"><span class="tag public">public</span></span> <span class="anchor" id="instance64"><span class="tag instance">64</span></span> Array#<span class="feature-name">reverse_each</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Array<span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="p">Same as <code class="inline">#each</code>, but traverses <code class="inline">self</code> in reverse order.</div><div class="CodeRay">
|
|
703
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
704
|
+
a.reverse_each{|x| print x, <span class="string"><span class="delimiter">"</span><span class="content"> </span><span class="delimiter">"</span></span>}
|
|
705
|
+
</pre></div>
|
|
706
|
+
</div>
|
|
707
|
+
<div class="p">produces:</div><div class="CodeRay">
|
|
708
|
+
<div class="code"><pre>c b a
|
|
709
|
+
</pre></div>
|
|
710
|
+
</div>
|
|
711
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature80"><span class="anchor" id="public68"><span class="tag public">public</span></span> <span class="anchor" id="instance65"><span class="tag instance">65</span></span> Array#<span class="feature-name">rindex</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#index</code>.</div><span class="head">Usage</span> <code class="inline">(obj)</code> → Integer | <code class="inline">nil</code><div class="p">Returns the index of the last object in <code class="inline">self</code> <code class="inline">==</code> to <code class="inline">obj</code>. Returns <code class="inline">nil</code> if no match is found.</div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Integer | <code class="inline">nil</code><div class="p">Returns the index of the first object for which the block returns true, starting from the last object.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="CodeRay">
|
|
712
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
713
|
+
a.rindex(<span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>) <span class="comment">#=> 3</span>
|
|
714
|
+
a.rindex(<span class="string"><span class="delimiter">"</span><span class="content">z</span><span class="delimiter">"</span></span>) <span class="comment">#=> nil</span>
|
|
715
|
+
a.rindex{|x| x == <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>} <span class="comment">#=> 3</span>
|
|
716
|
+
</pre></div>
|
|
717
|
+
</div>
|
|
718
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature81"><span class="anchor" id="public69"><span class="tag public">public</span></span> <span class="anchor" id="instance66"><span class="tag instance">66</span></span> Array#<span class="feature-name">rotate</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(count=1)</code> → Array<div class="p">Returns a new array by rotating <code class="inline">self</code> so that the element at count is the first element of the new array.</div><div class="p">If count is negative then it rotates in the opposite direction, starting from the end of <code class="inline">self</code> where <code class="inline">-1</code> is the last element.</div><div class="CodeRay">
|
|
719
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>]
|
|
720
|
+
a.rotate <span class="comment">#=> ["b", "c", "d", "a"]</span>
|
|
721
|
+
a <span class="comment">#=> ["a", "b", "c", "d"]</span>
|
|
722
|
+
a.rotate(<span class="integer">2</span>) <span class="comment">#=> ["c", "d", "a", "b"]</span>
|
|
723
|
+
a.rotate(<span class="integer">-3</span>) <span class="comment">#=> ["b", "c", "d", "a"]</span>
|
|
724
|
+
</pre></div>
|
|
725
|
+
</div>
|
|
726
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature82"><span class="anchor" id="public70"><span class="tag public">public</span></span> <span class="anchor" id="instance67"><span class="tag instance">67</span></span> Array#<span class="feature-name">rotate!</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">(count=1)</code> → Array<div class="p">Rotates <code class="inline">self</code> in place so that the element at count comes first, and returns <code class="inline">self</code>.</div><div class="p">If count is negative, then it rotates in the opposite direction, starting from the end of the array where <code class="inline">-1</code> is the last element.</div><div class="CodeRay">
|
|
727
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>]
|
|
728
|
+
a.rotate! <span class="comment">#=> ["b", "c", "d", "a"]</span>
|
|
729
|
+
a <span class="comment">#=> ["b", "c", "d", "a"]</span>
|
|
730
|
+
a.rotate!(<span class="integer">2</span>) <span class="comment">#=> ["d", "a", "b", "c"]</span>
|
|
731
|
+
a.rotate!(<span class="integer">-3</span>) <span class="comment">#=> ["a", "b", "c", "d"]</span>
|
|
732
|
+
</pre></div>
|
|
733
|
+
</div>
|
|
734
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature83"><span class="anchor" id="public71"><span class="tag public">public</span></span> <span class="anchor" id="instance68"><span class="tag instance">68</span></span> Array#<span class="feature-name">sample</span></h2><div class="feature-contents"><div class="user-item"><div class="p">The elements are chosen by using random and unique indices into the array in order to ensure that an element doesn’t repeat itself unless the array already contained duplicate elements.</div><div class="p">If the array is empty the first form returns <code class="inline">nil</code> and the second form returns an empty array.</div><span class="head">Usage</span> <code class="inline"></code> → Object<div class="p">Chooses a random element from the array. If the array is empty,returns <code class="inline">nil</code>.</div><span class="head">Usage</span> <code class="inline">(n)</code> → Array<div class="p">Chooses <code class="inline">n</code> random elements from the array. If the array is empty, returns an empty array.</div><span class="head">Usage</span> <code class="inline">(random: rng)</code> → Object<span class="head">Usage</span> <code class="inline">(n, random: rng)</code> → Array<div class="p">The optional <code class="inline">rng</code> argument will be used as the random number generator.</div><div class="CodeRay">
|
|
735
|
+
<div class="code"><pre>a = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">4</span>, <span class="integer">5</span>, <span class="integer">6</span>, <span class="integer">7</span>, <span class="integer">8</span>, <span class="integer">9</span>, <span class="integer">10</span>]
|
|
736
|
+
a.sample <span class="comment">#=> 7</span>
|
|
737
|
+
a.sample(<span class="integer">4</span>) <span class="comment">#=> [6, 4, 2, 5]</span>
|
|
738
|
+
</pre></div>
|
|
739
|
+
</div>
|
|
740
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature84"><span class="anchor" id="public72"><span class="tag public">public</span></span> <span class="anchor" id="instance69"><span class="tag instance">69</span></span> Array#<span class="feature-name">select</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">Enumerable#select</code>.</div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Array<div class="p">Returns a new array containing all elements of ary for which the given block returns a true value.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="CodeRay">
|
|
741
|
+
<div class="code"><pre>[<span class="integer">1</span>,<span class="integer">2</span>,<span class="integer">3</span>,<span class="integer">4</span>,<span class="integer">5</span>].select{|num| num.even?} <span class="comment">#=> [2, 4]</span>
|
|
742
|
+
|
|
743
|
+
a = <span class="string"><span class="delimiter">%w{</span><span class="content">a b c d e f</span><span class="delimiter">}</span></span>
|
|
744
|
+
a.select{|v| v =~ <span class="regexp"><span class="delimiter">/</span><span class="content">[aeiou]</span><span class="delimiter">/</span></span>} <span class="comment">#=> ["a", "e"]</span>
|
|
745
|
+
</pre></div>
|
|
746
|
+
</div>
|
|
747
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature85"><span class="anchor" id="public73"><span class="tag public">public</span></span> <span class="anchor" id="instance70"><span class="tag instance">70</span></span> Array#<span class="feature-name">select!</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#keep_if</code></div><span class="head">Usage</span> <code class="inline">{|item| block}</code> → Array | <code class="inline">nil</code><div class="p">Invokes the given block passing in successive elements from <code class="inline">self</code>, deleting elements for which the block returns a false value.</div><div class="p">If changes were made, it will return <code class="inline">self</code>, otherwise it returns <code class="inline">nil</code>.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature86"><span class="anchor" id="public74"><span class="tag public">public</span></span> <span class="anchor" id="instance71"><span class="tag instance">71</span></span> Array#<span class="feature-name">shift</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#unshift</code> for the opposite effect.</div><span class="head">Usage</span> <code class="inline"></code> → Object | <code class="inline">nil</code><div class="p">Removes the first element of <code class="inline">self</code> and returns it (shifting all other elements down by one). Returns <code class="inline">nil</code> if the array is empty.</div><span class="head">Usage</span> <code class="inline">(n)</code> → Array<div class="p">Returns an array of the first <code class="inline">n</code> elements (or less) just like <code class="inline">array.slice!(0, n)</code> does. With <code class="inline">ary</code> containing only the remainder elements, not including what was shifted to <code class="inline">new_ary</code>.</div><div class="CodeRay">
|
|
748
|
+
<div class="code"><pre>args = [<span class="string"><span class="delimiter">"</span><span class="content">-m</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">-q</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">filename</span><span class="delimiter">"</span></span>]
|
|
749
|
+
args.shift <span class="comment">#=> "-m"</span>
|
|
750
|
+
args <span class="comment">#=> ["-q", "filename"]</span>
|
|
751
|
+
|
|
752
|
+
args = [<span class="string"><span class="delimiter">"</span><span class="content">-m</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">-q</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">filename</span><span class="delimiter">"</span></span>]
|
|
753
|
+
args.shift(<span class="integer">2</span>) <span class="comment">#=> ["-m", "-q"]</span>
|
|
754
|
+
args <span class="comment">#=> ["filename"]</span>
|
|
755
|
+
</pre></div>
|
|
756
|
+
</div>
|
|
757
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature87"><span class="anchor" id="public75"><span class="tag public">public</span></span> <span class="anchor" id="instance72"><span class="tag instance">72</span></span> Array#<span class="feature-name">shuffle</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Array<div class="p">Returns a new array with elements of <code class="inline">self</code> shuffled.</div><div class="CodeRay">
|
|
758
|
+
<div class="code"><pre>a = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>] <span class="comment">#=> [1, 2, 3]</span>
|
|
759
|
+
a.shuffle <span class="comment">#=> [2, 3, 1]</span>
|
|
760
|
+
</pre></div>
|
|
761
|
+
</div>
|
|
762
|
+
<span class="head">Usage</span> <code class="inline">(random: rng)</code> → Array<div class="p">The optional <code class="inline">rng</code> argument will be used as the random number generator.</div><div class="CodeRay">
|
|
763
|
+
<div class="code"><pre>a.shuffle(<span class="key">random</span>: <span class="constant">Random</span>.new(<span class="integer">1</span>)) <span class="comment">#=> [1, 3, 2]</span>
|
|
764
|
+
</pre></div>
|
|
765
|
+
</div>
|
|
766
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature88"><span class="anchor" id="public76"><span class="tag public">public</span></span> <span class="anchor" id="instance73"><span class="tag instance">73</span></span> Array#<span class="feature-name">shuffle!</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Array<div class="p">Shuffles elements in <code class="inline">self</code> in place.</div><span class="head">Usage</span> <code class="inline">(random: rng)</code> → Array<div class="p">The optional <code class="inline">rng</code> argument will be used as the random number generator.</div></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature89"><span class="anchor" id="public77"><span class="tag public">public</span></span> <span class="anchor" id="instance74"><span class="tag instance">74</span></span> Array#<span class="feature-name">size</span></h2><div class="feature-contents"><div class="user-item"><div class="p">Alias for: <code class="inline">length</code></div></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature90"><span class="anchor" id="public78"><span class="tag public">public</span></span> <span class="anchor" id="instance75"><span class="tag instance">75</span></span> Array#<span class="feature-name">slice</span></h2><div class="feature-contents"><div class="user-item"><div class="p">Element Reference</div><div class="p">Negative indices count backward from the end of the array (<code class="inline">-1</code> is the last element).</div><div class="p">Returns <code class="inline">nil</code> if the index (or starting index) are out of range.</div><span class="head">Usage</span> <code class="inline">(index)</code> → Object | <code class="inline">nil</code><div class="p">Returns the element at <code class="inline">index</code>.</div><span class="head">Usage</span> <code class="inline">(start, length)</code> → Array | <code class="inline">nil</code><span class="head">Usage</span> <code class="inline">(range)</code> → Array | <code class="inline">nil</code><div class="p">Returns a subarray starting at the <code class="inline">start</code> index and continuing for <code class="inline">length</code> elements, or a subarray specified by <code class="inline">range</code> of indices.</div><div class="p">The starting index is just before an element.</div><div class="p">An empty array is returned when the starting index for an element range is at the end of the array.</div><div class="CodeRay">
|
|
767
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">e</span><span class="delimiter">"</span></span>]
|
|
768
|
+
a[<span class="integer">2</span>] + a[<span class="integer">0</span>] + a[<span class="integer">1</span>] <span class="comment">#=> "cab"</span>
|
|
769
|
+
a[<span class="integer">6</span>] <span class="comment">#=> nil</span>
|
|
770
|
+
a[<span class="integer">1</span>, <span class="integer">2</span>] <span class="comment">#=> ["b", "c"]</span>
|
|
771
|
+
a[<span class="integer">1</span>..<span class="integer">3</span>] <span class="comment">#=> ["b", "c", "d"]</span>
|
|
772
|
+
a[<span class="integer">4</span>..<span class="integer">7</span>] <span class="comment">#=> ["e"]</span>
|
|
773
|
+
a[<span class="integer">6</span>..<span class="integer">10</span>] <span class="comment">#=> nil</span>
|
|
774
|
+
a[<span class="integer">-3</span>, <span class="integer">3</span>] <span class="comment">#=> ["c", "d", "e"]</span>
|
|
775
|
+
<span class="comment"># special cases</span>
|
|
776
|
+
a[<span class="integer">5</span>] <span class="comment">#=> nil</span>
|
|
777
|
+
a[<span class="integer">6</span>, <span class="integer">1</span>] <span class="comment">#=> nil</span>
|
|
778
|
+
a[<span class="integer">5</span>, <span class="integer">1</span>] <span class="comment">#=> []</span>
|
|
779
|
+
a[<span class="integer">5</span>..<span class="integer">10</span>] <span class="comment">#=> []</span>
|
|
780
|
+
</pre></div>
|
|
781
|
+
</div>
|
|
782
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature91"><span class="anchor" id="public79"><span class="tag public">public</span></span> <span class="anchor" id="instance76"><span class="tag instance">76</span></span> Array#<span class="feature-name">slice!</span></h2><div class="feature-contents"><div class="user-item"><div class="p">Returns the deleted object (or objects), or <code class="inline">nil</code> if the index is out of range.</div><span class="head">Usage</span> <code class="inline">(index)</code> → Object | <code class="inline">nil</code><div class="p">Deletes the element given by an index.</div><span class="head">Usage</span> <code class="inline">(start, length)</code> → Array | <code class="inline">nil</code><span class="head">Usage</span> <code class="inline">(range)</code> → Array | <code class="inline">nil</code><div class="p">Deletes the element(s) given by an index up to <code class="inline">length</code> elements or by <code class="inline">range</code>.</div><div class="CodeRay">
|
|
783
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
784
|
+
a.slice!(<span class="integer">1</span>) <span class="comment">#=> "b"</span>
|
|
785
|
+
a <span class="comment">#=> ["a", "c"]</span>
|
|
786
|
+
a.slice!(<span class="integer">-1</span>) <span class="comment">#=> "c"</span>
|
|
787
|
+
a <span class="comment">#=> ["a"]</span>
|
|
788
|
+
a.slice!(<span class="integer">100</span>) <span class="comment">#=> nil</span>
|
|
789
|
+
a <span class="comment">#=> ["a"]</span>
|
|
790
|
+
</pre></div>
|
|
791
|
+
</div>
|
|
792
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature92"><span class="anchor" id="public80"><span class="tag public">public</span></span> <span class="anchor" id="instance77"><span class="tag instance">77</span></span> Array#<span class="feature-name">sort</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">Enumerable#sort_by</code>.</div><div class="p">Returns a new array created by sorting <code class="inline">self</code>.</div><span class="head">Usage</span> <code class="inline"></code> → Array<div class="p">Comparisons for the <code class="inline">sort</code> will be done using the <code class="inline"><=></code> operator.</div><span class="head">Usage</span> <code class="inline">{|a, b| block}</code> → Array<div class="p">Comparisons for the <code class="inline">sort</code> will be done using the code block.</div><div class="p">The block must implement a comparison between <code class="inline">a</code> and <code class="inline">b</code>, and return <code class="inline">-1</code>, when <code class="inline">a</code> follows <code class="inline">b</code>, <code class="inline">0</code> when <code class="inline">a</code> and <code class="inline">b</code> are equivalent, or <code class="inline">+1</code> if <code class="inline">b</code> follows <code class="inline">a</code>.</div><div class="CodeRay">
|
|
793
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">e</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>]
|
|
794
|
+
a.sort <span class="comment">#=> ["a", "b", "c", "d", "e"]</span>
|
|
795
|
+
a.sort{|x,y| y <=> x} <span class="comment">#=> ["e", "d", "c", "b", "a"]</span>
|
|
796
|
+
</pre></div>
|
|
797
|
+
</div>
|
|
798
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature93"><span class="anchor" id="public81"><span class="tag public">public</span></span> <span class="anchor" id="instance78"><span class="tag instance">78</span></span> Array#<span class="feature-name">sort!</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">Enumerable#sort_by</code>.</div><div class="p">Sorts <code class="inline">self</code> in place.</div><span class="head">Usage</span> <code class="inline"></code> → Array<div class="p">Comparisons for the <code class="inline">sort</code> will be done using the <code class="inline"><=></code> operator.</div><span class="head">Usage</span> <code class="inline">{|a, b| block}</code> → Array<div class="p">Comparisons for the <code class="inline">sort</code> will be done using the code block.</div><div class="p">The block must implement a comparison between <code class="inline">a</code> and <code class="inline">b</code>, and return <code class="inline">-1</code>, when <code class="inline">a</code> follows <code class="inline">b</code>, <code class="inline">0</code> when <code class="inline">a</code> and <code class="inline">b</code> are equivalent, or <code class="inline">+1</code> if <code class="inline">b</code> follows <code class="inline">a</code>.</div><div class="CodeRay">
|
|
799
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">e</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>]
|
|
800
|
+
a.sort! <span class="comment">#=> ["a", "b", "c", "d", "e"]</span>
|
|
801
|
+
a.sort!{|x,y| y <=> x} <span class="comment">#=> ["e", "d", "c", "b", "a"]</span>
|
|
802
|
+
</pre></div>
|
|
803
|
+
</div>
|
|
804
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature94"><span class="anchor" id="public82"><span class="tag public">public</span></span> <span class="anchor" id="instance79"><span class="tag instance">79</span></span> Array#<span class="feature-name">sort_by!</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline">{|obj| block}</code> → Array<div class="p">Sorts <code class="inline">self</code> in place using a set of keys generated by mapping the values in self through the given block.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature95"><span class="anchor" id="public83"><span class="tag public">public</span></span> <span class="anchor" id="instance80"><span class="tag instance">80</span></span> Array#<span class="feature-name">take</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#drop</code></div><span class="head">Usage</span> <code class="inline">(n)</code> → Array<div class="p">Returns first <code class="inline">n</code> elements from the array.</div><div class="p">If a negative number is given, raises an <code class="inline">ArgumentError</code>.</div><div class="CodeRay">
|
|
805
|
+
<div class="code"><pre>a = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">4</span>, <span class="integer">5</span>, <span class="integer">0</span>]
|
|
806
|
+
a.take(<span class="integer">3</span>) <span class="comment">#=> [1, 2, 3]</span>
|
|
807
|
+
</pre></div>
|
|
808
|
+
</div>
|
|
809
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature96"><span class="anchor" id="public84"><span class="tag public">public</span></span> <span class="anchor" id="instance81"><span class="tag instance">81</span></span> Array#<span class="feature-name">take_while</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#drop_while</code></div><span class="head">Usage</span> <code class="inline">{|arr| block}</code> → Array<div class="p">Passes elements to the block until the block returns <code class="inline">nil</code> or <code class="inline">false</code>, then stops iterating and returns an array of all prior elements.</div><span class="head">Usage</span> <code class="inline"></code> → Enumerator<div class="CodeRay">
|
|
810
|
+
<div class="code"><pre>a = [<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>, <span class="integer">4</span>, <span class="integer">5</span>, <span class="integer">0</span>]
|
|
811
|
+
a.take_while{|i| i < <span class="integer">3</span>} <span class="comment">#=> [1, 2]</span>
|
|
812
|
+
</pre></div>
|
|
813
|
+
</div>
|
|
814
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature97"><span class="anchor" id="public85"><span class="tag public">public</span></span> <span class="anchor" id="instance82"><span class="tag instance">82</span></span> Array#<span class="feature-name">to_a</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Array<div class="p">Returns <code class="inline">self</code>.</div><div class="p">If called on a subclass of <code class="inline">Array</code>, converts the receiver to an <code class="inline">Array</code> object.</div></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature98"><span class="anchor" id="public86"><span class="tag public">public</span></span> <span class="anchor" id="instance83"><span class="tag instance">83</span></span> Array#<span class="feature-name">to_ary</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Array<div class="p">Returns <code class="inline">self</code>.</div></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature99"><span class="anchor" id="public87"><span class="tag public">public</span></span> <span class="anchor" id="instance84"><span class="tag instance">84</span></span> Array#<span class="feature-name">to_h</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Hash<div class="p">Returns the result of interpreting <code class="inline">ary</code> as an array of <code class="inline">[key, value]</code> pairs.</div><div class="CodeRay">
|
|
815
|
+
<div class="code"><pre>[[<span class="symbol">:foo</span>, <span class="symbol">:bar</span>], [<span class="integer">1</span>, <span class="integer">2</span>]].to_h
|
|
816
|
+
<span class="comment"># => {:foo => :bar, 1 => 2}</span>
|
|
817
|
+
</pre></div>
|
|
818
|
+
</div>
|
|
819
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature100"><span class="anchor" id="public88"><span class="tag public">public</span></span> <span class="anchor" id="instance85"><span class="tag instance">85</span></span> Array#<span class="feature-name">to_s</span></h2><div class="feature-contents"><div class="user-item"><div class="p">Alias for: <code class="inline">inspect</code>.</div></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature101"><span class="anchor" id="public89"><span class="tag public">public</span></span> <span class="anchor" id="instance86"><span class="tag instance">86</span></span> Array#<span class="feature-name">transpose</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Array<div class="p">Assumes that <code class="inline">self</code> is an array of arrays and transposes the rows and columns.</div><div class="CodeRay">
|
|
820
|
+
<div class="code"><pre>a = [[<span class="integer">1</span>,<span class="integer">2</span>], [<span class="integer">3</span>,<span class="integer">4</span>], [<span class="integer">5</span>,<span class="integer">6</span>]]
|
|
821
|
+
a.transpose <span class="comment">#=> [[1, 3, 5], [2, 4, 6]]</span>
|
|
822
|
+
</pre></div>
|
|
823
|
+
</div>
|
|
824
|
+
<div class="p">If the length of the subarrays don’t match, an <code class="inline">IndexError</code> is raised.</div></div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature102"><span class="anchor" id="public90"><span class="tag public">public</span></span> <span class="anchor" id="instance87"><span class="tag instance">87</span></span> Array#<span class="feature-name">uniq</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Array<div class="p">Returns a new array by removing duplicate values in <code class="inline">self</code>.</div><div class="p">It compares values using their hash and eql? methods for efficiency.</div><span class="head">Usage</span> <code class="inline">{|item| ...}</code> → Array<div class="p">It will use the return value of the block for comparison.</div><div class="CodeRay">
|
|
825
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
826
|
+
a.uniq <span class="comment"># => ["a", "b", "c"]</span>
|
|
827
|
+
|
|
828
|
+
b = [[<span class="string"><span class="delimiter">"</span><span class="content">student</span><span class="delimiter">"</span></span>,<span class="string"><span class="delimiter">"</span><span class="content">sam</span><span class="delimiter">"</span></span>], [<span class="string"><span class="delimiter">"</span><span class="content">student</span><span class="delimiter">"</span></span>,<span class="string"><span class="delimiter">"</span><span class="content">george</span><span class="delimiter">"</span></span>], [<span class="string"><span class="delimiter">"</span><span class="content">teacher</span><span class="delimiter">"</span></span>,<span class="string"><span class="delimiter">"</span><span class="content">matz</span><span class="delimiter">"</span></span>]]
|
|
829
|
+
b.uniq{|s| s.first} <span class="comment"># => [["student", "sam"], ["teacher", "matz"]]</span>
|
|
830
|
+
</pre></div>
|
|
831
|
+
</div>
|
|
832
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature103"><span class="anchor" id="public91"><span class="tag public">public</span></span> <span class="anchor" id="instance88"><span class="tag instance">88</span></span> Array#<span class="feature-name">uniq!</span></h2><div class="feature-contents"><div class="user-item"><span class="head">Usage</span> <code class="inline"></code> → Array | <code class="inline">nil</code><div class="p">Removes duplicate elements from <code class="inline">self</code>.</div><div class="p">It compares values using their <code class="inline">hash</code> and <code class="inline">eql?</code> methods for efficiency.</div><div class="p">Returns <code class="inline">nil</code> if no changes are made (that is, no duplicates are found).</div><span class="head">Usage</span> <code class="inline">{|item| ...}</code> → Array | <code class="inline">nil</code><div class="p">It will use the return value of the block for comparison.</div><div class="CodeRay">
|
|
833
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
834
|
+
a.uniq! <span class="comment"># => ["a", "b", "c"]</span>
|
|
835
|
+
|
|
836
|
+
b = [<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>]
|
|
837
|
+
b.uniq! <span class="comment"># => nil</span>
|
|
838
|
+
|
|
839
|
+
c = [[<span class="string"><span class="delimiter">"</span><span class="content">student</span><span class="delimiter">"</span></span>,<span class="string"><span class="delimiter">"</span><span class="content">sam</span><span class="delimiter">"</span></span>], [<span class="string"><span class="delimiter">"</span><span class="content">student</span><span class="delimiter">"</span></span>,<span class="string"><span class="delimiter">"</span><span class="content">george</span><span class="delimiter">"</span></span>], [<span class="string"><span class="delimiter">"</span><span class="content">teacher</span><span class="delimiter">"</span></span>,<span class="string"><span class="delimiter">"</span><span class="content">matz</span><span class="delimiter">"</span></span>]]
|
|
840
|
+
c.uniq!{|s| s.first} <span class="comment"># => [["student", "sam"], ["teacher", "matz"]]</span>
|
|
841
|
+
</pre></div>
|
|
842
|
+
</div>
|
|
843
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature104"><span class="anchor" id="public92"><span class="tag public">public</span></span> <span class="anchor" id="instance89"><span class="tag instance">89</span></span> Array#<span class="feature-name">unshift</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#shift</code> for the opposite effect.</div><span class="head">Usage</span> <code class="inline">(obj, ...)</code> → Array<div class="p">Prepends objects to the front of <code class="inline">self</code>, moving other elements upwards.</div><div class="CodeRay">
|
|
844
|
+
<div class="code"><pre>a = [<span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>]
|
|
845
|
+
a.unshift(<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>) <span class="comment">#=> ["a", "b", "c", "d"]</span>
|
|
846
|
+
a.unshift(<span class="integer">1</span>, <span class="integer">2</span>) <span class="comment">#=> [1, 2, "a", "b", "c", "d"]</span>
|
|
847
|
+
</pre></div>
|
|
848
|
+
</div>
|
|
849
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature105"><span class="anchor" id="public93"><span class="tag public">public</span></span> <span class="anchor" id="instance90"><span class="tag instance">90</span></span> Array#<span class="feature-name">values_at</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#select</code>.</div><span class="head">Usage</span> <code class="inline">(selector, ...)</code> → Array<div class="p">Returns an array containing the elements in <code class="inline">self</code> corresponding to the given selector(s).</div><div class="p">The selectors may be either integer indices or ranges.</div><div class="CodeRay">
|
|
850
|
+
<div class="code"><pre>a = <span class="string"><span class="delimiter">%w{</span><span class="content">a b c d e f</span><span class="delimiter">}</span></span>
|
|
851
|
+
a.values_at(<span class="integer">1</span>, <span class="integer">3</span>, <span class="integer">5</span>) <span class="comment"># => ["b", "d", "f"]</span>
|
|
852
|
+
a.values_at(<span class="integer">1</span>, <span class="integer">3</span>, <span class="integer">5</span>, <span class="integer">7</span>) <span class="comment"># => ["b", "d", "f", nil]</span>
|
|
853
|
+
a.values_at(<span class="integer">-1</span>, <span class="integer">-2</span>, <span class="integer">-2</span>, <span class="integer">-7</span>) <span class="comment"># => ["f", "e", "e", nil]</span>
|
|
854
|
+
a.values_at(<span class="integer">4</span>..<span class="integer">6</span>, <span class="integer">3</span>...<span class="integer">6</span>) <span class="comment"># => ["e", "f", nil, "d", "e", "f"]</span>
|
|
855
|
+
</pre></div>
|
|
856
|
+
</div>
|
|
857
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature106"><span class="anchor" id="public94"><span class="tag public">public</span></span> <span class="anchor" id="instance91"><span class="tag instance">91</span></span> Array#<span class="feature-name">zip</span></h2><div class="feature-contents"><div class="user-item"><div class="p">Converts any arguments to arrays, then merges elements of self with corresponding elements from each argument.</div><div class="p">This generates a sequence of <code class="inline">ary.size</code> n-element arrays, where n is one more than the count of arguments.</div><div class="p">If the size of any argument is less than the size of the initial array, <code class="inline">nil</code> values are supplied.</div><span class="head">Usage</span> <code class="inline">(arg, ...)</code> → Array<div class="p">An array of arrays is returned.</div><span class="head">Usage</span> <code class="inline">(arg, ...){|arr| block}</code> → NilClass<div class="p">It is invoked for each output array.</div><div class="CodeRay">
|
|
858
|
+
<div class="code"><pre>a = [<span class="integer">4</span>, <span class="integer">5</span>, <span class="integer">6</span>]
|
|
859
|
+
b = [<span class="integer">7</span>, <span class="integer">8</span>, <span class="integer">9</span>]
|
|
860
|
+
[<span class="integer">1</span>, <span class="integer">2</span>, <span class="integer">3</span>].zip(a, b) <span class="comment">#=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]</span>
|
|
861
|
+
[<span class="integer">1</span>, <span class="integer">2</span>].zip(a, b) <span class="comment">#=> [[1, 4, 7], [2, 5, 8]]</span>
|
|
862
|
+
a.zip([<span class="integer">1</span>, <span class="integer">2</span>], [<span class="integer">8</span>]) <span class="comment">#=> [[4, 1, 8], [5, 2, nil], [6, nil, nil]]</span>
|
|
863
|
+
</pre></div>
|
|
864
|
+
</div>
|
|
865
|
+
</div></div></div><div class="feature" onclick="toggleFeatureContents(this)"><h2 id="feature107"><span class="anchor" id="public95"><span class="tag public">public</span></span> <span class="anchor" id="instance92"><span class="tag instance">92</span></span> Array#<span class="feature-name">|</span></h2><div class="feature-contents"><div class="user-item"><div class="p">See also <code class="inline">#uniq</code>.</div><span class="head">Usage</span> <code class="inline">other_ary</code> → Array<div class="p">Set Union — Returns a new array by joining <code class="inline">ary</code> with <code class="inline">other_ary</code>, excluding any duplicates and preserving the order from the original array.</div><div class="p">It compares elements using their <code class="inline">hash</code> and <code class="inline">eql?</code> methods for efficiency.</div><div class="CodeRay">
|
|
866
|
+
<div class="code"><pre>[<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>] | [<span class="string"><span class="delimiter">"</span><span class="content">c</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">d</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>] <span class="comment">#=> ["a", "b", "c", "d"]</span>
|
|
867
|
+
</pre></div>
|
|
868
|
+
</div>
|
|
869
|
+
</div></div></div></div><div class="module"><div class="feature" onclick="toggleModuleContents(this)"><h1 class="module-header" id="feature108"><span class="anchor" id="public96"><span class="tag public">public</span></span> class <span class="feature-name">String</span></h1><div class="feature-contents"></div></div><div class="feature"><h2 id="feature109"><span class="anchor" id="public97"><span class="tag public">public</span></span> <span class="anchor" id="instance93"><span class="tag instance">93</span></span> String#<span class="feature-name">split</span></h2><div class="feature-contents"></div></div></div></div></div><script>//-*-mode: javascript-*-
|
|
870
|
+
|
|
871
|
+
// Copyright (c) 2014-2016 sawa
|
|
872
|
+
|
|
873
|
+
var main;
|
|
874
|
+
var scrollMargin;
|
|
875
|
+
|
|
876
|
+
// Scroll to the anchor.
|
|
877
|
+
window.onhashchange = function(e) {
|
|
878
|
+
// location.href = location.hash;
|
|
879
|
+
// main.scrollTop -= main.offsetHeight * 0.5 + scrollMargin;
|
|
880
|
+
main.scrollTop -= scrollMargin;
|
|
881
|
+
};
|
|
882
|
+
|
|
883
|
+
document.body.onload = function() {
|
|
884
|
+
main = document.getElementById('main');
|
|
885
|
+
//This line is needed to invoke `window.onhashchange` even when `location.hash`
|
|
886
|
+
// is the same as the previous load.
|
|
887
|
+
location.hash = '';
|
|
888
|
+
//TODO. Import data from webstore.
|
|
889
|
+
//location.hash =
|
|
890
|
+
var joinQuery = function(obj, prefix, affix){
|
|
891
|
+
return prefix + obj.dataset.tags.split(' ').join(affix + ', ' + prefix) + affix;
|
|
892
|
+
}
|
|
893
|
+
var tagsumPrefix = '#tagsum-', tagsumAffix = ':not([style="opacity: 0.2;"])';
|
|
894
|
+
var i, obj, query;
|
|
895
|
+
query = '.feature:not([style="display: none;"]) .tag.';
|
|
896
|
+
for(i = 1; obj = document.getElementById('user-feature-navigation' + i); i++) {
|
|
897
|
+
obj.query = joinQuery(obj, query, '');
|
|
898
|
+
obj.tagsums = joinQuery(obj, tagsumPrefix, tagsumAffix);
|
|
899
|
+
initializeNavigation(obj);
|
|
900
|
+
}
|
|
901
|
+
for(i = 1; obj = document.getElementById('dev-feature-navigation' + i); i++) {
|
|
902
|
+
obj.query = joinQuery(obj, query, '');
|
|
903
|
+
obj.tagsums = joinQuery(obj, tagsumPrefix, tagsumAffix);
|
|
904
|
+
initializeNavigation(obj);
|
|
905
|
+
}
|
|
906
|
+
query = '\
|
|
907
|
+
.feature:not([style="display: none;"]):not([folded="true"]) \
|
|
908
|
+
.feature-contents > :not([style="display: none;"]) \
|
|
909
|
+
.anchor:not([style="display: none;"]) \
|
|
910
|
+
.tag.';
|
|
911
|
+
for(i = 1; obj = document.getElementById('anchor-navigation' + i); i++) {
|
|
912
|
+
obj.query = joinQuery(obj, query, '');
|
|
913
|
+
obj.tagsums = joinQuery(obj, tagsumPrefix, tagsumAffix);
|
|
914
|
+
initializeNavigation(obj);
|
|
915
|
+
}
|
|
916
|
+
var objs = document.getElementsByClassName('feature');
|
|
917
|
+
for(var i = 0; i < objs.length; i++) {
|
|
918
|
+
// TODO. copy from webstore if any.
|
|
919
|
+
objs[i].hiddenFor = {};
|
|
920
|
+
// hide(objs[i], Object.keys(objs[i].hiddenFor).length);
|
|
921
|
+
}
|
|
922
|
+
switch(document.body.id){
|
|
923
|
+
case 'user':
|
|
924
|
+
scrollMargin = 200;
|
|
925
|
+
// Click "Features" button.
|
|
926
|
+
document.getElementById('top').children[0].children[1].onclick();
|
|
927
|
+
break;
|
|
928
|
+
case 'dev':
|
|
929
|
+
// Approximates half of line height from experience. TODO: Do it logically.
|
|
930
|
+
scrollMargin = 200;
|
|
931
|
+
// Click "Full" button. (Neccessary to do this also for adding `folded` attribute)
|
|
932
|
+
document.getElementById('top').children[0].children[2].onclick();
|
|
933
|
+
break;
|
|
934
|
+
}
|
|
935
|
+
// Prevents feature toggling.
|
|
936
|
+
// Overwriting `onclick` does not interfere with linking to `href`; it is different from `onclick`.
|
|
937
|
+
var objs = document.getElementsByTagName('a');
|
|
938
|
+
for(var i = 0; i < objs.length; i++) objs[i].onclick = function(e) {e.stopPropagation();};
|
|
939
|
+
};
|
|
940
|
+
|
|
941
|
+
initializeNavigation = function(obj) {
|
|
942
|
+
obj.features = document.querySelectorAll(obj.query);
|
|
943
|
+
var sum = obj.features.length;
|
|
944
|
+
obj.querySelector('.sum').innerText = sum;
|
|
945
|
+
var excluded = -sum;
|
|
946
|
+
var objs = document.querySelectorAll(obj.tagsums);
|
|
947
|
+
for(var i = 0; i < objs.length; i++) excluded += parseInt(objs[i].innerText);
|
|
948
|
+
obj.querySelector('.excluded').innerText = excluded;
|
|
949
|
+
var current = obj.querySelector('.current');
|
|
950
|
+
if(sum == 0) {
|
|
951
|
+
current.innerText = 1;
|
|
952
|
+
} else {if(parseInt(current.innerText) > sum
|
|
953
|
+
) current.innerText = sum;
|
|
954
|
+
};
|
|
955
|
+
};
|
|
956
|
+
|
|
957
|
+
initializeNavigations = function() {
|
|
958
|
+
for(var i = 1, obj; obj = document.getElementById('user-feature-navigation' + i); i++
|
|
959
|
+
) initializeNavigation(obj);
|
|
960
|
+
for(var i = 1, obj; obj = document.getElementById('dev-feature-navigation' + i); i++
|
|
961
|
+
) initializeNavigation(obj);
|
|
962
|
+
for(var i = 1, obj; obj = document.getElementById('anchor-navigation' + i); i++
|
|
963
|
+
) initializeNavigation(obj);
|
|
964
|
+
};
|
|
965
|
+
|
|
966
|
+
getFeatureNodeFromId = function(id) {
|
|
967
|
+
var obj = document.getElementById(id);
|
|
968
|
+
if(!obj) return null;
|
|
969
|
+
while(true) {
|
|
970
|
+
if(obj.className == 'feature') return obj;
|
|
971
|
+
obj = obj.parentNode;
|
|
972
|
+
if(!obj) return null;
|
|
973
|
+
}
|
|
974
|
+
};
|
|
975
|
+
|
|
976
|
+
getIdFromObj = function(obj) {
|
|
977
|
+
while(true) {
|
|
978
|
+
if(obj.id) return obj.id;
|
|
979
|
+
obj = obj.parentNode;
|
|
980
|
+
if(!obj) return null;
|
|
981
|
+
}
|
|
982
|
+
};
|
|
983
|
+
|
|
984
|
+
hide = function(obj, bool) {obj.style.display = bool ? 'none' : null;};
|
|
985
|
+
|
|
986
|
+
inactivate = function(obj, bool) {obj.style.opacity = bool ? 0.2 : null;};
|
|
987
|
+
|
|
988
|
+
mark = function(obj, bool) {return obj.marking = bool;};
|
|
989
|
+
|
|
990
|
+
toggleMarking = function(obj) {return obj.marking = !obj.marking;};
|
|
991
|
+
|
|
992
|
+
hideByTag = function(obj, tag, bool) {
|
|
993
|
+
if(bool) {obj.hiddenFor[tag] = true;} else {delete obj.hiddenFor[tag];};
|
|
994
|
+
hide(obj, Object.keys(obj.hiddenFor).length);
|
|
995
|
+
};
|
|
996
|
+
|
|
997
|
+
foldModuleContents = function(obj, bool){
|
|
998
|
+
obj.firstChild.setAttribute('folded', bool);
|
|
999
|
+
var objs = obj.childNodes;
|
|
1000
|
+
foldFeatureContents(objs[0], bool);
|
|
1001
|
+
// From the second children.
|
|
1002
|
+
for (var i = 1; i < objs.length; i++) hideByTag(objs[i], 'folded', bool);
|
|
1003
|
+
return bool;
|
|
1004
|
+
};
|
|
1005
|
+
|
|
1006
|
+
foldFeatureContents = function(obj, bool){
|
|
1007
|
+
obj.setAttribute('folded', bool);
|
|
1008
|
+
hide(obj.firstChild.nextSibling, bool);
|
|
1009
|
+
return bool;
|
|
1010
|
+
};
|
|
1011
|
+
|
|
1012
|
+
displayMode = function(bool1, bool2) {
|
|
1013
|
+
var objs = document.getElementsByClassName('module');
|
|
1014
|
+
for(var i = 0; i < objs.length; i++) foldModuleContents(objs[i], mark(objs[i], bool1));
|
|
1015
|
+
// `[onclick]`: Features with `type` `:module_as_constant` are not clickable.
|
|
1016
|
+
// `:not(:first-child)`: Don't fold module headers here.
|
|
1017
|
+
var objs = document.querySelectorAll('.feature[onclick]:not(:first-child)');
|
|
1018
|
+
for(var i = 0; i < objs.length; i++) foldFeatureContents(objs[i], mark(objs[i], bool2));
|
|
1019
|
+
initializeNavigations();
|
|
1020
|
+
};
|
|
1021
|
+
|
|
1022
|
+
toggleModuleContents = function(feature) {
|
|
1023
|
+
var module = feature.parentNode;
|
|
1024
|
+
var bool = foldModuleContents(module, toggleMarking(module));
|
|
1025
|
+
if(bool) {
|
|
1026
|
+
module.scrollIntoView();
|
|
1027
|
+
window.onhashchange();
|
|
1028
|
+
}
|
|
1029
|
+
initializeNavigations();
|
|
1030
|
+
};
|
|
1031
|
+
|
|
1032
|
+
toggleFeatureContents = function(feature) {
|
|
1033
|
+
var bool = foldFeatureContents(feature, toggleMarking(feature));
|
|
1034
|
+
if(bool) {
|
|
1035
|
+
feature.scrollIntoView();
|
|
1036
|
+
window.onhashchange();
|
|
1037
|
+
}
|
|
1038
|
+
initializeNavigations();
|
|
1039
|
+
};
|
|
1040
|
+
|
|
1041
|
+
toggleUserItems = function(button) {
|
|
1042
|
+
// recordScrollPosition();
|
|
1043
|
+
var bool = toggleMarking(button);
|
|
1044
|
+
inactivate(button, bool);
|
|
1045
|
+
objs = document.getElementsByClassName('user-item');
|
|
1046
|
+
for(i = 0; i < objs.length; i++) hide(objs[i], bool);
|
|
1047
|
+
initializeNavigations();
|
|
1048
|
+
// resumeScrollPosition();
|
|
1049
|
+
};
|
|
1050
|
+
|
|
1051
|
+
toggleFeatures = function(button, tag, navigation) {
|
|
1052
|
+
// recordScrollPosition();
|
|
1053
|
+
var bool = toggleMarking(button);
|
|
1054
|
+
inactivate(button, bool);
|
|
1055
|
+
inactivate(document.getElementById('tagsum-' + tag), bool);
|
|
1056
|
+
for(var i = 1, obj; obj = getFeatureNodeFromId(tag + i); i ++) hideByTag(obj, tag, bool);
|
|
1057
|
+
navigation = document.getElementById(navigation);
|
|
1058
|
+
initializeNavigations();
|
|
1059
|
+
// resumeScrollPosition();
|
|
1060
|
+
};
|
|
1061
|
+
|
|
1062
|
+
toggleAnchors = function(button, tag, navigation) {
|
|
1063
|
+
// recordScrollPosition();
|
|
1064
|
+
var bool = toggleMarking(button);
|
|
1065
|
+
inactivate(button, bool);
|
|
1066
|
+
inactivate(document.getElementById('tagsum-' + tag), bool);
|
|
1067
|
+
for(var i = 1, obj; obj = document.getElementById(tag + i); i ++) hide(obj, bool);
|
|
1068
|
+
navigation = document.getElementById(navigation);
|
|
1069
|
+
initializeNavigation(navigation);
|
|
1070
|
+
// resumeScrollPosition();
|
|
1071
|
+
};
|
|
1072
|
+
|
|
1073
|
+
navigateTag = function(navigation, d) {
|
|
1074
|
+
var n = navigation.features.length;
|
|
1075
|
+
if(n == 0) return;
|
|
1076
|
+
var old = document.getElementById('current');
|
|
1077
|
+
if(old) old.removeAttribute('id');
|
|
1078
|
+
var current = navigation.querySelector('.current');
|
|
1079
|
+
current.id = 'current';
|
|
1080
|
+
var i = parseInt(current.innerText) + d;
|
|
1081
|
+
if(i < 1) i = 1;
|
|
1082
|
+
if(i > n) i = n;
|
|
1083
|
+
current.innerText = i;
|
|
1084
|
+
location.hash = getIdFromObj(navigation.features[i - 1]);
|
|
1085
|
+
};
|
|
1086
|
+
|
|
1087
|
+
//var lastToggled =
|
|
1088
|
+
//var lastViewPort =
|
|
1089
|
+
recordScrollPosition = function() {
|
|
1090
|
+
// main.scrollTop = navigation.features[i - 1].offsetTop - main.offsetTop;
|
|
1091
|
+
/*
|
|
1092
|
+
foo = function(obj) {
|
|
1093
|
+
var ref = window.scrollY - window.pageYOffset + document.documentElement.clientTop;
|
|
1094
|
+
var checkChildDivs = function() {
|
|
1095
|
+
var children = obj.childNodes;
|
|
1096
|
+
if (children.length) {[].forEach.call(children, function(e, i, a) {
|
|
1097
|
+
if (e.toString() === "[object HTMLDivElement]") {
|
|
1098
|
+
// the top of the div relative to the document
|
|
1099
|
+
// minus the height of window hidden above the top of the screen
|
|
1100
|
+
var top = e.getBoundingClientRect().top;
|
|
1101
|
+
// top and bottom posns relative to the top of the screen
|
|
1102
|
+
// the top and bottom distances of the element relative to the top of the screen
|
|
1103
|
+
// the div overlaps the screen top
|
|
1104
|
+
if ((top <= ref) && (ref <= top + e.offsetHeight)) {
|
|
1105
|
+
obj = e;
|
|
1106
|
+
checkChildDivs();
|
|
1107
|
+
return false;
|
|
1108
|
+
}
|
|
1109
|
+
}
|
|
1110
|
+
});}
|
|
1111
|
+
};
|
|
1112
|
+
checkChildDivs();
|
|
1113
|
+
return obj;
|
|
1114
|
+
};
|
|
1115
|
+
*/
|
|
1116
|
+
};
|
|
1117
|
+
|
|
1118
|
+
resumeScrollPosition = function() {
|
|
1119
|
+
};
|
|
1120
|
+
|
|
1121
|
+
coverage = function(obj){
|
|
1122
|
+
alert("Sorry, this function is not implemented.");
|
|
1123
|
+
// alert(obj.nextSibling.contentDocument.querySelector('body').innerText);
|
|
1124
|
+
// var f = obj.dataset.file;
|
|
1125
|
+
};
|
|
1126
|
+
</script></body></html>
|