JavaScript
Datatyper i Javascript

sorts

typeof är den "officiella" funktionen som man använder för att få type i javascript, men i vissa fall kan det ge några oväntade resultat ...

1. Strängar

typeof "String" eller
typeof Date(2011,01,01)

"sträng"

2. Siffror

typeof 42

"siffra"

3. Bool

typeof true (giltiga värden true och false )

"Boolean"

4. Objekt

typeof {} eller
typeof [] eller
typeof null eller
typeof /aaa/ eller
typeof Error()

"objekt"

5. Funktion

typeof function(){}

"fungera"

6. Odefinierad

var var1; typeof var1

"odefinierad"

Få objekttyp efter konstruktörens namn

När ett med typeof operatör man får typ object faller in i något wast kategori ...

I praktiken kan du behöva begränsa det till vilken typ av "objekt" det faktiskt är och ett sätt att göra det är att använda objektkonstruktörens namn för att få vilken smak av objekt det faktiskt är: Object.prototype.toString.call(yourObject)

1. Sträng

Object.prototype.toString.call("String")

"[object String]"

2. Antal

Object.prototype.toString.call(42)

"[objektnummer]"

3. Bool

Object.prototype.toString.call(true)

"[objekt Boolean]"

4. Objekt

Object.prototype.toString.call(Object()) eller
Object.prototype.toString.call({})

"[object Object]"

5. Funktion

Object.prototype.toString.call(function(){})

"[objektfunktion]"

6. Datum

Object.prototype.toString.call(new Date(2015,10,21))

"[object Date]"

7. Regex

Object.prototype.toString.call(new RegExp()) eller
Object.prototype.toString.call(/foo/);

"[object RegExp]"

8. Array

Object.prototype.toString.call([]);

"[object Array]"

9. Null

Object.prototype.toString.call(null);

"[object Null]"

10. odefinierad

Object.prototype.toString.call(undefined);

"[Objekt definierat objekt]"

11. Fel

Object.prototype.toString.call(Error());

"[object Error]"

Hitta ett objekts klass

För att hitta om ett objekt har konstruerats av en viss konstruktör eller ett som ärvt från det kan du använda instanceof kommandot:

//We want this function to take the sum of the numbers passed to it
//It can be called as sum(1, 2, 3) or sum([1, 2, 3]) and should give 6
function sum(...arguments) {
    if (arguments.length === 1) {
        const [firstArg] = arguments
        if (firstArg instanceof Array) { //firstArg is something like [1, 2, 3]
            return sum(...firstArg) //calls sum(1, 2, 3)
        }
    }
    return arguments.reduce((a, b) => a + b)
}

console.log(sum(1, 2, 3))   //6
console.log(sum([1, 2, 3])) //6
console.log(sum(4))         //4

Observera att primitiva värden inte betraktas som fall av någon klass:

console.log(2 instanceof Number)        //false
console.log('abc' instanceof String)    //false
console.log(true instanceof Boolean)    //false
console.log(Symbol() instanceof Symbol) //false

Varje värde i JavaScript förutom null och undefined har också en constructor lagrar funktionen som användes för att konstruera den. Detta fungerar till och med med primitiv.

//Whereas instanceof also catches instances of subclasses,
//using obj.constructor does not
console.log([] instanceof Object, [] instanceof Array)           //true true
console.log([].constructor === Object, [].constructor === Array) //false true

function isNumber(value) {
    //null.constructor and undefined.constructor throw an error when accessed
    if (value === null || value === undefined) return false
    return value.constructor === Number
}
console.log(isNumber(null), isNumber(undefined))                  //false false
console.log(isNumber('abc'), isNumber([]), isNumber(() => 1))     //false false false
console.log(isNumber(0), isNumber(Number('10.1')), isNumber(NaN)) //true true true