@burakboduroglu/penote 3.0.1

package/Javascript-Notes/readme.md

@@ -0,0 +1,16 @@
+### About Javascript-Notes 🚀
+
+Kişisel JavaScript notları — Markdown formatında düzenlenmiştir.
+
+### Table of Contents 📚
+
+| File Name | Topics |
+| --------- | ------ |
+| [javascirpt_array_methods.md](javascirpt_array_methods.md) | JS Array Methods |
+| [closures_currying_compose.md](closures_currying_compose.md) | Closures, Currying, Compose |
+| [async_js.md](async_js.md) | Fetch API, Promise, async/await |
+| [regex_part_1.md](regex_part_1.md) | Regular expressions (1) |
+
+---
+
+[← README](../README.md)

package/Javascript-Notes/regex_part_1.md

@@ -0,0 +1,258 @@
+# Regular Expressions Cheat Sheet PART - 1
+
+Regular expressions are a powerful tool for matching patterns in text. This blog post will introduce some of the basic syntax for regular expressions and how to use them in JavaScript.
+
+## Creating a Regular Expression
+
+There are two ways to create a regular expression in JavaScript. The first is to use the `RegExp` constructor:
+
+```javascript
+let text = "Programming is my favorite thing to do in the world.";
+
+let regex1 = new RegExp("Programming");
+let regex2 = /Programming/;
+
+// .test()
+console.log(regex1.test(text)); // true
+console.log(regex2.test(text)); // true
+
+// .exec()
+console.log(regex1.exec(text)); // ["Programming", index: 0, input: "Programming is my favorite thing to do in the world."]
+console.log(regex2.exec(text)); // ["Programming", index: 0, input: "Programming is my favorite thing to do in the world."]
+
+// .match()
+console.log(text.match(regex)); // ["Programming", index: 0, input: "Programming is my favorite thing to do in the world."]
+
+// .search()
+console.log(text.search(regex)); // 0
+
+// .replace()
+console.log(text.replace(regex, "Coding")); // Coding is my favorite thing to do in the world.
+
+// .split()
+console.log(text.split(regex)); // ["", " is my favorite thing to do in the world."]
+
+// /\s/
+console.log(text.split(/\s/)); // ["Programming", "is", "my", "favorite", "thing", "to", "do", "in", "the", "world."]
+```
+
+`.test()` returns a boolean value indicating whether or not the regular expression matches the text.
+`.exec()` returns an array containing the matched text, the index of the match, and the input string.
+`.match()` returns an array containing the matched text, the index of the match, and the input string.
+`.search()` returns the index of the first match.
+`.replace()` returns a new string with the matched text replaced by the second argument.
+`.split()` returns an array of strings split at the matched text.
+`/\s/` is a regular expression that matches whitespace characters.
+
+> exec and match are the same, but `match` is a string method and `exec` is a RegExp method.
+
+### Flags
+
+Regular expressions can also have flags. Flags are added to the end of the regular expression and change the behavior of the regular expression. Usage of flags is demonstrated below:
+
+- /pattern/flags
+- new RegExp("pattern", "flags")
+
+Flags
+
+- `g` - global, match all instances of the pattern
+- `i` - ignore case, match regardless of case
+- `m` - multiline, match across multiple lines
+
+```javascript
+let text = "Programming is my favorite thing to do in the world.";
+let regex1 = /o\s/;
+
+console.log(text.match(regex1)); // ["o ", index: 13, input: "Programming is my favorite thing to do in the world."]
+
+let regex2 = /o\s/g;
+
+console.log(text.match(regex2)); // ["o ", "o "]
+
+let regex3 = /G\s/gi;
+
+console.log(text.match(regex3)); // ["g ", "g "]
+```
+
+Explanation of the above code:
+
+- `regex1` matches the first instance of the pattern.
+- `regex2` matches all instances of the pattern.
+- `regex3` matches all instances of the pattern regardless of case.
+
+## Recommended Resources
+
+Regex Pal is a great tool for testing regular expressions: https://www.regexpal.com/
+
+## Wildcards
+
+Wildcards are characters that match any character. The wildcard character is `.`. The following example demonstrates the use of the wildcard character:
+
+```javascript
+let text = "Programming is my favorite thing to do in the world.";
+let regex1 = /w.r/g;
+
+console.log(text.match(regex1)); // ["wor"]
+
+let regex2 = /w\./gi;
+
+console.log(text.match(regex2)); // ["w."]
+```
+
+Explanation of the above code:
+
+- `regex1` matches any character between `w` and `r`.
+- `regex2` matches any character between `w` and `.`.
+
+```javascript
+let text = "He is holding his hat in his hand.";
+let regex1 = /h../g;
+
+console.log(text.match(regex1)); // ["hol", "his", "hat", "his", "han"]
+
+let regex2 = /h../gi;
+
+console.log(text.match(regex2)); // ["He ", "hol", "his", "hat", "his", "han"]
+```
+
+## Control Characters
+
+- `\t` is a tab character
+- `\n` is a newline character
+- `\r` is a carriage return character
+- `\v` is a vertical tab character
+
+## Using Character Sets
+
+```javascript
+let text1 = "Gray, Grey, Grab";
+let regex1 = /Gr[ae]y/g;
+
+console.log(text.match(regex1)); // ["Gray", "Grey"]
+
+let text2 = "Programming is my favorite thing to do in the world.";
+let regex2 = /[aei][ w]/g;
+
+console.log(text2.match(regex2)); // "e " -> from "favorite", "e " -> from "the"
+```
+
+## Specifying Ranges
+
+```javascript
+let text1 = "1 11 a b c abc";
+let regex1 = /[1-6a-z]/g;
+
+console.log(text1.match(regex1)); // ["1", "1", "a", "b", "c", "a", "b", "c"]
+
+let text2 = "13-20";
+let regex2 = /[10-20]/;
+
+console.log(text2.match(regex2)); // ["1","2","0"]
+```
+
+## Excluding a Character Set
+
+```javascript
+let text1 = "1 2 33 123 12 93 85 abcd";
+let regex1 = /[^0-9]/;
+
+console.log(text1.match(regex1)); //  a b c d and all spaces
+```
+
+## Shorthand of Character Set
+
+- `\d` -> [0-9]
+- `\w` -> [a-zA-Z0-9_]
+- `\s` -> [ \t\r\n]
+
+```javascript
+let text1 = "1 2 33 123 12 93 85 abcd";
+let regex1 = /\d/g;
+
+console.log(text1.match(regex1)); // ["1", "2", "3", "3", "1", "2", "9", "3", "8", "5"]
+
+let text2 = "Programming is my favorite thing to do in the world.";
+let regex2 = /\w/g;
+
+console.log(text2.match(regex2)); // ["P", "r", "o", "g", "r", "a", "m", "m", "i", "n", "g", "i", "s", "m", "y", "f", "a", "v", "o", "r", "i", "t", "e", "t", "h", "i", "n", "g", "t", "o", "d", "o", "i", "n", "t", "h", "e", "w", "o", "r", "l", "d"]
+
+let text3 = "Programming is my favorite thing to do in the world.";
+let regex3 = /\s/g;
+
+console.log(text3.match(regex3)); // [" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "]
+```
+
+- `\D` -> [^0-9]
+- `\W` -> [^a-zA-Z0-9_]
+- `\S` -> [^ \t\r\n]
+
+```javascript
+let text1 = "1 2 33 123 12 93 85 abcd";
+let regex1 = /\D/g;
+
+console.log(text1.match(regex1)); // [" ", " ", " ", " ", " ", " ", " ", "a", "b", "c", "d"]
+```
+
+## Repetitions
+
+- `*` -> It used to match 0 or more times
+- `+` -> It used to match 1 or more times
+- `?` -> It used to match 0 or 1 time
+
+### Greedy and Lazy Matching
+
+`Greedy matching` is the default behavior of regular expressions. Greedy matching means that the regular expression will match as many characters as possible. `Lazy matching` means that the regular expression will match as few characters as possible.
+
+```javascript
+let html = "<h1>Heading</h1><p>Paragraph</p>";
+let h1Regex = /<h1>.*<\/h1>/;
+
+console.log(html.match(h1Regex)); // ["<h1>Heading</h1>"]
+```
+
+### Specifying the Repetition Amount
+
+- `{n}` -> It used to match exactly n times
+- `{n,}` -> It used to match at least n times
+- `{n,m}` -> It used to match at least n times and at most m times
+
+```javascript
+let text1 = "Programming is my favorite thing to do in the world.";
+let regex1 = /\w{3,5}/g;
+
+console.log(text1.match(regex1)); // ["Program", "ming", "favor", "ite", "thing", "world"]
+```
+
+### Example
+
+- Validate phone numbers, check to see if it matches these formats:
+  - (nnn)-nnn-nnnn
+  - nnn.nnn.nnnn
+  - nnn-nnn-nnnn
+  - nnnnnnnnnn
+  - (nnn)nnnnnnn
+
+`Solution`:
+
+```javascript
+let phoneNumber = 555 - 444 - 3333;
+let regex = /\(?\d{3}\)?-?\d{3}-?\d{4}/;
+
+console.log(phoneNumber.match(regex));
+```
+
+`Explanation`: /\(?\d{3}\)?-?\d{3}-?\d{4}/
+
+- `\(?` -> It matches 0 or 1 time "("
+- `\d{3}` -> It matches exactly 3 times digit
+- `\)?` -> It matches 0 or 1 time ")"
+- `-?` -> It matches 0 or 1 time "-"
+- `\d{3}` -> It matches exactly 3 times digit
+- `-?` -> It matches 0 or 1 time "-"
+- `\d{4}` -> It matches exactly 4 times digit
+
+If you have any recommendations or feedback, please feel free to reach out to me on comment. However Part-2 will be coming soon. Stay tuned.
+
+## Follow me on GitHub
+
+[GitHub](https://github.com/burakboduroglu)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023–2026 Burak Boduroğlu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MongoDB-Notes/mongodb_basic_1.md

@@ -0,0 +1 @@
+## MongoDB Basics - 1 🚀👩‍🚀

package/MongoDB-Notes/readme.md

@@ -0,0 +1,13 @@
+### About MongoDB-Notes 🚀
+
+Kişisel MongoDB notları — Markdown formatında düzenlenmiştir.
+
+### Table of Contents 📚
+
+| File Name | Topics |
+| --------- | ------ |
+| [mongodb_basic_1.md](mongodb_basic_1.md) | MongoDB temelleri |
+
+---
+
+[← README](../README.md)

package/Python-Notes/advanced_python_1.md

@@ -0,0 +1,142 @@
+## Advanced Python - 1 🚀👩‍🚀
+
+### - Enumerate
+
+- Enumerate is a built-in function of Python. It allows us to loop over something and have an automatic counter.
+
+```python
+# Example 1
+for i, char in enumerate('Hello'):
+    print(i, char)
+
+# Output -> 0 H 1 e 2 l 3 l 4 o
+
+# Example 2
+for i, char in enumerate(list(range(100))):
+    if char == 50:
+        print(f'The index of 50 is: {i}')
+```
+
+### - Zip
+
+- Zip is a built-in function of Python. It allows us to loop over two lists at the same time.
+
+```python
+# Example 1
+list1 = [1, 2, 3]
+list2 = [10, 20, 30]
+
+for item in zip(list1, list2):
+    print(item)
+# Output -> (1, 10) (2, 20) (3, 30)
+
+# Example 2
+list1 = [1, 2, 3]
+list2 = [10, 20, 30, 40, 50]
+list3 = ['a', 'b', 'c', 'd', 'e']
+
+for item in zip(list1, list2, list3):
+    print(item)
+# Output -> (1, 10, 'a') (2, 20, 'b') (3, 30, 'c')
+
+# Example 3
+list1 = [1, 2, 3]
+list2 = [10, 20, 30, 40, 50]
+list3 = ['a', 'b', 'c', 'd', 'e']
+
+for a, b, c in zip(list1, list2, list3):
+    print(a, b, c)
+# Output -> 1 10 a 2 20 b 3 30 c
+
+# Example 4
+list1 = [1, 2, 3]
+list2 = [10, 20, 30, 40, 50]
+list3 = ['a', 'b', 'c', 'd', 'e']
+
+print(list(zip(list1, list2, list3)))
+# Output -> [(1, 10, 'a'), (2, 20, 'b'), (3, 30, 'c')]
+```
+
+### - Unzip
+
+- Unzip is a built-in function of Python. It allows us to unzip a list.
+
+```python
+# Example 1
+list1 = [1, 2, 3]
+list2 = [10, 20, 30]
+
+unzipped = list(zip(list1, list2))
+print(unzipped)
+# Output -> [(1, 10), (2, 20), (3, 30)]
+```
+
+### - List Comprehension
+
+- List comprehension is a way to create a list using for loop in a single line.
+
+```python
+# Example 1
+my_list = [char for char in 'hello']
+print(my_list)
+# Output -> ['h', 'e', 'l', 'l', 'o']
+
+# Example 2
+my_list = [num for num in range(0, 8)]
+print(my_list)
+# Output -> [0, 1, 2, 3, 4, 5, 6, 7]
+
+# Example 3
+my_list = [num**2 for num in range(0, 5)]
+print(my_list)
+# Output -> [0, 1, 4, 9, 16]
+
+# Example 4
+my_list = [num**2 for num in range(0, 5) if num % 2 == 0]
+print(my_list)
+# Output -> [0, 4, 16]
+
+# Example 5
+my_list = [x*y for x in [2, 4, 6] for y in [1, 10, 1000]]
+print(my_list)
+# Output -> [2, 20, 2000, 4, 40, 4000, 6, 60, 6000]
+
+# Example 6
+my_list = [x*y for x in [2, 4, 6] for y in [1, 10, 1000] if x*y > 50]
+print(my_list)
+# Output -> [60, 6000]
+
+# Example 7
+my_list = [x if x % 2 == 0 else 'ODD' for x in range(0, 10)]
+print(my_list)
+# Output -> [0, 'ODD', 2, 'ODD', 4, 'ODD', 6, 'ODD', 8, 'ODD']
+```
+
+### - Dictionary Comprehension
+
+- Dictionary comprehension is a way to create a dictionary using for loop in a single line.
+
+```python
+# Example 1
+simple_dict = {
+    'a': 1,
+    'b': 2
+}
+
+my_dict = {key: value**2 for key, value in simple_dict.items()}
+print(my_dict)
+# Output -> {'a': 1, 'b': 4}
+```
+
+### - Set Comprehension
+
+- Set comprehension is a way to create a set using for loop in a single line.
+
+```python
+# Example 1
+simple_set = {1, 2, 3}
+
+my_set = {num for num in simple_set}
+print(my_set)
+# Output -> {1, 2, 3}
+```

package/Python-Notes/advanced_python_2.md

@@ -0,0 +1,155 @@
+## Advanced Python - 2 🚀👩‍🚀
+
+### - kwargs
+
+- kwargs allows us to pass a variable number of keyword arguments to a function. We use the \*\* operator to unpack the dictionary into keyword arguments.
+- kwargs is a dictionary.
+
+```python
+# Example 1
+def func(**kwargs):
+    print(kwargs)
+
+func(name='name_1', age=30)
+# Output -> {'name': 'name_1', 'age': 30}
+```
+
+### - args
+
+- args allows us to pass a variable number of arguments to a function. We use the \* operator to unpack the list into positional arguments.
+
+- args is a tuple.
+
+```python
+# Example 1
+def func(*args):
+    print(args)
+
+func(1, 2, 3, 4, 5)
+# Output -> (1, 2, 3, 4, 5)
+
+# Example 2
+def super_func(*args, **kwargs):
+    total = 0
+    for items in kwargs.values():
+        total += items
+    return sum(args) + total
+print(super_func(1, 2, 3, 4, 5, num1=5, num2=10))
+# Output -> 40
+```
+
+### - global
+
+- global allows us to modify a global variable inside a function.
+
+### - lambda
+
+- lambda is a way to create an anonymous function (a function without a name).
+- lambda is a one-line function.
+
+```python
+# Example 1
+square = lambda num: num * num
+print(square(2))
+# Output -> 4
+
+# Example 2
+add = lambda a, b: a + b
+print(add(2, 3))
+# Output -> 5
+```
+
+### - filter
+
+- filter is a built-in function of Python. It allows us to filter out items in an iterable (list, tuple, etc.) that don't match a certain condition.
+
+```python
+# Example 1
+def check_even(num):
+    return num % 2 == 0
+
+my_nums = [1, 2, 3, 4, 5, 6]
+print(list(filter(check_even, my_nums)))
+# Output -> [2, 4, 6]
+
+# Example 2
+my_nums = [1, 2, 3, 4, 5, 6]
+print(list(filter(lambda num: num % 2 == 0, my_nums)))
+# Output -> [2, 4, 6]
+```
+
+### - map
+
+- map is a built-in function of Python. It allows us to execute a function for each item in an iterable (list, tuple, etc.).
+
+```python
+# Example 1
+def square(num): return num * num
+
+my_nums = [1, 2, 3, 4, 5]
+print(list(map(square, my_nums)))
+# Output -> [1, 4, 9, 16, 25]
+
+# Example 2
+my_nums = [1, 2, 3, 4, 5]
+print(list(map(lambda num: num * num, my_nums)))
+# Output -> [1, 4, 9, 16, 25]
+
+# Example 3
+def splicer(mystring):
+    if len(mystring) % 2 == 0:
+        return 'EVEN'
+    else:
+        return mystring[0]
+
+names = ['Andy', 'Eve', 'Sally']
+print(list(map(splicer, names)))
+# Output -> ['EVEN', 'E', 'S']
+
+
+# Example 4
+def check_even(num):
+    return num % 2 == 0
+
+my_nums = [1, 2, 3, 4, 5, 6]
+print(list(map(lambda num: num * 2, filter(check_even, my_nums))))
+# Output -> [4, 8, 12]
+```
+
+### - keyword arguments
+
+- keyword arguments are arguments preceded by an identifier when we pass them to a function. The order of the arguments can be changed.
+
+```python
+# Example 1
+def func(a, b, c):
+    print(a, b, c)
+
+func(1, 2, 3)
+# Output -> 1 2 3
+
+func(c=3, b=2, a=1)
+# Output -> 1 2 3
+```
+
+### - all any
+
+- all() returns True if all elements in an iterable are true (or if the iterable is empty).
+
+- any() returns True if any element of an iterable is true. If the iterable is empty, it returns False.
+
+```python
+# Example 1
+my_list = [True, True, True]
+print(all(my_list))
+# Output -> True
+
+my_list = [True, False, True]
+print(all(my_list))
+# Output -> False
+
+# Example 2
+my_list = [1, 2, 3, 4, 5, 6]
+print(all([num % 2 == 0 for num in my_list]))
+# Output -> False
+```