Ruby七天入门(2 函数，数组和类)

最新推荐文章于 2019-09-04 16:40:20 发布
最新推荐文章于 2019-09-04 16:40:20 发布
阅读量231 收藏 1
点赞数
分类专栏： ruby
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/raosheng1993/article/details/45457721
版权


DAY 2

第二天学习继续，今天重点学习函数，集合和类等编程的基本要素。

2.1 函数

2.1.1 简单定义

<code class="hljs ruby has-numbering"> <span class="hljs-function"><span class="hljs-keyword">def</span> </span>tell_me
 puts <span class="hljs-keyword">true</span>
 <span class="hljs-keyword">end</span></code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li></ul>
  • 定义一个简单的函数（无参无返回值）很简单，使用def end包裹函数体即可。

2.1.2 参数

<code class="hljs ruby has-numbering"><span class="hljs-function"><span class="hljs-keyword">def</span> </span>tell_me(a)
puts a
<span class="hljs-keyword">end</span>
tell_me <span class="hljs-number">1</span>
<span class="hljs-number">1</span>
=> <span class="hljs-keyword">nil</span></code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li></ul>
  • 使用参数和其他语言类似，加括号加变量名即可。
2.1.2.1 参数默认值

同样可以指定参数默认值：

<code class="hljs haml has-numbering">def tell_me(a='1',b)
puts a
puts b
end
=<span class="ruby">> <span class="hljs-keyword">nil</span>
</span>tell_me 2
1
2
=<span class="ruby">> <span class="hljs-keyword">nil</span>
</span>tell_me 3,4
3
4
=<span class="ruby">> <span class="hljs-keyword">nil</span></span></code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li></ul>

我们看到指定默认值的方式跟其他语言类似。

有些苦恼的是，看起来我们需要记住每一个函数的参数数量和含义。

2.1.2.2 可变参数

Ruby同样支持可变参数，而且因为不受类型的限制，使用相当自由：

<code class="hljs ruby has-numbering"><span class="hljs-function"><span class="hljs-keyword">def</span> </span>test(*tt)
    <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-number">0</span>...tt.length
        puts tt[i]
    <span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>
=> <span class="hljs-keyword">nil</span>
test <span class="hljs-number">1</span>,<span class="hljs-number">2</span>
<span class="hljs-number">1</span>
<span class="hljs-number">2</span>
=> <span class="hljs-number">0</span>...<span class="hljs-number">2</span>
test <span class="hljs-string">'a'</span>
a
=> <span class="hljs-number">0</span>...<span class="hljs-number">1</span></code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li></ul>
  • 我们看到只需要将参数前加*即可，收到的参数就将是一个数组。

2.1.3 返回值

2.1.3.1 默认返回值

  • 昨天的学习里看到过，其实所有的Ruby语句都有返回值，那么其实我们及时不给函数指定返回值，函数也会返回他执行的最后一个语句的值。
    看下面的例子：
<code class="hljs haml has-numbering">def give_me
true
end
=<span class="ruby">> <span class="hljs-keyword">nil</span>
</span>
i=give_me
=<span class="ruby">> <span class="hljs-keyword">true</span>
</span>
i
=<span class="ruby">> <span class="hljs-keyword">true</span></span></code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li></ul>

这个函数我们并没有指定返回值，但是函数还是返回了最后执行的语句true的值。

2.1.3.2 return语句

<code class="hljs php has-numbering">$ irb
def test
a=<span class="hljs-number">1</span>
b=<span class="hljs-number">2</span>
<span class="hljs-keyword">return</span> a,b
end
=> nil
<span class="hljs-keyword">var</span>=test
=> [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>]
<span class="hljs-keyword">var</span>.class
=> <span class="hljs-keyword">Array</span>
<span class="hljs-keyword">var</span>
=> [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>]</code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li></ul>

  • Ruby可以通过return语句指定返回值，而且跟C家族语言不同的是，Ruby可以同时返回多个返回值。

  • 因为动态语言的特性，Ruby看起来如此自由，但是看起来这就更要求调用者对他们的调用负责。

2.2 代码块和yield

2.2.1 代码块的使用

代码块是没有名字的函数。

<code class="hljs perl has-numbering"><span class="hljs-number">3</span>.<span class="hljs-keyword">times</span>{puts <span class="hljs-string">'hi'</span>}</code><ul style="display: block;" class="pre-numbering"><li>1</li></ul>
  • times是Fixnum类的方法，它可以执行后面的代码块n次。
  • 后面大括号中内容就是代码块，代码块既可以用{}来包裹，也可以用do/end来包裹,就像下面的的代码。
<code class="hljs livecodeserver has-numbering"><span class="hljs-number">3.</span>times <span class="hljs-built_in">do</span>
puts <span class="hljs-string">'hello'</span>
<span class="hljs-function"><span class="hljs-keyword">end</span></span></code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li></ul>

昨天在区间一节中提到的each函数后面其实也是代码块：

<code class="hljs livecodeserver has-numbering">names=[<span class="hljs-string">'lee'</span>,<span class="hljs-string">'tom'</span>,<span class="hljs-string">'jim'</span>]
names.<span class="hljs-keyword">each</span>{|<span class="hljs-operator">a</span>| puts <span class="hljs-operator">a</span>}</code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li></ul>

2.2.2 yield执行代码块

下面我们来看下自定义的方法来执行代码块：

<code class="hljs matlab has-numbering">def my_times(<span class="hljs-built_in">i</span>=<span class="hljs-number">5</span>)
    <span class="hljs-keyword">while</span> <span class="hljs-built_in">i</span>><span class="hljs-number">0</span>
        <span class="hljs-built_in">i</span>=<span class="hljs-built_in">i</span>-<span class="hljs-number">1</span>
        yield
    <span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>

my_times(<span class="hljs-number">3</span>)<span class="hljs-cell">{puts <span class="hljs-string">'a'</span>}</span></code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li></ul>

我们看到这个函数根据传入参数，调用了一定数量的代码块。

  • 函数中定义的yield表示执行代码块中的代码。

2.2.3 代码块作为函数参数

我们也可以将代码块作为参数一直传递下去。

<code class="hljs oxygene has-numbering">def call_block(&<span class="hljs-keyword">block</span>)
    <span class="hljs-keyword">block</span>.call
<span class="hljs-keyword">end</span>

def pass_block(&<span class="hljs-keyword">block</span>)
    call_block(&<span class="hljs-keyword">block</span>)
<span class="hljs-keyword">end</span>

pass_block<span class="hljs-comment">{puts 'hello'}</span></code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li></ul>
  • 在Ruby中，参数名之前加一个“&”，表示将代码块作为闭包传递给函数。闭包就是把函数以及变量包起来，使得变量的生存周期延长。

2.3 数组

<code class="hljs bash has-numbering">animals = [<span class="hljs-string">'lions'</span>, <span class="hljs-string">'tigers'</span>, <span class="hljs-string">'bears'</span>]
puts animals[<span class="hljs-number">1</span>]
puts animals[-<span class="hljs-number">1</span>]
puts animals[<span class="hljs-number">0</span>..<span class="hljs-number">1</span>]</code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li></ul>
  • 上面这段代码有个语法糖，-1表示返回倒数第一个元素；当然1和其他语言一样，表示第二个元素
  • animals[0..1]用了昨天学过的区间，表示从0到1个元素
<code class="hljs haml has-numbering">irb(main):002:0> [].class
=<span class="ruby">> <span class="hljs-constant">Array</span>
</span>irb(main):003:0> a =[]
=<span class="ruby">> []
</span>irb(main):004:0> a[1]
=<span class="ruby">> <span class="hljs-keyword">nil</span>
</span>irb(main):005:0> b[1]
NameError: undefined local variable or method `b' for main:Object
        from (irb):5
        from /usr/bin/irb:12:in `<main>'
irb(main):006:0> a[1] = 1
=<span class="ruby">> <span class="hljs-number">1</span>
</span>irb(main):007:0> a[0] = 'zero'
=<span class="ruby">> <span class="hljs-string">"zero"</span>
</span>irb(main):009:0> a[2]=['2','3',[4,5]]
=<span class="ruby">> [<span class="hljs-string">"2"</span>, <span class="hljs-string">"3"</span>, [<span class="hljs-number">4</span>, <span class="hljs-number">5</span>]]
</span>irb(main):010:0> a
=<span class="ruby">> [<span class="hljs-string">"zero"</span>, <span class="hljs-number">1</span>, [<span class="hljs-string">"2"</span>, <span class="hljs-string">"3"</span>, [<span class="hljs-number">4</span>, <span class="hljs-number">5</span>]]]
</span>irb(main):011:0> a[2][2]
=<span class="ruby">> [<span class="hljs-number">4</span>, <span class="hljs-number">5</span>]
</span>irb(main):012:0> a[2][2][1]
=<span class="ruby">> <span class="hljs-number">5</span>
</span>irb(main):021:0> a=[]
=<span class="ruby">> []
</span>irb(main):022:0> a[1]=8
=<span class="ruby">> <span class="hljs-number">8</span>
</span>irb(main):023:0> a[3]=6
=<span class="ruby">> <span class="hljs-number">6</span>
</span>irb(main):024:0> a
=<span class="ruby">> [<span class="hljs-keyword">nil</span>, <span class="hljs-number">8</span>, <span class="hljs-keyword">nil</span>, <span class="hljs-number">6</span>]</span></code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li><li>28</li><li>29</li><li>30</li></ul>

比起大多数语言的数组，Ruby的数组使用很自由，从上面这些代码可以看出来。

  • 数组元素不必有相同类型
  • 可以只定义部分数组元素，其余位置将默认为nil值
  • 需要注意的是，在给数组元素赋值时，需要首先使用a =[]类似语法让a的类型变为数组类型，否则出现上面直接运行 b[1]时报的错误
<code class="hljs haml has-numbering">irb(main):025:0> a.push(4)
=<span class="ruby">> [<span class="hljs-keyword">nil</span>, <span class="hljs-number">8</span>, <span class="hljs-keyword">nil</span>, <span class="hljs-number">6</span>, <span class="hljs-number">4</span>]
</span>irb(main):026:0> a.pop
=<span class="ruby">> <span class="hljs-number">4</span>
</span>irb(main):027:0> a
=<span class="ruby">> [<span class="hljs-keyword">nil</span>, <span class="hljs-number">8</span>, <span class="hljs-keyword">nil</span>, <span class="hljs-number">6</span>]</span></code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li></ul>

数组同样支持push和pop，栈顶位于数组尾部。

2.3.4 散列表

散列表就是键值对，对应java里面的map容器。

<code class="hljs php has-numbering">irb(main):<span class="hljs-number">032</span>:<span class="hljs-number">0</span>> map={<span class="hljs-number">1</span>=><span class="hljs-string">'one'</span>,<span class="hljs-number">2</span>=><span class="hljs-string">'two'</span>}
=> {<span class="hljs-number">1</span>=><span class="hljs-string">"one"</span>, <span class="hljs-number">2</span>=><span class="hljs-string">"two"</span>}
irb(main):<span class="hljs-number">033</span>:<span class="hljs-number">0</span>> map
=> {<span class="hljs-number">1</span>=><span class="hljs-string">"one"</span>, <span class="hljs-number">2</span>=><span class="hljs-string">"two"</span>}
irb(main):<span class="hljs-number">034</span>:<span class="hljs-number">0</span>> map[<span class="hljs-number">1</span>]
=> <span class="hljs-string">"one"</span>
irb(main):<span class="hljs-number">035</span>:<span class="hljs-number">0</span>> map[<span class="hljs-number">3</span>]
=> nil</code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li></ul>

其实和数组类似，关键的不同就在于一个=>符号，符号前面是键，后面是值。

<code class="hljs php has-numbering">map={<span class="hljs-number">1</span>=><span class="hljs-string">'one'</span>,<span class="hljs-number">2</span>=><span class="hljs-string">'two'</span>}
a = map.to_a
puts a</code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li></ul>
  • 散列表可以转化为数组:其中每个元素是一个key, value组成的数组
<code class="hljs haml has-numbering">map.each { |k,v| p "#{<span class="ruby">k}</span>=>#{<span class="ruby">v}</span>"  }</code><ul style="display: block;" class="pre-numbering"><li>1</li></ul>

散列表同样可以遍历

2.5 类

所有的类都有一个共同的祖先，BasicObject。

<code class="hljs ruby has-numbering"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">TreeTest</span></span>
<span class="hljs-keyword">attr_accessor</span> <span class="hljs-symbol">:children</span>,<span class="hljs-symbol">:node_name</span>

<span class="hljs-function"><span class="hljs-keyword">def</span> </span>initialize(name,children=[])
    <span class="hljs-variable">@children</span> = children
    <span class="hljs-variable">@node_name</span> = name
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>

ruby_tree = <span class="hljs-constant">Tree</span>.new(<span class="hljs-string">"ruby"</span>,[<span class="hljs-constant">Tree</span>.new(<span class="hljs-string">'1'</span>),<span class="hljs-constant">Tree</span>.new(<span class="hljs-string">'2'</span>)])</code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li></ul>

上面代码定义了一个简单的类。

  • 类命名一般使用骆驼命名法，变量和方法名采用小写下划线命名法，而常量采用全大写形式；用于逻辑测试的函数一般用？结尾
  • 实例变量前需要加@（类似java的this？），而类变量前需要加@@（类似java的类名？）
  • attr关键字可用来定义实例变量。它有几种版本，其中最常用的版本是attr和attr_accessor。attr定义实例变量和访问变量的同名方法，而attr_accessor定义实例变量、访问方法和设置方法。
  • initialize方法有特殊含义，类在初始化一个新对象的时候，会调用这个方法
  • 类初始化时采用类名加.new的方法来初始化

2.6 小结

今天主要学习了Ruby的函数，类，数组的基本使用，最大的感触是Ruby的实现充满了符合直觉的特性，在掌握了基本语法后，很多代码只需要按照尝试着写就可以执行。

2.7实践

今天实践在前面Tree类的基础上加上遍历访问的功能,同时我修改了初始化方法，接受散列表和数组嵌套的结构：

<code class="hljs ruby has-numbering"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Tree</span></span>
<span class="hljs-keyword">attr_accessor</span> <span class="hljs-symbol">:children</span>,<span class="hljs-symbol">:node_name</span>

<span class="hljs-function"><span class="hljs-keyword">def</span> </span>initialize(map={})
    <span class="hljs-variable">@children</span> = []
    map.each <span class="hljs-keyword">do</span> |k,v| 
        <span class="hljs-variable">@node_name</span> = k
        v.each { |key,value|  <span class="hljs-variable">@children</span>.push(<span class="hljs-constant">Tree</span>.new({key=>value}))} <span class="hljs-keyword">if</span> v!=<span class="hljs-keyword">nil</span>
    <span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>

<span class="hljs-function"><span class="hljs-keyword">def</span> </span>visit_all(&block)
    visit(&block)
    children.each{|c| c.visit_all(&block)}
<span class="hljs-keyword">end</span>

<span class="hljs-function"><span class="hljs-keyword">def</span> </span>visit(&block)
    block.call(<span class="hljs-keyword">self</span>)
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>

ruby_tree = <span class="hljs-constant">Tree</span>.new({<span class="hljs-string">'grandpa'</span> => { <span class="hljs-string">'dad'</span> => {<span class="hljs-string">'child 1'</span> => {}, <span class="hljs-string">'child 2'</span> => {} }, <span class="hljs-string">'uncle'</span>=> {<span class="hljs-string">'child 3'</span> => {}, <span class="hljs-string">'child 4'</span> => {} } } } )

ruby_tree.visit {|node| puts node.node_name}
ruby_tree.visit_all {|node| puts node.node_name}</code><ul style="display: block;" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li></ul>

visit方法传递了代码块，调用了代码块并用self做参数（所以看起来代码块是通过这种方式获得参数？），其实就是打印了调用实例的node_name。
visit_all先对当前节点调用了visit方法，然后对子节点进行了递归。

ruby小酱
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Ruby简明教程之数组和Hash介绍
01-02
今天学习的是数组和Hash，数组在很多编程语言中都能常常用到。 数组： 数组是存储数据的一种容器，在Ruby中，数组中存储的数据可以是任何类型的数据；这和JAVA不同，在JAVA中，数组是存储同一类型数据的结构。 1. 在...
Ruby类和函数
冰水@blueの专栏 让优秀成为一种习惯
04-05 874
虽然后续会单独有一章专门介绍类和函数，但是作为面向对象中最常用的两个主要角色，这里还是要先简单的介绍一下。 （1）类 Ruby语言中类的定义使用的表现形式为class…end，如下： class class_name                                                                         class_member   
Ruby类函数定义的几种方式
autumn20080101的专栏
11-08 1627
Ruby类函数定义的几种方式 博客分类：  Ruby   Ruby类函数定义的几种方式  参考：ruby-defining-class-methods  1、  Ruby代码   class Person     def Person.find(id)       ...     end   end   这种方式，有
Ruby中的各种方法定义和调用（函数式方法|实例方法|类方法）
@_囚徒-2018_的家园
06-18 1万+
1.ruby方法的定义 (1)不带参数的方法 def function_name 　 statement …… end 调用方式： function_name or function_name() (2)带参数的方法定义 def function_name(parm1, parm2, …) 　 statement …… end 调用方式： function_
ruby编程下的main 对象
花括号的博客
05-05 940
ruby的运行一定要知道当前那个对象在充当self的角色。 只要追踪最后一个方法的接收者就可以。任意时候显示当前self对象，即可查看当前的self对象。 p self Ruby程序开始运行的时候，Ruby解释器会创建一个名为main的对象作为当前对象。这个对象有时候被称为顶层上下文（top level context）, 这个名字的由来是因为你已经处于调用堆栈的顶层，要么还没有调用任何方法，要...
Ruby中的数组和散列表的使用详解
01-20
Ruby的数组（arrays）和散列表（hashes）是被索引的收集（indexed collections）. 两者都存储对象的集合，通过键（key）来访问。数组的键是整数。而散列表支持以任何对象作为它的键。数组和散列表会按需调整大小来...
Ruby创建数组方法总结
08-26
例如，`days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]`创建了一个包含一周七天的数组。数组文字允许您快速初始化包含不同类型数据的数组，比如字符串、数字等。 访问...
Ruby数组(Array)学习笔记
01-02
Ruby中的数组是动态数组，存储的数据不用限定类型，数组的长度是根据存储需要动态扩展，所以，在进行数据定义的时候，只用用最简单的方式new一个Array对象就可以了，可以使用以下几种方式： 代码如下: arr1=[] #最...
Ruby语言简介
热门推荐
whatday的专栏
09-04 1万+
Ruby是一种解释型、面向对象、动态类型的语言。Ruby采取的策略是在灵活性和运行时安全之间寻找平衡点。随着Rails框架的出现，Ruby也在2006年前后一鸣惊人，同时也指引人们重新找回编程乐趣。尽管从执行速度上说，Ruby谈不上有多高效，但它却能让程序员的编程效率大幅提高。本文将讲述Ruby语言的基础语言特性，包括基本的语法及代码块和类的定义。 1. 基础 在Ruby交互命令行中输入以...
从main.c开始走进Ruby－登上调试Ruby之旅
你我皆凡人，生在人世间
08-18 373
我想更深入的了解Ruby内部的实现，出发点或许过于天真，   我想了解下这门语言的实现，从中或许可以学习到某些思路， 比如： 如果我们要设计另外一种动态语言该如何去下手， 如何将其他语言的特性融合进Ruby或者我们要设计的语言， 特定领域的特定语言该如何设计（不要一门又广又全的语言，但又不是DSL）。 题目是《从main.c开始走进Ruby》，那我们需要以下的准备...
Ruby on rails /rspec undefine 'visit'
u011179695的专栏
10-24 639
ling@ling-Lenovo-N480:~/rails_projects/sample_app$ bundle exec rspec spec/requests/static_pages_spec.rb F Failures: 1) Static pages Home page should have the content 'Sample App' Failure/Err
中国石油大学(北京)克拉玛依校区在广东2021-2024各专业最低录取分数及位次表.pdf
09-08
全国各大学在广东省2021~2024年各专业最低录取分数及位次
浙江越秀外国语学院在广东2021-2024各专业最低录取分数及位次表.pdf
09-08
全国各大学在广东省2021~2024年各专业最低录取分数及位次
网站模板源代码（组件划分规范，二改省力）
最新发布
09-08
组件划分规范，二改省力！！！
华中科技大学 Java课程设计实验.zip
09-08
华中科技大学 Java课程设计实验.zip
4G语音质差参数优化调整建议.xlsx
09-08
4G语音质差参数优化调整建议
仲恺农业工程学院在广东2021-2024各专业最低录取分数及位次表.pdf
09-08
全国各大学在广东省2021~2024年各专业最低录取分数及位次
《Java语言程序设计（基础篇）》课后编程练习题.zip
09-08
《Java语言程序设计（基础篇）》课后编程练习题
Ruby语言入门教程：快速掌握特性和语法
"Ruby语言入门教程v1.0"是一份全面介绍Ruby编程语言的基础教程，适合初学者系统地了解和掌握Ruby的核心概念。教程共分为四个章节，旨在帮助读者从零开始进入Ruby的世界。 第1章概述了编程语言的发展历程，强调编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值