JavaScript中是否有字典实现？

Question

如何在JavaScript中使用索引器实现数组？.Net中有字典吗？

Answer 1

技术上没有,但你可以像字典一样使用常规的JavaScript对象:

var a = {"a":"wohoo", 2:"hello2", "d":"hello"};
alert(a["a"]);
alert(a[2]);
alert(a["d"]);

Answer 2

John Resig(jQuery的作者)最近发布了javascript中的字典查找.

他的解决方案是将字典值指定为对象的属性.从上面的文章逐字粘贴的代码:

// The dictionary lookup object
var dict = {};
// Do a jQuery Ajax request for the text dictionary
$.get( "dict/dict.txt", function( txt ) {
  // Get an array of all the words
  var words = txt.split( "\n" );

  // And add them as properties to the dictionary lookup
  // This will allow for fast lookups later
  for ( var i = 0; i < words.length; i++ ) {
    dict[ words[i] ] = true;
  }

  // The game would start after the dictionary was loaded
  // startGame();
});

// Takes in an array of letters and finds the longest
// possible word at the front of the letters
function findWord( letters ) {
  // Clone the array for manipulation
  var curLetters = letters.slice( 0 ), word = "";

  // Make sure the word is at least 3 letters long
  while ( curLetters.length > 2 ) {
    // Get a word out of the existing letters
    word = curLetters.join("");

    // And see if it's in the dictionary
    if ( dict[ word ] ) {
      // If it is, return that word
      return word;
    }

    // Otherwise remove another letter from the end
    curLetters.pop();
  }
}

Answer 3

你可以试试buckets,是一个javascript数据结构库,它允许你在字典中使用任何类型的对象.

Answer 4

在我的上一个项目中,我的任务是创建一个浏览器客户端应用程序,该应用程序将读取数万行数据,然后对数据进行分组和聚合,以便在网格和图表中显示.目标技术是HTML 5,CSS 3和EMCS 5.(2013年6月的现代浏览器).由于较旧的浏览器兼容性不是一个问题,外部库仅限于D3(没有JQuery).

我需要构建一个数据模型.我之前在C#中构建了一个,并依赖自定义字典对象来快速访问数据,组和聚合.多年来我没有使用JavaScript,所以我开始搜索字典.我发现JavaScript仍然没有真正的原生字典.我发现了一些示例实现,但没有真正符合我的期望.所以我建了一个.

正如我所提到的,我多年没有使用过JavaScript.这些进步(或者可能仅仅是信息的网络可用性)令人印象深刻.我之前的所有工作都是基于类的语言,因此原型基础语言需要一些时间来习惯(而且我还有很长的路要走).

像大多数人一样,这个项目在它开始之前就已经到期了,所以当我从基于类的语言转换到基于原型的语言时,我学到了很多新的错误.创建的词典是功能性的,但过了一段时间后,我意识到我可以做一些改进,使它不那么新鲜.在我有时间重做字典之前,该项目耗尽了资金.哦,我的位置同时失去了资金(令人惊讶的是如何发生).所以我决定使用我学到的东西重新创建字典,并确定字典是否实际上是对数组的性能改进.

/*
* Dictionary Factory Object
* Holds common object functions. similar to V-Table
* this.New() used to create new dictionary objects
* Uses Object.defineProperties so won't work on older browsers.
* Browser Compatibility (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties)
*      Firefox (Gecko) 4.0 (2), Chrome 5, IE 9, Opera 11.60, Safari 5
*/
function Dict() {

    /*
    * Create a new Dictionary
    */
    this.New = function () {
        return new dict();
    };

    /*
    * Return argument f if it is a function otherwise return undefined
    */
    function ensureF(f) {
        if (isFunct(f)) {
            return f;
        }
    }

    function isFunct(f) {
        return (typeof f == "function");
    }

    /*
    * Add a "_" as first character just to be sure valid property name
    */
    function makeKey(k) {
        return "_" + k;
    };

    /*
    * Key Value Pair object - held in array
    */
    function newkvp(key, value) {
        return {
            key: key,
            value: value,
            toString: function () { return this.key; },
            valueOf: function () { return this.key; }
        };
    };

    /*
    * Return the current set of keys. 
    */
    function keys(a) {
        // remove the leading "-" character from the keys
        return a.map(function (e) { return e.key.substr(1); });
        // Alternative: Requires Opera 12 vs. 11.60
        // -- Must pass the internal object instead of the array
        // -- Still need to remove the leading "-" to return user key values
        //    Object.keys(o).map(function (e) { return e.key.substr(1); });
    };

    /*
    * Return the current set of values. 
    */
    function values(a) {
        return a.map(function(e) { return e.value; } );
    };

    /*
    * Return the current set of key value pairs. 
    */
    function kvPs(a) {
        // remove the leading "-" character from the keys
        return a.map(function (e) { return newkvp(e.key.substr(1), e.value); });
    }

    /*
    * Returns true if key exists in the dictionary.
    * k - Key to check (with the leading "_" character) 
    */
    function exists(k, o) {
        return o.hasOwnProperty(k);
    }

    /*
    * Array Map implementation
    */
    function map(a, f) {
        if (!isFunct(f)) { return; }
        return a.map(function (e, i) { return f(e.value, i); });
    }

    /*
    * Array Every implementation
    */
    function every(a, f) {
        if (!isFunct(f)) { return; }
        return a.every(function (e, i) { return f(e.value, i) });
    }

    /*
    * Returns subset of "values" where function "f" returns true for the "value"
    */
    function filter(a, f) {
        if (!isFunct(f)) {return; }
        var ret = a.filter(function (e, i) { return f(e.value, i); });
        // if anything returned by array.filter, then get the "values" from the key value pairs
        if (ret && ret.length > 0) {
            ret = values(ret);
        }
        return ret;
    }

    /*
    * Array Reverse implementation
    */
    function reverse(a, o) {
        a.reverse();
        reindex(a, o, 0);
    }

    /**
    * Randomize array element order in-place.
    * Using Fisher-Yates shuffle algorithm.
    * (Added just because:-)
    */
    function shuffle(a, o) {
        var j, t;
        for (var i = a.length - 1; i > 0; i--) {
            j = Math.floor(Math.random() * (i + 1));
            t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
        reindex(a, o, 0);
        return a;
    }
    /*
    * Array Some implementation
    */
    function some(a, f) {
        if (!isFunct(f)) { return; }
        return a.some(function (e, i) { return f(e.value, i) });
    }

    /*
    * Sort the dictionary. Sorts the array and reindexes the object.
    * a - dictionary array
    * o - dictionary object
    * sf - dictionary default sort function (can be undefined)
    * f - sort method sort function argument (can be undefined)
    */
    function sort(a, o, sf, f) {
        var sf1 = f || sf; // sort function  method used if not undefined
        // if there is a customer sort function, use it
        if (isFunct(sf1)) {
            a.sort(function (e1, e2) { return sf1(e1.value, e2.value); });
        }
        else {
            // sort by key values
            a.sort();
        }
        // reindex - adds O(n) to perf
        reindex(a, o, 0);
        // return sorted values (not entire array)
        // adds O(n) to perf
        return values(a);
    };

    /*
    * forEach iteration of "values"
    *   uses "for" loop to allow exiting iteration when function returns true 
    */
    function forEach(a, f) {
        if (!isFunct(f)) { return; }
        // use for loop to allow exiting early and not iterating all items
        for(var i = 0; i < a.length; i++) {
            if (f(a[i].value, i)) { break; }
        }
    };

    /*
    * forEachR iteration of "values" in reverse order
    *   uses "for" loop to allow exiting iteration when function returns true 
    */
    function forEachR(a, f) {
        if (!isFunct(f)) { return; }
        // use for loop to allow exiting early and not iterating all items
        for (var i = a.length - 1; i > -1; i--) {
            if (f(a[i].value, i)) { break; }
        }
    }

    /*
    * Add a new Key Value Pair, or update the value of an existing key value pair
    */
    function add(key, value, a, o, resort, sf) {
        var k = makeKey(key);
        // Update value if key exists
        if (exists(k, o)) {
            a[o[k]].value = value;
        }
        else {
            // Add a new Key value Pair
            var kvp = newkvp(k, value);
            o[kvp.key] = a.length;
            a.push(kvp);
        }
        // resort if requested
        if (resort) { sort(a, o, sf); }
    };

    /*
    * Removes an existing key value pair and returns the "value" If the key does not exists, returns undefined
    */
    function remove(key, a, o) {
        var k = makeKey(key);
        // return undefined if the key does not exist
        if (!exists(k, o)) { return; }
        // get the array index
        var i = o[k];
        // get the key value pair
        var ret = a[i];
        // remove the array element
        a.splice(i, 1);
        // remove the object property
        delete o[k];
        // reindex the object properties from the remove element to end of the array
        reindex(a, o, i);
        // return the removed value
        return ret.value;
    };

    /*
    * Returns true if key exists in the dictionary.
    * k - Key to check (without the leading "_" character) 
    */
    function keyExists(k, o) {
        return exists(makeKey(k), o);
    };

    /*
    * Returns value assocated with "key". Returns undefined if key not found
    */
    function item(key, a, o) {
        var k = makeKey(key);
        if (exists(k, o)) {
            return a[o[k]].value;
        }
    }

    /*
    * changes index values held by object properties to match the array index location
    * Called after sorting or removing
    */
    function reindex(a, o, i){
        for (var j = i; j < a.length; j++) {
            o[a[j].key] = j;
        }
    }

    /*
    * The "real dictionary"
    */
    function dict() {
        var _a = [];
        var _o = {};
        var _sortF;

        Object.defineProperties(this, {
            "length": { get: function () { return _a.length; }, enumerable: true },
            "keys": { get: function() { return keys(_a); }, enumerable: true },
            "values": { get: function() { return values(_a); }, enumerable: true },
            "keyValuePairs": { get: function() { return kvPs(_a); }, enumerable: true},
            "sortFunction": { get: function() { return _sortF; }, set: function(funct) { _sortF = ensureF(funct); }, enumerable: true }
        });

        // Array Methods - Only modification to not pass the actual array to the callback function
        this.map = function(funct) { return map(_a, funct); };
        this.every = function(funct) { return every(_a, funct); };
        this.filter = function(funct) { return filter(_a, funct); };
        this.reverse = function() { reverse(_a, _o); };
        this.shuffle = function () { return shuffle(_a, _o); };
        this.some = function(funct) { return some(_a, funct); };
        this.sort = function(funct) { return sort(_a, _o, _sortF, funct); };

        // Array Methods - Modified aborts when funct returns true.
        this.forEach = function (funct) { forEach(_a, funct) };

        // forEach in reverse order
        this.forEachRev = function (funct) { forEachR(_a, funct) };

        // Dictionary Methods
        this.addOrUpdate = function(key, value, resort) { return add(key, value, _a, _o, resort, _sortF); };
        this.remove = function(key) { return remove(key, _a, _o); };
        this.exists = function(key) { return keyExists(key, _o); };
        this.item = function(key) { return item(key, _a, _o); };
        this.get = function (index) { if (index > -1 && index < _a.length) { return _a[index].value; } } ,
        this.clear = function() { _a = []; _o = {}; };

        return this;
    }


    return this;
}

我在尝试精神上调和类和原型对象时的一个顿悟是原型基本上是创建对象的v表.另外,机箱中的功能也可以像v表条目一样工作.随着项目的进展,我开始使用Object Factories,其中顶级对象包含对象类型的常用函数,并包含一个"this.New(args)"方法,用于创建解决方案中使用的实际对象.这是我用于字典的样式.

字典的核心是Array,Object和KeyValuePair对象."addOrUpdate"方法接受一个键和一个值,并且:

1. 创建KeyValuePair
2. 使用键作为属性名称并将数组长度作为属性值,向对象添加新属性
3. 将KeyValuePair添加到Array,使对象new属性值成为数组中的索引

注意:我读取对象属性名称可以以"几乎任何"Unicode字符开头.该项目将处理客户数据,该数据可以以"任何"Unicode字符开头.为了确保字典没有由于无效的属性名称而爆炸,我将下划线(_)作为键的前缀,并在返回字典外部的键时去掉该下划线.

要使字典起作用,内部数组和对象必须保持同步.为了确保这一点,Array和Object都不会从外部暴露.我想避免意外更改,例如当"If"测试只有一个等号并且左侧有错误设置值时可能发生的更改.

If(dict.KeyObj[“SomeKey”] = “oops”) { alert(“good luck tracing this down:-)”); }

当错误(症状)开始出现在计算,显示等中时,字典的这种典型错误可能很难追踪.因此,"this"属性将无法访问任何一个.这种保护主义是我没有深入研究原型的原因之一.在我使用"调用"或"应用"方法时,我已经想到使用内部对象暴露数组和对象并传递该内部对象,我可能会在以后查看,因为我仍然不确定我不会必须暴露内部对象,这将破坏保护核心数组和对象的目的.

我修复了我用我创建的第一个字典对象所犯的一些新错误.

• "Dict()"函数包含每个字典对象的大部分工作代码.我用来确定是否应该使用封闭函数与实际字典对象中的功能的标准:
  • 不止一行代码
  • 由其他封闭函数使用
  • 当我发现错误/问题时,可能会发生变化导致增长
• 使用的Array方法和属性名称有意义.来自C#我做的事情使得我的字典不太可用,因为使用"Count"而不是"length"或"ForEach"而不是"forEach".通过使用数组名称,在大多数情况下,字典现在可以用作数组.不幸的是我无法找到创建括号访问器的方法(例如val = dict [key]),无论如何这可能是一件好事.在考虑它时,我很难确定val = dict [12]之类的东西是否正常工作.数字12很容易被用作关键,所以我想不出一个了解这种电话"意图"的好方法.
• 完全包含下划线前缀处理.在我正在工作的项目中,我将其展开并在各种数据模型对象中重复.太丑了!

Answer 5

在JS中,{"index":anyValue}只是一个字典.您也可以参考JSON的定义(http://www.json.org/)