{"id":27218,"date":"2019-04-12T05:08:39","date_gmt":"2019-04-12T05:08:39","guid":{"rendered":"https:\/\/blog.jetbrains.com\/idea\/?p=19531"},"modified":"2019-04-12T05:08:39","modified_gmt":"2019-04-12T05:08:39","slug":"refactoring-extract-variable-in-intellij-idea","status":"publish","type":"idea","link":"https:\/\/blog.jetbrains.com\/pt-br\/idea\/2019\/04\/refactoring-extract-variable-in-intellij-idea","title":{"rendered":"Refactoring: Extract Variable in IntelliJ IDEA"},"content":{"rendered":"

As a code base ages, new code is added, and the existing code is modified to meet the business requirements. This can often have a negative impact on the design and structure of the code. Developers may fear\u00a0working with such code as it is difficult to understand, modify, or extend.<\/p>\n

As a developer, you can take redundancy and complexity out of your code, by refactoring it. Refactoring<\/a> is the process of improving your source code without creating any new functionality. It helps you keep your code SOLID<\/a>, DRY<\/a>, and easy to maintain. Even though clean code bases and code refactoring is crucial (code maintenance accounts for about 80% of a project\u2019s cost), it is often avoided or put off because it can<\/strong> break your existing code.<\/p>\n

In this blog post,\u00a0we will take a look at how IntelliJ IDEA can help you to refactor your code safely<\/strong> with Variable refactorings,\u00a0and talk about some of the\u00a0dos<\/strong> and don’ts <\/strong>we need to be aware of. Let’s get started.<\/p>\n

Extract Variable Refactoring<\/h1>\n

The Extract Variable refactoring lets you simplify an expression and remove its redundant parts.<\/p>\n

If an expression is hard to understand or it is duplicated in several places throughout your code, you can place the result of such expression (or a part of it) into a separate variable that is less complex and easier to understand.<\/p>\n

Introducing a variable for readability<\/h2>\n

Let’s introduce a variable to simplify the expression that assigns a value to the variable result<\/code>. Select the expression you want to extract into another variable, and press Ctrl+Alt+V (on Windows)\/ Cmd+Alt+V (on Mac). You can also choose to define the extracted variable as final<\/code>\u00a0or declared using type var<\/code>. IntelliJ IDEA gives a default name to the extracted variable, which you can then modify:<\/p>\n

\"\"<\/p>\n

Reducing duplicate sub-expressions<\/h2>\n

IntelliJ IDEA is quick to detect if the expression that you are extracting into another variable is duplicated in multiple places. If it is, then it offers to replace one<\/em> or all<\/em>\u00a0the occurrences of the selected expression. You can also change the default variable name suggested by IntelliJ IDEA.<\/p>\n

If you\u00a0are replacing multiple occurrences of an expression, IntelliJ IDEA can detect where and how you have used it. For example, if an expression is used both in the\u00a0then<\/em> and else<\/code> branches of an if<\/code> statement, IntelliJ IDEA extracts and defines it before it starts:<\/p>\n

\"\"<\/p>\n

Part of the expression that you extract into a variable could also<\/em> include a method call. Let’s have a look at how IntelliJ IDEA can help you replace one or all of these occurrences:<\/p>\n

\"\"<\/p>\n

Extract variable from field initializer<\/h2>\n

(New in IntelliJ IDEA 2019.1)<\/h3>\n

You can find complex expressions in various places, including a field initializer. When you try to simplify such an expression, IntelliJ IDEA will move the extracted variable to an instance initializer. If you think that that’s unexpected\u00a0\u2013 read on.<\/p>\n

If you decompile bytecodes of a class, you’ll realize that a field (or instance variable) is initialized in a class constructor. So even if you initialize a field with its declaration, the compiler would move its initialization code to the constructor. Also, all the code in the instance initializers is moved to class constructors, in the order\u00a0that they appear in the class. This explains why IntelliJ IDEA moves the extracted variable from a field initializer to an instance initializer, as demonstrated here:<\/p>\n

\"\"<\/p>\n

Similarly, if a static variable uses a complex expression in its initialization, IntelliJ IDEA can simplify the expression for you. Just select the part of the expression you want to extract in a new extract variable. With static variables, this code would be defined within a static initializer block:<\/p>\n

\"\"<\/p>\n

Simplifying expressions with ternary operator<\/h2>\n

(New in IntelliJ IDEA 2019.1)<\/h3>\n

Ternary operators offer a concise way to define a simple if<\/code>–else<\/code> statement. You can evaluate a boolean expression and return a value based on its result. However, a ternary operator can become complex, especially if it includes checks\u00a0\u2013 such as instanceof<\/code> for a variable.<\/p>\n

In such cases, IntelliJ IDEA can help you extract a variable and also replace the ternary operator with an if<\/code> statement:<\/p>\n

\"\"<\/p>\n

Here’s a similar example of a seemingly complex ternary operator that includes a null check. Again, IntelliJ IDEA can help you extract a variable and replace the ternary operator with an if<\/code>–else<\/code> statement:<\/p>\n

\"\"<\/p>\n

However, if the condition used in your ternary operator is not complex (with a null check or instanceof<\/code> operator), it doesn’t make sense to automatically convert it to an if<\/code>–else<\/code> statement. The essence of refactoring is to make your code simple to read and maintain. In cases like this, IntelliJ IDEA applies simple refactoring\u00a0\u2013 keeping your ternary operator, and extracting the selected expression into a variable:<\/p>\n

\"\"<\/p>\n

Automatic refactoring is not a magic bullet<\/h2>\n

To use variable refactorings in IntelliJ IDEA effectively, you must know when it works safely and when you need to exercise caution.<\/p>\n

For example, in the following code, extracting emp.title<\/code> into a variable and replacing all<\/strong> its occurrences could\u00a0output unexpected results. Calling emp.title<\/code> on line1 and line2, might<\/em> return different values:<\/p>\n

void test(Employee emp, Runnable runnable) {\r\n    if (emp != null) {\r\n        log("Starting " + emp.title);            \/\/ line 1\r\n    }\r\n    runnable.run();                              \r\n    if (emp != null) {\r\n        log("Finishing " + emp.title);           \/\/ line 2\r\n    }\r\n}<\/pre>\n
Similarly, when you extract an expression that includes a method call, IntelliJ IDEA lets you choose whether you want to replace just one occurrence or all of them. Be careful in such cases \u2013 such extraction may change your code behavior, irrespective of whether the method call that you extract into a variable is pure or not.<\/p>\n
Impure methods can output different results\u00a0when called with the same parameters. Even for pure functions, the mutable arguments you use to invoke your method might change between its invocations.<\/p>\n
Here’s an example of an impure method variableValue<\/code>, whose return value is dependent on when it is called (since it returns the ‘seconds’ value of the time it executes at):<\/p>\n
public class ExtractVarMethodCall {\r\n    public int calcResult(int total) {\r\n        int a = 100;\r\n        int b = a + getVariableValue();\r\n        int c = b + getVariableValue();\r\n        return c;\r\n    }\r\n\r\n    private int getVariableValue() {\r\n        return LocalTime.now().getSecond();\r\n    }\r\n}<\/pre>\n
You could refactor the preceding code, as follows:<\/p>\n
final var variableValue = getVariableValue();\r\nint b = a + variableValue;\r\nint c = b + variableValue;<\/pre>\n
In the preceding refactored code, the method variableValue<\/code> executes once and the same value is used twice\u00a0\u2013 which wasn’t the intent of the original code. So this code won’t execute as expected.<\/p>\n
Automated tests to the rescue<\/h2>\n
Before you get started with some serious refactoring of your code, please ensure you have an automated test suite set up to ensure all the functionality is still the same after the modifications. Here’s how<\/a> IntelliJ IDEA can quickly help you to get started with defining unit tests.<\/p>\n
Happy refactoring!<\/p>\n","protected":false},"author":921,"featured_media":0,"comment_status":"open","ping_status":"open","template":"","categories":[808,907,2347],"tags":[744,3335,195,3346],"cross-post-tag":[],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/pt-br\/wp-json\/wp\/v2\/idea\/27218"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/pt-br\/wp-json\/wp\/v2\/idea"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/pt-br\/wp-json\/wp\/v2\/types\/idea"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/pt-br\/wp-json\/wp\/v2\/users\/921"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/pt-br\/wp-json\/wp\/v2\/comments?post=27218"}],"version-history":[{"count":0,"href":"https:\/\/blog.jetbrains.com\/pt-br\/wp-json\/wp\/v2\/idea\/27218\/revisions"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/pt-br\/wp-json\/wp\/v2\/media?parent=27218"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/pt-br\/wp-json\/wp\/v2\/categories?post=27218"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/pt-br\/wp-json\/wp\/v2\/tags?post=27218"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/pt-br\/wp-json\/wp\/v2\/cross-post-tag?post=27218"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}