I have my own non-exhaustive list, and these are purely based on what I have used: JavaScript, TypeScript, C#
Safe Navigation Operator
This is also known as optional chaining operator, safe call operator, null-conditional operator.
Instead of writing multiple nested ifs, we just use usual chaining, but put question mark symbols ?
before dots (or other characters used for chaining).
String name = articles?[0]?.author?.name;
Null Coalescing Operator
This is the shorthand of the ternary conditional if operator x ? x : y
string pageTitle = suppliedTitle ?? "Default Title";
In JavaScript the OR operator ||
has the same behavior as the above. It returns the first operand if it evaluates to true, otherwise, it returns the second operand. When the left hand side is true, the right hand side is not even evaluated; it is "short-circuited."
let pageTitle = suppliedTitle || "Default Title"
Lambda
This is also known as anonymous function, function literal, lambda abstraction, or lambda expression.
const hello = (name) => `Hello ${name}`
You can do a lot of things with this construct. Currying, closures, high order functions etc.
Auto Implemented Properties
In C# auto-implemented properties make property-declaration more concise when no additional logic is required in the property accessors.
public string Name { get; set; }
In C# 6 and later, you can initialize auto-implemented properties similarly to fields:
public string FirstName { get; set; } = "Jane";
You can learn more about automatic properties here
Async/Await
The async/await pattern is a syntactic feature of many programming languages that allows an asynchronous, non-blocking function to be structured in a way similar to an ordinary synchronous function.
C#
public async Task<int> FindPageSize(Uri uri)
{
byte[] data = await new WebClient().DownloadDataTaskAsync(uri);
return data.Length;
}
JS
async function createNewDoc() {
let response = await db.post({}); // post a new doc
return await db.get(response.id); // find by id
}
Intersection / Union Types
In TypeScript, the intersection type combines types, so that you can have all properties and members of both types on your particular object or method.
target: string & Element;
Union types, meanwhile, are an either/or scenario. Instead of combining types to receive all members and properties, we use union types to specify that a method accepts either of several different types.
target: number | string;
JSON Serialize / Deserialize
JavaScript makes it very easy for us to serialize and deserialize JSON.
const obj = { name: 'Aivan' }
JSON.stringify(obj) // serialize object to JSON string
const str = `{name : "Aivan"}`
JSON.parse(str) // deserialize string to object
Template Literals
Template literals are string literals allowing embedded expressions. You can use multi-line strings and string interpolation features with them.
`string text
${expression}
string text`
Destructuring and Spread Operator
The destructuring assignment syntax is a JavaScript expression that makes it possible to unpack values from arrays, or properties from objects, into distinct variables.
var a, b, rest;
[a, b] = [10, 20];
console.log(a); // 10
console.log(b); // 20
[a, b, ...rest] = [10, 20, 30, 40, 50];
console.log(a); // 10
console.log(b); // 20
console.log(rest); // [30, 40, 50]
({ a, b } = { a: 10, b: 20 });
console.log(a); // 10
console.log(b); // 20
({a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40});
console.log(a); // 10
console.log(b); // 20
console.log(rest); // {c: 30, d: 40}
This is taken from the MDN
Object Property Value Shorthand
Instead of writing your objects like this:
const name = 'Aivan'
const obj = { name: name } // { name: 'Aivan'}
You can write it like this. This is possible if the name of the key and the variable name of the value is the same.
const name = 'Aivan'
const obj = { name } // { name: 'Aivan'}
Annotations / Decorators
Decorators provide a very simple syntax for calling higher-order function. It also allows for a cleaner syntax for applying wrappers around your code, resulting in something that detracts less from the actual intention of what you’re writing.
@Wove()
class DataMapper {
// ...
}
You can learn more about decorators here.
Default Parameters
Default parameters allow named parameters to be initialized with default values if no value or undefined is passed.
function multiply(a, b = 1) {
return a * b;
}
// you can call it like this
multiply(1) // 1
multiply(2, 2) // 4
Top comments (15)
List Comprehensions in Python is an interesting one. I absolutely love them in some cases, and despise them on others.
It's my first time to see such syntax since I haven't really touched Python. Looks interesting , I couldn't understand what the last line does though.
The last line is:
Pattern matching like you see in OCaml variants (ReasonML, F#, etc.)
Elixir has something similar in guards:
+1 for Guards.
Also I really enjoy Pipes, like
instead of
I think they are even coming to JS.
All these things almost look alien to me. I haven't done any heavy functional programming and let alone use a language that was specifically built for such purpose. This is something I'll definitely look into.
I'm not sure if I like it really, and I think its an anti-pattern in almost all cases, and some of it can be done via reflection in most languages, and I don't know the name for it...
This BS in PHP:
This comes from function pointer in C. You can create a function pointer, like this:
Let's say that we have an application which could connect to either MySQL or PostgreSQL. In a config file, the software could detect which DBMS is used, and then link all the DBMS interface correctly. Like this
So, in the DBMS manager module:
This is basically what is happening here. Since PHP is VERY weakly typed, any variable can be either an integer, float, string, boolean, a function pointer. In fact, they are all of those types. It is when you use them that they fall into the intended one #quantumTyped.
Kotlin's function literals with receiver and infix functions are pretty cool.
Function literals with receivers:
Infix:
Of those, async/await is certainly my favourite. It makes asynchronous programming so wonderfully obvious. I'm not too big a fan of decorators, because they hide underlying logic, making code less readable, if you're not handling them with care.
Even though it's not yet a native language feature in JavaScript or TypeScript, Observables (reactive programming style) are on their way to become one. Until then, we're fine with rxjs.
I also like the unique concept of borrowing in Rust and I like its traits, which allow for a lot of flexibility in the type system.
I was thinking of adding traits here but I have not used it extensively while I was doing PHP. The same is true with it though I believe that it should be handled with care.
I'll definitely checkout Rust.
I would say variadics, multiple returns, and interfaces in Go.
golang's "empty" switch statement (a cleaner else-if).
The way switch case work on golang alone is already interesting 😁
It has been a while since I've used C#, but I remember I really liked LINQ queries and local anonymous types that can be type-checked on compilation