@burakboduroglu/penote 3.0.1

package/Java-Notes/spring_boot_framework.md

@@ -0,0 +1,227 @@
+## 🌱 Spring Annotations
+
+#### @Repository :
+
+- Class Level Annotation
+- It can reach the database and do all the operations.
+- It make the connection between the database and the business logic.
+- DAO is a repository.
+- It is a marker interface.
+
+```java
+@Repository
+public class TestRepo{
+   public void add(){
+      System.out.println("Added");
+   }
+}
+```
+
+#### @Service :
+
+- Class Level Annotation
+- It is a marker interface.
+- It is a business logic.
+- It is a service layer.
+- It used to create a service layer.
+
+```java
+@Service
+public class TestService{
+   public void service1(){
+      //business code (iş kodları)
+   }
+}
+```
+
+---
+
+#### @Autowired :
+
+- Field Level Annotation
+- It is used to inject the dependency.
+- It is used to inject the object.
+- It is used to inject the object reference.
+- Dependency Injection is a design pattern.
+
+```java
+public class Brand{
+   private int id;
+   private String name;
+
+   @Autowired
+   public Brand(int id, String name){
+     this.id = id;
+     this.name = name;
+   }
+}
+```
+
+---
+
+#### @Controller :
+
+- Class Level Annotation
+- It is a marker interface.
+- It is a controller layer.
+- It is used to create a controller layer.
+- It use with @RequestMapping annotation.
+
+```java
+@Controller
+@RequestMapping("/api/brands")
+public class BrandsController{
+   @GetMapping("/getall")
+   public Employee getAll(){
+       return brandService.getAll();
+   }
+}
+```
+
+---
+
+#### @RequestMapping :
+
+- Method Level Annotation
+- It is used to map the HTTP request with specific method.
+
+```java
+@Controller
+@RequestMapping("/api/brands")
+public class BrandsController{
+   @GetMapping("/getall")
+   public Employee getAll(){
+       return brandService.getAll();
+   }
+}
+```
+
+---
+
+#### @GetMapping :
+
+- Method Level Annotation
+- It is used to map the HTTP GET request with specific method.
+- It is used to get the data.
+- It is used to read the data.
+  ```java
+  @GetMapping("/getall")
+  public Employee getAll(){
+      return brandService.getAll();
+  }
+  ```
+
+---
+
+#### @PostMapping :
+
+- Method Level Annotation
+- It is used to map the HTTP POST request with specific method.
+- It is used to add the data.
+- It is used to create the data.
+  ```java
+  @PostMapping("/add")
+  public void add(@RequestBody Brand brand){
+      brandService.add(brand);
+  }
+  ```
+
+---
+
+#### @PutMapping :
+
+- Method Level Annotation
+- It is used to map the HTTP PUT request with specific method.
+- It is used to update the data.
+  ```java
+  @PutMapping("/update")
+  public void update(@RequestBody Brand brand){
+      brandService.update(brand);
+  }
+  ```
+
+---
+
+#### @DeleteMapping :
+
+- Method Level Annotation
+- It is used to map the HTTP DELETE request with specific method.
+- It is used to delete the data.
+  ```java
+  @DeleteMapping("/delete")
+  public void delete(@RequestBody Brand brand){
+      brandService.delete(brand);
+  }
+  ```
+
+---
+
+#### @PathVariable :
+
+- Method Level Annotation
+- It is used to get the data from the URL.
+- It is the most suitable for RESTful web service that contains a path variable.
+  ```java
+  @GetMapping("/getbyid/{id}")
+  public Brand getById(@PathVariable int id){
+      return brandService.getById(id);
+  }
+  ```
+
+---
+
+#### @RequestBody:
+
+- It is used to get the data from the request body.
+- It is used to get the data from the HTTP request.
+- It is used to get the data from the HTTP request body.
+
+  ```java
+  @PostMapping("/add")
+  public void add(@RequestBody Brand brand){
+      brandService.add(brand);
+  }
+  ```
+
+---
+
+#### @RequestParam:
+
+- It is used to get the data from the URL.
+- It is used to get the data from the URL query parameters.
+- It is also known as query parameter.
+
+```java
+@GetMapping("/getbyid")
+public Brand getById(@RequestParam int id){
+    return brandService.getById(id);
+}
+```
+
+---
+
+#### @RestController:
+
+- Class Level Annotation
+- It is a marker interface.
+- It is a controller layer.
+- It is used to create a controller layer.
+- It use with @RequestMapping annotation.
+- It is a combination of @Controller and @ResponseBody annotations.
+- @RestController annotation is explained with @ResponseBody annotation.
+- @ResponseBody eliminates the need to add a comment to every method.
+
+```java
+@RestController
+@RequestMapping("/api/brands")
+public class BrandsController{
+   @GetMapping("/getall")
+   public Employee getAll(){
+       return brandService.getAll();
+   }
+}
+```
+
+---
+
+* ✅ Beğendiyseniz depoya yıldız verebilirsiniz. Okuduğunuz için teşekkürler.

package/Javascript-Notes/async_js.md

@@ -0,0 +1,82 @@
+## `Fetch API:`
+- The Fetch API is a JavaScript interface that allows for making network requests in a modern and flexible way.
+
+```javascript
+fetch("https://jsonplaceholder.typicode.com/users")
+    .then(resp => resp.json())
+    .then(console.log)
+```
+- This code block uses the Fetch API to make a GET request to the URL "https://jsonplaceholder.typicode.com/users", which returns a JSON response containing an array of user data.
+- The `then()` method is used twice to handle the response: the first `then()` method converts the response to a JSON object, and the second `then()` method logs the JSON object to the console.
+
+## `Promise:`
+- A promise is a JavaScript object that represents an eventual result of an asynchronous operation.
+```javascript
+const promise = new Promise((resolve, reject) => {
+    if(true){
+        resolve("RESOLVE WORKED!!!")
+    } else {
+        reject("REJECT WORKED!!!")
+    }
+})
+promise.then(result => console.log(result))
+```
+- This code block creates a new Promise object that takes a function as an argument with resolve and reject functions as parameters.
+- The if statement checks whether a condition is true or false, and if true, the resolve function is called with a message.
+- The then() method is used to handle the resolved value of the promise and logs it to the console.
+
+## `ASYNC Function:`
+- An async function in JavaScript allows you to write asynchronous code that looks like synchronous code, making it easier to read and understand.
+```javascript
+async function fetchUsers(){
+    const resp = await fetch(urls[0]);
+    const data = await resp.json();
+    console.log(data);
+}
+fetchUsers();
+```
+- This code block declares an `async` function `fetchUsers()` which makes an asynchronous network request using the Fetch API to the URL stored in the `urls` array. The `await` keyword is used to wait for the response from the request and then for the response body to be converted to a JSON object. 
+- Finally, the JSON object is logged to the console using `console.log()`. The `fetchUsers()` function is then called to execute this asynchronous operation.
+
+## `More Example About This Topic:`
+### `Example-1:`
+```javascript
+const urls = [
+    "https://jsonplaceholder.typicode.com/users",  //users
+    "https://jsonplaceholder.typicode.com/albums", //albums
+    "https://jsonplaceholder.typicode.com/photos"  //photos
+]
+
+// With Promise
+Promise.all(urls.map(url =>
+    fetch(url).then(resp => resp.json())
+)).then(arr => {
+    console.log("Users: ", arr[0]);
+    console.log("Albums: ", arr[1]);
+    console.log("Photos: ", arr[2]);
+}).catch("Errorrrrr!!!!");
+
+```
+
+### `Example-2:`
+```javascript
+const urls = [
+    "https://jsonplaceholder.typicode.com/users",  //users
+    "https://jsonplaceholder.typicode.com/albums", //albums
+    "https://jsonplaceholder.typicode.com/photos"  //photos
+]
+
+// With ASYNC-AWAIT
+try {
+    const getData = async function() {
+        const [users, albums, photos] = await Promise.all(urls.map(url => fetch(url).then(resp => resp.json())))
+        console.log("Users: ", users);
+        console.log("Albums: ", albums);
+        console.log("Photos: ", photos);
+    }
+    getData();
+} catch (err) {
+    console.log("Errorrrr!!!");
+    console.log(err);
+}
+```

package/Javascript-Notes/closures_currying_compose.md

@@ -0,0 +1,63 @@
+### Javascript Closure, Currying and Compose
+
+## `Closure:`
+- A closure is a function having access to the parent scope, even after the parent function has closed.
+- Example:
+```javascript
+function outer() {
+  let a = 10;
+  function inner() {
+    console.log(a);
+  }
+  return inner;
+}
+const innerFn = outer();
+innerFn(); // 10
+```
+- In the above example, the inner function has access to the variable a, even after the outer function has returned. This is because of closure.
+
+## `Currying:`
+- Currying is a technique of evaluating function with multiple arguments, into sequence of functions with single argument.
+- Example:
+```javascript
+function curriedAdd(a) {
+  return function(b) {
+    return a + b;
+  }
+}
+const add5 = curriedAdd(5);
+add5(10); // 15
+```
+- In the above example, the curriedAdd function returns a function which takes a single argument and returns the sum of the argument passed to the curriedAdd function and the argument passed to the returned function.
+- Example with 'Arrow Function':
+```javascript
+const curriedAdd = a => b => a + b;
+const add5 = curriedAdd(5);
+add5(10); // 15
+```
+
+## `Compose:`
+- Compose is a technique of combining two or more functions to produce a new function.
+- Example:
+```javascript
+function compose(f, g) {
+  return function(a) {
+    return f(g(a));
+  }
+}
+const sum = num => num + 1;
+const multiply = num => num * 2;
+const multiplyAndSum = compose(sum, multiply);
+multiplyAndSum(5); // 11
+```
+- In the above example, the compose function takes two functions as arguments and returns a new function which takes a single argument and returns the result of the first function applied to the result of the second function applied to the argument.
+- Example with 'Arrow Function':
+```javascript
+const compose = (f, g) => a => f(g(a));
+const sum = num => num + 1;
+const multiply = num => num * 2;
+const multiplyAndSum = compose(sum, multiply);
+multiplyAndSum(5); // 11
+```
+✅ If you like this article, you can give me a star on. 😎
+Thanks for reading. 🙏

package/Javascript-Notes/javascirpt_array_methods.md

@@ -0,0 +1,339 @@
+### Javascript Array Methods
+
+- #### -> **Map:**
+  The map() method creates a new array with the results of calling a provided function on every element in the calling array.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newArr = arr.map(function (val) {
+  return val * 2;
+});
+```
+
+---
+
+- #### -> **Filter:**
+  The filter() method creates a new array with all elements that pass the test implemented by the provided function.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newArr = arr.filter(function (val) {
+  return val % 2 === 0;
+});
+```
+
+---
+
+- #### -> **Reduce:**
+  The reduce() method applies a function against an accumulator and each element in the array (from left to right) to reduce it to a single value.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newArr = arr.reduce(function (acc, val) {
+  return acc + val;
+}, 0);
+```
+
+---
+
+- #### -> **Every:**
+  The every() method tests whether all elements in the array pass the test implemented by the provided function. It returns a Boolean value.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newArr = arr.every(function (val) {
+  return val % 2 == 0;
+});
+```
+
+---
+
+- #### -> **Some:**
+  The some() method tests whether at least one element in the array passes the test implemented by the provided function. It returns a Boolean value.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newArr = arr.some(function (val) {
+  return val > 5;
+});
+```
+
+---
+
+- #### -> **Sort:**
+  The sort() method sorts the elements of an array in place and returns the sorted array. The default sort order is ascending, built upon converting the elements into strings, then comparing their sequences of UTF-16 code units values.
+
+```javascript
+let arr = [12, 2, 34, 14, 5, 86, 17, 8, 91, 10];
+let newArr = arr.sort(function (a, b) {
+  return a - b;
+});
+```
+
+---
+
+- #### -> **Reverse:**
+  The reverse() method reverses an array in place. The first array element becomes the last, and the last array element becomes the first.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newArr = arr.reverse();
+```
+
+---
+
+- #### -> **Concat:**
+  The concat() method is used to merge two or more arrays. This method does not change the existing arrays, but instead returns a new array.
+
+```javascript
+let arr1 = [1, 2, 3, 4, 5];
+let arr2 = [6, 7, 8, 9, 10];
+let newArr = arr1.concat(arr2);
+```
+
+---
+
+- #### -> **Slice:**
+  The slice() method returns a shallow copy of a portion of an array into a new array object selected from begin to end (end not included) where begin and end represent the index of items in that array. The original array will not be modified.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newArr = arr.slice(2, 5);
+```
+
+---
+
+- #### -> **Splice:**
+  The splice() method changes the contents of an array by removing or replacing existing elements and/or adding new elements in place.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newArr = arr.splice(2, 5);
+```
+
+---
+
+- #### -> **Join:**
+  The join() method joins all elements of an array into a string.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newStr = arr.join('-');
+```
+
+---
+
+- #### -> **Split:**
+  The split() method is used to split a string into an array of substrings, and returns the new array.
+
+```javascript
+let str = '1-2-3-4-5-6-7-8-9-10';
+let newArr = str.split('-');
+```
+
+---
+
+- #### -> **Push:**
+  The push() method adds one or more elements to the end of an array and returns the new length of the array.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newArr = arr.push(11);
+```
+
+---
+
+- #### -> **Pop:**
+  The pop() method removes the last element from an array and returns that element. This method changes the length of the array.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newArr = arr.pop();
+```
+
+---
+
+- #### -> **Shift:**
+  The shift() method removes the first element from an array and returns that removed element. This method changes the length of the array.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newArr = arr.shift();
+```
+
+---
+
+- #### -> **Unshift:**
+  The unshift() method adds one or more elements to the beginning of an array and returns the new length of the array.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newArr = arr.unshift(0);
+```
+
+---
+
+- #### -> **Includes:**
+  The includes() method determines whether an array includes a certain value among its entries, returning true or false as appropriate.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let bool = arr.includes(5);
+```
+
+---
+
+- #### -> **IndexOf:**
+  The indexOf() method returns the first index at which a given element can be found in the array, or -1 if it is not present.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let index = arr.indexOf(5);
+```
+
+---
+
+- #### -> **LastIndexOf:**
+  The lastIndexOf() method returns the last index at which a given element can be found in the array, or -1 if it is not present. The array is searched backwards, starting at fromIndex.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 5, 10];
+let index = arr.lastIndexOf(5);
+```
+
+---
+
+- #### -> **Find:**
+  The find() method returns the value of the first element in the provided array that satisfies the provided testing function. Otherwise undefined is returned.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newArr = arr.find(function (val) {
+  return val === 5;
+});
+```
+
+---
+
+- #### -> **FindIndex:**
+  The findIndex() method returns the index of the first element in the array that satisfies the provided testing function. Otherwise -1 is returned.
+
+```javascript
+let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let newArr = arr.findIndex(function (val) {
+  return val === 5;
+});
+```
+
+---
+
+## -> Other Features
+
+---
+
+### **Destructuring Objects:**
+
+Destructuring is a JavaScript expression that makes it possible to unpack values from arrays, or properties from objects, into distinct variables.
+
+```javascript
+let obj = {
+  name: 'John',
+  age: 30,
+  city: 'New York',
+};
+let { name, age, city } = obj;
+```
+
+---
+
+### **Destructuring Arrays:**
+
+```javascript
+let arr = ['John', 30, 'New York'];
+let [name, age, city] = arr;
+```
+
+---
+
+### **Rest Parameters:**
+
+```javascript
+function sum(...args) {
+  let sum = 0;
+  for (let arg of args) sum += arg;
+  return sum;
+}
+```
+
+---
+
+### **Spread Objects:**
+
+```javascript
+let obj1 = { name: 'John', age: 30 };
+let obj2 = { city: 'New York' };
+let obj3 = { ...obj1, ...obj2 };
+```
+
+---
+
+### **Spread Arrays:**
+
+```javascript
+let arr1 = [1, 2, 3];
+let arr2 = [4, 5, 6];
+let arr3 = [...arr1, ...arr2];
+```
+
+---
+
+### **Default Parameters:**
+
+```javascript
+function sum(a = 0, b = 0) {
+  return a + b;
+}
+```
+
+---
+
+### **Arrow Functions:**
+
+```javascript
+let sum = (a, b) => a + b;
+```
+
+---
+
+### **Template Literals:**
+
+```javascript
+let name = 'John';
+let age = 30;
+let city = 'New York';
+let str = `My name is ${name}, I'm ${age} years old, and I live in ${city}.`;
+```
+
+---
+
+### **Object Literal Shorthand:**
+
+```javascript
+let name = 'John';
+let age = 30;
+let city = 'New York';
+let obj = { name, age, city };
+```
+
+---
+
+### **Destructuring Params:**
+
+```javascript
+function sum({ a, b }) {
+  return a + b;
+}
+```
+
+✅ If you like this article, you can give me a star on. 😎
+Thanks for reading. 🙏