Я могу сказать Linux не выгружать память конкретных процессов?

Чтобы сравнить массивы, проведите через них и сравните каждое значение:

Сравнение массивов:

// Warn if overriding existing method
if(Array.prototype.equals)
    console.warn("Overriding existing Array.prototype.equals. Possible causes: New API defines the method, there's a framework conflict or you've got double inclusions in your code.");
// attach the .equals method to Array's prototype to call it on any array
Array.prototype.equals = function (array) {
    // if the other array is a falsy value, return
    if (!array)
        return false;

    // compare lengths - can save a lot of time 
    if (this.length != array.length)
        return false;

    for (var i = 0, l=this.length; i < l; i++) {
        // Check if we have nested arrays
        if (this[i] instanceof Array && array[i] instanceof Array) {
            // recurse into the nested arrays
            if (!this[i].equals(array[i]))
                return false;       
        }           
        else if (this[i] != array[i]) { 
            // Warning - two different object instances will never be equal: {x:20} != {x:20}
            return false;   
        }           
    }       
    return true;
}
// Hide method from for-in loops
Object.defineProperty(Array.prototype, "equals", {enumerable: false});

Использование:

[1, 2, [3, 4]].equals([1, 2, [3, 2]]) === false;
[1, "2,3"].equals([1, 2, 3]) === false;
[1, 2, [3, 4]].equals([1, 2, [3, 4]]) === true;
[1, 2, 1, 2].equals([1, 2, 1, 2]) === true;

Вы можете сказать: « Но гораздо проще сравнивать строки - нет петель ... « ну, тогда вы должны отметить, что есть циклы ARE. Первый рекурсивный цикл, который преобразует Array в строку и второй, который сравнивает две строки. Таким образом, этот метод быстрее, чем использование строки.

Я считаю, что большие объемы данных должны всегда храниться в массивах, а не в объектах. Однако, если вы используете объекты, их также можно частично сравнить. Вот как:

Сравнение объектов:

Я уже говорил выше, что два экземпляра объекта никогда не будут равными, даже если они содержат одни и те же данные на данный момент:

({a:1, foo:"bar", numberOfTheBeast: 666}) == ({a:1, foo:"bar", numberOfTheBeast: 666})  //false

У этого есть причина, поскольку в объектах могут быть, например, частные переменные.

Однако, если вы просто используете структуру объектов для хранения данных, сравнение все еще возможно:

Object.prototype.equals = function(object2) {
    //For the first loop, we only check for types
    for (propName in this) {
        //Check for inherited methods and properties - like .equals itself
        //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
        //Return false if the return value is different
        if (this.hasOwnProperty(propName) != object2.hasOwnProperty(propName)) {
            return false;
        }
        //Check instance type
        else if (typeof this[propName] != typeof object2[propName]) {
            //Different types => not equal
            return false;
        }
    }
    //Now a deeper check using other objects property names
    for(propName in object2) {
        //We must check instances anyway, there may be a property that only exists in object2
            //I wonder, if remembering the checked values from the first loop would be faster or not 
        if (this.hasOwnProperty(propName) != object2.hasOwnProperty(propName)) {
            return false;
        }
        else if (typeof this[propName] != typeof object2[propName]) {
            return false;
        }
        //If the property is inherited, do not check any more (it must be equa if both objects inherit it)
        if(!this.hasOwnProperty(propName))
          continue;

        //Now the detail check and recursion

        //This returns the script back to the array comparing
        /**REQUIRES Array.equals**/
        if (this[propName] instanceof Array && object2[propName] instanceof Array) {
                   // recurse into the nested arrays
           if (!this[propName].equals(object2[propName]))
                        return false;
        }
        else if (this[propName] instanceof Object && object2[propName] instanceof Object) {
                   // recurse into another objects
                   //console.log("Recursing to compare ", this[propName],"with",object2[propName], " both named \""+propName+"\"");
           if (!this[propName].equals(object2[propName]))
                        return false;
        }
        //Normal value comparison for strings and numbers
        else if(this[propName] != object2[propName]) {
           return false;
        }
    }
    //If everything passed, let's say YES
    return true;
}  

Однако помните, что этот метод должен служить для сравнения JSON как данных, а не экземпляров классов и других вещей. Если вы хотите сравнить более сложные объекты, посмотрите на этот ответ, и это суперлайновая функция . Чтобы выполнить эту работу с Array.equals, вы должны немного отредактировать исходную функцию:

...
    // Check if we have nested arrays
    if (this[i] instanceof Array && array[i] instanceof Array) {
        // recurse into the nested arrays
        if (!this[i].equals(array[i]))
            return false;
    }
    /**REQUIRES OBJECT COMPARE**/
    else if (this[i] instanceof Object && array[i] instanceof Object) {
        // recurse into another objects
        //console.log("Recursing to compare ", this[propName],"with",object2[propName], " both named \""+propName+"\"");
        if (!this[i].equals(array[i]))
            return false;
        }
    else if (this[i] != array[i]) {
...

Я сделал маленький тестовый инструмент для обеих функций .

Бонус: Вложенные массивы с indexOf и contains

Сэмю Бенчифеф подготовил полезные функции для случая, когда вы ищете определенный объект во вложенных массивах , которые доступны здесь: https://jsfiddle.net/SamyBencherif/8352y6yw/

43
задан sanity 24 February 2009 в 02:03
поделиться

5 ответов

Можно сделать это через mlockall (2) системный вызов в соответствии с Linux; это будет работать на целый процесс, но действительно читает об аргументе, который необходимо передать.

необходимо ли действительно вытянуть все это в ядре? Если бы это - приложение Java, Вы, по-видимому, заблокировали бы целую JVM в ядре. Я не знаю о методе командной строки для того, чтобы сделать это, но Вы могли записать тривиальную программу, чтобы звонить fork, звонить mlockall, затем exec.

Вы могли бы также надеяться видеть, удовлетворяет ли одно из уведомлений о схеме доступа в madvise (2) Ваши потребности. Уведомление подсистеме VM о лучшей стратегии подкачки страниц могло бы удаться лучше, если это применимо для Вас.

Примечание, что давным-давно теперь под SunOS, был механизм, подобный madvise, названному vadvise (2) .

25
ответ дан Cristian Ciupitu 23 September 2019 в 13:05
поделиться

Можно сделать это семейство mlock syscalls. Я не уверен, однако, если можно сделать это для другого процесса.

2
ответ дан jpalecek 23 September 2019 в 13:05
поделиться

Как суперпользователь Вы можете 'хороший' это к самому высокому приоритетному уровню-20 и надеяться, что этого достаточно, чтобы помешать ему выгружаться. Это обычно. Положительные числа понижают приоритет планирования. Обычные пользователи не могут хороший вверх (отрицательные номера)

2
ответ дан SumoRunner 23 September 2019 в 13:05
поделиться

Почему Вы хотите сделать это?
, При попытке увеличить производительность этого приложения затем, Вы, вероятно, на ложном пути. ОС выгрузит процесс для увеличения памяти для дискового кэша - даже если будет свободная RAM, ядро знает лучше всего (actauly умные парни, которые записали, что планировщик знает лучше всего).
, Если у Вас есть процесс, для которого нужна скорость отклика (она выгружается не используемый и при необходимости в ней для перезапуска быстро) затем хороший она к высокому приоритету, mlock, или использованию оперативного ядра могла бы помочь.

1
ответ дан Martin Beckett 23 September 2019 в 13:05
поделиться

Кроме чрезвычайно необычных обстоятельств, задавая этот вопрос означает, что Вы Делаете Его Неправильно (TM).

Серьезно, если Linux хочет подкачать и Вы пытаетесь сохранить свой процесс в памяти затем, Вы помещаете неблагоразумный спрос к ОС. Если Ваше приложение настолько важно, затем 1) покупают больше памяти, 2) удаляют другие приложения/демонов из машины или выделяют машину Вашему приложению и/или 3) вкладывают капитал в действительно быструю дисковую подсистему. Эти шаги разумны для важного приложения. Если Вы не можете выровнять по ширине их, то Вы, вероятно, не можете выровнять по ширине память проводного соединения и исчерпание ресурсов другие процессы также.

1
ответ дан dwc 23 September 2019 в 13:05
поделиться
Другие вопросы по тегам:

Похожие вопросы: