Question

我有一个数组

ok

我想从sourceArray = [{'type':'A'}, {'type':'B'}, {'type':'C'}, {'type':'D'}]; arrayB = ['B', 'C'];包含的值中过滤数组sourceArray。我们可以通过迭代arrayB来做到这一点，但只是想要一些好方法来做到这一点。

arrayB

可以更优雅地完成任务。

Answer 1

只需sourceArray = [{'type':'A'}, {'type':'B'}, {'type':'C'}, {'type':'D'}]; arrayB = ['B', 'C']; result = sourceArray.filter(function(item) { return arrayB.indexOf(item.type) >= 0; }); document.write("<pre>" + JSON.stringify(result,0,3));：

func

[].filter(func)迭代一个数组并收集true返回arrayB的元素。在我们的函数中，我们检查item.type是否包含sourceArray = [{'type':'A'}, {'type':'B'}, {'type':'C'}, {'type':'D'}]; arrayB = ['B', 'C']; setB = new Set(arrayB) result = sourceArray.filter(item => setB.has(item.type))并返回true（如果有）（请参阅indexOf）。

ES6解决方案，适用于已经使用它的人：

public class SystemConfigManagement {
private static final int    DEFAULT_NO_THREADS = 10;
private static final String DEFAULT_SCHEMA     = "default";

private static String       response           = null;

public static void main(String[] args) throws MalformedObjectNameException, InterruptedException,
        InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException {
    // Get the MBean server
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    // register the MBean
    SystemConfig mBean = new SystemConfig(DEFAULT_NO_THREADS, DEFAULT_SCHEMA);
    ObjectName name = new ObjectName("com.sigma.jmx:type=SystemConfig");
    mbs.registerMBean(mBean, name);
    do {
        Thread.sleep(3000);
        System.out.println("Thread Count=" + mBean.getThreadCount() + ":::Schema Name="
                + mBean.getSchemaName());
        if (mBean.getSchemaName().equalsIgnoreCase("NewSchema")) {
            System.out.println("Yes, you got right shcema name with token " + mBean.getToken());
            response = RestClient.callPost("/validate-token", mBean.getToken(), "{}");
            System.out.println("Toekn validation response " + response);

            if (response.contains("\"valid\":true")) {
                System.out.println("You are Logged In....");
            } else {
                System.out.println("Your Token is invalid, you cannot login...");
            }

        } else {
            System.out.println("Schema name is invalid");
        }

    } while (mBean.getThreadCount() != 0);

}

Answer 2

有filtering并使用indexOf的解决方案，但它包含一个隐藏的迭代，如果您的arrayB数组包含的内容不仅仅是几个元素，那么代价很高。

在一般情况下，有效的解决方案是构建元素的哈希映射，以便过滤操作更快。这可以这样做：

var filteredArray = sourceArray.filter(
    function(v){ return this[v.type] }.bind(arrayB.reduce(
        function(s,v){ s[v]=1; return s }, Object.create(null)
    ))
)

在此代码中，arrayB.reduce(function(s,v){ s[v]=1; return s }, {}))是一个对象，其键是有效类型：{B: 1, C: 1}。 JavaScript引擎在重复检索此类对象的属性时非常快。

Answer 3

var sourceArray = [{
    'type': 'A'
}, {
    'type': 'B'
}, {
    'type': 'C'
}, {
    'type': 'D'
}];
var arrayB = ['B', 'C'];

var desiredArr = sourceArray.filter(function (val) {
    for (var i = 0; i <= arrayB.length; ++i) {
        if (val.type == arrayB[i]){
            return val;
        }
    }
});
alert(JSON.stringify(desiredArr));

从存储在数组中的值过滤数组

3 个答案: