编程C,C ++,Java,PHP,Ruby,图灵,VB
计算机科学加拿大 
编程C,C ++,Java,PHP,Ruby,图灵,VB  

用户名:    Password: 
  登记 登记    
 IO介绍
指数 -> 一般编程
转到页面 1, 2   下一个
查看上一个主题 可打印的版本下载主题订阅本主题私人信息刷新页面 查看下一个主题
作者 信息
WTD.




 邮政 发布: Sun 1月1日,2006年6:06 PM  帖子主题:IO介绍

为什么另一种编程语言?

我们都听到了表达“在盒子外思考”。这意味着你不应该让你的想法受到你习惯的限制。

每种编程语言都迫使我们在一个盒子里面思考。一些盒子较小,有些盒子更大,但它们仍然是盒子。那时获得广泛理解的唯一方法,就可以了解尽可能多的编程语言。

为什么 编程语言?

学习在学习编程语言时,学生绊倒了两件事。它们要么对语法或语义都有问题。语言看起来如何,或者它的行为方式。

语法并非没有重要性。寻找更简单的方式做事是好的。但句法便利似乎只是一个支持有益语义的支持。

在功能性编程语言中,我们不认为通过匿名功能传递的能力是有用的,因为语法是有用的。

代码:
\X -> x * 3 + 16


这是有用的,因为能够快速生成函数并将其传递为值。这是我们可以在其他地方使用的想法。我们很少能够使用的语法。

IO是一种具有最小句法规则的编程语言。因为没有太多的情况,很少有足以绊倒。这强调了语义。

那么哎呀是什么?

IO是一种纯粹面向对象的编程语言。 IO中的一切都是一个对象。

这意味着什么?好吧,简单地说,这意味着语言是一致的。

代码:
Io> "hello" size
==> 5
Io> list(1, 2, 3) size
==> 3
Io> "hello" foreach(i, x,
       writeln(i, ": ", x asCharacter)
    )
0: h
1: e
2: l
3: l
4: o

==> Nil
Io> list(1, 2, 3) foreach(i, x,
       writeln(i, ": ", x)
    )
0: 1
1: 2
2: 3

==> Nil
Io> "hello" print
你好
==> hello
Io> 9 print
9
==> 9


一个大的是IO有一个交互式解释器,可以轻松实验代码。

这可能不会告诉你一个很多,所以让我们更具体一点。

你好, world

代码:
Io> writeln("hello, world")
你好, world

==> Nil


这里发生了什么?

Well, "Writeln." is a message.

3d中奖规则具有接收器,可选择参数。在程序的顶级,接收器是隐式对象的。因此,我们可以轻松地写下以下内容。

代码:
Io> Object writeln("Hello, world")
你好, world

==> Nil


在这种情况下的论点是字符串,“Hello,World”。

当“writeln”3d中奖规则发送给对象时,它会查找相应的方法并将其调用它提供的参数。

在看到如下执行的相同操作之前,3d中奖规则传递并不是那么明显。

代码:
Io> perform("writeln", "Hello, world")
你好, world

==> Nil


数学和东西怎么样?

运营商存在,并且对于我们所有的数学需求非常方便。它们还遵循您习惯的相同的级级规则。

代码:
Io> 1 + 1
==> 2
Io> 2 + 3 * 4
==> 14


那么,这个网格如何与3d中奖规则的想法和一致性?

好吧,让我们重写上述内容。

代码:
Io> 1 +(1)
==> 2
Io> 2 +(3 *(4))
==> 14


这样做只是丑陋。

变量?

想要为信息提供名称并不罕见。

代码:
Io> msg := "Hello, world"
==> Hello, world
Io> writeln(msg)
你好, world

==> Nil


但是这里真的发生了什么?

代码:
Io> Object writeln(Object msg)
你好, world

==> Nil


与writeln一样,对象隐含地存在。

因此,“MSG”变为与“插槽”相关的值。

对象以外的接收器?

代码:
Io> msg println
你好, world

==> Hello, world


这里msg是接收器,并打印3d中奖规则。当然,隐式对象仍然存在。

代码:
Io> Object msg println
你好, world

==> Hello, world


也许这更容易理解如下。

代码:
Io> (Object msg) println
你好, world

==> Hello, world


PrintLN3d中奖规则正在发送到“对象MSG”。习惯于没有括号的版本,Thogh,因为这就是你从这里看到的东西。

创建自己的方法

到目前为止,我们只看到了一个很少的标准库提供了方法。让我们创造一个。

代码:
Io> sayHello := method("Hello" println)
==> method("Hello" println)
Io> sayHello
你好

==> Hello


这里没有什么新鲜事。 :=和方法都是3d中奖规则。以下是更详细的版本。

代码:
Io> Object sayHello := Object method("Hello" println)
==> method("Hello" println)
Io> Object sayHello
你好

==> Hello


让我们添加一个论点。

代码:
Io> sayHelloTo := method(name, writeln("Hello ", name))
==> method(name, writeln("Hello ", name))
Io> sayHelloTo("Bob")
你好Bob

==> Nil


如果该方法有很多参数,该怎么办?

代码:
Io> sayHelloTo := method(
       这个争论争论(arg,
          writeln("Hello ", doMessage(arg))
       )
    )
==> method(这个争论争论(arg, writeln("Hello ", doMessage(arg))))
Io> sayHelloTo("Bob")
你好Bob

==> Nil
Io> sayHelloTo("Bob", "John")
你好Bob
你好John

==> Nil


那么,这里发生了什么?什么是“thismessage”?

这是指好的,目前的3d中奖规则。如果是:

代码:
打招呼("Bob", "John")


它指的是Sayhelloto3d中奖规则的传递。该对象的参数插槽包含包含参数的列表。这相当简单。

对于该列表,我们发送“foreach”3d中奖规则。对于该列表中的每个参数,请评估3d中奖规则。当然,这里我们向“foreach”发送了两个参数,所以第一个是我们向列表中的每个参数提供的名称。

那么,为什么我们不能写下面?

代码:
Writeln.("Hello ", arg)


列表中的参数不是简单的值。它们实际上是在评估之前代表3d中奖规则本身的对象。要评估这些3d中奖规则并获取结果值,我们可以使用Domessage3d中奖规则。

如何结合在一起是合理的直截了当。

条件

如果我们希望它打印“Hello World”如果没有参数?

代码:
Io> sayHelloTo := method(
       args :=这个名称参数
       if(args size == 0,
          "Hello world" println
          return(Nil)
       )
       args foreach(arg,
          writeln("Hello ", doMessage(arg))
       )
    )
==> method(setSlot("args",这个争论论点);
if(args size ==(0), "Hello world" println;
返回 (Nil));
args.. foreach(arg, writeln("Hello ", doMessage(arg))))
Io> sayHelloTo
你好world

==> Nil


Here we can see first off the addition of the "args.." slot to give a more convenient name to the arguments list.

下一个新的当然是条件。如果没有争论Sayhelloto,那么我们首先打印“Hello World”,然后我们将返回3d中奖规则与Argument Nil发送。返回3d中奖规则会导致控制流跳至该方法的末尾。

值得注意的是,这里的多个3d中奖规则被认为是IF3d中奖规则的单个3d中奖规则。它们被换绳子分开,但可以通过半冒号分开,作为代码“==”>" shows.

现在这里我们只为“如果”提供两个参数。我们可以提供三个。

代码:
Io> sayHelloTo := method(
       args :=这个名称参数
       if(args size == 0,
          "Hello world" println,
          args foreach(arg,
             writeln("Hello ", doMessage(arg))
          )
       )
    )
==> method(setSlot("args",这个争论论点);
if(args size ==(0), "Hello world"println,args foreach(arg, writeln("Hello ", d
Omessage.(arg)))))


这里的第三个论点成为条件的“else”部分。由于只能评估两条3d中奖规则中的一个,因此不再需要显式返回。

评估3d中奖规则和对“如果”的更大欣赏

让我们来实现自己的“如果”3d中奖规则。

代码:
Io> myIf := method(
       args :=这个名称参数
       if(args size == 2,
          if(doMessage(args at(0)), doMessage(args at(1)))
       )
       if(args size == 3,
          if(doMessage(args at(0)),
             doMessage(args at(1)),
             doMessage(args at(2))
          )
       )
    )
==> method(setSlot("args",这个争论论点); if(args size ==(2), if(doMessage(args at(0)), doMessage(args at(1)))); if(args size ==(3), if(doMessage(args at(0)), doMessage(args at(1)), doMessage(args at(2)))))
Io> myIf(4 == 3, "foo" print, "bar" print)
酒吧
==> bar
Io> myIf(4 == 3, "foo" print, "bar" print; "baz" print)
酒吧baz
==> baz


它是合理的“如果”复制,这很简单。那么这是如何工作的?

它不适用于许多其他语言。它们严格评估表达式(“3d中奖规则”的粗略等同物)。如果某些东西被传递为方法/函数/ etc的参数。立即评估它,任何副作用都会立即显而易见。

这是我们不能有条件的东西。它必须只评估一个论点或另一个论点。幸运的是,io很简单。因此,写自己的控制结构是一块蛋糕。

更灵活的条件

到目前为止,我们看到的条件只是桃子......如果我们想要两种可能性之间非常简单的决定。当我们有很多可能性时,它看起来不那么好。

代码:
写("Your name is? ")
名称:=文件StanditalInput Readline

if(name == "Clarence") then(
   writeln("What a goofy name.")
) elseif(name == "Sid") then(
   writeln("Sure it is...")
) else(
   writeln("Hello ", name)
)


您将注意到我不仅仅是从口译员复制和粘贴它。相反,我将其保存在名为“hello.io”的文件中,并使用“io hello.io”从命令行运行它。

或者,您可以打开解释器并发送以下3d中奖规则。

代码:
dofile.("hello.io")


这将运行该文件。如果您在该文件中创建了新方法,则稍后将在解释器中可用。

将插槽添加到对象以外的东西

到目前为止,我们所做的就是为对象提供新的变量和方法。我们可以尝试添加别的东西。

代码:
Io> Number double := method(self * 2)
==> method(self *(2))
Io> 2 double
==> 4


但是,那么“数字”都会出现?

数字只是对象的克隆。然后它有一堆额外的东西。 但, 那些东西被加到数字上,而不是对象。例如,+对数字有效,但不是对象。

代码:
Io> a := Object clone
==> Object_0074B3B0 do(
  appendProto(Object_003FD640)
)

Io> a + 4


进口商:对象没有响应'+'

标签                 Line       Char    Message
--------- - - ---------------------------------------------
VMCODE.                619        18724   raise("Importer", theObject type ..(" do)...
VMCODE.                623        18927   find(这个名字,自我)
[命令行]        1          3       +(4)


==> Nil
Io> a := Number clone
==> 0
Io> a + 4
==> 4


然而,对象是数字的原型,因此数字响应所有3d中奖规则对象。那些已经熟悉面向对象的编程的人应该思考现在的“继承”。

但让我们创造一些新的东西。

代码:
Io> Name := Object clone
==> Object_00789D90 do(
  appendProto(Object_003FD640)
)

Io> Name first := ""
==>
Io> Name last := ""
==>
Io> Name fullName := method(first with(" ") with(last))
==> method(first with(" ") with(last))


那看起来很乱。让我们使用“do”3d中奖规则来清理它。

代码:
Io> Name := Object clone do(
       first := ""
       last := ""
       fullName := method(first with(" ") with(last))
    )
==> Object_0073A9C8 do(
  appendProto(Object_003FD640)
  first := ""
  last := ""
  fullName := Block_0078D3B8
)


现在,我们希望创建新的名称对象。

代码:
Io> myName := Name clone do(
       first := "Bob"
       last := "Smith"
    )
==> Object_00727DC8 do(
  appendProto(Object_0073A9C8)
  first := "Bob"
  last := "Smith"
)

Io> myName fullName
==> Bob Smith


MyName对象具有原型名称,从而响应FullName3d中奖规则。现在,如果我们想要更正式的名字,怎么办?

代码:
Io> FormalName := Name clone do(
       title := ""
       fullName := method(
          name := resend
          title with(" ") with(name)
       )
    )
==> Object_00759DC0 do(
  appendProto(Object_0073A9C8)
  title := ""
  fullName := Block_0075A2A8
)

Io> myName :=拼写克隆(
       first := "Bob"
       last := "Smith"
       title := "Mr."
    )
==> Object_00767A88 do(
  appendProto(Object_00759DC0)
  title := "Mr."
  first := "Bob"
  last := "Smith"
)

Io> myName fullName
==> Mr. Bob Smith


由于名称是拼写名称的原型,我们可以使用重新发送3d中奖规则将全名称发送给获取名称和姓氏的组合的名称。然后,我们只是将标题添加到此开头。

各种原型神话人

那么,如果我有什么:

代码:
Io> myName := Name clone do(
       first := "Bob"
       last := "Smith"
    )
==> Object_00727DC8 do(
  appendProto(Object_0073A9C8)
  first := "Bob"
  last := "Smith"
)

Io> myName fullName
==> Bob Smith


我希望能够将其视为铭文?

代码:
Io> myName do(
       title := "Mr."
       prependProto(FormalName)
    )
==> Object_00742368 do(
  appendProto(Object_00746850,Object_007566B0.)
  title := "Mr."
  first := "Bob"
  last := "Smith"
)

Io> myName fullName
==> Mr. Bob Smith


那么,我究竟是做的?

我向MyName添加了标题插槽,我将拼写名称添加到MyName的原型列表中。

然后,当我向MyName发送全名称3d中奖规则时,而不是以全名称为名称,它在拼写名称中找到了一个完全合适的版本,而是使用它。我说服了你的名字,实际上是一个铭文。

运营商

所以,让我们说我们想检查两个名称是否为平等。

代码:
Io> Name setSlot("==",
       method(other,
         其他第一个==第一个和其他最后一个==最后
       )
    )
==> method(其他,其他第一个==(first) and(other last ==(last)))
Io> a := Name clone do(first := "Bob"; last := "Smith")
==> Object_00724490 do(
  appendProto(Object_007566B0)
  first := "Bob"
  last := "Smith"
)

Io> b := a clone
==> Object_00725BE8 do(
  appendProto(Object_00724490)
)

Io> a == b
==> Bob
Io> b := a clone do(last := "Wilson")
==> Object_00728DC0 do(
  appendProto(Object_00724490)
  last := "Wilson"
)

Io> a == b
==> Nil


然后定义相反的是简单地检查它们是否不等于。如果==返回nil,则它们不等于。

代码:
Io> Name setSlot("!=", method(other, (self == other) isNil))
==> method(other, (self ==(other)) isNil)
赞助
赞助
 赞助
 赞助
塞万提斯




 邮政 发布: Sun 1月1日,2006年6:37 PM  帖子主题:(没有主题)

WTD写道:

如果该方法有很多参数,该怎么办?
代码:

Io> sayHelloTo := method(
       这个争论争论(arg,
          writeln("Hello ", doMessage(arg))
       )
    )
...... ...



如果我在这里使用错误的术语,请原谅我,但这里给出了两个参数,这似乎与你在开始时使用的foreach是相比:
代码:

Io> "hello" foreach(i, x,
       writeln(i, ": ", x asCharacter)
    )


这是一个可选参数的一个例子吗?


IO的一个很好的介绍。谢谢wtd。  微笑
WTD.




 邮政 发布: Sun 1月1日,2006年6:39 PM  帖子主题:(没有主题)

使用三个参数发送foreach3d中奖规则时,第一个充当索引。
塞万提斯




 邮政 发布: Sun 1月1日,2006年6:43 PM  帖子主题:(没有主题)

 眨眼

我从第一个例子的输出中得到了那个。但是,它有点奇怪,因为所谓的“可选”参数取自开始,但这必须是具有“功能”的“身体”(缺乏My Io-ingerinology)的直接后果。范围。
WTD.




 邮政 发布: Sun 1月1日,2006年7:19 PM  帖子主题:(没有主题)

每次发送3d中奖规则时,参数都存储在列表中。您可以在运行时使用此列表执行任何您想要的任何内容。
WTD.




 邮政 发布: Sun 1月1日,2006年9:25 PM  帖子主题:(没有主题)

哦,是的,有关更多信息:

http://www.iolanguage.com
纳米




 邮政 发布: Sun 1月1日,2006年10:27 PM  帖子主题:(没有主题)

WTD写道:
代码:
Io> Name setSlot("==",
       method(other,
         其他第一个==第一个和其他最后一个==最后
       )
    )
==> method(其他,其他第一个==(first) and(other last ==(last)))
Io> a := Name clone do(first := "Bob"; last := "Smith")
==> Object_00724490 do(
  appendProto(Object_007566B0)
  first := "Bob"
  last := "Smith"
)

Io> b := a clone
==> Object_00725BE8 do(
  appendProto(Object_00724490)
)

Io> a == b
==> Bob
Io> b := a clone do(last := "Wilson")
==> Object_00728DC0 do(
  appendProto(Object_00724490)
  last := "Wilson"
)

Io> a == b
==> Nil


在第一个示例中,为什么该方法返回“Bob”而不是“true”,“1”或“bob smith”
Rizzix.




 邮政 发布: Sun 1月1日,2006年11:06 PM  帖子主题:(没有主题)

基于原型和纯粹的。  非难 完美的语言?  眨眼
赞助
赞助
 赞助
 赞助
WTD.




 邮政 发布: 2006年1月02日星期八12:34  帖子主题:(没有主题)

纳米 写道:
WTD写道:
代码:
Io> Name setSlot("==",
       method(other,
         其他第一个==第一个和其他最后一个==最后
       )
    )
==> method(其他,其他第一个==(first) and(other last ==(last)))
Io> a := Name clone do(first := "Bob"; last := "Smith")
==> Object_00724490 do(
  appendProto(Object_007566B0)
  first := "Bob"
  last := "Smith"
)

Io> b := a clone
==> Object_00725BE8 do(
  appendProto(Object_00724490)
)

Io> a == b
==> Bob
Io> b := a clone do(last := "Wilson")
==> Object_00728DC0 do(
  appendProto(Object_00724490)
  last := "Wilson"
)

Io> a == b
==> Nil


在第一个示例中,为什么该方法返回“Bob”而不是“true”,“1”或“bob smith”


希望以下内容将有助于展示:

代码:
Io> 4 == 4 and 3 == 3
==> 4
Io>4 == 4和3 == 3和5 == 5
==> 4
Io> 4 == 4和3 == 3或5 == 5
==> 4


并展示估值:

代码:
Io> block(4 == 4和3 == 3或5 == 5)
==> block(4 ==(4) and(3 ==(3)) or(5 ==(5)))
WTD.




 邮政 发布: 2006年1月02日1:36 AM  帖子主题:(没有主题)

唯一的“假”是零。因此,像“4 == 4”的比较没有返回“真实”,它返回4. 4是真的,并保持信息周围的信息不能伤害。

代码:
Io> if(4 == 4, writeln("foo"))
Foo

==> Nil
WTD.




 邮政 发布: 2006年1月02日1:48 AM  帖子主题:(没有主题)

Rizzix写道:
基于原型和纯粹的。  非难 完美的语言?  眨眼


我很惊讶你对一种允许创建新运营商的语言如此愉快。  眨眼

代码:
Io> Sequence setSlot("+|+", method(other, with(other)))
==> method(other, with(other))
Io> "hello" +|+ " " +|+ "world"
==> hello world


当你看到时,我也有点惊讶你没有中风 .
纳米




 邮政 发布: 2006年1月2日星期八2:10  帖子主题:(没有主题)

WTD写道:
唯一的“假”是零。因此,像“4 == 4”的比较没有返回“真实”,它返回4. 4是真的,并保持信息周围的信息不能伤害。

代码:
Io> if(4 == 4, writeln("foo"))
Foo

==> Nil


啊,现在我明白了  很高兴
WTD.




 邮政 发布: 2006年1月02日星期八3:36  帖子主题:(没有主题)

纳米 写道:
啊,现在我明白了  很高兴


优秀的!
Rizzix.




 邮政 发布: 2006年1月02日星期八8:09  帖子主题:(没有主题)

WTD写道:
我很惊讶你对一种允许创建新运营商的语言如此愉快。  眨眼
我做了。但我决定现在忽略它。这是我可以提出“好”的回复。但是,如果他们没有添加运算符重载,那么它会反对IO的哲学..是的..是的。它基本上归结为严格预防 - 滥用虐待,并选择繁重。

WTD写道:
当你看到时,我也有点惊讶你没有中风 .

我猜原型呼吁混合呢  眨眼
德拉邦Zeil.




 邮政 发布: 2006年1月02日星期一上午10:45  帖子主题:(没有主题)

这看起来很有趣。我会把它放在我的东西上学习列表。
从上一个显示帖子:   
    指数 -> 一般编程
查看上一个主题 告诉一个朋友可打印的版本下载主题订阅本主题私人信息刷新页面 查看下一个主题

12  [ 17 Posts ]
转到页面 1, 2   下一个
跳到:    


Style:  
搜索: