我村子周围的和我差不多大的孩子，如今也和我一样，二十四五的大人了。他们大多是初中高中毕业，成绩好点的，上了普通的二本，再好的就是一本了。我的朋友中，最高的就是二本差不多，一本的都是我听过，却不曾认识的校友。我的亲戚中，也就几乎都是初中或高中毕业了。

他们不上学的原因都相似，不是因为家里孩子多，就是因为自己不爱学，想早点出来靠自己养活自己。当还是初中生高中生的时候，想象的，世界靠自己的打拼，应该是可以糊口的，甚至是光明的。有的学理发，有的跟随大人一起去工厂打工，还有的男孩子跟着父亲去工地。听说去工地的薪资还会高一些，每天劳作的时间很长，消耗体力也比较大。

出来打拼，我看到别人说的都挺美的励志故事。可是，我自己出来找工作的时候，发现，没学历没技能，只能去找服务员，餐厅后厨，工厂，卖化妆品这些工作了，而和我差不多的孩子也大都如此，他们至今依然如此。每个月薪资很薄弱，每天工作最少都得12个小时，一个月只能休息一天，好一点的能多休息几天。我所知道的，都在这样的讨生活。

村里的父亲们，一年到头，在工地，只在过年或家里有急事的时候回来一趟，待个几天就又继续去工地了。承担着为儿子盖房子娶媳妇的债务，还承担着家人和孙子的生活费。因为儿子的薪资也只够自己过活吧。有好一点的，还得自己还贷啊。

我自己第一份工作是汉堡店，工资 1600，刚拿到手的时候，现金嘛，比较有手感。当时，第一次有自己的钱，还是自己有史以来最多的钱的时候，我很激动；但也有一个一直没有漏掉的对自己的质疑，一个月这么快，给我发工资了，我干的活配的上这些工资么？之后，我也去过电子厂，当过服务员，发过传单，找过兼职。

在我的印象里，一直都是在讨生活，我，和我周围的人，生活是艰辛的。通过自己的考虑，我决定去学一项技能，来改变这种讨生活的局面。是的，在这个层面上，有可能现在我算是小小的达到目的了。现在，我月薪过万了。在我的村子里，这是多么让人羡慕的数字。我像小时候勤快会干家务活一样迎来了很多的夸赞。

可是，我还是觉得自己在讨生活。我还没有过另外一个阶段。我害怕自己失业，一失业我就又什么都没有了。我时刻保持着危机感，尤其是我给家里的亲戚打电话的时候。他们又在跟我说着多少为钱发愁的地方，说着谁家又离婚了，谁家又生孩子了，谁家孩子又死不听话做了什么天大的错事了。

是的，我很害怕跟他们打电话听他们说这些。我害怕进入这些生活的轮回中。我要改变我的命运，从我记事起，我就一直这样对自己赌气。我通过不断地学习与自省，以一个理智而又正确的眼光看待自己的生活以及周围人的生活，就像我今天读老舍的《我这一辈子》一样，看透这些乱七八糟的悲惨故事，穿透它，重新审视生活，用高维的智慧去审视，才能在生活的怪圈之外找到出路。那些凄惨的，大人们不愿意看到的孩子的命运，有些时候也并不能全怪孩子不争气，反过来你也很难要求家长去增长见识，去学会该如何教育孩子，是的，他们讨生活已经够艰辛了。

妈妈常常劝我，老老实实好好干自己的工作，别想那么多。我对象也觉得我总是瞎忙，而忽略了好好生活，一起好好生活。其实，他们不知道，不折腾，我内心的恐惧就无法摆脱。我想拥有像李笑来有篇文章里面说的「逃逸速度」。「赚钱一定要快，要快到超越“第二宇宙速度”，不然你飞不出去」，里面形象的用了「逃逸速度」，也就是「第二宇宙速度」来比喻，只有用第二宇宙速度「航天器可以摆脱地球引力的束缚，飞离地球」。他不只是这篇文章打动了我，《七年就是一辈子》这整本电子书的每一篇文章都打动了我。虽然，现在看来，读过这本书快两年的我，远远达不到这种速度，以至于我觉得自己永远都达不到这个速度了。

我相信我是努力的，我也可以是继续努力的，并且我觉得自己是在努力的，可是我的学习效率，以及学习深度，从哪里学？怎么学？怎么学的更好？如何分配自己的工作、学历学习、生活、感情和家庭？讨生活，还在不停的赶着我，继续讨生活。我崩的越紧，生活反而会越糟，我试着理清自己的思绪。想以慢来达快，以从容面对内心的恐惧，以成熟应对过去的焦灼！嗯，至少我现在做到了可以安稳的度过一天。虽然，还是在讨生活，但，讨生活，是寻求生路，是追求过活的。

我是学 rails 开始写学习日志到现在陆续养成的写作习惯。当然中间也有停过的时候。我觉得，想写的时候就写，不想写的时候也别硬着头皮给自己下任务。生活不紧不慢，不要把自己逼的过于紧张，虽然，我也经常说自己是追求不断进步的人，但是，逼的太紧，会有很多焦虑感，反而做不了更多的事情。

这段时间写些东西，第一个印象深刻的感触就是，不管是写技术博客，还是写生活感悟，发布前后，阅读此文章最多次数的人，就是作者自己了。

从开始构思文章，到敲满整个屏幕，最后一遍一遍的「增删改查」这篇文章，少了两三次，多的得几十次。可想而知，从这篇文章里面收获最大的还是你自己。如果你是写的技术博客，兴许你能把这个技术点的小知识就能了然于胸了，巩固了自己的学习，也给别人的学习增加了参考。如果是关于生活的感悟，我想你也能在这篇文章里面得到最大的宣泄，同时，你也会发现自己会理智很多，也更能理清情绪的来由。在朋友圈，很难去表达自己的心情，尤其是在自己不断成熟的时刻。一个小的心情，发个状态还会引起大家过分的关注，写篇文章抒发，就不会遇到这种问题了。因为文章会理的比较详尽，就算有朋友关心，也不会像朋友圈那里那样轰炸。

写作，可以让你深入思考；写作的时候，你会从文字的表达中，不断理清思绪，结构化他们。甚至，写作，可以平静你的内心，也能帮你好好找到解决问题的出发点。就是那么神奇，当你下笔后，或许你就会停不下来了。

有话没人说，写作；有感悟没处分享，写作；获得了一个小技能分享给大家，写作；遇到了一个美妙的故事，写作；是的，当你开始写的时候，会发现，生活到处都是素材，哪块都能提取出来一篇文章，给自己给他人带来愉悦，感动，或者悲伤。

之前一瞬间的感触，我就想记下来，直到现在我还不知道怎么能写一篇文章，不过可以记下这思考的片段：
晚上回家，遇到马路上有卸小汽车的，我只是经过且眼睛大概扫了一眼，就径直要离开了；这时，一个小孩的声音传了过来，“妈妈，我要过去看看”，说完就欢快的一路跑过去，为了看的更清楚一点这个卸车的过程；这个小孩大概才3岁吧，他妈妈在后面走的更快了，去追他。

从这里我想到啥呢，如果是我以前，我也会很好奇的，像那个孩子一样跑过去，看整个卸车的过程。现在不是因为我很清楚卸车的过程了，这种装了好几层小汽车的，我也没怎么见过，只是，我心里装着生存状态下的忧虑，装不下那些对于生存没有帮助的好奇心了。我要回家吃饭，洗刷，学习，或者别的什么，总有忙的，甚至是没有什么忙的，我的大脑潜意识也是朝着对生存有用的方向连接着，默认的情况下，是不能停下脚步的。

我不知道这个现象代表了什么，也不知道是不是意味着自己长大了，还是失去童趣了，总觉得，生活因为生存的考虑少了本该有的好奇心和趣味。值得庆幸的是，我还能反向思考。

就是像这样，写作，给了我一个思考和记录的空间，记录这些美妙的小瞬间。
如果，你不确定写作是否真的为你带来好处，可以试试。不要逼自己，就想到了的时候，试一试。或许你也会因为听到噼啪的键盘声音而如痴如醉，这或许也能给你带来些小惊喜呢。

使用的电脑为 mac 。

参考：Learn Enough Command Line to Be Dangerous

目录结构

在 Unix 中的所有目录都是 / 的子目录。目录以 / 开头和分隔目录。

/Users/yourname/ruby/projects 和 ~/ruby/projects 是一样的。

除了用户目录之外，每个 Unix 系统都有用于计算机正常操作的程序的系统目录。超级用户才能修改系统文件或者系统目录，root。以root身份登录的超级用户很强大，以至于被认为是一种不好的形式; 被替代的做法是作为 root 执行的任务通常应该使用 sudo 命令。

sudo !! 会以 sudo 形式运行上一个命令。
!ls 会运行 上一个 ls 命令。

sudo 命令让普通的用户可以像超级yo可以执行命令

创建目录

mkdir 是 make directory 的缩写.

$ mkdir text_files

创建过目录，我们可以使用通配符把所有的文本文件都转移到这个目录里面。

$ mv *.txt text_files/

我们可以通过 ls 确认一下：

$ ls text_files/

ls 一个目录，可以把它包含的所有内容都展示出来，我们可以用 -d 来仅仅展示目录。

$ ls -d text_files/

这个常常和 -l 一起使用。

$ ls -ld text_files/

我们可以通过 cd 切换目录。

cd 支持 Tab 自动补全。

可以只输入部分，再按 Tab 键即可自动补全。如 cd tex⇥

cd 输入之后，我们可以用 print working directory 命令，缩写 pwd，还有 ls 一起配合使用来看我们是否进入了正确的目录。

$ pwd 看看你是否在正确的目录结构
$ ls 看看目录中的内容，就可以确定您是都正确进入

切换目录

使用 cd 是最主要的切换目录的方式，但还有很多别的形式值得我们了解。想去上级目录，可以使用 cd ..

如：

1
2
3
4
5

$ pwd
/Users/mhartl/text_files
$ cd ..
$ pwd
/Users/mhartl

如果只输入 cd ，将会进入用户的根目录。和 cd ~ 是一样的。

如果我们在其他的目录下，使用 cd ~/text_files 这种形式可以快速进入这个目录中。

cd . 代表当前目录。最常用的是移动文件或者复制文件到当前目录中。

如：

1
2
3
4
5
6
7

$ pwd
/Users/mhartl/text_files
$ cd ~/second_directory
$ ls
$ cp ~/text_files/sonnets.txt .
$ ls
sonnets.txt

在上面，第一次输入 ls 没有东西输出，是因为，刚刚创建的 second_directory 里面还是空的。

另外一个用 . 的是和 find 一起使用。想 grep 一样的强大。
如：

1
2
3
4
5

$ cd
$ find . -name '*.txt'
./text_files/sonnet_1.txt
./text_files/sonnet_1_reversed.txt
./text_files/sonnets.txt

这是找到当前目录下以及它们的子目录中所有匹配 *.txt 的文件。
还有使用 . 的地方是 open .，在 mac 系统中总是可以生效。

open 命令可以打开目录或者文件，比如 open foo.pdf 将会用默认的 pdf 预览器打开 foo 这个 PDF 文件， open . 则是在 finder 中打开。

最后一个切换命令是 cd -, 它会切换到上一个目录中。
如：

1
2
3
4
5
6
7

$ pwd
/Users/mhartl/second_directory
$ cd ~/text_files
$ pwd
/Users/mhartl/text_files
$ cd -
/Users/mhartl/second_directory

混合命令。

如：

$ ./configure ; make ; make install

这个混合命令，会先执行 make 在执行 make install

更好一点的写法是：

$ ./configure && make && make install

一个用 ; 分隔开，一个用 && 分隔开。使用 && 的话，只有上一个命令执行成功了才会执行下一个命令。而使用 ; 分隔，不管上一个命令是否执行成功，都会执行下一个命令。

重命名，复制和删除目录

重命名：

1
2
3
4
5

$ mkdir foo
$ mv foo/ bar/
$ cd foo/
-bash: cd: foo: No such file or directory
$ cd bar/

把 text_files 目录及所有内容 复制到 foobar 中：

1
2
3
4
5
6

$ cd
$ mkdir foobar
$ cd foobar/
$ cp -r ../text_files .
$ ls
text_files

如果仅仅是复制目录下的所有内容到此目录中，要加上 /,如：

1
2
3

$ cp -r ../text_files/ .
$ ls
sonnet_1.txt     sonnet_1_reversed.txt sonnets.txt   text_files

如果你只是想复制文件，使用 * 来表示，如：
$ cp ../text_files/* . 把 text_files 下的所有文件复制到当前目录下。

删除目录 rmdir，很难执行成功。如：

1
2
3

$ cd
$ rmdir second_directory
rmdir: second_directory/: Directory not empty

当删除目录的时候，99% 的记录会出现上面这个错误，因为 rmdir 目录必须要是空的。可以使用一个更强大，但同时也更危险的命令 remove recursive force，即 rm -rf，这会删除这个目录，以及这个目录里的所有文件及子目录，而且没有再次的确认提示。
如：

1
2
3

$ rm -rf second_directory/
$ ls second_directory
ls: second_directory: No such file or directory

如果你想找到含有 sesquipedalian 这个词的文件，但是你又忘记了文件的名字了，你可以使用：

1
2

$ grep -r sesquipedalian text_files
text_files/foo/long_word.txt:sesquipedalian

由于大小写不重要，建议在递归的情况下添加 -i 选项，如下:

1
2

$ grep -ri sesquipedalian text_files
text_files/foo/long_word.txt:sesquipedalian

总结

使用的电脑为 mac 。

参考：Learn Enough Command Line to Be Dangerous

下载文件

用 which 命令可以查看命令行是否支持 curl，

$ which curl
/usr/bin/curl

如果输出结果是空的，说明不支持，得安装。可以自行 google 关键词 install curl 进行安装。
curl 安装好，可以下载文件了。

$ curl -OL cdn.learnenough.com/sonnets.txt
$ ls -rtl
$ !! # 可以出来最近一次使用的命令
$ !curl # 可以出来最近一次使用 curl 开头的命令

还有一个小技巧，可以使用 ctrl + r，这个可以进行搜索，输入 curl ，便可以查询以 curl 开头的命令。

1
2

$ 按住 ctrl 和 R
(reverse-i-search)`': curl

head tail

$ head sonnets.txt # 查看 sonnets.txt 文件的前 10 行
$ tail sonnets.txt # 查看 sonnets.txt 文件的后 10 行
$ wc sonnets.txt # 查看 sonnets.txt 文件有多少行，多少字，多少字节 2620 17670 95635 sonnets.txt
# 把 sonnets.txt 的 head 部分放入 sonnets_head.txt，并统计 sonnets_head.txt 中有多少行，多少字，和多少字节
$ head sonnets.txt > sonnets_head.txt
$ wc sonnets_head.txt 10 46 294 sonnets_head.txt
# 用一行命令也可以搞定
$ head sonnets.txt | wc 10 46 294Â

less more

$ less sonnets.txt
这个可以给文件一个导航，然后你可以通过 ↑ ↓，空格键去翻页。按 ctrl + f 可以一下到下个目录，ctrl + b 可以到上一个目录。输入 q 退出。

还可以 输入 /rose 来搜索 rose，可以按 n 去到下一个匹配的地方, N 去到上一个匹配的地方。

还有一个 G 去到文件的结尾，1G 去到文件的开头。
less 中的命令，和 man 中的类似，所以会了 less ，man 中的也可以很好的使用了。

grep

$ grep rose sonnets.txt # 找出所有存在 rose 的地方

$ grep rose sonnets.txt | wc # 统计出现 rose 的行数 字数 字节数（大写的 Rose 不能被统计到，grep 大小写敏感）
10 82 419
$ grep -i rose sonnets.txt | wc # 不计大小写统计 12 96 508

ps 是 process status 的缩写。

1
2
3
4
5
6
7
8

ps -aux
$ ps aux
$ ps aux | grep spring # 查看 spring 进程
    ubuntu 12241 0.3 0.5 589960 178416 ? Ssl Sep20 1:46
    spring app | sample_app | started 7 hours ago
$ kill -15 12241    # 杀死 12241 进程
$ pkill -15 -f spring # 杀死所有的 spring 进程
$ top # 可查看所有的进程

由 不写测试 到 补测试 再到 第一次有了测试先行的冲动。

写 java 的时候，在第一家公司都是给银行开发系统，都有专门的框架，只需要让我们补 service 层，也有一堆专门的测试人员，我们是不写测试的。后来去另一个创业的小公司，居然我的水平也是担当了开发主力。每天都是不断写代码，也不知测试为何物。

再后来，转学 rails 了。rails 虽然国内使用的很少，可是一般都要求写测试。而且我们学习的时候老师也有强调，虽然也没怎么学测试怎么写。第一家 rails 公司的技术总监就特别重视测试，也很崇尚 TDD（测试驱动开发，测试先行）。我刚开始十分不习惯，由于几乎没写过测试，对写测试的那套代码也不熟，通过 google 和参考项目中别人写的测试，我每次写测试都费了九牛二虎之力。有一次忘写测试了，还被批了一顿。我那时真的害怕写测试啊。

后来，技术总监给我推荐了《测试驱动开发》那本书，我也硬着头皮看完了，还看了两遍。读完后，了解了 TDD 的很多好处和一些测试的流程。虽然表面上知道了很多TDD 的好处，但我心里还是很害怕写测试。应了那句话，纸上得来终觉浅。

这次，我终于第一次有了测试先行的冲动！因为项目用了些 gem ，修改代码后不重启服务会超级慢。所以每次改完代码都去重启。然而来回重启去测试代码，一旦出错或者有逻辑错误的话，必须再次改代码，再次重启继续测，循环往复，花的时间特别长。所以，我想起来先写测试的好处了。如果我先有了测试，只需要一键就可运行看到结果。

写测试的时候，最讨厌的是要去构造数据，有些数据结构还比较复杂，另外也一直觉得添加测试代码会拖慢进度，构造完数据，还得去构造场景，尤其是进度一直赶着你的时候，写测试的时间就更觉得是浪费了。但是很多时候的偷懒，却带来了更大的不便，快（不写测试）变成了慢，慢（写测试）变成了快。

TDD 崇尚的是测试先行，即没写代码呢，就先写测试。好处是，如果先写测试，必然得知道输入是什么，期望输出的是什么。这样就不断促进思考该如何得到这样的输出，即把设计代码也放入了测试前期的准备中。构思差不多了，可以通过写伪代码的形式快速得到期望值。然后再去一步步把伪代码变成真正的代码。运行测试的时候有可能就变红了（出错了）。改好代码，再次运行，有可能就变绿了（运行正常）。觉得代码写的不太好，重构一下，再运行测试校验重构是否正确，如果变红，继续更改代码，直到再次变绿。这个过程就是 TDD 的过程。也是由红到绿再重构，然后再继续循环，直到觉得代码不需重构且都 Green. （Red Green Refactor为一个循环）。

像我开头说的，我现在是先写代码，通过浏览器测试直到代码正确，最后再去补测试。如果以 TDD 的过程写代码，我就不需要来回重启服务，在浏览器测试代码了，这个节省的时间是大把的，对我这个情境来说更是了。虽然浏览器测试省去了构造数据，模拟场景这些初期写测试不熟的人觉得很麻烦的步骤，但是却也少了测试先行的众多优点。何况写完代码之后一般是必定要写测试的，那提前一步写，其实并没有减慢整体的速度。只不过是写测试手生，被进度赶的慌了神，心里上就觉得写测试耽误时间了。

第一次有了测试先行的冲动。值得记录一下。

使用的电脑为 mac 。

参考：Learn Enough Command Line to Be Dangerous

1. > 和 >> 就算没有编辑器，也是可以把输出的一行字，新创建到一个文件中。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   $ echo "From fairest creatures we desire increase," > sonnet_1.txt` # 这句命令就可以创建一个新的文件 sonnet_1.txt 并把 echo 后面的那句话放到这个文件中。 $ cat sonnet_1.txt # 查看 sonnet_1.txt，会把 sonnet_1.txt 中的内容输出。（cat 是 concatenate 的缩写） $ echo "That thereby beauty's Rose might never die," >> sonnet_1.txt # 使用 >> 可以把一句话追加到文件中。 $ diff sonnet_1.txt sonnet_1_lower_case.txt < That thereby beauty's Rose might never die, --- > That thereby beauty's rose might never die, # 快速比较两个文件的不同。

2. ls

   列出当前目录所有的文件和文件夹。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   $ ls foo # 列出这个 foo 下所有的文件和文件夹。 $ touch foo # 可以创建一个空的文件，名字是 foo. $ cd + 文件名 # 切换到这个文件下面。 $ ls *.txt # 可以列出所有的以 .txt 结尾的文件 $ ls -l *.txt # 可以列出所有以 .txt 结尾的文件，以及更改文件的时间等。时间前面的是这个文件的大小（字节）。 $ ls -rtl # 可以按照修改时间排序，最近的在最后面。这个也可以拆开写 ls -r -t -l $ echo "*.txt" > .gitignore $ cat .gitignore *.txt $ ls # 不会列出隐藏的文件 .gitignore 。 $ ls -a # 可以列出所有的文件包括隐藏的文件 .gitignore 。

3. mv

   1 2 3 4

   $ echo "test text" > test $ mv test test_file.txt $ ls test_file.txt

   重命名 text 文件变成 test_file.txt。

4. cp copy 复制文件

   1 2 3 4

   $ cp test_file.txt second_test.txt $ ls second_test.txt test_file.txt

5. rm remove 删除文件

   1 2 3 4

   $ rm second_test.txt remove second_test.txt? y $ ls second_test.txt ls: second_test.txt: No such file or directory

6. Tab completion Tab 键自动补全

   1 2 3

   $ rm tes⇥ # 输入一半的时候可以按住 tab 键，便会自动补全后面的文件名。 $ rm -f *.txt # 删除所有以 *.txt 结尾的文件。f 为 force 的缩写。

总结

翻译好累 😫，结合上面看吧。

使用的为 mac 电脑。

1. echo

   • prints the word “hello” to the screen

   • 把 hello 打印到屏幕上

     1 2 3

     $ echo hello $ echo "hello" $ echo 'hello'

     如果你输入$ echo "hello 忘了一个关闭的双引号，会无法停止命令，凡是遇到命令行的相关错误，都可以通过 Ctrl-C 来停止运行。如果 Ctrl-C 也不行，按 esc 90% 的时候都是可以退出的。

2. man

   • short for “manual”
   • man 后面跟命令名称，可以看到这个命令的说明
   • 打开的说明中，输入 :q 可以退出查看的窗口；如果最后一行有个 : 这说明下面还有更多的说明，按键盘中的 ↓ 键，或者空格键，都可以继续阅读下面的说明。

3. 键盘中有很多特殊键，这些符号代表很多命令操作（键盘可能会有些不同，不过大部分是能找到类似的）。

按 ↑ ↓ 上下键，可以翻到刚刚运行的命令。

`$ hello`

如果你想在 hello 的最前方输入，你可以通过 ← 一个一个到最前面，还有一个快速的方法是 按住 ctrl 键（或者 ⌃），再按住 a 键( ctrl + a)，就可以快速移动到最前方。同样的，ctrl + e 可以快速移动到最后面。ctrl + u 可以快速删除一整行。

如果一整行太长的话，有可能这几个还不够。比如：

`$ echo "From fairest creatures we desire increase,"`

如果想吧 `From` 改成 `FRom` 的话，可以按住 Option 键，然后再用鼠标点击到需要移动到的字母，就可以了。如果很多都需要改，那你就用 ctrl + u 删除一整行，重新写吧，😆。

1. clear

   清空屏幕。

   $ clear

   ctrl + l 或者 command + k 也可以清屏。

   如果我们想退出这个 tab，可以输入

   $ exit

   ctrl + d 也可以退出

总结：

$ psql postgres （进入psql 命令）
postgres=# \c testdb; （进入 testdb 数据库 ）
testdb-# \d posts; （列出 posts 表结构）

参考：
PostgreSQL SQL Syntax and Use

PostgreSQL - SELECT Database

OpenStruct

快速创建一个 class。并拥有 class 的功能。

参考：

Ruby 中的 OpenStruct 详解

OpenStruct

instance_eval

参考：BasicObject

可以使用 instance_eval 访问类的实例变量, 可以把变量中保存的代码执行。

如：（通过 OpenStruct 快速创建对象，通过 instance_eval 执行代码变量）

注：*args, * 后面是自定义的变量名。如 *names。

这是一个 splat 操作符，它是 ruby 的方法，不是 rails 特有的，根据不同应用场景，它有两种应用方式：

• 将多个参数打包成一个数组
• 将数组拆分成一个参数列表

1. 如果在方法定义中使用 splat 操作符，那么这个方法就可以接受任意数量的参数，参数列表会被打包到一个数组中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

def foo(*args)
  args.each_with_index{ |arg, i| puts "#{i+1}. #{arg}" }
end
# 将参数列表打包成数组
foo("a", "b", "c")
# 1. a   <== this is the output
# 2. b
# 3. c
foo1(1, 2, 3, 4, 5)
# 把前面的参数打包成数组
def foo1(*other_args, arg1, arg2)
  p arg1.inspect       # => 4
  p arg2.inspect       # => 5
  p other_args.inspect # => [1, 2, 3]
end
# 把剩余的参数打包成数组
def foo1(arg1, arg2, *other_args)
  p arg1.inspect       # => 1
  p arg2.inspect       # => 2
  p other_args.inspect # => [3, 4, 5]
end
# 把中间的参数打包成数组
def foo1(arg1, *other_args, arg2)
  p arg1.inspect       # => 1
  p arg2.inspect       # => 5
  p other_args.inspect # => [2, 3, 4]
end

1. 如果在调用方法的时候，在数组前面加上 *，方法体内，会把数组拆分成参数进行运算和处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def bar(a, b, c)
  a + b + c
end
# 将数组拆分成参数列表
my_array = [1, 2, 3]
bar(*my_array)
# 6
# 将数组拆分成参数列表
foo(*my_array)
# 1. 1   <== this is the output
# 2. 2
# 3. 3