Здравствуйте, Mamut, Вы писали:

L>>Да сколько угодно, статические классы — и вперед. Пусть тебя не смущает слово class в их определении, это не имеет ничего общего с классами из ООП.

M>Это все равно ООП.

ООП без объектов? Это пять.

L>>Можно, только синтаксис немного другой и надо указать аннотацию типа у переменной a, т.к. язык — статически типизированный.

M>Что значит синтаксис немного другой?

int func() { /* чтщ-то там */}

Func<int> a = func;

Здравствуйте, Mamut, Вы писали:

L>>Спасибо, Кэп. Странно, что ты поправил меня, а не Цыбу.

M>Поправил тебя, потому что "var O = {}" — не аналог "var O = new Object()".

Вот и попровлял бы того, кто написал про аналог. Подсказка: это был не я.

M>И поправил тебя, потому что такое впечатление, что о JS ты знаешь если не понаслышке, то очень мало (многстрочные лямбды, ага)

Это неверное впечатление. JS я знаю хорошо, а вот ты похоже не очень, раз не видишь его недостатков.

Здравствуйте, Lloyd, Вы писали:

L>Это неверное впечатление. JS я знаю хорошо, а вот ты похоже не очень, раз не видишь его недостатков.

позвольте поинтересоваться, почему вы тогда спрашивали, о том, что такое var O = {}?

Здравствуйте, Mamut, Вы писали:

M>>>Повторю в шестой раз. То, что я показал, и есть общий случай для js

L>>Ты просто жжошь. 1 случай не может быть общим, т.к. он — частный случай по определению.

M>Аналогично с твоими лямбдами.

Не аналогично ни разу.
С большой "лямбдой" ты показал только то, что js-синтаксис не проигрывает шарповому при больших лямбдах. Из этого ты сделал вывод, что js-синтаксис никогда не проигрывает шарповому. Этот вывод неверен, для доказательства этого достаточно одного примера, когда js-синтаксис проигрывает. Я и привел пример с маленькой лямбдой в качестве такого примера.

Здравствуйте, Цыба, Вы писали:

L>>Это неверное впечатление. JS я знаю хорошо, а вот ты похоже не очень, раз не видишь его недостатков.

Ц>позвольте поинтересоваться, почему вы тогда спрашивали, о том, что такое var O = {}?

Ты почитай тот пост, в ответе на который я это спросил. Только прочитай его непредвзято. Вопросы сами пропадут, уверяю тебя.

Здравствуйте, Lloyd, Вы писали:

L>Ты почитай тот пост, в ответе на который я это спросил. Только прочитай его непредвзято. Вопросы сами пропадут, уверяю тебя.

я, как и вы, не обладаю даром чтения мыслей, к сожалению, а посему ответьте здесь на мой вопрос выше, пожалуйста

Здравствуйте, Цыба, Вы писали:

L>>Ты почитай тот пост, в ответе на который я это спросил. Только прочитай его непредвзято. Вопросы сами пропадут, уверяю тебя.

Ц>я, как и вы, не обладаю даром чтения мыслей, к сожалению, а посему ответьте здесь на мой вопрос выше, пожалуйста

Я не понял, к чему ты привел эти строчки, что ты хотел получить в итоге на выходе. С синтаксисом проблем не было, уверяю тебя.

P.S. Немного личного: когда посылаешь ответ, перечитывай его перед тем, как послать. В частности это относится и к этому посту — ты зачем-то выбросил из сообщения вопрос, на который сам же просишь ответить.

M>>И поправил тебя, потому что такое впечатление, что о JS ты знаешь если не понаслышке, то очень мало (многстрочные лямбды, ага)

L>Это неверное впечатление. JS я знаю хорошо, а вот ты похоже не очень, раз не видишь его недостатков.

Я вижу его недостатки, и уже их тут один раз рассказал. И это точно не громоздкий синтаксис лямбд, который якобы является свидетельством плохой поддержки ФП (объяснение

Автор: Lloyd
Дата: 26.05.10

я читал, если что)

M>>>>Повторю в шестой раз. То, что я показал, и есть общий случай для js

L>>>Ты просто жжошь. 1 случай не может быть общим, т.к. он — частный случай по определению.

M>>Аналогично с твоими лямбдами.

L>Не аналогично ни разу.
L>С большой "лямбдой" ты показал только то, что js-синтаксис не проигрывает шарповому при больших лямбдах. Из этого ты сделал вывод, что js-синтаксис никогда не проигрывает шарповому.

Этого вывода я не делал

L>Этот вывод неверен, для доказательства этого достаточно одного примера, когда js-синтаксис проигрывает. Я и привел пример с маленькой лямбдой в качестве такого примера.

Класс, сделал какой-то вывод, который я лично не делал, и сам его блестяще опроверг. Браво. Апплодирую стоя.

В яваскрипте анонимные функции/лямбды используются повсеместно, а не только для написания кортких однострочных мыслей.

Я понимаю, кому-то так и хочется ввести однострочные лямбды по типу питоновских, только смысла в этом нет. Потому что повсеместно и в большинстве своем лямбды, они же — анонимные функции, в Javascript'е применяются именно как многострочные конструкции, и ввод отдельного нового синтаксиса специально для коротких/однострочных лямбд не приведет к ожидаемому повышению читаемости кода. Примеры я тоже приводил.

Желание краткого синтаксиса для коротких вещей типа map/filter понятно, но что делать с тем кодом, что писался, пишется и будет писаться с использованием анонимных функций? «Пожалуйста, злдесь используйте такой синтаксис, а здесь — такой»? А смысл?

Здравствуйте, Mamut, Вы писали:

L>>Это неверное впечатление. JS я знаю хорошо, а вот ты похоже не очень, раз не видишь его недостатков.

M>Я вижу его недостатки, и уже их тут один раз рассказал. И это точно не громоздкий синтаксис лямбд, который якобы является свидетельством плохой поддержки ФП (объяснение

Автор: Lloyd
Дата: 26.05.10

я читал, если что)

Кстати, я запамятовал, ты уже ответил на вопрос зачем надо было в Functional добавлять передачу "функций" в виде строк, когда и с существующим синтаксисом якобы все хорошо?

Здравствуйте, Mamut, Вы писали:

L>>Не аналогично ни разу.
L>>С большой "лямбдой" ты показал только то, что js-синтаксис не проигрывает шарповому при больших лямбдах. Из этого ты сделал вывод, что js-синтаксис никогда не проигрывает шарповому.

M>Этого вывода я не делал

Ты привел пример большой лямбды чтобы продемонстрировать, что альтернативный синтаксис ничего не дает. Несколькими постами позже ты начал утверждать, что такие лямбды — общий случай. Из этого я сделал вывод, что ты считаешь, что в общем случае краткий синтаксис не нужен. Я где-то допустил ошибку? Где?

L>>Этот вывод неверен, для доказательства этого достаточно одного примера, когда js-синтаксис проигрывает. Я и привел пример с маленькой лямбдой в качестве такого примера.

M>Класс, сделал какой-то вывод, который я лично не делал, и сам его блестяще опроверг. Браво. Апплодирую стоя.

M>

M>В яваскрипте анонимные функции/лямбды используются повсеместно, а не только для написания кортких однострочных мыслей.

M>Я понимаю, кому-то так и хочется ввести однострочные лямбды по типу питоновских, только смысла в этом нет. Потому что повсеместно и в большинстве своем лямбды,

Так "повсеместно" или "в большинстве"? Ты уж определись окончательно.

M>они же — анонимные функции, в Javascript'е применяются именно как многострочные конструкции, и ввод отдельного нового синтаксиса специально для коротких/однострочных лямбд не приведет к ожидаемому повышению читаемости кода. Примеры я тоже приводил.

M>Желание краткого синтаксиса для коротких вещей типа map/filter понятно, но что делать с тем кодом, что писался, пишется и будет писаться с использованием анонимных функций? «Пожалуйста, злдесь используйте такой синтаксис, а здесь — такой»? А смысл?

Гм. Извините, что повторяюсь, но смысл остается тем же, что и в моем первом посте — лучшая читабельность.

Здравствуйте, Lloyd, Вы писали:

L>Кстати, я запамятовал, ты уже ответил на вопрос зачем надо было в Functional добавлять передачу "функций" в виде строк, когда и с существующим синтаксисом якобы все хорошо?

Это eval() — стандартная возможность таких языков. Добавили, потому что можно.

Здравствуйте, anonymous, Вы писали:

A>Если вдаваться в подробности, то это не так. Но здесь сойдёт.

Не поясните, в чём разница? Ну за исключением ситуации, когда var объявлен в некотором scope...

Здравствуйте, anonymous, Вы писали:

L>>Кстати, я запамятовал, ты уже ответил на вопрос зачем надо было в Functional добавлять передачу "функций" в виде строк, когда и с существующим синтаксисом якобы все хорошо?

A>Это eval() — стандартная возможность таких языков. Добавили, потому что можно.

Это твое мнение или мнение авторов библиотеки?

Здравствуйте, anonymous, Вы писали:

L>>Кстати, я запамятовал, ты уже ответил на вопрос зачем надо было в Functional добавлять передачу "функций" в виде строк, когда и с существующим синтаксисом якобы все хорошо?

A>Это eval() — стандартная возможность таких языков. Добавили, потому что можно.

Только вот eval там не используется.

M>>Желание краткого синтаксиса для коротких вещей типа map/filter понятно, но что делать с тем кодом, что писался, пишется и будет писаться с использованием анонимных функций? «Пожалуйста, злдесь используйте такой синтаксис, а здесь — такой»? А смысл?

L>Гм. Извините, что повторяюсь, но смысл остается тем же, что и в моем первом посте — лучшая читабельность.

Неверно для Яваскрипта. Объясняю на пальцах.

В C# лямбды — это "add-on". Поздно появившийся, являющейся лишь сахаром для делегатов. Предназначен для выполнения коротких, однострочных функций. Как только строчек становится больше, чем одна, все, ховайся, читабельность убегает далеко и надолго:

static Func<double, double, double> hypotenuse =
    (x, y) => Math.Sqrt(x * x + y * y);
 
static Func<int, int, bool> divisibleBy =
    (int a, int b) => a % b == 0;
 
static Func<int, bool> isPrime =
    x => {
        for (int i = 2; i <= x / 2; i++)
            if (divisibleBy(x, i))
                return false;
            return true;
    };
 
static void Main(string[] args)
{
    int n = 19;
    if (isPrime(n)) Console.WriteLine(n + " is prime");
    Console.ReadLine();
}

Для определения isPrime вообще лучше, наверное, использовать delegate(x), чтобы не потерять объявление собственно лямбды в коде. И правильно, отношение к лямбдам ВНЕЗАПНО становится «не используй многострочных лямбд». Почему? А потому что многострочность резко сводит на нет всю читабельность лямбд.

В Javascript'е опять же ВНЕЗАПНО оказывается, что коротких лямбд достаточно мало. А анонимные многострочные функции — это в порядке вещей. Ты же не против многстрочных делегатов в C#? Зачем же вводить еще один синтаксис для тех же яиц? Ради некоей мифической читаемости кода, которая в реально используемом Яваскрипте не проявится?

Здравствуйте, koandrew, Вы писали:

A>>Если вдаваться в подробности, то это не так. Но здесь сойдёт.
K>Не поясните, в чём разница? Ну за исключением ситуации, когда var объявлен в некотором scope...

Разница в том, что в одном случае это объявление функции (создаётся на этапе входа в контекст), а в другом — функция-выражение (создаётся на этапе интерпретации кода контекста), отсюда немного различное поведение:

alert(foo); // function
function foo() {}

alert(foo); // undefined
var foo = function () {};

Но и это не всё, подробности тут: http://dmitrysoshnikov.com/ecmascript/ru-chapter-5-functions/.

Здравствуйте, Mamut, Вы писали:

M>В Javascript'е опять же ВНЕЗАПНО оказывается, что коротких лямбд достаточно мало. А анонимные многострочные функции — это в порядке вещей. Ты же не против многстрочных делегатов в C#? Зачем же вводить еще один синтаксис для тех же яиц? Ради некоей мифической читаемости кода, которая в реально используемом Яваскрипте не проявится?

Ну это кто как пишет. Тот код, что ты приводил, я не считаю образцом для подражания. Как я уже писал, я бы вытащил код модификации дома в отдельную функцию и передавал бы ее в jQuery-вский each. Тут громоздкость уже явно мозолила бы глаза. А если все загонять в одно выражение, то разницы никакой не будет.

Здравствуйте, Lloyd, Вы писали:

L>>>Кстати, я запамятовал, ты уже ответил на вопрос зачем надо было в Functional добавлять передачу "функций" в виде строк, когда и с существующим синтаксисом якобы все хорошо?
A>>Это eval() — стандартная возможность таких языков. Добавили, потому что можно.
L>Это твое мнение или мнение авторов библиотеки?

Нужны функции, код которых формируется динамически во время исполнения, для этого и нужен конструктор функций, принимающий строку.

M>>В Javascript'е опять же ВНЕЗАПНО оказывается, что коротких лямбд достаточно мало. А анонимные многострочные функции — это в порядке вещей. Ты же не против многстрочных делегатов в C#? Зачем же вводить еще один синтаксис для тех же яиц? Ради некоей мифической читаемости кода, которая в реально используемом Яваскрипте не проявится?

L>Ну это кто как пишет. Тот код, что ты приводил, я не считаю образцом для подражания.

Я его и не выдвигаю, как образец для подражания.

L>Как я уже писал, я бы вытащил код модификации дома в отдельную функцию и передавал бы ее в jQuery-вский each. Тут громоздкость уже явно мозолила бы глаза.

??? Где и как бы она мозолила?

// для полноты картины, это находится в $(document).ready();
$(document).ready(function(){
    $('span.rss-url').each(function(){
        var url = $(this).html();
        var parent = $(this).parent();
        var feed = new google.feeds.Feed(url);
        feed.load(function(result){
                
        if(result.error) { 
            var div = $('<div class="item"></div>');
            div.appendTo(parent);
            div.append('Не удалось получить RSS с ' + url);
            return;
        }
                
        for(i = 0; i < 10 && i < result.feed.entries.length; i++){
            var div = $('<div class="item"></div>');
            div.appendTo(parent);
                    
            var item = result.feed.entries[i];
            div.append('<'+headerElement+'><a href="'+item.link+'">'+item.title+'</a></'+headerElement+'>'+item.content);
            div.find('p:gt(0), p+div').hide();
            if(div.find('p').length > 1) div.find('p:eq(0)').append(' ...');
        }
    });
});

против (синтаксис как есть сейчас):

// избавляемся от всех «многострочных лямбд»

// в loadCallback придется протягивать parent, которая
// иначе была бы в замыкании

function loadCallback(parent, result) {
    if(result.error) { 
        var div = $('<div class="item"></div>');
        div.appendTo(parent);
        div.append('Не удалось получить RSS с ' + url);
        return;
    }
                
    for(i = 0; i < 10 && i < result.feed.entries.length; i++){
        var div = $('<div class="item"></div>');
        div.appendTo(parent);
                    
        var item = result.feed.entries[i];
        div.append('<'+headerElement+'><a href="'+item.link+'">'+item.title+'</a></'+headerElement+'>'+item.content);
        div.find('p:gt(0), p+div').hide();
        if(div.find('p').length > 1) div.find('p:eq(0)').append(' ...');
    }
}

function eachCallback() {
    var url = $(this).html();
    var parent = $(this).parent();
    var feed = new google.feeds.Feed(url);
    feed.load(function(result){ loadCallback(parent, result) });
}

$(document).ready(function(){
    $('span.rss-url').each(eachCallback);
});

против (синтаксис с лямбдами a la С#):

// избавляемся от всех «многострочных лямбд»

// в loadCallback придется протягивать parent, которая
// иначе была бы в замыкании

function loadCallback(parent, result) {
    if(result.error) { 
        var div = $('<div class="item"></div>');
        div.appendTo(parent);
        div.append('Не удалось получить RSS с ' + url);
        return;
    }
                
    for(i = 0; i < 10 && i < result.feed.entries.length; i++){
        var div = $('<div class="item"></div>');
        div.appendTo(parent);
                    
        var item = result.feed.entries[i];
        div.append('<'+headerElement+'><a href="'+item.link+'">'+item.title+'</a></'+headerElement+'>'+item.content);
        div.find('p:gt(0), p+div').hide();
        if(div.find('p').length > 1) div.find('p:eq(0)').append(' ...');
    }
}

function eachCallback() {
    var url = $(this).html();
    var parent = $(this).parent();
    var feed = new google.feeds.Feed(url);
    feed.load(result => loadCallback(parent, result));
}

$(document).ready(
   () => $('span.rss-url').each(eachCallback);
});

Разница? Минимальна, если она вообще есть. В случае, если нам не надо протягивать parent в loadCallback, то — вау! — лямбда будет ровно в одном месте.