161 lines
2.7 KiB
CoffeeScript
161 lines
2.7 KiB
CoffeeScript
# Simple variable swapping.
|
|
a = -1
|
|
b = -2
|
|
|
|
[a, b] = [b, a]
|
|
|
|
eq a, -2
|
|
eq b, -1
|
|
|
|
func = ->
|
|
[a, b] = [b, a]
|
|
|
|
eq func().join(' '), '-1 -2'
|
|
eq a, -1
|
|
eq b, -2
|
|
|
|
#713
|
|
eq (onetwo = [1, 2]), [a, b] = [c, d] = onetwo
|
|
ok a is c is 1 and b is d is 2
|
|
|
|
|
|
# Array destructuring, including splats.
|
|
[x,y...,z] = [1,2,3,4,5]
|
|
|
|
ok x is 1
|
|
ok y.length is 3
|
|
ok z is 5
|
|
|
|
[x, [y, mids..., last], z..., end] = [1, [10, 20, 30, 40], 2,3,4, 5]
|
|
|
|
ok x is 1
|
|
ok y is 10
|
|
ok mids.length is 2 and mids[1] is 30
|
|
ok last is 40
|
|
ok z.length is 3 and z[2] is 4
|
|
ok end is 5
|
|
|
|
|
|
# Object destructuring.
|
|
obj = {x: 10, y: 20, z: 30}
|
|
|
|
{x: a, y: b, z: c} = obj
|
|
|
|
ok a is 10
|
|
ok b is 20
|
|
ok c is 30
|
|
|
|
person = {
|
|
name: "Moe"
|
|
family: {
|
|
'elder-brother': {
|
|
addresses: [
|
|
"first"
|
|
{
|
|
street: "101 Deercreek Ln."
|
|
city: "Moquasset NY, 10021"
|
|
}
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
{name: a, family: {'elder-brother': {addresses: [one, {city: b}]}}} = person
|
|
|
|
ok a is "Moe"
|
|
ok b is "Moquasset NY, 10021"
|
|
|
|
test = {
|
|
person: {
|
|
address: [
|
|
"------"
|
|
"Street 101"
|
|
"Apt 101"
|
|
"City 101"
|
|
]
|
|
}
|
|
}
|
|
|
|
{person: {address: [ignore, addr...]}} = test
|
|
|
|
ok addr.join(', ') is "Street 101, Apt 101, City 101"
|
|
|
|
|
|
# Pattern matching against an expression.
|
|
[a, b] = if true then [2, 1] else [1, 2]
|
|
|
|
ok a is 2
|
|
ok b is 1
|
|
|
|
|
|
# Pattern matching with object shorthand.
|
|
|
|
person = {
|
|
name: "Bob"
|
|
age: 26
|
|
dogs: ["Prince", "Bowie"]
|
|
}
|
|
|
|
{name, age, dogs: [first, second]} = person
|
|
|
|
ok name is "Bob"
|
|
ok age is 26
|
|
ok first is "Prince"
|
|
ok second is "Bowie"
|
|
|
|
# Pattern matching within for..loops
|
|
|
|
persons = {
|
|
George: { name: "Bob" },
|
|
Bob: { name: "Alice" }
|
|
Christopher: { name: "Stan" }
|
|
}
|
|
|
|
join1 = "#{key}: #{name}" for key, { name } of persons
|
|
|
|
eq join1.join(' / '), "George: Bob / Bob: Alice / Christopher: Stan"
|
|
|
|
persons = [
|
|
{ name: "Bob", parent: { name: "George" } },
|
|
{ name: "Alice", parent: { name: "Bob" } },
|
|
{ name: "Stan", parent: { name: "Christopher" } }
|
|
]
|
|
|
|
join2 = "#{parent}: #{name}" for { name, parent: { name: parent } } in persons
|
|
|
|
eq join1.join(' '), join2.join(' ')
|
|
|
|
persons = [['Bob', ['George']], ['Alice', ['Bob']], ['Stan', ['Christopher']]]
|
|
join3 = "#{parent}: #{name}" for [name, [parent]] in persons
|
|
|
|
eq join2.join(' '), join3.join(' ')
|
|
|
|
|
|
# Pattern matching doesn't clash with implicit block objects.
|
|
obj = a: 101
|
|
func = -> true
|
|
|
|
if func func
|
|
{a} = obj
|
|
|
|
ok a is 101
|
|
|
|
[x] = {0: y} = {'0': z} = [Math.random()]
|
|
ok x is y is z, 'destructuring in multiple'
|
|
|
|
|
|
# Destructuring into an object.
|
|
obj =
|
|
func: (list, object) ->
|
|
[@one, @two] = list
|
|
{@a, @b} = object
|
|
{@a} = object # must not unroll this
|
|
null
|
|
|
|
obj.func [1, 2], a: 'a', b: 'b'
|
|
|
|
eq obj.one, 1
|
|
eq obj.two, 2
|
|
eq obj.a, 'a'
|
|
eq obj.b, 'b'
|