1. Using the delete Operator

The delete operator is the simplest method for deleting a property from a JavaScript object. Although this operator is simple and easy to use, developers should be aware of some of its limitations.

const employee= {
  name: 'John Doe',
  age: 33,
  job: 'Manager'
}

delete employee.age

console.log(employee) // Output: { name: 'John Doe', job: 'Manager' }

A JavaScript object’s given property can be deleted using the delete operator. The property can no longer be accessed within the original object after deletion. However, if a property is present in the prototype, it can still be accessed because the delete operator has no effect on the object’s prototype chain.

While the delete operator is easy to use, it has a few downsides:

• Performance Problems: In applications where performance is crucial, the delete operator may result in a decline in performance. JavaScript engines optimize objects for speed; nevertheless, de-optimization may occur if a property is removed.
• Mutating Objects: By eliminating the designated property, the delete operator modifies the original object. Unexpected side effects may result from this, particularly when working with shared objects in a global scope.

2. Setting the Property to undefined or null

Setting a property’s value to undefined or null is an additional method for eliminating properties from a JavaScript object. This shows that the property has no value but does not physically delete it from the object.

const employee= {
  name: 'John Doe',
  age: 33,
  job: 'Manager'
}

employee.age = undefined

console.log(employee) // Output: { name: 'John Doe',  age: undefined, job: 'Manager' }

Differences Between undefined and null

• Undefined: Indicates a property or variable that has not yet been given a value.
• null: Indicates that there is no object value present on purpose.

When you wish to communicate that a property has no value but yet need to preserve the original object’s structure, this method can be helpful. When a property is set to null or undefined, it indicates that the property is still present in the object. If other sections of your code require the property to be totally absent, this could cause confusion.

The post How to remove a property from an object in Javascript appeared first on Info Spot.

• Pass by value: The copied object is supplied to the method after the method parameter values have been transferred to another variable. The copy is used in the technique.

• Pass by reference: The method receives an alias or reference to the real parameter. The actual parameter is accessed by the method.

The idea of the object reference in Java is frequently the cause of the misunderstanding surrounding these concepts. Although a variable may contain a reference to an object, the object reference is actually a value that indicates the object’s position in memory, therefore technically, Java is always pass by value. As a result, object references are supplied by value.

Primitive and reference data types are both provided by value. Study up on Java’s data types. Because reference data types and basic data types are stored differently, it’s crucial to comprehend memory allocation in Java in addition to data types.

pass by value Example

The following example demonstrates how values are passed in Java.

public class Car{
	private String color;
	public Car() {}	
	public Car(String c) {
		this.color = c;
	}	
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
}

The following example program uses a generic method, swap(), that swaps two variables. Another method, changeValues(), attempts to change the variable values.

public class Test {
	public static void main(String[] args) {
		Car red = new Car("Red"); // memory reference = 50
		Car blue = new Car("Blue"); // memory reference = 100
		
		swap(red, blue);
		System.out.println("After the swap method executes:");
		System.out.println("`red` color value = " + red.getColor());
		System.out.println("`blue` color value = " + blue.getColor());
		
		changeValues(blue);
		System.out.println("After the changeValues method executes:");
		System.out.println("`blue` color value = " + blue.getColor());		
	}
	// Generic swap method
	public static void swap(Object o1, Object o2){
		Object temp = o1;
		o1 = o2;
		o2 = temp;
	}
	private static void changeValues(Car car) { // car= 100
		car.setColor("Red"); // car= 100
		car = new Car("Green"); // car = 200
		car.setColor("Blue"); // car = 200
	}
}

When you execute the example program, you get the following output:

OutputAfter the swap method executes:
'red' color value = Red
'blue' color value = Blue
After the changeValues method executes:
'blue' color value = Red

The result demonstrates that the color values of the original objects were not changed by the swap() method. Because the swap() function only works with copies of the original object reference values, it helps demonstrate that Java is pass by value. Any programming language can be used to determine whether a method is pass by reference or pass by value using the swap() method test.

swap() Method Explained

When you use the new operator to create an instance of a class, the object is created and the variable contains the location in memory where the object is saved.

Car red = new Car("Red");
Car blue = new Car("Blue");

Here’s a step-by-step breakdown of what happens when the swap() method executes:

• Suppose that both car objects’ memory addresses are 50 and 100, respectively, and that red and blue are pointing to these locations.
• Two new object variables, o1 and o2, are produced when the class invokes the swap() function with the red and blue variables as parameters.Additionally, memory locations 50 and 100 are indicated by o1 and o2, respectively.
• The snippet of code that follows describes what occurs in the swap() method:swap(Object o1, Object o2) and public static void // o2 = 100, o1 = 50 Assign the object reference value of o1 to temp by using the formula temp = 50, o1 = 50, o2 = 100. temp = 50, o1 = 100, o2 = 100 o1 = o2; // assign the object reference value of o2 to o1: o2 = temp; // assign the object

Java is pass by reference, so it’s a common misconception to think that you’re passing the reference because the variables hold the reference to the objects. It is pass-by value, though, because you are providing a value that is a copy of the reference.

changeValues() Method Explained

The next method in the example program changes the color value of the object referenced by the blue variable:

private static void changeValues(Car car) { // car = 100
	car.setColor("Red"); // car = 100
	car = new Car("Green"); // car = 200
	car.setColor("Blue"); // car = 200
}

Here’s a step-by-step breakdown of what happens within the changeValues() method:

• The blue variable that points to memory address 100 is called by the class using the changeValues() method. A reference that also points to memory address 100 is created in the first line. The item at memory address 100 now has the color value “Red” instead.
• The new object (with color value “Green”) is created in the second line. Memory location 200 is where the new object is located. The object at memory address 200 is affected by any additional operations performed on the car variable, while the object at memory location 100 is unaffected. The reference made in line 1 is overwritten by the new car variable, and this method no longer makes the car reference available.
• The old object that blue references at memory address 100 remains unaltered, but the third line adds “Blue” as the color value of the new car object at memory location 200. This explains why the example program output’s last line, which represents the change from line 1, prints blue color value = Red.

The post Is Java “pass-by-reference” or “pass-by-value”? appeared first on Info Spot.

Because it makes it easy to construct and manage containerized apps, Docker has become a vital tool for many developers in recent years. One of Docker’s biggest benefits is its capacity to control data volumes, which lets you store data that lasts longer than a container. Docker’s volume control can occasionally be difficult, despite its many advantages. Specifically, creating backups and recovering volumes can be difficult and prone to mistakes. We’ll look at why you might need to backup your volumes in this post, as well as how to do it properly. There are many compelling reasons to do so. Here are a few reasons why you might need to take backups of your Docker volumes:

Disaster Recovery

The most evident justification for backing up your Docker volumes is to guard against data loss in the case of an emergency. You can make sure that your important data is secure and recoverable in an emergency by regularly backing up your volumes.

Testing and Development

Making backups of your Docker volumes is also necessary for testing and development. You may quickly revert to a previous state in case of issues or the need to test new features by making backups of your volumes at various points during the development process.

Replication

Replicating data across different environments might also benefit from backing up your Docker volumes. You may guarantee that your data is consistent throughout all of your development, staging, and production environments by making backups of your volumes and restoring them in different settings.

Detailed steps

After discussing the issues and justifications for backups and volume restoration in Docker, let’s see how to accomplish it properly. The following procedures should be followed in order to create backups of your volumes:

Step 1: Identify the Volume

Selecting the volume you wish to backup is the first step in creating a copy of that volume. This can be accomplished by executing the subsequent command:

docker volume ls

This will show you a list of all the volumes that are currently available on your Docker host. Note down the name of the volume that you want to back up.

Step 2: Create a Backup

To create a backup of the volume, you can use the docker run command to start a container that mounts the volume you want to back up and a separate container that writes the backup data to a file.

Here’s an example of how to do this:

docker run --rm \
--mount source=<volume-name>,target=<target> \
-v $(pwd):/backup \
busybox \
tar -czvf /backup/<backup-filename>.tar.gz <target>

In this command, replace <volume-name> with the name of the volume you want to back up, <target> with the mount point inside the docker container, and <backup-filename> with a name for the backup file.

Step 3: Move the Backup File to an External Server

To make sure your backup file is safe and secure, it’s a good idea to relocate it to an external server or storage device after creating it. In the event of a calamity, such as a server failure or security breach, the backup file can be better protected by being stored on a different server or storage device. SCP can be used to transfer the backup file to an external server.

Using SSH, you can move files between servers using Secure Copy (SCP), a secure file transfer protocol. You must have SSH access to the source and destination servers in order to utilize SCP. The backup file can be copied to the external server using the following command:

scp /path/to/backupfile user@external-server:/path/to/destination

Step 4: Restore the Volume

If you need to restore the volume from the backup, you can use the docker run command to start a container that mounts the backup file and a separate container that writes the backup data to the volume.

Here’s an example of how to do this:

docker run --rm \
--mount source=<volume-name>,target=<target> \
-v $(pwd):/backup \
busybox \
tar -xzvf /backup/<backup-filename>.tar.gz -C /

In this command, replace <volume-name> with the name of the volume you want to back up, <target> with the mount point inside the docker container, and <backup-filename> with a name for the backup file.

The post Backup and Restore of Docker Volumes appeared first on Info Spot.

The images of those applications automatically reroute both stdout and stderr to the application’s CloudWatch Logs LogStream within the CloudWatch Logs LogGroup for the current environment using the open-source CloudCaptain CloudWatch Logs agent.

Providing a brand-new open-source appender for both Logback and Log4J, is one step further today for JVM apps. By natively integrating with the chosen logging framework and having the choice on how to route the logs, this provides a far more fine-grained control.

Installation

Simply include the dependency in your build file to incorporate the CloudCaptain Java log appender for AWS CloudWatch Logs into your application.

Maven

Start by adding the CloudCaptain Maven repository to your list of repositories in your pom.xml:

<repositories>
    <repository>
        <id>central</id>
        <url>https://repo1.maven.org/maven2/</url>
    </repository>
    <repository>
        <id>boxfuse-repo</id>
        <url>https://files.cloudcaptain.sh</url>
    </repository>
</repositories>

Then add the dependency:

<dependency>
    <groupId>com.boxfuse.cloudwatchlogs</groupId>
    <artifactId>cloudwatchlogs-java-appender</artifactId>
    <version>1.0.2.17</version>
</dependency>

Gradle

Start by adding the CloudCaptain Maven repository to your list of repositories in your build.gradle:

repositories {
    mavenCentral()
    maven {
        url "https://files.cloudcaptain.sh"
    }
}

Then add the dependency:

dependencies {
    compile 'com.boxfuse.cloudwatchlogs:cloudwatchlogs-java-appender:1.0.2.17'
}

Usage

To use the appender you must add it to the configuration of your logging system.

Logback

Add the appender to your logback.xml file at the root of your classpath. In a Maven or Gradle project you can find it under src/main/resources:

<configuration>
    <appender name="CloudCaptain-CloudwatchLogs" class="com.boxfuse.cloudwatchlogs.logback.CloudwatchLogsLogbackAppender"/>

    <root level="debug">
        <appender-ref ref="CloudCaptain-CloudwatchLogs" />
    </root>
</configuration>

Log4J2

Add the appender to your log4j2.xml file at the root of your classpath. In a Maven or Gradle project you can find it under src/main/resources:

<?xml version="1.0" encoding="UTF-8"?>
    <Configuration packages="com.boxfuse.cloudwatchlogs.log4j2">
    <Appenders>
        <CloudCaptain-CloudwatchLogs/>
    </Appenders>
    <Loggers>
        <Root level="debug">
            <AppenderRef ref="CloudCaptain-CloudwatchLogs"/>
        </Root>
    </Loggers>
</Configuration>

Code

And that’s all the setup you need! With SLF4J or your preferred api, you can now begin using it from code as you typically would.

Logging a message like this:

private static final Logger LOGGER = LoggerFactory.getLogger(MyClazz.class);
...
LOGGER.info("This is a log message ...");

will now be automatically sent as a structured JSON document to CloudWatch Logs. Important metadata is also automatically added to the document by the CloudCaptain CloudWatch Logs appender, making it appear as follows:

{
    "image": "myuser/myapp:123",
    "instance": "i-607b5ddc",
    "level": "INFO",
    "logger": "org.mycompany.myapp.MyClazz",
    "message": "This is a log message ...",
    "thread": "main"
}

This is very useful as this will allow us to query and filter the logs later.

Keep in mind that these are only the automatically sent properties. you can also utilize the MDC to fill in a lot of additional ones (such current user, session id, request id, etc.).

Displaying the Logs

To display the logs simply open a new terminal and show the logs for your app in your desired environment:

> boxfuse logs myapp -env=prod

Live tailing

And if you want to follow along in real time you can use log tailing:

> boxfuse logs myapp -env=prod -logs.tail

And new logs will now automatically be displayed as soon as they are sent from the application to CloudWatch Logs.

Log filtering

But this can yield a lot of results. CloudCaptain also offers robust log filtering to help discover the needle in the haystack, both on old logs and when a log stream is being tailed live.

The structured logs’ properties can be used to precisely filter them as you see fit. For instance, you can only display the logs for a particular instance and tail the logs live on the production environment on AWS by doing the following:

> boxfuse logs myapp -env=prod -logs.tail -logs.filter.instance=i-607b5ddc

And if you aren’t quite sure what you are looking for you can also simply filter by time. For example to show all the logs created in the last minute (60 seconds) you could do:

> boxfuse logs myapp -env=prod -logs.tail -logs.filter.start=-60

source: https://cloudcaptain.sh/blog/logback-log4j2-appender

The post Store app logs in AWS Cloudwatch using Log4J (or Logback) appender appeared first on Info Spot.

Using git stash is the most straightforward and secure method for accomplishing this. This command will restore a repository to the state of its most recent commit and save any modifications made to its working directory since then. To retrieve remote changes, you can then use the git pull command. In order to reapply the uncommitted changes on top of the new commits, run git stash pop.

The post Git: Force `git pull` to overwrite local files appeared first on Info Spot.

Removing the Last Element of an Array

The pop() method removes and returns the last element of an array.

const myArray = [1, 2, 3, 4, 5];

const x = myArray.pop();

console.log(`The values of myArray are: ${myArray}`);
console.log(`The element x value is: ${x}`);

Output:

The values of myArray are: 1,2,3,4
The element x value is: 5

Removing the First Element of an Array

The shift() method removes and returns the first element of an array.

const myArray = [1, 2, 3, 4, 5];

const x = myArray.shift();

console.log(`The values of myArray are: ${myArray}`);
console.log(`The element x value is: ${x}`);

Output:

The values of myArray are: 2,3,4,5
The element x value is: 1

Removing an Element by Index

If you are identifying the item to be removed by its index, you can use the delete operator. If you want to use the value of the item you are removing, use the splice() method.

The delete Operator

The value at that position of the array will be undefined since the delete operator removes the object property at the designated index without changing the array’s length.

const myArray = [1, 2, 3, 4, 5];

delete myArray[1];

console.log(`The values of myArray are: ${myArray}`);

Output:

The values of myArray are: 1,,3,4,5

The splice() Method

The index of the element you want to remove and the index you want to remove up to are the two arguments that the splice() function requires. All of the values that were deleted from the original array are stored in a new array created by the splice() method. The length of the original array will be adjusted, and the values that were eliminated will no longer be present.

const myArray = [1, 2, 3, 4, 5];

const x = myArray.splice(1, 1);

console.log(`The values of myArray are: ${myArray}`);
console.log(`The element x value is: ${x}`);

Output:

The values of myArray are: 1,3,4,5
variable x value: 2

Removing an Element by Value

Once the index has been identified using the indexOf() method, you can delete the element from its index if you are identifying the element to be removed by its value. Use the filter() technique or a combination of the indexOf() and splice() methods if you wish to use the value of the element you are deleting.

Combining indexOf() and splice() Methods

The indexOf() method returns the index of the element in the array that corresponds to the value you pass in for the element you want to delete from your array. The element at the returned index is then removed using the splice() technique.

const myArray = [1, 2, 3, 4, 5];

const index = myArray.indexOf(2);

const x = myArray.splice(index, 1);

console.log(`The values of myArray are: ${myArray}`);
console.log(`The element x value is: ${x}`);

Output:

The values of myArray are: 1,3,4,5
The element x value is: 2

The post JavaScript: How Can I Remove a Specific Item from an Array? appeared first on Info Spot.

You must indicate the commit you want to reset to when you call git reset. You can use the tilde (~) suffix to identify an ancestor of HEAD, the current commit, or you can use the git log to obtain the hash of the desired commit. The most recent commit can be undone and redone using the commands below:

git add .
git commit -m "This commit is a mistake"
git reset HEAD~
git add main.py # need to re-add files after reset
git commit -m "This commit corrects the mistake"

To undo the last two commits, use the commands:

git add .
git commit -m "This commit is a mistake"
# make changes
git add .
git commit -m "This commit is another mistake"
git reset HEAD~2
git add .
git commit -m "this commit corrects both mistakes"

If you don’t want to have to re-stage your files after a reset, you can use the --soft flag:

git add .
git commit -m "This commit is a mistake"
git reset --soft HEAD~
# no need to git add, as files are already staged
git commit -m "This commit corrects the mistake"

The --hard flag can be used to restore the working tree and Git history to the state of a prior commit. Keep in mind that doing this would undo all tracked file modifications, even those that haven’t been committed yet.

git add .
git commit -m ""
git reset --hard HEAD~

Use of git reset --hard should be done carefully. Nevertheless, up to 90 days after they were erased, you can still use git reflog to recover any deleted changes. Git reflog will display a list of prior commits on the tips of branches when it is executed. You can select the partial hash of the commit (such as 5c8f5a7) from this list in order to restore it and make a new branch for it:

git checkout -b restored-commit-branch 5c8f5a7

Git revert can be used to produce new commits that do the opposite of current commits, i.e., removing lines and files that were added and adding lines and files that were removed, if you want to keep your repository’s history intact but restore the contents to a former state:

git add .
git commit -m "This commit is a mistake"
git revert HEAD # will create a new commit doing the opposite of the one above

The post Git: Undo the most recent local Git commits appeared first on Info Spot.

To revert the most recently created commit, you can specify its hash or use HEAD:

git add .
git commit -m "This commit is a mistake"
git revert HEAD # will create a new commit doing the opposite of the one above

You can choose a range, from oldest to newest, to undo several recent changes. For every commit that is retracted, a new commit will be made.

git revert HEAD~2...HEAD # revert the last two commits

Restoring a prior state while keeping the repository’s edit history is possible with git revert. But sometimes you might want to remove past commitments instead of undoing them. Git reset --hard, with the commit to return to specified, can be used to accomplish this:

git reset --hard HEAD~

This will return the repository’s files to their previous state and remove the most recent commit from the current branch’s history.

The post Git: Revert a Git repository to a previous commit appeared first on Info Spot.

Using window.location.href

The window location href property is used to set or return the full URL of the current page. The Location href property can also be used to set the href value redirect to another link. The Location href property returns a string that contains the entire URL of the page, including the protocol (http, https, etc). 

Syntax

window.location.href = "URL"

Using location.replace() Method

The location replace() method is used to replace the current document with the specified one. This method is different from the assign() method as this removes the current document from the document history, therefore it is not possible to go back to the previous document using the ‘back’ button. 

Syntax

location.replace("URL");

How to redirect browser window back using JavaScript ?

There are two approaches used to redirect the browser window back:

• Using history.back() Method
• Using history.go() Method

The post How to Redirect to Another Webpage using JavaScript? appeared first on Info Spot.

Before executing code, Python interpreter reads source file and define few special variables/global variables. 
If the python interpreter is running that module (the source file) as the main program, it sets the special __name__ variable to have a value “__main__”. If this file is being imported from another module, __name__ will be set to the module’s name. Module’s name is available as value to __name__ global variable. 

What is a module

A module is a file containing Python definitions and statements. The file name is the module name with the extension .py. 

This is how we execute a file as command to the python interpreter,  

python script.py

print ("Always executed")

if __name__ == "__main__": 
	print ("Executed when invoked directly")
else: 
	print ("Executed when imported")

• All of the code that is at indentation level 0 [Block 1] gets executed. Functions and classes are defined but their code is not executed.
• Here, as we executed script.py directly __name__ variable will be __main__. So, code in this if block[Block 2] will only run if that module is the entry point to your program. 
• Thus, you can test whether your script is being run directly or being imported by something else by testing __name__ variable.
• If script is getting imported by some other module at that time __name__ will be module name.

Why and How to use it?

For example we are developing script which is designed to be used as module. Now if we want to use that module by importing we have to comment out our call. Rather than that approach, it is better to use below code: 

if __name__ == "__main__":
    my_function()
 
import myscript
 
myscript.my_function()

Benefits: 

1. Python files can act as either reusable modules, or as standalone programs.
2. if __name__ == “__main__”: is used to execute some code only if the file was run directly, and not imported.
3. If you import this script as a module in another script, the __name__ is set to the name of the script/module.

The post Python: What Does if __name__ == “__main__” Do ? appeared first on Info Spot.