AngularJS
Inbyggda hjälparfunktioner

angular.equals

Funktionen angular.equals jämför och bestämmer om 2 objekt eller värden är lika, angular.equals utför en djup jämförelse och returnerar sant om och bara om minst 1 av följande villkor är uppfyllda.

angular.equals (värde1, värde2)

1. Om objekten eller värdena === jämförelsen ===
2. Om både objekt eller värden är av samma typ, och alla deras egenskaper också är lika med hjälp av angular.equals
3. Båda värdena är lika med NaN
4. Båda värdena representerar samma regelbundna uttrycks resultat.

Den här funktionen är användbar när du behöver jämnt jämföra objekt eller matriser efter deras värden eller resultat snarare än bara referenser.

exempel

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

Funktionen angular.isString returnerar sant om objektet eller värdet som ges till det är av string

angular.isString (värde1)

exempel

angular.isString("hello") // true
angular.isString([1, 2]) // false
angular.isString(42) // false

Detta är motsvarigheten till att utföra

typeof someValue === "string"

angular.isArray

angular.isArray funktionen returnerar sann om och bara om objektet eller värdet som skickas till det är av typen Array .

angular.isArray (värde)

exempel

angular.isArray([]) // true
angular.isArray([2, 3]) // true
angular.isArray({}) // false
angular.isArray(17) // false

Det är motsvarigheten till

Array.isArray(someValue)

angular.merge

Funktionen angular.merge tar alla de många egenskaperna från källobjektet för att djupt förlänga destinationsobjektet.

Funktionen returnerar en referens till det nu utökade destinationsobjektet

angular.merge (destination, källa)

exempel

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 och angular.isUefined

Funktionen angular.isDefined testar ett värde om det är definierat

angular.isDefined (someValue)

Detta är motsvarigheten till att utföra

value !== undefined; // will evaluate to true is value is defined

exempel

angular.isDefined(42) // true
angular.isDefined([1, 2]) // true
angular.isDefined(undefined) // false
angular.isDefined(null) // true

Funktionen angular.isUndefined testar om ett värde är odefinierat (det är verkligen motsatsen till angular.isDefined )

angular.isUndefined (someValue)

Detta är motsvarigheten till att utföra

value === undefined; // will evaluate to true is value is undefined

Eller bara

!angular.isDefined(value)

exempel

angular.isUndefined(42) // false
angular.isUndefined(undefined) // true

angular.isDate

Funktionen angular.isDate returnerar sann om och bara om objektet som skickas till det är av typen Datum.

angular.isDate (värde)

exempel

angular.isDate("lone star") // false
angular.isDate(new Date()) // true

angular.isNumber

angular.isNumber funktionen returnerar sant om och bara om objektet eller värdet som skickas till det är av typen Number, detta inkluderar + Infinity, -Infinity och NaN

angular.isNumber (värde)

Denna funktion orsakar inte en typ av tvång såsom

"23" == 23 // true 

exempel

angular.isNumber("23") // false
angular.isNumber(23) // true
angular.isNumber(NaN) // true
angular.isNumber(Infinity) // true

Denna funktion orsakar inte en typ av tvång såsom

"23" == 23 // true 

angular.isFunction

Funktionen angular.isFunction bestämmer och returnerar sant om och bara om värdet som skickas till är en referens till en funktion.

Funktionen returnerar en referens till det nu utökade destinationsobjektet

angular.isFunction (fn)

exempel

var onClick = function(e) {return e};
angular.isFunction(onClick); // true

var someArray = ["pizza", "the", "hut"];
angular.isFunction(someArray ); // false

angular.toJson

Funktionen angular.toJson tar ett objekt och serialiserar det i en JSON-formaterad sträng.

Till skillnad från den ursprungliga funktionen JSON.stringify kommer den här funktionen att ta bort alla egenskaper som börjar med $$ (eftersom vinkel vanligtvis prefixerar interna egenskaper med $$ )

angular.toJson(object)

Eftersom data måste serialiseras innan de passerar genom ett nätverk, är den här funktionen användbar för att förvandla all data du vill överföra till JSON.

Denna funktion är också användbar för felsökning eftersom den fungerar på samma sätt som en .toString metod skulle fungera.

Exempel:

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

Funktionen angular.fromJson deserialiserar en giltig JSON-sträng och returnerar ett objekt eller en array.

angular.fromJson (sträng | objekt)

Observera att den här funktionen inte är begränsad till endast strängar, den kommer att visa en representation av alla objekt som skickas till den.

Exempel:

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 är en funktion som inte utför några operationer, du passerar angular.noop när du behöver tillhandahålla ett funktionsargument som inte kommer att göra någonting.

angular.noop ()

En vanlig användning för angular.noop kan vara att tillhandahålla en tom återuppringning till en funktion som annars kommer att kasta ett fel när något annat än en funktion skickas till den.

Exempel:

$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

Ytterligare exempel:

angular.noop() // undefined
angular.isFunction(angular.noop) // true

angular.isObject

angular.isObject return true if och bara om argumentet som skickas till det är ett objekt kommer denna funktion också att returnera true för en Array och kommer att returnera falsk för null även om typeof null är object .

angular.isObject (värde)

Denna funktion är användbar för typkontroll när du behöver ett definierat objekt för att bearbeta.

Exempel:

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 återgår sant om argumentet som skickas till det är ett DOM-element eller ett jQuery-inslaget element.

angular.isElement (elem)

Den här funktionen är användbar för att skriva kontroll om ett godkänt argument är ett element innan det behandlas som sådant.

Exempel:

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

Funktionen angular.copy tar ett objekt, en grupp eller ett värde och skapar en djup kopia av den.

angular.copy ()

Exempel:

Objekt:

let obj = {name: "vespa", occupation: "princess"};
let cpy = angular.copy(obj);
cpy.name = "yogurt"
// obj = {name: "vespa", occupation: "princess"}
// cpy = {name: "yogurt", occupation: "princess"}

Arrays:

var w = [a, [b, [c, [d]]]];
var q = angular.copy(w);
// q = [a, [b, [c, [d]]]]

Vid exemplet angular.equals(w, q) att utvärderas till true eftersom .equals testar jämlikhet efter värde. men w === q kommer att utvärderas till falskt eftersom strikt jämförelse mellan objekt och matriser görs genom referens.

angular.identity

Funktionen angular.identity returnerar det första argumentet som skickas till det.

angular.identity (argument)

Den här funktionen är användbar för funktionell programmering, du kan tillhandahålla den här funktionen som standard i fall en förväntad funktion inte har passerat.

Exempel:

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 accepterar ett objekt och en iteratorfunktion. Den kör sedan iteratorfunktionen över varje objekts egendom / värde. Denna funktion fungerar också på matriser.

Som JS-versionen av Array.prototype.forEach Funktionen Array.prototype.forEach inte över ärvda egenskaper (prototypegenskaper), men funktionen kommer inte att försöka bearbeta ett null eller ett undefined värde och kommer bara att returnera det.

angular.forEach (objekt, funktion (värde, nyckel) {// funktion});

Exempel:

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