Merge pull request #16 from uddinmehrab/gitdocs/whatisgitignore

Add doc on .gitignore

Author: TommyOh0428

docs/git_docs/what_is_gitignore.md

@@ -0,0 +1,164 @@
+---
+sidebar_position: 7
+---
+
+# .gitignore Best Practices
+
+The `.gitignore` file is a powerful tool in Git for specifying which files or directories should be ignored in version control. By keeping unnecessary or sensitive files out of your Git repository, you ensure a cleaner, more efficient workflow. This guide covers some best practices for creating and managing `.gitignore` files effectively.
+
+## 1. Understand the Purpose of `.gitignore`
+
+The `.gitignore` file helps prevent certain files or directories from being tracked by Git. Typical files to ignore include:
+
+Temporary or Build Files: These include compiled code, temporary data, and build artifacts, such as `.o`, `.class`, `dist/`, or `build/`.
+
+Environment-Specific Files: Files that differ based on environment, such as IDE settings (`*.iml`, `.vscode/`) or operating system artifacts (`.DS_Store` on macOS).
+
+Sensitive Information: Files containing sensitive data, like credentials (`.env`, `config.json`), should be ignored to avoid leaking critical information.
+
+## 2. Use Global `.gitignore` for System-Wide Exclusions
+
+You can define a global `.gitignore` file for files that you want to ignore across all repositories on your machine. This is useful for ignoring OS-generated files like `.DS_Store` or editor-specific files.
+
+To set up a global `.gitignore`, run the following commands:
+
+```bash
+git config --global core.excludesfile ~/.gitignore_global
+```
+
+Add common system or editor-specific files to `~/.gitignore_global` to prevent them from cluttering your repositories.
+
+## 3. Organize Your `.gitignore` by Category
+
+Organize the contents of your `.gitignore` file for easy readability and maintenance. For example, group entries by their type:
+
+```gitignore
+
+#OS-generated files
+
+.DS_Store
+Thumbs.db
+
+#Log files
+
+*.log
+
+#Dependency directories
+
+node_modules/
+
+#Build directories
+
+/build/
+/dist/
+```
+
+Keeping related items together helps ensure that your `.gitignore` file remains readable, especially in larger projects.
+
+## 4. Leverage `.gitignore` Templates
+
+For many common languages and frameworks, you can find `.gitignore` templates that cover the majority of what needs to be ignored. GitHub provides a useful repository with `.gitignore` templates for different languages:
+
+GitHub .gitignore Templates
+
+Use these templates as a starting point and customize them based on the needs of your specific project.
+
+## 5. Avoid Ignoring Critical Files
+
+Be careful not to ignore files that are essential for running or building the project, such as:
+
+Configuration Files: Certain configuration files (`webpack.config.js`, `package.json`, etc.) may be necessary for the project setup.
+
+Documentation: Files like `README.md` or `LICENSE` should always be tracked.
+
+Before adding something to `.gitignore`, consider whether it might be useful for others working on the project.
+
+## 6. Environment Variables and `.env` Files
+
+Environment variables often contain sensitive information, such as API keys, database credentials, or other private configurations. It's a best practice to store these variables in a `.env` file and include that file in your `.gitignore` to ensure that sensitive information is not committed to your repository.
+
+For example, you can add the following entry to your `.gitignore` file:
+
+```gitignore
+
+#Environment variables
+
+.env
+```
+
+To share the structure of the environment variables without exposing sensitive values, create a `.env.example` file that contains placeholder keys. This way, new developers can easily understand what environment variables are required for the project:
+
+```
+
+#Example .env file
+
+API_KEY=your_api_key_here
+DB_HOST=localhost
+DB_USER=your_db_user
+DB_PASS=your_db_password
+```
+
+By using `.env` files properly, you help protect sensitive data while providing clear instructions for setting up the development environment.
+
+## 7. Ignore by Patterns
+
+You can use wildcard patterns to efficiently ignore multiple files:
+
+`*.log` will ignore all `.log` files.
+
+`**/temp` will ignore any directory named `temp` regardless of where it appears in the directory tree.
+
+`!important.log` will explicitly track `important.log` even if other `.log` files are ignored.
+
+## 8. Check for Existing `.gitignore` Before Adding Files
+
+When adding new dependencies or files, always check the existing `.gitignore` to avoid unnecessary redundancy or missed files. Adding duplicates can make the file harder to maintain.
+
+## 9. Use `.git/info/exclude` for Local Ignores
+
+If there are files you want to ignore locally (for your copy only), you can use `.git/info/exclude`. This file works similarly to `.gitignore` but doesn’t affect others who clone the repository. It’s perfect for local, temporary settings or configurations.
+
+## 10. Audit Your `.gitignore` Regularly
+
+Over time, projects change, and files that were once useful might become obsolete. Periodically review and clean up the `.gitignore` file to remove entries that are no longer needed. This keeps it relevant and tidy.
+
+## Example `.gitignore` for a Node.js Project
+
+Here’s an example `.gitignore` file for a typical Node.js project:
+
+```gitignore
+
+#Node modules
+
+node_modules/
+
+#Logs
+
+logs
+.log
+npm-debug.log
+
+#Build artifacts
+
+dist/
+
+#Environment variables
+
+.env
+
+#OS-specific files
+
+.DS_Store
+Thumbs.db
+```
+
+This example covers commonly ignored files, ensuring that your repository remains clean while maintaining only essential code and configuration.
+
+
+
+## Additional Resources
+
+[Git Documentation on `.gitignore`](https://git-scm.com/docs/gitignore)
+
+[GitHub `.gitignore` Templates Repository](https://github.com/github/gitignore)
+