Node2

Bienvenido al test sobre Node.js

Para comenzar pulsa sobre el botón de Iniciar.
Dispones de 15 minutos para responder el mayor número posible de respuestas correctas.
Las preguntas tendrán una única respuesta correcta.
Si has terminado el test antes del tiempo establecido, pulsa el botón Finalizar para enviarlo.

Para comenzar el test, completa tus datos y pulsa el botón "Siguiente"

Nombre completo

assert.isDate(value)

util.types.isDate(value)

console.isDate(value)

util.date(value)

exports, __filename, __dirname

exports, require, module, __filename, __dirname

exports, process, require, module, __filename, __dirname

exports, module, __filename, __dirname

p62

{'John'}

John

{}

Undefined

The event loop is single-threaded, but a JavaScript VM can use multiple threads

JavaScript execution in Node.js is single-threaded, but I/O operations are executed using multiple threads

Every Node process runs in a single thread, and all the I/O work is run in that same thread

Every Node process gets four threads that it can share between its JavaScript VM and the event loop

p24

server running at http://localhost:3000/

server running at port 3000

server running at http://localhost:4000/

server running at http://127.0.0.1:3000/

a C++ file that can have a .node extension and that Node will be able to execute directly.

a C++ Addon file that is built with node-gyp

a JSON file that can have a .node extension as well as the .json extension

a JavaScript file that can have a .node extension as well as the .js extension

spawn("ps -ef")

fork("ps -ef")

exec("ps", "-ef")

exec("ps -ef")

As Node.js is asynchronous, this is handled by a libuv and a threadpool. The performance will not notably degrade.

As Node.js is asynchronous, this is handled by a threadpool and the performance will not notably degrade.

The current thread will block until the executon is completed and the operating system will spawn new threads to handle incoming requests. This can exhaust the number of allowed threads (255) and degrade performance over time.

As the application code runs asynchronously within a single thread, the execution will block, accepting no more requests until the operation is completed.