Comparaison de CoffeeScript avec la grammaire JavaScript, Python et Ruby

Je l'écris comme ça avec Python et Ruby, mais je l'écris comme je le pense avec CoffeeScript.

• Ajout de JavaScript

commentaire

# comment

# comment

// comment

# comment

Commentaires qui s'étendent sur plusieurs lignes

Python n'a pas de commentaires sur plusieurs lignes, alors remplacez-le par une chaîne

'''
comment
'''

"""
comment
"""

=begin
comment
=end

/*
comment
*/

###
comment
###

Incorporer des personnages

>>> width = 100
>>> "{0}px".format(width)
"100px"
>>> "%dpx" % width
"100px"

width = 100
p "#{width}px"
# => 100px

width = 100;
console.log("" + width + "px");

Similaire à Ruby

width = 100
console.log "#{width}px"
# 100px

Une chaîne qui s'étend sur plusieurs lignes

>>> a = '''a
... b'''
"a\nb"

a = 'a
b'
# => "a\nb"

a = 'a\
      b';
// "a\n     b"

a = 'a
b'
# "ab"

Tableau associatif

d = {'a': 0, 'b': 2}

d = {:a => 0, :b => 2}

d = {a: 0, b: 2}

d = a: 0, b: 2
d = {a: 0, b: 2} #D'accord
#S'il s'étend sur plusieurs lignes`,`Peut être omis
d =
  a: 0  #Vous pouvez également ajouter des commentaires en cours de route
  b: 2
d = {
  a: 0
  b: 2
}

Tableau

l = [1, 3, 5]

l = [1, 3, 5]

l = [1, 3, 5]

l = [1, 3, 5]
#S'il s'étend sur plusieurs lignes`,`Peut être omis
l = [
  1
  3
  5
]

Tableau contigu

>>> range(5)
[0, 1, 2, 3, 4]
>>> range(5, 0, -1)
[5, 4, 3, 2, 1]
>>> range(2, 5)
[2, 3, 4]

[0...5]
# [0, 1, 2, 3, 4]
[0..4]
# [0, 1, 2, 3, 4]

[4...-1]
# [4, 3, 2, 1, 0]
[4..0]
# [4, 3, 2, 1, 0]

[2...5]
# [2, 3, 4]
[2..4]
# [2, 3, 4]

Accès au tableau

>>> l = range(10)
>>> l[1]
1
>>> l[2:4]
[2, 3]
>>> l[2:]
[2, 3, 4, 5, 6, 7, 8, 9]
>>> l[:4]
[0, 1, 2, 3]
>>> l[::3]
[0, 3, 6, 9]
>>> l[-1]
9
>>> l[3:6] = [6, 8, 9]
>>> l
[0, 1, 2, 6, 8, 9, 6, 7, 8, 9]

l = [0...10]
l[1]
# 1
l[2...4]
# [2, 3]
l[2...]
# [2, 3, 4, 5, 6, 7, 8, 9]
l[...4]
# [0, 1, 2, 3]
i for i in l by 3
# [0, 3, 6, 9]
l[l.length-1]]
# 9
l[3...6] = [6, 8, 9]
# [0, 1, 2, 6, 8, 9, 6, 7, 8, 9]

Notation d'inclusion de liste

Cas simple

>>> l = ['a', 'b', 'c']
>>> [v for v in l]
['a', 'b', 'c']
>>> [(i, v) for i, v in enumerate(l)]
[(0, 'a'), (1, 'b'), (2, 'c')]
>>> d = {'a': 0, 'b': 1, 'c': 2}
>>> [k for k in d]
['a', 'b', 'c']
>>> [(k, v) for k, v in d.items()]
[('a', 0), ('b', 1), ('c', 2)]

l = ['a', 'b', 'c']
v for v in l
# ['a', 'b', 'c']
[v for v in l]
# [ ['a', 'b', 'c'] ]
[i, v] for i, v in l
# [[0, 'a'], [1, 'b'], [2, 'c']]
d = a: 0, b: 1, c: 2
k for k of d
# ['a', 'b', 'c']
[k, v] for k, v of d
# [['a', 0], ['b', 1], ['c', 2]]

Filtrage à l'aide de la notation d'inclusion de liste

>>> [i for i in range(10) if i % 3 == 0]
[0, 3, 6, 9]

i for i in [0...10] when i % 3 is 0
# [0, 3, 6, 9]

La notation d'inclusion de liste CoffeeScript peut être plus variée

>>> for i in range(5)
...     print i
0
1
2
3
4

console.log i for i in [0...5]
# 0
# 1
# 2
# 3
# 4

une fonction

def func(arg, *args):
    pass

def func(arg, *args)
end

var func = function(arg) {
  var args = 2 <= arguments.length ? Array.prototype.slice.call(arguments, 1) : []
}

func = (arg, args...) ->

Appel de fonction

Python nécessite () pour appeler la fonction

>>> def foo(): return 'foo'
>>> foo
<function __main.foo>
>>> foo()
'foo'

Aucun rubis requis

def foo
  'foo'
end
p foo
# => foo
def bar(x)
  x
end
p bar 'bar'
# => bar

JavaScript n'est pas requis lors de la création d'une instance. Requis pour les appels normaux

var foo = function() {return 'foo'};
console.log(typeof foo);
// 'function'
console.log(foo());
// 'foo'
f = new foo;
console.log(f.construoctor === foo);
// true

CoffeeScript requiert () si aucun argument n'est passé, non requis s'il y a un argument

foo = -> 'foo'
console.log typeof foo
# 'function'
console.log foo()
# foo
bar = (x) -> x
console.log foo 'bar'
# bar

Valeur de retour de la fonction

Python et JavaScript nécessitent un «retour». Sinon, «None» est retourné pour Python, et «undefined» est retourné pour JavaScript.

>>> def bar(): 'bar'
>>> bar() is None
True

var bar = function() { 'bar' };
console.log(bar === undefined);
// true

Dans Ruby et CoffeeScript, la dernière phrase est «return».

def bar
  'bar'
end
bar
# => 'bar'

bar = -> 'bar'
bar()
# 'bar'

classe

>>> class Klass(object):
...     def __init__(self, name):
...         self.name = name
>>> k = Klass('hoge')
>>> k.name
"hoge"

class Klass
  attr "name"
  def initialize(name)
    @name = name
  end
end
k = Klass.new 'hoge'
p k.name
# => hoge

function Klass(name) {
  this.name = name;
}
var k = new Klass('hoge');
console.log(k.name);
// hoge

class Klass
  constructor: (name) ->
    @name = name
k = new Klass 'hoge'
console.log k.name
# hoge

Héritage

>>> class Parent(object):
...     def foo(self):
...         print 'parent'
>>> class Child(Parent):
...     def foo(self):
...         super(Child, self).foo()
...         print 'child'
>>> c = Child()
>>> c.foo()
parent
child

class Parent
  def foo
    p 'parent'
  end
end
class Child < Parent
  def foo
    super
    p 'child'
  end
end
c = Child.new
c.foo
# => parent
# => child

function Parent() {}
Parent.prototype.foo = function () { console.log('parent'); };
function Child() {}
Child.prototype = new Parent;
Child.prototype.foo = function () {
  Parent.prototype.foo.call(this);
  console.log('child');
}
var c = new Child;
c.foo();
// parent
// child

class Parent
  foo: ->
    console.log 'parent'
class Child extend 
  foo: ->
    super
    console.log 'child'
c = new Child
c.foo()
# parent
# child

Mixin

module Fooable
  def foo
    p 'foo'
  end
end
class Klass
  include Fooable
end
k = Klass.new
k.foo
# => 'foo

# https://gist.github.com/993415
class Mixin
  augment: (t) ->
    (t[n] = m unless n == 'augment' or !this[n].prototype?) for n, m of this
class Fooable extends Mixin
  foo: ->
    console.log 'foo'
class Klass
  constructor: ->
    Fooable::augment @
k = new Klass
k.foo()
# foo