Process Object in ElectronJS - GeeksforGeeks

24 Jul, 2020
ElectronJS is an Open Source Framework used for building Cross-Platform native desktop applications using web technologies such as HTML, CSS, and JavaScript which are capable of running on Windows, macOS, and Linux operating systems. It combines the Chromium engine and NodeJS into a Single Runtime.
As mentioned above, Electron combines the Chromium engine and NodeJS into a single runtime. Electron extends the features of NodeJS and provides access to several APIs which otherwise would not be accessible in a sandbox browser environment. One such crucial feature is the NodeJS process object. The NodeJS process object is a global object that provides an extensive set of information and defines the behavior of the NodeJS application. Since it is a global object, it can be accessed within any module of the NodeJS application. It provides us with an extensive set of Instance Properties, Methods, and Events that can be used.
For a detailed explanation on the Process object, refer to the article: Global, Process and buffer in Node.js. Electron also supports the global process object. It is an extension of the NodeJS process object and adds its own set of Instance Properties, Methods, and Events which are exclusive to Electron. In this tutorial, we will look at some features of the Electron’s process object.
We assume that you are familiar with the prerequisites as covered in the above-mentioned link. For Electron to work, node and npm need to be pre-installed in the system.
Project Structure:  
Example: Follow the Steps given in Drag and Drop Files in ElectronJS to set up the basic Electron Application. Copy the Boilerplate code for the main.js file and the index.html file as provided in the article. Also, perform the necessary changes mentioned for the package.json file to launch the Electron Application. We will continue building our application using the same code base. The basic steps required to set up the Electron application remain the same. 
package.json: 
{
  "name": "electron-properties",
  "version": "1.0.0",
  "description": "Process Object in Electron",
  "main": "main.js",
  "scripts": {
    "start": "electron ."
  },
  "keywords": [
    "electron"
  ],
  "author": "Radhesh Khanna",
  "license": "ISC",
  "dependencies": {
    "electron": "^8.3.0"
  }
}

Output: 
Process Object in Electron: A process object is a global object which can be accessed in the Main Process as well as in the Renderer Processes. As discussed above, the process object in the Electron provides its own set of features apart from the already pre-existing features of the NodeJS process object. In a Sandbox environment, the process object contains only a subset of the APIs.
Note: The process object in Electron can interact with the System APIs as well and hence has access to detailed System properties such as CPU Information, Memory Information, etc which can be leveraged in a Desktop Application.
index.html: Add the following snippet in that file. 
html
<h3>System Properties in Electron</h3>  <button id="print">    Print all System Properties in Console  </button>
index.js: The Print all System Properties in Console button does not have any functionality associated with it yet. To change this, add the following code in the index.js file.
javascript
const electron = require('electron')  // Instance Properties process.noDeprecation = false;process.throwDeprecation = false;process.traceDeprecation = true;process.traceProcessWarnings = true;  // Instance Event process.once('loaded', () => {    console.log('Pre-Initialization Complete');  });  function properties(label, value) {    this.label = label;    this.value = value;}  var props = {};  var print = document.getElementById('print');// Instance Properties, continued ...print.addEventListener('click', (event) => {    props.defaultApp = new properties('Default App', process.defaultApp);    props.mainFrame = new properties('Main Frame', process.isMainFrame);    props.resourcePath = new properties('Resource Path', process.resourcesPath);    props.sandbox = new properties('Sandbox Environment', process.sandboxed);    props.processType = new properties('Type of Process', process.type);    props.chrome = new properties('Chrome Version', process.versions.chrome);    props.electron = new properties('Electron Version', process.versions.electron);    props.windowsStore = new properties('Window Store', process.windowsStore);    props.CreationTime = new properties('Window Store', process.getCreationTime());      console.table(props);    // Instance Methods     console.log('-------------------');    console.log('Application Creation Time');    console.log(process.getCreationTime());    console.log('-------------------');    console.log('CPU Usage Information')    console.log(process.getCPUUsage());    console.log('-------------------');    console.log('IOCounters Information')    console.log(process.getIOCounters());    console.log('-------------------');    console.log('Heap Statistics Information')    console.log(process.getHeapStatistics());    console.log('-------------------');    console.log('Blink Memory Information')    console.log(process.getBlinkMemoryInfo());    console.log('-------------------');    console.log('System Memory Information')    console.log(process.getSystemMemoryInfo());    console.log('-------------------');    console.log('System Versions Information')    console.log(process.getSystemVersion());    console.log('-------------------');    console.log('Process Memory Information')    process.getProcessMemoryInfo().then(processMemoryInfo => {        console.log(processMemoryInfo);    }).catch(err => {        console.log(err);    })});
loaded: Event This Instance event is emitted when Electron has loaded its internal initialization script and libraries and is beginning to load the web page or the main script i.e. the main.js file. One important use-case of this Event is that it can be used by the preloaded script to add the Node global symbols which are removed, back to the global scope when node integration is turned off for the electron application such as when defining the BrowserWindow webPreferences property. 
process.defaultApp: This Instance property is a ReadOnly property. It returns a Boolean value. This property is set during application startup and is passed to the Main Process. If the default app, the value returned is true, else undefined.
process.isMainFrame: This Instance property is a ReadOnly property. It returns a Boolean value. It returns true when the current renderer context is the main renderer frame. Refer to the output below for a better understanding. If we want the ID of the current frame we should use the webFrame.routingId Instance property.
process.mas: This Instance property is a ReadOnly property. It returns a Boolean value. For Mac App Store build, this property is set as true. For other operating systems builds it is returned as undefined.
process.noAsar: This Instance property takes in a Boolean value. This property controls ASAR support inside your application. Setting this to true will disable the support for asar archives in NodeJS built-in modules. Asar is a simple extensive archive format, it works like .tar that concatenates all files together without compression, while having random access support. With this Property is enabled, Electron can read arbitrary files from it without unpacking the whole file. For a detailed Explanation and leveraging ASAR Support, refer https://www.npmjs.com/package/asar.
process.noDeprecation: This Instance property takes in a Boolean value. This property controls whether or not deprecation warnings are printed to stderr/console. Setting this to true will silence deprecation warnings. This property is used instead of the –no-deprecation command line flag. For a detailed Explanation on command line arguments and switches, Refer Command Line Arguments in ElectronJS
process.resourcesPath: This Instance property is a ReadOnly property. It returns a String value. It represents the path to the resources’ directory in Electron.
process.sandboxed: This Instance property is a ReadOnly property. It returns a Boolean value. This property returns true when the Renderer Process is a sandbox, otherwise returns undefined.
process.throwDeprecation: This Instance property takes in a Boolean value. This Instance Property controls whether or not deprecation warnings will be thrown as exceptions. Setting this to true will throw errors for deprecations and interrupt the execution of the application. This property is used instead of the –throw-deprecation command line flag. For a detailed Explanation on command line arguments and switches, Refer Command Line Arguments in ElectronJS
process.traceDeprecation: This Instance property takes in a Boolean value. This Instance property controls whether or not deprecation warnings are printed to stderr/console with their stack trace. Setting this to true will print stack traces. This property is used instead of the –trace-deprecation command line flag. For a detailed Explanation on command line arguments and switches, Refer Command Line Arguments in ElectronJS
process.traceProcessWarnings: This Instance property takes in a Boolean value. This Instance property controls whether or not process warnings are printed to stderr/console with their stack trace. Setting this to true will print stack traces. This property is used instead of the –trace-warnings command line flag. For a detailed Explanation on command line arguments and switches, Refer Command Line Arguments in ElectronJS Note – Setting this Instance Property to true will override the behavior of the process.traceDeprecation since it will print the stack traces of deprecations as well to stderr.
process.type: This Instance property is a ReadOnly property. It returns a String value representing the current process’s type. It can return the following values:browser: For the Main Process.renderer: For the Renderer Process.worker: For the Web Worker.
browser: For the Main Process.
renderer: For the Renderer Process.
worker: For the Web Worker.
process.versions.chrome: This Instance property is a ReadOnly property. It returns a String value representing the Chrome’s current version being used.
process.versions.electron: This Instance property is a ReadOnly property. It returns a String value representing the Electron’s current version being used.
process.windowsStore: This Instance property is a ReadOnly property. It returns a Boolean value. If the application is running as a Windows Store app (appx) build, this property is set as true. For other operating systems builds it is returned as undefined.
process.crash(): This Instance method causes the main thread of the current process to crash. This Instance method is extremely useful when testing the application for the production environment to determine how the application behaves in different operating systems in case it crashes. This method does not have a return type.
process.hang() This Instance method causes the main thread of the current process to hang. This Instance method is extremely useful when testing the application for the production environment to determine how the application behaves in different operating systems in case it crashes. This method does not have a return type.
process.getCreationTime(): This Instance method returns an integer value which represents the number of milliseconds since epoch. This indicates the creation time of the application. It returns null if it is unable to get the process creation time.
process.getCPUUsage(): This Instance method returns a CPUUsage object. This object consists of the following parameters. percentCPUUsage: Integer This parameter represents the percentage of CPU used since the last call to this Instance Method. First call always returns 0 and sets up the measurement task.idleWakeupsPerSecond: Integer This Parameter is not Supported in Windows and will always return 0. This parameter returns the number of average idle CPU wakeups per second since the last call to this Instance Method. First call always returns 0 and sets up the measurement task.
percentCPUUsage: Integer This parameter represents the percentage of CPU used since the last call to this Instance Method. First call always returns 0 and sets up the measurement task.
idleWakeupsPerSecond: Integer This Parameter is not Supported in Windows and will always return 0. This parameter returns the number of average idle CPU wakeups per second since the last call to this Instance Method. First call always returns 0 and sets up the measurement task.
process.getIOCounters(): This Instance Method is supported in Windows and Linux only. It returns an IOCounters object. This object consists of the following parameters.readOperationCount: Integer The number of read I/O operations.writeOperationCount: Integer The number of write I/O operations.otherOperationCount: Integer The number of I/O other operations.readTransferCount: Integer The number of I/O read transfers.writeTransferCount: Integer The number of I/O write transfers.otherTransferCount: Integer The number of I/O other transfers.
readOperationCount: Integer The number of read I/O operations.
writeOperationCount: Integer The number of write I/O operations.
otherOperationCount: Integer The number of I/O other operations.
readTransferCount: Integer The number of I/O read transfers.
writeTransferCount: Integer The number of I/O write transfers.
otherTransferCount: Integer The number of I/O other transfers.
process.getHeapStatistics(): This Instance method returns an object with V8 Heap Statistics, the same which are generated by the .snapshot file when uploaded to the Chrome Dev Tools. This Instance method is important in analyzing code statistics and Memory Leaks within the application. All statistics are reported in Kilobytes. For a detailed Explanation of the V8 Heap Snapshot, refer to the article: Create a V8 Heap Snapshot in ElectronJS. The object consists of the following parameters.totalHeapSize: IntegertotalHeapSizeExecutable: IntegertotalPhysicalSize: IntegertotalAvailableSize: IntegerheapSizeLimit: IntegerusedHeapSize: IntegermallocedMemory: IntegerpeakMallocedMemory: IntegerdoesZapGarbage: Boolean
totalHeapSize: Integer
totalHeapSizeExecutable: Integer
totalPhysicalSize: Integer
totalAvailableSize: Integer
heapSizeLimit: Integer
usedHeapSize: Integer
mallocedMemory: Integer
peakMallocedMemory: Integer
doesZapGarbage: Boolean
process.takeHeapSnapshot(filePath): This Instance Method takes a V8 Heap snapshot of the application and saves it to provided filePath String parameter. It behaves exactly in the same way as the webContents.takeHeapSnapshot(filepath) Instance method of the webContents Property of the BrowserWindow object. For a detailed Explanation and understanding of how V8 Heap Snapshot works in ElectronJS, Refer the article: Create a V8 Heap Snapshot in ElectronJS.
process.getBlinkMemoryInfo(): This Instance method returns an object with Blink Memory Information. It can be useful for debugging rendering, DOM related memory issues. All statistics are reported in Kilobytes. The object consists of the following parameters.allocated: Integer Size of all allocated objects.marked: Integer Size of all marked objects.total: Integer The Total allocated space.
allocated: Integer Size of all allocated objects.
marked: Integer Size of all marked objects.
total: Integer The Total allocated space.
process.getSystemVersion(): This Instance Method returns a String value representing the current version of the Host OS. Note: This Instance method returns the actual OS version instead of Kernel Version on macOS.
process.getSystemMemoryInfo(): This Instance Method returns an object giving general memory usage statistics about the entire system where the application is hosted. All statistics are reported in Kilobytes. This object consists of the following parameters.total: Integer The total amount of physical memory available to the system.free: Integer The total amount of memory not being used by applications or disk cache.swapTotal: Integer This Parameter is supported in Windows and Linux only. The total amount of Swap memory available to the system.swapFree: Integer This Parameter is supported in Windows and Linux only. The free amount of Swap memory available to the system.
total: Integer The total amount of physical memory available to the system.
free: Integer The total amount of memory not being used by applications or disk cache.
swapTotal: Integer This Parameter is supported in Windows and Linux only. The total amount of Swap memory available to the system.
swapFree: Integer This Parameter is supported in Windows and Linux only. The free amount of Swap memory available to the system.
process.setFdLimit(maxDescriptors): This Instance Method is supported in macOS and Linux only. It sets the file descriptor soft limit or the OS hard limit to the specified maxDescriptors Integer value, whichever is lower for the current process. This method does not have a return type.
Output: 
ElectronJS
JavaScript
Web Technologies
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Convert a string to an integer in JavaScript
Difference between var, let and const keywords in JavaScript
Differences between Functional Components and Class Components in React
How to append HTML code to a div using JavaScript ?
How to Open URL in New Tab using JavaScript ?
Roadmap to Become a Web Developer in 2022
Top 10 Projects For Beginners To Practice HTML and CSS Skills
Installation of Node.js on Linux
How to fetch data from an API in ReactJS ?
Convert a string to an integer in JavaScript