Variabili

• NioCodeV01

  • Description: Use the camelCase convention for variable naming or other format that compatible with framework.
  • Example: Used camelCase (myVariable), snakeCase (my_variable)
  • Tag: Variable Naming Convention

• NioCodeV02

  • Description: Variable name has to be clear and describe the contained type.
  • Example: userList, productTagList,
  • Tag: Variable Naming Convention

• NioCodeV03

  • Description: Declare type of variable.
  • Example: int count, String lastName,
  • Tag: Variable Type Convention

• NioCodeV04

  • Description: Define the accessibility level.
  • Example: private int count, public String lastName,
  • Tag: Variable Type Convention

• NioCodeV05

  • Description: Define always constant for type qualifier, if the variable has to be reassigned, define another constant variable.
  • Example: const String lastName = “lastname”
  • Tag: Variable Type Convention

• NioCodeV06

  • Description: Don't define Global variables and use local scope when possible to keep the code modular, reduce side effects, and improve readability.
  • Example:

  // Bad Example
  
  let status;
  
  if(user.isAuthenticated){
  	status = user.getUserStatus();
  } else {
  	status = UserStatus.NotAuthenticated;
  }
  
  // Good Example
  
  const status = user.isAuthenticated ? 
  									user.getUserStatus() :
  									UserStatus.NotAuthenticated;
  
  

  • Tag: Variable Scope Convention

Metodi

• NioCodeM01

  • Description: Use method names that are explanatory and clearly reflect their function.
  • Example: getUserData, setUserAddress
  • Tag: Naming Convention

• NioCodeM02

  • Description: In method signatures, clearly specify the name and type of each attribute.
  • Example: function calculateInterest(rate: float, principal: float, time: int)
  • Tag: Method Signature

• NioCodeM03

  • Description: Avoid large and complex methods or those with frequently repeated code blocks, preferring to split them into multiple methods.
  • Example:

  class SaleProcessor {
    constructor(price, taxRate, discount) {
      this.price = price;
      this.taxRate = taxRate;
      this.discount = discount;
    }
  
    // Calculate tax based on the price and tax rate
    calculateTax() {
      return this.price * this.taxRate / 100;
    }
  
    // Process discount based on the original price and discount rate
    processDiscount() {
      return this.price * this.discount / 100;
    }
  
    // Finalize sale by calculating the final price after tax and discount
    finalizeSale() {
      const taxAmount = this.calculateTax();
      const discountAmount = this.processDiscount();
      const finalPrice = this.price + taxAmount - discountAmount;
      console.log(`The final sale price is: ${finalPrice}`);
      return finalPrice;
    }
  }
  
  // Example usage
  const sale = new SaleProcessor(100, 10, 5); // price = 100, taxRate = 10%, discount = 5%
  sale.finalizeSale(); // Outputs: The final sale price is: 105
  

  • Tag: Method Decomposition

• NioCodeM04

  • Description: Avoid using complex or unnecessary queries within methods.
  • Example: Instead of a complex SQL query, use simpler queries or ORM methods like find() or select() for database operations.
  • Tag: Query Optimization

• NioCodeM05

  • Description: Limit the number of arguments per method to four and use formatting that includes the names of the arguments, for example: func(arg1: value1, arg2: value2).
  • Example: function sendEmail(to: String, subject: String, body: String, cc: String = None)
  • Tag: Argument Limitation

• NioCodeM06

  • Description: Design methods that are testable, with well-defined inputs and outputs with annotations.
  • Example: function calculateArea(length: float, width: float) -> float
  • Tag: Testable Methods

• NioCodeM07

  • Description: Avoid side effects in methods, preferring idempotent functions that do not modify the inputs, considering the use of transactions to preserve consistency.
  • Example:

  // A function to compute the total price of items without modifying the input list
  function computeTotal(items) {
    return items.reduce((total, item) => total + item.price, 0);
  }
  
  // Example usage
  const items = [
    { name: 'Apple', price: 1.2 },
    { name: 'Banana', price: 0.8 },
    { name: 'Orange', price: 1.5 },
  ];
  
  const total = computeTotal(items);
  console.log(`The total price is: ${total}`);
  

  • Tag: Side Effect Management

• NioCodeM08

  • Description: Anticipate and manage all possible inputs and errors that methods may encounter.
  • Example:

  function processInput(input) {
    try {
      // Validate input
      if (typeof input !== 'number') {
        throw new TypeError('Input must be a number');
      }
  
      // Process input (as an example, let's square the input)
      const result = input * input;
      console.log(`Processed result: ${result}`);
      return result;
    } catch (error) {
      console.error(`Error processing input: ${error.message}`);
      // Return a default value or rethrow the error, depending on your error handling strategy
      return null; // Example of returning a default value
    }
  }
  
  // Example usage
  processInput(10); // Should log: Processed result: 100
  processInput('a'); // Should log: Error processing input: Input must be a number
  
  

  • Tag: Error Handling

• NioCodeM09

  • Description: Use access specifiers like private, public, or protected to control the visibility of methods.
  • Example:

  public class AccountManager {
      // Public method - accessible from outside the class
      public void addAccount(String username, String password) {
          // Logic to add a new account
          logAccountCreation(username); // Internal use only
      }
  
      // Private method - restricted to access within the class itself
      private void logAccountCreation(String username) {
          System.out.println("Account created for: " + username);
      }
  }
  
  // Example usage
  public class Main {
      public static void main(String[] args) {
          AccountManager manager = new AccountManager();
          manager.addAccount("john_doe", "securepassword123");
          // manager.logAccountCreation("john_doe"); // This would result in a compile-time error
      }
  }
  
  

  • Tag: Access Control

• NioCodeM10

  • Description: When possible, make methods return a useful value for testing instead of void.
  • Example:

  public class Operation {
      // Method returns a boolean indicating the success of the operation
      public boolean performOperation(int a, int b) {
          try {
              // Simulate an operation (e.g., writing to a file, processing data)
              int result = a + b; // Example operation
              System.out.println("Operation performed successfully. Result: " + result);
              return true; // Indicate success
          } catch (Exception e) {
              System.err.println("Operation failed: " + e.getMessage());
              return false; // Indicate failure
          }
      }
  }
  
  // Example usage
  public class Main {
      public static void main(String[] args) {
          Operation operation = new Operation();
          boolean isSuccess = operation.performOperation(5, 3);
          if (isSuccess) {
              System.out.println("Operation was successful.");
          } else {
              System.out.println("Operation failed.");
          }
      }
  }
  
  

  • Tag: Return Value

Classi