AngularJS
Funzioni ausiliarie integrate
Ricerca…
angular.equals
La funzione angular.equals confronta e determina se 2 oggetti o valori sono uguali, angular.equals esegue un confronto profondo e restituisce true se e solo se almeno una delle seguenti condizioni è soddisfatta.
angular.equals (valore1, valore2)
- Se gli oggetti o i valori superano il confronto
=== - Se entrambi gli oggetti o valori sono dello stesso tipo e tutte le loro proprietà sono uguali utilizzando
angular.equals - Entrambi i valori sono uguali a
NaN - Entrambi i valori rappresentano il risultato della stessa espressione regolare.
Questa funzione è utile quando è necessario confrontare in profondità gli oggetti o gli array con i loro valori o risultati piuttosto che con semplici riferimenti.
Esempi
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 funzione angular.isString restituisce true se l'oggetto o il valore ad esso assegnato è del tipo string
angular.isString (valore1)
Esempi
angular.isString("hello") // true
angular.isString([1, 2]) // false
angular.isString(42) // false
Questo è l'equivalente di esibirsi
typeof someValue === "string"
angular.isArray
La funzione angular.isArray restituisce true se e solo se l'oggetto o il valore passato ad esso è del tipo Array .
angular.isArray (valore)
Esempi
angular.isArray([]) // true
angular.isArray([2, 3]) // true
angular.isArray({}) // false
angular.isArray(17) // false
È l'equivalente di
Array.isArray(someValue)
angular.merge
La funzione angular.merge prende tutte le proprietà enumerabili dall'oggetto sorgente per estendere profondamente l'oggetto di destinazione.
La funzione restituisce un riferimento all'oggetto di destinazione ora esteso
angular.merge (destination, source)
Esempi
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 and angular.isUndefined
La funzione angular.isDefined verifica un valore se è definito
angular.isDefined (someValue)
Questo è l'equivalente di esibirsi
value !== undefined; // will evaluate to true is value is defined
Esempi
angular.isDefined(42) // true
angular.isDefined([1, 2]) // true
angular.isDefined(undefined) // false
angular.isDefined(null) // true
La funzione angular.isUndefined verifica se un valore non è definito (è effettivamente l'opposto di angular.isDefined )
angular.isUndefined (someValue)
Questo è l'equivalente di esibirsi
value === undefined; // will evaluate to true is value is undefined
O semplicemente
!angular.isDefined(value)
Esempi
angular.isUndefined(42) // false
angular.isUndefined(undefined) // true
angular.isDate
La funzione angular.isDate restituisce true se e solo se l'oggetto passato ad esso è del tipo Date.
angular.isDate (valore)
Esempi
angular.isDate("lone star") // false
angular.isDate(new Date()) // true
angular.isNumber
La funzione angular.isNumber restituisce true se e solo se l'oggetto o il valore passato ad esso è del tipo Number, questo include + Infinity, -Infinity e NaN
angular.isNumber (valore)
Questa funzione non causerà un tipo di coercizione come
"23" == 23 // true
Esempi
angular.isNumber("23") // false
angular.isNumber(23) // true
angular.isNumber(NaN) // true
angular.isNumber(Infinity) // true
Questa funzione non causerà un tipo di coercizione come
"23" == 23 // true
angular.isFunction
La funzione angular.isFunction determina e restituisce true se e solo se il valore passato è un riferimento a una funzione.
La funzione restituisce un riferimento all'oggetto di destinazione ora esteso
angular.isFunction (fn)
Esempi
var onClick = function(e) {return e};
angular.isFunction(onClick); // true
var someArray = ["pizza", "the", "hut"];
angular.isFunction(someArray ); // false
angular.toJson
La funzione angular.toJson prenderà un oggetto e lo serializzerà in una stringa formattata JSON.
A differenza della funzione nativa JSON.stringify , questa funzione rimuoverà tutte le proprietà che iniziano con $$ (come angolare di solito prefigura le proprietà interne con $$ )
angular.toJson(object)
Poiché i dati devono essere serializzati prima di passare attraverso una rete, questa funzione è utile per trasformare qualsiasi dato che desideri trasmettere in JSON.
Questa funzione è utile anche per il debug in quanto funziona in modo simile a un metodo .toString .
Esempi:
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 funzione angular.fromJson deserializza una stringa JSON valida e restituisce un oggetto o una matrice.
angular.fromJson (string | oggetto)
Si noti che questa funzione non è limitata alle sole stringhe, ma produrrà una rappresentazione di qualsiasi oggetto passato ad esso.
Esempi:
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
L' angular.noop è una funzione che non esegue operazioni, si passa angular.noop quando è necessario fornire un argomento di funzione che non farà nulla.
angular.noop ()
Un uso comune di angular.noop può essere quello di fornire un callback vuoto a una funzione che altrimenti genera un errore quando viene passato ad esso qualcosa di diverso da una funzione.
Esempio:
$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
Ulteriori esempi:
angular.noop() // undefined
angular.isFunction(angular.noop) // true
angular.isObject
angular.isObject restituisce true se e solo se l'argomento passato ad esso è un oggetto, questa funzione restituirà anche true per una matrice e restituirà false per null anche se typeof null è object .
angular.isObject (valore)
Questa funzione è utile per il controllo del tipo quando è necessario elaborare un oggetto definito.
Esempi:
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 restituisce true se l'argomento passato ad esso è un elemento DOM o un elemento jQuery spostato.
angular.isElement (elem)
Questa funzione è utile per digitare check se un argomento passato è un elemento prima di essere elaborato come tale.
Esempi:
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
angular.copy
La funzione angular.copy accetta un oggetto, una matrice o un valore e ne crea una copia profonda.
angular.copy ()
Esempio:
Oggetti:
let obj = {name: "vespa", occupation: "princess"};
let cpy = angular.copy(obj);
cpy.name = "yogurt"
// obj = {name: "vespa", occupation: "princess"}
// cpy = {name: "yogurt", occupation: "princess"}
Array:
var w = [a, [b, [c, [d]]]];
var q = angular.copy(w);
// q = [a, [b, [c, [d]]]]
Nell'esempio precedente angular.equals(w, q) valuterà true perché .equals verifica l'uguaglianza per valore. tuttavia w === q valuterà come falso perché il confronto stretto tra oggetti e matrici viene fatto per riferimento.
angular.identity
La funzione angular.identity restituisce il primo argomento passato ad esso.
angular.identity (argomento)
Questa funzione è utile per la programmazione funzionale, è possibile fornire questa funzione come predefinita nel caso in cui non sia stata superata una funzione prevista.
Esempi:
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
angular.forEach
angular.forEach accetta un oggetto e una funzione iteratore. Quindi esegue la funzione iteratore su ciascuna proprietà / valore enumerabile dell'oggetto. Questa funzione funziona anche sugli array.
Come la versione JS di Array.prototype.forEach La funzione non esegue iterazioni sulle proprietà ereditate (proprietà prototype), tuttavia la funzione non tenterà di elaborare un valore null o undefined e lo restituirà semplicemente.
angular.forEach (oggetto, funzione (valore, chiave) {// funzione});
Esempi:
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
