Some C implementations permit code to write to one member of a union type then read from another in order to perform a sort of reinterpreting cast (parsing the new type as the bit representation of the old one).
It is important to note however, this is not permitted by the C standard current or pas...
You can declare multiple constants within the same const block:
const (
Alpha = "alpha"
Beta = "beta"
Gamma = "gamma"
)
And automatically increment constants with the iota keyword:
const (
Zero = iota // Zero == 0
One // One == 1...
Invoking a function as a method of an object the value of this will be that object.
var obj = {
name: "Foo",
print: function () {
console.log(this.name)
}
}
We can now invoke print as a method of obj. this will be obj
obj.print();
This will thus log:
Foo...
Invoking a function as an anonymous function, this will be the global object (self in the browser).
function func() {
return this;
}
func() === window; // true
5
In ECMAScript 5's strict mode, this will be undefined if the function is invoked anonymously.
(function () {
"use...
When a function is invoked as a constructor with the new keyword this takes the value of the object being constructed
function Obj(name) {
this.name = name;
}
var obj = new Obj("Foo");
console.log(obj);
This will log
{ name: "Foo" }
6
When using arrow functions this takes the value from the enclosing execution context's this (that is, this in arrow functions has lexical scope rather than the usual dynamic scope). In global code (code that doesn't belong to any function) it would be the global object. And it keeps that way, eve...
The apply and call methods in every function allow it to provide a custom value for this.
function print() {
console.log(this.toPrint);
}
print.apply({ toPrint: "Foo" }); // >> "Foo"
print.call({ toPrint: "Foo" }); // >> "Foo"
You mig...
The bind method of every function allows you to create new version of that function with the context strictly bound to a specific object. It is specially useful to force a function to be called as a method of an object.
var obj = { foo: 'bar' };
function foo() {
return this.foo;
}
fooOb...
let sel = document.getSelection();
let text = sel.toString();
console.log(text); // logs what the user selected
Alternatively, since the toString member function is called automatically by some functions when converting the object to a string, you don't always have to call it yourself.
console...
Values can be given names using let:
# let a = 1;;
val a : int = 1
You can use similar syntax to define a function. Just provide additional parameters for the arguments.
# let add arg1 arg2 = arg1 + arg2;;
val add : int -> int -> int = <fun>
We can call it like this:
# add 1...
The function keyword automatically has pattern matching when you define the
body of your function. Observe it below:
# let foo = function
0 -> "zero"
| 1 -> "one"
| 2 -> "couple"
| 3 -> "few"
| _ -> "many";;
val foo : int ->...
3.0
let string = "My fantastic string"
var index = string.startIndex
while index != string.endIndex {
print(string[index])
index = index.successor()
}
Note: endIndex is after the end of the string (i.e. string[string.endIndex] is an error, but string[string.startIndex] i...
[1, 2, [[3, 4], [5]], 6].flatten # => [1, 2, 3, 4, 5, 6]
If you have a multi-dimensional array and you need to make it a simple (i.e. one-dimensional) array, you can use the #flatten method.
Standard enumerations allow users to declare a useful name for a set of integers. The names are collectively referred to as enumerators. An enumeration and its associated enumerators are defined as follows:
enum myEnum
{
enumName1,
enumName2,
};
An enumeration is a type, one which is...
A common use for enumerators is for switch statements and so they commonly appear in state machines. In fact a useful feature of switch statements with enumerations is that if no default statement is included for the switch, and not all values of the enum have been utilized, the compiler will issue ...
Enums in Swift are much more powerful than some of their counterparts in other languages, such as C. They share many features with classes and structs, such as defining initialisers, computed properties, instance methods, protocol conformances and extensions.
protocol ChangesDirection {
mutati...
Using functions that take in and execute closures can be extremely useful for sending a block of code to be executed elsewhere. We can start by allowing our function to take in an optional closure that will (in this case) return Void.
func closedFunc(block: (()->Void)? = nil) {
print("...
We define the type of boolean expressions whose atoms are identified by strings as
type expr =
| Atom of string
| Not of expr
| And of expr * expr
| Or of expr * expr
and can evaluate these expressions using an oracle : string -> bool giving the values of the atoms we find as follows:
le...
