Home Blog

nodejs cheatsheet

0

/* *******************************************************************************************
* SYNOPSIS
* http://nodejs.org/api/synopsis.html
* ******************************************************************************************* */

var http = require(‘http’);

// An example of a web server written with Node which responds with ‘Hello World’.
// To run the server, put the code into a file called example.js and execute it with the node program.
http.createServer(function (request, response) {
response.writeHead(200, {‘Content-Type’: ‘text/plain’});
response.end(‘Hello World\n’);
}).listen(8124);

console.log(‘Server running at http://127.0.0.1:8124/’);

/* *******************************************************************************************
* GLOBAL OBJECTS
* http://nodejs.org/api/globals.html
* ******************************************************************************************* */

// In browsers, the top-level scope is the global scope.
// That means that in browsers if you’re in the global scope var something will define a global variable.
// In Node this is different. The top-level scope is not the global scope; var something inside a Node module will be local to that module.

__filename; // The filename of the code being executed. (absolute path)
__dirname; // The name of the directory that the currently executing script resides in. (absolute path)
module; // A reference to the current module. In particular module.exports is used for defining what a module exports and makes available through require().
exports; // A reference to the module.exports that is shorter to type.
process; // The process object is a global object and can be accessed from anywhere. It is an instance of EventEmitter.
Buffer; // The Buffer class is a global type for dealing with binary data directly.

/* *******************************************************************************************
* CONSOLE
* http://nodejs.org/api/console.html
* ******************************************************************************************* */

console.log([data], […]); // Prints to stdout with newline.
console.info([data], […]); // Same as console.log.
console.error([data], […]); // Same as console.log but prints to stderr.
console.warn([data], […]); // Same as console.error.
console.dir(obj); // Uses util.inspect on obj and prints resulting string to stdout.
console.time(label); // Mark a time.
console.timeEnd(label); // Finish timer, record output.
console.trace(label); // Print a stack trace to stderr of the current position.
console.assert(expression, [message]); // Same as assert.ok() where if the expression evaluates as false throw an AssertionError with message.

/* *******************************************************************************************
* TIMERS
* http://nodejs.org/api/timers.html
* ******************************************************************************************* */

setTimeout(callback, delay, [arg], […]); // To schedule execution of a one-time callback after delay milliseconds. Optionally you can also pass arguments to the callback.
clearTimeout(t); // Stop a timer that was previously created with setTimeout().
setInterval(callback, delay, [arg], […]); // To schedule the repeated execution of callback every delay milliseconds. Optionally you can also pass arguments to the callback.
clearInterval(t); // Stop a timer that was previously created with setInterval().
setImmediate(callback, [arg], […]); // To schedule the “immediate” execution of callback after I/O events callbacks and before setTimeout and setInterval.
clearImmediate(immediateObject); // Stop a timer that was previously created with setImmediate().

unref(); // Allow you to create a timer that is active but if it is the only item left in the event loop, node won’t keep the program running.
ref(); // If you had previously unref()d a timer you can call ref() to explicitly request the timer hold the program open.

/* *******************************************************************************************
* MODULES
* http://nodejs.org/api/modules.html
* ******************************************************************************************* */

var module = require(‘./module.js’); // Loads the module module.js in the same directory.
module.require(‘./another_module.js’); // load another_module as if require() was called from the module itself.

module.id; // The identifier for the module. Typically this is the fully resolved filename.
module.filename; // The fully resolved filename to the module.
module.loaded; // Whether or not the module is done loading, or is in the process of loading.
module.parent; // The module that required this one.
module.children; // The module objects required by this one.

exports.area = function (r) {
return Math.PI * r * r;
};

// If you want the root of your module’s export to be a function (such as a constructor)
// or if you want to export a complete object in one assignment instead of building it one property at a time,
// assign it to module.exports instead of exports.
module.exports = function(width) {
return {
area: function() {
return width * width;
}
};
}

/* *******************************************************************************************
* PROCESS
* http://nodejs.org/api/process.html
* ******************************************************************************************* */

process.on(‘exit’, function(code) {}); // Emitted when the process is about to exit
process.on(‘uncaughtException’, function(err) {}); // Emitted when an exception bubbles all the way back to the event loop. (should not be used)

process.stdout; // A writable stream to stdout.
process.stderr; // A writable stream to stderr.
process.stdin; // A readable stream for stdin.

process.argv; // An array containing the command line arguments.
process.env; // An object containing the user environment.
process.execPath; // This is the absolute pathname of the executable that started the process.
process.execArgv; // This is the set of node-specific command line options from the executable that started the process.

process.arch; // What processor architecture you’re running on: ‘arm’, ‘ia32’, or ‘x64’.
process.config; // An Object containing the JavaScript representation of the configure options that were used to compile the current node executable.
process.pid; // The PID of the process.
process.platform; // What platform you’re running on: ‘darwin’, ‘freebsd’, ‘linux’, ‘sunos’ or ‘win32’.
process.title; // Getter/setter to set what is displayed in ‘ps’.
process.version; // A compiled-in property that exposes NODE_VERSION.
process.versions; // A property exposing version strings of node and its dependencies.

process.abort(); // This causes node to emit an abort. This will cause node to exit and generate a core file.
process.chdir(dir); // Changes the current working directory of the process or throws an exception if that fails.
process.cwd(); // Returns the current working directory of the process.
process.exit([code]); // Ends the process with the specified code. If omitted, exit uses the ‘success’ code 0.
process.getgid(); // Gets the group identity of the process.
process.setgid(id); // Sets the group identity of the process.
process.getuid(); // Gets the user identity of the process.
process.setuid(id); // Sets the user identity of the process.
process.getgroups(); // Returns an array with the supplementary group IDs.
process.setgroups(grps); // Sets the supplementary group IDs.

process.initgroups(user, extra_grp); // Reads /etc/group and initializes the group access list, using all groups of which the user is a member.
process.kill(pid, [signal]); // Send a signal to a process. pid is the process id and signal is the string describing the signal to send.
process.memoryUsage(); // Returns an object describing the memory usage of the Node process measured in bytes.
process.nextTick(callback); // On the next loop around the event loop call this callback.
process.maxTickDepth; // Callbacks passed to process.nextTick will usually be called at the end of the current flow of execution, and are thus approximately as fast as calling a function synchronously.
process.umask([mask]); // Sets or reads the process’s file mode creation mask.
process.uptime(); // Number of seconds Node has been running.
process.hrtime(); // Returns the current high-resolution real time in a [seconds, nanoseconds] tuple Array.

/* *******************************************************************************************
* CHILD PROCESS
* http://nodejs.org/api/child_process.html
* ******************************************************************************************* */

// Node provides a tri-directional popen facility through the child_process module.
// It is possible to stream data through a child’s stdin, stdout, and stderr in a fully non-blocking way.

ChildProcess; // Class. ChildProcess is an EventEmitter.

child.stdin; // A Writable Stream that represents the child process’s stdin
child.stdout; // A Readable Stream that represents the child process’s stdout
child.stderr; // A Readable Stream that represents the child process’s stderr.
child.pid; // The PID of the child process
child.connected; // If .connected is false, it is no longer possible to send messages
child.kill([signal]); // Send a signal to the child process
child.send(message, [sendHandle]); // When using child_process.fork() you can write to the child using child.send(message, [sendHandle]) and messages are received by a ‘message’ event on the child.
child.disconnect(); // Close the IPC channel between parent and child, allowing the child to exit gracefully once there are no other connections keeping it alive.
child_process.spawn(command, [args], [options]); // Launches a new process with the given command, with command line arguments in args. If omitted, args defaults to an empty Array.
child_process.exec(command, [options], callback); // Runs a command in a shell and buffers the output.
child_process.execFile(file, [args], [options], [callback]); // Runs a command in a shell and buffers the output.
child_process.fork(modulePath, [args], [options]); // This is a special case of the spawn() functionality for spawning Node processes. In addition to having all the methods in a normal ChildProcess instance, the returned object has a communication channel built-in.

/* *******************************************************************************************
* UTIL
* http://nodejs.org/api/util.html
* ******************************************************************************************* */

// These functions are in the module ‘util’. Use require(‘util’) to access them.

util.format(format, […]); // Returns a formatted string using the first argument as a printf-like format. (%s, %d, %j)
util.debug(string); // A synchronous output function. Will block the process and output string immediately to stderr.
util.error([…]); // Same as util.debug() except this will output all arguments immediately to stderr.
util.puts([…]); // A synchronous output function. Will block the process and output all arguments to stdout with newlines after each argument.
util.print([…]); // A synchronous output function. Will block the process, cast each argument to a string then output to stdout. (no newlines)
util.log(string); // Output with timestamp on stdout.
util.inspect(object, [opts]); // Return a string representation of object, which is useful for debugging. (options: showHidden, depth, colors, customInspect)
util.isArray(object); // Returns true if the given “object” is an Array. false otherwise.
util.isRegExp(object); // Returns true if the given “object” is a RegExp. false otherwise.
util.isDate(object); // Returns true if the given “object” is a Date. false otherwise.
util.isError(object); // Returns true if the given “object” is an Error. false otherwise.
util.promisify(fn) // Takes a function whose last argument is a callback and returns a version that returns promises.

util.inherits(constructor, superConstructor); // Inherit the prototype methods from one constructor into another.

/* *******************************************************************************************
* EVENTS
* http://nodejs.org/api/events.html
* ******************************************************************************************* */

// All objects which emit events are instances of events.EventEmitter. You can access this module by doing: require(“events”);
// To access the EventEmitter class, require(‘events’).EventEmitter.
// All EventEmitters emit the event ‘newListener’ when new listeners are added and ‘removeListener’ when a listener is removed.

emitter.addListener(event, listener); // Adds a listener to the end of the listeners array for the specified event.
emitter.on(event, listener); // Same as emitter.addListener().
emitter.once(event, listener); // Adds a one time listener for the event. This listener is invoked only the next time the event is fired, after which it is removed.
emitter.removeListener(event, listener); // Remove a listener from the listener array for the specified event.
emitter.removeAllListeners([event]); // Removes all listeners, or those of the specified event.
emitter.setMaxListeners(n); // By default EventEmitters will print a warning if more than 10 listeners are added for a particular event.
emitter.listeners(event); // Returns an array of listeners for the specified event.
emitter.emit(event, [arg1], [arg2], […]); // Execute each of the listeners in order with the supplied arguments. Returns true if event had listeners, false otherwise.

EventEmitter.listenerCount(emitter, event); // Return the number of listeners for a given event.

/* *******************************************************************************************
* STREAM
* http://nodejs.org/api/stream.html
* ******************************************************************************************* */

// A stream is an abstract interface implemented by various objects in Node. For example a request to an HTTP server is a stream, as is stdout.
// Streams are readable, writable, or both. All streams are instances of EventEmitter.

// The Readable stream interface is the abstraction for a source of data that you are reading from.
// In other words, data comes out of a Readable stream.
// A Readable stream will not start emitting data until you indicate that you are ready to receive it.
// Examples of readable streams include: http responses on the client, http requests on the server, fs read streams
// zlib streams, crypto streams, tcp sockets, child process stdout and stderr, process.stdin.

var readable = getReadableStreamSomehow();

readable.on(‘readable’, function() {}); // When a chunk of data can be read from the stream, it will emit a ‘readable’ event.
readable.on(‘data’, function(chunk) {}); // If you attach a data event listener, then it will switch the stream into flowing mode, and data will be passed to your handler as soon as it is available.
readable.on(‘end’, function() {}); // This event fires when there will be no more data to read.
readable.on(‘close’, function() {}); // Emitted when the underlying resource (for example, the backing file descriptor) has been closed. Not all streams will emit this.
readable.on(‘error’, function() {}); // Emitted if there was an error receiving data.

// The read() method pulls some data out of the internal buffer and returns it. If there is no data available, then it will return null.
// This method should only be called in non-flowing mode. In flowing-mode, this method is called automatically until the internal buffer is drained.
readable.read([size]);

readable.setEncoding(encoding); // Call this function to cause the stream to return strings of the specified encoding instead of Buffer objects.
readable.resume(); // This method will cause the readable stream to resume emitting data events.
readable.pause(); // This method will cause a stream in flowing-mode to stop emitting data events.
readable.pipe(destination, [options]); // This method pulls all the data out of a readable stream, and writes it to the supplied destination, automatically managing the flow so that the destination is not overwhelmed by a fast readable stream.
readable.unpipe([destination]); // This method will remove the hooks set up for a previous pipe() call. If the destination is not specified, then all pipes are removed.
readable.unshift(chunk); // This is useful in certain cases where a stream is being consumed by a parser, which needs to “un-consume” some data that it has optimistically pulled out of the source, so that the stream can be passed on to some other party.

// The Writable stream interface is an abstraction for a destination that you are writing data to.
// Examples of writable streams include: http requests on the client, http responses on the server, fs write streams,
// zlib streams, crypto streams, tcp sockets, child process stdin, process.stdout, process.stderr.

var writer = getWritableStreamSomehow();

writable.write(chunk, [encoding], [callback]); // This method writes some data to the underlying system, and calls the supplied callback once the data has been fully handled.
writer.once(‘drain’, write); // If a writable.write(chunk) call returns false, then the drain event will indicate when it is appropriate to begin writing more data to the stream.

writable.end([chunk], [encoding], [callback]); // Call this method when no more data will be written to the stream.
writer.on(‘finish’, function() {}); // When the end() method has been called, and all data has been flushed to the underlying system, this event is emitted.
writer.on(‘pipe’, function(src) {}); // This is emitted whenever the pipe() method is called on a readable stream, adding this writable to its set of destinations.
writer.on(‘unpipe’, function(src) {}); // This is emitted whenever the unpipe() method is called on a readable stream, removing this writable from its set of destinations.
writer.on(‘error’, function(src) {}); // Emitted if there was an error when writing or piping data.

// Duplex streams are streams that implement both the Readable and Writable interfaces. See above for usage.
// Examples of Duplex streams include: tcp sockets, zlib streams, crypto streams.

// Transform streams are Duplex streams where the output is in some way computed from the input. They implement both the Readable and Writable interfaces. See above for usage.
// Examples of Transform streams include: zlib streams, crypto streams.

/* *******************************************************************************************
* FILE SYSTEM
* http://nodejs.org/api/fs.html
* ******************************************************************************************* */

// To use this module do require(‘fs’).
// All the methods have asynchronous and synchronous forms.

fs.rename(oldPath, newPath, callback); // Asynchronous rename. No arguments other than a possible exception are given to the completion callback.Asynchronous ftruncate. No arguments other than a possible exception are given to the completion callback.
fs.renameSync(oldPath, newPath); // Synchronous rename.

fs.ftruncate(fd, len, callback); // Asynchronous ftruncate. No arguments other than a possible exception are given to the completion callback.
fs.ftruncateSync(fd, len); // Synchronous ftruncate.
fs.truncate(path, len, callback); // Asynchronous truncate. No arguments other than a possible exception are given to the completion callback.
fs.truncateSync(path, len); // Synchronous truncate.

fs.chown(path, uid, gid, callback); // Asynchronous chown. No arguments other than a possible exception are given to the completion callback.
fs.chownSync(path, uid, gid); // Synchronous chown.
fs.fchown(fd, uid, gid, callback); // Asynchronous fchown. No arguments other than a possible exception are given to the completion callback.
fs.fchownSync(fd, uid, gid); // Synchronous fchown.
fs.lchown(path, uid, gid, callback); // Asynchronous lchown. No arguments other than a possible exception are given to the completion callback.
fs.lchownSync(path, uid, gid); // Synchronous lchown.

fs.chmod(path, mode, callback); // Asynchronous chmod. No arguments other than a possible exception are given to the completion callback.
fs.chmodSync(path, mode); // Synchronous chmod.
fs.fchmod(fd, mode, callback); // Asynchronous fchmod. No arguments other than a possible exception are given to the completion callback.
fs.fchmodSync(fd, mode); // Synchronous fchmod.
fs.lchmod(path, mode, callback); // Asynchronous lchmod. No arguments other than a possible exception are given to the completion callback.
fs.lchmodSync(path, mode); // Synchronous lchmod.

fs.stat(path, callback); // Asynchronous stat. The callback gets two arguments (err, stats) where stats is a fs.Stats object.
fs.statSync(path); // Synchronous stat. Returns an instance of fs.Stats.
fs.lstat(path, callback); // Asynchronous lstat. The callback gets two arguments (err, stats) where stats is a fs.Stats object. lstat() is identical to stat(), except that if path is a symbolic link, then the link itself is stat-ed, not the file that it refers to.
fs.lstatSync(path); // Synchronous lstat. Returns an instance of fs.Stats.
fs.fstat(fd, callback); // Asynchronous fstat. The callback gets two arguments (err, stats) where stats is a fs.Stats object. fstat() is identical to stat(), except that the file to be stat-ed is specified by the file descriptor fd.
fs.fstatSync(fd); // Synchronous fstat. Returns an instance of fs.Stats.

fs.link(srcpath, dstpath, callback); // Asynchronous link. No arguments other than a possible exception are given to the completion callback.
fs.linkSync(srcpath, dstpath); // Synchronous link.
fs.symlink(srcpath, dstpath, [type], callback); // Asynchronous symlink. No arguments other than a possible exception are given to the completion callback. The type argument can be set to ‘dir’, ‘file’, or ‘junction’ (default is ‘file’) and is only available on Windows (ignored on other platforms)
fs.symlinkSync(srcpath, dstpath, [type]); // Synchronous symlink.
fs.readlink(path, callback); // Asynchronous readlink. The callback gets two arguments (err, linkString).
fs.readlinkSync(path); // Synchronous readlink. Returns the symbolic link’s string value.
fs.unlink(path, callback); // Asynchronous unlink. No arguments other than a possible exception are given to the completion callback.
fs.unlinkSync(path); // Synchronous unlink.

fs.realpath(path, [cache], callback); // Asynchronous realpath. The callback gets two arguments (err, resolvedPath).
fs.realpathSync(path, [cache]); // Synchronous realpath. Returns the resolved path.

fs.rmdir(path, callback); // Asynchronous rmdir. No arguments other than a possible exception are given to the completion callback.
fs.rmdirSync(path); // Synchronous rmdir.
fs.mkdir(path, [mode], callback); // Asynchronous mkdir. No arguments other than a possible exception are given to the completion callback. mode defaults to 0777.
fs.mkdirSync(path, [mode]); // Synchronous mkdir.
fs.readdir(path, callback); // Asynchronous readdir. Reads the contents of a directory. The callback gets two arguments (err, files) where files is an array of the names of the files in the directory excluding ‘.’ and ‘..’.
fs.readdirSync(path); // Synchronous readdir. Returns an array of filenames excluding ‘.’ and ‘..’.
fs.close(fd, callback); // Asynchronous close. No arguments other than a possible exception are given to the completion callback.
fs.closeSync(fd); // Synchronous close.
fs.open(path, flags, [mode], callback); // Asynchronous file open.
fs.openSync(path, flags, [mode]); // Synchronous version of fs.open().
fs.utimes(path, atime, mtime, callback); // Change file timestamps of the file referenced by the supplied path.
fs.utimesSync(path, atime, mtime); // Synchronous version of fs.utimes().
fs.futimes(fd, atime, mtime, callback); // Change the file timestamps of a file referenced by the supplied file descriptor.
fs.futimesSync(fd, atime, mtime); // Synchronous version of fs.futimes().
fs.fsync(fd, callback); // Asynchronous fsync. No arguments other than a possible exception are given to the completion callback.
fs.fsyncSync(fd); // Synchronous fsync.

fs.write(fd, buffer, offset, length, position, callback); // Write buffer to the file specified by fd.
fs.writeSync(fd, buffer, offset, length, position); // Synchronous version of fs.write(). Returns the number of bytes written.
fs.read(fd, buffer, offset, length, position, callback); // Read data from the file specified by fd.
fs.readSync(fd, buffer, offset, length, position); // Synchronous version of fs.read. Returns the number of bytesRead.
fs.readFile(filename, [options], callback); // Asynchronously reads the entire contents of a file.
fs.readFileSync(filename, [options]); // Synchronous version of fs.readFile. Returns the contents of the filename. If the encoding option is specified then this function returns a string. Otherwise it returns a buffer.

fs.writeFile(filename, data, [options], callback); // Asynchronously writes data to a file, replacing the file if it already exists. data can be a string or a buffer.
fs.writeFileSync(filename, data, [options]); // The synchronous version of fs.writeFile.
fs.appendFile(filename, data, [options], callback); // Asynchronously append data to a file, creating the file if it not yet exists. data can be a string or a buffer.
fs.appendFileSync(filename, data, [options]); // The synchronous version of fs.appendFile.
fs.watch(filename, [options], [listener]); // Watch for changes on filename, where filename is either a file or a directory. The returned object is a fs.FSWatcher. The listener callback gets two arguments (event, filename). event is either ‘rename’ or ‘change’, and filename is the name of the file which triggered the event.
fs.exists(path, callback); // Test whether or not the given path exists by checking with the file system. Then call the callback argument with either true or false. (should not be used)
fs.existsSync(path); // Synchronous version of fs.exists. (should not be used)

// fs.Stats: objects returned from fs.stat(), fs.lstat() and fs.fstat() and their synchronous counterparts are of this type.
stats.isFile();
stats.isDirectory()
stats.isBlockDevice()
stats.isCharacterDevice()
stats.isSymbolicLink() // (only valid with fs.lstat())
stats.isFIFO()
stats.isSocket()

fs.createReadStream(path, [options]); // Returns a new ReadStream object.
fs.createWriteStream(path, [options]); // Returns a new WriteStream object.

/* *******************************************************************************************
* PATH
* http://nodejs.org/api/fs.html
* ******************************************************************************************* */

// Use require(‘path’) to use this module.
// This module contains utilities for handling and transforming file paths.
// Almost all these methods perform only string transformations.
// The file system is not consulted to check whether paths are valid.

path.normalize(p); // Normalize a string path, taking care of ‘..’ and ‘.’ parts.
path.join([path1], [path2], […]); // Join all arguments together and normalize the resulting path.
path.resolve([from …], to); // Resolves ‘to’ to an absolute path.
path.relative(from, to); // Solve the relative path from ‘from’ to ‘to’.
path.dirname(p); // Return the directory name of a path. Similar to the Unix dirname command.
path.basename(p, [ext]); // Return the last portion of a path. Similar to the Unix basename command.
path.extname(p); // Return the extension of the path, from the last ‘.’ to end of string in the last portion of the path.

path.sep; // The platform-specific file separator. ‘\\’ or ‘/’.
path.delimiter; // The platform-specific path delimiter, ‘;’ or ‘:’.

/* *******************************************************************************************
* HTTP
* http://nodejs.org/api/http.html
* ******************************************************************************************* */

// To use the HTTP server and client one must require(‘http’).

http.STATUS_CODES; // A collection of all the standard HTTP response status codes, and the short description of each.
http.request(options, [callback]); // This function allows one to transparently issue requests.
http.get(options, [callback]); // Set the method to GET and calls req.end() automatically.

server = http.createServer([requestListener]); // Returns a new web server object. The requestListener is a function which is automatically added to the ‘request’ event.
server.listen(port, [hostname], [backlog], [callback]); // Begin accepting connections on the specified port and hostname.
server.listen(path, [callback]); // Start a UNIX socket server listening for connections on the given path.
server.listen(handle, [callback]); // The handle object can be set to either a server or socket (anything with an underlying _handle member), or a {fd: <n>} object.
server.close([callback]); // Stops the server from accepting new connections.
server.setTimeout(msecs, callback); // Sets the timeout value for sockets, and emits a ‘timeout’ event on the Server object, passing the socket as an argument, if a timeout occurs.

server.maxHeadersCount; // Limits maximum incoming headers count, equal to 1000 by default. If set to 0 – no limit will be applied.
server.timeout; // The number of milliseconds of inactivity before a socket is presumed to have timed out.

server.on(‘request’, function (request, response) { }); // Emitted each time there is a request.
server.on(‘connection’, function (socket) { }); // When a new TCP stream is established.
server.on(‘close’, function () { }); // Emitted when the server closes.
server.on(‘checkContinue’, function (request, response) { }); // Emitted each time a request with an http Expect: 100-continue is received.
server.on(‘connect’, function (request, socket, head) { }); // Emitted each time a client requests a http CONNECT method.
server.on(‘upgrade’, function (request, socket, head) { }); // Emitted each time a client requests a http upgrade.
server.on(‘clientError’, function (exception, socket) { }); // If a client connection emits an ‘error’ event – it will forwarded here.

request.write(chunk, [encoding]); // Sends a chunk of the body.
request.end([data], [encoding]); // Finishes sending the request. If any parts of the body are unsent, it will flush them to the stream.
request.abort(); // Aborts a request.
request.setTimeout(timeout, [callback]); // Once a socket is assigned to this request and is connected socket.setTimeout() will be called.
request.setNoDelay([noDelay]); // Once a socket is assigned to this request and is connected socket.setNoDelay() will be called.
request.setSocketKeepAlive([enable], [initialDelay]); // Once a socket is assigned to this request and is connected socket.setKeepAlive() will be called.

request.on(‘response’, function(response) { }); // Emitted when a response is received to this request. This event is emitted only once.
request.on(‘socket’, function(socket) { }); // Emitted after a socket is assigned to this request.
request.on(‘connect’, function(response, socket, head) { }); // Emitted each time a server responds to a request with a CONNECT method. If this event isn’t being listened for, clients receiving a CONNECT method will have their connections closed.
request.on(‘upgrade’, function(response, socket, head) { }); // Emitted each time a server responds to a request with an upgrade. If this event isn’t being listened for, clients receiving an upgrade header will have their connections closed.
request.on(‘continue’, function() { }); // Emitted when the server sends a ‘100 Continue’ HTTP response, usually because the request contained ‘Expect: 100-continue’. This is an instruction that the client should send the request body.

response.write(chunk, [encoding]); // This sends a chunk of the response body. If this merthod is called and response.writeHead() has not been called, it will switch to implicit header mode and flush the implicit headers.
response.writeContinue(); // Sends a HTTP/1.1 100 Continue message to the client, indicating that the request body should be sent.
response.writeHead(statusCode, [reasonPhrase], [headers]); // Sends a response header to the request.
response.setTimeout(msecs, callback); // Sets the Socket’s timeout value to msecs. If a callback is provided, then it is added as a listener on the ‘timeout’ event on the response object.
response.setHeader(name, value); // Sets a single header value for implicit headers. If this header already exists in the to-be-sent headers, its value will be replaced. Use an array of strings here if you need to send multiple headers with the same name.
response.getHeader(name); // Reads out a header that’s already been queued but not sent to the client. Note that the name is case insensitive.
response.removeHeader(name); // Removes a header that’s queued for implicit sending.
response.addTrailers(headers); // This method adds HTTP trailing headers (a header but at the end of the message) to the response.
response.end([data], [encoding]); // This method signals to the server that all of the response headers and body have been sent; that server should consider this message complete. The method, response.end(), MUST be called on each response.

response.statusCode; // When using implicit headers (not calling response.writeHead() explicitly), this property controls the status code that will be sent to the client when the headers get flushed.
response.headersSent; // Boolean (read-only). True if headers were sent, false otherwise.
response.sendDate; // When true, the Date header will be automatically generated and sent in the response if it is not already present in the headers. Defaults to true.

response.on(‘close’, function () { }); // Indicates that the underlying connection was terminated before response.end() was called or able to flush.
response.on(‘finish’, function() { }); // Emitted when the response has been sent.

message.httpVersion; // In case of server request, the HTTP version sent by the client. In the case of client response, the HTTP version of the connected-to server.
message.headers; // The request/response headers object.
message.trailers; // The request/response trailers object. Only populated after the ‘end’ event.
message.method; // The request method as a string. Read only. Example: ‘GET’, ‘DELETE’.
message.url; // Request URL string. This contains only the URL that is present in the actual HTTP request.
message.statusCode; // The 3-digit HTTP response status code. E.G. 404.
message.socket; // The net.Socket object associated with the connection.

message.setTimeout(msecs, callback); // Calls message.connection.setTimeout(msecs, callback).

/* *******************************************************************************************
* URL
* http://nodejs.org/api/url.html
* ******************************************************************************************* */

// This module has utilities for URL resolution and parsing. Call require(‘url’) to use it.

url.parse(urlStr, [parseQueryString], [slashesDenoteHost]); // Take a URL string, and return an object.
url.format(urlObj); // Take a parsed URL object, and return a formatted URL string.
url.resolve(from, to); // Take a base URL, and a href URL, and resolve them as a browser would for an anchor tag.

/* *******************************************************************************************
* QUERY STRING
* http://nodejs.org/api/querystring.html
* ******************************************************************************************* */

// This module provides utilities for dealing with query strings. Call require(‘querystring’) to use it.

querystring.stringify(obj, [sep], [eq]); // Serialize an object to a query string. Optionally override the default separator (‘&’) and assignment (‘=’) characters.
querystring.parse(str, [sep], [eq], [options]); // Deserialize a query string to an object. Optionally override the default separator (‘&’) and assignment (‘=’) characters.

/* *******************************************************************************************
* ASSERT
* http://nodejs.org/api/assert.html
* ******************************************************************************************* */

// This module is used for writing unit tests for your applications, you can access it with require(‘assert’).

assert.fail(actual, expected, message, operator); // Throws an exception that displays the values for actual and expected separated by the provided operator.
assert(value, message); assert.ok(value, [message]); // Tests if value is truthy, it is equivalent to assert.equal(true, !!value, message);
assert.equal(actual, expected, [message]); // Tests shallow, coercive equality with the equal comparison operator ( == ).
assert.notEqual(actual, expected, [message]); // Tests shallow, coercive non-equality with the not equal comparison operator ( != ).
assert.deepEqual(actual, expected, [message]); // Tests for deep equality.
assert.notDeepEqual(actual, expected, [message]); // Tests for any deep inequality.
assert.strictEqual(actual, expected, [message]); // Tests strict equality, as determined by the strict equality operator ( === )
assert.notStrictEqual(actual, expected, [message]); // Tests strict non-equality, as determined by the strict not equal operator ( !== )
assert.throws(block, [error], [message]); // Expects block to throw an error. error can be constructor, RegExp or validation function.
assert.doesNotThrow(block, [message]); // Expects block not to throw an error, see assert.throws for details.
assert.ifError(value); // Tests if value is not a false value, throws if it is a true value. Useful when testing the first argument, error in callbacks.

/* *******************************************************************************************
* OS
* http://nodejs.org/api/os.html
* ******************************************************************************************* */

// Provides a few basic operating-system related utility functions.
// Use require(‘os’) to access this module.

os.tmpdir(); // Returns the operating system’s default directory for temp files.
os.endianness(); // Returns the endianness of the CPU. Possible values are “BE” or “LE”.
os.hostname(); // Returns the hostname of the operating system.
os.type(); // Returns the operating system name.
os.platform(); // Returns the operating system platform.
os.arch(); // Returns the operating system CPU architecture.
os.release(); // Returns the operating system release.
os.uptime(); // Returns the system uptime in seconds.
os.loadavg(); // Returns an array containing the 1, 5, and 15 minute load averages.
os.totalmem(); // Returns the total amount of system memory in bytes.
os.freemem(); // Returns the amount of free system memory in bytes.
os.cpus(); // Returns an array of objects containing information about each CPU/core installed: model, speed (in MHz), and times (an object containing the number of milliseconds the CPU/core spent in: user, nice, sys, idle, and irq).
os.networkInterfaces(); // Get a list of network interfaces.
os.EOL; // A constant defining the appropriate End-of-line marker for the operating system.

/* *******************************************************************************************
* BUFFER
* http://nodejs.org/api/buffer.html
* ******************************************************************************************* */

// Buffer is used to dealing with binary data
// Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap

Buffer.from(size); // Allocates a new buffer of size octets.
Buffer.from(array); // Allocates a new buffer using an array of octets.
Buffer.from(str, [encoding]); // Allocates a new buffer containing the given str. encoding defaults to ‘utf8’.

Buffer.isEncoding(encoding); // Returns true if the encoding is a valid encoding argument, or false otherwise.
Buffer.isBuffer(obj); // Tests if obj is a Buffer
Buffer.concat(list, [totalLength]); // Returns a buffer which is the result of concatenating all the buffers in the list together.
Buffer.byteLength(string, [encoding]); // Gives the actual byte length of a string.

buf.write(string, [offset], [length], [encoding]); // Writes string to the buffer at offset using the given encoding
buf.toString([encoding], [start], [end]); // Decodes and returns a string from buffer data encoded with encoding (defaults to ‘utf8’) beginning at start (defaults to 0) and ending at end (defaults to buffer.length).
buf.toJSON(); // Returns a JSON-representation of the Buffer instance, which is identical to the output for JSON Arrays
buf.copy(targetBuffer, [targetStart], [sourceStart], [sourceEnd]); // Does copy between buffers. The source and target regions can be overlapped
buf.slice([start], [end]); // Returns a new buffer which references the same memory as the old, but offset and cropped by the start (defaults to 0) and end (defaults to buffer.length) indexes. Negative indexes start from the end of the buffer.
buf.fill(value, [offset], [end]); // Fills the buffer with the specified value
buf[index]; // Get and set the octet at index
buf.length; // The size of the buffer in bytes, Note that this is not necessarily the size of the contents

buffer.INSPECT_MAX_BYTES; // How many bytes will be returned when buffer.inspect() is called. This can be overridden by user modules.

Javascript cheatsheet

0

/* *******************************************************************************************
* GLOBAL OBJECTS > OBJECT
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object
* ******************************************************************************************* */

// Global object: properties
Object.length // length is a property of a function object, and indicates how many arguments the function expects, i.e. the number of formal parameters. This number does not include the rest parameter. Has a value of 1.
Object.prototype // Represents the Object prototype object and allows to add new properties and methods to all objects of type Object.

// Methods of the Object constructor
Object.assign(target, …sources) // Copies the values of all enumerable own properties from one or more source objects to a target object. method is used to copy the values of all enumerable own properties from one or more source objects to a target object. It will return the target object
Object.create(MyObject) // Creates a new object with the specified prototype object and properties. The object which should be the prototype of the newly-created object.
Object.defineProperty(obj, prop, descriptor) // Adds the named property described by a given descriptor to an object.
Object.defineProperties(obj, props) // Adds the named properties described by the given descriptors to an object.
Object.entries(obj) // Returns an array containing all of the [key, value] pairs of a given object’s own enumerable string properties.
Object.freeze(obj) // Freezes an object: other code can’t delete or change any properties.
Object.getOwnPropertyDescriptor(obj, prop) // Returns a property descriptor for a named property on an object.
Object.getOwnPropertyDescriptors(obj) // Returns an object containing all own property descriptors for an object.
Object.getOwnPropertyNames(obj) // Returns an array containing the names of all of the given object’s own enumerable and non-enumerable properties.
Object.getOwnPropertySymbols(obj) // Returns an array of all symbol properties found directly upon a given object.
Object.getPrototypeOf(obj) // Returns the prototype of the specified object.
Object.is(value1, value2); // Compares if two values are the same value. Equates all NaN values (which differs from both Abstract Equality Comparison and Strict Equality Comparison).
Object.isExtensible(obj) // Determines if extending of an object is allowed.
Object.isFrozen(obj) // Determines if an object was frozen.
Object.isSealed(obj) // Determines if an object is sealed.
Object.keys(obj) // Returns an array containing the names of all of the given object’s own enumerable string properties.
Object.preventExtensions(obj) // Prevents any extensions of an object.
Object.seal(obj) // Prevents other code from deleting properties of an object.
Object.setPrototypeOf(obj, prototype) // Sets the prototype (i.e., the internal [[Prototype]] property).
Object.values(obj) // Returns an array containing the values that correspond to all of a given object’s own enumerable string properties.

// Object instances and Object prototype object (Object.prototype.property or Object.prototype.method())
// Properties
obj.constructor // Specifies the function that creates an object’s prototype.
obj.__proto__ // Points to the object which was used as prototype when the object was instantiated.

// Methods
obj.hasOwnProperty(prop) // Returns a boolean indicating whether an object contains the specified property as a direct property of that object and not inherited through the prototype chain.
prototypeObj.isPrototypeOf(object) // Returns a boolean indicating whether the object this method is called upon is in the prototype chain of the specified object.
obj.propertyIsEnumerable(prop) // Returns a boolean indicating if the internal ECMAScript [[Enumerable]] attribute is set.
obj.toLocaleString() // Calls toString().
obj.toString() // Returns a string representation of the object.
object.valueOf() // Returns the primitive value of the specified object.

/* *******************************************************************************************
* GLOBAL OBJECTS > ARRAY
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
* ******************************************************************************************* */

// Global object: properties
Array.length // Reflects the number of elements in an array.
Array.prototype // Represents the prototype for the Array constructor and allows to add new properties and methods to all Array objects.

// Global object: methods
Array.from(arrayLike[, mapFn[, thisArg]]) // Creates a new Array instance from an array-like or iterable object.
Array.isArray(obj) // Returns true if a variable is an array, if not false.
Array.of(element0[, element1[, …[, elementN]]]) // Creates a new Array instance with a variable number of arguments, regardless of number or type of the arguments.

// Instance: properties
arr.length // Reflects the number of elements in an array.

// Instance: mutator methods
arr.copyWithin(target, start, end) // Copies a sequence of array elements within the array.
arr.fill(value, start, end) // Fills all the elements of an array from a start index to an end index with a static value.
arr.pop() // Removes the last element from an array and returns that element.
arr.push([element1[, …[, elementN]]]) // Adds one or more elements to the end of an array and returns the new length of the array.
arr.reverse() // Reverses the order of the elements of an array in place — the first becomes the last, and the last becomes the first.
arr.shift() // Removes the first element from an array and returns that element.
arr.sort() // Sorts the elements of an array in place and returns the array.
array.splice(start, deleteCount, item1, item2, …) // Adds and/or removes elements from an array.
arr.unshift([element1[, …[, elementN]]]) // Adds one or more elements to the front of an array and returns the new length of the array.

// Instance: accessor methods
arr.concat(value1[, value2[, …[, valueN]]]) // Returns a new array comprised of this array joined with other array(s) and/or value(s).
arr.includes(searchElement, fromIndex) // Determines whether an array contains a certain element, returning true or false as appropriate.
arr.indexOf(searchElement[, fromIndex]) // Returns the first (least) index of an element within the array equal to the specified value, or -1 if none is found.
arr.join(separator) // Joins all elements of an array into a string.
arr.lastIndexOf(searchElement, fromIndex) // Returns the last (greatest) index of an element within the array equal to the specified value, or -1 if none is found.
arr.slice(begin, end) // Extracts a section of an array and returns a new array.
arr.toString() // Returns a string representing the array and its elements. Overrides the Object.prototype.toString() method.
arr.toLocaleString(locales, options) // Returns a localized string representing the array and its elements. Overrides the Object.prototype.toLocaleString() method.

// Instance: iteration methods
arr.entries() // Returns a new Array Iterator object that contains the key/value pairs for each index in the array.
arr.every(callback[, thisArg]) // Returns true if every element in this array satisfies the provided testing function.
arr.filter(callback[, thisArg]) // Creates a new array with all of the elements of this array for which the provided filtering function returns true.
arr.find(callback[, thisArg]) // Returns the found value in the array, if an element in the array satisfies the provided testing function or undefined if not found.
arr.findIndex(callback[, thisArg]) // Returns the found index in the array, if an element in the array satisfies the provided testing function or -1 if not found.
arr.forEach(callback[, thisArg]) // Calls a function for each element in the array.
arr.keys() // Returns a new Array Iterator that contains the keys for each index in the array.
arr.map(callback[, initialValue]) // Creates a new array with the results of calling a provided function on every element in this array.
arr.reduce(callback[, initialValue]) // Apply a function against an accumulator and each value of the array (from left-to-right) as to reduce it to a single value.
arr.reduceRight(callback[, initialValue]) // Apply a function against an accumulator and each value of the array (from right-to-left) as to reduce it to a single value.
arr.some(callback[, initialValue]) // Returns true if at least one element in this array satisfies the provided testing function.
arr.values() // Returns a new Array Iterator object that contains the values for each index in the array.

List of Assembly related tools

0

Assembler List

Name Desc
Flat Assembler (FASM) is a fast assembly language compiler for the x86 architecture processors, which does multiple passes to optimize the size of generated machine code
Microsoft Macro Assembler (MASM) is an x86 assembler that uses the Intel syntax for MS-DOS and Microsoft Windows
Netwide Assembler (NASM) is an assembler and disassembler for the Intel x86 architecture
YASM is an assembler and disassembler for the Intel x86 architecture. Yasm is a full rewrite of Netwide Assembler (NASM).
ILASM – IL Assembler ILAsm (IL Assembler) generates a portable executable (PE) file from Common Intermediate Language (CIL) code
PeachPy is an x86-64 assembler embedded in Python which targets high-performance computing audience. PeachPy can generate object files or assembly listings for Windows, Linux, Mac OS X, Native Client, and Go from the same source
FLASM Flasm is a free command line assembler/disassembler of Flash ActionScript bytecode. It lets you make changes to any SWF. Flasm fully supports SWFs produced by Macromedia Flash 8 and earlier.
XEDParse XEDParse is an open source (LGPLv3) library for assembling single x86(-x64) instructions from text to bytes. Useful to integrate in reverse engineering frameworks to quickly assemble instructions.
HLA High Level Assembly (HLA) is an assembly language developed by Randall Hyde. It allows the use of higher-level language constructs to aid both beginners and advanced assembly developers.

Disassembler & Debuggers

Name Desc
IDA PRO IDA is a Windows, Linux or Mac OS X hosted multi-processor disassembler and debugger that offers so many features it is hard to describe them all.
OllyDbg is an x86 debugger that emphasizes binary code analysis, which is useful when source code is not available. most popular!
x64_dbg An open-source x64/x32 debugger for windows.
Visual DuxDebugger Visual DuxDebugger is a 64-bit debugger disassembler for Windows executables, especially useful when source code is unavailable. The user interface is very intuitive so it makes very simple any task in reverse.
Immunity Debugger Immunity Debugger is a powerful new way to write exploits, analyze malware, and reverse engineer binary files. It builds on a solid user interface with function graphing, the industrys first heap analysis tool.
Hopper Hopper is a binary disassembler, decompiler and debugger for 32bits and 64bits executables. Hopper can disassemble Mac (Intel 32/64), iOS (ARM/Intel), PE (PE32/32+/64) and ELF (Intel 32/64 and ARM).
WinDbg WinDbg is a multipurposed debugger for Microsoft Windows, distributed on the web by Microsoft as part of the Debugging Tools for Windows.
Syser Syser Kernel Debugger is designed for Windows NT Family based on X86 platform. It is a kernel debugger with full-graphical interfaces and supports assembly debugging and source code debugging.
Radare2
ILDASM .NET Disassembler
dnSpy .NET debugger and assembly editor

IDE

Name Desc
Visual Studio 20XX Microsoft Visual Studio is an integrated development environment (IDE) from Microsoft.
RadASM RadASM — a free Integrated development environment for Microsoft Windows originally designed for writing programs in assembly language. It has a flexible system of configuration files, and can be used to develop software in high-level programming languages and to author documents based on a markup language. It was created by the programmer Ketil Olsen (KetilO).
EasyCode WinAsm Studio is a free Integrated Development Environment IDE for developing 32-bit Windows and 16-bit DOS programs using the Assembler.
WinAsm Studio Visual DuxDebugger is a 64-bit debugger disassembler for Windows executables, especially useful when source code is unavailable. The user interface is very intuitive so it makes very simple any task in reverse.
Visual MASM IDE for MASM written in Delphi. What? It is dev brain.
MASM Builder MASM Builder is a free Integrated Development Environment IDE for developing 32-bit Windows programs using the Assembler. MASM Builder contains many useful features which will assist you in creating Windows API based programs.
SASM SASM (SimpleASM) – simple Open Source crossplatform IDE for NASM, MASM, GAS, FASM assembly languages. SASM has syntax highlighting and debugger. The program works out of the box and is great for beginners to learn assembly language. SASM is translated into Russian and English. Licensed under the GNU GPL v3.0. Based on the Qt.

 

Originally found at awesome list

HTML cheatsheet

0

<!– * *******************************************************************************************
* HTML5 Cheat sheet by Hackr.io
* Source: https://websitesetup.org/wp-content/uploads/2014/02/HTML-CHEAT-SHEET-768×8555.png
* ******************************************************************************************* * –>

<!– Document Summary –>

<!DOCTYPE html> <!– Tells the browser that HTML5 version of HTML to be recognized by the browser –>
<html lang=”en”></html> <!– The HTML lang attribute is used to identify the language of text content on the web. This information helps search engines return language specific results, –>
<head></head> <!– Contains Information specific to the page like title, styles and scripts –>
<title></title> <!– Title for the page that shows up in the browser title bar –>
<body></body> <!– Content that the user will see –>

<!– Document Information –>

<base/> <!– Usefull for specifying relative links in a document –>
<style></style> <!– Contains styles for the html document –>
<meta/> <!– Contains additional information about the page, author, page description and other hidden page info –>
<script></script> <!– Contains all scripts internal or external –>
<link/> <!– Used to create relationships with external pages and stylesheets –>

<!– Document Structure –>

<h1></h1> … <h6></h6> <!– All six levels of heading with 1 being the most promiment and 6 being the least prominent –>
<p></p> <!– Used to organize paragraph text –>
<div></div> <!– A generic ontainerused to denote a page section –>
<span></span> <!– Inline section or block container used for creating inline style elements –>
<br/> <!– Creates a line-break –>
<hr> <!– Creates a sectional break into HTML –>

<!– Text Formatting –>

<strong></strong> and <b></b> <!– Makes text contained in the tag as bold –>
<em></em> and <i></i> <!– Alternative way to make the text contained in the tag as italic –>
<strike></strike> <!– creates a strike through the text element –>
<pre></pre> <!– Preformatted monospace text block with some spacing intact –>
<blockquote></blockquote> <!– Contains long paragraphs of quotations often cited –>
<abbr></abbr> <!– Contains abbreviations while also making the full form avaialable –>
<address></address> <!– Used to display contact information –>
<code></code> <!– Used to display inline code snippets –>

<!– Links Formatting –>

<a href=”url”></a> <!– Used to link to external or internal pages of a wbesite –>
<a href=”mailto:email@example.com”></a> <!– Used to link to an email address –>
<a href=”name”></a> <!– Used to link to a document element –>
<a href=”#name”></a> <!– Used to link to specific div element –>
<a href=”tel://####-####-##”></a> <!– Used to display phone numbers and make them as clickable –>

<!– Image Formatting –>

<img src=”url” alt=”text”> <!– Used to display images in a webpage wehre src=”url” contains the link to the image source and alt=”” contains an alternative text to display wehn the image is not displayed –>

<!– List Formatting –>

<ol></ol> <!– Used to create ordered lists with numbers in the items –>
<ul></ul> <!– Used to display unordered lists with numbers in the items –>
<li></li> <!– Contains list items inside ordered and unordered lists –>
<dl></dl> <!– Contains list item definitions –>
<dt></dt> <!– definition of single term inline with body content –>
<dd></dd> <!– The descrpition of the defined term –>

<!– Forms Formatting and Attributes –>

<form action=”url”></form> <!– Form element creates a form and action=”” specifies where the data is to be sent to when the visitor submits the form –>

<!– Supported attributes –>
method=”somefunction()” <!– Contains the type of request (GET, POST… etc) which dictates how to send the data of the form –>
enctype=”” <!– Dictates how the data is to be encoded when the data is sent to the web server. –>
autocomplete=”” <!– Specifies if the autocomplete functionality is enabled or not –>
novalidate <!– Dictates if the form will be validated or not –>
accept-charset=”” <!– Identifies the character encoding upon form submission –>
target=”” <!– Tell where to display the information upon form submission. POssible values: ‘_blank’, ‘_self’, ‘_parent’, ‘_top’ –>

<fieldset disabled=”disabled”></fieldset> <!– Identifies the group of all fields in the form –>
<label for=””></label> <!– A simple field label telling the user what to type in the field –>
<legend></legend> <!– The form legend acts as a caption for the fieldset element –>

<input type=”text/email/number/color/date”> <!– Input is the input field where the user can input various types of data –>

<!– Supported attributes –>
name=”” <!– Describes the name of the form –>
width=”” <!– Specifies the width of an input field –>
value=”” <!– Describes the value of the input information field –>
size=”” <!– Specifies the input element width in characters –>
maxlength=”” <!– Specifies the maximum input character numbers –>
required=”” <!– Specifies if the input field is required to fill in before submitting the form –>
step=”” <!– Identifies the legal number intervals of the input field –>

<textarea name=”” id=”” cols=”30″ rows=”10″> <!– Specifies a large input text field for longer messages –>
</textarea>

<select name=””></select> <!– Describes a dropdown box for users to select from variety of ochoices–>

<!– Supported attributes –>
name=”” <!– The name for a dropdown combination box –>
size=”” <!– Specifies the number of available options –>
multiple <!– Allows for multiple option selections –>
required <!– Requires that a value is selected before submitting the form –>
autofocus <!– Specifies that the dropdown automatically comes to focus once the page loads –>
<optgroup></optgroup> <!– Specifies the entire grouping of available options –>
<option value=””></option> <!– Defines one of the avaialble option from the dorpdown list–>
<button></button> <!– A clickable button to submit the form –>

<!– Tables Formatting –>

<table></table> <!– Defines and contains all table related content –>
<caption></caption> <!– A description of what table is and what it contains –>
<thead></thead> <!– The table headers contain the type of information defined in each column underneath –>
<tbody></tbody> <!– Contains the tables data or information –>
<tfoot></tfoot> <!– Defines table footer –>
<tr></tr> <!– Contains the information to be included in a table row –>
<th></th> <!– Contains the information to be included in a single table header –>
<td></td> <!– Contains actual information in a table cell –>
<colgroup></colgroup> <!– Groups a single or multiple columns for formatting purposes –>
<col> <!– Defines a single column of information inside a table –>

<!– Objects and iFrames –>

<object data=””></object> <!– Describes and embed file type including audio, video, PDf’s, images –>

<!– Supported attributes –>
type=”” <!– Describes the type of media embedded –>
height=”” <!– Describes the height of the object in pixels –>
width=”” <!– Describes the width of the object in pixels –>
usemap=”” <!– This is the name of the client-side image map in the object –>

<iframe src=”” frameborder=”0″></iframe> <!– Contains an inline frame that allows to embed external information –>
<embed src=”” type=””> <!– Acts as a container for external application or plug-in –>
scr=”” <!– The source of the external file you’re embedding –>
width=”” <!– Describes the width of the iframe in pixels –>

<!– HTML5 New Tags –>

<header></header> <!– Defines the header block for a document or a section –>
<footer></footer> <!– Defines the footer block for a document or a section –>
<main></main> <!– Describes the main content of a document–>
<article></article> <!– Identifies an article inside a document –>
<aside></aside> <!– Specifies content contained in a document sidebar –>
<section></section> <!– Defines a section of a document –>
<details></details> <!– Describes additonal information that user can view or hide –>
<dialog></dialog> <!– A dialog box or a window –>
<figure></figure> <!– An independent content block featuring images, diagrams or illustrations –>
<figcaption></figcaption> <!– Caption that describe a figure –>
<mark></mark> <!– Displays a portion of highlighted text with in a page content –>
<nav></nav> <!– Navigation links for the user in a document –>
<menuitem></menuitem> <!– The specific menu item that a usrr can raise from a pop up menu –>
<meter></meter> <!– Describes the scalar measurement with in a known array –>
<progress></progress> <!– Displays the progress of a task usually a progress bar –>
<rp></rp> <!– Describes text within the browsers that do not support ruby notations –>
<rt></rt> <!– Displays east asian typography character details –>
<ruby></ruby> <!– Describes annotations for east asian typography –>
<summary></summary> <!– Contains a visible heading for details element –>
<bdi></bdi> <!– Helps you format parts of text in a different direction than other text –>
<time></time> <!– Identifies the time and date –>
<wbr> <!– A line break within the content –>

<!– Collective CHaracter Obejcts –>

&#34; &quot; Quotation Marks – ”
&#38; &amp; Ampersand – &
&#60; &lt; Less than sign – <
&#62; &gt; Greater than sign – >
&#160; &nbsp; Non-breaking space
&#169; &copy; Copyright Symbol – ©
&#64; &Uuml; @ symbol – @
&#149; &ouml; Small bullet – .
&#153; &ucirc; Trademark Symbol – ™

PHP cheatsheet

0

<?php

// Exit the file, string inside get’s echo’ed
die(“This file is not ment to be ran. ¯\_(ツ)_/¯”);
exit(“This file is not ment to be ran. ¯\_(ツ)_/¯”);

/**
* Printing
*/
echo “”; // Print a string or type that can be made into a string(I.E int, float).
print_r($arr); // Print anything, with type hints for array’s and object’s
var_dump($arr); // Print anything, with type hints for any value and sizes

/**
* Ways of looping
*/
continue; // Skip current iter
break; // Exit loop

// Foreach
foreach($arr as $key => $value) {
$key = $key;
$value = $value;
}

// For
for($i = 0; $i < count($arr) – 1; $i++) {
$key = $i;
$value = $arr[$i];
}

// While
$i = 0;
while($i < count($arr) – 1) {
$key = $i;
$value = $arr[$i];
}

// Do while
$i = 0;
do {
$key = $i;
$value = $arr[$i];
} while($i < count($arr));

// Switch
switch($arr) {
case 1:
break;
case 2:
break;
case 3:
break;
default:
}

/**
* Global variables
* http://php.net/manual/en/language.variables.superglobals.php
*/
$_SERVER; // SERVER variables
$_GET; // Query params
$_POST; // Post fields
$_REQUEST; // GET and POST together
$GLOBALS; // Array of global variables
$_SESSION; // Browser session
$_FILES; // Array of files that are sent in request
$_COOKIE; // Array of cookies sent in request
$_ENV; // php.ini options
$argv; // Array of terminal arguments (filename included)
$argc; // Number of arguments passed into terminal

/**
* Class
* http://php.net/manual/en/language.oop5.basic.php
*/
class NormalClass extends AbstractClassName implements InterfaceName
{

use TraitName;

// –> PROPERTY TYPES <–

/**
* Public property, everyone can access this property.
* @var Type
*/
public $property;

/**
* Private property, only this instance can access this property.
* @var Type
*/
private $property;

/**
* Protected property, this instance and childs can access this property.
* @var Type
*/
protected $property;

/**
* Static property, is the same for all instances of this class.
* @var Type
*/
static $property;

// –> FUNCTION TYPES <–

/**
* Public function, everyone can access this function.
* @param Type
* @return Type
*/
public function publicFunction(Type $var = null): Type
{
}

/**
* Private function, only this instance can access this function.
* @param Type
* @return Type
*/
private function privateFunction(Type $var = null): Type
{
}

/**
* Protected function, this instance and childs can access this function.
* @param Type
* @return Type
*/
protected function protectedFunction(Type $var = null): Type
{
}

/**
* Static function, doesn’t need an instance to be executed.
* @param Type
* @return Type
*/
public static function staticFunction(Type $var = null): Type
{
}

// –> MAGIC METHODS <–

/**
* Gets triggered on creating a new class instance
* http://php.net/manual/en/language.oop5.decon.php
* @param Type
* @return void
*/
public function __construct(Type $var = null)
{
}

/**
* Gets triggered on destruction of a class instance
* http://php.net/manual/en/language.oop5.decon.php
* @return void
*/
public function __destruct()
{
}

/**
* __set() is run when writing data to inaccessible properties.
* http://php.net/manual/en/language.oop5.overloading.php
* @param string name
* @param mixed value
* @return void
*/
public function __set(string $name , mixed $value)
{
}

/**
* __get() is utilized for reading data from inaccessible properties.
* http://php.net/manual/en/language.oop5.overloading.php
* @param string name
* @return mixed
*/
public function __get(string $name)
{
}

/**
* __isset() is triggered by calling isset() or empty() on inaccessible properties.
* http://php.net/manual/en/language.oop5.overloading.php
* @param string name
* @return bool
*/
public function __isset(string $name)
{
}

/**
* __unset() is invoked when unset() is used on inaccessible properties.
* http://php.net/manual/en/language.oop5.overloading.php
* @param string name
* @return void
*/
public function __unset(string $name)
{
}

/**
* __call is triggered when invoking inaccessible methods in an object context.
* http://php.net/manual/en/language.oop5.overloading.php
* @param string name
* @param array arguments
* @return mixed
*/
public function __call(string $name, array $arguments)
{
}

/**
* __callStatic() is triggered when invoking inaccessible methods in a static context.
* http://php.net/manual/en/language.oop5.overloading.php
* @param string name
* @param array arguments
* @return mixed
*/
public static function __callStatic(string $name, array $arguments)
{
}

/**
* http://php.net/manual/en/language.oop5.magic.php
* @return array
*/
public function __sleep()
{
}

/**
* http://php.net/manual/en/language.oop5.magic.php
* @return void
*/
public function __wakeup()
{
}

/**
* http://php.net/manual/en/language.oop5.magic.php
* @return string
*/
public function __toString()
{
}

/**
* http://php.net/manual/en/language.oop5.magic.php
* @param Type
* @return mixed
*/
public function __invoke(Type $var = null)
{
}

/**
* http://php.net/manual/en/language.oop5.magic.php
* @param array properties
* @return object
*/
public static function __set_state(array $properties)
{
}

/**
* http://php.net/manual/en/language.oop5.magic.php
* @return array
*/
public function __debugInfo()
{
}

}

/**
* Every class that has implemented this interface need to have the same functions.
*/
interface InterfaceName
{

public function FunctionName(Type $var = null): Type;

}

/**
* Combination of class and interface.
*/
abstract class AbstractClassName
{

/**
* Classes extending this abstract class need to have this function.
* @param Type
* @return Type
*/
abstract function abstractFunction(Type $var = null): Type;