Why can I add named properties to an array as if it were an object?

前端 未结 7 2014
盖世英雄少女心
盖世英雄少女心 2020-11-22 06:33

The following two different code snippets seem equivalent to me:

var myArray = Array();
myArray[\'A\'] = \"Athens\";
myArray[\'B\'] = \"Berlin\";


        
相关标签:
7条回答
  • 2020-11-22 07:03

    Virtually everything in javascript is an object, so you can "abuse" an Array object by setting arbitrary properties on it. This should be considered harmful though. Arrays are for numerically indexed data - for non-numeric keys, use an Object.

    Here's a more concrete example why non-numeric keys don't "fit" an Array:

    var myArray = Array();
    myArray['A'] = "Athens";
    myArray['B'] = "Berlin";
    
    alert(myArray.length);
    

    This won't display '2', but '0' - effectively, no elements have been added to the array, just some new properties added to the array object.

    0 讨论(0)
  • 2020-11-22 07:03

    In JS arrays are objects, just slightly modified (with a few more functions).

    Functions like:

    concat
    every   
    filer
    forEach
    join
    indexOf
    lastIndexOf
    map
    pop
    push
    reverse
    shift
    slice
    some
    sort
    splice
    toSource
    toString
    unshift
    valueOf 
    
    0 讨论(0)
  • 2020-11-22 07:03

    Me thinks, me too metaphorical and cryptic with previous answer. Clarification follows.

    An instance of Array, Boolean, Date, Function, Number, RegExp, String is an Object but enhanced with methods and properties specific to each type. For example, an array has a predefined length property while generic objects do not.

    javascript:alert([].length+'\n'+{}.length)
    

    displays

    0
    undefined
    

    Intrinsically, the FF Gecko interpreter also distinguishes between Arrays and generic Objects with distinct differences evaluating language constructs.

    javascript:
      ra=[  "one",   "two",   "three"]; ra.a=4;
      ob={0:"one", 1:"two", 2:"three"}; ob.a=4;
      alert(
        ra            +"\n\n"+
        ob            +"\n\n"+
        ra.toSource() +"\n\n"+
        ra.a          +"\t .toSource() forgot me! \n\n"+
        ra.length     +"\t and my length! \n\n"+
        ob.toSource());
      ps=""; for(i in ra)ps+=i+" "; alert(ps);  /* NB .length is missing! */
      ps=""; for(i in ob)ps+=i+" "; alert(ps);
    

    displaying

    one,two,three
    
    [object Object]
    
    ["one", "two", "three"]
    
    4    .toSource() forgot me! 
    
    3    and my length! 
    
    ({0:"one", 1:"two", 2:"three", a:4})
    

    and 0 1 2 a and 0 1 2 a.

    Regarding the statement that all objects are functions:

    It is neither syntactically nor semantically correct to use an arbitrary object instance as a function like 123() or "abc"() or []() or {}() or obj() where obj is any type other than Function, so an arbitrary object INSTANCE is not a Function. However, given an object obj and it's type as Array, Boolean, Date, ..., how did obj come to be as an Array, Boolean, Date, ...? What is an Array, Boolean, Date, ...?

    javascript:
        alert([Array, Boolean, Date, Function, 
                  Number, Object, RegExp, String] . join('\n\n') );
    

    displays

    function Array() {
        [native code]
    }
    
    function Boolean() {
        [native code]
    }
    
    function Date() {
        [native code]
    }
    
    function Function() {
        [native code]
    }
    
    function Number() {
        [native code]
    }
    
    function Object() {
        [native code]
    }
    
    function RegExp() {
        [native code]
    }
    
    function String() {
        [native code]
    }
    

    In every case, without equivocation, the object type manifests as a function definition, hence the statement that all objects are functions! (The tongue-in-cheek is that I intentionally obscured and blurred the distinction of an object instance with that of it's type! Still, this shows "you can't have one without the other", Object and Function! Capitalization emphasizes type as opposed to instance.)

    Both a functional and object paradigm seem to be fundamental to the programming and implementing of the JS interpreter low level built-in primitives, such as Math and JSON and true.

     javascript:alert([Math, JSON, true.toSource()].join("\n\n"));
    

    displays

    [object Math]
    
    [object JSON]
    
    (new Boolean(true))
    

    At the time of the development of Javascript, an object-centric programming style (OOP's - Object Oriented Programming style - the "'s" is my own pun!) was in vogue and the interpreter was similarly christened with Java to give it greater credibility. Functional programming techniques were relegated to more abstract and esoteric examinations studying the theories of Automata, Recursive Functions, Formal Languages, etc. and as such not as palatable. However, the strengths of these formal considerations are clearly manifest in Javascript particularly as implemented in FF's Gecko engine (ie. .toSource()).


    The Object definition for Function is particularly satisfying for it is defined as a recurrence relation! defined using it's own definition!

    function Function() { [native code] }
    and since a function is an Object the same sentiment holds for
    function Object() { [native code] }.

    Most of the other definitions quiesce to a static terminal value. However, eval() is a particularly powerful primitive and so a String can also embed arbitrary functionality.

    Note again, the vernacular used above obscures object type and instance distinction.

    0 讨论(0)
  • 2020-11-22 07:06

    The {}-notation is just syntactical sugar to make the code nicer ;-)

    JavaScript has many similar constructs like the construction of functions, where function() is just a synonym for

    var Func = new Function("<params>", "<code>");
    
    0 讨论(0)
  • 2020-11-22 07:09

    Everything in JavaScript is an object besides primitive types.

    The code

    var myArray = Array();
    

    creates an instance of the Array object while

    var myObject = {'A': 'Athens', 'B':'Berlin'};
    

    creates an instance of Object object.

    Try the following code

    alert(myArray.constructor)
    alert(myObject.constructor)
    

    So you will see the difference is in the type of object constructor.

    The instance of the Array object will contain all the properties and methods of the Array prototype.

    0 讨论(0)
  • 2020-11-22 07:12

    You can add named properties to almost anything in javascript but that doesn't mean that you should. Array in javascript should be used as a list, if you want an associative array use Object instead.

    Beware that if you really want to use an Array with named properties instead of Object those properties won't be accessible in a for...of loop and you might also get unexpected results when JSON encoding it to pass it around. See example below where all non-numeric indexes get ignored:

    let arr = [];
    let obj = {};
    
    arr['name'] = 'John';
    obj['name'] = 'John';
    
    console.log(arr);    // will output [name: "John"]
    console.log(obj);    // will output {name: "John"}
    
    JSON.stringify(arr); // will return [] <- not what you expected
    JSON.stringify(obj); // will return {"name":"John"}
    
    0 讨论(0)
提交回复
热议问题