Dans Tapuscrit ce n' <T> signifie?

Question

export declare function createEntityAdapter<T>(options?: {
    selectId?: IdSelector<T>;
    sortComparer?: false | Comparer<T>;
}): EntityAdapter<T>;

Quelqu'un peut-il m'expliquer ce que les moyens? Je connais <> est l'assertion de type mais je ne sais pas ce qu' 'T' est. Il faudrait aussi être utile si quelqu'un pourrait m'expliquer ce que cette fonction est en train de faire.

Answer 1

Quelqu'un peut-il m'expliquer ce qu' <T> les moyens?

C'est tapuscrits Génériques déclaration.

Extrait:

Une grande partie du génie logiciel est de construire des composants qui n'ont pas seulement bien définie et cohérente des Api, mais sont également réutilisables. Les composants qui sont capables de travailler sur les données d'aujourd'hui ainsi que les données de demain, qui va vous donner le plus souple des capacités pour la construction de grands systèmes logiciels.

Dans des langages tels que C# et Java, l'un des principaux outils dans la boîte à outils pour la création de composants réutilisables est les génériques, c'est être capable de créer un composant qui peut fonctionner sur une variété de types plutôt qu'un seul. Cela permet aux utilisateurs de consommer ces composants et d'utiliser leurs propres types.

.

Je ne sais pas ce que " T " est.

'T' va être un type déclaré au moment de l'exécution au lieu de compiler temps. L' T d'une variable non déclarée variable (je ne pouvais pas trouver une référence, mais je suppose tout un ensemble de caractères qui pourraient être utilisés pour les noms de variables). De même, en c#, si le type T représente n'est pas un type de valeur, mais de plus en plus complexes de type (classe) ou de l'interface, il pourrait être nommé/benoit xvi a déclaré que TVehicle ou TAnimal pour aider à désigner un type valide pour les futurs programmeurs (et pourrait être considéré comme une bonne pratique, car il suffit de T n'est pas intuitif). Je préfère TSomething parce que je sais que T majuscule désigne un type générique. WSometing ou ASomething est aussi valable, mais je ne préfère pas elle. (Microsoft Api sont presque toujours TContext ou TEntity par exemple).

Il faudrait aussi être utile si quelqu'un pourrait m'expliquer ce que cette fonction est en train de faire.

Bien que la fonction n'est pas de faire quoi que ce soit. C'est plus de déclarer un type de fonction que peut avoir plusieurs type à l'exécution de valeurs. Au lieu d'expliquer que, je vais inclure un extrait directement à partir du lien ci-dessus.

function identity<T>(arg: T): T {
  return arg;
}

qui peut être utilisé comme:

// type of output will be 'string'
let output = identity<string>("myString");  

ou

// type of output will be 'string', the compiler will figure out `T`
// based on the value passed in
let output = identity("myString");  

ou

// type of output will be 'number'
let output = identity(8675309);  

Ce qui pourrait poser la question:

Pourquoi utiliser des génériques

Bien que Javascript a des tableaux, mais lorsque vous récupérez une valeur du tableau, littéralement, pourrait être n'importe quoi (tapuscrit: any). Avec la machine, vous obtenez le Type de sécurité en les déclarant comme:

 // Array<T>
 let list: number[] = [1, 2, 3];
 // or 
 let list: Array<number> = [1, 2, 3];

Maintenant, chaque valeur dans le tableau a un type. Tapuscrit lèvera une erreur de compilation si vous essayez de mettre une chaîne de caractères dans ce tableau. Et vous obtenez de sécurité du type et de l'intellisense (en fonction de votre éditeur) lorsque vous récupérer une valeur:

class Person {
  FirstName: string;
}

let people: Array<Person> = [];
people.push({ FirstName: "John" } as Person);

let john = people.pop();  
// john is of type Person, the typescript compiler knows this
// because we've declared the people variable as an array of Person

console.log(john.FirstName);  

Déclarer le type avait des contraintes génériques. Un très bon exemple de Ouvert - Fermé Principe.

En programmation orientée objet, l'ouvert/fermé principe états "logiciel entités (classes, modules, fonctions, etc.) doit être ouvert pour l'extension, mais fermées pour la modification";[1] c'est, par exemple, une entité peut permettre à son comportement pour être prorogé sans modification de son code source.

Dans l'exemple suivant, n'importe qui pourrait s'étendre de l'Homme ou Cheeah ou même créer leur propre type dérivé et l'Enregistreur de la fonctionnalité de continuer à travailler sans aucune modification.

interface IAnimal {
  LegCount: number;
}

class Cheetah 
  implements IAnimal {
  LegCount: number = 4;
}

class Human
  implements IAnimal {
  LegCount: number = 2;
}

public class Logger<TAnimal extends IAnimal> {
  public Log(animal: TAnimal) {
    console.log(animal.LegCount);
  }
}

var logger = new Logger();
var human = new Human();
logger.Log(human);      

Exemple De Travail

Dans l'exemple précédent, j'ai utilisé une Contrainte Générique pour limiter l' TAnimal type de programmeurs peuvent utiliser pour créer un Logger exemple de types qui dérivent de l'interface IAnimal. Cela permet au compilateur de vérifier que l' Logger classe suppose toujours que le type a une propriété LegCount.

Answer 2

L'exemple que vous fournissez est une fonction avec un paramètre générique. T (qui ne doit pas être T. On pourrait appeler cela G.) est appelé un modèle générique où le type réel de l' T est remplacé à l'exécution.

Imaginez EntityAdapter a la suite de la mise en œuvre:

interface EntityAdapter<T> {
   save(entity: T);
}

Ci-dessous le code renvoie une EntityAdapter dont le contenu est - any. any pourrait être texte,nombre, objet ou quoi que ce soit.

let adapter1 = createEntityAdapter<any>(<parameters here>)

Ci-dessous le code renvoie une EntityAdapter dont le contenu est - Car.

let adapter2 = createEntityAdapter<Car>(<parameters here>)

Fondamentalement, Car plus précis que l' any , de sorte que vous pouvez obtenir de type supplémentaire de sécurité. Alors, comment cela vous aide?

En un mot, modèle générique peut vous donner plus de sécurité de type. Par exemple,

adapter1.save('I am string') // this works because `T` is `any`
adapter1.save(new Car()) // this also works because `T` is `any`

adapter2.save('I am string') // this wont works  because `T` is `Car`, typescript compiler will complains
adapter2.save(new Car()) //this works because `T` is `Car`

Espérons que cette aide.