Skip to content

Latest commit

 

History

History
1079 lines (892 loc) · 29.3 KB

dongbei-ref.md

File metadata and controls

1079 lines (892 loc) · 29.3 KB

dongbei语言咬文嚼字

学习一门语言,先得了解它的词法(怎么从一串串的字符组成词),然后是语法(怎么把词组成句子)和语义(这些句子都啥意思啊?)。 所以,咱们先讲讲 dongbei 语言词汇的构成。

词法

字符串常量

一行代码当中,要是出现配对的中文全角双引号,比如

...“我是一个字符串”...

那么引号当中的内容(我是一个字符串)会被当成一个字符串常量。

注释

一行代码当中,如果在字符串常量外面出现 # 字符,所有从 # 开始的字符都会被当成注释被忽略掉。 比如

嘀咕:  # 我是一个注释。
    “嘎哈#?”。  # 我还是一个注释。

嘀咕:“嘎哈#?”。

是一样一样的。

分词

大部分的西方语言在书写的时候要用空白字符或者标点把单词隔开,要不就会产生歧义。 比如 therapist(理疗师)和 the rapist(强X犯)就有很大的不同!

所以,西人开发的编程语言也一样啰嗦,动不动就要加空格,忒麻烦了。

dongbei 语言以人为本,适应华人的书写习惯,加不加空格换行都无所谓。 反正加了也白加(除非加在一个字符串常量的内部)。 所以对 dongbei 来说,

唠
  唠
    :
      “嘎哈?”
        。

嘀咕:“嘎哈?”。

是一样一样的。

名字

代码里面除了各种有特俗意义的关键词(keyword),还会有各种用户定义的名字(变量名、函数名、类型名,等等)。 在 dongbei 语言里面,除了关键词、标点符号和常数,剩下的都是名字。 比如,在“张三乘李四”这个 dongbei 语言表达式里,“乘”是一个关键词,“张三”和“李四”是两个不同的名字,

那么问题来了:dongbei 语言是不尿空格的,名字和关键词之间没有明显的隔离。 要是名字里包含关键词怎么办? 比如,我们知道“乘”是一个关键词,那还能用“阶乘”做套路名吗? 系统会不会把它理解成名字“阶”和关键词“乘”?

嫑方! dongbei 语言允许你用中文全角方括号【】把一串字符标注为名字。 比方说,“【阶乘】”就明明白白地是一个叫“阶乘”的名字,绝对不会被当成是名字“阶”加关键词“乘”。

常数

除了用阿拉伯数字表示的十进制整数(比如 2、42、250,等等),0 到 10 的常数也可以用中文表达:

零一二三四五六七八九十

也可以写成鸭蛋也可以写成或者也可以写成

比如,

五加二

的意思就是 5 + 2。

除此之外还有表示对错的常数 没毛病(对)和 有毛病(错)。

语句

一个 dongbei 程序是由一串语句组成的。 每个语句以句号(。)结束。 为了表达程序员炽热的感情,也可以用感叹号(!)结束,意思和句号是一样一样的。 请大家根据自己的心情任选使用。

变量

dongbei 语言允许使用任何字符串做变量名。只要记住两点:

  1. 变量名里所有的空白字符都会被忽略。
  2. 有歧义的时候要把变量名用【】括起来。

定义变量

dongbei 是一门以人为本的语言。 我们知道东北人都是活雷锋。 所以,要定义一个叫 XX 的变量,我们要写......

XX是活雷锋。

比如:

老王是活雷锋。

当然,热情洋溢的

老王是活雷锋!

也是可以的。

给变量赋值

dongbei 语言不整“赋值”这种文绉绉的词儿。 咱们叫“装”。 比如:

老王装二。

可以理解为 C 语言的

lao_wang = 2;

要把一个活雷锋的值清空回到原始状态,可以用

削老王。  # 跟 '老王 装 啥也不是。' 意思一样,可是带感啊!

过后老王就啥也不是了,但是名字还在。所以

老张装老王。

还是可以的,结果是老张也变成啥也不是。

更狠的操作捏是 炮决

炮决老王。

过后老王就香消玉殒,尸骨无存了,连名字都留不下。 这时候,要是再来

老张装老王。

就会爆出一个错(整叉劈了)。

增减变量

活雷锋除了会装,加加减减也是常见的操作。 按没病走两步的规矩,这些操作的名字叫做:走走稍稍走X步稍X步。 比如:

老张装二。  # 现在老张等于2
老张走走。  # 现在老张等于3
老张走两步。  # 现在老张等于5
老张稍稍。  # 现在老张等于4
老张稍五步。  # 现在老张等于-1

注:稍(shào)稍这个词的意思是“退退”。 它具有十分浓厚的地方风味,尤其在东北大老哥向社会小老弟传授人生的经验时,出现得尤为频繁,体现了东北人民的儒雅随和,平易近人。 近年来随着各种视频、社交平台的发展,这个东北词汇也受到了来自社会各界人士的喜爱。

引用变量

变量,呃,活雷锋定义以后就可以引用了。 引用的方法很简单:把活雷锋的名字写出来就成。 比如:

老张是活雷锋。
老王是活雷锋。
老张装250。
老王装老张加13。

定义了两个活雷锋:老张和老王。 老张值250。 老王值263。

交流

dongbei 能说会道。 输出信息咱们得说 嘀咕。 假定要说的信息是 YY,就得写

嘀咕:YY。

比如说,活雷锋老王的当前值是263,那么

嘀咕:老王。

的结果就是打印

263

唠的内容也可以是中文全角双引号括起来的字符串常量,像

嘀咕:“诶呀妈呀!”。

的结果就是打印出

诶呀妈呀!

要是等用户输入呢,就整 你吱声

贵姓 装 整你吱声(“你贵姓?”)  # 打印消息,然后等输入。
嘀咕:“名字呢?”
名字 装 整你吱声。  # 不打印消息,等输入。
嘀咕:“你揍是传说中的”、贵姓、名字、“啊!”。

字符串运算

顿号(、) 操作符可以把两个值当成字符串拼接起来。 假定活雷锋老王的当前值是字符串“NB”,那么表达式

老王、“A”

的值就是字符串 NBA。而

“老王”、665加一

的值是 老王666

算术运算

基本的四则运算 dongbei 都是支持的。举例说明:

表达式 含义
拉饥荒 老王 - 老王
老王 加 老张 老王 + 老张
老王 减 老张 老王 - 老张
老王 乘 老张 老王 * 老张
老王 除以 老张 老王 / 老张
老王 齐整整地除以 老张 老王 / 老张,只保留整数部分
老王 刨掉一堆堆 老张 老王 除以 老张 的余数

注意除法运算叫“除以”,不叫“除”。 问问你小学数学老师就知道,“A除B”的意思其实是“B除以A”,也就是说“B/A“。 所以,要是你说“6除2”,数学老师会以为你在说3分之1,而不是3。 你要是跟他讲“6除2得3”,信不信他削你?

跟小学学过的一样,乘除和求余的优先级比加减高。 相同优先级的情况下,运算从左到右。比如说:

3加2乘5

的结果是13,不是25。

括号也是可以的:

嘀咕:(五减(四减三))乘二。

8

比大小

dongbei 人讲究分寸,长幼有序。

假定老王装的是5,老张装的是6。 那么

嘀咕:老王 比 老张 还大。
嘀咕:老王 比 老张 还小。
嘀咕:老王 跟 老张 一样一样的。
嘀咕:老王 跟 老张 不是一样一样的。

的结果就是

有毛病
没毛病
有毛病
没毛病

除此之外,一个刚刚创建的活雷锋还没有值。 我们就说他啥也不是

老王是活雷锋。
嘀咕:老王。
嘀咕:老王啥也不是。

会打印

啥也不是
没毛病

群众

单只单只的活雷锋有的时候略显捉襟见肘。 dongbei 支持“群众”的概念。 就是一个变量里放一群活雷锋。 有学习好的同学可能发觉了:这不就是数组吗!

比如:

张家庄都是活雷锋。  # 张家庄是个群众变量。初始值是「」。

完了吧就可以往里边儿加人了:

张家庄 装 「二加三,“大”」。  # 张家庄现在 = 「5, '大'」
张家庄 来了个 四减一。  # 张家庄现在 = 「5, '大', 3」
张家庄 来了个 “粗”。   # 张家庄现在 = 「5, '大', 3, '粗'」

加完人就可以点名了:

嘀咕:张家庄的老大。  # 第一个人(5)。
嘀咕:张家庄的老二。  # 第二个人('大')。
嘀咕:张家庄的老(四减一)。  # 第三个人(3)。
嘀咕:张家庄的老四。  # 第四个人('粗')。
嘀咕:张家庄的老一。  # 跟老大一回事。
嘀咕:张家庄的老幺。  # 最后一个人('粗')。

要想无视老大或老幺,可以分别用 掐头去尾 运算。比如:

嘀咕:张家庄掐头。  # 「'大', 3, '粗'」
嘀咕:张家庄去尾。  # 「5, '大', 3」

注意 掐头去尾 只是运算,它们返回一个新的群体,不会真的去修改 张家庄。 所以,上面的操作弄完后,张家庄 还是 「5, '大', 3, '粗'」,一个也不能少。

既然数组里头可以套数组,那么群众当中也可以套群众:

李家村都是活雷锋。  # 李家村也是个群众变量。初始值是「」。
李家村来了个三。  # 李家村现在 = 「3」。
李家村来了个张家庄。  # 李家村现在 = 「3, 「5, '大', 3, '粗'」」。
嘀咕:李家村的老幺的老大。  # 5。

也可以用 来了群 一次把一个村庄的群众挨个加入到另一个村庄:

李家村 来了群 张家庄。
# 李家村现在 = 「3, 「5, '大', 3, '粗'」, 5, '大', 3, '粗'」。
# 张家庄现在还 = 「5, '大', 3, '粗'」。

# 一次加多个群众。
李家村 来了群 「9,2,3」。  # 也可以说: 李家村 来了群 路银「9,2,3」。
# 李家村现在 = 「3, 「5, '大', 3, '粗'」, 5, '大', 3, '粗', 9, 2, 3」。

要数数一个数组里有几个元素,用XX有几个坑

嘀咕:张家庄有几个坑。  # 4
嘀咕:李家村有几个坑。  # 9

注意这李家村有九个坑,第一个装的是3,第二个装的是「5, '大', 3, '粗'」,......

国有国法,村有村规。 在村子里要干掉某人,可以炮决

# 一开始张家庄 = 「5, '大', 3, '粗'」。
炮决张家庄的老三。  # 张家庄现在 = 「5, '大', '粗'」。

要想团灭群众,只需要他们:

削张家庄。  # 张家庄现在啥也不是。

抱团

和参加群众性活动类似,活雷锋们还可以抱团。 一个群的成员数可以是0,1,2,3...... 同样的,一个团的成员数也可以是0, 1, 2, 3......

X 跟 Y 跟 Z 抱团 这个操作,可以把 0 到多个活雷锋抱成一团:

圣人团 装 抱团。  # ()
独孤求败团 装 西门吹雪 抱团。  # (西门吹雪,)
二人转团 装 赵英俊 跟 高老师 抱团。  # (赵英俊, 高老师)
桃园社 装 老刘 跟 老关 跟 老张 抱团。  # (老刘, 老关, 老张)
嘀咕:桃园社 有几个坑。  # 3

抱团之后,可以用 老几 操作访问团员:

嘀咕:桃园社 的老大。  # 老刘
嘀咕:桃园社 的老二。  # 老关
嘀咕:桃园社 的老幺。  # 老张

那么你要问了:这个到底有啥不一样?说叨说叨?

问得好!

群众是来去自由的,还可以变来变去:

张家庄装「5,3,2,4」。
张家庄来了个7。    # 变多了:「5, 3, 2, 4, 7」
炮决张家庄的老大。  # 变少了:「3, 2, 4, 7」
张家庄的老二装九。  # 变节了:「3, 9, 4, 7」

团就不一样了。一朝入团,终身不悔。

XX团 来了个 YYXX团 来了群 YYY炮决 XX团的老二XX团的老幺 装 YY,......这些妄想改变团成员的操作,整个儿都是徒劳的。

切记,切记。

磨叽

所谓磨叽,就是一遍一遍循环。 所以,在 dongbei 语言里循环的写法是:

变量名 从 X 到 Y 磨叽:
  ...  # 需要重复做的事
磨叽完了。

举例说明:

老王从一到五磨叽:  # 老王从1走到5。
  嘀咕:老王!  # 打印老王的当前值。
磨叽完了!  # 循环结束。

运行的结果是:

1
2
3
4
5

要是步子要大一点呢可以整“一步 N 蹿”:

老王从一到八一步三蹿磨叽:  # 老王从 1 走到 8 每次加 3。
  嘀咕:老王!  # 打印老王的当前值。
磨叽完了!  # 循环结束。

运行的结果是:

1
4
7

磨叽的范围也可以是群众。比如,要是张家庄装的是「3,1,5,2」,那么

老王在张家庄磨叽:
  嘀咕:老王。
磨叽完了。

的结果就是

3
1
5
2

磨叽是可以嵌套的。比如:

老张从一到二磨叽:
  嘀咕:“老张:”、老张。
  老王从老张到四磨叽:  # 内层磨叽可以引用外层磨叽变量
    嘀咕:“老王:”、老王。
  磨叽完了。  # 内层磨叽结束。
磨叽完了。  # 外层磨叽结束。

运行出来是这样的:

老张:1
老王:1
老王:2
老王:3
老王:4
老张:2
老王:2
老王:3
老王:4

要是磨叽到半拉儿就不想再磨叽了咋办咧?那就 尥蹶子。 要是想跳过从当前到 磨叽完了 中间的所有操作,就说 接着磨叽。 比如这个:

老张从一到十磨叽:
  寻思:老张跟二一样一样的?
  要行咧就接着磨叽。
  嘀咕:“老张是”、老张。
  寻思:老张比五还大?
  要行咧就尥蹶子。
磨叽完了。

结果就是

老张是1
老张是3
老张是4
老张是5
老张是6

要是想 死磨叽,可以 从一而终

老王装一。
老张从一而终磨叽:  # 磨叽无穷次,每次的值都是一。
  嘀咕:老张、“和”、老王。
  老王装老王加一。
  寻思:老王比三还大?
  要行咧就尥蹶子。
磨叽完了。

结果就是

1和1
1和2
1和3

另外,你可以试试“在苹果总部磨叽”是啥结果。

讲条件

虽然 dongbei 人都是活雷锋,干活的时候该讲条件还是要讲条件的。 寻思 是一项很有用的技能!

一般来讲,要是俺们有件事情(不妨叫做 XXX)只想在某个条件(不妨叫 CCC)成立的时候再做,就写:

寻思: CCC ?
要行咧就 XXX

要是 CCC 不成立的时候俺们有另外一件事情 YYY 要做,那就写:

寻思: CCC ?
要行咧就 XXX
要不行咧就 YYY

比如说吧,要是俺们瞅着老王比老张还大就想夸夸老王,那就这么写:

寻思:老王比老张还大?
要行咧就嘀咕:“老王比较牛叉!”。

再复杂一点的:

寻思:老王比老张还大?
要行咧就嘀咕:“老王比较牛叉!”。
要不行咧就寻思:老张比老王还大?
要行咧就嘀咕:“老张比较牛叉!”。
要不行咧就嘀咕:“老王老张共同牛叉。”。

看懂了?要是老王是3老张是2,那么这段代码就会打印

老王比较牛叉!

要是老王2老张3咧,就会打印

老张比较牛叉!

要是老王老张都2咧,打印的就是

老王老张共同牛叉。

叉劈

很多的时候,要是一个前提条件不成立,咱们就想立马尥蹶子退出整个程序,因为它意味着上游提了个不合理的要求。 虽然理论上说寻思可以处理这种情况,实际用起来相当啰嗦。 这时候咱们就可以用保准CCC,非常精炼。 比如:

保准老王比五还大。

要是老王的值比五还大咧,这句话没毛病,程序接着往下跑。 如若不然,程序立马退出,而且打印出一条错误:

整叉劈了:该着 【老王】比5还大,咋有毛病了咧?

还有的时候咧,咱们要保准某个条件不成立。跟保准相对的是辟谣

老王装二。
辟谣老王比五还大。  # 没毛病
辟谣五比老王还大。  # 整叉劈了:5比【老王】还大不应该啊,咋有毛病了咧?

严格来说“辟谣”并不是东北特有的词汇,但是东北人民对它可以说是相当的熟悉了。 所以把它收入 dongbei 编程语言是相当和谐的。 你明白了吗?

善用保准辟谣,保准臭虫在你代码里藏不住。

要是写 整叉劈了:XXX。 咧,就会让程序马上打印 XXX 然后退出。比如:

寻思:小王比18还小?
要行咧就 整叉劈了:“小王只有”、小王、“,小朋友请回避!”。

会在小王装16的时候打出消息

整叉劈了:小王只有16。小朋友请回避!

然后立马退出。

组合拳

你有没有想过:要是俺们在某个条件成立的时候想做两件事而不是一件事,该咋办咧? 要是写

寻思:CCC ?
要行咧就
   XXX。
   YYY。

成嘛?

不成。

前面俺们说过咧,dongbei 语言里面字符串常量外边儿的空白是不作数的。 写了也瞎掰活。 所以,按上面这种写法,XXX 倒是只有 CCC 成立的时候才会做,可 YYY 是无论如何都会做的。 相当于:

# 先讲条件:
寻思:CCC ?
要行咧就XXX。

# 这个不讲条件。
YYY。

要解决这个问题,咱得上 组合拳:把一串操作整合成一个操作。 组合拳的写法是:

开整:
  XXX。
  YYY。
  ...
  ZZZ。
整完了。

尽管整了一串,在 dongbei 语言看来这是一个操作。 所以,

寻思:CCC ?
要行咧就开整:
   XXX。
   YYY。
整完了。

就能达到俺们的目的了!

套路

“套路”这名字听着吓人,其实就是给一串常用的组合拳取一个名字,然后吧需要做这些操作的时候提一下这个名字就OK了。

定义套路

要定义一个套路,用这个格式:

套路名字 咋整:
  ...  # 爱做的事儿
整完了。

还是举例说明:

写九九表咋整:  # 定义套路 写九九表。
  老王从1到9磨叽:
    老张从老王到9磨叽:
      嘀咕:老王、“*”、老张、“=”、老王乘老张。  # 打印 X*Y=Z
    磨叽完了。
    嘀咕:“”。  # 空一行。
  磨叽完了。
整完了。  # 结束套路定义。

定义了一个叫“写九九表”的套路。 注意定义套路本身不会让这个套路真的跑起来。 所以上面这段程序跑的结果是啥也不做。

使用套路

要把一个套路代表的操作跑一遍,得写:

整 套路名。

比如说,上面这个“写九九表”的套路定义好了过后,你只要写:

整写九九表。

就可以打印出一份浓眉大眼的九九表了:

1*1=1
1*2=2
1*3=3
...

8*8=64
8*9=72

9*9=81

带参数的套路

有的时候,我们希望通过一个参数去控制一个套路的行为。 比如,我们要教会电脑算一个数的阶乘(就是123*... 一直乘到这个数)。 在定义这个“阶乘”套路的时候,我们并不知道以后会用它来算哪个数的阶乘。 所以,我们要把这个数定义成这个套路的一个参数。

那就要这样写:

套路名(参数名)咋整:
  ...  # 爱做的事
整完了。

具体到这个“阶乘”套路,就是这样的:

【阶乘】(那啥)咋整:  # 定义套路 阶乘,有一个参数 那啥
  ...  # 阶乘的操作步骤
整完了。  # 定义结束。

注意这里我们把套路名“阶乘”用方括号【】括起来,因为“乘”本身是个关键词,不括起来容易引起误会。

这个套路有一个参数,名字叫“那啥”。 “【阶乘】(那啥)”就是算那啥的阶乘。

要是一个套路有多个参数,那就得把它们一个一个列出来,中间用逗号隔开:

求和(甲,乙)咋整:
  滚犊子吧 甲加乙。
整完了。

调用这种套路的时候咧,相应地要把参数的值一个一个列出来:

嘀咕:整求和(五,七)。

会打印出 12。

从套路返回值

在“写九九表”这个例子里,套路本身是不返回任何值的。 它要做的事都通过“嘀咕”打印出来了。

而对于“阶乘”来说,我们并不想打印这个阶乘的结果。 我们只想把结果返回给整这个套路的人,爱咋用咋用。

在 dongbei 里边儿,从套路里返回一个值X,得说“滚犊子吧X。”

这个阶乘的完整定义,可以是这样的:

【阶乘】(那啥)咋整:  # 定义套路 阶乘,有一个参数 那啥
  老王是活雷锋。
  老王装一。
  老李从一到那啥磨叽:
    老王装老王乘老李。
  磨叽完了。
  滚犊子吧老王!  # 返回值。
整完了。  # 定义结束。

写完这个,再来一句

嘀咕:整【阶乘】(五)。

就可以看到打印结果

120

了!

套路套套路

一个套路里面可以定义别的套路。 这个内层的套路只在外层套路的范围内看得见。 内层套路可以引用外层套路的活雷锋。

比如,这是九九表的另一种写法:

写九九表咋整:
  老王从一到九磨叽:
    王九表咋整:  # 定义一个套在“写九九表”套路里的套路。
      老张从老王到九磨叽:  # 内层套路可以引用外层套路的活雷锋。
        嘀咕:老王、“*”、老张、“=”、老王乘老张。
      磨叽完了。
    整完了。  # 内层套路定义结束。
    整王九表。  # 使用内层套路。
    嘀咕:“”。
  磨叽完了。
整完了。

自推

每个程序员在学习编程的时候都要翻一个坎儿,这就是 递归

在 dongbei 语言里面,咱不整这些虚头八脑的概念。 咱就叫“自推”。

啥意思? 就是说在做一个操作的时候调用这个操作自己。 有点循环定义的意思。

其实这就是俺们中学老师讲过的数学归纳法:欲求 f(n),先求 f(n-1)。 然后如果从 f(n-1) 的值可以推算出 f(n) 的值,不就搞定了吗? 当然,前提是这个自推不能无穷无尽地整下去,到某一步得停下来。

举个例子。 求 n 的阶乘 f(n) 可以这么搞: 要是 n 是 0 的话,结果就是 1。 要是 n 比 0 大的话,就给就是 n * f(n-1)。

这里,在算 f(n) 的时候,我们先算 f(n-1),再从 f(n-1) 算出 f(n)。 这就是自推大法的精髓。

把上面的思路用 dongbei 语言写出来,就是:

【阶乘】(那啥)咋整:  # 定义套路 阶乘,有一个参数 那啥。
  寻思:那啥比一还小? # 需要自推吗?
  要行咧就 滚犊子吧 一。  # 不需要。
  要不行咧就 滚犊子吧 那啥乘整【阶乘】(那啥减一)。  # 需要。自推吧。
整完了。  # 定义结束。

出溜

“滚犊子吧”有它的局限性,那就是滚完之后套路就整不下去了。 有滴时候捏,俺们在一个套路里头滚完还想再滚,连滚带爬那种。 这又该咋整捏?

这个就涉及到一种全新的出行方式了:“出溜”。 出溜跟滚犊子的区别,在于出溜完了吧还可以在套路里接着出溜。 一直到套路弄完了,或者是使套路的银半途而废为止。

举个栗子。

体育老师今天病了。 数学老师给大家讲啥叫平方数。

所谓平方数,就是从一一得一,二二得四,三三得九开始,一直向下数不停。 就好了。 写成 dongbei 语言,揍是这样的:

平方数 咋整:
  数学老师 是活雷锋。
  数学老师 装 一。
  老王 从一而终磨叽:
    数学老师 乘 数学老师 出溜。
    数学老师 走走。
  磨叽完了。
整完了。

每次数学老师走走,他的值就加个一。

每次一出溜,就会从套路里蹦出来(数学老师 乘 数学老师)的当前值。 这个值捏,一开始是 1,然后是4,9,16......

接下来是提问时间:如何利用这个平方数的套路打印出100以内的平方数捏? 这个难不倒小明:

小明 在 整 平方数 磨叽:
  寻思:小明比 100 还大?
  要行咧就 尥蹶子!
  嘀咕:小明。
磨叽完了。

这样一搞,就会出来前十个平方数啦。

有同学问了:这道题用自推不可以吗?干嘛要出溜啊?

问滴好!会自推,确实没有必要一定要出溜。 可是!出溜经常比自推省事儿。 不信你把这道题用自推做做试试。

阶级

伟大领袖教导我们,银一出生就打上了阶级的烙印。 一个银,不属于这个阶级,必然属于那个阶级。 超越阶级存在的银,是不可能的。

所以,在 dongbei,所有的活雷锋都可以根据他们拥有的财产(洋文叫 properties)划分成不同的阶级(class)。

银的财产是可以继承的。 老子的财产,儿子都可以有。 按照这个财产继承的关系,不同的阶级可以分出三六九等。

最高高在上的,是无产阶级。 顾名思义,无产阶级没有任何财产(properties)。

在 dongbei,我们可以用

XX 阶级的接班银 YY 阶级咋整:
  ...
整完了。

来定义一个叫 YY 的新阶级。 每个 YY 阶级的成员,都继承了 XX 阶级的全部财产。

比如:

无产阶级的接班银 YY 阶级咋整:
  ...
整完了。

要给一个阶级创造一个新的对象,先定义如何初始化这个对象:

无产阶级的接班银 有名 阶级咋整:
  新对象(名字)咋整:  # 要初始化一个有名的对象,得提供一个参数(名字)。
    俺的名字 装 名字。  # 把这个对象的名字设成提供的参数。
  整完了。
整完了。

完了吧就可以按需分配对象了:

# 创建一个有名阶级的对象,他的名字参数是“林蛋大”。
老林 装 有名的新对象(“林蛋大”)。

然后咧就可以使用这个对象的财产了:

嘀咕:老林的名字。  # 打印:林蛋大

前面说过,阶级之间是有继承关系的。 要是阶级乙是从阶级甲继承来的,那么在创建阶级乙的新对象的时候,可以先创建阶级甲的对象:

有名 阶级的接班银 特有名 阶级咋整:
  新对象咋整:
    # 先按 有名 阶级的方法初始化这个对象。
    整 领导的新对象(“赵英俊”)。

    # 再加一些 特有名 阶级的操作。
    俺的 年龄 装 25。
  整完了。
整完了。

老赵 装 特有名 的新对象。
嘀咕:老赵 的 名字。  # 赵英俊
嘀咕:老赵 的 年龄。  # 25

一个阶级的成员除了有财产,还可以有自己的套路。 定义阶级套路的办法跟定义普通套路是一样的,只要把它的定义放在一个阶级内部就好了。 在阶级套路里面,可以直接使用一个叫 的特殊活雷锋。 指代当前对象。 比如:

有名 阶级的接班银 特有名 阶级咋整:
  ...
  公岁咋整:
    滚犊子吧 俺的年龄除以二!
  整完了。

  显呗咋整:
    嘀咕:“我你都不认识啊?我是那啥”、俺的名字、“!”。
  整完了。
整完了。

定义完阶级套路过后,只要有一个这个阶级的对象,就可以整这个套路了:

老赵 装 特有名 的新对象。
嘀咕:老赵 整 公岁。  # 12.5
老赵 整 显呗。  # 我你都不认识啊?我是那啥赵英俊!

帮衬

在家啃父母,出门靠姐妹儿。 甭管你多大能耐,没人帮衬也不成。 所以咱们写 dongbei 程序得借力,憋啥玩意儿都自己从头整。 比如翠花蛇家宝贝不少,咱就借来用用呗。

举例说明,

翠花,上 re。  # 导入 python 的正则表达式 re 模块。
老王装“abd”。
寻思:整re.match(“a.*”,老王)?  # 调用 re.match()。
要行咧就嘀咕:“OK!”。
要不行咧就嘀咕:“砸了!”。

跑出来结果

OK!

特殊名字

最高指示 是一个特殊的名字。 它是一个群众变量,装的是当前运行的命令行。比如有一个程序是这样的:

# a.dongbei
嘀咕:最高指示。  # 打印当前命令行。

那么

src/dongbei.py a.dongbei 今天 风大

的结果就是

「'a.dongbei', '今天', '风大'」

要是想歇两秒再接着干,就

整 打个盹(二)。

以此类推,多歇几秒也是可以的:

# 睡个半小时。
整 打个盹(30 乘 60)。