cdanyl

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano()) // initialisation du générateur de nombres aléatoires

cdanyl

/*
 * Visitor pattern solves the problem elegantly. Start by modifying our base Fruit class:
 */
interface FruitVisitor {
  visit(fruit: Orange): void;
  visit(fruit: Apple): void;
  visit(fruit: Banana): void;
}

abstract class Fruit {

cdanyl

import {Injectable} from '@angular/core';
import {Configuration} from '../../../assets/config/config';
import {HttpClient} from '@angular/common/http';



@Injectable()
export class ConfigService {
  private defaultConfig: Configuration;
  private runningConfig: Configuration;

cdanyl

/**
 * Enum Alternatives in Typescript.
 * Enums are simple value-type flags that provide very minimal protection from invalid values and no behavior.
 * Displaying enums in UI elements like DropDownLists is another challenge if they need to have spaces.
 */
class Role {
  public static allRoles = [];

  public static Author: Role = new Role(0, 'Author');
  public static Editor: Role = new Role(1, 'Editor');

cdanyl

function makeProductList(productDb) {
  return Object.freeze({
    addProduct,
  })

  function addProduct() {
    return 1;
  }
}

cdanyl

import * as R from 'ramda';

import { HttpParams } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs/Observable';

import { ApiService } from '@core/api-service/api.service';
import { ApiResponseLegacy } from '@core/api-service/apiResponse.interface';
import { Company } from '@shared/services/company/company.model';

cdanyl

// Resolve promises one after another (i.e. in sequence)
function sequence(tasks, fn) {
  return tasks.reduce((promise, task) => promise.then(() => fn(task)), Promise.resolve());
}

function inSequence(tasks) {
    return tasks.reduce((p, task) => p.then(task), Promise.resolve())
}

cdanyl

// Constructors or Static Factory Methods VS. Polymorphism

/*
 * Advantages to using static factory methods instead of constructors
 * They have names.
 * They can cache.
 * They can subtype.
 */
class Color {
  private hex: number;

cdanyl

class Person {
  public name: string = "default";
  public address: string = "default";
  public age: number = 0;

  public constructor(init?: Partial<Person>) {
    Object.assign(this, init);
  }
}

cdanyl

/**
 * Classes vs. Objects "classes" vs. "behavior delegation (OLOO-style)"
 */

/**
 * ES6 class
 * Example: common base widget behavior, and then child derived classes for specific widget types (like Button)
 */
class Widget {
  constructor(width, height) {