AngularJS
Funzioni ausiliarie integrate

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)

1. Se gli oggetti o i valori superano il confronto ===
2. Se entrambi gli oggetti o valori sono dello stesso tipo e tutte le loro proprietà sono uguali utilizzando angular.equals
3. Entrambi i valori sono uguali a NaN
4. 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