process.stdout.write("Hello world\n");и это будет работать, и мне не надо вникать как#include <unistd.h>
#include <string.h>
int main() {
char* str = "Hello world\n";
write(1, str, strlen(str));
return 0;
}.section .rodata
.LC0:
.string "Hello world\n"
.text
.globl main
.type main, @function
main:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
subq $16, %rsp
leaq .LC0(%rip), %rax
movq %rax, -8(%rbp)
movq -8(%rbp), %rax
movq %rax, %rdi
call strlen@PLT
movq %rax, %rdx
movq -8(%rbp), %rax
movq %rax, %rsi
movl $1, %edi
call write@PLT
movl $0, %eax
leave
.cfi_def_cfa 7, 8
ret
.cfi_endprocсам текст может содержать ошибки- тем более гуглим про расстояние Левинштейна
/**
* Crossbrowser event adding
*
* http://javascript.ru/tutorial/events/crossbrowser
*/
define([], function () {
var uid = 0;
function fixEvent (event) {
event = event || window.event;
if (event.isFixed) {
return event;
}
event.isFixed = true;
event.preventDefault = event.preventDefault || function () {
this.returnValue = false;
};
event.stopPropagation = event.stopPropagaton || function () {
this.cancelBubble = true;
};
if (!event.target) {
event.target = event.srcElement;
}
if (!event.relatedTarget && event.fromElement) {
event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
}
if (event.pageX == null && event.clientX != null) {
var html = document.documentElement,
body = document.body;
event.pageX = event.clientX + (html && html.scrollLeft || body && body.scrollLeft || 0) - (html.clientLeft || 0);
event.pageY = event.clientY + (html && html.scrollTop || body && body.scrollTop || 0) - (html.clientTop || 0);
}
if (!event.which && event.button) {
event.which = (event.button & 1 ? 1 : (event.button & 2 ? 3 : (event.button & 4 ? 2 : 0)));
}
return event;
}
/* this = element */
function commonHandle (event) {
event = fixEvent(event);
var handlers = this.events[event.type];
for (var g in handlers) {
var handler = handlers[g],
ret = handler.call(this, event);
if (ret === false) {
event.preventDefault();
event.stopPropagation();
}
}
}
var exports = {
/**
* custom event polyfill
* @param {String} name Event name
* @param {Object} options {bubles: Boolean, cancelable: Boolean, detail: {}}
*
* @return {EventObject} event instance
*/
create: function (name, options) {
try {
new CustomEvent('IE has CustomEvent, but doesn\'t support constructor');
} catch (e) {
var CustomEvent = function(event, params) {
var evt;
params = params || {
bubbles: false,
cancelable: false,
detail: undefined
};
evt = document.createEvent('CustomEvent');
evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
return evt;
};
}
return new CustomEvent(name, options);
},
/**
* Call handler only once by event type
*/
addOnce: function (elem, type, handler) {
var fn = function () {
handler.apply(this, arguments);
exports.remove(elem, type, fn);
};
this.add(elem, type, fn);
},
/**
* Add handler to element by event type
*/
add: function (elem, type, handler) {
if (elem.setInterval && (elem != window && !elem.frameElement)) {
elem = window;
}
if (!handler.uid) {
handler.uid = ++uid;
}
if (!elem.events) {
elem.events = {};
elem.handle = function (event) {
return commonHandle.call(elem, event);
}
}
if (!elem.events[type]) {
elem.events[type] = {};
if (elem.addEventListener) {
elem.addEventListener(type, elem.handle, false);
} else if (elem.attachEvent) {
elem.attachEvent('on' + type, elem.handle);
}
}
elem.events[type][handler.uid] = handler;
return handler;
},
/**
* Add handler to element by list of events
*/
addAll: function (element, events, handler) {
for (var i = 0; i < events.length; i++) {
this.add(element, events[i], handler);
}
},
/**
* Remove handler from element by event type
*/
remove: function (elem, type, handler) {
var handlers = elem.events && elem.events[type];
if (!handlers) {
return;
}
delete handlers[handler.uid];
for (var any in handlers) {
return;
}
if (elem.removeEventListener) {
elem.removeEventListener(type, elem.handle, false);
} else if (elem.detachEvent) {
elem.detachEvent('on' + type, elem.handle);
}
delete elem.events[type];
for (var any in elem.events) {
return;
}
try {
delete elem.handle;
delete elem.events;
} catch (e) {
elem.removeAttribute('handle');
elem.removeAttribute('events');
}
},
/**
* Remove handler from element by list of events
*/
removeAll: function (element, events, handler) {
for (var i = 0; i < events.length; i++) {
this.remove(element, events[i], handler);
}
}
};
return exports;
});
Но жрут-то они точно так же, как не в себя.
Спасибо за комментарий. А Вы уже что-то писали на электроне?да, писал
То есть, все кто на нём "пишет" сейчас, если смотреть по популярным программам - быдлокодеры и криворучки? Хм, то есть вообще все.Далеко не все. Те же VSCode и Discord весьма хорошо написаны, и проблем почему то не вызывают
И маааленький такой нюанс, хейтят его не столько программёры, сколько пользователи, часто просто вынужденные пользоваться, так как другого нет.Пользователь в 99.99% случаев вообще не парится, что под капотом у приложения, которым он пользуется
А в чем суть "надежности" второго решения?конкретно в данном небольшом кусочке - ни в чем, но в более глобальном смысле, иммутабельный код гарантирует, что текущий кусок кода не изменит никаких внешних данных и ничего этим не поломает.
Когда Вы компилите свою программу в elf (под Linux) - внутри именно такой код, только в бинарном виде (каждой такой команде соответствует своя последовательность байт, которую понимает процессор)
Вот только писать на этом что-то серьезное - тот еще гемор, поэтому на асме пишут только небольшие фрагменты, когда нужно точно быть уверенным, что будет делать процессор