AngularJS
Fonctions d'assistance intégrées
Recherche…
angular.equals
La fonction angular.equals compare et détermine si 2 objets ou valeurs sont égaux, angular.equals effectue une comparaison profonde et renvoie true si et seulement si au moins 1 des conditions suivantes est remplie.
angular.equals (value1, value2)
- Si les objets ou les valeurs passent la comparaison
=== - Si les deux objets ou les valeurs sont du même type et que toutes leurs propriétés sont également égales en utilisant
angular.equals - Les deux valeurs sont égales à
NaN - Les deux valeurs représentent le même résultat de l'expression régulière.
Cette fonction est utile lorsque vous avez besoin de comparer des objets ou des tableaux en fonction de leurs valeurs ou de leurs résultats plutôt que de simples références.
Exemples
angular.equals(1, 1) // true
angular.equals(1, 2) // false
angular.equals({}, {}) // true, note that {}==={} is false
angular.equals({a: 1}, {a: 1}) // true
angular.equals({a: 1}, {a: 2}) // false
angular.equals(NaN, NaN) // true
angular.isString
La fonction angular.isString renvoie true si l'objet ou la valeur qui lui est donné est du type string
angular.isString (value1)
Exemples
angular.isString("hello") // true
angular.isString([1, 2]) // false
angular.isString(42) // false
C'est l'équivalent de la performance
typeof someValue === "string"
angular.isArray
La fonction angular.isArray renvoie true si et seulement si l'objet ou la valeur qui lui est transmis est du type Array .
angular.isArray (valeur)
Exemples
angular.isArray([]) // true
angular.isArray([2, 3]) // true
angular.isArray({}) // false
angular.isArray(17) // false
C'est l'équivalent de
Array.isArray(someValue)
angular.merge
La fonction angular.merge prend toutes les propriétés énumérables de l'objet source pour étendre profondément l'objet de destination.
La fonction renvoie une référence à l'objet de destination maintenant étendu
angular.merge (destination, source)
Exemples
angular.merge({}, {}) // {}
angular.merge({name: "king roland"}, {password: "12345"})
// {name: "king roland", password: "12345"}
angular.merge({a: 1}, [4, 5, 6]) // {0: 4, 1: 5, 2: 6, a: 1}
angular.merge({a: 1}, {b: {c: {d: 2}}}) // {"a":1,"b":{"c":{"d":2}}}
angular.isDefined et angular.isUndefined
La fonction angular.isDefined teste une valeur si elle est définie
angular.isDefined (someValue)
C'est l'équivalent de la performance
value !== undefined; // will evaluate to true is value is defined
Exemples
angular.isDefined(42) // true
angular.isDefined([1, 2]) // true
angular.isDefined(undefined) // false
angular.isDefined(null) // true
La fonction angular.isUndefined teste si une valeur est indéfinie (c'est en fait l'opposé de angular.isDefined )
angular.isUndefined (someValue)
C'est l'équivalent de la performance
value === undefined; // will evaluate to true is value is undefined
Ou juste
!angular.isDefined(value)
Exemples
angular.isUndefined(42) // false
angular.isUndefined(undefined) // true
angular.isDate
La fonction angular.isDate renvoie true si et seulement si l'objet qui lui est transmis est du type Date.
angular.isDate (valeur)
Exemples
angular.isDate("lone star") // false
angular.isDate(new Date()) // true
angular.isNumber
La fonction angular.isNumber renvoie true si et seulement si l'objet ou la valeur qui lui est transmis est du type Number, cela inclut + Infinity, -Infinity et NaN
angular.isNumber (valeur)
Cette fonction ne provoquera pas une contrainte de type telle que
"23" == 23 // true
Exemples
angular.isNumber("23") // false
angular.isNumber(23) // true
angular.isNumber(NaN) // true
angular.isNumber(Infinity) // true
Cette fonction ne provoquera pas une contrainte de type telle que
"23" == 23 // true
angular.isFunction
La fonction angular.isFunction détermine et renvoie true si et seulement si la valeur passée à est une référence à une fonction.
La fonction renvoie une référence à l'objet de destination maintenant étendu
angular.isFunction (fn)
Exemples
var onClick = function(e) {return e};
angular.isFunction(onClick); // true
var someArray = ["pizza", "the", "hut"];
angular.isFunction(someArray ); // false
angular.toJson
La fonction angular.toJson prendra un objet et le sérialisera dans une chaîne au format JSON.
A la différence de la fonction native JSON.stringify , cette fonction supprime toutes les propriétés commençant par $$ (car angulaire en général préfixe les propriétés internes avec $$ )
angular.toJson(object)
Comme les données doivent être sérialisées avant de passer par un réseau, cette fonction est utile pour transformer les données que vous souhaitez transmettre en JSON.
Cette fonction est également utile pour le débogage car elle fonctionne de manière similaire à une méthode .toString .
Exemples:
angular.toJson({name: "barf", occupation: "mog", $$somebizzareproperty: 42})
// "{"name":"barf","occupation":"mog"}"
angular.toJson(42)
// "42"
angular.toJson([1, "2", 3, "4"])
// "[1,"2",3,"4"]"
var fn = function(value) {return value}
angular.toJson(fn)
// undefined, functions have no representation in JSON
angular.fromJson
La fonction angular.fromJson va désérialiser une chaîne JSON valide et retourner un objet ou un tableau.
angular.fromJson (chaîne | objet)
Notez que cette fonction n'est pas limitée aux chaînes uniquement, elle affichera une représentation de tout objet transmis.
Exemples:
angular.fromJson("{\"yogurt\": \"strawberries\"}")
// Object {yogurt: "strawberries"}
angular.fromJson('{jam: "raspberries"}')
// will throw an exception as the string is not a valid JSON
angular.fromJson(this)
// Window {external: Object, chrome: Object, _gaq: Y, angular: Object, ng339: 3…}
angular.fromJson([1, 2])
// [1, 2]
typeof angular.fromJson(new Date())
// "object"
angular.noop
angular.noop est une fonction qui angular.noop aucune opération, vous passez angular.noop lorsque vous devez fournir un argument de fonction qui ne fera rien.
angular.noop ()
angular.noop peut servir à fournir un rappel vide à une fonction qui angular.noop une erreur lorsque quelque chose d'autre qu'une fonction lui est transmis.
Exemple:
$scope.onSomeChange = function(model, callback) {
updateTheModel(model);
if (angular.isFunction(callback)) {
callback();
} else {
throw new Error("error: callback is not a function!");
}
};
$scope.onSomeChange(42, function() {console.log("hello callback")});
// will update the model and print 'hello callback'
$scope.onSomeChange(42, angular.noop);
// will update the model
Exemples supplémentaires:
angular.noop() // undefined
angular.isFunction(angular.noop) // true
angular.isObject
angular.isObject renvoie true si et seulement si l'argument qui lui est transmis est un objet, cette fonction renverra également true pour un tableau et renverra false pour null même si typeof null est object .
angular.isObject (valeur)
Cette fonction est utile pour la vérification de type lorsque vous avez besoin d'un objet défini à traiter.
Exemples:
angular.isObject({name: "skroob", job: "president"})
// true
angular.isObject(null)
// false
angular.isObject([null])
// true
angular.isObject(new Date())
// true
angular.isObject(undefined)
// false
angular.isElement
angular.isElement renvoie true si l'argument qui lui est transmis est un élément DOM ou un élément angular.isElement jQuery.
angular.isElement (elem)
Cette fonction est utile pour taper check si un argument passé est un élément avant d'être traité comme tel.
Exemples:
angular.isElement(document.querySelector("body"))
// true
angular.isElement(document.querySelector("#some_id"))
// false if "some_id" is not using as an id inside the selected DOM
angular.isElement("<div></div>")
// false
copie angulaire
La fonction angular.copy prend un objet, un tableau ou une valeur et en crée une copie angular.copy .
angular.copy ()
Exemple:
Objets:
let obj = {name: "vespa", occupation: "princess"};
let cpy = angular.copy(obj);
cpy.name = "yogurt"
// obj = {name: "vespa", occupation: "princess"}
// cpy = {name: "yogurt", occupation: "princess"}
Tableaux:
var w = [a, [b, [c, [d]]]];
var q = angular.copy(w);
// q = [a, [b, [c, [d]]]]
Dans l'exemple ci-dessus, angular.equals(w, q) sera évalué à true car .equals teste l'égalité par valeur. Cependant, w === q évaluera à false car la comparaison stricte entre les objets et les tableaux se fait par référence.
angular.identity
La fonction angular.identity renvoie le premier argument qui lui est passé.
angular.identity (argument)
Cette fonction est utile pour la programmation fonctionnelle, vous pouvez fournir cette fonction par défaut au cas où une fonction attendue ne serait pas passée.
Exemples:
angular.identity(42) // 42
var mutate = function(fn, num) {
return angular.isFunction(fn) ? fn(num) : angular.identity(num)
}
mutate(function(value) {return value-7}, 42) // 35
mutate(null, 42) // 42
mutate("mount. rushmore", 42) // 42
angulaire.pour chaque
angular.forEach accepte un objet et une fonction itérateur. Il exécute ensuite la fonction itérateur sur chaque propriété / valeur énumérable de l'objet. Cette fonction fonctionne également sur les tableaux.
Comme la version JS de Array.prototype.forEach La fonction ne Array.prototype.forEach pas les propriétés héritées (propriétés de prototype), mais la fonction ne tentera pas de traiter une valeur null ou undefined et la renverra simplement.
angular.forEach (objet, fonction (valeur, clé) {// fonction});
Exemples:
angular.forEach({"a": 12, "b": 34}, (value, key) => console.log("key: " + key + ", value: " + value))
// key: a, value: 12
// key: b, value: 34
angular.forEach([2, 4, 6, 8, 10], (value, key) => console.log(key))
// will print the array indices: 1, 2, 3, 4, 5
angular.forEach([2, 4, 6, 8, 10], (value, key) => console.log(value))
// will print the array values: 2, 4, 6, 7, 10
angular.forEach(undefined, (value, key) => console.log("key: " + key + ", value: " + value))
// undefined
